fltkhs-0.5.4.1: FLTK bindings

Safe HaskellNone
LanguageHaskell2010

Graphics.UI.FLTK.LowLevel.Hierarchy

Contents

Synopsis

Region

type Region = CRegion Base Source #

GlContext

type GlContext = CGlContext Base Source #

Widget

type Widget = CWidget Base Source #

destroy :: (HasCallStack, Match r ~ FindOp a a (Destroy ()), Op (Destroy ()) r a impl) => Ref a -> impl Source #

data Handle a Source #

handle :: (HasCallStack, Match r ~ FindOp a a (Handle ()), Op (Handle ()) r a impl) => Ref a -> impl Source #

getParent :: (HasCallStack, Match r ~ FindOp a a (GetParent ()), Op (GetParent ()) r a impl) => Ref a -> impl Source #

setParent :: (HasCallStack, Match r ~ FindOp a a (SetParent ()), Op (SetParent ()) r a impl) => Ref a -> impl Source #

getType_ :: (HasCallStack, Match r ~ FindOp a a (GetType_ ()), Op (GetType_ ()) r a impl) => Ref a -> impl Source #

setType :: (HasCallStack, Match r ~ FindOp a a (SetType ()), Op (SetType ()) r a impl) => Ref a -> impl Source #

drawLabel :: (HasCallStack, Match r ~ FindOp a a (DrawLabel ()), Op (DrawLabel ()) r a impl) => Ref a -> impl Source #

data GetX a Source #

getX :: (HasCallStack, Match r ~ FindOp a a (GetX ()), Op (GetX ()) r a impl) => Ref a -> impl Source #

data GetY a Source #

getY :: (HasCallStack, Match r ~ FindOp a a (GetY ()), Op (GetY ()) r a impl) => Ref a -> impl Source #

data GetW a Source #

getW :: (HasCallStack, Match r ~ FindOp a a (GetW ()), Op (GetW ()) r a impl) => Ref a -> impl Source #

data GetH a Source #

getH :: (HasCallStack, Match r ~ FindOp a a (GetH ()), Op (GetH ()) r a impl) => Ref a -> impl Source #

getRectangle :: (HasCallStack, Match r ~ FindOp a a (GetRectangle ()), Op (GetRectangle ()) r a impl) => Ref a -> impl Source #

setAlign :: (HasCallStack, Match r ~ FindOp a a (SetAlign ()), Op (SetAlign ()) r a impl) => Ref a -> impl Source #

getAlign :: (HasCallStack, Match r ~ FindOp a a (GetAlign ()), Op (GetAlign ()) r a impl) => Ref a -> impl Source #

data GetBox a Source #

getBox :: (HasCallStack, Match r ~ FindOp a a (GetBox ()), Op (GetBox ()) r a impl) => Ref a -> impl Source #

data SetBox a Source #

setBox :: (HasCallStack, Match r ~ FindOp a a (SetBox ()), Op (SetBox ()) r a impl) => Ref a -> impl Source #

getColor :: (HasCallStack, Match r ~ FindOp a a (GetColor ()), Op (GetColor ()) r a impl) => Ref a -> impl Source #

setColor :: (HasCallStack, Match r ~ FindOp a a (SetColor ()), Op (SetColor ()) r a impl) => Ref a -> impl Source #

getLabel :: (HasCallStack, Match r ~ FindOp a a (GetLabel ()), Op (GetLabel ()) r a impl) => Ref a -> impl Source #

copyLabel :: (HasCallStack, Match r ~ FindOp a a (CopyLabel ()), Op (CopyLabel ()) r a impl) => Ref a -> impl Source #

setLabel :: (HasCallStack, Match r ~ FindOp a a (SetLabel ()), Op (SetLabel ()) r a impl) => Ref a -> impl Source #

getLabeltype :: (HasCallStack, Match r ~ FindOp a a (GetLabeltype ()), Op (GetLabeltype ()) r a impl) => Ref a -> impl Source #

setLabeltype :: (HasCallStack, Match r ~ FindOp a a (SetLabeltype ()), Op (SetLabeltype ()) r a impl) => Ref a -> impl Source #

getLabelcolor :: (HasCallStack, Match r ~ FindOp a a (GetLabelcolor ()), Op (GetLabelcolor ()) r a impl) => Ref a -> impl Source #

setLabelcolor :: (HasCallStack, Match r ~ FindOp a a (SetLabelcolor ()), Op (SetLabelcolor ()) r a impl) => Ref a -> impl Source #

getLabelfont :: (HasCallStack, Match r ~ FindOp a a (GetLabelfont ()), Op (GetLabelfont ()) r a impl) => Ref a -> impl Source #

setLabelfont :: (HasCallStack, Match r ~ FindOp a a (SetLabelfont ()), Op (SetLabelfont ()) r a impl) => Ref a -> impl Source #

getLabelsize :: (HasCallStack, Match r ~ FindOp a a (GetLabelsize ()), Op (GetLabelsize ()) r a impl) => Ref a -> impl Source #

setLabelsize :: (HasCallStack, Match r ~ FindOp a a (SetLabelsize ()), Op (SetLabelsize ()) r a impl) => Ref a -> impl Source #

getImage :: (HasCallStack, Match r ~ FindOp a a (GetImage ()), Op (GetImage ()) r a impl) => Ref a -> impl Source #

setImage :: (HasCallStack, Match r ~ FindOp a a (SetImage ()), Op (SetImage ()) r a impl) => Ref a -> impl Source #

getDeimage :: (HasCallStack, Match r ~ FindOp a a (GetDeimage ()), Op (GetDeimage ()) r a impl) => Ref a -> impl Source #

setDeimage :: (HasCallStack, Match r ~ FindOp a a (SetDeimage ()), Op (SetDeimage ()) r a impl) => Ref a -> impl Source #

getTooltip :: (HasCallStack, Match r ~ FindOp a a (GetTooltip ()), Op (GetTooltip ()) r a impl) => Ref a -> impl Source #

copyTooltip :: (HasCallStack, Match r ~ FindOp a a (CopyTooltip ()), Op (CopyTooltip ()) r a impl) => Ref a -> impl Source #

setTooltip :: (HasCallStack, Match r ~ FindOp a a (SetTooltip ()), Op (SetTooltip ()) r a impl) => Ref a -> impl Source #

getWhen :: (HasCallStack, Match r ~ FindOp a a (GetWhen ()), Op (GetWhen ()) r a impl) => Ref a -> impl Source #

setWhen :: (HasCallStack, Match r ~ FindOp a a (SetWhen ()), Op (SetWhen ()) r a impl) => Ref a -> impl Source #

getVisible :: (HasCallStack, Match r ~ FindOp a a (GetVisible ()), Op (GetVisible ()) r a impl) => Ref a -> impl Source #

getVisibleR :: (HasCallStack, Match r ~ FindOp a a (GetVisibleR ()), Op (GetVisibleR ()) r a impl) => Ref a -> impl Source #

showWidgetSuper :: (HasCallStack, Match r ~ FindOp a a (ShowWidgetSuper ()), Op (ShowWidgetSuper ()) r a impl) => Ref a -> impl Source #

showWidget :: (HasCallStack, Match r ~ FindOp a a (ShowWidget ()), Op (ShowWidget ()) r a impl) => Ref a -> impl Source #

hideSuper :: (HasCallStack, Match r ~ FindOp a a (HideSuper ()), Op (HideSuper ()) r a impl) => Ref a -> impl Source #

data Hide a Source #

hide :: (HasCallStack, Match r ~ FindOp a a (Hide ()), Op (Hide ()) r a impl) => Ref a -> impl Source #

setVisible :: (HasCallStack, Match r ~ FindOp a a (SetVisible ()), Op (SetVisible ()) r a impl) => Ref a -> impl Source #

clearVisible :: (HasCallStack, Match r ~ FindOp a a (ClearVisible ()), Op (ClearVisible ()) r a impl) => Ref a -> impl Source #

data Active a Source #

active :: (HasCallStack, Match r ~ FindOp a a (Active ()), Op (Active ()) r a impl) => Ref a -> impl Source #

activeR :: (HasCallStack, Match r ~ FindOp a a (ActiveR ()), Op (ActiveR ()) r a impl) => Ref a -> impl Source #

activate :: (HasCallStack, Match r ~ FindOp a a (Activate ()), Op (Activate ()) r a impl) => Ref a -> impl Source #

deactivate :: (HasCallStack, Match r ~ FindOp a a (Deactivate ()), Op (Deactivate ()) r a impl) => Ref a -> impl Source #

getOutput :: (HasCallStack, Match r ~ FindOp a a (GetOutput ()), Op (GetOutput ()) r a impl) => Ref a -> impl Source #

setOutput :: (HasCallStack, Match r ~ FindOp a a (SetOutput ()), Op (SetOutput ()) r a impl) => Ref a -> impl Source #

clearOutput :: (HasCallStack, Match r ~ FindOp a a (ClearOutput ()), Op (ClearOutput ()) r a impl) => Ref a -> impl Source #

takesevents :: (HasCallStack, Match r ~ FindOp a a (Takesevents ()), Op (Takesevents ()) r a impl) => Ref a -> impl Source #

setChanged :: (HasCallStack, Match r ~ FindOp a a (SetChanged ()), Op (SetChanged ()) r a impl) => Ref a -> impl Source #

clearChanged :: (HasCallStack, Match r ~ FindOp a a (ClearChanged ()), Op (ClearChanged ()) r a impl) => Ref a -> impl Source #

changed :: (HasCallStack, Match r ~ FindOp a a (Changed ()), Op (Changed ()) r a impl) => Ref a -> impl Source #

setActive :: (HasCallStack, Match r ~ FindOp a a (SetActive ()), Op (SetActive ()) r a impl) => Ref a -> impl Source #

clearActive :: (HasCallStack, Match r ~ FindOp a a (ClearActive ()), Op (ClearActive ()) r a impl) => Ref a -> impl Source #

takeFocus :: (HasCallStack, Match r ~ FindOp a a (TakeFocus ()), Op (TakeFocus ()) r a impl) => Ref a -> impl Source #

setVisibleFocus :: (HasCallStack, Match r ~ FindOp a a (SetVisibleFocus ()), Op (SetVisibleFocus ()) r a impl) => Ref a -> impl Source #

getVisibleFocus :: (HasCallStack, Match r ~ FindOp a a (GetVisibleFocus ()), Op (GetVisibleFocus ()) r a impl) => Ref a -> impl Source #

contains :: (HasCallStack, Match r ~ FindOp a a (Contains ()), Op (Contains ()) r a impl) => Ref a -> impl Source #

data Inside a Source #

inside :: (HasCallStack, Match r ~ FindOp a a (Inside ()), Op (Inside ()) r a impl) => Ref a -> impl Source #

data Redraw a Source #

redraw :: (HasCallStack, Match r ~ FindOp a a (Redraw ()), Op (Redraw ()) r a impl) => Ref a -> impl Source #

redrawLabel :: (HasCallStack, Match r ~ FindOp a a (RedrawLabel ()), Op (RedrawLabel ()) r a impl) => Ref a -> impl Source #

getDamage :: (HasCallStack, Match r ~ FindOp a a (GetDamage ()), Op (GetDamage ()) r a impl) => Ref a -> impl Source #

clearDamage :: (HasCallStack, Match r ~ FindOp a a (ClearDamage ()), Op (ClearDamage ()) r a impl) => Ref a -> impl Source #

setDamage :: (HasCallStack, Match r ~ FindOp a a (SetDamage ()), Op (SetDamage ()) r a impl) => Ref a -> impl Source #

setDamageInside :: (HasCallStack, Match r ~ FindOp a a (SetDamageInside ()), Op (SetDamageInside ()) r a impl) => Ref a -> impl Source #

measureLabel :: (HasCallStack, Match r ~ FindOp a a (MeasureLabel ()), Op (MeasureLabel ()) r a impl) => Ref a -> impl Source #

getWindow :: (HasCallStack, Match r ~ FindOp a a (GetWindow ()), Op (GetWindow ()) r a impl) => Ref a -> impl Source #

getTopWindow :: (HasCallStack, Match r ~ FindOp a a (GetTopWindow ()), Op (GetTopWindow ()) r a impl) => Ref a -> impl Source #

resizeSuper :: (HasCallStack, Match r ~ FindOp a a (ResizeSuper ()), Op (ResizeSuper ()) r a impl) => Ref a -> impl Source #

data Resize a Source #

resize :: (HasCallStack, Match r ~ FindOp a a (Resize ()), Op (Resize ()) r a impl) => Ref a -> impl Source #

setCallback :: (HasCallStack, Match r ~ FindOp a a (SetCallback ()), Op (SetCallback ()) r a impl) => Ref a -> impl Source #

hasCallback :: (HasCallStack, Match r ~ FindOp a a (HasCallback ()), Op (HasCallback ()) r a impl) => Ref a -> impl Source #

drawBox :: (HasCallStack, Match r ~ FindOp a a (DrawBox ()), Op (DrawBox ()) r a impl) => Ref a -> impl Source #

drawBackdrop :: (HasCallStack, Match r ~ FindOp a a (DrawBackdrop ()), Op (DrawBackdrop ()) r a impl) => Ref a -> impl Source #

drawFocus :: (HasCallStack, Match r ~ FindOp a a (DrawFocus ()), Op (DrawFocus ()) r a impl) => Ref a -> impl Source #

Group

type Group = CGroup Widget Source #

drawChild :: (HasCallStack, Match r ~ FindOp a a (DrawChild ()), Op (DrawChild ()) r a impl) => Ref a -> impl Source #

drawChildren :: (HasCallStack, Match r ~ FindOp a a (DrawChildren ()), Op (DrawChildren ()) r a impl) => Ref a -> impl Source #

drawOutsideLabel :: (HasCallStack, Match r ~ FindOp a a (DrawOutsideLabel ()), Op (DrawOutsideLabel ()) r a impl) => Ref a -> impl Source #

updateChild :: (HasCallStack, Match r ~ FindOp a a (UpdateChild ()), Op (UpdateChild ()) r a impl) => Ref a -> impl Source #

data Begin a Source #

begin :: (HasCallStack, Match r ~ FindOp a a (Begin ()), Op (Begin ()) r a impl) => Ref a -> impl Source #

data End a Source #

end :: (HasCallStack, Match r ~ FindOp a a (End ()), Op (End ()) r a impl) => Ref a -> impl Source #

data Find a Source #

find :: (HasCallStack, Match r ~ FindOp a a (Find ()), Op (Find ()) r a impl) => Ref a -> impl Source #

data Add a Source #

add :: (HasCallStack, Match r ~ FindOp a a (Add ()), Op (Add ()) r a impl) => Ref a -> impl Source #

data Insert a Source #

insert :: (HasCallStack, Match r ~ FindOp a a (Insert ()), Op (Insert ()) r a impl) => Ref a -> impl Source #

removeIndex :: (HasCallStack, Match r ~ FindOp a a (RemoveIndex ()), Op (RemoveIndex ()) r a impl) => Ref a -> impl Source #

removeWidget :: (HasCallStack, Match r ~ FindOp a a (RemoveWidget ()), Op (RemoveWidget ()) r a impl) => Ref a -> impl Source #

data Clear a Source #

clear :: (HasCallStack, Match r ~ FindOp a a (Clear ()), Op (Clear ()) r a impl) => Ref a -> impl Source #

setResizable :: (HasCallStack, Match r ~ FindOp a a (SetResizable ()), Op (SetResizable ()) r a impl) => Ref a -> impl Source #

setNotResizable :: (HasCallStack, Match r ~ FindOp a a (SetNotResizable ()), Op (SetNotResizable ()) r a impl) => Ref a -> impl Source #

getResizable :: (HasCallStack, Match r ~ FindOp a a (GetResizable ()), Op (GetResizable ()) r a impl) => Ref a -> impl Source #

addResizable :: (HasCallStack, Match r ~ FindOp a a (AddResizable ()), Op (AddResizable ()) r a impl) => Ref a -> impl Source #

initSizes :: (HasCallStack, Match r ~ FindOp a a (InitSizes ()), Op (InitSizes ()) r a impl) => Ref a -> impl Source #

children :: (HasCallStack, Match r ~ FindOp a a (Children ()), Op (Children ()) r a impl) => Ref a -> impl Source #

setClipChildren :: (HasCallStack, Match r ~ FindOp a a (SetClipChildren ()), Op (SetClipChildren ()) r a impl) => Ref a -> impl Source #

clipChildren :: (HasCallStack, Match r ~ FindOp a a (ClipChildren ()), Op (ClipChildren ()) r a impl) => Ref a -> impl Source #

data Focus a Source #

focus :: (HasCallStack, Match r ~ FindOp a a (Focus ()), Op (Focus ()) r a impl) => Ref a -> impl Source #

ddfdesignKludge :: (HasCallStack, Match r ~ FindOp a a (DdfdesignKludge ()), Op (DdfdesignKludge ()) r a impl) => Ref a -> impl Source #

insertWithBefore :: (HasCallStack, Match r ~ FindOp a a (InsertWithBefore ()), Op (InsertWithBefore ()) r a impl) => Ref a -> impl Source #

getArray :: (HasCallStack, Match r ~ FindOp a a (GetArray ()), Op (GetArray ()) r a impl) => Ref a -> impl Source #

getChild :: (HasCallStack, Match r ~ FindOp a a (GetChild ()), Op (GetChild ()) r a impl) => Ref a -> impl Source #

Window

type Window = CWindow Group Source #

drawSuper :: (HasCallStack, Match r ~ FindOp a a (DrawSuper ()), Op (DrawSuper ()) r a impl) => Ref a -> impl Source #

handleSuper :: (HasCallStack, Match r ~ FindOp a a (HandleSuper ()), Op (HandleSuper ()) r a impl) => Ref a -> impl Source #

flushSuper :: (HasCallStack, Match r ~ FindOp a a (FlushSuper ()), Op (FlushSuper ()) r a impl) => Ref a -> impl Source #

makeFullscreen :: (HasCallStack, Match r ~ FindOp a a (MakeFullscreen ()), Op (MakeFullscreen ()) r a impl) => Ref a -> impl Source #

fullscreenOff :: (HasCallStack, Match r ~ FindOp a a (FullscreenOff ()), Op (FullscreenOff ()) r a impl) => Ref a -> impl Source #

setBorder :: (HasCallStack, Match r ~ FindOp a a (SetBorder ()), Op (SetBorder ()) r a impl) => Ref a -> impl Source #

clearBorder :: (HasCallStack, Match r ~ FindOp a a (ClearBorder ()), Op (ClearBorder ()) r a impl) => Ref a -> impl Source #

getBorder :: (HasCallStack, Match r ~ FindOp a a (GetBorder ()), Op (GetBorder ()) r a impl) => Ref a -> impl Source #

setOverride :: (HasCallStack, Match r ~ FindOp a a (SetOverride ()), Op (SetOverride ()) r a impl) => Ref a -> impl Source #

getOverride :: (HasCallStack, Match r ~ FindOp a a (GetOverride ()), Op (GetOverride ()) r a impl) => Ref a -> impl Source #

setModal :: (HasCallStack, Match r ~ FindOp a a (SetModal ()), Op (SetModal ()) r a impl) => Ref a -> impl Source #

getModal :: (HasCallStack, Match r ~ FindOp a a (GetModal ()), Op (GetModal ()) r a impl) => Ref a -> impl Source #

setNonModal :: (HasCallStack, Match r ~ FindOp a a (SetNonModal ()), Op (SetNonModal ()) r a impl) => Ref a -> impl Source #

nonModal :: (HasCallStack, Match r ~ FindOp a a (NonModal ()), Op (NonModal ()) r a impl) => Ref a -> impl Source #

setMenuWindow :: (HasCallStack, Match r ~ FindOp a a (SetMenuWindow ()), Op (SetMenuWindow ()) r a impl) => Ref a -> impl Source #

getMenuWindow :: (HasCallStack, Match r ~ FindOp a a (GetMenuWindow ()), Op (GetMenuWindow ()) r a impl) => Ref a -> impl Source #

setTooltipWindow :: (HasCallStack, Match r ~ FindOp a a (SetTooltipWindow ()), Op (SetTooltipWindow ()) r a impl) => Ref a -> impl Source #

getTooltipWindow :: (HasCallStack, Match r ~ FindOp a a (GetTooltipWindow ()), Op (GetTooltipWindow ()) r a impl) => Ref a -> impl Source #

hotSpot :: (HasCallStack, Match r ~ FindOp a a (HotSpot ()), Op (HotSpot ()) r a impl) => Ref a -> impl Source #

freePosition :: (HasCallStack, Match r ~ FindOp a a (FreePosition ()), Op (FreePosition ()) r a impl) => Ref a -> impl Source #

sizeRange :: (HasCallStack, Match r ~ FindOp a a (SizeRange ()), Op (SizeRange ()) r a impl) => Ref a -> impl Source #

getIconlabel :: (HasCallStack, Match r ~ FindOp a a (GetIconlabel ()), Op (GetIconlabel ()) r a impl) => Ref a -> impl Source #

setIconlabel :: (HasCallStack, Match r ~ FindOp a a (SetIconlabel ()), Op (SetIconlabel ()) r a impl) => Ref a -> impl Source #

getXclass :: (HasCallStack, Match r ~ FindOp a a (GetXclass ()), Op (GetXclass ()) r a impl) => Ref a -> impl Source #

setXclass :: (HasCallStack, Match r ~ FindOp a a (SetXclass ()), Op (SetXclass ()) r a impl) => Ref a -> impl Source #

getIcon :: (HasCallStack, Match r ~ FindOp a a (GetIcon ()), Op (GetIcon ()) r a impl) => Ref a -> impl Source #

setIcon :: (HasCallStack, Match r ~ FindOp a a (SetIcon ()), Op (SetIcon ()) r a impl) => Ref a -> impl Source #

data Shown a Source #

shown :: (HasCallStack, Match r ~ FindOp a a (Shown ()), Op (Shown ()) r a impl) => Ref a -> impl Source #

iconize :: (HasCallStack, Match r ~ FindOp a a (Iconize ()), Op (Iconize ()) r a impl) => Ref a -> impl Source #

getXRoot :: (HasCallStack, Match r ~ FindOp a a (GetXRoot ()), Op (GetXRoot ()) r a impl) => Ref a -> impl Source #

getYRoot :: (HasCallStack, Match r ~ FindOp a a (GetYRoot ()), Op (GetYRoot ()) r a impl) => Ref a -> impl Source #

makeCurrent :: (HasCallStack, Match r ~ FindOp a a (MakeCurrent ()), Op (MakeCurrent ()) r a impl) => Ref a -> impl Source #

setCursor :: (HasCallStack, Match r ~ FindOp a a (SetCursor ()), Op (SetCursor ()) r a impl) => Ref a -> impl Source #

setDefaultCursor :: (HasCallStack, Match r ~ FindOp a a (SetDefaultCursor ()), Op (SetDefaultCursor ()) r a impl) => Ref a -> impl Source #

getDecoratedW :: (HasCallStack, Match r ~ FindOp a a (GetDecoratedW ()), Op (GetDecoratedW ()) r a impl) => Ref a -> impl Source #

getDecoratedH :: (HasCallStack, Match r ~ FindOp a a (GetDecoratedH ()), Op (GetDecoratedH ()) r a impl) => Ref a -> impl Source #

waitForExpose :: (HasCallStack, Match r ~ FindOp a a (WaitForExpose ()), Op (WaitForExpose ()) r a impl) => Ref a -> impl Source #

SingleWindow

type SingleWindow = CSingleWindow Window Source #

DoubleWindow

type DoubleWindow = CDoubleWindow Window Source #

OverlayWindow

type OverlayWindow = COverlayWindow DoubleWindow Source #

canDoOverlay :: (HasCallStack, Match r ~ FindOp a a (CanDoOverlay ()), Op (CanDoOverlay ()) r a impl) => Ref a -> impl Source #

redrawOverlay :: (HasCallStack, Match r ~ FindOp a a (RedrawOverlay ()), Op (RedrawOverlay ()) r a impl) => Ref a -> impl Source #

data Flush a Source #

flush :: (HasCallStack, Match r ~ FindOp a a (Flush ()), Op (Flush ()) r a impl) => Ref a -> impl Source #

Button

type Button = CButton Widget Source #

getValue :: (HasCallStack, Match r ~ FindOp a a (GetValue ()), Op (GetValue ()) r a impl) => Ref a -> impl Source #

setValue :: (HasCallStack, Match r ~ FindOp a a (SetValue ()), Op (SetValue ()) r a impl) => Ref a -> impl Source #

data Set a Source #

set :: (HasCallStack, Match r ~ FindOp a a (Set ()), Op (Set ()) r a impl) => Ref a -> impl Source #

setonly :: (HasCallStack, Match r ~ FindOp a a (Setonly ()), Op (Setonly ()) r a impl) => Ref a -> impl Source #

getShortcut :: (HasCallStack, Match r ~ FindOp a a (GetShortcut ()), Op (GetShortcut ()) r a impl) => Ref a -> impl Source #

setShortcut :: (HasCallStack, Match r ~ FindOp a a (SetShortcut ()), Op (SetShortcut ()) r a impl) => Ref a -> impl Source #

getDownBox :: (HasCallStack, Match r ~ FindOp a a (GetDownBox ()), Op (GetDownBox ()) r a impl) => Ref a -> impl Source #

setDownBox :: (HasCallStack, Match r ~ FindOp a a (SetDownBox ()), Op (SetDownBox ()) r a impl) => Ref a -> impl Source #

getDownColor :: (HasCallStack, Match r ~ FindOp a a (GetDownColor ()), Op (GetDownColor ()) r a impl) => Ref a -> impl Source #

setDownColor :: (HasCallStack, Match r ~ FindOp a a (SetDownColor ()), Op (SetDownColor ()) r a impl) => Ref a -> impl Source #

LightButton

type LightButton = CLightButton Button Source #

RadioLightButton

type RadioLightButton = CRadioLightButton LightButton Source #

CheckButton

type CheckButton = CCheckButton Button Source #

ReturnButton

type ReturnButton = CReturnButton Button Source #

RoundButton

type RoundButton = CRoundButton Button Source #

RepeatButton

type RepeatButton = CRepeatButton Button Source #

ToggleButton

type ToggleButton = CToggleButton Button Source #

Valuator

type Valuator = CValuator Widget Source #

data Bounds a Source #

bounds :: (HasCallStack, Match r ~ FindOp a a (Bounds ()), Op (Bounds ()) r a impl) => Ref a -> impl Source #

getMinimum :: (HasCallStack, Match r ~ FindOp a a (GetMinimum ()), Op (GetMinimum ()) r a impl) => Ref a -> impl Source #

setMinimum :: (HasCallStack, Match r ~ FindOp a a (SetMinimum ()), Op (SetMinimum ()) r a impl) => Ref a -> impl Source #

getMaximum :: (HasCallStack, Match r ~ FindOp a a (GetMaximum ()), Op (GetMaximum ()) r a impl) => Ref a -> impl Source #

setMaximum :: (HasCallStack, Match r ~ FindOp a a (SetMaximum ()), Op (SetMaximum ()) r a impl) => Ref a -> impl Source #

data Range a Source #

range :: (HasCallStack, Match r ~ FindOp a a (Range ()), Op (Range ()) r a impl) => Ref a -> impl Source #

setStep :: (HasCallStack, Match r ~ FindOp a a (SetStep ()), Op (SetStep ()) r a impl) => Ref a -> impl Source #

getStep :: (HasCallStack, Match r ~ FindOp a a (GetStep ()), Op (GetStep ()) r a impl) => Ref a -> impl Source #

precision :: (HasCallStack, Match r ~ FindOp a a (Precision ()), Op (Precision ()) r a impl) => Ref a -> impl Source #

setFormat :: (HasCallStack, Match r ~ FindOp a a (SetFormat ()), Op (SetFormat ()) r a impl) => Ref a -> impl Source #

data Round a Source #

round :: (HasCallStack, Match r ~ FindOp a a (Round ()), Op (Round ()) r a impl) => Ref a -> impl Source #

data Clamp a Source #

clamp :: (HasCallStack, Match r ~ FindOp a a (Clamp ()), Op (Clamp ()) r a impl) => Ref a -> impl Source #

increment :: (HasCallStack, Match r ~ FindOp a a (Increment ()), Op (Increment ()) r a impl) => Ref a -> impl Source #

Slider

type Slider = CSlider Valuator Source #

scrollvalue :: (HasCallStack, Match r ~ FindOp a a (Scrollvalue ()), Op (Scrollvalue ()) r a impl) => Ref a -> impl Source #

setSliderSize :: (HasCallStack, Match r ~ FindOp a a (SetSliderSize ()), Op (SetSliderSize ()) r a impl) => Ref a -> impl Source #

getSliderSize :: (HasCallStack, Match r ~ FindOp a a (GetSliderSize ()), Op (GetSliderSize ()) r a impl) => Ref a -> impl Source #

getSlider :: (HasCallStack, Match r ~ FindOp a a (GetSlider ()), Op (GetSlider ()) r a impl) => Ref a -> impl Source #

setSlider :: (HasCallStack, Match r ~ FindOp a a (SetSlider ()), Op (SetSlider ()) r a impl) => Ref a -> impl Source #

FillSlider

type FillSlider = CFillSlider Slider Source #

HorSlider

type HorSlider = CHorSlider Slider Source #

HorFillSider

type HorFillSlider = CHorFillSlider Slider Source #

NiceSlider

type NiceSlider = CNiceSlider Slider Source #

HorNiceSlider

type HorNiceSlider = CHorNiceSlider Slider Source #

MenuItem

type MenuItem = CMenuItem Base Source #

nextWithStep :: (HasCallStack, Match r ~ FindOp a a (NextWithStep ()), Op (NextWithStep ()) r a impl) => Ref a -> impl Source #

data Next a Source #

next :: (HasCallStack, Match r ~ FindOp a a (Next ()), Op (Next ()) r a impl) => Ref a -> impl Source #

getFirst :: (HasCallStack, Match r ~ FindOp a a (GetFirst ()), Op (GetFirst ()) r a impl) => Ref a -> impl Source #

submenu :: (HasCallStack, Match r ~ FindOp a a (Submenu ()), Op (Submenu ()) r a impl) => Ref a -> impl Source #

checkbox :: (HasCallStack, Match r ~ FindOp a a (Checkbox ()), Op (Checkbox ()) r a impl) => Ref a -> impl Source #

data Radio a Source #

radio :: (HasCallStack, Match r ~ FindOp a a (Radio ()), Op (Radio ()) r a impl) => Ref a -> impl Source #

visible :: (HasCallStack, Match r ~ FindOp a a (Visible ()), Op (Visible ()) r a impl) => Ref a -> impl Source #

activevisible :: (HasCallStack, Match r ~ FindOp a a (Activevisible ()), Op (Activevisible ()) r a impl) => Ref a -> impl Source #

measure :: (HasCallStack, Match r ~ FindOp a a (Measure ()), Op (Measure ()) r a impl) => Ref a -> impl Source #

drawWithT :: (HasCallStack, Match r ~ FindOp a a (DrawWithT ()), Op (DrawWithT ()) r a impl) => Ref a -> impl Source #

data Draw a Source #

draw :: (HasCallStack, Match r ~ FindOp a a (Draw ()), Op (Draw ()) r a impl) => Ref a -> impl Source #

getFlags :: (HasCallStack, Match r ~ FindOp a a (GetFlags ()), Op (GetFlags ()) r a impl) => Ref a -> impl Source #

setFlags :: (HasCallStack, Match r ~ FindOp a a (SetFlags ()), Op (SetFlags ()) r a impl) => Ref a -> impl Source #

getText :: (HasCallStack, Match r ~ FindOp a a (GetText ()), Op (GetText ()) r a impl) => Ref a -> impl Source #

pulldown :: (HasCallStack, Match r ~ FindOp a a (Pulldown ()), Op (Pulldown ()) r a impl) => Ref a -> impl Source #

data Popup a Source #

popup :: (HasCallStack, Match r ~ FindOp a a (Popup ()), Op (Popup ()) r a impl) => Ref a -> impl Source #

testShortcut :: (HasCallStack, Match r ~ FindOp a a (TestShortcut ()), Op (TestShortcut ()) r a impl) => Ref a -> impl Source #

findShortcut :: (HasCallStack, Match r ~ FindOp a a (FindShortcut ()), Op (FindShortcut ()) r a impl) => Ref a -> impl Source #

doCallback :: (HasCallStack, Match r ~ FindOp a a (DoCallback ()), Op (DoCallback ()) r a impl) => Ref a -> impl Source #

getSize :: (HasCallStack, Match r ~ FindOp a a (GetSize ()), Op (GetSize ()) r a impl) => Ref a -> impl Source #

MenuPrim

type MenuPrim = CMenuPrim Widget Source #

itemPathname :: (HasCallStack, Match r ~ FindOp a a (ItemPathname ()), Op (ItemPathname ()) r a impl) => Ref a -> impl Source #

data Picked a Source #

picked :: (HasCallStack, Match r ~ FindOp a a (Picked ()), Op (Picked ()) r a impl) => Ref a -> impl Source #

findIndex :: (HasCallStack, Match r ~ FindOp a a (FindIndex ()), Op (FindIndex ()) r a impl) => Ref a -> impl Source #

data Global a Source #

global :: (HasCallStack, Match r ~ FindOp a a (Global ()), Op (Global ()) r a impl) => Ref a -> impl Source #

getMenu :: (HasCallStack, Match r ~ FindOp a a (GetMenu ()), Op (GetMenu ()) r a impl) => Ref a -> impl Source #

setMenu :: (HasCallStack, Match r ~ FindOp a a (SetMenu ()), Op (SetMenu ()) r a impl) => Ref a -> impl Source #

addName :: (HasCallStack, Match r ~ FindOp a a (AddName ()), Op (AddName ()) r a impl) => Ref a -> impl Source #

data Copy a Source #

copy :: (HasCallStack, Match r ~ FindOp a a (Copy ()), Op (Copy ()) r a impl) => Ref a -> impl Source #

setSize :: (HasCallStack, Match r ~ FindOp a a (SetSize ()), Op (SetSize ()) r a impl) => Ref a -> impl Source #

clearSubmenu :: (HasCallStack, Match r ~ FindOp a a (ClearSubmenu ()), Op (ClearSubmenu ()) r a impl) => Ref a -> impl Source #

replace :: (HasCallStack, Match r ~ FindOp a a (Replace ()), Op (Replace ()) r a impl) => Ref a -> impl Source #

data Remove a Source #

remove :: (HasCallStack, Match r ~ FindOp a a (Remove ()), Op (Remove ()) r a impl) => Ref a -> impl Source #

setMode :: (HasCallStack, Match r ~ FindOp a a (SetMode ()), Op (SetMode ()) r a impl) => Ref a -> impl Source #

getMode :: (HasCallStack, Match r ~ FindOp a a (GetMode ()), Op (GetMode ()) r a impl) => Ref a -> impl Source #

data Mvalue a Source #

mvalue :: (HasCallStack, Match r ~ FindOp a a (Mvalue ()), Op (Mvalue ()) r a impl) => Ref a -> impl Source #

getTextWithIndex :: (HasCallStack, Match r ~ FindOp a a (GetTextWithIndex ()), Op (GetTextWithIndex ()) r a impl) => Ref a -> impl Source #

getTextfont :: (HasCallStack, Match r ~ FindOp a a (GetTextfont ()), Op (GetTextfont ()) r a impl) => Ref a -> impl Source #

setTextfont :: (HasCallStack, Match r ~ FindOp a a (SetTextfont ()), Op (SetTextfont ()) r a impl) => Ref a -> impl Source #

getTextsize :: (HasCallStack, Match r ~ FindOp a a (GetTextsize ()), Op (GetTextsize ()) r a impl) => Ref a -> impl Source #

setTextsize :: (HasCallStack, Match r ~ FindOp a a (SetTextsize ()), Op (SetTextsize ()) r a impl) => Ref a -> impl Source #

getTextcolor :: (HasCallStack, Match r ~ FindOp a a (GetTextcolor ()), Op (GetTextcolor ()) r a impl) => Ref a -> impl Source #

setTextcolor :: (HasCallStack, Match r ~ FindOp a a (SetTextcolor ()), Op (SetTextcolor ()) r a impl) => Ref a -> impl Source #

downBox :: (HasCallStack, Match r ~ FindOp a a (DownBox ()), Op (DownBox ()) r a impl) => Ref a -> impl Source #

MenuBar

type MenuBar = CMenuBar MenuPrim Source #

SysMenuBar

type SysMenuBar = CSysMenuBar MenuBar Source #

Choice,

type Choice = CChoice MenuPrim Source #

MenuButton

type MenuButton = CMenuButton MenuPrim Source #

Image

type Image = CImage Base Source #

data GetD a Source #

getD :: (HasCallStack, Match r ~ FindOp a a (GetD ()), Op (GetD ()) r a impl) => Ref a -> impl Source #

data GetLd a Source #

getLd :: (HasCallStack, Match r ~ FindOp a a (GetLd ()), Op (GetLd ()) r a impl) => Ref a -> impl Source #

getCount :: (HasCallStack, Match r ~ FindOp a a (GetCount ()), Op (GetCount ()) r a impl) => Ref a -> impl Source #

colorAverage :: (HasCallStack, Match r ~ FindOp a a (ColorAverage ()), Op (ColorAverage ()) r a impl) => Ref a -> impl Source #

inactive :: (HasCallStack, Match r ~ FindOp a a (Inactive ()), Op (Inactive ()) r a impl) => Ref a -> impl Source #

desaturate :: (HasCallStack, Match r ~ FindOp a a (Desaturate ()), Op (Desaturate ()) r a impl) => Ref a -> impl Source #

drawResize :: (HasCallStack, Match r ~ FindOp a a (DrawResize ()), Op (DrawResize ()) r a impl) => Ref a -> impl Source #

uncache :: (HasCallStack, Match r ~ FindOp a a (Uncache ()), Op (Uncache ()) r a impl) => Ref a -> impl Source #

data Fail a Source #

fail :: (HasCallStack, Match r ~ FindOp a a (Fail ()), Op (Fail ()) r a impl) => Ref a -> impl Source #

Bitmap

type Bitmap = CBitmap Image Source #

Pixmap

type Pixmap = CPixmap Image Source #

CopySurface

type CopySurface = CCopySurface Base Source #

className :: (HasCallStack, Match r ~ FindOp a a (ClassName ()), Op (ClassName ()) r a impl) => Ref a -> impl Source #

setCurrent :: (HasCallStack, Match r ~ FindOp a a (SetCurrent ()), Op (SetCurrent ()) r a impl) => Ref a -> impl Source #

ImageSurface

type ImageSurface = CImageSurface Base Source #

Adjuster

type Adjuster = CAdjuster Valuator Source #

setSoft :: (HasCallStack, Match r ~ FindOp a a (SetSoft ()), Op (SetSoft ()) r a impl) => Ref a -> impl Source #

getSoft :: (HasCallStack, Match r ~ FindOp a a (GetSoft ()), Op (GetSoft ()) r a impl) => Ref a -> impl Source #

Dial

type Dial = CDial Valuator Source #

getAngle1 :: (HasCallStack, Match r ~ FindOp a a (GetAngle1 ()), Op (GetAngle1 ()) r a impl) => Ref a -> impl Source #

setAngle1 :: (HasCallStack, Match r ~ FindOp a a (SetAngle1 ()), Op (SetAngle1 ()) r a impl) => Ref a -> impl Source #

getAngle2 :: (HasCallStack, Match r ~ FindOp a a (GetAngle2 ()), Op (GetAngle2 ()) r a impl) => Ref a -> impl Source #

setAngle2 :: (HasCallStack, Match r ~ FindOp a a (SetAngle2 ()), Op (SetAngle2 ()) r a impl) => Ref a -> impl Source #

setAngles :: (HasCallStack, Match r ~ FindOp a a (SetAngles ()), Op (SetAngles ()) r a impl) => Ref a -> impl Source #

FillDial

type FillDial = CFillDial Dial Source #

LineDial

type LineDial = CLineDial Dial Source #

Roller

type Roller = CRoller Valuator Source #

Counter

type Counter = CCounter Valuator Source #

setLstep :: (HasCallStack, Match r ~ FindOp a a (SetLstep ()), Op (SetLstep ()) r a impl) => Ref a -> impl Source #

SimpleCounter

type SimpleCounter = CSimpleCounter Counter Source #

Scrollbar

type Scrollbar = CScrollbar Slider Source #

setLinesize :: (HasCallStack, Match r ~ FindOp a a (SetLinesize ()), Op (SetLinesize ()) r a impl) => Ref a -> impl Source #

getLinesize :: (HasCallStack, Match r ~ FindOp a a (GetLinesize ()), Op (GetLinesize ()) r a impl) => Ref a -> impl Source #

setScrollValue :: (HasCallStack, Match r ~ FindOp a a (SetScrollValue ()), Op (SetScrollValue ()) r a impl) => Ref a -> impl Source #

ValueSlider

type ValueSlider = CValueSlider Slider Source #

HorValueSlider

type HorValueSlider = CHorValueSlider ValueSlider Source #

Input

type Input = CInput Widget Source #

staticValue :: (HasCallStack, Match r ~ FindOp a a (StaticValue ()), Op (StaticValue ()) r a impl) => Ref a -> impl Source #

data Index a Source #

index :: (HasCallStack, Match r ~ FindOp a a (Index ()), Op (Index ()) r a impl) => Ref a -> impl Source #

getMaximumSize :: (HasCallStack, Match r ~ FindOp a a (GetMaximumSize ()), Op (GetMaximumSize ()) r a impl) => Ref a -> impl Source #

setMaximumSize :: (HasCallStack, Match r ~ FindOp a a (SetMaximumSize ()), Op (SetMaximumSize ()) r a impl) => Ref a -> impl Source #

getPosition :: (HasCallStack, Match r ~ FindOp a a (GetPosition ()), Op (GetPosition ()) r a impl) => Ref a -> impl Source #

getMark :: (HasCallStack, Match r ~ FindOp a a (GetMark ()), Op (GetMark ()) r a impl) => Ref a -> impl Source #

setPosition :: (HasCallStack, Match r ~ FindOp a a (SetPosition ()), Op (SetPosition ()) r a impl) => Ref a -> impl Source #

setMark :: (HasCallStack, Match r ~ FindOp a a (SetMark ()), Op (SetMark ()) r a impl) => Ref a -> impl Source #

data Cut a Source #

cut :: (HasCallStack, Match r ~ FindOp a a (Cut ()), Op (Cut ()) r a impl) => Ref a -> impl Source #

cutFromCursor :: (HasCallStack, Match r ~ FindOp a a (CutFromCursor ()), Op (CutFromCursor ()) r a impl) => Ref a -> impl Source #

cutRange :: (HasCallStack, Match r ~ FindOp a a (CutRange ()), Op (CutRange ()) r a impl) => Ref a -> impl Source #

insertWithLength :: (HasCallStack, Match r ~ FindOp a a (InsertWithLength ()), Op (InsertWithLength ()) r a impl) => Ref a -> impl Source #

data Undo a Source #

undo :: (HasCallStack, Match r ~ FindOp a a (Undo ()), Op (Undo ()) r a impl) => Ref a -> impl Source #

copyCuts :: (HasCallStack, Match r ~ FindOp a a (CopyCuts ()), Op (CopyCuts ()) r a impl) => Ref a -> impl Source #

getCursorColor :: (HasCallStack, Match r ~ FindOp a a (GetCursorColor ()), Op (GetCursorColor ()) r a impl) => Ref a -> impl Source #

setCursorColor :: (HasCallStack, Match r ~ FindOp a a (SetCursorColor ()), Op (SetCursorColor ()) r a impl) => Ref a -> impl Source #

getInputType :: (HasCallStack, Match r ~ FindOp a a (GetInputType ()), Op (GetInputType ()) r a impl) => Ref a -> impl Source #

setInputType :: (HasCallStack, Match r ~ FindOp a a (SetInputType ()), Op (SetInputType ()) r a impl) => Ref a -> impl Source #

getReadonly :: (HasCallStack, Match r ~ FindOp a a (GetReadonly ()), Op (GetReadonly ()) r a impl) => Ref a -> impl Source #

setReadonly :: (HasCallStack, Match r ~ FindOp a a (SetReadonly ()), Op (SetReadonly ()) r a impl) => Ref a -> impl Source #

getWrap :: (HasCallStack, Match r ~ FindOp a a (GetWrap ()), Op (GetWrap ()) r a impl) => Ref a -> impl Source #

setWrap :: (HasCallStack, Match r ~ FindOp a a (SetWrap ()), Op (SetWrap ()) r a impl) => Ref a -> impl Source #

getTabNav :: (HasCallStack, Match r ~ FindOp a a (GetTabNav ()), Op (GetTabNav ()) r a impl) => Ref a -> impl Source #

setTabNav :: (HasCallStack, Match r ~ FindOp a a (SetTabNav ()), Op (SetTabNav ()) r a impl) => Ref a -> impl Source #

Output

type Output = COutput Input Source #

ValueInput

type ValueInput = CValueInput Valuator Source #

ValueOutput

type ValueOutput = CValueOutput Valuator Source #

Timer

type Timer = CTimer Widget Source #

getDirection :: (HasCallStack, Match r ~ FindOp a a (GetDirection ()), Op (GetDirection ()) r a impl) => Ref a -> impl Source #

setDirection :: (HasCallStack, Match r ~ FindOp a a (SetDirection ()), Op (SetDirection ()) r a impl) => Ref a -> impl Source #

getSuspended :: (HasCallStack, Match r ~ FindOp a a (GetSuspended ()), Op (GetSuspended ()) r a impl) => Ref a -> impl Source #

setSuspended :: (HasCallStack, Match r ~ FindOp a a (SetSuspended ()), Op (SetSuspended ()) r a impl) => Ref a -> impl Source #

HiddenTimer

type HiddenTimer = CHiddenTimer Widget Source #

ValueTimer

type ValueTimer = CValueTimer Widget Source #

Progress

type Progress = CProgress Widget Source #

Positioner

type Positioner = CPositioner Widget Source #

setXvalue :: (HasCallStack, Match r ~ FindOp a a (SetXvalue ()), Op (SetXvalue ()) r a impl) => Ref a -> impl Source #

getXvalue :: (HasCallStack, Match r ~ FindOp a a (GetXvalue ()), Op (GetXvalue ()) r a impl) => Ref a -> impl Source #

setYvalue :: (HasCallStack, Match r ~ FindOp a a (SetYvalue ()), Op (SetYvalue ()) r a impl) => Ref a -> impl Source #

getYvalue :: (HasCallStack, Match r ~ FindOp a a (GetYvalue ()), Op (GetYvalue ()) r a impl) => Ref a -> impl Source #

setXminimum :: (HasCallStack, Match r ~ FindOp a a (SetXminimum ()), Op (SetXminimum ()) r a impl) => Ref a -> impl Source #

getXminimum :: (HasCallStack, Match r ~ FindOp a a (GetXminimum ()), Op (GetXminimum ()) r a impl) => Ref a -> impl Source #

setYminimum :: (HasCallStack, Match r ~ FindOp a a (SetYminimum ()), Op (SetYminimum ()) r a impl) => Ref a -> impl Source #

getYminimum :: (HasCallStack, Match r ~ FindOp a a (GetYminimum ()), Op (GetYminimum ()) r a impl) => Ref a -> impl Source #

setXmaximum :: (HasCallStack, Match r ~ FindOp a a (SetXmaximum ()), Op (SetXmaximum ()) r a impl) => Ref a -> impl Source #

getXmaximum :: (HasCallStack, Match r ~ FindOp a a (GetXmaximum ()), Op (GetXmaximum ()) r a impl) => Ref a -> impl Source #

setYmaximum :: (HasCallStack, Match r ~ FindOp a a (SetYmaximum ()), Op (SetYmaximum ()) r a impl) => Ref a -> impl Source #

getYmaximum :: (HasCallStack, Match r ~ FindOp a a (GetYmaximum ()), Op (GetYmaximum ()) r a impl) => Ref a -> impl Source #

setXbounds :: (HasCallStack, Match r ~ FindOp a a (SetXbounds ()), Op (SetXbounds ()) r a impl) => Ref a -> impl Source #

setYbounds :: (HasCallStack, Match r ~ FindOp a a (SetYbounds ()), Op (SetYbounds ()) r a impl) => Ref a -> impl Source #

setXstep :: (HasCallStack, Match r ~ FindOp a a (SetXstep ()), Op (SetXstep ()) r a impl) => Ref a -> impl Source #

setYstep :: (HasCallStack, Match r ~ FindOp a a (SetYstep ()), Op (SetYstep ()) r a impl) => Ref a -> impl Source #

Wizard

type Wizard = CWizard Group Source #

data Prev a Source #

prev :: (HasCallStack, Match r ~ FindOp a a (Prev ()), Op (Prev ()) r a impl) => Ref a -> impl Source #

Table

type Table = CTable Group Source #

setTableBox :: (HasCallStack, Match r ~ FindOp a a (SetTableBox ()), Op (SetTableBox ()) r a impl) => Ref a -> impl Source #

getTableBox :: (HasCallStack, Match r ~ FindOp a a (GetTableBox ()), Op (GetTableBox ()) r a impl) => Ref a -> impl Source #

setRows :: (HasCallStack, Match r ~ FindOp a a (SetRows ()), Op (SetRows ()) r a impl) => Ref a -> impl Source #

getRows :: (HasCallStack, Match r ~ FindOp a a (GetRows ()), Op (GetRows ()) r a impl) => Ref a -> impl Source #

setCols :: (HasCallStack, Match r ~ FindOp a a (SetCols ()), Op (SetCols ()) r a impl) => Ref a -> impl Source #

getCols :: (HasCallStack, Match r ~ FindOp a a (GetCols ()), Op (GetCols ()) r a impl) => Ref a -> impl Source #

getVisibleCells :: (HasCallStack, Match r ~ FindOp a a (GetVisibleCells ()), Op (GetVisibleCells ()) r a impl) => Ref a -> impl Source #

getRowResize :: (HasCallStack, Match r ~ FindOp a a (GetRowResize ()), Op (GetRowResize ()) r a impl) => Ref a -> impl Source #

setRowResize :: (HasCallStack, Match r ~ FindOp a a (SetRowResize ()), Op (SetRowResize ()) r a impl) => Ref a -> impl Source #

getColResize :: (HasCallStack, Match r ~ FindOp a a (GetColResize ()), Op (GetColResize ()) r a impl) => Ref a -> impl Source #

setColResize :: (HasCallStack, Match r ~ FindOp a a (SetColResize ()), Op (SetColResize ()) r a impl) => Ref a -> impl Source #

getColResizeMin :: (HasCallStack, Match r ~ FindOp a a (GetColResizeMin ()), Op (GetColResizeMin ()) r a impl) => Ref a -> impl Source #

setColResizeMin :: (HasCallStack, Match r ~ FindOp a a (SetColResizeMin ()), Op (SetColResizeMin ()) r a impl) => Ref a -> impl Source #

getRowResizeMin :: (HasCallStack, Match r ~ FindOp a a (GetRowResizeMin ()), Op (GetRowResizeMin ()) r a impl) => Ref a -> impl Source #

setRowResizeMin :: (HasCallStack, Match r ~ FindOp a a (SetRowResizeMin ()), Op (SetRowResizeMin ()) r a impl) => Ref a -> impl Source #

getRowHeader :: (HasCallStack, Match r ~ FindOp a a (GetRowHeader ()), Op (GetRowHeader ()) r a impl) => Ref a -> impl Source #

setRowHeader :: (HasCallStack, Match r ~ FindOp a a (SetRowHeader ()), Op (SetRowHeader ()) r a impl) => Ref a -> impl Source #

getColHeader :: (HasCallStack, Match r ~ FindOp a a (GetColHeader ()), Op (GetColHeader ()) r a impl) => Ref a -> impl Source #

setColHeader :: (HasCallStack, Match r ~ FindOp a a (SetColHeader ()), Op (SetColHeader ()) r a impl) => Ref a -> impl Source #

setRowHeight :: (HasCallStack, Match r ~ FindOp a a (SetRowHeight ()), Op (SetRowHeight ()) r a impl) => Ref a -> impl Source #

getRowHeight :: (HasCallStack, Match r ~ FindOp a a (GetRowHeight ()), Op (GetRowHeight ()) r a impl) => Ref a -> impl Source #

setColWidth :: (HasCallStack, Match r ~ FindOp a a (SetColWidth ()), Op (SetColWidth ()) r a impl) => Ref a -> impl Source #

getColWidth :: (HasCallStack, Match r ~ FindOp a a (GetColWidth ()), Op (GetColWidth ()) r a impl) => Ref a -> impl Source #

setRowHeightAll :: (HasCallStack, Match r ~ FindOp a a (SetRowHeightAll ()), Op (SetRowHeightAll ()) r a impl) => Ref a -> impl Source #

setColWidthAll :: (HasCallStack, Match r ~ FindOp a a (SetColWidthAll ()), Op (SetColWidthAll ()) r a impl) => Ref a -> impl Source #

setRowPosition :: (HasCallStack, Match r ~ FindOp a a (SetRowPosition ()), Op (SetRowPosition ()) r a impl) => Ref a -> impl Source #

setColPosition :: (HasCallStack, Match r ~ FindOp a a (SetColPosition ()), Op (SetColPosition ()) r a impl) => Ref a -> impl Source #

getRowPosition :: (HasCallStack, Match r ~ FindOp a a (GetRowPosition ()), Op (GetRowPosition ()) r a impl) => Ref a -> impl Source #

getColPosition :: (HasCallStack, Match r ~ FindOp a a (GetColPosition ()), Op (GetColPosition ()) r a impl) => Ref a -> impl Source #

setTopRow :: (HasCallStack, Match r ~ FindOp a a (SetTopRow ()), Op (SetTopRow ()) r a impl) => Ref a -> impl Source #

getTopRow :: (HasCallStack, Match r ~ FindOp a a (GetTopRow ()), Op (GetTopRow ()) r a impl) => Ref a -> impl Source #

isSelected :: (HasCallStack, Match r ~ FindOp a a (IsSelected ()), Op (IsSelected ()) r a impl) => Ref a -> impl Source #

getSelection :: (HasCallStack, Match r ~ FindOp a a (GetSelection ()), Op (GetSelection ()) r a impl) => Ref a -> impl Source #

setSelection :: (HasCallStack, Match r ~ FindOp a a (SetSelection ()), Op (SetSelection ()) r a impl) => Ref a -> impl Source #

moveCursor :: (HasCallStack, Match r ~ FindOp a a (MoveCursor ()), Op (MoveCursor ()) r a impl) => Ref a -> impl Source #

callbackRow :: (HasCallStack, Match r ~ FindOp a a (CallbackRow ()), Op (CallbackRow ()) r a impl) => Ref a -> impl Source #

callbackCol :: (HasCallStack, Match r ~ FindOp a a (CallbackCol ()), Op (CallbackCol ()) r a impl) => Ref a -> impl Source #

callbackContext :: (HasCallStack, Match r ~ FindOp a a (CallbackContext ()), Op (CallbackContext ()) r a impl) => Ref a -> impl Source #

findCell :: (HasCallStack, Match r ~ FindOp a a (FindCell ()), Op (FindCell ()) r a impl) => Ref a -> impl Source #

clearSuper :: (HasCallStack, Match r ~ FindOp a a (ClearSuper ()), Op (ClearSuper ()) r a impl) => Ref a -> impl Source #

setRowsSuper :: (HasCallStack, Match r ~ FindOp a a (SetRowsSuper ()), Op (SetRowsSuper ()) r a impl) => Ref a -> impl Source #

setColsSuper :: (HasCallStack, Match r ~ FindOp a a (SetColsSuper ()), Op (SetColsSuper ()) r a impl) => Ref a -> impl Source #

TableRow

type TableRow = CTableRow Table Source #

getRowSelected :: (HasCallStack, Match r ~ FindOp a a (GetRowSelected ()), Op (GetRowSelected ()) r a impl) => Ref a -> impl Source #

selectAllRows :: (HasCallStack, Match r ~ FindOp a a (SelectAllRows ()), Op (SelectAllRows ()) r a impl) => Ref a -> impl Source #

GlWindow

type GlWindow = CGlWindow Window Source #

getValid :: (HasCallStack, Match r ~ FindOp a a (GetValid ()), Op (GetValid ()) r a impl) => Ref a -> impl Source #

setValid :: (HasCallStack, Match r ~ FindOp a a (SetValid ()), Op (SetValid ()) r a impl) => Ref a -> impl Source #

invalidate :: (HasCallStack, Match r ~ FindOp a a (Invalidate ()), Op (Invalidate ()) r a impl) => Ref a -> impl Source #

getContextValid :: (HasCallStack, Match r ~ FindOp a a (GetContextValid ()), Op (GetContextValid ()) r a impl) => Ref a -> impl Source #

setContextValid :: (HasCallStack, Match r ~ FindOp a a (SetContextValid ()), Op (SetContextValid ()) r a impl) => Ref a -> impl Source #

data CanDo a Source #

canDo :: (HasCallStack, Match r ~ FindOp a a (CanDo ()), Op (CanDo ()) r a impl) => Ref a -> impl Source #

getContext :: (HasCallStack, Match r ~ FindOp a a (GetContext ()), Op (GetContext ()) r a impl) => Ref a -> impl Source #

setContext :: (HasCallStack, Match r ~ FindOp a a (SetContext ()), Op (SetContext ()) r a impl) => Ref a -> impl Source #

swapBuffers :: (HasCallStack, Match r ~ FindOp a a (SwapBuffers ()), Op (SwapBuffers ()) r a impl) => Ref a -> impl Source #

data Ortho a Source #

ortho :: (HasCallStack, Match r ~ FindOp a a (Ortho ()), Op (Ortho ()) r a impl) => Ref a -> impl Source #

hideOverlay :: (HasCallStack, Match r ~ FindOp a a (HideOverlay ()), Op (HideOverlay ()) r a impl) => Ref a -> impl Source #

pixelsPerUnit :: (HasCallStack, Match r ~ FindOp a a (PixelsPerUnit ()), Op (PixelsPerUnit ()) r a impl) => Ref a -> impl Source #

data PixelH a Source #

pixelH :: (HasCallStack, Match r ~ FindOp a a (PixelH ()), Op (PixelH ()) r a impl) => Ref a -> impl Source #

data PixelW a Source #

pixelW :: (HasCallStack, Match r ~ FindOp a a (PixelW ()), Op (PixelW ()) r a impl) => Ref a -> impl Source #

Box

type Box = CBox Widget Source #

Browser

type Browser = CBrowser Group Source #

data Move a Source #

move :: (HasCallStack, Match r ~ FindOp a a (Move ()), Op (Move ()) r a impl) => Ref a -> impl Source #

data Load a Source #

load :: (HasCallStack, Match r ~ FindOp a a (Load ()), Op (Load ()) r a impl) => Ref a -> impl Source #

data Swap a Source #

swap :: (HasCallStack, Match r ~ FindOp a a (Swap ()), Op (Swap ()) r a impl) => Ref a -> impl Source #

getTopline :: (HasCallStack, Match r ~ FindOp a a (GetTopline ()), Op (GetTopline ()) r a impl) => Ref a -> impl Source #

lineposition :: (HasCallStack, Match r ~ FindOp a a (Lineposition ()), Op (Lineposition ()) r a impl) => Ref a -> impl Source #

setTopline :: (HasCallStack, Match r ~ FindOp a a (SetTopline ()), Op (SetTopline ()) r a impl) => Ref a -> impl Source #

setBottomline :: (HasCallStack, Match r ~ FindOp a a (SetBottomline ()), Op (SetBottomline ()) r a impl) => Ref a -> impl Source #

setMiddleline :: (HasCallStack, Match r ~ FindOp a a (SetMiddleline ()), Op (SetMiddleline ()) r a impl) => Ref a -> impl Source #

data Select a Source #

select :: (HasCallStack, Match r ~ FindOp a a (Select ()), Op (Select ()) r a impl) => Ref a -> impl Source #

selected :: (HasCallStack, Match r ~ FindOp a a (Selected ()), Op (Selected ()) r a impl) => Ref a -> impl Source #

showWidgetLine :: (HasCallStack, Match r ~ FindOp a a (ShowWidgetLine ()), Op (ShowWidgetLine ()) r a impl) => Ref a -> impl Source #

hideLine :: (HasCallStack, Match r ~ FindOp a a (HideLine ()), Op (HideLine ()) r a impl) => Ref a -> impl Source #

setText :: (HasCallStack, Match r ~ FindOp a a (SetText ()), Op (SetText ()) r a impl) => Ref a -> impl Source #

getFormatChar :: (HasCallStack, Match r ~ FindOp a a (GetFormatChar ()), Op (GetFormatChar ()) r a impl) => Ref a -> impl Source #

setFormatChar :: (HasCallStack, Match r ~ FindOp a a (SetFormatChar ()), Op (SetFormatChar ()) r a impl) => Ref a -> impl Source #

getColumnChar :: (HasCallStack, Match r ~ FindOp a a (GetColumnChar ()), Op (GetColumnChar ()) r a impl) => Ref a -> impl Source #

setColumnChar :: (HasCallStack, Match r ~ FindOp a a (SetColumnChar ()), Op (SetColumnChar ()) r a impl) => Ref a -> impl Source #

getColumnWidths :: (HasCallStack, Match r ~ FindOp a a (GetColumnWidths ()), Op (GetColumnWidths ()) r a impl) => Ref a -> impl Source #

setColumnWidths :: (HasCallStack, Match r ~ FindOp a a (SetColumnWidths ()), Op (SetColumnWidths ()) r a impl) => Ref a -> impl Source #

displayed :: (HasCallStack, Match r ~ FindOp a a (Displayed ()), Op (Displayed ()) r a impl) => Ref a -> impl Source #

makeVisible :: (HasCallStack, Match r ~ FindOp a a (MakeVisible ()), Op (MakeVisible ()) r a impl) => Ref a -> impl Source #

removeIcon :: (HasCallStack, Match r ~ FindOp a a (RemoveIcon ()), Op (RemoveIcon ()) r a impl) => Ref a -> impl Source #

selectOnly :: (HasCallStack, Match r ~ FindOp a a (SelectOnly ()), Op (SelectOnly ()) r a impl) => Ref a -> impl Source #

deselect :: (HasCallStack, Match r ~ FindOp a a (Deselect ()), Op (Deselect ()) r a impl) => Ref a -> impl Source #

getHposition :: (HasCallStack, Match r ~ FindOp a a (GetHposition ()), Op (GetHposition ()) r a impl) => Ref a -> impl Source #

setHposition :: (HasCallStack, Match r ~ FindOp a a (SetHposition ()), Op (SetHposition ()) r a impl) => Ref a -> impl Source #

getHasScrollbar :: (HasCallStack, Match r ~ FindOp a a (GetHasScrollbar ()), Op (GetHasScrollbar ()) r a impl) => Ref a -> impl Source #

setHasScrollbar :: (HasCallStack, Match r ~ FindOp a a (SetHasScrollbar ()), Op (SetHasScrollbar ()) r a impl) => Ref a -> impl Source #

getScrollbarSize :: (HasCallStack, Match r ~ FindOp a a (GetScrollbarSize ()), Op (GetScrollbarSize ()) r a impl) => Ref a -> impl Source #

setScrollbarSize :: (HasCallStack, Match r ~ FindOp a a (SetScrollbarSize ()), Op (SetScrollbarSize ()) r a impl) => Ref a -> impl Source #

data Sort a Source #

sort :: (HasCallStack, Match r ~ FindOp a a (Sort ()), Op (Sort ()) r a impl) => Ref a -> impl Source #

sortWithSortType :: (HasCallStack, Match r ~ FindOp a a (SortWithSortType ()), Op (SortWithSortType ()) r a impl) => Ref a -> impl Source #

SelectBrowser

type SelectBrowser = CSelectBrowser Browser Source #

IntInput

type IntInput = CIntInput Input Source #

Clock

type Clock = CClock Widget Source #

TreePrefs

type TreePrefs = CTreePrefs Base Source #

getItemLabelfont :: (HasCallStack, Match r ~ FindOp a a (GetItemLabelfont ()), Op (GetItemLabelfont ()) r a impl) => Ref a -> impl Source #

getItemLabelsize :: (HasCallStack, Match r ~ FindOp a a (GetItemLabelsize ()), Op (GetItemLabelsize ()) r a impl) => Ref a -> impl Source #

setItemLabelsize :: (HasCallStack, Match r ~ FindOp a a (SetItemLabelsize ()), Op (SetItemLabelsize ()) r a impl) => Ref a -> impl Source #

getLabelfgcolor :: (HasCallStack, Match r ~ FindOp a a (GetLabelfgcolor ()), Op (GetLabelfgcolor ()) r a impl) => Ref a -> impl Source #

setLabelfgcolor :: (HasCallStack, Match r ~ FindOp a a (SetLabelfgcolor ()), Op (SetLabelfgcolor ()) r a impl) => Ref a -> impl Source #

getLabelbgcolor :: (HasCallStack, Match r ~ FindOp a a (GetLabelbgcolor ()), Op (GetLabelbgcolor ()) r a impl) => Ref a -> impl Source #

setLabelbgcolor :: (HasCallStack, Match r ~ FindOp a a (SetLabelbgcolor ()), Op (SetLabelbgcolor ()) r a impl) => Ref a -> impl Source #

getMarginleft :: (HasCallStack, Match r ~ FindOp a a (GetMarginleft ()), Op (GetMarginleft ()) r a impl) => Ref a -> impl Source #

setMarginleft :: (HasCallStack, Match r ~ FindOp a a (SetMarginleft ()), Op (SetMarginleft ()) r a impl) => Ref a -> impl Source #

getMargintop :: (HasCallStack, Match r ~ FindOp a a (GetMargintop ()), Op (GetMargintop ()) r a impl) => Ref a -> impl Source #

setMargintop :: (HasCallStack, Match r ~ FindOp a a (SetMargintop ()), Op (SetMargintop ()) r a impl) => Ref a -> impl Source #

getLinespacing :: (HasCallStack, Match r ~ FindOp a a (GetLinespacing ()), Op (GetLinespacing ()) r a impl) => Ref a -> impl Source #

setLinespacing :: (HasCallStack, Match r ~ FindOp a a (SetLinespacing ()), Op (SetLinespacing ()) r a impl) => Ref a -> impl Source #

getOpenicon :: (HasCallStack, Match r ~ FindOp a a (GetOpenicon ()), Op (GetOpenicon ()) r a impl) => Ref a -> impl Source #

setOpenicon :: (HasCallStack, Match r ~ FindOp a a (SetOpenicon ()), Op (SetOpenicon ()) r a impl) => Ref a -> impl Source #

getCloseicon :: (HasCallStack, Match r ~ FindOp a a (GetCloseicon ()), Op (GetCloseicon ()) r a impl) => Ref a -> impl Source #

setCloseicon :: (HasCallStack, Match r ~ FindOp a a (SetCloseicon ()), Op (SetCloseicon ()) r a impl) => Ref a -> impl Source #

getUsericon :: (HasCallStack, Match r ~ FindOp a a (GetUsericon ()), Op (GetUsericon ()) r a impl) => Ref a -> impl Source #

setUsericon :: (HasCallStack, Match r ~ FindOp a a (SetUsericon ()), Op (SetUsericon ()) r a impl) => Ref a -> impl Source #

getShowcollapse :: (HasCallStack, Match r ~ FindOp a a (GetShowcollapse ()), Op (GetShowcollapse ()) r a impl) => Ref a -> impl Source #

setShowcollapse :: (HasCallStack, Match r ~ FindOp a a (SetShowcollapse ()), Op (SetShowcollapse ()) r a impl) => Ref a -> impl Source #

getSortorder :: (HasCallStack, Match r ~ FindOp a a (GetSortorder ()), Op (GetSortorder ()) r a impl) => Ref a -> impl Source #

setSortorder :: (HasCallStack, Match r ~ FindOp a a (SetSortorder ()), Op (SetSortorder ()) r a impl) => Ref a -> impl Source #

getSelectbox :: (HasCallStack, Match r ~ FindOp a a (GetSelectbox ()), Op (GetSelectbox ()) r a impl) => Ref a -> impl Source #

setSelectbox :: (HasCallStack, Match r ~ FindOp a a (SetSelectbox ()), Op (SetSelectbox ()) r a impl) => Ref a -> impl Source #

getShowroot :: (HasCallStack, Match r ~ FindOp a a (GetShowroot ()), Op (GetShowroot ()) r a impl) => Ref a -> impl Source #

setShowroot :: (HasCallStack, Match r ~ FindOp a a (SetShowroot ()), Op (SetShowroot ()) r a impl) => Ref a -> impl Source #

getSelectmode :: (HasCallStack, Match r ~ FindOp a a (GetSelectmode ()), Op (GetSelectmode ()) r a impl) => Ref a -> impl Source #

setSelectmode :: (HasCallStack, Match r ~ FindOp a a (SetSelectmode ()), Op (SetSelectmode ()) r a impl) => Ref a -> impl Source #

TreeItem

type TreeItem = CTreeItem Base Source #

showSelf :: (HasCallStack, Match r ~ FindOp a a (ShowSelf ()), Op (ShowSelf ()) r a impl) => Ref a -> impl Source #

setWidget :: (HasCallStack, Match r ~ FindOp a a (SetWidget ()), Op (SetWidget ()) r a impl) => Ref a -> impl Source #

getWidget :: (HasCallStack, Match r ~ FindOp a a (GetWidget ()), Op (GetWidget ()) r a impl) => Ref a -> impl Source #

data Child a Source #

child :: (HasCallStack, Match r ~ FindOp a a (Child ()), Op (Child ()) r a impl) => Ref a -> impl Source #

hasChildren :: (HasCallStack, Match r ~ FindOp a a (HasChildren ()), Op (HasChildren ()) r a impl) => Ref a -> impl Source #

findChild :: (HasCallStack, Match r ~ FindOp a a (FindChild ()), Op (FindChild ()) r a impl) => Ref a -> impl Source #

removeChild :: (HasCallStack, Match r ~ FindOp a a (RemoveChild ()), Op (RemoveChild ()) r a impl) => Ref a -> impl Source #

clearChildren :: (HasCallStack, Match r ~ FindOp a a (ClearChildren ()), Op (ClearChildren ()) r a impl) => Ref a -> impl Source #

swapChildren :: (HasCallStack, Match r ~ FindOp a a (SwapChildren ()), Op (SwapChildren ()) r a impl) => Ref a -> impl Source #

findInChildren :: (HasCallStack, Match r ~ FindOp a a (FindInChildren ()), Op (FindInChildren ()) r a impl) => Ref a -> impl Source #

findItem :: (HasCallStack, Match r ~ FindOp a a (FindItem ()), Op (FindItem ()) r a impl) => Ref a -> impl Source #

data AddAt a Source #

addAt :: (HasCallStack, Match r ~ FindOp a a (AddAt ()), Op (AddAt ()) r a impl) => Ref a -> impl Source #

insertAbove :: (HasCallStack, Match r ~ FindOp a a (InsertAbove ()), Op (InsertAbove ()) r a impl) => Ref a -> impl Source #

deparent :: (HasCallStack, Match r ~ FindOp a a (Deparent ()), Op (Deparent ()) r a impl) => Ref a -> impl Source #

reparent :: (HasCallStack, Match r ~ FindOp a a (Reparent ()), Op (Reparent ()) r a impl) => Ref a -> impl Source #

data MoveTo a Source #

moveTo :: (HasCallStack, Match r ~ FindOp a a (MoveTo ()), Op (MoveTo ()) r a impl) => Ref a -> impl Source #

getDepth :: (HasCallStack, Match r ~ FindOp a a (GetDepth ()), Op (GetDepth ()) r a impl) => Ref a -> impl Source #

nextSibling :: (HasCallStack, Match r ~ FindOp a a (NextSibling ()), Op (NextSibling ()) r a impl) => Ref a -> impl Source #

prevSibling :: (HasCallStack, Match r ~ FindOp a a (PrevSibling ()), Op (PrevSibling ()) r a impl) => Ref a -> impl Source #

updatePrevNext :: (HasCallStack, Match r ~ FindOp a a (UpdatePrevNext ()), Op (UpdatePrevNext ()) r a impl) => Ref a -> impl Source #

nextDisplayed :: (HasCallStack, Match r ~ FindOp a a (NextDisplayed ()), Op (NextDisplayed ()) r a impl) => Ref a -> impl Source #

prevDisplayed :: (HasCallStack, Match r ~ FindOp a a (PrevDisplayed ()), Op (PrevDisplayed ()) r a impl) => Ref a -> impl Source #

data Open a Source #

open :: (HasCallStack, Match r ~ FindOp a a (Open ()), Op (Open ()) r a impl) => Ref a -> impl Source #

data Close a Source #

close :: (HasCallStack, Match r ~ FindOp a a (Close ()), Op (Close ()) r a impl) => Ref a -> impl Source #

data IsOpen a Source #

isOpen :: (HasCallStack, Match r ~ FindOp a a (IsOpen ()), Op (IsOpen ()) r a impl) => Ref a -> impl Source #

isClose :: (HasCallStack, Match r ~ FindOp a a (IsClose ()), Op (IsClose ()) r a impl) => Ref a -> impl Source #

openToggle :: (HasCallStack, Match r ~ FindOp a a (OpenToggle ()), Op (OpenToggle ()) r a impl) => Ref a -> impl Source #

selectWithVal :: (HasCallStack, Match r ~ FindOp a a (SelectWithVal ()), Op (SelectWithVal ()) r a impl) => Ref a -> impl Source #

selectToggle :: (HasCallStack, Match r ~ FindOp a a (SelectToggle ()), Op (SelectToggle ()) r a impl) => Ref a -> impl Source #

selectAll :: (HasCallStack, Match r ~ FindOp a a (SelectAll ()), Op (SelectAll ()) r a impl) => Ref a -> impl Source #

deselectAll :: (HasCallStack, Match r ~ FindOp a a (DeselectAll ()), Op (DeselectAll ()) r a impl) => Ref a -> impl Source #

activateWith :: (HasCallStack, Match r ~ FindOp a a (ActivateWith ()), Op (ActivateWith ()) r a impl) => Ref a -> impl Source #

isActive :: (HasCallStack, Match r ~ FindOp a a (IsActive ()), Op (IsActive ()) r a impl) => Ref a -> impl Source #

isVisible :: (HasCallStack, Match r ~ FindOp a a (IsVisible ()), Op (IsVisible ()) r a impl) => Ref a -> impl Source #

visibleR :: (HasCallStack, Match r ~ FindOp a a (VisibleR ()), Op (VisibleR ()) r a impl) => Ref a -> impl Source #

findClicked :: (HasCallStack, Match r ~ FindOp a a (FindClicked ()), Op (FindClicked ()) r a impl) => Ref a -> impl Source #

eventOnLabel :: (HasCallStack, Match r ~ FindOp a a (EventOnLabel ()), Op (EventOnLabel ()) r a impl) => Ref a -> impl Source #

data IsRoot a Source #

isRoot :: (HasCallStack, Match r ~ FindOp a a (IsRoot ()), Op (IsRoot ()) r a impl) => Ref a -> impl Source #

data LabelX a Source #

labelX :: (HasCallStack, Match r ~ FindOp a a (LabelX ()), Op (LabelX ()) r a impl) => Ref a -> impl Source #

data LabelY a Source #

labelY :: (HasCallStack, Match r ~ FindOp a a (LabelY ()), Op (LabelY ()) r a impl) => Ref a -> impl Source #

data LabelW a Source #

labelW :: (HasCallStack, Match r ~ FindOp a a (LabelW ()), Op (LabelW ()) r a impl) => Ref a -> impl Source #

data LabelH a Source #

labelH :: (HasCallStack, Match r ~ FindOp a a (LabelH ()), Op (LabelH ()) r a impl) => Ref a -> impl Source #

Tree

type Tree = CTree Group Source #

rootLabel :: (HasCallStack, Match r ~ FindOp a a (RootLabel ()), Op (RootLabel ()) r a impl) => Ref a -> impl Source #

data Root a Source #

root :: (HasCallStack, Match r ~ FindOp a a (Root ()), Op (Root ()) r a impl) => Ref a -> impl Source #

itemClicked :: (HasCallStack, Match r ~ FindOp a a (ItemClicked ()), Op (ItemClicked ()) r a impl) => Ref a -> impl Source #

firstVisible :: (HasCallStack, Match r ~ FindOp a a (FirstVisible ()), Op (FirstVisible ()) r a impl) => Ref a -> impl Source #

nextItem :: (HasCallStack, Match r ~ FindOp a a (NextItem ()), Op (NextItem ()) r a impl) => Ref a -> impl Source #

nextAfterItem :: (HasCallStack, Match r ~ FindOp a a (NextAfterItem ()), Op (NextAfterItem ()) r a impl) => Ref a -> impl Source #

prevBeforeItem :: (HasCallStack, Match r ~ FindOp a a (PrevBeforeItem ()), Op (PrevBeforeItem ()) r a impl) => Ref a -> impl Source #

getLast :: (HasCallStack, Match r ~ FindOp a a (GetLast ()), Op (GetLast ()) r a impl) => Ref a -> impl Source #

lastVisible :: (HasCallStack, Match r ~ FindOp a a (LastVisible ()), Op (LastVisible ()) r a impl) => Ref a -> impl Source #

lastSelectedItem :: (HasCallStack, Match r ~ FindOp a a (LastSelectedItem ()), Op (LastSelectedItem ()) r a impl) => Ref a -> impl Source #

nextSelectedItem :: (HasCallStack, Match r ~ FindOp a a (NextSelectedItem ()), Op (NextSelectedItem ()) r a impl) => Ref a -> impl Source #

openAndCallback :: (HasCallStack, Match r ~ FindOp a a (OpenAndCallback ()), Op (OpenAndCallback ()) r a impl) => Ref a -> impl Source #

closeAndCallback :: (HasCallStack, Match r ~ FindOp a a (CloseAndCallback ()), Op (CloseAndCallback ()) r a impl) => Ref a -> impl Source #

setItemFocus :: (HasCallStack, Match r ~ FindOp a a (SetItemFocus ()), Op (SetItemFocus ()) r a impl) => Ref a -> impl Source #

getItemFocus :: (HasCallStack, Match r ~ FindOp a a (GetItemFocus ()), Op (GetItemFocus ()) r a impl) => Ref a -> impl Source #

setItemLabelfont :: (HasCallStack, Match r ~ FindOp a a (SetItemLabelfont ()), Op (SetItemLabelfont ()) r a impl) => Ref a -> impl Source #

selectmode :: (HasCallStack, Match r ~ FindOp a a (Selectmode ()), Op (Selectmode ()) r a impl) => Ref a -> impl Source #

showItemWithYoff :: (HasCallStack, Match r ~ FindOp a a (ShowItemWithYoff ()), Op (ShowItemWithYoff ()) r a impl) => Ref a -> impl Source #

showItemTop :: (HasCallStack, Match r ~ FindOp a a (ShowItemTop ()), Op (ShowItemTop ()) r a impl) => Ref a -> impl Source #

showItemMiddle :: (HasCallStack, Match r ~ FindOp a a (ShowItemMiddle ()), Op (ShowItemMiddle ()) r a impl) => Ref a -> impl Source #

showItemBottom :: (HasCallStack, Match r ~ FindOp a a (ShowItemBottom ()), Op (ShowItemBottom ()) r a impl) => Ref a -> impl Source #

display :: (HasCallStack, Match r ~ FindOp a a (Display ()), Op (Display ()) r a impl) => Ref a -> impl Source #

getVposition :: (HasCallStack, Match r ~ FindOp a a (GetVposition ()), Op (GetVposition ()) r a impl) => Ref a -> impl Source #

setVposition :: (HasCallStack, Match r ~ FindOp a a (SetVposition ()), Op (SetVposition ()) r a impl) => Ref a -> impl Source #

isScrollbar :: (HasCallStack, Match r ~ FindOp a a (IsScrollbar ()), Op (IsScrollbar ()) r a impl) => Ref a -> impl Source #

isVscrollVisible :: (HasCallStack, Match r ~ FindOp a a (IsVscrollVisible ()), Op (IsVscrollVisible ()) r a impl) => Ref a -> impl Source #

setCallbackItem :: (HasCallStack, Match r ~ FindOp a a (SetCallbackItem ()), Op (SetCallbackItem ()) r a impl) => Ref a -> impl Source #

getCallbackItem :: (HasCallStack, Match r ~ FindOp a a (GetCallbackItem ()), Op (GetCallbackItem ()) r a impl) => Ref a -> impl Source #

TextSelection

type TextSelection = CTextSelection Base Source #

data Update a Source #

update :: (HasCallStack, Match r ~ FindOp a a (Update ()), Op (Update ()) r a impl) => Ref a -> impl Source #

data Start a Source #

start :: (HasCallStack, Match r ~ FindOp a a (Start ()), Op (Start ()) r a impl) => Ref a -> impl Source #

setSelected :: (HasCallStack, Match r ~ FindOp a a (SetSelected ()), Op (SetSelected ()) r a impl) => Ref a -> impl Source #

includes :: (HasCallStack, Match r ~ FindOp a a (Includes ()), Op (Includes ()) r a impl) => Ref a -> impl Source #

TextBuffer

type TextBuffer = CTextBuffer Base Source #

getLength :: (HasCallStack, Match r ~ FindOp a a (GetLength ()), Op (GetLength ()) r a impl) => Ref a -> impl Source #

textRange :: (HasCallStack, Match r ~ FindOp a a (TextRange ()), Op (TextRange ()) r a impl) => Ref a -> impl Source #

data CharAt a Source #

charAt :: (HasCallStack, Match r ~ FindOp a a (CharAt ()), Op (CharAt ()) r a impl) => Ref a -> impl Source #

data ByteAt a Source #

byteAt :: (HasCallStack, Match r ~ FindOp a a (ByteAt ()), Op (ByteAt ()) r a impl) => Ref a -> impl Source #

appendToBuffer :: (HasCallStack, Match r ~ FindOp a a (AppendToBuffer ()), Op (AppendToBuffer ()) r a impl) => Ref a -> impl Source #

canUndo :: (HasCallStack, Match r ~ FindOp a a (CanUndo ()), Op (CanUndo ()) r a impl) => Ref a -> impl Source #

insertfile :: (HasCallStack, Match r ~ FindOp a a (Insertfile ()), Op (Insertfile ()) r a impl) => Ref a -> impl Source #

appendfile :: (HasCallStack, Match r ~ FindOp a a (Appendfile ()), Op (Appendfile ()) r a impl) => Ref a -> impl Source #

loadfile :: (HasCallStack, Match r ~ FindOp a a (Loadfile ()), Op (Loadfile ()) r a impl) => Ref a -> impl Source #

outputfile :: (HasCallStack, Match r ~ FindOp a a (Outputfile ()), Op (Outputfile ()) r a impl) => Ref a -> impl Source #

savefile :: (HasCallStack, Match r ~ FindOp a a (Savefile ()), Op (Savefile ()) r a impl) => Ref a -> impl Source #

getTabDistance :: (HasCallStack, Match r ~ FindOp a a (GetTabDistance ()), Op (GetTabDistance ()) r a impl) => Ref a -> impl Source #

setTabDistance :: (HasCallStack, Match r ~ FindOp a a (SetTabDistance ()), Op (SetTabDistance ()) r a impl) => Ref a -> impl Source #

unselect :: (HasCallStack, Match r ~ FindOp a a (Unselect ()), Op (Unselect ()) r a impl) => Ref a -> impl Source #

selectionText :: (HasCallStack, Match r ~ FindOp a a (SelectionText ()), Op (SelectionText ()) r a impl) => Ref a -> impl Source #

removeSelection :: (HasCallStack, Match r ~ FindOp a a (RemoveSelection ()), Op (RemoveSelection ()) r a impl) => Ref a -> impl Source #

replaceSelection :: (HasCallStack, Match r ~ FindOp a a (ReplaceSelection ()), Op (ReplaceSelection ()) r a impl) => Ref a -> impl Source #

secondarySelect :: (HasCallStack, Match r ~ FindOp a a (SecondarySelect ()), Op (SecondarySelect ()) r a impl) => Ref a -> impl Source #

getHighlight :: (HasCallStack, Match r ~ FindOp a a (GetHighlight ()), Op (GetHighlight ()) r a impl) => Ref a -> impl Source #

setHighlight :: (HasCallStack, Match r ~ FindOp a a (SetHighlight ()), Op (SetHighlight ()) r a impl) => Ref a -> impl Source #

unhighlight :: (HasCallStack, Match r ~ FindOp a a (Unhighlight ()), Op (Unhighlight ()) r a impl) => Ref a -> impl Source #

highlightText :: (HasCallStack, Match r ~ FindOp a a (HighlightText ()), Op (HighlightText ()) r a impl) => Ref a -> impl Source #

lineText :: (HasCallStack, Match r ~ FindOp a a (LineText ()), Op (LineText ()) r a impl) => Ref a -> impl Source #

lineStart :: (HasCallStack, Match r ~ FindOp a a (LineStart ()), Op (LineStart ()) r a impl) => Ref a -> impl Source #

lineEnd :: (HasCallStack, Match r ~ FindOp a a (LineEnd ()), Op (LineEnd ()) r a impl) => Ref a -> impl Source #

wordStart :: (HasCallStack, Match r ~ FindOp a a (WordStart ()), Op (WordStart ()) r a impl) => Ref a -> impl Source #

wordEnd :: (HasCallStack, Match r ~ FindOp a a (WordEnd ()), Op (WordEnd ()) r a impl) => Ref a -> impl Source #

countLines :: (HasCallStack, Match r ~ FindOp a a (CountLines ()), Op (CountLines ()) r a impl) => Ref a -> impl Source #

skipLines :: (HasCallStack, Match r ~ FindOp a a (SkipLines ()), Op (SkipLines ()) r a impl) => Ref a -> impl Source #

rewindLines :: (HasCallStack, Match r ~ FindOp a a (RewindLines ()), Op (RewindLines ()) r a impl) => Ref a -> impl Source #

findcharForward :: (HasCallStack, Match r ~ FindOp a a (FindcharForward ()), Op (FindcharForward ()) r a impl) => Ref a -> impl Source #

findcharBackward :: (HasCallStack, Match r ~ FindOp a a (FindcharBackward ()), Op (FindcharBackward ()) r a impl) => Ref a -> impl Source #

primarySelection :: (HasCallStack, Match r ~ FindOp a a (PrimarySelection ()), Op (PrimarySelection ()) r a impl) => Ref a -> impl Source #

prevChar :: (HasCallStack, Match r ~ FindOp a a (PrevChar ()), Op (PrevChar ()) r a impl) => Ref a -> impl Source #

prevCharClipped :: (HasCallStack, Match r ~ FindOp a a (PrevCharClipped ()), Op (PrevCharClipped ()) r a impl) => Ref a -> impl Source #

nextChar :: (HasCallStack, Match r ~ FindOp a a (NextChar ()), Op (NextChar ()) r a impl) => Ref a -> impl Source #

nextCharClipped :: (HasCallStack, Match r ~ FindOp a a (NextCharClipped ()), Op (NextCharClipped ()) r a impl) => Ref a -> impl Source #

utf8Align :: (HasCallStack, Match r ~ FindOp a a (Utf8Align ()), Op (Utf8Align ()) r a impl) => Ref a -> impl Source #

TextDisplay,

type TextDisplay = CTextDisplay Group Source #

setBuffer :: (HasCallStack, Match r ~ FindOp a a (SetBuffer ()), Op (SetBuffer ()) r a impl) => Ref a -> impl Source #

getBuffer :: (HasCallStack, Match r ~ FindOp a a (GetBuffer ()), Op (GetBuffer ()) r a impl) => Ref a -> impl Source #

redisplayRange :: (HasCallStack, Match r ~ FindOp a a (RedisplayRange ()), Op (RedisplayRange ()) r a impl) => Ref a -> impl Source #

data Scroll a Source #

scroll :: (HasCallStack, Match r ~ FindOp a a (Scroll ()), Op (Scroll ()) r a impl) => Ref a -> impl Source #

overstrike :: (HasCallStack, Match r ~ FindOp a a (Overstrike ()), Op (Overstrike ()) r a impl) => Ref a -> impl Source #

positionToXy :: (HasCallStack, Match r ~ FindOp a a (PositionToXy ()), Op (PositionToXy ()) r a impl) => Ref a -> impl Source #

inSelection :: (HasCallStack, Match r ~ FindOp a a (InSelection ()), Op (InSelection ()) r a impl) => Ref a -> impl Source #

moveRight :: (HasCallStack, Match r ~ FindOp a a (MoveRight ()), Op (MoveRight ()) r a impl) => Ref a -> impl Source #

moveLeft :: (HasCallStack, Match r ~ FindOp a a (MoveLeft ()), Op (MoveLeft ()) r a impl) => Ref a -> impl Source #

data MoveUp a Source #

moveUp :: (HasCallStack, Match r ~ FindOp a a (MoveUp ()), Op (MoveUp ()) r a impl) => Ref a -> impl Source #

moveDown :: (HasCallStack, Match r ~ FindOp a a (MoveDown ()), Op (MoveDown ()) r a impl) => Ref a -> impl Source #

nextWord :: (HasCallStack, Match r ~ FindOp a a (NextWord ()), Op (NextWord ()) r a impl) => Ref a -> impl Source #

previousWord :: (HasCallStack, Match r ~ FindOp a a (PreviousWord ()), Op (PreviousWord ()) r a impl) => Ref a -> impl Source #

showCursor :: (HasCallStack, Match r ~ FindOp a a (ShowCursor ()), Op (ShowCursor ()) r a impl) => Ref a -> impl Source #

setCursorStyle :: (HasCallStack, Match r ~ FindOp a a (SetCursorStyle ()), Op (SetCursorStyle ()) r a impl) => Ref a -> impl Source #

highlightData :: (HasCallStack, Match r ~ FindOp a a (HighlightData ()), Op (HighlightData ()) r a impl) => Ref a -> impl Source #

positionStyle :: (HasCallStack, Match r ~ FindOp a a (PositionStyle ()), Op (PositionStyle ()) r a impl) => Ref a -> impl Source #

data XToCol a Source #

xToCol :: (HasCallStack, Match r ~ FindOp a a (XToCol ()), Op (XToCol ()) r a impl) => Ref a -> impl Source #

data ColToX a Source #

colToX :: (HasCallStack, Match r ~ FindOp a a (ColToX ()), Op (ColToX ()) r a impl) => Ref a -> impl Source #

wrapMode :: (HasCallStack, Match r ~ FindOp a a (WrapMode ()), Op (WrapMode ()) r a impl) => Ref a -> impl Source #

TextEditor

type TextEditor = CTextEditor TextDisplay Source #

setInsertMode :: (HasCallStack, Match r ~ FindOp a a (SetInsertMode ()), Op (SetInsertMode ()) r a impl) => Ref a -> impl Source #

getInsertMode :: (HasCallStack, Match r ~ FindOp a a (GetInsertMode ()), Op (GetInsertMode ()) r a impl) => Ref a -> impl Source #

NativeFileChooser

type NativeFileChooser = CNativeFileChooser Base Source #

setOptions :: (HasCallStack, Match r ~ FindOp a a (SetOptions ()), Op (SetOptions ()) r a impl) => Ref a -> impl Source #

getOptions :: (HasCallStack, Match r ~ FindOp a a (GetOptions ()), Op (GetOptions ()) r a impl) => Ref a -> impl Source #

getFilename :: (HasCallStack, Match r ~ FindOp a a (GetFilename ()), Op (GetFilename ()) r a impl) => Ref a -> impl Source #

getFilenameAt :: (HasCallStack, Match r ~ FindOp a a (GetFilenameAt ()), Op (GetFilenameAt ()) r a impl) => Ref a -> impl Source #

setDirectory :: (HasCallStack, Match r ~ FindOp a a (SetDirectory ()), Op (SetDirectory ()) r a impl) => Ref a -> impl Source #

getDirectory :: (HasCallStack, Match r ~ FindOp a a (GetDirectory ()), Op (GetDirectory ()) r a impl) => Ref a -> impl Source #

setTitle :: (HasCallStack, Match r ~ FindOp a a (SetTitle ()), Op (SetTitle ()) r a impl) => Ref a -> impl Source #

getTitle :: (HasCallStack, Match r ~ FindOp a a (GetTitle ()), Op (GetTitle ()) r a impl) => Ref a -> impl Source #

getFilter :: (HasCallStack, Match r ~ FindOp a a (GetFilter ()), Op (GetFilter ()) r a impl) => Ref a -> impl Source #

setFilter :: (HasCallStack, Match r ~ FindOp a a (SetFilter ()), Op (SetFilter ()) r a impl) => Ref a -> impl Source #

filters :: (HasCallStack, Match r ~ FindOp a a (Filters ()), Op (Filters ()) r a impl) => Ref a -> impl Source #

setFilterValue :: (HasCallStack, Match r ~ FindOp a a (SetFilterValue ()), Op (SetFilterValue ()) r a impl) => Ref a -> impl Source #

getFilterValue :: (HasCallStack, Match r ~ FindOp a a (GetFilterValue ()), Op (GetFilterValue ()) r a impl) => Ref a -> impl Source #

setPresetFile :: (HasCallStack, Match r ~ FindOp a a (SetPresetFile ()), Op (SetPresetFile ()) r a impl) => Ref a -> impl Source #

getPresetFile :: (HasCallStack, Match r ~ FindOp a a (GetPresetFile ()), Op (GetPresetFile ()) r a impl) => Ref a -> impl Source #

getErrmsg :: (HasCallStack, Match r ~ FindOp a a (GetErrmsg ()), Op (GetErrmsg ()) r a impl) => Ref a -> impl Source #

Tile

type Tile = CTile Group Source #

type Pack = CPack Group Source #

setSpacing :: (HasCallStack, Match r ~ FindOp a a (SetSpacing ()), Op (SetSpacing ()) r a impl) => Ref a -> impl Source #

getSpacing :: (HasCallStack, Match r ~ FindOp a a (GetSpacing ()), Op (GetSpacing ()) r a impl) => Ref a -> impl Source #

isHorizontal :: (HasCallStack, Match r ~ FindOp a a (IsHorizontal ()), Op (IsHorizontal ()) r a impl) => Ref a -> impl Source #

type Scrolled = CScrolled Group Source #

scrollTo :: (HasCallStack, Match r ~ FindOp a a (ScrollTo ()), Op (ScrollTo ()) r a impl) => Ref a -> impl Source #

xposition :: (HasCallStack, Match r ~ FindOp a a (Xposition ()), Op (Xposition ()) r a impl) => Ref a -> impl Source #

yposition :: (HasCallStack, Match r ~ FindOp a a (Yposition ()), Op (Yposition ()) r a impl) => Ref a -> impl Source #

type Tabs = CTabs Group Source #

getPush :: (HasCallStack, Match r ~ FindOp a a (GetPush ()), Op (GetPush ()) r a impl) => Ref a -> impl Source #

setPush :: (HasCallStack, Match r ~ FindOp a a (SetPush ()), Op (SetPush ()) r a impl) => Ref a -> impl Source #

data Which a Source #

which :: (HasCallStack, Match r ~ FindOp a a (Which ()), Op (Which ()) r a impl) => Ref a -> impl Source #

clientArea :: (HasCallStack, Match r ~ FindOp a a (ClientArea ()), Op (ClientArea ()) r a impl) => Ref a -> impl Source #

type Spinner = CSpinner Group Source #

getFormat :: (HasCallStack, Match r ~ FindOp a a (GetFormat ()), Op (GetFormat ()) r a impl) => Ref a -> impl Source #

type ColorChooser = CColorChooser Group Source #

data GetHue a Source #

getHue :: (HasCallStack, Match r ~ FindOp a a (GetHue ()), Op (GetHue ()) r a impl) => Ref a -> impl Source #

getSaturation :: (HasCallStack, Match r ~ FindOp a a (GetSaturation ()), Op (GetSaturation ()) r a impl) => Ref a -> impl Source #

data GetR a Source #

getR :: (HasCallStack, Match r ~ FindOp a a (GetR ()), Op (GetR ()) r a impl) => Ref a -> impl Source #

data GetG a Source #

getG :: (HasCallStack, Match r ~ FindOp a a (GetG ()), Op (GetG ()) r a impl) => Ref a -> impl Source #

data GetB a Source #

getB :: (HasCallStack, Match r ~ FindOp a a (GetB ()), Op (GetB ()) r a impl) => Ref a -> impl Source #

data SetHsv a Source #

setHsv :: (HasCallStack, Match r ~ FindOp a a (SetHsv ()), Op (SetHsv ()) r a impl) => Ref a -> impl Source #

data SetRgb a Source #

setRgb :: (HasCallStack, Match r ~ FindOp a a (SetRgb ()), Op (SetRgb ()) r a impl) => Ref a -> impl Source #

type FileBrowser = CFileBrowser Browser Source #

setIconsize :: (HasCallStack, Match r ~ FindOp a a (SetIconsize ()), Op (SetIconsize ()) r a impl) => Ref a -> impl Source #

getIconsize :: (HasCallStack, Match r ~ FindOp a a (GetIconsize ()), Op (GetIconsize ()) r a impl) => Ref a -> impl Source #

setFiletype :: (HasCallStack, Match r ~ FindOp a a (SetFiletype ()), Op (SetFiletype ()) r a impl) => Ref a -> impl Source #

getFiletype :: (HasCallStack, Match r ~ FindOp a a (GetFiletype ()), Op (GetFiletype ()) r a impl) => Ref a -> impl Source #

type RGBImage = CRGBImage Image Source #

type JPEGImage = CJPEGImage RGBImage Source #

type BMPImage = CBMPImage RGBImage Source #

type GIFImage = CGIFImage RGBImage Source #

type XBMImage = CXBMImage RGBImage Source #

type XPMImage = CXPMImage RGBImage Source #

type PNGImage = CPNGImage RGBImage Source #

type PNMImage = CPNMImage RGBImage Source #

type FileInput = CFileInput Input Source #

getErrorColor :: (HasCallStack, Match r ~ FindOp a a (GetErrorColor ()), Op (GetErrorColor ()) r a impl) => Ref a -> impl Source #

setErrorColor :: (HasCallStack, Match r ~ FindOp a a (SetErrorColor ()), Op (SetErrorColor ()) r a impl) => Ref a -> impl Source #