Graphics.UI.FLTK.LowLevel.Hierarchy

Region

type Region = CRegion Base

GlContext

type GlContext = CGlContext Base

Widget

type Widget = CWidget Base

type WidgetFuncs = Destroy (Handle (GetParent (SetParent (GetType_ (SetType (DrawLabel (DoCallback (GetX (GetY (GetW (GetH (GetRectangle (SetAlign (GetAlign (GetBox (SetBox (GetColor (SetColor (SetColorWithBgSel (GetSelectionColor (SetSelectionColor (GetLabel (CopyLabel (SetLabel (GetLabeltype (SetLabeltype (GetLabelcolor (SetLabelcolor (GetLabelfont (SetLabelfont (GetLabelsize (SetLabelsize (GetImage (SetImage (GetDeimage (SetDeimage (GetTooltip (CopyTooltip (SetTooltip (GetWhen (SetWhen (GetVisible (GetVisibleR (ShowWidgetSuper (ShowWidget (HideSuper (Hide (SetVisible (ClearVisible (Active (ActiveR (Activate (Deactivate (GetOutput (SetOutput (Takesevents (Changed (SetChanged (ClearChanged (SetActive (ClearActive (TakeFocus (SetVisibleFocus (ClearVisibleFocus (ModifyVisibleFocus (GetVisibleFocus (Contains (Inside (Redraw (RedrawLabel (GetDamage (ClearDamageWithBitmask (ClearDamage (GetDamageWithText (GetDamageInsideWidget (MeasureLabel (GetWindow (GetTopWindow (GetTopWindowOffset (ResizeSuper (Resize (SetCallback (HasCallback (DrawBox (DrawBoxWithBoxtype (DrawBackdrop (DrawFocus ())))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))))

data Destroy a

Instances

Functions Widget WidgetFuncs

destroy :: (?loc :: CallStack, FindOp a (Destroy ()) (Match r), Op (Destroy ()) r a impl) => Ref a -> impl

data Handle a

Instances

Functions Widget WidgetFuncs

handle :: (?loc :: CallStack, FindOp a (Handle ()) (Match r), Op (Handle ()) r a impl) => Ref a -> impl

data GetParent a

Instances

Functions Widget WidgetFuncs

getParent :: (?loc :: CallStack, FindOp a (GetParent ()) (Match r), Op (GetParent ()) r a impl) => Ref a -> impl

data SetParent a

Instances

Functions Widget WidgetFuncs

setParent :: (?loc :: CallStack, FindOp a (SetParent ()) (Match r), Op (SetParent ()) r a impl) => Ref a -> impl

data GetType_ a

Instances

Functions Widget WidgetFuncs

getType_ :: (?loc :: CallStack, FindOp a (GetType_ ()) (Match r), Op (GetType_ ()) r a impl) => Ref a -> impl

data SetType a

Instances

Functions Widget WidgetFuncs

setType :: (?loc :: CallStack, FindOp a (SetType ()) (Match r), Op (SetType ()) r a impl) => Ref a -> impl

data DrawLabel a

Instances

Functions Widget WidgetFuncs

drawLabel :: (?loc :: CallStack, FindOp a (DrawLabel ()) (Match r), Op (DrawLabel ()) r a impl) => Ref a -> impl

data GetX a

Instances

Functions Widget WidgetFuncs

getX :: (?loc :: CallStack, FindOp a (GetX ()) (Match r), Op (GetX ()) r a impl) => Ref a -> impl

data GetY a

Instances

Functions Widget WidgetFuncs

getY :: (?loc :: CallStack, FindOp a (GetY ()) (Match r), Op (GetY ()) r a impl) => Ref a -> impl

data GetW a

Instances

Functions Widget WidgetFuncs

getW :: (?loc :: CallStack, FindOp a (GetW ()) (Match r), Op (GetW ()) r a impl) => Ref a -> impl

data GetH a

Instances

Functions Widget WidgetFuncs

getH :: (?loc :: CallStack, FindOp a (GetH ()) (Match r), Op (GetH ()) r a impl) => Ref a -> impl

data GetRectangle a

Instances

Functions Widget WidgetFuncs

getRectangle :: (?loc :: CallStack, FindOp a (GetRectangle ()) (Match r), Op (GetRectangle ()) r a impl) => Ref a -> impl

data SetAlign a

Instances

Functions Widget WidgetFuncs

setAlign :: (?loc :: CallStack, FindOp a (SetAlign ()) (Match r), Op (SetAlign ()) r a impl) => Ref a -> impl

data GetAlign a

Instances

Functions Widget WidgetFuncs

getAlign :: (?loc :: CallStack, FindOp a (GetAlign ()) (Match r), Op (GetAlign ()) r a impl) => Ref a -> impl

data GetBox a

Instances

Functions Widget WidgetFuncs

getBox :: (?loc :: CallStack, FindOp a (GetBox ()) (Match r), Op (GetBox ()) r a impl) => Ref a -> impl

data SetBox a

Instances

Functions Widget WidgetFuncs

setBox :: (?loc :: CallStack, FindOp a (SetBox ()) (Match r), Op (SetBox ()) r a impl) => Ref a -> impl

data GetColor a

Instances

Functions Widget WidgetFuncs

getColor :: (?loc :: CallStack, FindOp a (GetColor ()) (Match r), Op (GetColor ()) r a impl) => Ref a -> impl

data SetColor a

Instances

Functions Widget WidgetFuncs

setColor :: (?loc :: CallStack, FindOp a (SetColor ()) (Match r), Op (SetColor ()) r a impl) => Ref a -> impl

data SetColorWithBgSel a

Instances

Functions Widget WidgetFuncs

setColorWithBgSel :: (?loc :: CallStack, FindOp a (SetColorWithBgSel ()) (Match r), Op (SetColorWithBgSel ()) r a impl) => Ref a -> impl

data GetSelectionColor a

Instances

Functions Widget WidgetFuncs

getSelectionColor :: (?loc :: CallStack, FindOp a (GetSelectionColor ()) (Match r), Op (GetSelectionColor ()) r a impl) => Ref a -> impl

data SetSelectionColor a

Instances

Functions Widget WidgetFuncs

setSelectionColor :: (?loc :: CallStack, FindOp a (SetSelectionColor ()) (Match r), Op (SetSelectionColor ()) r a impl) => Ref a -> impl

data GetLabel a

Instances

Functions Widget WidgetFuncs

getLabel :: (?loc :: CallStack, FindOp a (GetLabel ()) (Match r), Op (GetLabel ()) r a impl) => Ref a -> impl

data CopyLabel a

Instances

Functions Widget WidgetFuncs

copyLabel :: (?loc :: CallStack, FindOp a (CopyLabel ()) (Match r), Op (CopyLabel ()) r a impl) => Ref a -> impl

data SetLabel a

Instances

Functions Widget WidgetFuncs

setLabel :: (?loc :: CallStack, FindOp a (SetLabel ()) (Match r), Op (SetLabel ()) r a impl) => Ref a -> impl

data GetLabeltype a

Instances

Functions Widget WidgetFuncs

getLabeltype :: (?loc :: CallStack, FindOp a (GetLabeltype ()) (Match r), Op (GetLabeltype ()) r a impl) => Ref a -> impl

data SetLabeltype a

Instances

Functions Widget WidgetFuncs

setLabeltype :: (?loc :: CallStack, FindOp a (SetLabeltype ()) (Match r), Op (SetLabeltype ()) r a impl) => Ref a -> impl

data GetLabelcolor a

Instances

Functions Widget WidgetFuncs

getLabelcolor :: (?loc :: CallStack, FindOp a (GetLabelcolor ()) (Match r), Op (GetLabelcolor ()) r a impl) => Ref a -> impl

data SetLabelcolor a

Instances

Functions Widget WidgetFuncs

setLabelcolor :: (?loc :: CallStack, FindOp a (SetLabelcolor ()) (Match r), Op (SetLabelcolor ()) r a impl) => Ref a -> impl

data GetLabelfont a

Instances

Functions Widget WidgetFuncs

getLabelfont :: (?loc :: CallStack, FindOp a (GetLabelfont ()) (Match r), Op (GetLabelfont ()) r a impl) => Ref a -> impl

data SetLabelfont a

Instances

Functions Widget WidgetFuncs

setLabelfont :: (?loc :: CallStack, FindOp a (SetLabelfont ()) (Match r), Op (SetLabelfont ()) r a impl) => Ref a -> impl

data GetLabelsize a

Instances

Functions Widget WidgetFuncs

getLabelsize :: (?loc :: CallStack, FindOp a (GetLabelsize ()) (Match r), Op (GetLabelsize ()) r a impl) => Ref a -> impl

data SetLabelsize a

Instances

Functions Widget WidgetFuncs

setLabelsize :: (?loc :: CallStack, FindOp a (SetLabelsize ()) (Match r), Op (SetLabelsize ()) r a impl) => Ref a -> impl

data GetImage a

Instances

Functions Widget WidgetFuncs

getImage :: (?loc :: CallStack, FindOp a (GetImage ()) (Match r), Op (GetImage ()) r a impl) => Ref a -> impl

data SetImage a

Instances

Functions Widget WidgetFuncs

setImage :: (?loc :: CallStack, FindOp a (SetImage ()) (Match r), Op (SetImage ()) r a impl) => Ref a -> impl

data GetDeimage a

Instances

Functions Widget WidgetFuncs

getDeimage :: (?loc :: CallStack, FindOp a (GetDeimage ()) (Match r), Op (GetDeimage ()) r a impl) => Ref a -> impl

data SetDeimage a

Instances

Functions Widget WidgetFuncs

setDeimage :: (?loc :: CallStack, FindOp a (SetDeimage ()) (Match r), Op (SetDeimage ()) r a impl) => Ref a -> impl

data GetTooltip a

Instances

Functions Widget WidgetFuncs

getTooltip :: (?loc :: CallStack, FindOp a (GetTooltip ()) (Match r), Op (GetTooltip ()) r a impl) => Ref a -> impl

data CopyTooltip a

Instances

Functions Widget WidgetFuncs

copyTooltip :: (?loc :: CallStack, FindOp a (CopyTooltip ()) (Match r), Op (CopyTooltip ()) r a impl) => Ref a -> impl

data SetTooltip a

Instances

Functions Widget WidgetFuncs

setTooltip :: (?loc :: CallStack, FindOp a (SetTooltip ()) (Match r), Op (SetTooltip ()) r a impl) => Ref a -> impl

data GetWhen a

Instances

Functions Widget WidgetFuncs

getWhen :: (?loc :: CallStack, FindOp a (GetWhen ()) (Match r), Op (GetWhen ()) r a impl) => Ref a -> impl

data SetWhen a

Instances

Functions Widget WidgetFuncs

setWhen :: (?loc :: CallStack, FindOp a (SetWhen ()) (Match r), Op (SetWhen ()) r a impl) => Ref a -> impl

data GetVisible a

Instances

Functions Widget WidgetFuncs

getVisible :: (?loc :: CallStack, FindOp a (GetVisible ()) (Match r), Op (GetVisible ()) r a impl) => Ref a -> impl

data GetVisibleR a

Instances

Functions Widget WidgetFuncs

getVisibleR :: (?loc :: CallStack, FindOp a (GetVisibleR ()) (Match r), Op (GetVisibleR ()) r a impl) => Ref a -> impl

data ShowWidgetSuper a

Instances

Functions Widget WidgetFuncs

showWidgetSuper :: (?loc :: CallStack, FindOp a (ShowWidgetSuper ()) (Match r), Op (ShowWidgetSuper ()) r a impl) => Ref a -> impl

data ShowWidget a

Instances

Functions Widget WidgetFuncs

showWidget :: (?loc :: CallStack, FindOp a (ShowWidget ()) (Match r), Op (ShowWidget ()) r a impl) => Ref a -> impl

data HideSuper a

Instances

Functions Widget WidgetFuncs

hideSuper :: (?loc :: CallStack, FindOp a (HideSuper ()) (Match r), Op (HideSuper ()) r a impl) => Ref a -> impl

data Hide a

Instances

Functions Widget WidgetFuncs

hide :: (?loc :: CallStack, FindOp a (Hide ()) (Match r), Op (Hide ()) r a impl) => Ref a -> impl

data SetVisible a

Instances

Functions Widget WidgetFuncs

setVisible :: (?loc :: CallStack, FindOp a (SetVisible ()) (Match r), Op (SetVisible ()) r a impl) => Ref a -> impl

data ClearVisible a

Instances

Functions Widget WidgetFuncs

clearVisible :: (?loc :: CallStack, FindOp a (ClearVisible ()) (Match r), Op (ClearVisible ()) r a impl) => Ref a -> impl

data Active a

Instances

Functions Widget WidgetFuncs

active :: (?loc :: CallStack, FindOp a (Active ()) (Match r), Op (Active ()) r a impl) => Ref a -> impl

data ActiveR a

Instances

Functions Widget WidgetFuncs

activeR :: (?loc :: CallStack, FindOp a (ActiveR ()) (Match r), Op (ActiveR ()) r a impl) => Ref a -> impl

data Activate a

Instances

Functions Widget WidgetFuncs

activate :: (?loc :: CallStack, FindOp a (Activate ()) (Match r), Op (Activate ()) r a impl) => Ref a -> impl

data Deactivate a

Instances

Functions Widget WidgetFuncs

deactivate :: (?loc :: CallStack, FindOp a (Deactivate ()) (Match r), Op (Deactivate ()) r a impl) => Ref a -> impl

data GetOutput a

Instances

Functions Widget WidgetFuncs

getOutput :: (?loc :: CallStack, FindOp a (GetOutput ()) (Match r), Op (GetOutput ()) r a impl) => Ref a -> impl

data SetOutput a

Instances

Functions Widget WidgetFuncs

setOutput :: (?loc :: CallStack, FindOp a (SetOutput ()) (Match r), Op (SetOutput ()) r a impl) => Ref a -> impl

data ClearOutput a

clearOutput :: (?loc :: CallStack, FindOp a (ClearOutput ()) (Match r), Op (ClearOutput ()) r a impl) => Ref a -> impl

data Takesevents a

Instances

Functions Widget WidgetFuncs

takesevents :: (?loc :: CallStack, FindOp a (Takesevents ()) (Match r), Op (Takesevents ()) r a impl) => Ref a -> impl

data SetChanged a

Instances

Functions Widget WidgetFuncs

setChanged :: (?loc :: CallStack, FindOp a (SetChanged ()) (Match r), Op (SetChanged ()) r a impl) => Ref a -> impl

data ClearChanged a

Instances

Functions Widget WidgetFuncs

clearChanged :: (?loc :: CallStack, FindOp a (ClearChanged ()) (Match r), Op (ClearChanged ()) r a impl) => Ref a -> impl

data Changed a

Instances

Functions Widget WidgetFuncs

changed :: (?loc :: CallStack, FindOp a (Changed ()) (Match r), Op (Changed ()) r a impl) => Ref a -> impl

data SetActive a

Instances

Functions Widget WidgetFuncs

setActive :: (?loc :: CallStack, FindOp a (SetActive ()) (Match r), Op (SetActive ()) r a impl) => Ref a -> impl

data ClearActive a

Instances

Functions Widget WidgetFuncs

clearActive :: (?loc :: CallStack, FindOp a (ClearActive ()) (Match r), Op (ClearActive ()) r a impl) => Ref a -> impl

data TakeFocus a

Instances

Functions Widget WidgetFuncs

takeFocus :: (?loc :: CallStack, FindOp a (TakeFocus ()) (Match r), Op (TakeFocus ()) r a impl) => Ref a -> impl

data SetVisibleFocus a

Instances

Functions Widget WidgetFuncs

setVisibleFocus :: (?loc :: CallStack, FindOp a (SetVisibleFocus ()) (Match r), Op (SetVisibleFocus ()) r a impl) => Ref a -> impl

data ClearVisibleFocus a

Instances

Functions Widget WidgetFuncs

clearVisibleFocus :: (?loc :: CallStack, FindOp a (ClearVisibleFocus ()) (Match r), Op (ClearVisibleFocus ()) r a impl) => Ref a -> impl

data ModifyVisibleFocus a

Instances

Functions Widget WidgetFuncs

modifyVisibleFocus :: (?loc :: CallStack, FindOp a (ModifyVisibleFocus ()) (Match r), Op (ModifyVisibleFocus ()) r a impl) => Ref a -> impl

data GetVisibleFocus a

Instances

Functions Widget WidgetFuncs

getVisibleFocus :: (?loc :: CallStack, FindOp a (GetVisibleFocus ()) (Match r), Op (GetVisibleFocus ()) r a impl) => Ref a -> impl

data Contains a

Instances

Functions Widget WidgetFuncs

contains :: (?loc :: CallStack, FindOp a (Contains ()) (Match r), Op (Contains ()) r a impl) => Ref a -> impl

data Inside a

Instances

Functions Widget WidgetFuncs

inside :: (?loc :: CallStack, FindOp a (Inside ()) (Match r), Op (Inside ()) r a impl) => Ref a -> impl

data Redraw a

Instances

Functions Widget WidgetFuncs

redraw :: (?loc :: CallStack, FindOp a (Redraw ()) (Match r), Op (Redraw ()) r a impl) => Ref a -> impl

data RedrawLabel a

Instances

Functions Widget WidgetFuncs

redrawLabel :: (?loc :: CallStack, FindOp a (RedrawLabel ()) (Match r), Op (RedrawLabel ()) r a impl) => Ref a -> impl

data GetDamage a

Instances

Functions Widget WidgetFuncs

getDamage :: (?loc :: CallStack, FindOp a (GetDamage ()) (Match r), Op (GetDamage ()) r a impl) => Ref a -> impl

data ClearDamageWithBitmask a

Instances

Functions Widget WidgetFuncs

clearDamageWithBitmask :: (?loc :: CallStack, FindOp a (ClearDamageWithBitmask ()) (Match r), Op (ClearDamageWithBitmask ()) r a impl) => Ref a -> impl

data ClearDamage a

Instances

Functions Widget WidgetFuncs

clearDamage :: (?loc :: CallStack, FindOp a (ClearDamage ()) (Match r), Op (ClearDamage ()) r a impl) => Ref a -> impl

data GetDamageWithText a

Instances

Functions Widget WidgetFuncs

getDamageWithText :: (?loc :: CallStack, FindOp a (GetDamageWithText ()) (Match r), Op (GetDamageWithText ()) r a impl) => Ref a -> impl

data GetDamageInsideWidget a

Instances

Functions Widget WidgetFuncs

getDamageInsideWidget :: (?loc :: CallStack, FindOp a (GetDamageInsideWidget ()) (Match r), Op (GetDamageInsideWidget ()) r a impl) => Ref a -> impl

data MeasureLabel a

Instances

Functions Widget WidgetFuncs

measureLabel :: (?loc :: CallStack, FindOp a (MeasureLabel ()) (Match r), Op (MeasureLabel ()) r a impl) => Ref a -> impl

data GetWindow a

Instances

Functions Widget WidgetFuncs

getWindow :: (?loc :: CallStack, FindOp a (GetWindow ()) (Match r), Op (GetWindow ()) r a impl) => Ref a -> impl

data GetTopWindow a

Instances

Functions Widget WidgetFuncs

getTopWindow :: (?loc :: CallStack, FindOp a (GetTopWindow ()) (Match r), Op (GetTopWindow ()) r a impl) => Ref a -> impl

data GetTopWindowOffset a

Instances

Functions Widget WidgetFuncs

getTopWindowOffset :: (?loc :: CallStack, FindOp a (GetTopWindowOffset ()) (Match r), Op (GetTopWindowOffset ()) r a impl) => Ref a -> impl

data ResizeSuper a

Instances

Functions Widget WidgetFuncs

resizeSuper :: (?loc :: CallStack, FindOp a (ResizeSuper ()) (Match r), Op (ResizeSuper ()) r a impl) => Ref a -> impl

data Resize a

Instances

Functions Widget WidgetFuncs

resize :: (?loc :: CallStack, FindOp a (Resize ()) (Match r), Op (Resize ()) r a impl) => Ref a -> impl

data SetCallback a

Instances

Functions Widget WidgetFuncs

setCallback :: (?loc :: CallStack, FindOp a (SetCallback ()) (Match r), Op (SetCallback ()) r a impl) => Ref a -> impl

data HasCallback a

Instances

Functions Widget WidgetFuncs

hasCallback :: (?loc :: CallStack, FindOp a (HasCallback ()) (Match r), Op (HasCallback ()) r a impl) => Ref a -> impl

data DrawBox a

Instances

Functions Widget WidgetFuncs

drawBox :: (?loc :: CallStack, FindOp a (DrawBox ()) (Match r), Op (DrawBox ()) r a impl) => Ref a -> impl

data DrawBoxWithBoxtype a

Instances

Functions Widget WidgetFuncs

drawBoxWithBoxtype :: (?loc :: CallStack, FindOp a (DrawBoxWithBoxtype ()) (Match r), Op (DrawBoxWithBoxtype ()) r a impl) => Ref a -> impl

data DrawBackdrop a

Instances

Functions Widget WidgetFuncs

drawBackdrop :: (?loc :: CallStack, FindOp a (DrawBackdrop ()) (Match r), Op (DrawBackdrop ()) r a impl) => Ref a -> impl

data DrawFocus a

Instances

Functions Widget WidgetFuncs

drawFocus :: (?loc :: CallStack, FindOp a (DrawFocus ()) (Match r), Op (DrawFocus ()) r a impl) => Ref a -> impl

Group

type Group = CGroup Widget

data DrawChild a

drawChild :: (?loc :: CallStack, FindOp a (DrawChild ()) (Match r), Op (DrawChild ()) r a impl) => Ref a -> impl

data DrawChildren a

drawChildren :: (?loc :: CallStack, FindOp a (DrawChildren ()) (Match r), Op (DrawChildren ()) r a impl) => Ref a -> impl

data DrawOutsideLabel a

drawOutsideLabel :: (?loc :: CallStack, FindOp a (DrawOutsideLabel ()) (Match r), Op (DrawOutsideLabel ()) r a impl) => Ref a -> impl

data UpdateChild a

updateChild :: (?loc :: CallStack, FindOp a (UpdateChild ()) (Match r), Op (UpdateChild ()) r a impl) => Ref a -> impl

data Begin a

begin :: (?loc :: CallStack, FindOp a (Begin ()) (Match r), Op (Begin ()) r a impl) => Ref a -> impl

data End a

end :: (?loc :: CallStack, FindOp a (End ()) (Match r), Op (End ()) r a impl) => Ref a -> impl

data Find a

find :: (?loc :: CallStack, FindOp a (Find ()) (Match r), Op (Find ()) r a impl) => Ref a -> impl

data Add a

add :: (?loc :: CallStack, FindOp a (Add ()) (Match r), Op (Add ()) r a impl) => Ref a -> impl

data Insert a

insert :: (?loc :: CallStack, FindOp a (Insert ()) (Match r), Op (Insert ()) r a impl) => Ref a -> impl

data RemoveIndex a

removeIndex :: (?loc :: CallStack, FindOp a (RemoveIndex ()) (Match r), Op (RemoveIndex ()) r a impl) => Ref a -> impl

data RemoveWidget a

removeWidget :: (?loc :: CallStack, FindOp a (RemoveWidget ()) (Match r), Op (RemoveWidget ()) r a impl) => Ref a -> impl

data Clear a

clear :: (?loc :: CallStack, FindOp a (Clear ()) (Match r), Op (Clear ()) r a impl) => Ref a -> impl

data SetResizable a

setResizable :: (?loc :: CallStack, FindOp a (SetResizable ()) (Match r), Op (SetResizable ()) r a impl) => Ref a -> impl

data SetNotResizable a

setNotResizable :: (?loc :: CallStack, FindOp a (SetNotResizable ()) (Match r), Op (SetNotResizable ()) r a impl) => Ref a -> impl

data GetResizable a

getResizable :: (?loc :: CallStack, FindOp a (GetResizable ()) (Match r), Op (GetResizable ()) r a impl) => Ref a -> impl

data AddResizable a

addResizable :: (?loc :: CallStack, FindOp a (AddResizable ()) (Match r), Op (AddResizable ()) r a impl) => Ref a -> impl

data InitSizes a

initSizes :: (?loc :: CallStack, FindOp a (InitSizes ()) (Match r), Op (InitSizes ()) r a impl) => Ref a -> impl

data Children a

children :: (?loc :: CallStack, FindOp a (Children ()) (Match r), Op (Children ()) r a impl) => Ref a -> impl

data SetClipChildren a

setClipChildren :: (?loc :: CallStack, FindOp a (SetClipChildren ()) (Match r), Op (SetClipChildren ()) r a impl) => Ref a -> impl

data ClipChildren a

clipChildren :: (?loc :: CallStack, FindOp a (ClipChildren ()) (Match r), Op (ClipChildren ()) r a impl) => Ref a -> impl

data Focus a

focus :: (?loc :: CallStack, FindOp a (Focus ()) (Match r), Op (Focus ()) r a impl) => Ref a -> impl

data DdfdesignKludge a

ddfdesignKludge :: (?loc :: CallStack, FindOp a (DdfdesignKludge ()) (Match r), Op (DdfdesignKludge ()) r a impl) => Ref a -> impl

data InsertWithBefore a

insertWithBefore :: (?loc :: CallStack, FindOp a (InsertWithBefore ()) (Match r), Op (InsertWithBefore ()) r a impl) => Ref a -> impl

data GetArray a

getArray :: (?loc :: CallStack, FindOp a (GetArray ()) (Match r), Op (GetArray ()) r a impl) => Ref a -> impl

data GetChild a

getChild :: (?loc :: CallStack, FindOp a (GetChild ()) (Match r), Op (GetChild ()) r a impl) => Ref a -> impl

Window

type Window = CWindow Group

data DrawSuper a

drawSuper :: (?loc :: CallStack, FindOp a (DrawSuper ()) (Match r), Op (DrawSuper ()) r a impl) => Ref a -> impl

data HandleSuper a

handleSuper :: (?loc :: CallStack, FindOp a (HandleSuper ()) (Match r), Op (HandleSuper ()) r a impl) => Ref a -> impl

data FlushSuper a

flushSuper :: (?loc :: CallStack, FindOp a (FlushSuper ()) (Match r), Op (FlushSuper ()) r a impl) => Ref a -> impl

data MakeFullscreen a

makeFullscreen :: (?loc :: CallStack, FindOp a (MakeFullscreen ()) (Match r), Op (MakeFullscreen ()) r a impl) => Ref a -> impl

data FullscreenOff a

fullscreenOff :: (?loc :: CallStack, FindOp a (FullscreenOff ()) (Match r), Op (FullscreenOff ()) r a impl) => Ref a -> impl

data SetBorder a

setBorder :: (?loc :: CallStack, FindOp a (SetBorder ()) (Match r), Op (SetBorder ()) r a impl) => Ref a -> impl

data ClearBorder a

clearBorder :: (?loc :: CallStack, FindOp a (ClearBorder ()) (Match r), Op (ClearBorder ()) r a impl) => Ref a -> impl

data GetBorder a

getBorder :: (?loc :: CallStack, FindOp a (GetBorder ()) (Match r), Op (GetBorder ()) r a impl) => Ref a -> impl

data SetOverride a

setOverride :: (?loc :: CallStack, FindOp a (SetOverride ()) (Match r), Op (SetOverride ()) r a impl) => Ref a -> impl

data GetOverride a

getOverride :: (?loc :: CallStack, FindOp a (GetOverride ()) (Match r), Op (GetOverride ()) r a impl) => Ref a -> impl

data SetModal a

setModal :: (?loc :: CallStack, FindOp a (SetModal ()) (Match r), Op (SetModal ()) r a impl) => Ref a -> impl

data GetModal a

getModal :: (?loc :: CallStack, FindOp a (GetModal ()) (Match r), Op (GetModal ()) r a impl) => Ref a -> impl

data SetNonModal a

setNonModal :: (?loc :: CallStack, FindOp a (SetNonModal ()) (Match r), Op (SetNonModal ()) r a impl) => Ref a -> impl

data NonModal a

nonModal :: (?loc :: CallStack, FindOp a (NonModal ()) (Match r), Op (NonModal ()) r a impl) => Ref a -> impl

data SetMenuWindow a

setMenuWindow :: (?loc :: CallStack, FindOp a (SetMenuWindow ()) (Match r), Op (SetMenuWindow ()) r a impl) => Ref a -> impl

data GetMenuWindow a

getMenuWindow :: (?loc :: CallStack, FindOp a (GetMenuWindow ()) (Match r), Op (GetMenuWindow ()) r a impl) => Ref a -> impl

data SetTooltipWindow a

setTooltipWindow :: (?loc :: CallStack, FindOp a (SetTooltipWindow ()) (Match r), Op (SetTooltipWindow ()) r a impl) => Ref a -> impl

data GetTooltipWindow a

getTooltipWindow :: (?loc :: CallStack, FindOp a (GetTooltipWindow ()) (Match r), Op (GetTooltipWindow ()) r a impl) => Ref a -> impl

data HotSpot a

hotSpot :: (?loc :: CallStack, FindOp a (HotSpot ()) (Match r), Op (HotSpot ()) r a impl) => Ref a -> impl

data FreePosition a

freePosition :: (?loc :: CallStack, FindOp a (FreePosition ()) (Match r), Op (FreePosition ()) r a impl) => Ref a -> impl

data SizeRange a

sizeRange :: (?loc :: CallStack, FindOp a (SizeRange ()) (Match r), Op (SizeRange ()) r a impl) => Ref a -> impl

data SizeRangeWithArgs a

sizeRangeWithArgs :: (?loc :: CallStack, FindOp a (SizeRangeWithArgs ()) (Match r), Op (SizeRangeWithArgs ()) r a impl) => Ref a -> impl

data GetIconlabel a

getIconlabel :: (?loc :: CallStack, FindOp a (GetIconlabel ()) (Match r), Op (GetIconlabel ()) r a impl) => Ref a -> impl

data SetIconlabel a

setIconlabel :: (?loc :: CallStack, FindOp a (SetIconlabel ()) (Match r), Op (SetIconlabel ()) r a impl) => Ref a -> impl

data SetLabelWithIconlabel a

setLabelWithIconlabel :: (?loc :: CallStack, FindOp a (SetLabelWithIconlabel ()) (Match r), Op (SetLabelWithIconlabel ()) r a impl) => Ref a -> impl

data GetXclass a

getXclass :: (?loc :: CallStack, FindOp a (GetXclass ()) (Match r), Op (GetXclass ()) r a impl) => Ref a -> impl

data SetXclass a

setXclass :: (?loc :: CallStack, FindOp a (SetXclass ()) (Match r), Op (SetXclass ()) r a impl) => Ref a -> impl

data GetIcon a

getIcon :: (?loc :: CallStack, FindOp a (GetIcon ()) (Match r), Op (GetIcon ()) r a impl) => Ref a -> impl

data SetIcon a

setIcon :: (?loc :: CallStack, FindOp a (SetIcon ()) (Match r), Op (SetIcon ()) r a impl) => Ref a -> impl

data Shown a

shown :: (?loc :: CallStack, FindOp a (Shown ()) (Match r), Op (Shown ()) r a impl) => Ref a -> impl

data Iconize a

iconize :: (?loc :: CallStack, FindOp a (Iconize ()) (Match r), Op (Iconize ()) r a impl) => Ref a -> impl

data GetXRoot a

getXRoot :: (?loc :: CallStack, FindOp a (GetXRoot ()) (Match r), Op (GetXRoot ()) r a impl) => Ref a -> impl

data GetYRoot a

getYRoot :: (?loc :: CallStack, FindOp a (GetYRoot ()) (Match r), Op (GetYRoot ()) r a impl) => Ref a -> impl

data MakeCurrent a

makeCurrent :: (?loc :: CallStack, FindOp a (MakeCurrent ()) (Match r), Op (MakeCurrent ()) r a impl) => Ref a -> impl

data SetCursor a

setCursor :: (?loc :: CallStack, FindOp a (SetCursor ()) (Match r), Op (SetCursor ()) r a impl) => Ref a -> impl

data SetCursorWithFgBg a

setCursorWithFgBg :: (?loc :: CallStack, FindOp a (SetCursorWithFgBg ()) (Match r), Op (SetCursorWithFgBg ()) r a impl) => Ref a -> impl

data SetDefaultCursor a

setDefaultCursor :: (?loc :: CallStack, FindOp a (SetDefaultCursor ()) (Match r), Op (SetDefaultCursor ()) r a impl) => Ref a -> impl

data SetDefaultCursorWithFgBg a

setDefaultCursorWithFgBg :: (?loc :: CallStack, FindOp a (SetDefaultCursorWithFgBg ()) (Match r), Op (SetDefaultCursorWithFgBg ()) r a impl) => Ref a -> impl

data GetDecoratedW a

getDecoratedW :: (?loc :: CallStack, FindOp a (GetDecoratedW ()) (Match r), Op (GetDecoratedW ()) r a impl) => Ref a -> impl

data GetDecoratedH a

getDecoratedH :: (?loc :: CallStack, FindOp a (GetDecoratedH ()) (Match r), Op (GetDecoratedH ()) r a impl) => Ref a -> impl

data WaitForExpose a

waitForExpose :: (?loc :: CallStack, FindOp a (WaitForExpose ()) (Match r), Op (WaitForExpose ()) r a impl) => Ref a -> impl

SingleWindow

type SingleWindow = CSingleWindow Window

DoubleWindow

type DoubleWindow = CDoubleWindow Window

OverlayWindow

type OverlayWindow = COverlayWindow DoubleWindow

data CanDoOverlay a

canDoOverlay :: (?loc :: CallStack, FindOp a (CanDoOverlay ()) (Match r), Op (CanDoOverlay ()) r a impl) => Ref a -> impl

data RedrawOverlay a

redrawOverlay :: (?loc :: CallStack, FindOp a (RedrawOverlay ()) (Match r), Op (RedrawOverlay ()) r a impl) => Ref a -> impl

data Flush a

flush :: (?loc :: CallStack, FindOp a (Flush ()) (Match r), Op (Flush ()) r a impl) => Ref a -> impl

Button

type Button = CButton Widget

data GetValue a

getValue :: (?loc :: CallStack, FindOp a (GetValue ()) (Match r), Op (GetValue ()) r a impl) => Ref a -> impl

data SetValue a

setValue :: (?loc :: CallStack, FindOp a (SetValue ()) (Match r), Op (SetValue ()) r a impl) => Ref a -> impl

data Set a

set :: (?loc :: CallStack, FindOp a (Set ()) (Match r), Op (Set ()) r a impl) => Ref a -> impl

data Setonly a

setonly :: (?loc :: CallStack, FindOp a (Setonly ()) (Match r), Op (Setonly ()) r a impl) => Ref a -> impl

data GetShortcut a

getShortcut :: (?loc :: CallStack, FindOp a (GetShortcut ()) (Match r), Op (GetShortcut ()) r a impl) => Ref a -> impl

data SetShortcut a

setShortcut :: (?loc :: CallStack, FindOp a (SetShortcut ()) (Match r), Op (SetShortcut ()) r a impl) => Ref a -> impl

data GetDownBox a

getDownBox :: (?loc :: CallStack, FindOp a (GetDownBox ()) (Match r), Op (GetDownBox ()) r a impl) => Ref a -> impl

data SetDownBox a

setDownBox :: (?loc :: CallStack, FindOp a (SetDownBox ()) (Match r), Op (SetDownBox ()) r a impl) => Ref a -> impl

data GetDownColor a

getDownColor :: (?loc :: CallStack, FindOp a (GetDownColor ()) (Match r), Op (GetDownColor ()) r a impl) => Ref a -> impl

data SetDownColor a

setDownColor :: (?loc :: CallStack, FindOp a (SetDownColor ()) (Match r), Op (SetDownColor ()) r a impl) => Ref a -> impl

LightButton

type LightButton = CLightButton Button

RadioLightButton

type RadioLightButton = CRadioLightButton LightButton

CheckButton

type CheckButton = CCheckButton Button

ReturnButton

type ReturnButton = CReturnButton Button

RoundButton

type RoundButton = CRoundButton Button

RepeatButton

type RepeatButton = CRepeatButton Button

ToggleButton

type ToggleButton = CToggleButton Button

Valuator

type Valuator = CValuator Widget

data Bounds a

bounds :: (?loc :: CallStack, FindOp a (Bounds ()) (Match r), Op (Bounds ()) r a impl) => Ref a -> impl

data GetMinimum a

getMinimum :: (?loc :: CallStack, FindOp a (GetMinimum ()) (Match r), Op (GetMinimum ()) r a impl) => Ref a -> impl

data SetMinimum a

setMinimum :: (?loc :: CallStack, FindOp a (SetMinimum ()) (Match r), Op (SetMinimum ()) r a impl) => Ref a -> impl

data GetMaximum a

getMaximum :: (?loc :: CallStack, FindOp a (GetMaximum ()) (Match r), Op (GetMaximum ()) r a impl) => Ref a -> impl

data SetMaximum a

setMaximum :: (?loc :: CallStack, FindOp a (SetMaximum ()) (Match r), Op (SetMaximum ()) r a impl) => Ref a -> impl

data Range a

range :: (?loc :: CallStack, FindOp a (Range ()) (Match r), Op (Range ()) r a impl) => Ref a -> impl

data SetStep a

setStep :: (?loc :: CallStack, FindOp a (SetStep ()) (Match r), Op (SetStep ()) r a impl) => Ref a -> impl

data GetStep a

getStep :: (?loc :: CallStack, FindOp a (GetStep ()) (Match r), Op (GetStep ()) r a impl) => Ref a -> impl

data Precision a

precision :: (?loc :: CallStack, FindOp a (Precision ()) (Match r), Op (Precision ()) r a impl) => Ref a -> impl

data SetFormat a

setFormat :: (?loc :: CallStack, FindOp a (SetFormat ()) (Match r), Op (SetFormat ()) r a impl) => Ref a -> impl

data Round a

round :: (?loc :: CallStack, FindOp a (Round ()) (Match r), Op (Round ()) r a impl) => Ref a -> impl

data Clamp a

clamp :: (?loc :: CallStack, FindOp a (Clamp ()) (Match r), Op (Clamp ()) r a impl) => Ref a -> impl

data Increment a

increment :: (?loc :: CallStack, FindOp a (Increment ()) (Match r), Op (Increment ()) r a impl) => Ref a -> impl

Slider

type Slider = CSlider Valuator

data Scrollvalue a

scrollvalue :: (?loc :: CallStack, FindOp a (Scrollvalue ()) (Match r), Op (Scrollvalue ()) r a impl) => Ref a -> impl

data SetSliderSize a

setSliderSize :: (?loc :: CallStack, FindOp a (SetSliderSize ()) (Match r), Op (SetSliderSize ()) r a impl) => Ref a -> impl

data GetSliderSize a

getSliderSize :: (?loc :: CallStack, FindOp a (GetSliderSize ()) (Match r), Op (GetSliderSize ()) r a impl) => Ref a -> impl

data GetSlider a

getSlider :: (?loc :: CallStack, FindOp a (GetSlider ()) (Match r), Op (GetSlider ()) r a impl) => Ref a -> impl

data SetSlider a

setSlider :: (?loc :: CallStack, FindOp a (SetSlider ()) (Match r), Op (SetSlider ()) r a impl) => Ref a -> impl

FillSlider

type FillSlider = CFillSlider Slider

HorSlider

type HorSlider = CHorSlider Slider

HorFillSider

type HorFillSlider = CHorFillSlider Slider

NiceSlider

type NiceSlider = CNiceSlider Slider

HorNiceSlider

type HorNiceSlider = CHorNiceSlider Slider

MenuItem

type MenuItem = CMenuItem Base

data NextWithStep a

nextWithStep :: (?loc :: CallStack, FindOp a (NextWithStep ()) (Match r), Op (NextWithStep ()) r a impl) => Ref a -> impl

data Next a

next :: (?loc :: CallStack, FindOp a (Next ()) (Match r), Op (Next ()) r a impl) => Ref a -> impl

data GetFirst a

getFirst :: (?loc :: CallStack, FindOp a (GetFirst ()) (Match r), Op (GetFirst ()) r a impl) => Ref a -> impl

data SetLabelWithLabeltype a

setLabelWithLabeltype :: (?loc :: CallStack, FindOp a (SetLabelWithLabeltype ()) (Match r), Op (SetLabelWithLabeltype ()) r a impl) => Ref a -> impl

data Submenu a

submenu :: (?loc :: CallStack, FindOp a (Submenu ()) (Match r), Op (Submenu ()) r a impl) => Ref a -> impl

data Checkbox a

checkbox :: (?loc :: CallStack, FindOp a (Checkbox ()) (Match r), Op (Checkbox ()) r a impl) => Ref a -> impl

data Radio a

radio :: (?loc :: CallStack, FindOp a (Radio ()) (Match r), Op (Radio ()) r a impl) => Ref a -> impl

data Visible a

visible :: (?loc :: CallStack, FindOp a (Visible ()) (Match r), Op (Visible ()) r a impl) => Ref a -> impl

data Activevisible a

activevisible :: (?loc :: CallStack, FindOp a (Activevisible ()) (Match r), Op (Activevisible ()) r a impl) => Ref a -> impl

data Measure a

measure :: (?loc :: CallStack, FindOp a (Measure ()) (Match r), Op (Measure ()) r a impl) => Ref a -> impl

data DrawWithT a

drawWithT :: (?loc :: CallStack, FindOp a (DrawWithT ()) (Match r), Op (DrawWithT ()) r a impl) => Ref a -> impl

data Draw a

draw :: (?loc :: CallStack, FindOp a (Draw ()) (Match r), Op (Draw ()) r a impl) => Ref a -> impl

data GetFlags a

getFlags :: (?loc :: CallStack, FindOp a (GetFlags ()) (Match r), Op (GetFlags ()) r a impl) => Ref a -> impl

data SetFlags a

setFlags :: (?loc :: CallStack, FindOp a (SetFlags ()) (Match r), Op (SetFlags ()) r a impl) => Ref a -> impl

data GetText a

getText :: (?loc :: CallStack, FindOp a (GetText ()) (Match r), Op (GetText ()) r a impl) => Ref a -> impl

data Pulldown a

pulldown :: (?loc :: CallStack, FindOp a (Pulldown ()) (Match r), Op (Pulldown ()) r a impl) => Ref a -> impl

data Popup a

popup :: (?loc :: CallStack, FindOp a (Popup ()) (Match r), Op (Popup ()) r a impl) => Ref a -> impl

data TestShortcut a

testShortcut :: (?loc :: CallStack, FindOp a (TestShortcut ()) (Match r), Op (TestShortcut ()) r a impl) => Ref a -> impl

data FindShortcut a

findShortcut :: (?loc :: CallStack, FindOp a (FindShortcut ()) (Match r), Op (FindShortcut ()) r a impl) => Ref a -> impl

data DoCallback a

Instances

Functions Widget WidgetFuncs

doCallback :: (?loc :: CallStack, FindOp a (DoCallback ()) (Match r), Op (DoCallback ()) r a impl) => Ref a -> impl

data GetSize a

getSize :: (?loc :: CallStack, FindOp a (GetSize ()) (Match r), Op (GetSize ()) r a impl) => Ref a -> impl

MenuPrim

type MenuPrim = CMenuPrim Widget

data ItemPathname a

itemPathname :: (?loc :: CallStack, FindOp a (ItemPathname ()) (Match r), Op (ItemPathname ()) r a impl) => Ref a -> impl

data ItemPathnameRecent a

itemPathnameRecent :: (?loc :: CallStack, FindOp a (ItemPathnameRecent ()) (Match r), Op (ItemPathnameRecent ()) r a impl) => Ref a -> impl

data Picked a

picked :: (?loc :: CallStack, FindOp a (Picked ()) (Match r), Op (Picked ()) r a impl) => Ref a -> impl

data FindIndex a

findIndex :: (?loc :: CallStack, FindOp a (FindIndex ()) (Match r), Op (FindIndex ()) r a impl) => Ref a -> impl

data Global a

global :: (?loc :: CallStack, FindOp a (Global ()) (Match r), Op (Global ()) r a impl) => Ref a -> impl

data GetMenu a

getMenu :: (?loc :: CallStack, FindOp a (GetMenu ()) (Match r), Op (GetMenu ()) r a impl) => Ref a -> impl

data SetMenu a

setMenu :: (?loc :: CallStack, FindOp a (SetMenu ()) (Match r), Op (SetMenu ()) r a impl) => Ref a -> impl

data AddName a

addName :: (?loc :: CallStack, FindOp a (AddName ()) (Match r), Op (AddName ()) r a impl) => Ref a -> impl

data Copy a

copy :: (?loc :: CallStack, FindOp a (Copy ()) (Match r), Op (Copy ()) r a impl) => Ref a -> impl

data SetSize a

setSize :: (?loc :: CallStack, FindOp a (SetSize ()) (Match r), Op (SetSize ()) r a impl) => Ref a -> impl

data ClearSubmenu a

clearSubmenu :: (?loc :: CallStack, FindOp a (ClearSubmenu ()) (Match r), Op (ClearSubmenu ()) r a impl) => Ref a -> impl

data Replace a

replace :: (?loc :: CallStack, FindOp a (Replace ()) (Match r), Op (Replace ()) r a impl) => Ref a -> impl

data Remove a

remove :: (?loc :: CallStack, FindOp a (Remove ()) (Match r), Op (Remove ()) r a impl) => Ref a -> impl

data SetMode a

setMode :: (?loc :: CallStack, FindOp a (SetMode ()) (Match r), Op (SetMode ()) r a impl) => Ref a -> impl

data GetMode a

getMode :: (?loc :: CallStack, FindOp a (GetMode ()) (Match r), Op (GetMode ()) r a impl) => Ref a -> impl

data Mvalue a

mvalue :: (?loc :: CallStack, FindOp a (Mvalue ()) (Match r), Op (Mvalue ()) r a impl) => Ref a -> impl

data GetTextWithIndex a

getTextWithIndex :: (?loc :: CallStack, FindOp a (GetTextWithIndex ()) (Match r), Op (GetTextWithIndex ()) r a impl) => Ref a -> impl

data GetTextfont a

getTextfont :: (?loc :: CallStack, FindOp a (GetTextfont ()) (Match r), Op (GetTextfont ()) r a impl) => Ref a -> impl

data SetTextfont a

setTextfont :: (?loc :: CallStack, FindOp a (SetTextfont ()) (Match r), Op (SetTextfont ()) r a impl) => Ref a -> impl

data GetTextsize a

getTextsize :: (?loc :: CallStack, FindOp a (GetTextsize ()) (Match r), Op (GetTextsize ()) r a impl) => Ref a -> impl

data SetTextsize a

setTextsize :: (?loc :: CallStack, FindOp a (SetTextsize ()) (Match r), Op (SetTextsize ()) r a impl) => Ref a -> impl

data GetTextcolor a

getTextcolor :: (?loc :: CallStack, FindOp a (GetTextcolor ()) (Match r), Op (GetTextcolor ()) r a impl) => Ref a -> impl

data SetTextcolor a

setTextcolor :: (?loc :: CallStack, FindOp a (SetTextcolor ()) (Match r), Op (SetTextcolor ()) r a impl) => Ref a -> impl

data DownBox a

downBox :: (?loc :: CallStack, FindOp a (DownBox ()) (Match r), Op (DownBox ()) r a impl) => Ref a -> impl

SysMenuBar

type SysMenuBar = CSysMenuBar MenuPrim

Choice,

type Choice = CChoice MenuPrim

MenuButton

type MenuButton = CMenuButton MenuPrim

Image

type Image = CImage Base

data GetD a

getD :: (?loc :: CallStack, FindOp a (GetD ()) (Match r), Op (GetD ()) r a impl) => Ref a -> impl

data GetLd a

getLd :: (?loc :: CallStack, FindOp a (GetLd ()) (Match r), Op (GetLd ()) r a impl) => Ref a -> impl

data GetCount a

getCount :: (?loc :: CallStack, FindOp a (GetCount ()) (Match r), Op (GetCount ()) r a impl) => Ref a -> impl

data ColorAverage a

colorAverage :: (?loc :: CallStack, FindOp a (ColorAverage ()) (Match r), Op (ColorAverage ()) r a impl) => Ref a -> impl

data Inactive a

inactive :: (?loc :: CallStack, FindOp a (Inactive ()) (Match r), Op (Inactive ()) r a impl) => Ref a -> impl

data Desaturate a

desaturate :: (?loc :: CallStack, FindOp a (Desaturate ()) (Match r), Op (Desaturate ()) r a impl) => Ref a -> impl

data DrawResize a

drawResize :: (?loc :: CallStack, FindOp a (DrawResize ()) (Match r), Op (DrawResize ()) r a impl) => Ref a -> impl

data Uncache a

uncache :: (?loc :: CallStack, FindOp a (Uncache ()) (Match r), Op (Uncache ()) r a impl) => Ref a -> impl

Bitmap

type Bitmap = CBitmap Image

Pixmap

type Pixmap = CPixmap Image

CopySurface

type CopySurface = CCopySurface Base

data ClassName a

className :: (?loc :: CallStack, FindOp a (ClassName ()) (Match r), Op (ClassName ()) r a impl) => Ref a -> impl

data SetCurrent a

setCurrent :: (?loc :: CallStack, FindOp a (SetCurrent ()) (Match r), Op (SetCurrent ()) r a impl) => Ref a -> impl

ImageSurface

type ImageSurface = CImageSurface Base

Adjuster

type Adjuster = CAdjuster Valuator

data SetSoft a

setSoft :: (?loc :: CallStack, FindOp a (SetSoft ()) (Match r), Op (SetSoft ()) r a impl) => Ref a -> impl

data GetSoft a

getSoft :: (?loc :: CallStack, FindOp a (GetSoft ()) (Match r), Op (GetSoft ()) r a impl) => Ref a -> impl

Dial

type Dial = CDial Valuator

data GetAngle1 a

getAngle1 :: (?loc :: CallStack, FindOp a (GetAngle1 ()) (Match r), Op (GetAngle1 ()) r a impl) => Ref a -> impl

data SetAngle1 a

setAngle1 :: (?loc :: CallStack, FindOp a (SetAngle1 ()) (Match r), Op (SetAngle1 ()) r a impl) => Ref a -> impl

data GetAngle2 a

getAngle2 :: (?loc :: CallStack, FindOp a (GetAngle2 ()) (Match r), Op (GetAngle2 ()) r a impl) => Ref a -> impl

data SetAngle2 a

setAngle2 :: (?loc :: CallStack, FindOp a (SetAngle2 ()) (Match r), Op (SetAngle2 ()) r a impl) => Ref a -> impl

data SetAngles a

setAngles :: (?loc :: CallStack, FindOp a (SetAngles ()) (Match r), Op (SetAngles ()) r a impl) => Ref a -> impl

FillDial

type FillDial = CFillDial Dial

LineDial

type LineDial = CLineDial Dial

Roller

type Roller = CRoller Valuator

Counter

type Counter = CCounter Valuator

data SetLstep a

setLstep :: (?loc :: CallStack, FindOp a (SetLstep ()) (Match r), Op (SetLstep ()) r a impl) => Ref a -> impl

SimpleCounter

type SimpleCounter = CSimpleCounter Counter

Scrollbar

type Scrollbar = CScrollbar Slider

data SetLinesize a

setLinesize :: (?loc :: CallStack, FindOp a (SetLinesize ()) (Match r), Op (SetLinesize ()) r a impl) => Ref a -> impl

data GetLinesize a

getLinesize :: (?loc :: CallStack, FindOp a (GetLinesize ()) (Match r), Op (GetLinesize ()) r a impl) => Ref a -> impl

data SetScrollValue a

setScrollValue :: (?loc :: CallStack, FindOp a (SetScrollValue ()) (Match r), Op (SetScrollValue ()) r a impl) => Ref a -> impl

ValueSlider

type ValueSlider = CValueSlider Slider

HorValueSlider

type HorValueSlider = CHorValueSlider ValueSlider

Input

type Input = CInput Widget

data StaticValue a

staticValue :: (?loc :: CallStack, FindOp a (StaticValue ()) (Match r), Op (StaticValue ()) r a impl) => Ref a -> impl

data Index a

index :: (?loc :: CallStack, FindOp a (Index ()) (Match r), Op (Index ()) r a impl) => Ref a -> impl

data GetMaximumSize a

getMaximumSize :: (?loc :: CallStack, FindOp a (GetMaximumSize ()) (Match r), Op (GetMaximumSize ()) r a impl) => Ref a -> impl

data SetMaximumSize a

setMaximumSize :: (?loc :: CallStack, FindOp a (SetMaximumSize ()) (Match r), Op (SetMaximumSize ()) r a impl) => Ref a -> impl

data GetPosition a

getPosition :: (?loc :: CallStack, FindOp a (GetPosition ()) (Match r), Op (GetPosition ()) r a impl) => Ref a -> impl

data GetMark a

getMark :: (?loc :: CallStack, FindOp a (GetMark ()) (Match r), Op (GetMark ()) r a impl) => Ref a -> impl

data SetPosition a

setPosition :: (?loc :: CallStack, FindOp a (SetPosition ()) (Match r), Op (SetPosition ()) r a impl) => Ref a -> impl

data SetMark a

setMark :: (?loc :: CallStack, FindOp a (SetMark ()) (Match r), Op (SetMark ()) r a impl) => Ref a -> impl

data Cut a

cut :: (?loc :: CallStack, FindOp a (Cut ()) (Match r), Op (Cut ()) r a impl) => Ref a -> impl

data CutFromCursor a

cutFromCursor :: (?loc :: CallStack, FindOp a (CutFromCursor ()) (Match r), Op (CutFromCursor ()) r a impl) => Ref a -> impl

data CutRange a

cutRange :: (?loc :: CallStack, FindOp a (CutRange ()) (Match r), Op (CutRange ()) r a impl) => Ref a -> impl

data InsertWithLength a

insertWithLength :: (?loc :: CallStack, FindOp a (InsertWithLength ()) (Match r), Op (InsertWithLength ()) r a impl) => Ref a -> impl

data Undo a

undo :: (?loc :: CallStack, FindOp a (Undo ()) (Match r), Op (Undo ()) r a impl) => Ref a -> impl

data CopyCuts a

copyCuts :: (?loc :: CallStack, FindOp a (CopyCuts ()) (Match r), Op (CopyCuts ()) r a impl) => Ref a -> impl

data GetCursorColor a

getCursorColor :: (?loc :: CallStack, FindOp a (GetCursorColor ()) (Match r), Op (GetCursorColor ()) r a impl) => Ref a -> impl

data SetCursorColor a

setCursorColor :: (?loc :: CallStack, FindOp a (SetCursorColor ()) (Match r), Op (SetCursorColor ()) r a impl) => Ref a -> impl

data GetInputType a

getInputType :: (?loc :: CallStack, FindOp a (GetInputType ()) (Match r), Op (GetInputType ()) r a impl) => Ref a -> impl

data SetInputType a

setInputType :: (?loc :: CallStack, FindOp a (SetInputType ()) (Match r), Op (SetInputType ()) r a impl) => Ref a -> impl

data GetReadonly a

getReadonly :: (?loc :: CallStack, FindOp a (GetReadonly ()) (Match r), Op (GetReadonly ()) r a impl) => Ref a -> impl

data SetReadonly a

setReadonly :: (?loc :: CallStack, FindOp a (SetReadonly ()) (Match r), Op (SetReadonly ()) r a impl) => Ref a -> impl

data GetWrap a

getWrap :: (?loc :: CallStack, FindOp a (GetWrap ()) (Match r), Op (GetWrap ()) r a impl) => Ref a -> impl

data SetWrap a

setWrap :: (?loc :: CallStack, FindOp a (SetWrap ()) (Match r), Op (SetWrap ()) r a impl) => Ref a -> impl

data GetTabNav a

getTabNav :: (?loc :: CallStack, FindOp a (GetTabNav ()) (Match r), Op (GetTabNav ()) r a impl) => Ref a -> impl

data SetTabNav a

setTabNav :: (?loc :: CallStack, FindOp a (SetTabNav ()) (Match r), Op (SetTabNav ()) r a impl) => Ref a -> impl

Output

type Output = COutput Input

ValueInput

type ValueInput = CValueInput Valuator

ValueOutput

type ValueOutput = CValueOutput Valuator

Timer

type Timer = CTimer Widget

data GetDirection a

getDirection :: (?loc :: CallStack, FindOp a (GetDirection ()) (Match r), Op (GetDirection ()) r a impl) => Ref a -> impl

data SetDirection a

setDirection :: (?loc :: CallStack, FindOp a (SetDirection ()) (Match r), Op (SetDirection ()) r a impl) => Ref a -> impl

data GetSuspended a

getSuspended :: (?loc :: CallStack, FindOp a (GetSuspended ()) (Match r), Op (GetSuspended ()) r a impl) => Ref a -> impl

data SetSuspended a

setSuspended :: (?loc :: CallStack, FindOp a (SetSuspended ()) (Match r), Op (SetSuspended ()) r a impl) => Ref a -> impl

HiddenTimer

type HiddenTimer = CHiddenTimer Widget

ValueTimer

type ValueTimer = CValueTimer Widget

Progress

type Progress = CProgress Widget

Positioner

type Positioner = CPositioner Widget

data SetXvalue a

setXvalue :: (?loc :: CallStack, FindOp a (SetXvalue ()) (Match r), Op (SetXvalue ()) r a impl) => Ref a -> impl

data GetXvalue a

getXvalue :: (?loc :: CallStack, FindOp a (GetXvalue ()) (Match r), Op (GetXvalue ()) r a impl) => Ref a -> impl

data SetYvalue a

setYvalue :: (?loc :: CallStack, FindOp a (SetYvalue ()) (Match r), Op (SetYvalue ()) r a impl) => Ref a -> impl

data GetYvalue a

getYvalue :: (?loc :: CallStack, FindOp a (GetYvalue ()) (Match r), Op (GetYvalue ()) r a impl) => Ref a -> impl

data SetXminimum a

setXminimum :: (?loc :: CallStack, FindOp a (SetXminimum ()) (Match r), Op (SetXminimum ()) r a impl) => Ref a -> impl

data GetXminimum a

getXminimum :: (?loc :: CallStack, FindOp a (GetXminimum ()) (Match r), Op (GetXminimum ()) r a impl) => Ref a -> impl

data SetYminimum a

setYminimum :: (?loc :: CallStack, FindOp a (SetYminimum ()) (Match r), Op (SetYminimum ()) r a impl) => Ref a -> impl

data GetYminimum a

getYminimum :: (?loc :: CallStack, FindOp a (GetYminimum ()) (Match r), Op (GetYminimum ()) r a impl) => Ref a -> impl

data SetXmaximum a

setXmaximum :: (?loc :: CallStack, FindOp a (SetXmaximum ()) (Match r), Op (SetXmaximum ()) r a impl) => Ref a -> impl

data GetXmaximum a

getXmaximum :: (?loc :: CallStack, FindOp a (GetXmaximum ()) (Match r), Op (GetXmaximum ()) r a impl) => Ref a -> impl

data SetYmaximum a

setYmaximum :: (?loc :: CallStack, FindOp a (SetYmaximum ()) (Match r), Op (SetYmaximum ()) r a impl) => Ref a -> impl

data GetYmaximum a

getYmaximum :: (?loc :: CallStack, FindOp a (GetYmaximum ()) (Match r), Op (GetYmaximum ()) r a impl) => Ref a -> impl

data SetXbounds a

setXbounds :: (?loc :: CallStack, FindOp a (SetXbounds ()) (Match r), Op (SetXbounds ()) r a impl) => Ref a -> impl

data SetYbounds a

setYbounds :: (?loc :: CallStack, FindOp a (SetYbounds ()) (Match r), Op (SetYbounds ()) r a impl) => Ref a -> impl

data SetXstep a

setXstep :: (?loc :: CallStack, FindOp a (SetXstep ()) (Match r), Op (SetXstep ()) r a impl) => Ref a -> impl

data SetYstep a

setYstep :: (?loc :: CallStack, FindOp a (SetYstep ()) (Match r), Op (SetYstep ()) r a impl) => Ref a -> impl

Wizard

type Wizard = CWizard Group

data Prev a

prev :: (?loc :: CallStack, FindOp a (Prev ()) (Match r), Op (Prev ()) r a impl) => Ref a -> impl

Table

type Table = CTable Group

data SetTableBox a

setTableBox :: (?loc :: CallStack, FindOp a (SetTableBox ()) (Match r), Op (SetTableBox ()) r a impl) => Ref a -> impl

data GetTableBox a

getTableBox :: (?loc :: CallStack, FindOp a (GetTableBox ()) (Match r), Op (GetTableBox ()) r a impl) => Ref a -> impl

data SetRows a

setRows :: (?loc :: CallStack, FindOp a (SetRows ()) (Match r), Op (SetRows ()) r a impl) => Ref a -> impl

data GetRows a

getRows :: (?loc :: CallStack, FindOp a (GetRows ()) (Match r), Op (GetRows ()) r a impl) => Ref a -> impl

data SetCols a

setCols :: (?loc :: CallStack, FindOp a (SetCols ()) (Match r), Op (SetCols ()) r a impl) => Ref a -> impl

data GetCols a

getCols :: (?loc :: CallStack, FindOp a (GetCols ()) (Match r), Op (GetCols ()) r a impl) => Ref a -> impl

data GetVisibleCells a

getVisibleCells :: (?loc :: CallStack, FindOp a (GetVisibleCells ()) (Match r), Op (GetVisibleCells ()) r a impl) => Ref a -> impl

data IsInteractiveResize a

isInteractiveResize :: (?loc :: CallStack, FindOp a (IsInteractiveResize ()) (Match r), Op (IsInteractiveResize ()) r a impl) => Ref a -> impl

data GetRowResize a

getRowResize :: (?loc :: CallStack, FindOp a (GetRowResize ()) (Match r), Op (GetRowResize ()) r a impl) => Ref a -> impl

data SetRowResize a

setRowResize :: (?loc :: CallStack, FindOp a (SetRowResize ()) (Match r), Op (SetRowResize ()) r a impl) => Ref a -> impl

data GetColResize a

getColResize :: (?loc :: CallStack, FindOp a (GetColResize ()) (Match r), Op (GetColResize ()) r a impl) => Ref a -> impl

data SetColResize a

setColResize :: (?loc :: CallStack, FindOp a (SetColResize ()) (Match r), Op (SetColResize ()) r a impl) => Ref a -> impl

data GetColResizeMin a

getColResizeMin :: (?loc :: CallStack, FindOp a (GetColResizeMin ()) (Match r), Op (GetColResizeMin ()) r a impl) => Ref a -> impl

data SetColResizeMin a

setColResizeMin :: (?loc :: CallStack, FindOp a (SetColResizeMin ()) (Match r), Op (SetColResizeMin ()) r a impl) => Ref a -> impl

data GetRowResizeMin a

getRowResizeMin :: (?loc :: CallStack, FindOp a (GetRowResizeMin ()) (Match r), Op (GetRowResizeMin ()) r a impl) => Ref a -> impl

data SetRowResizeMin a

setRowResizeMin :: (?loc :: CallStack, FindOp a (SetRowResizeMin ()) (Match r), Op (SetRowResizeMin ()) r a impl) => Ref a -> impl

data GetRowHeader a

getRowHeader :: (?loc :: CallStack, FindOp a (GetRowHeader ()) (Match r), Op (GetRowHeader ()) r a impl) => Ref a -> impl

data SetRowHeader a

setRowHeader :: (?loc :: CallStack, FindOp a (SetRowHeader ()) (Match r), Op (SetRowHeader ()) r a impl) => Ref a -> impl

data GetColHeader a

getColHeader :: (?loc :: CallStack, FindOp a (GetColHeader ()) (Match r), Op (GetColHeader ()) r a impl) => Ref a -> impl

data SetColHeader a

setColHeader :: (?loc :: CallStack, FindOp a (SetColHeader ()) (Match r), Op (SetColHeader ()) r a impl) => Ref a -> impl

data SetColHeaderHeight a

setColHeaderHeight :: (?loc :: CallStack, FindOp a (SetColHeaderHeight ()) (Match r), Op (SetColHeaderHeight ()) r a impl) => Ref a -> impl

data GetColHeaderHeight a

getColHeaderHeight :: (?loc :: CallStack, FindOp a (GetColHeaderHeight ()) (Match r), Op (GetColHeaderHeight ()) r a impl) => Ref a -> impl

data SetRowHeaderWidth a

setRowHeaderWidth :: (?loc :: CallStack, FindOp a (SetRowHeaderWidth ()) (Match r), Op (SetRowHeaderWidth ()) r a impl) => Ref a -> impl

data GetRowHeaderWidth a

getRowHeaderWidth :: (?loc :: CallStack, FindOp a (GetRowHeaderWidth ()) (Match r), Op (GetRowHeaderWidth ()) r a impl) => Ref a -> impl

data SetRowHeaderColor a

setRowHeaderColor :: (?loc :: CallStack, FindOp a (SetRowHeaderColor ()) (Match r), Op (SetRowHeaderColor ()) r a impl) => Ref a -> impl

data GetRowHeaderColor a

getRowHeaderColor :: (?loc :: CallStack, FindOp a (GetRowHeaderColor ()) (Match r), Op (GetRowHeaderColor ()) r a impl) => Ref a -> impl

data SetColHeaderColor a

setColHeaderColor :: (?loc :: CallStack, FindOp a (SetColHeaderColor ()) (Match r), Op (SetColHeaderColor ()) r a impl) => Ref a -> impl

data GetColHeaderColor a

getColHeaderColor :: (?loc :: CallStack, FindOp a (GetColHeaderColor ()) (Match r), Op (GetColHeaderColor ()) r a impl) => Ref a -> impl

data SetRowHeight a

setRowHeight :: (?loc :: CallStack, FindOp a (SetRowHeight ()) (Match r), Op (SetRowHeight ()) r a impl) => Ref a -> impl

data GetRowHeight a

getRowHeight :: (?loc :: CallStack, FindOp a (GetRowHeight ()) (Match r), Op (GetRowHeight ()) r a impl) => Ref a -> impl

data SetColWidth a

setColWidth :: (?loc :: CallStack, FindOp a (SetColWidth ()) (Match r), Op (SetColWidth ()) r a impl) => Ref a -> impl

data GetColWidth a

getColWidth :: (?loc :: CallStack, FindOp a (GetColWidth ()) (Match r), Op (GetColWidth ()) r a impl) => Ref a -> impl

data SetRowHeightAll a

setRowHeightAll :: (?loc :: CallStack, FindOp a (SetRowHeightAll ()) (Match r), Op (SetRowHeightAll ()) r a impl) => Ref a -> impl

data SetColWidthAll a

setColWidthAll :: (?loc :: CallStack, FindOp a (SetColWidthAll ()) (Match r), Op (SetColWidthAll ()) r a impl) => Ref a -> impl

data SetRowPosition a

setRowPosition :: (?loc :: CallStack, FindOp a (SetRowPosition ()) (Match r), Op (SetRowPosition ()) r a impl) => Ref a -> impl

data SetColPosition a

setColPosition :: (?loc :: CallStack, FindOp a (SetColPosition ()) (Match r), Op (SetColPosition ()) r a impl) => Ref a -> impl

data GetRowPosition a

getRowPosition :: (?loc :: CallStack, FindOp a (GetRowPosition ()) (Match r), Op (GetRowPosition ()) r a impl) => Ref a -> impl

data GetColPosition a

getColPosition :: (?loc :: CallStack, FindOp a (GetColPosition ()) (Match r), Op (GetColPosition ()) r a impl) => Ref a -> impl

data SetTopRow a

setTopRow :: (?loc :: CallStack, FindOp a (SetTopRow ()) (Match r), Op (SetTopRow ()) r a impl) => Ref a -> impl

data GetTopRow a

getTopRow :: (?loc :: CallStack, FindOp a (GetTopRow ()) (Match r), Op (GetTopRow ()) r a impl) => Ref a -> impl

data IsSelected a

isSelected :: (?loc :: CallStack, FindOp a (IsSelected ()) (Match r), Op (IsSelected ()) r a impl) => Ref a -> impl

data GetSelection a

getSelection :: (?loc :: CallStack, FindOp a (GetSelection ()) (Match r), Op (GetSelection ()) r a impl) => Ref a -> impl

data SetSelection a

setSelection :: (?loc :: CallStack, FindOp a (SetSelection ()) (Match r), Op (SetSelection ()) r a impl) => Ref a -> impl

data MoveCursor a

moveCursor :: (?loc :: CallStack, FindOp a (MoveCursor ()) (Match r), Op (MoveCursor ()) r a impl) => Ref a -> impl

data CallbackRow a

callbackRow :: (?loc :: CallStack, FindOp a (CallbackRow ()) (Match r), Op (CallbackRow ()) r a impl) => Ref a -> impl

data CallbackCol a

callbackCol :: (?loc :: CallStack, FindOp a (CallbackCol ()) (Match r), Op (CallbackCol ()) r a impl) => Ref a -> impl

data CallbackContext a

callbackContext :: (?loc :: CallStack, FindOp a (CallbackContext ()) (Match r), Op (CallbackContext ()) r a impl) => Ref a -> impl

data FindCell a

findCell :: (?loc :: CallStack, FindOp a (FindCell ()) (Match r), Op (FindCell ()) r a impl) => Ref a -> impl

data ClearSuper a

clearSuper :: (?loc :: CallStack, FindOp a (ClearSuper ()) (Match r), Op (ClearSuper ()) r a impl) => Ref a -> impl

data SetRowsSuper a

setRowsSuper :: (?loc :: CallStack, FindOp a (SetRowsSuper ()) (Match r), Op (SetRowsSuper ()) r a impl) => Ref a -> impl

data SetColsSuper a

setColsSuper :: (?loc :: CallStack, FindOp a (SetColsSuper ()) (Match r), Op (SetColsSuper ()) r a impl) => Ref a -> impl

TableRow

type TableRow = CTableRow Table

data GetRowSelected a

getRowSelected :: (?loc :: CallStack, FindOp a (GetRowSelected ()) (Match r), Op (GetRowSelected ()) r a impl) => Ref a -> impl

data SelectAllRows a

selectAllRows :: (?loc :: CallStack, FindOp a (SelectAllRows ()) (Match r), Op (SelectAllRows ()) r a impl) => Ref a -> impl

GlWindow

type GlWindow = CGlWindow Window

data GetValid a

getValid :: (?loc :: CallStack, FindOp a (GetValid ()) (Match r), Op (GetValid ()) r a impl) => Ref a -> impl

data SetValid a

setValid :: (?loc :: CallStack, FindOp a (SetValid ()) (Match r), Op (SetValid ()) r a impl) => Ref a -> impl

data Invalidate a

invalidate :: (?loc :: CallStack, FindOp a (Invalidate ()) (Match r), Op (Invalidate ()) r a impl) => Ref a -> impl

data GetContextValid a

getContextValid :: (?loc :: CallStack, FindOp a (GetContextValid ()) (Match r), Op (GetContextValid ()) r a impl) => Ref a -> impl

data SetContextValid a

setContextValid :: (?loc :: CallStack, FindOp a (SetContextValid ()) (Match r), Op (SetContextValid ()) r a impl) => Ref a -> impl

data CanDoWithM a

canDoWithM :: (?loc :: CallStack, FindOp a (CanDoWithM ()) (Match r), Op (CanDoWithM ()) r a impl) => Ref a -> impl

data CanDo a

canDo :: (?loc :: CallStack, FindOp a (CanDo ()) (Match r), Op (CanDo ()) r a impl) => Ref a -> impl

data GetContext a

getContext :: (?loc :: CallStack, FindOp a (GetContext ()) (Match r), Op (GetContext ()) r a impl) => Ref a -> impl

data SetContext a

setContext :: (?loc :: CallStack, FindOp a (SetContext ()) (Match r), Op (SetContext ()) r a impl) => Ref a -> impl

data SetContextWithDestroyFlag a

setContextWithDestroyFlag :: (?loc :: CallStack, FindOp a (SetContextWithDestroyFlag ()) (Match r), Op (SetContextWithDestroyFlag ()) r a impl) => Ref a -> impl

data SwapBuffers a

swapBuffers :: (?loc :: CallStack, FindOp a (SwapBuffers ()) (Match r), Op (SwapBuffers ()) r a impl) => Ref a -> impl

data Ortho a

ortho :: (?loc :: CallStack, FindOp a (Ortho ()) (Match r), Op (Ortho ()) r a impl) => Ref a -> impl

data HideOverlay a

hideOverlay :: (?loc :: CallStack, FindOp a (HideOverlay ()) (Match r), Op (HideOverlay ()) r a impl) => Ref a -> impl

data MakeOverlayCurrent a

makeOverlayCurrent :: (?loc :: CallStack, FindOp a (MakeOverlayCurrent ()) (Match r), Op (MakeOverlayCurrent ()) r a impl) => Ref a -> impl

Box

type Box = CBox Widget

Browser

type Browser = CBrowser Group

data Move a

move :: (?loc :: CallStack, FindOp a (Move ()) (Match r), Op (Move ()) r a impl) => Ref a -> impl

data Load a

load :: (?loc :: CallStack, FindOp a (Load ()) (Match r), Op (Load ()) r a impl) => Ref a -> impl

data Swap a

swap :: (?loc :: CallStack, FindOp a (Swap ()) (Match r), Op (Swap ()) r a impl) => Ref a -> impl

data GetTopline a

getTopline :: (?loc :: CallStack, FindOp a (GetTopline ()) (Match r), Op (GetTopline ()) r a impl) => Ref a -> impl

data Lineposition a

lineposition :: (?loc :: CallStack, FindOp a (Lineposition ()) (Match r), Op (Lineposition ()) r a impl) => Ref a -> impl

data SetTopline a

setTopline :: (?loc :: CallStack, FindOp a (SetTopline ()) (Match r), Op (SetTopline ()) r a impl) => Ref a -> impl

data SetBottomline a

setBottomline :: (?loc :: CallStack, FindOp a (SetBottomline ()) (Match r), Op (SetBottomline ()) r a impl) => Ref a -> impl

data SetMiddleline a

setMiddleline :: (?loc :: CallStack, FindOp a (SetMiddleline ()) (Match r), Op (SetMiddleline ()) r a impl) => Ref a -> impl

data Select a

select :: (?loc :: CallStack, FindOp a (Select ()) (Match r), Op (Select ()) r a impl) => Ref a -> impl

data Selected a

selected :: (?loc :: CallStack, FindOp a (Selected ()) (Match r), Op (Selected ()) r a impl) => Ref a -> impl

data ShowWidgetLine a

showWidgetLine :: (?loc :: CallStack, FindOp a (ShowWidgetLine ()) (Match r), Op (ShowWidgetLine ()) r a impl) => Ref a -> impl

data HideLine a

hideLine :: (?loc :: CallStack, FindOp a (HideLine ()) (Match r), Op (HideLine ()) r a impl) => Ref a -> impl

data SetText a

setText :: (?loc :: CallStack, FindOp a (SetText ()) (Match r), Op (SetText ()) r a impl) => Ref a -> impl

data GetFormatChar a

getFormatChar :: (?loc :: CallStack, FindOp a (GetFormatChar ()) (Match r), Op (GetFormatChar ()) r a impl) => Ref a -> impl

data SetFormatChar a

setFormatChar :: (?loc :: CallStack, FindOp a (SetFormatChar ()) (Match r), Op (SetFormatChar ()) r a impl) => Ref a -> impl

data GetColumnChar a

getColumnChar :: (?loc :: CallStack, FindOp a (GetColumnChar ()) (Match r), Op (GetColumnChar ()) r a impl) => Ref a -> impl

data SetColumnChar a

setColumnChar :: (?loc :: CallStack, FindOp a (SetColumnChar ()) (Match r), Op (SetColumnChar ()) r a impl) => Ref a -> impl

data GetColumnWidths a

getColumnWidths :: (?loc :: CallStack, FindOp a (GetColumnWidths ()) (Match r), Op (GetColumnWidths ()) r a impl) => Ref a -> impl

data SetColumnWidths a

setColumnWidths :: (?loc :: CallStack, FindOp a (SetColumnWidths ()) (Match r), Op (SetColumnWidths ()) r a impl) => Ref a -> impl

data Displayed a

displayed :: (?loc :: CallStack, FindOp a (Displayed ()) (Match r), Op (Displayed ()) r a impl) => Ref a -> impl

data MakeVisible a

makeVisible :: (?loc :: CallStack, FindOp a (MakeVisible ()) (Match r), Op (MakeVisible ()) r a impl) => Ref a -> impl

data RemoveIcon a

removeIcon :: (?loc :: CallStack, FindOp a (RemoveIcon ()) (Match r), Op (RemoveIcon ()) r a impl) => Ref a -> impl

data SelectOnly a

selectOnly :: (?loc :: CallStack, FindOp a (SelectOnly ()) (Match r), Op (SelectOnly ()) r a impl) => Ref a -> impl

data SelectOnlyAndCallback a

selectOnlyAndCallback :: (?loc :: CallStack, FindOp a (SelectOnlyAndCallback ()) (Match r), Op (SelectOnlyAndCallback ()) r a impl) => Ref a -> impl

data Deselect a

deselect :: (?loc :: CallStack, FindOp a (Deselect ()) (Match r), Op (Deselect ()) r a impl) => Ref a -> impl

data DeselectAndCallback a

deselectAndCallback :: (?loc :: CallStack, FindOp a (DeselectAndCallback ()) (Match r), Op (DeselectAndCallback ()) r a impl) => Ref a -> impl

data GetHposition a

getHposition :: (?loc :: CallStack, FindOp a (GetHposition ()) (Match r), Op (GetHposition ()) r a impl) => Ref a -> impl

data SetHposition a

setHposition :: (?loc :: CallStack, FindOp a (SetHposition ()) (Match r), Op (SetHposition ()) r a impl) => Ref a -> impl

data GetHasScrollbar a

getHasScrollbar :: (?loc :: CallStack, FindOp a (GetHasScrollbar ()) (Match r), Op (GetHasScrollbar ()) r a impl) => Ref a -> impl

data SetHasScrollbar a

setHasScrollbar :: (?loc :: CallStack, FindOp a (SetHasScrollbar ()) (Match r), Op (SetHasScrollbar ()) r a impl) => Ref a -> impl

data GetScrollbarSize a

getScrollbarSize :: (?loc :: CallStack, FindOp a (GetScrollbarSize ()) (Match r), Op (GetScrollbarSize ()) r a impl) => Ref a -> impl

data SetScrollbarSize a

setScrollbarSize :: (?loc :: CallStack, FindOp a (SetScrollbarSize ()) (Match r), Op (SetScrollbarSize ()) r a impl) => Ref a -> impl

data GetScrollbarWidth a

getScrollbarWidth :: (?loc :: CallStack, FindOp a (GetScrollbarWidth ()) (Match r), Op (GetScrollbarWidth ()) r a impl) => Ref a -> impl

data SetScrollbarWidth a

setScrollbarWidth :: (?loc :: CallStack, FindOp a (SetScrollbarWidth ()) (Match r), Op (SetScrollbarWidth ()) r a impl) => Ref a -> impl

data Sort a

sort :: (?loc :: CallStack, FindOp a (Sort ()) (Match r), Op (Sort ()) r a impl) => Ref a -> impl

data SortWithSortType a

sortWithSortType :: (?loc :: CallStack, FindOp a (SortWithSortType ()) (Match r), Op (SortWithSortType ()) r a impl) => Ref a -> impl

SelectBrowser

type SelectBrowser = CSelectBrowser Browser

IntInput

type IntInput = CIntInput Input

Clock

type Clock = CClock Widget

data GetValueSinceEpoch a

getValueSinceEpoch :: (?loc :: CallStack, FindOp a (GetValueSinceEpoch ()) (Match r), Op (GetValueSinceEpoch ()) r a impl) => Ref a -> impl

TreePrefs

type TreePrefs = CTreePrefs Base

data GetItemLabelfont a

getItemLabelfont :: (?loc :: CallStack, FindOp a (GetItemLabelfont ()) (Match r), Op (GetItemLabelfont ()) r a impl) => Ref a -> impl

data GetItemLabelsize a

getItemLabelsize :: (?loc :: CallStack, FindOp a (GetItemLabelsize ()) (Match r), Op (GetItemLabelsize ()) r a impl) => Ref a -> impl

data SetItemLabelsize a

setItemLabelsize :: (?loc :: CallStack, FindOp a (SetItemLabelsize ()) (Match r), Op (SetItemLabelsize ()) r a impl) => Ref a -> impl

data SetItemLabelfgcolor a

setItemLabelfgcolor :: (?loc :: CallStack, FindOp a (SetItemLabelfgcolor ()) (Match r), Op (SetItemLabelfgcolor ()) r a impl) => Ref a -> impl

data GetItemLabelbgcolor a

getItemLabelbgcolor :: (?loc :: CallStack, FindOp a (GetItemLabelbgcolor ()) (Match r), Op (GetItemLabelbgcolor ()) r a impl) => Ref a -> impl

data SetItemLabelbgcolor a

setItemLabelbgcolor :: (?loc :: CallStack, FindOp a (SetItemLabelbgcolor ()) (Match r), Op (SetItemLabelbgcolor ()) r a impl) => Ref a -> impl

data GetLabelfgcolor a

getLabelfgcolor :: (?loc :: CallStack, FindOp a (GetLabelfgcolor ()) (Match r), Op (GetLabelfgcolor ()) r a impl) => Ref a -> impl

data SetLabelfgcolor a

setLabelfgcolor :: (?loc :: CallStack, FindOp a (SetLabelfgcolor ()) (Match r), Op (SetLabelfgcolor ()) r a impl) => Ref a -> impl

data GetLabelbgcolor a

getLabelbgcolor :: (?loc :: CallStack, FindOp a (GetLabelbgcolor ()) (Match r), Op (GetLabelbgcolor ()) r a impl) => Ref a -> impl

data SetLabelbgcolor a

setLabelbgcolor :: (?loc :: CallStack, FindOp a (SetLabelbgcolor ()) (Match r), Op (SetLabelbgcolor ()) r a impl) => Ref a -> impl

data GetMarginleft a

getMarginleft :: (?loc :: CallStack, FindOp a (GetMarginleft ()) (Match r), Op (GetMarginleft ()) r a impl) => Ref a -> impl

data SetMarginleft a

setMarginleft :: (?loc :: CallStack, FindOp a (SetMarginleft ()) (Match r), Op (SetMarginleft ()) r a impl) => Ref a -> impl

data GetMargintop a

getMargintop :: (?loc :: CallStack, FindOp a (GetMargintop ()) (Match r), Op (GetMargintop ()) r a impl) => Ref a -> impl

data SetMargintop a

setMargintop :: (?loc :: CallStack, FindOp a (SetMargintop ()) (Match r), Op (SetMargintop ()) r a impl) => Ref a -> impl

data GetOpenchildMarginbottom a

getOpenchildMarginbottom :: (?loc :: CallStack, FindOp a (GetOpenchildMarginbottom ()) (Match r), Op (GetOpenchildMarginbottom ()) r a impl) => Ref a -> impl

data SetOpenchildMarginbottom a

setOpenchildMarginbottom :: (?loc :: CallStack, FindOp a (SetOpenchildMarginbottom ()) (Match r), Op (SetOpenchildMarginbottom ()) r a impl) => Ref a -> impl

data GetUsericonmarginleft a

getUsericonmarginleft :: (?loc :: CallStack, FindOp a (GetUsericonmarginleft ()) (Match r), Op (GetUsericonmarginleft ()) r a impl) => Ref a -> impl

data SetUsericonmarginleft a

setUsericonmarginleft :: (?loc :: CallStack, FindOp a (SetUsericonmarginleft ()) (Match r), Op (SetUsericonmarginleft ()) r a impl) => Ref a -> impl

data GetLabelmarginleft a

getLabelmarginleft :: (?loc :: CallStack, FindOp a (GetLabelmarginleft ()) (Match r), Op (GetLabelmarginleft ()) r a impl) => Ref a -> impl

data SetLabelmarginleft a

setLabelmarginleft :: (?loc :: CallStack, FindOp a (SetLabelmarginleft ()) (Match r), Op (SetLabelmarginleft ()) r a impl) => Ref a -> impl

data GetLinespacing a

getLinespacing :: (?loc :: CallStack, FindOp a (GetLinespacing ()) (Match r), Op (GetLinespacing ()) r a impl) => Ref a -> impl

data SetLinespacing a

setLinespacing :: (?loc :: CallStack, FindOp a (SetLinespacing ()) (Match r), Op (SetLinespacing ()) r a impl) => Ref a -> impl

data GetConnectorcolor a

getConnectorcolor :: (?loc :: CallStack, FindOp a (GetConnectorcolor ()) (Match r), Op (GetConnectorcolor ()) r a impl) => Ref a -> impl

data SetConnectorcolor a

setConnectorcolor :: (?loc :: CallStack, FindOp a (SetConnectorcolor ()) (Match r), Op (SetConnectorcolor ()) r a impl) => Ref a -> impl

data GetConnectorstyle a

getConnectorstyle :: (?loc :: CallStack, FindOp a (GetConnectorstyle ()) (Match r), Op (GetConnectorstyle ()) r a impl) => Ref a -> impl

data SetConnectorstyle a

setConnectorstyle :: (?loc :: CallStack, FindOp a (SetConnectorstyle ()) (Match r), Op (SetConnectorstyle ()) r a impl) => Ref a -> impl

data GetConnectorwidth a

getConnectorwidth :: (?loc :: CallStack, FindOp a (GetConnectorwidth ()) (Match r), Op (GetConnectorwidth ()) r a impl) => Ref a -> impl

data SetConnectorwidth a

setConnectorwidth :: (?loc :: CallStack, FindOp a (SetConnectorwidth ()) (Match r), Op (SetConnectorwidth ()) r a impl) => Ref a -> impl

data GetOpenicon a

getOpenicon :: (?loc :: CallStack, FindOp a (GetOpenicon ()) (Match r), Op (GetOpenicon ()) r a impl) => Ref a -> impl

data SetOpenicon a

setOpenicon :: (?loc :: CallStack, FindOp a (SetOpenicon ()) (Match r), Op (SetOpenicon ()) r a impl) => Ref a -> impl

data GetCloseicon a

getCloseicon :: (?loc :: CallStack, FindOp a (GetCloseicon ()) (Match r), Op (GetCloseicon ()) r a impl) => Ref a -> impl

data SetCloseicon a

setCloseicon :: (?loc :: CallStack, FindOp a (SetCloseicon ()) (Match r), Op (SetCloseicon ()) r a impl) => Ref a -> impl

data GetUsericon a

getUsericon :: (?loc :: CallStack, FindOp a (GetUsericon ()) (Match r), Op (GetUsericon ()) r a impl) => Ref a -> impl

data SetUsericon a

setUsericon :: (?loc :: CallStack, FindOp a (SetUsericon ()) (Match r), Op (SetUsericon ()) r a impl) => Ref a -> impl

data GetShowcollapse a

getShowcollapse :: (?loc :: CallStack, FindOp a (GetShowcollapse ()) (Match r), Op (GetShowcollapse ()) r a impl) => Ref a -> impl

data SetShowcollapse a

setShowcollapse :: (?loc :: CallStack, FindOp a (SetShowcollapse ()) (Match r), Op (SetShowcollapse ()) r a impl) => Ref a -> impl

data GetSortorder a

getSortorder :: (?loc :: CallStack, FindOp a (GetSortorder ()) (Match r), Op (GetSortorder ()) r a impl) => Ref a -> impl

data SetSortorder a

setSortorder :: (?loc :: CallStack, FindOp a (SetSortorder ()) (Match r), Op (SetSortorder ()) r a impl) => Ref a -> impl

data GetSelectbox a

getSelectbox :: (?loc :: CallStack, FindOp a (GetSelectbox ()) (Match r), Op (GetSelectbox ()) r a impl) => Ref a -> impl

data SetSelectbox a

setSelectbox :: (?loc :: CallStack, FindOp a (SetSelectbox ()) (Match r), Op (SetSelectbox ()) r a impl) => Ref a -> impl

data GetShowroot a

getShowroot :: (?loc :: CallStack, FindOp a (GetShowroot ()) (Match r), Op (GetShowroot ()) r a impl) => Ref a -> impl

data SetShowroot a

setShowroot :: (?loc :: CallStack, FindOp a (SetShowroot ()) (Match r), Op (SetShowroot ()) r a impl) => Ref a -> impl

data GetSelectmode a

getSelectmode :: (?loc :: CallStack, FindOp a (GetSelectmode ()) (Match r), Op (GetSelectmode ()) r a impl) => Ref a -> impl

data SetSelectmode a

setSelectmode :: (?loc :: CallStack, FindOp a (SetSelectmode ()) (Match r), Op (SetSelectmode ()) r a impl) => Ref a -> impl

TreeItem

type TreeItem = CTreeItem Base

data ShowSelf a

showSelf :: (?loc :: CallStack, FindOp a (ShowSelf ()) (Match r), Op (ShowSelf ()) r a impl) => Ref a -> impl

data SetWidget a

setWidget :: (?loc :: CallStack, FindOp a (SetWidget ()) (Match r), Op (SetWidget ()) r a impl) => Ref a -> impl

data GetWidget a

getWidget :: (?loc :: CallStack, FindOp a (GetWidget ()) (Match r), Op (GetWidget ()) r a impl) => Ref a -> impl

data Child a

child :: (?loc :: CallStack, FindOp a (Child ()) (Match r), Op (Child ()) r a impl) => Ref a -> impl

data HasChildren a

hasChildren :: (?loc :: CallStack, FindOp a (HasChildren ()) (Match r), Op (HasChildren ()) r a impl) => Ref a -> impl

data FindChild a

findChild :: (?loc :: CallStack, FindOp a (FindChild ()) (Match r), Op (FindChild ()) r a impl) => Ref a -> impl

data RemoveChild a

removeChild :: (?loc :: CallStack, FindOp a (RemoveChild ()) (Match r), Op (RemoveChild ()) r a impl) => Ref a -> impl

data ClearChildren a

clearChildren :: (?loc :: CallStack, FindOp a (ClearChildren ()) (Match r), Op (ClearChildren ()) r a impl) => Ref a -> impl

data SwapChildren a

swapChildren :: (?loc :: CallStack, FindOp a (SwapChildren ()) (Match r), Op (SwapChildren ()) r a impl) => Ref a -> impl

data SwapChildrenByTreeItem a

swapChildrenByTreeItem :: (?loc :: CallStack, FindOp a (SwapChildrenByTreeItem ()) (Match r), Op (SwapChildrenByTreeItem ()) r a impl) => Ref a -> impl

data FindInChildren a

findInChildren :: (?loc :: CallStack, FindOp a (FindInChildren ()) (Match r), Op (FindInChildren ()) r a impl) => Ref a -> impl

data FindItem a

findItem :: (?loc :: CallStack, FindOp a (FindItem ()) (Match r), Op (FindItem ()) r a impl) => Ref a -> impl

data AddAt a

addAt :: (?loc :: CallStack, FindOp a (AddAt ()) (Match r), Op (AddAt ()) r a impl) => Ref a -> impl

data InsertAbove a

insertAbove :: (?loc :: CallStack, FindOp a (InsertAbove ()) (Match r), Op (InsertAbove ()) r a impl) => Ref a -> impl

data Deparent a

deparent :: (?loc :: CallStack, FindOp a (Deparent ()) (Match r), Op (Deparent ()) r a impl) => Ref a -> impl

data Reparent a

reparent :: (?loc :: CallStack, FindOp a (Reparent ()) (Match r), Op (Reparent ()) r a impl) => Ref a -> impl

data MoveTo a

moveTo :: (?loc :: CallStack, FindOp a (MoveTo ()) (Match r), Op (MoveTo ()) r a impl) => Ref a -> impl

data GetDepth a

getDepth :: (?loc :: CallStack, FindOp a (GetDepth ()) (Match r), Op (GetDepth ()) r a impl) => Ref a -> impl

data NextSibling a

nextSibling :: (?loc :: CallStack, FindOp a (NextSibling ()) (Match r), Op (NextSibling ()) r a impl) => Ref a -> impl

data PrevSibling a

prevSibling :: (?loc :: CallStack, FindOp a (PrevSibling ()) (Match r), Op (PrevSibling ()) r a impl) => Ref a -> impl

data UpdatePrevNext a

updatePrevNext :: (?loc :: CallStack, FindOp a (UpdatePrevNext ()) (Match r), Op (UpdatePrevNext ()) r a impl) => Ref a -> impl

data NextDisplayed a

nextDisplayed :: (?loc :: CallStack, FindOp a (NextDisplayed ()) (Match r), Op (NextDisplayed ()) r a impl) => Ref a -> impl

data PrevDisplayed a

prevDisplayed :: (?loc :: CallStack, FindOp a (PrevDisplayed ()) (Match r), Op (PrevDisplayed ()) r a impl) => Ref a -> impl

data Open a

open :: (?loc :: CallStack, FindOp a (Open ()) (Match r), Op (Open ()) r a impl) => Ref a -> impl

data Close a

close :: (?loc :: CallStack, FindOp a (Close ()) (Match r), Op (Close ()) r a impl) => Ref a -> impl

data IsOpen a

isOpen :: (?loc :: CallStack, FindOp a (IsOpen ()) (Match r), Op (IsOpen ()) r a impl) => Ref a -> impl

data IsClose a

isClose :: (?loc :: CallStack, FindOp a (IsClose ()) (Match r), Op (IsClose ()) r a impl) => Ref a -> impl

data OpenToggle a

openToggle :: (?loc :: CallStack, FindOp a (OpenToggle ()) (Match r), Op (OpenToggle ()) r a impl) => Ref a -> impl

data SelectWithVal a

selectWithVal :: (?loc :: CallStack, FindOp a (SelectWithVal ()) (Match r), Op (SelectWithVal ()) r a impl) => Ref a -> impl

data SelectToggle a

selectToggle :: (?loc :: CallStack, FindOp a (SelectToggle ()) (Match r), Op (SelectToggle ()) r a impl) => Ref a -> impl

data SelectAll a

selectAll :: (?loc :: CallStack, FindOp a (SelectAll ()) (Match r), Op (SelectAll ()) r a impl) => Ref a -> impl

data DeselectAll a

deselectAll :: (?loc :: CallStack, FindOp a (DeselectAll ()) (Match r), Op (DeselectAll ()) r a impl) => Ref a -> impl

data ActivateWith a

activateWith :: (?loc :: CallStack, FindOp a (ActivateWith ()) (Match r), Op (ActivateWith ()) r a impl) => Ref a -> impl

data IsActive a

isActive :: (?loc :: CallStack, FindOp a (IsActive ()) (Match r), Op (IsActive ()) r a impl) => Ref a -> impl

data IsVisible a

isVisible :: (?loc :: CallStack, FindOp a (IsVisible ()) (Match r), Op (IsVisible ()) r a impl) => Ref a -> impl

data VisibleR a

visibleR :: (?loc :: CallStack, FindOp a (VisibleR ()) (Match r), Op (VisibleR ()) r a impl) => Ref a -> impl

data FindClicked a

findClicked :: (?loc :: CallStack, FindOp a (FindClicked ()) (Match r), Op (FindClicked ()) r a impl) => Ref a -> impl

data EventOnCollapseIcon a

eventOnCollapseIcon :: (?loc :: CallStack, FindOp a (EventOnCollapseIcon ()) (Match r), Op (EventOnCollapseIcon ()) r a impl) => Ref a -> impl

data EventOnLabel a

eventOnLabel :: (?loc :: CallStack, FindOp a (EventOnLabel ()) (Match r), Op (EventOnLabel ()) r a impl) => Ref a -> impl

data IsRoot a

isRoot :: (?loc :: CallStack, FindOp a (IsRoot ()) (Match r), Op (IsRoot ()) r a impl) => Ref a -> impl

data LabelX a

labelX :: (?loc :: CallStack, FindOp a (LabelX ()) (Match r), Op (LabelX ()) r a impl) => Ref a -> impl

data LabelY a

labelY :: (?loc :: CallStack, FindOp a (LabelY ()) (Match r), Op (LabelY ()) r a impl) => Ref a -> impl

data LabelW a

labelW :: (?loc :: CallStack, FindOp a (LabelW ()) (Match r), Op (LabelW ()) r a impl) => Ref a -> impl

data LabelH a

labelH :: (?loc :: CallStack, FindOp a (LabelH ()) (Match r), Op (LabelH ()) r a impl) => Ref a -> impl

Tree

type Tree = CTree Group

data RootLabel a

rootLabel :: (?loc :: CallStack, FindOp a (RootLabel ()) (Match r), Op (RootLabel ()) r a impl) => Ref a -> impl

data Root a

root :: (?loc :: CallStack, FindOp a (Root ()) (Match r), Op (Root ()) r a impl) => Ref a -> impl

data ItemClicked a

itemClicked :: (?loc :: CallStack, FindOp a (ItemClicked ()) (Match r), Op (ItemClicked ()) r a impl) => Ref a -> impl

data FirstVisible a

firstVisible :: (?loc :: CallStack, FindOp a (FirstVisible ()) (Match r), Op (FirstVisible ()) r a impl) => Ref a -> impl

data NextItem a

nextItem :: (?loc :: CallStack, FindOp a (NextItem ()) (Match r), Op (NextItem ()) r a impl) => Ref a -> impl

data NextAfterItem a

nextAfterItem :: (?loc :: CallStack, FindOp a (NextAfterItem ()) (Match r), Op (NextAfterItem ()) r a impl) => Ref a -> impl

data PrevBeforeItem a

prevBeforeItem :: (?loc :: CallStack, FindOp a (PrevBeforeItem ()) (Match r), Op (PrevBeforeItem ()) r a impl) => Ref a -> impl

data GetLast a

getLast :: (?loc :: CallStack, FindOp a (GetLast ()) (Match r), Op (GetLast ()) r a impl) => Ref a -> impl

data LastVisible a

lastVisible :: (?loc :: CallStack, FindOp a (LastVisible ()) (Match r), Op (LastVisible ()) r a impl) => Ref a -> impl

data FirstSelectedItem a

firstSelectedItem :: (?loc :: CallStack, FindOp a (FirstSelectedItem ()) (Match r), Op (FirstSelectedItem ()) r a impl) => Ref a -> impl

data LastSelectedItem a

lastSelectedItem :: (?loc :: CallStack, FindOp a (LastSelectedItem ()) (Match r), Op (LastSelectedItem ()) r a impl) => Ref a -> impl

data NextSelectedItem a

nextSelectedItem :: (?loc :: CallStack, FindOp a (NextSelectedItem ()) (Match r), Op (NextSelectedItem ()) r a impl) => Ref a -> impl

data NextSelectedItemAfterItem a

nextSelectedItemAfterItem :: (?loc :: CallStack, FindOp a (NextSelectedItemAfterItem ()) (Match r), Op (NextSelectedItemAfterItem ()) r a impl) => Ref a -> impl

data OpenAndCallback a

openAndCallback :: (?loc :: CallStack, FindOp a (OpenAndCallback ()) (Match r), Op (OpenAndCallback ()) r a impl) => Ref a -> impl

data OpenToggleAndCallback a

openToggleAndCallback :: (?loc :: CallStack, FindOp a (OpenToggleAndCallback ()) (Match r), Op (OpenToggleAndCallback ()) r a impl) => Ref a -> impl

data TreeMenuItemLocator a

treeMenuItemLocator :: (?loc :: CallStack, FindOp a (TreeMenuItemLocator ()) (Match r), Op (TreeMenuItemLocator ()) r a impl) => Ref a -> impl

data CloseAndCallback a

closeAndCallback :: (?loc :: CallStack, FindOp a (CloseAndCallback ()) (Match r), Op (CloseAndCallback ()) r a impl) => Ref a -> impl

data SelectAndCallback a

selectAndCallback :: (?loc :: CallStack, FindOp a (SelectAndCallback ()) (Match r), Op (SelectAndCallback ()) r a impl) => Ref a -> impl

data SelectToggleAndCallback a

selectToggleAndCallback :: (?loc :: CallStack, FindOp a (SelectToggleAndCallback ()) (Match r), Op (SelectToggleAndCallback ()) r a impl) => Ref a -> impl

data SelectAllAndCallback a

selectAllAndCallback :: (?loc :: CallStack, FindOp a (SelectAllAndCallback ()) (Match r), Op (SelectAllAndCallback ()) r a impl) => Ref a -> impl

data DeselectAllAndCallback a

deselectAllAndCallback :: (?loc :: CallStack, FindOp a (DeselectAllAndCallback ()) (Match r), Op (DeselectAllAndCallback ()) r a impl) => Ref a -> impl

data SetItemFocus a

setItemFocus :: (?loc :: CallStack, FindOp a (SetItemFocus ()) (Match r), Op (SetItemFocus ()) r a impl) => Ref a -> impl

data GetItemFocus a

getItemFocus :: (?loc :: CallStack, FindOp a (GetItemFocus ()) (Match r), Op (GetItemFocus ()) r a impl) => Ref a -> impl

data IsSelectedWithItem a

isSelectedWithItem :: (?loc :: CallStack, FindOp a (IsSelectedWithItem ()) (Match r), Op (IsSelectedWithItem ()) r a impl) => Ref a -> impl

data SetItemLabelfont a

setItemLabelfont :: (?loc :: CallStack, FindOp a (SetItemLabelfont ()) (Match r), Op (SetItemLabelfont ()) r a impl) => Ref a -> impl

data GetItemLabelfgcolor a

getItemLabelfgcolor :: (?loc :: CallStack, FindOp a (GetItemLabelfgcolor ()) (Match r), Op (GetItemLabelfgcolor ()) r a impl) => Ref a -> impl

data Selectmode a

selectmode :: (?loc :: CallStack, FindOp a (Selectmode ()) (Match r), Op (Selectmode ()) r a impl) => Ref a -> impl

data ShowItemWithYoff a

showItemWithYoff :: (?loc :: CallStack, FindOp a (ShowItemWithYoff ()) (Match r), Op (ShowItemWithYoff ()) r a impl) => Ref a -> impl

data ShowItemTop a

showItemTop :: (?loc :: CallStack, FindOp a (ShowItemTop ()) (Match r), Op (ShowItemTop ()) r a impl) => Ref a -> impl

data ShowItemMiddle a

showItemMiddle :: (?loc :: CallStack, FindOp a (ShowItemMiddle ()) (Match r), Op (ShowItemMiddle ()) r a impl) => Ref a -> impl

data ShowItemBottom a

showItemBottom :: (?loc :: CallStack, FindOp a (ShowItemBottom ()) (Match r), Op (ShowItemBottom ()) r a impl) => Ref a -> impl

data Display a

display :: (?loc :: CallStack, FindOp a (Display ()) (Match r), Op (Display ()) r a impl) => Ref a -> impl

data GetVposition a

getVposition :: (?loc :: CallStack, FindOp a (GetVposition ()) (Match r), Op (GetVposition ()) r a impl) => Ref a -> impl

data SetVposition a

setVposition :: (?loc :: CallStack, FindOp a (SetVposition ()) (Match r), Op (SetVposition ()) r a impl) => Ref a -> impl

data IsScrollbar a

isScrollbar :: (?loc :: CallStack, FindOp a (IsScrollbar ()) (Match r), Op (IsScrollbar ()) r a impl) => Ref a -> impl

data IsVscrollVisible a

isVscrollVisible :: (?loc :: CallStack, FindOp a (IsVscrollVisible ()) (Match r), Op (IsVscrollVisible ()) r a impl) => Ref a -> impl

data SetCallbackItem a

setCallbackItem :: (?loc :: CallStack, FindOp a (SetCallbackItem ()) (Match r), Op (SetCallbackItem ()) r a impl) => Ref a -> impl

data GetCallbackItem a

getCallbackItem :: (?loc :: CallStack, FindOp a (GetCallbackItem ()) (Match r), Op (GetCallbackItem ()) r a impl) => Ref a -> impl

data SetCallbackReason a

setCallbackReason :: (?loc :: CallStack, FindOp a (SetCallbackReason ()) (Match r), Op (SetCallbackReason ()) r a impl) => Ref a -> impl

data GetCallbackReason a

getCallbackReason :: (?loc :: CallStack, FindOp a (GetCallbackReason ()) (Match r), Op (GetCallbackReason ()) r a impl) => Ref a -> impl

TextSelection

type TextSelection = CTextSelection Base

data Update a

update :: (?loc :: CallStack, FindOp a (Update ()) (Match r), Op (Update ()) r a impl) => Ref a -> impl

data Start a

start :: (?loc :: CallStack, FindOp a (Start ()) (Match r), Op (Start ()) r a impl) => Ref a -> impl

data SetSelected a

setSelected :: (?loc :: CallStack, FindOp a (SetSelected ()) (Match r), Op (SetSelected ()) r a impl) => Ref a -> impl

data Includes a

includes :: (?loc :: CallStack, FindOp a (Includes ()) (Match r), Op (Includes ()) r a impl) => Ref a -> impl

TextBuffer

type TextBuffer = CTextBuffer Base

data InputFileWasTranscoded a

inputFileWasTranscoded :: (?loc :: CallStack, FindOp a (InputFileWasTranscoded ()) (Match r), Op (InputFileWasTranscoded ()) r a impl) => Ref a -> impl

data FileEncodingWarningMessage a

fileEncodingWarningMessage :: (?loc :: CallStack, FindOp a (FileEncodingWarningMessage ()) (Match r), Op (FileEncodingWarningMessage ()) r a impl) => Ref a -> impl

data GetLength a

getLength :: (?loc :: CallStack, FindOp a (GetLength ()) (Match r), Op (GetLength ()) r a impl) => Ref a -> impl

data TextRange a

textRange :: (?loc :: CallStack, FindOp a (TextRange ()) (Match r), Op (TextRange ()) r a impl) => Ref a -> impl

data CharAt a

charAt :: (?loc :: CallStack, FindOp a (CharAt ()) (Match r), Op (CharAt ()) r a impl) => Ref a -> impl

data ByteAt a

byteAt :: (?loc :: CallStack, FindOp a (ByteAt ()) (Match r), Op (ByteAt ()) r a impl) => Ref a -> impl

data AppendToBuffer a

appendToBuffer :: (?loc :: CallStack, FindOp a (AppendToBuffer ()) (Match r), Op (AppendToBuffer ()) r a impl) => Ref a -> impl

data CanUndo a

canUndo :: (?loc :: CallStack, FindOp a (CanUndo ()) (Match r), Op (CanUndo ()) r a impl) => Ref a -> impl

data Insertfile a

insertfile :: (?loc :: CallStack, FindOp a (Insertfile ()) (Match r), Op (Insertfile ()) r a impl) => Ref a -> impl

data InsertfileWithBuflen a

insertfileWithBuflen :: (?loc :: CallStack, FindOp a (InsertfileWithBuflen ()) (Match r), Op (InsertfileWithBuflen ()) r a impl) => Ref a -> impl

data Appendfile a

appendfile :: (?loc :: CallStack, FindOp a (Appendfile ()) (Match r), Op (Appendfile ()) r a impl) => Ref a -> impl

data AppendfileWithBuflen a

appendfileWithBuflen :: (?loc :: CallStack, FindOp a (AppendfileWithBuflen ()) (Match r), Op (AppendfileWithBuflen ()) r a impl) => Ref a -> impl

data Loadfile a

loadfile :: (?loc :: CallStack, FindOp a (Loadfile ()) (Match r), Op (Loadfile ()) r a impl) => Ref a -> impl

data LoadfileWithBuflen a

loadfileWithBuflen :: (?loc :: CallStack, FindOp a (LoadfileWithBuflen ()) (Match r), Op (LoadfileWithBuflen ()) r a impl) => Ref a -> impl

data Outputfile a

outputfile :: (?loc :: CallStack, FindOp a (Outputfile ()) (Match r), Op (Outputfile ()) r a impl) => Ref a -> impl

data OutputfileWithBuflen a

outputfileWithBuflen :: (?loc :: CallStack, FindOp a (OutputfileWithBuflen ()) (Match r), Op (OutputfileWithBuflen ()) r a impl) => Ref a -> impl

data Savefile a

savefile :: (?loc :: CallStack, FindOp a (Savefile ()) (Match r), Op (Savefile ()) r a impl) => Ref a -> impl

data SavefileWithBuflen a

savefileWithBuflen :: (?loc :: CallStack, FindOp a (SavefileWithBuflen ()) (Match r), Op (SavefileWithBuflen ()) r a impl) => Ref a -> impl

data GetTabDistance a

getTabDistance :: (?loc :: CallStack, FindOp a (GetTabDistance ()) (Match r), Op (GetTabDistance ()) r a impl) => Ref a -> impl

data SetTabDistance a

setTabDistance :: (?loc :: CallStack, FindOp a (SetTabDistance ()) (Match r), Op (SetTabDistance ()) r a impl) => Ref a -> impl

data Unselect a

unselect :: (?loc :: CallStack, FindOp a (Unselect ()) (Match r), Op (Unselect ()) r a impl) => Ref a -> impl

data SelectionPosition a

selectionPosition :: (?loc :: CallStack, FindOp a (SelectionPosition ()) (Match r), Op (SelectionPosition ()) r a impl) => Ref a -> impl

data SelectionText a

selectionText :: (?loc :: CallStack, FindOp a (SelectionText ()) (Match r), Op (SelectionText ()) r a impl) => Ref a -> impl

data RemoveSelection a

removeSelection :: (?loc :: CallStack, FindOp a (RemoveSelection ()) (Match r), Op (RemoveSelection ()) r a impl) => Ref a -> impl

data ReplaceSelection a

replaceSelection :: (?loc :: CallStack, FindOp a (ReplaceSelection ()) (Match r), Op (ReplaceSelection ()) r a impl) => Ref a -> impl

data SecondarySelect a

secondarySelect :: (?loc :: CallStack, FindOp a (SecondarySelect ()) (Match r), Op (SecondarySelect ()) r a impl) => Ref a -> impl

data SecondarySelected a

secondarySelected :: (?loc :: CallStack, FindOp a (SecondarySelected ()) (Match r), Op (SecondarySelected ()) r a impl) => Ref a -> impl

data SecondaryUnselect a

secondaryUnselect :: (?loc :: CallStack, FindOp a (SecondaryUnselect ()) (Match r), Op (SecondaryUnselect ()) r a impl) => Ref a -> impl

data SecondarySelectionPosition a

secondarySelectionPosition :: (?loc :: CallStack, FindOp a (SecondarySelectionPosition ()) (Match r), Op (SecondarySelectionPosition ()) r a impl) => Ref a -> impl

data SecondarySelectionText a

secondarySelectionText :: (?loc :: CallStack, FindOp a (SecondarySelectionText ()) (Match r), Op (SecondarySelectionText ()) r a impl) => Ref a -> impl

data RemoveSecondarySelection a

removeSecondarySelection :: (?loc :: CallStack, FindOp a (RemoveSecondarySelection ()) (Match r), Op (RemoveSecondarySelection ()) r a impl) => Ref a -> impl

data ReplaceSecondarySelection a

replaceSecondarySelection :: (?loc :: CallStack, FindOp a (ReplaceSecondarySelection ()) (Match r), Op (ReplaceSecondarySelection ()) r a impl) => Ref a -> impl

data GetHighlight a

getHighlight :: (?loc :: CallStack, FindOp a (GetHighlight ()) (Match r), Op (GetHighlight ()) r a impl) => Ref a -> impl

data SetHighlight a

setHighlight :: (?loc :: CallStack, FindOp a (SetHighlight ()) (Match r), Op (SetHighlight ()) r a impl) => Ref a -> impl

data Unhighlight a

unhighlight :: (?loc :: CallStack, FindOp a (Unhighlight ()) (Match r), Op (Unhighlight ()) r a impl) => Ref a -> impl

data HighlightPosition a

highlightPosition :: (?loc :: CallStack, FindOp a (HighlightPosition ()) (Match r), Op (HighlightPosition ()) r a impl) => Ref a -> impl

data HighlightText a

highlightText :: (?loc :: CallStack, FindOp a (HighlightText ()) (Match r), Op (HighlightText ()) r a impl) => Ref a -> impl

data AddModifyCallback a

addModifyCallback :: (?loc :: CallStack, FindOp a (AddModifyCallback ()) (Match r), Op (AddModifyCallback ()) r a impl) => Ref a -> impl

data RemoveModifyCallback a

removeModifyCallback :: (?loc :: CallStack, FindOp a (RemoveModifyCallback ()) (Match r), Op (RemoveModifyCallback ()) r a impl) => Ref a -> impl

data CallModifyCallbacks a

callModifyCallbacks :: (?loc :: CallStack, FindOp a (CallModifyCallbacks ()) (Match r), Op (CallModifyCallbacks ()) r a impl) => Ref a -> impl

data AddPredeleteCallback a

addPredeleteCallback :: (?loc :: CallStack, FindOp a (AddPredeleteCallback ()) (Match r), Op (AddPredeleteCallback ()) r a impl) => Ref a -> impl

data RemovePredeleteCallback a

removePredeleteCallback :: (?loc :: CallStack, FindOp a (RemovePredeleteCallback ()) (Match r), Op (RemovePredeleteCallback ()) r a impl) => Ref a -> impl

data CallPredeleteCallbacks a

callPredeleteCallbacks :: (?loc :: CallStack, FindOp a (CallPredeleteCallbacks ()) (Match r), Op (CallPredeleteCallbacks ()) r a impl) => Ref a -> impl

data LineText a

lineText :: (?loc :: CallStack, FindOp a (LineText ()) (Match r), Op (LineText ()) r a impl) => Ref a -> impl

data LineStart a

lineStart :: (?loc :: CallStack, FindOp a (LineStart ()) (Match r), Op (LineStart ()) r a impl) => Ref a -> impl

data LineEnd a

lineEnd :: (?loc :: CallStack, FindOp a (LineEnd ()) (Match r), Op (LineEnd ()) r a impl) => Ref a -> impl

data WordStart a

wordStart :: (?loc :: CallStack, FindOp a (WordStart ()) (Match r), Op (WordStart ()) r a impl) => Ref a -> impl

data WordEnd a

wordEnd :: (?loc :: CallStack, FindOp a (WordEnd ()) (Match r), Op (WordEnd ()) r a impl) => Ref a -> impl

data CountDisplayedCharacters a

countDisplayedCharacters :: (?loc :: CallStack, FindOp a (CountDisplayedCharacters ()) (Match r), Op (CountDisplayedCharacters ()) r a impl) => Ref a -> impl

data SkipDisplayedCharacters a

skipDisplayedCharacters :: (?loc :: CallStack, FindOp a (SkipDisplayedCharacters ()) (Match r), Op (SkipDisplayedCharacters ()) r a impl) => Ref a -> impl

data CountLines a

countLines :: (?loc :: CallStack, FindOp a (CountLines ()) (Match r), Op (CountLines ()) r a impl) => Ref a -> impl

data SkipLines a

skipLines :: (?loc :: CallStack, FindOp a (SkipLines ()) (Match r), Op (SkipLines ()) r a impl) => Ref a -> impl

data RewindLines a

rewindLines :: (?loc :: CallStack, FindOp a (RewindLines ()) (Match r), Op (RewindLines ()) r a impl) => Ref a -> impl

data FindcharForward a

findcharForward :: (?loc :: CallStack, FindOp a (FindcharForward ()) (Match r), Op (FindcharForward ()) r a impl) => Ref a -> impl

data FindcharBackward a

findcharBackward :: (?loc :: CallStack, FindOp a (FindcharBackward ()) (Match r), Op (FindcharBackward ()) r a impl) => Ref a -> impl

data SearchForwardWithMatchcase a

searchForwardWithMatchcase :: (?loc :: CallStack, FindOp a (SearchForwardWithMatchcase ()) (Match r), Op (SearchForwardWithMatchcase ()) r a impl) => Ref a -> impl

data SearchBackwardWithMatchcase a

searchBackwardWithMatchcase :: (?loc :: CallStack, FindOp a (SearchBackwardWithMatchcase ()) (Match r), Op (SearchBackwardWithMatchcase ()) r a impl) => Ref a -> impl

data PrimarySelection a

primarySelection :: (?loc :: CallStack, FindOp a (PrimarySelection ()) (Match r), Op (PrimarySelection ()) r a impl) => Ref a -> impl

data SecondarySelection a

secondarySelection :: (?loc :: CallStack, FindOp a (SecondarySelection ()) (Match r), Op (SecondarySelection ()) r a impl) => Ref a -> impl

data HighlightSelection a

highlightSelection :: (?loc :: CallStack, FindOp a (HighlightSelection ()) (Match r), Op (HighlightSelection ()) r a impl) => Ref a -> impl

data PrevChar a

prevChar :: (?loc :: CallStack, FindOp a (PrevChar ()) (Match r), Op (PrevChar ()) r a impl) => Ref a -> impl

data PrevCharClipped a

prevCharClipped :: (?loc :: CallStack, FindOp a (PrevCharClipped ()) (Match r), Op (PrevCharClipped ()) r a impl) => Ref a -> impl

data NextChar a

nextChar :: (?loc :: CallStack, FindOp a (NextChar ()) (Match r), Op (NextChar ()) r a impl) => Ref a -> impl

data NextCharClipped a

nextCharClipped :: (?loc :: CallStack, FindOp a (NextCharClipped ()) (Match r), Op (NextCharClipped ()) r a impl) => Ref a -> impl

data Utf8Align a

utf8Align :: (?loc :: CallStack, FindOp a (Utf8Align ()) (Match r), Op (Utf8Align ()) r a impl) => Ref a -> impl

TextDisplay,

type TextDisplay = CTextDisplay Group

data SetBuffer a

setBuffer :: (?loc :: CallStack, FindOp a (SetBuffer ()) (Match r), Op (SetBuffer ()) r a impl) => Ref a -> impl

data GetBuffer a

getBuffer :: (?loc :: CallStack, FindOp a (GetBuffer ()) (Match r), Op (GetBuffer ()) r a impl) => Ref a -> impl

data RedisplayRange a

redisplayRange :: (?loc :: CallStack, FindOp a (RedisplayRange ()) (Match r), Op (RedisplayRange ()) r a impl) => Ref a -> impl

data Scroll a

scroll :: (?loc :: CallStack, FindOp a (Scroll ()) (Match r), Op (Scroll ()) r a impl) => Ref a -> impl

data Overstrike a

overstrike :: (?loc :: CallStack, FindOp a (Overstrike ()) (Match r), Op (Overstrike ()) r a impl) => Ref a -> impl

data SetInsertPosition a

setInsertPosition :: (?loc :: CallStack, FindOp a (SetInsertPosition ()) (Match r), Op (SetInsertPosition ()) r a impl) => Ref a -> impl

data GetInsertPosition a

getInsertPosition :: (?loc :: CallStack, FindOp a (GetInsertPosition ()) (Match r), Op (GetInsertPosition ()) r a impl) => Ref a -> impl

data PositionToXy a

positionToXy :: (?loc :: CallStack, FindOp a (PositionToXy ()) (Match r), Op (PositionToXy ()) r a impl) => Ref a -> impl

data InSelection a

inSelection :: (?loc :: CallStack, FindOp a (InSelection ()) (Match r), Op (InSelection ()) r a impl) => Ref a -> impl

data ShowInsertPosition a

showInsertPosition :: (?loc :: CallStack, FindOp a (ShowInsertPosition ()) (Match r), Op (ShowInsertPosition ()) r a impl) => Ref a -> impl

data MoveRight a

moveRight :: (?loc :: CallStack, FindOp a (MoveRight ()) (Match r), Op (MoveRight ()) r a impl) => Ref a -> impl

data MoveLeft a

moveLeft :: (?loc :: CallStack, FindOp a (MoveLeft ()) (Match r), Op (MoveLeft ()) r a impl) => Ref a -> impl

data MoveUp a

moveUp :: (?loc :: CallStack, FindOp a (MoveUp ()) (Match r), Op (MoveUp ()) r a impl) => Ref a -> impl

data MoveDown a

moveDown :: (?loc :: CallStack, FindOp a (MoveDown ()) (Match r), Op (MoveDown ()) r a impl) => Ref a -> impl

data NextWord a

nextWord :: (?loc :: CallStack, FindOp a (NextWord ()) (Match r), Op (NextWord ()) r a impl) => Ref a -> impl

data PreviousWord a

previousWord :: (?loc :: CallStack, FindOp a (PreviousWord ()) (Match r), Op (PreviousWord ()) r a impl) => Ref a -> impl

data ShowCursor a

showCursor :: (?loc :: CallStack, FindOp a (ShowCursor ()) (Match r), Op (ShowCursor ()) r a impl) => Ref a -> impl

data SetCursorStyle a

setCursorStyle :: (?loc :: CallStack, FindOp a (SetCursorStyle ()) (Match r), Op (SetCursorStyle ()) r a impl) => Ref a -> impl

data GetScrollbarAlign a

getScrollbarAlign :: (?loc :: CallStack, FindOp a (GetScrollbarAlign ()) (Match r), Op (GetScrollbarAlign ()) r a impl) => Ref a -> impl

data SetScrollbarAlign a

setScrollbarAlign :: (?loc :: CallStack, FindOp a (SetScrollbarAlign ()) (Match r), Op (SetScrollbarAlign ()) r a impl) => Ref a -> impl

data HighlightData a

highlightData :: (?loc :: CallStack, FindOp a (HighlightData ()) (Match r), Op (HighlightData ()) r a impl) => Ref a -> impl

data PositionStyle a

positionStyle :: (?loc :: CallStack, FindOp a (PositionStyle ()) (Match r), Op (PositionStyle ()) r a impl) => Ref a -> impl

data XToCol a

xToCol :: (?loc :: CallStack, FindOp a (XToCol ()) (Match r), Op (XToCol ()) r a impl) => Ref a -> impl

data ColToX a

colToX :: (?loc :: CallStack, FindOp a (ColToX ()) (Match r), Op (ColToX ()) r a impl) => Ref a -> impl

data SetLinenumberWidth a

setLinenumberWidth :: (?loc :: CallStack, FindOp a (SetLinenumberWidth ()) (Match r), Op (SetLinenumberWidth ()) r a impl) => Ref a -> impl

data GetLinenumberWidth a

getLinenumberWidth :: (?loc :: CallStack, FindOp a (GetLinenumberWidth ()) (Match r), Op (GetLinenumberWidth ()) r a impl) => Ref a -> impl

data SetLinenumberFont a

setLinenumberFont :: (?loc :: CallStack, FindOp a (SetLinenumberFont ()) (Match r), Op (SetLinenumberFont ()) r a impl) => Ref a -> impl

data GetLinenumberFont a

getLinenumberFont :: (?loc :: CallStack, FindOp a (GetLinenumberFont ()) (Match r), Op (GetLinenumberFont ()) r a impl) => Ref a -> impl

data SetLinenumberSize a

setLinenumberSize :: (?loc :: CallStack, FindOp a (SetLinenumberSize ()) (Match r), Op (SetLinenumberSize ()) r a impl) => Ref a -> impl

data GetLinenumberSize a

getLinenumberSize :: (?loc :: CallStack, FindOp a (GetLinenumberSize ()) (Match r), Op (GetLinenumberSize ()) r a impl) => Ref a -> impl

data SetLinenumberFgcolor a

setLinenumberFgcolor :: (?loc :: CallStack, FindOp a (SetLinenumberFgcolor ()) (Match r), Op (SetLinenumberFgcolor ()) r a impl) => Ref a -> impl

data GetLinenumberFgcolor a

getLinenumberFgcolor :: (?loc :: CallStack, FindOp a (GetLinenumberFgcolor ()) (Match r), Op (GetLinenumberFgcolor ()) r a impl) => Ref a -> impl

data SetLinenumberBgcolor a

setLinenumberBgcolor :: (?loc :: CallStack, FindOp a (SetLinenumberBgcolor ()) (Match r), Op (SetLinenumberBgcolor ()) r a impl) => Ref a -> impl

data GetLinenumberBgcolor a

getLinenumberBgcolor :: (?loc :: CallStack, FindOp a (GetLinenumberBgcolor ()) (Match r), Op (GetLinenumberBgcolor ()) r a impl) => Ref a -> impl

data SetLinenumberAlign a

setLinenumberAlign :: (?loc :: CallStack, FindOp a (SetLinenumberAlign ()) (Match r), Op (SetLinenumberAlign ()) r a impl) => Ref a -> impl

data GetLinenumberAlign a

getLinenumberAlign :: (?loc :: CallStack, FindOp a (GetLinenumberAlign ()) (Match r), Op (GetLinenumberAlign ()) r a impl) => Ref a -> impl

data SetLinenumberFormat a

setLinenumberFormat :: (?loc :: CallStack, FindOp a (SetLinenumberFormat ()) (Match r), Op (SetLinenumberFormat ()) r a impl) => Ref a -> impl

data GetLinenumberFormat a

getLinenumberFormat :: (?loc :: CallStack, FindOp a (GetLinenumberFormat ()) (Match r), Op (GetLinenumberFormat ()) r a impl) => Ref a -> impl

TextEditor

type TextEditor = CTextEditor TextDisplay

data SetInsertMode a

setInsertMode :: (?loc :: CallStack, FindOp a (SetInsertMode ()) (Match r), Op (SetInsertMode ()) r a impl) => Ref a -> impl

data GetInsertMode a

getInsertMode :: (?loc :: CallStack, FindOp a (GetInsertMode ()) (Match r), Op (GetInsertMode ()) r a impl) => Ref a -> impl

data GetDefaultKeyBindings a

getDefaultKeyBindings :: (?loc :: CallStack, FindOp a (GetDefaultKeyBindings ()) (Match r), Op (GetDefaultKeyBindings ()) r a impl) => Ref a -> impl

data ReplaceKeyBindings a

replaceKeyBindings :: (?loc :: CallStack, FindOp a (ReplaceKeyBindings ()) (Match r), Op (ReplaceKeyBindings ()) r a impl) => Ref a -> impl

NativeFileChooser

type NativeFileChooser = CNativeFileChooser Base

data SetOptions a

setOptions :: (?loc :: CallStack, FindOp a (SetOptions ()) (Match r), Op (SetOptions ()) r a impl) => Ref a -> impl

data GetOptions a

getOptions :: (?loc :: CallStack, FindOp a (GetOptions ()) (Match r), Op (GetOptions ()) r a impl) => Ref a -> impl

data GetFilename a

getFilename :: (?loc :: CallStack, FindOp a (GetFilename ()) (Match r), Op (GetFilename ()) r a impl) => Ref a -> impl

data GetFilenameAt a

getFilenameAt :: (?loc :: CallStack, FindOp a (GetFilenameAt ()) (Match r), Op (GetFilenameAt ()) r a impl) => Ref a -> impl

data SetDirectory a

setDirectory :: (?loc :: CallStack, FindOp a (SetDirectory ()) (Match r), Op (SetDirectory ()) r a impl) => Ref a -> impl

data GetDirectory a

getDirectory :: (?loc :: CallStack, FindOp a (GetDirectory ()) (Match r), Op (GetDirectory ()) r a impl) => Ref a -> impl

data SetTitle a

setTitle :: (?loc :: CallStack, FindOp a (SetTitle ()) (Match r), Op (SetTitle ()) r a impl) => Ref a -> impl

data GetTitle a

getTitle :: (?loc :: CallStack, FindOp a (GetTitle ()) (Match r), Op (GetTitle ()) r a impl) => Ref a -> impl

data GetFilter a

getFilter :: (?loc :: CallStack, FindOp a (GetFilter ()) (Match r), Op (GetFilter ()) r a impl) => Ref a -> impl

data SetFilter a

setFilter :: (?loc :: CallStack, FindOp a (SetFilter ()) (Match r), Op (SetFilter ()) r a impl) => Ref a -> impl

data Filters a

filters :: (?loc :: CallStack, FindOp a (Filters ()) (Match r), Op (Filters ()) r a impl) => Ref a -> impl

data SetFilterValue a

setFilterValue :: (?loc :: CallStack, FindOp a (SetFilterValue ()) (Match r), Op (SetFilterValue ()) r a impl) => Ref a -> impl

data GetFilterValue a

getFilterValue :: (?loc :: CallStack, FindOp a (GetFilterValue ()) (Match r), Op (GetFilterValue ()) r a impl) => Ref a -> impl

data SetPresetFile a

setPresetFile :: (?loc :: CallStack, FindOp a (SetPresetFile ()) (Match r), Op (SetPresetFile ()) r a impl) => Ref a -> impl

data GetPresetFile a

getPresetFile :: (?loc :: CallStack, FindOp a (GetPresetFile ()) (Match r), Op (GetPresetFile ()) r a impl) => Ref a -> impl

data GetErrmsg a

getErrmsg :: (?loc :: CallStack, FindOp a (GetErrmsg ()) (Match r), Op (GetErrmsg ()) r a impl) => Ref a -> impl

Tile

type Tile = CTile Group

type Pack = CPack Group

setSpacing :: (?loc :: CallStack, FindOp a (SetSpacing ()) (Match r), Op (SetSpacing ()) r a impl) => Ref a -> impl

data SetSpacing a

getSpacing :: (?loc :: CallStack, FindOp a (GetSpacing ()) (Match r), Op (GetSpacing ()) r a impl) => Ref a -> impl

data GetSpacing a

isHorizontal :: (?loc :: CallStack, FindOp a (IsHorizontal ()) (Match r), Op (IsHorizontal ()) r a impl) => Ref a -> impl

data IsHorizontal a

type Scrolled = CScrolled Group

data ScrollTo a

scrollTo :: (?loc :: CallStack, FindOp a (ScrollTo ()) (Match r), Op (ScrollTo ()) r a impl) => Ref a -> impl

data Xposition a

xposition :: (?loc :: CallStack, FindOp a (Xposition ()) (Match r), Op (Xposition ()) r a impl) => Ref a -> impl

data Yposition a

yposition :: (?loc :: CallStack, FindOp a (Yposition ()) (Match r), Op (Yposition ()) r a impl) => Ref a -> impl

type Tabs = CTabs Group

data GetPush a

getPush :: (?loc :: CallStack, FindOp a (GetPush ()) (Match r), Op (GetPush ()) r a impl) => Ref a -> impl

data SetPush a

setPush :: (?loc :: CallStack, FindOp a (SetPush ()) (Match r), Op (SetPush ()) r a impl) => Ref a -> impl

data Which a

which :: (?loc :: CallStack, FindOp a (Which ()) (Match r), Op (Which ()) r a impl) => Ref a -> impl

data ClientArea a

clientArea :: (?loc :: CallStack, FindOp a (ClientArea ()) (Match r), Op (ClientArea ()) r a impl) => Ref a -> impl

type Spinner = CSpinner Group

data GetFormat a

getFormat :: (?loc :: CallStack, FindOp a (GetFormat ()) (Match r), Op (GetFormat ()) r a impl) => Ref a -> impl

type ColorChooser = CColorChooser Group

data GetHue a

getHue :: (?loc :: CallStack, FindOp a (GetHue ()) (Match r), Op (GetHue ()) r a impl) => Ref a -> impl

data GetSaturation a

getSaturation :: (?loc :: CallStack, FindOp a (GetSaturation ()) (Match r), Op (GetSaturation ()) r a impl) => Ref a -> impl

data GetR a

getR :: (?loc :: CallStack, FindOp a (GetR ()) (Match r), Op (GetR ()) r a impl) => Ref a -> impl

data GetG a

getG :: (?loc :: CallStack, FindOp a (GetG ()) (Match r), Op (GetG ()) r a impl) => Ref a -> impl

data GetB a

getB :: (?loc :: CallStack, FindOp a (GetB ()) (Match r), Op (GetB ()) r a impl) => Ref a -> impl

data SetHsv a

setHsv :: (?loc :: CallStack, FindOp a (SetHsv ()) (Match r), Op (SetHsv ()) r a impl) => Ref a -> impl

data SetRgb a

setRgb :: (?loc :: CallStack, FindOp a (SetRgb ()) (Match r), Op (SetRgb ()) r a impl) => Ref a -> impl