package tview

import (

"strings"

"sync"

"time"

"github.com/gdamore/tcell/v2"

)

const (

// The size of the event/update/redraw channels.

queueSize = 100

// The minimum time between two consecutive redraws.

redrawPause = 50 * time.Millisecond

)

// DoubleClickInterval specifies the maximum time between clicks to register a

// double click rather than click.

var DoubleClickInterval = 500 * time.Millisecond

// MouseAction indicates one of the actions the mouse is logically doing.

type MouseAction int16

// Available mouse actions.

const (

MouseMove MouseAction = iota

MouseLeftDown

MouseLeftUp

MouseLeftClick

MouseLeftDoubleClick

MouseMiddleDown

MouseMiddleUp

MouseMiddleClick

MouseMiddleDoubleClick

MouseRightDown

MouseRightUp

MouseRightClick

MouseRightDoubleClick

MouseScrollUp

MouseScrollDown

MouseScrollLeft

MouseScrollRight

// The following special value will not be provided as a mouse action but

// indicate that an overridden mouse event was consumed. See

// [Box.SetMouseCapture] for details.

MouseConsumed

)

// queuedUpdate represented the execution of f queued by

// Application.QueueUpdate(). If "done" is not nil, it receives exactly one

// element after f has executed.

type queuedUpdate struct {

f func()

done chan struct{}

}

// Application represents the top node of an application.

//

// It is not strictly required to use this class as none of the other classes

// depend on it. However, it provides useful tools to set up an application and

// plays nicely with all widgets.

//

// The following command displays a primitive p on the screen until Ctrl-C is

// pressed:

//

// if err := tview.NewApplication().SetRoot(p, true).Run(); err != nil {

// panic(err)

// }

type Application struct {

}

// NewApplication creates and returns a new application.

func NewApplication() *Application {

}

// SetInputCapture sets a function which captures all key events before they are

// forwarded to the key event handler of the primitive which currently has

// focus. This function can then choose to forward that key event (or a

// different one) by returning it or stop the key event processing by returning

// nil.

//

// The only default global key event is Ctrl-C which stops the application. It

// requires special handling:

//

// - If you do not wish to change the default behavior, return the original

// event object passed to your input capture function.

// - If you wish to block Ctrl-C from any functionality, return nil.

// - If you do not wish Ctrl-C to stop the application but still want to

// forward the Ctrl-C event to primitives down the hierarchy, return a new

// key event with the same key and modifiers, e.g.

// tcell.NewEventKey(tcell.KeyCtrlC, 0, tcell.ModNone).

//

// Pasted key events are not forwarded to the input capture function if pasting

// is enabled (see [Application.EnablePaste]).

func (a *Application) SetInputCapture(capture func(event *tcell.EventKey) *tcell.EventKey) *Application {

a.inputCapture = capture

return a

}

// GetInputCapture returns the function installed with SetInputCapture() or nil

// if no such function has been installed.

func (a *Application) GetInputCapture() func(event *tcell.EventKey) *tcell.EventKey {

return a.inputCapture

}

// SetMouseCapture sets a function which captures mouse events (consisting of

// the original tcell mouse event and the semantic mouse action) before they are

// forwarded to the appropriate mouse event handler. This function can then

// choose to forward that event (or a different one) by returning it or stop

// the event processing by returning a nil mouse event. In such a case, the

// event is considered consumed and the screen will be redrawn.

func (a *Application) SetMouseCapture(capture func(event *tcell.EventMouse, action MouseAction) (*tcell.EventMouse, MouseAction)) *Application {

a.mouseCapture = capture

return a

}

// GetMouseCapture returns the function installed with SetMouseCapture() or nil

// if no such function has been installed.

func (a *Application) GetMouseCapture() func(event *tcell.EventMouse, action MouseAction) (*tcell.EventMouse, MouseAction) {

return a.mouseCapture

}

// SetScreen allows you to provide your own tcell.Screen object. For most

// applications, this is not needed and you should be familiar with

// tcell.Screen when using this function.

//

// This function is typically called before the first call to Run(). Init() need

// not be called on the screen.

func (a *Application) SetScreen(screen tcell.Screen) *Application {

}

// EnableMouse enables mouse events or disables them (if "false" is provided).

func (a *Application) EnableMouse(enable bool) *Application {

}

// EnablePaste enables the capturing of paste events or disables them (if

// "false" is provided). This must be supported by the terminal.

//

// Widgets won't interpret paste events for navigation or selection purposes.

// Paste events are typically only used to insert a block of text into an

// [InputField] or a [TextArea].

func (a *Application) EnablePaste(enable bool) *Application {

}

// Run starts the application and thus the event loop. This function returns

// when [Application.Stop] was called.

//

// Note that while an application is running, it fully claims stdin, stdout, and

// stderr. If you use these standard streams, they may not work as expected.

// Consider stopping the application first or suspending it (using

// [Application.Suspend]) if you have to interact with the standard streams, for

// example when needing to print a call stack during a panic.

func (a *Application) Run() error {

}

// fireMouseActions analyzes the provided mouse event, derives mouse actions

// from it and then forwards them to the corresponding primitives.

func (a *Application) fireMouseActions(event *tcell.EventMouse) (consumed, isMouseDownAction bool) {

}

// Stop stops the application, causing Run() to return.

func (a *Application) Stop() {

}

// Suspend temporarily suspends the application by exiting terminal UI mode and

// invoking the provided function "f". When "f" returns, terminal UI mode is

// entered again and the application resumes.

//

// A return value of true indicates that the application was suspended and "f"

// was called. If false is returned, the application was already suspended,

// terminal UI mode was not exited, and "f" was not called.

func (a *Application) Suspend(f func()) bool {

}

// Draw refreshes the screen (during the next update cycle). It calls the Draw()

// function of the application's root primitive and then syncs the screen

// buffer. It is almost never necessary to call this function. It can actually

// deadlock your application if you call it from the main thread (e.g. in a

// callback function of a widget). Please see

// https://github.com/rivo/tview/wiki/Concurrency for details.

func (a *Application) Draw() *Application {

}

// ForceDraw refreshes the screen immediately. Use this function with caution as

// it may lead to race conditions with updates to primitives in other

// goroutines. It is always preferable to call [Application.Draw] instead.

// Never call this function from a goroutine.

//

// It is safe to call this function during queued updates and direct event

// handling.

func (a *Application) ForceDraw() *Application {

return a.draw()

}

// draw actually does what Draw() promises to do.

func (a *Application) draw() *Application {

}

// Sync forces a full re-sync of the screen buffer with the actual screen during

// the next event cycle. This is useful for when the terminal screen is

// corrupted so you may want to offer your users a keyboard shortcut to refresh

// the screen.

func (a *Application) Sync() *Application {

}

// SetBeforeDrawFunc installs a callback function which is invoked just before

// the root primitive is drawn during screen updates. If the function returns

// true, drawing will not continue, i.e. the root primitive will not be drawn

// (and an after-draw-handler will not be called).

//

// Note that the screen is not cleared by the application. To clear the screen,

// you may call screen.Clear().

//

// Provide nil to uninstall the callback function.

func (a *Application) SetBeforeDrawFunc(handler func(screen tcell.Screen) bool) *Application {

a.beforeDraw = handler

return a

}

// GetBeforeDrawFunc returns the callback function installed with

// SetBeforeDrawFunc() or nil if none has been installed.

func (a *Application) GetBeforeDrawFunc() func(screen tcell.Screen) bool {

return a.beforeDraw

}

// SetAfterDrawFunc installs a callback function which is invoked after the root

// primitive was drawn during screen updates.

//

// Provide nil to uninstall the callback function.

func (a *Application) SetAfterDrawFunc(handler func(screen tcell.Screen)) *Application {

a.afterDraw = handler

return a

}

// GetAfterDrawFunc returns the callback function installed with

// SetAfterDrawFunc() or nil if none has been installed.

func (a *Application) GetAfterDrawFunc() func(screen tcell.Screen) {

return a.afterDraw

}

// SetRoot sets the root primitive for this application. If "fullscreen" is set

// to true, the root primitive's position will be changed to fill the screen.

//

// This function must be called at least once or nothing will be displayed when

// the application starts.

//

// It also calls SetFocus() on the primitive.

func (a *Application) SetRoot(root Primitive, fullscreen bool) *Application {

}

// ResizeToFullScreen resizes the given primitive such that it fills the entire

// screen.

func (a *Application) ResizeToFullScreen(p Primitive) *Application {

}

// SetFocus sets the focus to a new primitive. All key events will be directed

// down the hierarchy (starting at the root) until a primitive handles them,

// which per default goes towards the focused primitive.

//

// Blur() will be called on the previously focused primitive. Focus() will be

// called on the new primitive.

func (a *Application) SetFocus(p Primitive) *Application {

}

// GetFocus returns the primitive which has the current focus. If none has it,

// nil is returned.

func (a *Application) GetFocus() Primitive {

}

// QueueUpdate is used to synchronize access to primitives from non-main

// goroutines. The provided function will be executed as part of the event loop

// and thus will not cause race conditions with other such update functions or

// the Draw() function.

//

// Note that Draw() is not implicitly called after the execution of f as that

// may not be desirable. You can call Draw() from f if the screen should be

// refreshed after each update. Alternatively, use QueueUpdateDraw() to follow

// up with an immediate refresh of the screen.

//

// This function returns after f has executed.

func (a *Application) QueueUpdate(f func()) *Application {

}

// QueueUpdateDraw works like QueueUpdate() except it refreshes the screen

// immediately after executing f.

func (a *Application) QueueUpdateDraw(f func()) *Application {

}

// QueueEvent sends an event to the Application event loop.

//

// It is not recommended for event to be nil.

func (a *Application) QueueEvent(event tcell.Event) *Application {

a.events <- event

return a

}