gowid

package module

Go to main page

Versions in this module

v1

v1.4.0

Jul 9, 2022

Changes in this version

type AppArgs

+ EnableBracketedPaste bool

+ EnableMouseMotion bool

+ Screen tcell.Screen

+ Tty string

v1.3.0

Sep 2, 2021

v1.2.0

Oct 29, 2020

Changes in this version

+ var IgnoreBase16 = false

type HAlignLeft

+ MarginRight int

type KeyValueError

+ func (e KeyValueError) Unwrap() error

+ type PrettyModMask tcell.ModMask

+ func (p PrettyModMask) String() string

+ type PrettyTcellKey tcell.EventKey

+ func (p *PrettyTcellKey) String() string

type VAlignBottom

+ Margin int

+ type WidgetCallbackExt struct

+ Name interface{}

+ func MakeWidgetCallbackExt(name interface{}, fn WidgetChangedFunctionExt) WidgetCallbackExt

+ func (f WidgetCallbackExt) ID() interface{}

+ type WidgetChangedFunctionExt func(app IApp, widget IWidget, data ...interface{})

+ func (f WidgetChangedFunctionExt) Changed(app IApp, widget IWidget, data ...interface{})

v1.1.0

Nov 16, 2019

Changes in this version

type App

+ func (a *App) ActivateScreen() error

+ func (a *App) DeactivateScreen()

type AppArgs

+ DontActivate bool

type ClickCallbacks

+ CB **Callbacks

type FocusCallbacks

+ CB **Callbacks

type KeyPressCallbacks

+ CB **Callbacks

type RGBColor

+ func (rgb RGBColor) RGBA() (r, g, b, a uint32)

type SubWidgetCallbacks

+ CB **Callbacks

type SubWidgetsCallbacks

+ CB **Callbacks

v1.0.0

Apr 18, 2019

Changes in this version

+ const Backwards

+ const Forwards

+ const Mode16Colors

+ const Mode24BitColors

+ const Mode256Colors

+ const Mode88Colors

+ const Mode8Colors

+ const ModeMonochrome

+ const StyleAllSet

+ const StyleNoneSet

+ var AllStyleMasks = [...]tcell.AttrMask

+ var AppClosingErr = fmt.Errorf("App is closing - no more events accepted.")

+ var ColorBlack = MakeTCellColorExt(tcell.ColorBlack)

+ var ColorBlue = MakeTCellColorExt(tcell.ColorBlue)

+ var ColorCyan = MakeTCellColorExt(tcell.ColorDarkCyan)

+ var ColorDarkBlue = MakeTCellColorExt(tcell.ColorDarkBlue)

+ var ColorDarkGray = MakeTCellColorExt(tcell.ColorDarkGray)

+ var ColorDarkGreen = MakeTCellColorExt(tcell.ColorDarkGreen)

+ var ColorDarkRed = MakeTCellColorExt(tcell.ColorDarkRed)

+ var ColorDefault = MakeTCellColorExt(tcell.ColorDefault)

+ var ColorGreen = MakeTCellColorExt(tcell.ColorGreen)

+ var ColorLightBlue = MakeTCellColorExt(tcell.ColorLightBlue)

+ var ColorLightGray = MakeTCellColorExt(tcell.ColorLightGray)

+ var ColorLightGreen = MakeTCellColorExt(tcell.ColorLightGreen)

+ var ColorMagenta = MakeTCellColorExt(tcell.ColorDarkMagenta)

+ var ColorNone = MakeTCellNoColor()

+ var ColorOrange = MakeTCellColorExt(tcell.ColorOrange)

+ var ColorPurple = MakeTCellColorExt(tcell.ColorPurple)

+ var ColorRed = MakeTCellColorExt(tcell.ColorRed)

+ var ColorWhite = MakeTCellColorExt(tcell.ColorWhite)

+ var ColorYellow = MakeTCellColorExt(tcell.ColorYellow)

+ var CubeSize256 = 6

+ var CubeStart = 16

+ var Focused = Selector

+ var NotSelected = Selector

+ var NumOfTCellBasicColors = len(tCellBasicColors)

+ var Selected = Selector

+ var StyleBlink = StyleAttrs

+ var StyleBlinkOnly = StyleAttrs

+ var StyleBold = StyleAttrs

+ var StyleBoldOnly = StyleAttrs

+ var StyleDim = StyleAttrs

+ var StyleDimOnly = StyleAttrs

+ var StyleNone = StyleAttrs

+ var StyleReverse = StyleAttrs

+ var StyleReverseOnly = StyleAttrs

+ var StyleUnderline = StyleAttrs

+ var StyleUnderlineOnly = StyleAttrs

+ func AddWidgetCallback(c ICallbacks, name interface{}, cb IWidgetChangedCallback)

+ func AppendBlankLines(c IAppendBlankLines, iters int)

+ func CanvasToString(c ICanvas) string

+ func ChangeFocus(w IWidget, dir Direction, wrap bool, app IApp) bool

+ func CopyModeUserInput(w ICopyModeWidget, ev interface{}, size IRenderSize, focus Selector, app IApp) bool

+ func Draw(canvas IDrawCanvas, mode IColorMode, screen tcell.Screen)

+ func FindNextSelectableFrom(w ICompositeMultipleDimensions, start int, dir Direction, wrap bool) (int, bool)

+ func FindNextSelectableWidget(w []IWidget, pos int, dir Direction, wrap bool) (int, bool)

+ func FixCanvasHeight(c ICanvas, size IRenderSize)

+ func Focus(w IWidget) int

+ func FocusPath(w IWidget) []interface

+ func HandleQuitKeys(app IApp, event interface{}) bool

+ func KeysEqual(k1, k2 IKey) bool

+ func MakeCanvasRightSize(c IRightSizeCanvas, size IRenderSize)

+ func MakeCellStyle(fg TCellColor, bg TCellColor, attr StyleAttrs) tcell.Style

+ func PanicIfCanvasNotRightSize(c IRenderBox, size IRenderSize)

+ func PrefPosition(curw interface{}) gwutil.IntOption

+ func QuitFn(app IApp, widget IWidget)

+ func RangeOverCanvas(c IRangeOverCanvas, f ICellProcessor)

+ func RemoveWidgetCallback(c ICallbacks, name interface{}, id IIdentity)

+ func RenderRoot(w IWidget, t *App)

+ func RunWidgetCallbacks(c ICallbacks, name interface{}, app IApp, data ...interface{})

+ func SelectableIfAnySubWidgetsAre(w ICompositeMultipleDimensions) bool

+ func SetPrefPosition(curw interface{}, prefPos int, app IApp) bool

+ func TranslatedMouseEvent(ev interface{}, x, y int) interface

+ func UserInput(w IWidget, ev interface{}, size IRenderSize, focus Selector, app IApp) bool

+ func UserInputIfSelectable(w IWidget, ev interface{}, size IRenderSize, focus Selector, app IApp) bool

+ func WithKVs(err error, kvs map[string]interface{}) error

+ func WriteToCanvas(c IRangeOverCanvas, p []byte) (n int, err error)

+ type AddressProvidesID struct

+ func (a *AddressProvidesID) ID() interface{}

+ type App struct

+ AfterRenderEvents chan IAfterRenderEvent

+ TCellEvents chan tcell.Event

+ func NewApp(args AppArgs) (rapp *App, rerr error)

+ func (a *App) Clips() []ICopyResult

+ func (a *App) Close()

+ func (a *App) CopyLevel(lvl ...int) int

+ func (a *App) CopyModeClaimedAt(lvl ...int) int

+ func (a *App) CopyModeClaimedBy(id ...IIdentity) IIdentity

+ func (a *App) GetColorMode() ColorMode

+ func (a *App) GetLastMouseState() MouseState

+ func (a *App) GetMouseState() MouseState

+ func (a *App) GetPalette() IPalette

+ func (a *App) GetScreen() tcell.Screen

+ func (a *App) HandleTCellEvent(ev interface{}, unhandled IUnhandledInput)

+ func (a *App) InCopyMode(on ...bool) bool

+ func (a *App) MainLoop(unhandled IUnhandledInput)

+ func (a *App) Quit()

+ func (a *App) Redraw()

+ func (a *App) RedrawTerminal()

+ func (a *App) RefreshCopyMode()

+ func (a *App) RegisterMenu(menu IMenuCompatible)

+ func (a *App) Run(f IAfterRenderEvent) error

+ func (a *App) RunThenRenderEvent(ev IAfterRenderEvent)

+ func (a *App) Runner() *AppRunner

+ func (a *App) SetColorMode(mode ColorMode)

+ func (a *App) SetPalette(palette IPalette)

+ func (a *App) SetSubWidget(widget IWidget, app IApp)

+ func (a *App) SimpleMainLoop()

+ func (a *App) StartTCellEvents(quit <-chan Unit, wg *sync.WaitGroup)

+ func (a *App) StopTCellEvents(quit chan<- Unit, wg *sync.WaitGroup)

+ func (a *App) SubWidget() IWidget

+ func (a *App) Sync()

+ func (a *App) TerminalSize() (x, y int)

+ func (a *App) UnregisterMenu(menu IMenuCompatible) bool

+ type AppArgs struct

+ Log log.StdLogger

+ Palette IPalette

+ View IWidget

+ type AppRunner struct

+ func (st *AppRunner) Start()

+ func (st *AppRunner) Stop()

+ type BackgroundColor struct

+ func MakeBackground(c IColor) BackgroundColor

+ func (a BackgroundColor) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type Callback struct

+ Name interface{}

+ func (f Callback) ID() interface{}

+ type CallbackFunction func(args ...interface{})

+ func (f CallbackFunction) Call(args ...interface{})

+ type CallbackID struct

+ Name interface{}

+ func (f CallbackID) ID() interface{}

+ type Callbacks struct

+ func NewCallbacks() *Callbacks

+ func (c *Callbacks) AddCallback(name interface{}, cb ICallback)

+ func (c *Callbacks) CopyOfCallbacks(name interface{}) ([]ICallback, bool)

+ func (c *Callbacks) RemoveCallback(name interface{}, cb IIdentity) bool

+ func (c *Callbacks) RunCallbacks(name interface{}, args ...interface{})

+ type Canvas struct

+ Lines [][]Cell

+ Marks map[string]CanvasPos

+ func NewCanvas() *Canvas

+ func NewCanvasOfSize(cols, rows int) *Canvas

+ func NewCanvasOfSizeExt(cols, rows int, fill Cell) *Canvas

+ func NewCanvasWithLines(lines [][]Cell) *Canvas

+ func (c *Canvas) AlignRight()

+ func (c *Canvas) AlignRightWith(cell Cell)

+ func (c *Canvas) AppendBelow(c2 IAppendCanvas, doCursor bool, makeCopy bool)

+ func (c *Canvas) AppendLine(line []Cell, makeCopy bool)

+ func (c *Canvas) AppendRight(c2 IMergeCanvas, useCursor bool)

+ func (c *Canvas) BoxColumns() int

+ func (c *Canvas) BoxRows() int

+ func (c *Canvas) CellAt(col, row int) Cell

+ func (c *Canvas) ComputeCurrentMaxColumn() int

+ func (c *Canvas) CursorCoords() CanvasPos

+ func (c *Canvas) CursorEnabled() bool

+ func (c *Canvas) Duplicate() ICanvas

+ func (c *Canvas) ExtendLeft(cells []Cell)

+ func (c *Canvas) ExtendRight(cells []Cell)

+ func (c *Canvas) GetMark(name string) (CanvasPos, bool)

+ func (c *Canvas) ImplementsWidgetDimension()

+ func (c *Canvas) Line(y int, cp LineCopy) LineResult

+ func (c *Canvas) MergeUnder(c2 IMergeCanvas, leftOffset, topOffset int, bottomGetsCursor bool)

+ func (c *Canvas) MergeWithFunc(c2 IMergeCanvas, leftOffset, topOffset int, fn CellMergeFunc, ...)

+ func (c *Canvas) RangeOverMarks(f func(key string, value CanvasPos) bool)

+ func (c *Canvas) RemoveMark(name string)

+ func (c *Canvas) SetCellAt(col, row int, cell Cell)

+ func (c *Canvas) SetCursorCoords(x, y int)

+ func (c *Canvas) SetLineAt(row int, line []Cell)

+ func (c *Canvas) SetMark(name string, x, y int)

+ func (c *Canvas) String() string

+ func (c *Canvas) TrimLeft(colsToHave int)

+ func (c *Canvas) TrimRight(colsToHave int)

+ func (c *Canvas) Truncate(above, below int)

+ func (c *Canvas) Write(p []byte) (n int, err error)

+ type CanvasPos struct

+ X int

+ Y int

+ func (c CanvasPos) PlusX(n int) CanvasPos

+ func (c CanvasPos) PlusY(n int) CanvasPos

+ type CanvasSizeWrong struct

+ Actual IRenderBox

+ Requested IRenderSize

+ func (e CanvasSizeWrong) Error() string

+ type Cell struct

+ func CellFromRune(r rune) Cell

+ func CellsFromString(s string) []Cell

+ func EmptyLine(length int) []Cell

+ func MakeCell(codePoint rune, fg TCellColor, bg TCellColor, Attr StyleAttrs) Cell

+ func (c Cell) BackgroundColor() TCellColor

+ func (c Cell) ForegroundColor() TCellColor

+ func (c Cell) GetDisplayAttrs() (x TCellColor, y TCellColor, z StyleAttrs)

+ func (c Cell) HasRune() bool

+ func (c Cell) MergeDisplayAttrsUnder(upper Cell) Cell

+ func (c Cell) MergeUnder(upper Cell) Cell

+ func (c Cell) Rune() rune

+ func (c Cell) Style() StyleAttrs

+ func (c Cell) WithBackgroundColor(a TCellColor) Cell

+ func (c Cell) WithForegroundColor(a TCellColor) Cell

+ func (c Cell) WithNoRune() Cell

+ func (c Cell) WithRune(r rune) Cell

+ func (c Cell) WithStyle(attr StyleAttrs) Cell

+ type CellMergeFunc func(lower, upper Cell) Cell

+ type CellRangeFunc func(cell Cell) Cell

+ func (f CellRangeFunc) ProcessCell(cell Cell) Cell

+ type ClickCB struct

+ type ClickCallbacks struct

+ func (w *ClickCallbacks) OnClick(f IWidgetChangedCallback)

+ func (w *ClickCallbacks) RemoveOnClick(f IIdentity)

+ type ClickTargets struct

+ func MakeClickTargets() ClickTargets

+ func (t ClickTargets) ClickTarget(f func(tcell.ButtonMask, IIdentityWidget))

+ func (t ClickTargets) DeleteClickTargets(k tcell.ButtonMask)

+ func (t ClickTargets) SetClickTarget(k tcell.ButtonMask, w IIdentityWidget) bool

+ type Color struct

+ Id string

+ func MakeColor(s string) Color

+ func MakeColorSafe(s string) (Color, error)

+ func (c Color) String() string

+ type ColorByMode struct

+ Colors map[ColorMode]IColor

+ func MakeColorByMode(cols map[ColorMode]IColor) ColorByMode

+ func MakeColorByModeSafe(cols map[ColorMode]IColor) (ColorByMode, error)

+ func (c ColorByMode) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type ColorInverter struct

+ func (c ColorInverter) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type ColorMode int

+ func (c ColorMode) String() string

+ type ColorModeMismatch struct

+ Color IColor

+ Mode ColorMode

+ func (e ColorModeMismatch) Error() string

+ type ContainerWidget struct

+ D IWidgetDimension

+ func (w *ContainerWidget) SetSubWidget(wi IWidget, app IApp)

+ func (w *ContainerWidget) String() string

+ func (w *ContainerWidget) SubWidget() IWidget

+ func (ww *ContainerWidget) SetDimension(d IWidgetDimension)

+ func (ww ContainerWidget) Dimension() IWidgetDimension

+ type CopyModeClipsEvent struct

+ Action ICopyModeClips

+ func (c CopyModeClipsEvent) When() time.Time

+ type CopyModeClipsFn func([]ICopyResult)

+ func (f CopyModeClipsFn) Collect(clips []ICopyResult)

+ type CopyModeEvent struct

+ func (c CopyModeEvent) When() time.Time

+ type CopyResult struct

+ Name string

+ Val string

+ func (c CopyResult) ClipName() string

+ func (c CopyResult) ClipValue() string

+ type DefaultColor struct

+ func (r DefaultColor) String() string

+ func (r DefaultColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type DimensionError struct

+ Dim IWidgetDimension

+ Row int

+ Size IRenderSize

+ func (e DimensionError) Error() string

+ type DimensionsCB struct

+ type Direction int

+ type EmptyLineTooLong struct

+ Requested int

+ func (e EmptyLineTooLong) Error() string

+ type EmptyPalette struct

+ func MakeEmptyPalette() EmptyPalette

+ func (a EmptyPalette) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type FocusCB struct

+ type FocusCallbacks struct

+ func (w *FocusCallbacks) OnFocusChanged(f IWidgetChangedCallback)

+ func (w *FocusCallbacks) RemoveOnFocusChanged(f IIdentity)

+ type FocusPathResult struct

+ FailedLevel int

+ Succeeded bool

+ func SetFocusPath(w IWidget, path []interface{}, app IApp) FocusPathResult

+ func (f FocusPathResult) Error() string

+ type ForegroundColor struct

+ func MakeForeground(c IColor) ForegroundColor

+ func (a ForegroundColor) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type GrayColor struct

+ Val int

+ func MakeGrayColor(val string) GrayColor

+ func MakeGrayColorSafe(val string) (GrayColor, error)

+ func (g GrayColor) String() string

+ func (s GrayColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type HAlignCB struct

+ type HAlignLeft struct

+ Margin int

+ func (h HAlignLeft) ImplementsHAlignment()

+ type HAlignMiddle struct

+ func (h HAlignMiddle) ImplementsHAlignment()

+ type HAlignRight struct

+ func (h HAlignRight) ImplementsHAlignment()

+ type HeightCB struct

+ type IAfterRenderEvent interface

+ RunThenRenderEvent func(IApp)

+ type IApp interface

+ ClickTarget func(func(tcell.ButtonMask, IIdentityWidget))

+ Clips func() []ICopyResult

+ CopyLevel func(...int) int

+ CopyModeClaimedAt func(...int) int

+ CopyModeClaimedBy func(...IIdentity) IIdentity

+ GetLastMouseState func() MouseState

+ GetMouseState func() MouseState

+ InCopyMode func(...bool) bool

+ Quit func()

+ Redraw func()

+ RefreshCopyMode func()

+ RegisterMenu func(menu IMenuCompatible)

+ Run func(f IAfterRenderEvent) error

+ SetClickTarget func(k tcell.ButtonMask, w IIdentityWidget) bool

+ SetColorMode func(mode ColorMode)

+ Sync func()

+ UnregisterMenu func(menu IMenuCompatible) bool

+ type IAppendBlankLines interface

+ AppendBelow func(c IAppendCanvas, doCursor bool, makeCopy bool)

+ BoxColumns func() int

+ type IAppendCanvas interface

+ type IBox interface

+ BoxColumns func() int

+ BoxRows func() int

+ type ICallback interface

+ Call func(args ...interface{})

+ type ICallbackRunner interface

+ RunWidgetCallbacks func(name interface{}, app IApp, w IWidget)

+ type ICallbacks interface

+ AddCallback func(name interface{}, cb ICallback)

+ RemoveCallback func(name interface{}, cb IIdentity) bool

+ RunCallbacks func(name interface{}, args ...interface{})

+ type ICanvas interface

+ AppendBelow func(c IAppendCanvas, doCursor bool, makeCopy bool)

+ AppendRight func(c IMergeCanvas, useCursor bool)

+ Duplicate func() ICanvas

+ ExtendLeft func(cells []Cell)

+ ExtendRight func(cells []Cell)

+ GetMark func(name string) (CanvasPos, bool)

+ MergeUnder func(c IMergeCanvas, leftOffset, topOffset int, bottomGetsCursor bool)

+ RemoveMark func(name string)

+ SetCellAt func(col, row int, c Cell)

+ SetCursorCoords func(col, row int)

+ SetLineAt func(row int, line []Cell)

+ SetMark func(name string, col, row int)

+ TrimLeft func(cols int)

+ TrimRight func(cols int)

+ Truncate func(above, below int)

+ func Render(w IWidget, size IRenderSize, focus Selector, app IApp) ICanvas

+ type ICanvasCellReader interface

+ CellAt func(col, row int) Cell

+ type ICanvasLineReader interface

+ Line func(int, LineCopy) LineResult

+ type ICanvasMarkIterator interface

+ RangeOverMarks func(f func(key string, value CanvasPos) bool)

+ type ICellProcessor interface

+ ProcessCell func(cell Cell) Cell

+ type ICellStyler interface

+ GetStyle func(IRenderContext) (IColor, IColor, StyleAttrs)

+ type IChangeFocus interface

+ ChangeFocus func(dir Direction, wrap bool, app IApp) bool

+ type IClickTracker interface

+ SetClickPending func(bool)

+ type IClickable interface

+ Click func(app IApp)

+ type IClickableWidget interface

+ type IClipboard interface

+ Clips func(app IApp) []ICopyResult

+ type IClipboardSelected interface

+ AlterWidget func(w IWidget, app IApp) IWidget

+ type IColor interface

+ ToTCellColor func(mode ColorMode) (TCellColor, bool)

+ type IColorMode interface

+ GetColorMode func() ColorMode

+ type IColumns interface

+ Columns func() int

+ type IComposite interface

+ SubWidget func() IWidget

+ type ICompositeMultiple interface

+ SubWidgets func() []IWidget

+ type ICompositeMultipleDimensions interface

+ Dimensions func() []IWidgetDimension

+ type ICompositeMultipleFocus interface

+ type ICompositeMultipleWidget interface

+ RenderSubWidgets func(size IRenderSize, focus Selector, focusIdx int, app IApp) []ICanvas

+ RenderedSubWidgetsSizes func(size IRenderSize, focus Selector, focusIdx int, app IApp) []IRenderBox

+ SubWidgetSize func(size IRenderSize, val int, sub IWidget, dim IWidgetDimension) IRenderSize

+ type ICompositeWidget interface

+ type IContainerWidget interface

+ Dimension func() IWidgetDimension

+ SetDimension func(IWidgetDimension)

+ type ICopyModeClips interface

+ Collect func([]ICopyResult)

+ type ICopyModeWidget interface

+ CopyModeLevels func() int

+ type ICopyResult interface

+ ClipName func() string

+ ClipValue func() string

+ type IDrawCanvas interface

+ CursorCoords func() CanvasPos

+ CursorEnabled func() bool

+ type IFindNextSelectable interface

+ FindNextSelectable func(dir Direction, wrap bool) (int, bool)

+ type IFocus interface

+ Focus func() int

+ SetFocus func(app IApp, i int)

+ type IFocusSelectable interface

+ type IGetFocus interface

+ Focus func() int

+ type IGetScreen interface

+ GetScreen func() tcell.Screen

+ type IHAlignment interface

+ ImplementsHAlignment func()

+ type IIdentity interface

+ ID func() interface{}

+ type IIdentityWidget interface

+ type IKey interface

+ Key func() tcell.Key

+ Modifiers func() tcell.ModMask

+ Rune func() rune

+ type IKeyPress interface

+ KeyPress func(key IKey, app IApp)

+ type IMenuCompatible interface

+ type IMergeCanvas interface

+ type IPalette interface

+ CellStyler func(name string) (ICellStyler, bool)

+ RangeOverPalette func(f func(key string, value ICellStyler) bool)

+ type IPreferedPosition interface

+ GetPreferedPosition func() gwutil.IntOption

+ SetPreferedPosition func(col int, app IApp)

+ type IRangeOverCanvas interface

+ SetCellAt func(col, row int, c Cell)

+ type IRenderBox interface

+ func RenderSize(w IWidget, size IRenderSize, focus Selector, app IApp) IRenderBox

+ type IRenderContext interface

+ type IRenderFixed interface

+ Fixed func()

+ type IRenderFlow interface

+ Flow func()

+ type IRenderFlowWith interface

+ FlowColumns func() int

+ type IRenderMax interface

+ MaxHeight func()

+ type IRenderMaxUnits interface

+ MaxUnits func() int

+ type IRenderRelative interface

+ Relative func() float64

+ type IRenderSize interface

+ func ComputeHorizontalSubSize(size IRenderSize, d IWidgetDimension) (IRenderSize, error)

+ func ComputeHorizontalSubSizeUnsafe(size IRenderSize, d IWidgetDimension) IRenderSize

+ func ComputeSubSize(size IRenderSize, w IWidgetDimension, h IWidgetDimension) (IRenderSize, error)

+ func ComputeSubSizeUnsafe(size IRenderSize, w IWidgetDimension, h IWidgetDimension) IRenderSize

+ func ComputeVerticalSubSize(size IRenderSize, d IWidgetDimension, maxCol int, advRow int) (IRenderSize, error)

+ func ComputeVerticalSubSizeUnsafe(size IRenderSize, d IWidgetDimension, maxCol int, advRow int) IRenderSize

+ func SubWidgetSize(w ICompositeWidget, size IRenderSize, focus Selector, app IApp) IRenderSize

+ type IRenderWithUnits interface

+ Units func() int

+ type IRenderWithWeight interface

+ Weight func() int

+ type IRightSizeCanvas interface

+ AppendBelow func(c IAppendCanvas, doCursor bool, makeCopy bool)

+ ExtendRight func(cells []Cell)

+ TrimRight func(cols int)

+ Truncate func(above, below int)

+ type IRows interface

+ Rows func() int

+ type ISelectChild interface

+ SelectChild func(Selector) bool

+ type ISettableComposite interface

+ SetSubWidget func(IWidget, IApp)

+ type ISettableDimensions interface

+ SetDimensions func([]IWidgetDimension, IApp)

+ type ISettableSubWidgets interface

+ SetSubWidgets func([]IWidget, IApp)

+ type ISubWidgetSize interface

+ SubWidgetSize func(size IRenderSize, focus Selector, app IApp) IRenderSize

+ type IUnhandledInput interface

+ UnhandledInput func(app IApp, ev interface{}) bool

+ type IVAlignment interface

+ ImplementsVAlignment func()

+ type IWidget interface

+ Render func(size IRenderSize, focus Selector, app IApp) ICanvas

+ RenderSize func(size IRenderSize, focus Selector, app IApp) IRenderBox

+ Selectable func() bool

+ UserInput func(ev interface{}, size IRenderSize, focus Selector, app IApp) bool

+ func CopyWidgets(w []IWidget) []IWidget

+ func FindInHierarchy(w IWidget, includeMe bool, pred WidgetPredicate) IWidget

+ type IWidgetChangedCallback interface

+ Changed func(app IApp, widget IWidget, data ...interface{})

+ type IWidgetDimension interface

+ ImplementsWidgetDimension func()

+ type InvalidColor struct

+ Color interface{}

+ func (e InvalidColor) Error() string

+ type InvalidTypeToCompare struct

+ LHS interface{}

+ RHS interface{}

+ func (e InvalidTypeToCompare) Error() string

+ type IsSelectable struct

+ func (r *IsSelectable) Selectable() bool

+ type Key struct

+ func MakeKey(ch rune) Key

+ func MakeKeyExt(key tcell.Key) Key

+ func MakeKeyExt2(mod tcell.ModMask, key tcell.Key, ch rune) Key

+ func (k Key) Key() tcell.Key

+ func (k Key) Modifiers() tcell.ModMask

+ func (k Key) Rune() rune

+ func (k Key) String() string

+ type KeyPressCB struct

+ type KeyPressCallbacks struct

+ func (w *KeyPressCallbacks) OnKeyPress(f IWidgetChangedCallback)

+ func (w *KeyPressCallbacks) RemoveOnKeyPress(f IIdentity)

+ type KeyValueError struct

+ Base error

+ KeyVals map[string]interface{}

+ func (e KeyValueError) Cause() error

+ func (e KeyValueError) Error() string

+ type LineCanvas []Cell

+ func (c LineCanvas) BoxColumns() int

+ func (c LineCanvas) BoxRows() int

+ func (c LineCanvas) ImplementsWidgetDimension()

+ func (c LineCanvas) Line(y int, cp LineCopy) LineResult

+ func (c LineCanvas) RangeOverMarks(f func(key string, value CanvasPos) bool)

+ type LineCopy struct

+ Cap int

+ Len int

+ type LineResult struct

+ Copied bool

+ Line []Cell

+ type LogField struct

+ Name string

+ Val interface{}

+ type MouseState struct

+ MouseLeftClicked bool

+ MouseMiddleClicked bool

+ MouseRightClicked bool

+ func (m MouseState) LeftIsClicked() bool

+ func (m MouseState) MiddleIsClicked() bool

+ func (m MouseState) NoButtonClicked() bool

+ func (m MouseState) RightIsClicked() bool

+ func (m MouseState) String() string

+ type NoColor struct

+ func (r NoColor) String() string

+ func (r NoColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type NotSelectable struct

+ func (r *NotSelectable) Selectable() bool

+ type Palette map[string]ICellStyler

+ func (m Palette) CellStyler(name string) (ICellStyler, bool)

+ func (m Palette) RangeOverPalette(f func(k string, v ICellStyler) bool)

+ type PaletteEntry struct

+ BG IColor

+ FG IColor

+ Style StyleAttrs

+ func MakePaletteEntry(fg, bg IColor) PaletteEntry

+ func MakeStyledPaletteEntry(fg, bg IColor, style StyleAttrs) PaletteEntry

+ func (a PaletteEntry) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type PaletteRef struct

+ Name string

+ func MakePaletteRef(name string) PaletteRef

+ func (a PaletteRef) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type RGBColor struct

+ Blue int

+ Green int

+ Red int

+ func MakeRGBColor(s string) RGBColor

+ func MakeRGBColorExt(r, g, b int) RGBColor

+ func MakeRGBColorExtSafe(r, g, b int) (RGBColor, error)

+ func MakeRGBColorSafe(s string) (RGBColor, error)

+ func (r RGBColor) String() string

+ func (r RGBColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type RejectUserInput struct

+ func (r RejectUserInput) UserInput(ev interface{}, size IRenderSize, focus Selector, app IApp) bool

+ type RenderBox struct

+ C int

+ R int

+ func CalculateRenderSizeFallback(w IWidget, size IRenderSize, focus Selector, app IApp) RenderBox

+ func MakeRenderBox(columns, rows int) RenderBox

+ func (r RenderBox) BoxColumns() int

+ func (r RenderBox) BoxRows() int

+ func (r RenderBox) Columns() int

+ func (r RenderBox) ImplementsWidgetDimension()

+ func (r RenderBox) Rows() int

+ func (r RenderBox) String() string

+ type RenderFixed struct

+ func MakeRenderFixed() RenderFixed

+ func (f RenderFixed) Fixed()

+ func (f RenderFixed) String() string

+ func (r RenderFixed) ImplementsWidgetDimension()

+ type RenderFlow struct

+ func (f RenderFlow) String() string

+ func (r RenderFlow) ImplementsWidgetDimension()

+ func (s RenderFlow) Flow()

+ type RenderFlowWith struct

+ C int

+ func MakeRenderFlow(columns int) RenderFlowWith

+ func (r RenderFlowWith) Columns() int

+ func (r RenderFlowWith) FlowColumns() int

+ func (r RenderFlowWith) ImplementsWidgetDimension()

+ func (r RenderFlowWith) String() string

+ type RenderMax struct

+ func (f RenderMax) String() string

+ func (s RenderMax) MaxHeight()

+ type RenderWithRatio struct

+ R float64

+ func (f RenderWithRatio) Relative() float64

+ func (f RenderWithRatio) String() string

+ func (r RenderWithRatio) ImplementsWidgetDimension()

+ type RenderWithUnits struct

+ U int

+ func (f RenderWithUnits) String() string

+ func (f RenderWithUnits) Units() int

+ func (r RenderWithUnits) ImplementsWidgetDimension()

+ type RenderWithWeight struct

+ W int

+ func (f RenderWithWeight) String() string

+ func (f RenderWithWeight) Weight() int

+ func (r RenderWithWeight) ImplementsWidgetDimension()

+ type RunFunction func(IApp)

+ func (f RunFunction) RunThenRenderEvent(app IApp)

+ type Selector struct

+ Focus bool

+ Selected bool

+ func (s Selector) And(cond bool) Selector

+ func (s Selector) SelectIf(cond bool) Selector

+ func (s Selector) String() string

+ type StyleAttrs struct

+ OnOff tcell.AttrMask

+ Set tcell.AttrMask

+ func (a StyleAttrs) MergeUnder(upper StyleAttrs) StyleAttrs

+ type StyleMod struct

+ Cur ICellStyler

+ Mod ICellStyler

+ func MakeStyleMod(cur, mod ICellStyler) StyleMod

+ func (a StyleMod) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type StyledAs struct

+ func MakeStyledAs(s StyleAttrs) StyledAs

+ func (a StyledAs) GetStyle(prov IRenderContext) (x IColor, y IColor, z StyleAttrs)

+ type SubWidgetCB struct

+ type SubWidgetCallbacks struct

+ func (w *SubWidgetCallbacks) OnSetSubWidget(f IWidgetChangedCallback)

+ func (w *SubWidgetCallbacks) RemoveOnSetSubWidget(f IIdentity)

+ type SubWidgetsCB struct

+ type SubWidgetsCallbacks struct

+ func (w *SubWidgetsCallbacks) OnSetSubWidgets(f IWidgetChangedCallback)

+ func (w *SubWidgetsCallbacks) RemoveOnSetSubWidgets(f IIdentity)

+ type TCellColor struct

+ func IColorToTCell(color IColor, def TCellColor, mode ColorMode) TCellColor

+ func MakeTCellColor(val string) (TCellColor, error)

+ func MakeTCellColorExt(val tcell.Color) TCellColor

+ func MakeTCellColorSafe(val tcell.Color) (TCellColor, error)

+ func MakeTCellNoColor() TCellColor

+ func (r TCellColor) String() string

+ func (r TCellColor) ToTCell() tcell.Color

+ func (r TCellColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type UnhandledInputFunc func(app IApp, ev interface{}) bool

+ func (f UnhandledInputFunc) UnhandledInput(app IApp, ev interface{}) bool

+ var IgnoreUnhandledInput UnhandledInputFunc = func(app IApp, ev interface{}) bool { ... }

+ type Unit struct

+ type UrwidColor struct

+ Id string

+ func NewUrwidColor(val string) *UrwidColor

+ func NewUrwidColorSafe(val string) (*UrwidColor, error)

+ func (r UrwidColor) String() string

+ func (s *UrwidColor) ToTCellColor(mode ColorMode) (TCellColor, bool)

+ type VAlignBottom struct

+ func (v VAlignBottom) ImplementsVAlignment()

+ type VAlignCB struct

+ type VAlignMiddle struct

+ func (v VAlignMiddle) ImplementsVAlignment()

+ type VAlignTop struct

+ Margin int

+ func (v VAlignTop) ImplementsVAlignment()

+ type WidgetCallback struct

+ Name interface{}

+ func MakeWidgetCallback(name interface{}, fn WidgetChangedFunction) WidgetCallback

+ func (f WidgetCallback) ID() interface{}

+ type WidgetChangedFunction func(app IApp, widget IWidget)

+ func (f WidgetChangedFunction) Changed(app IApp, widget IWidget, data ...interface{})

+ type WidgetPredicate func(w IWidget) bool

+ type WidgetSizeError struct

+ Required string

+ Size IRenderSize

+ Widget interface{}

+ func (e WidgetSizeError) Error() string

+ type WidthCB struct

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL