mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-10-05 21:46:49 -04:00
Stefan HallerandClaude Opus 5
20625407d6
Pressing { or } re-rendered the diff with less or more context around each
change and dropped you back at the top of it, so finding your way back to
what you were reading was on you.
Remember where the view is before triggering the re-render, and have the
restore put it back there. The line to remember is the selected one when a
selection is showing, and the middle visible line otherwise — what you are
looking at, rather than the view's top edge. It is remembered by identity,
because the new rendering puts it on a different line of the view, and it
is found again by the records a diff renderer states for its rows, or by
parsing the rendering as a diff where it still looks like one.
The line may not be there at all afterwards: shrinking the context takes
context lines away. So the lines around it come along as fallbacks, nearest
first, and the view lands on the nearest one that survived, put back on the
screen row it was on — leaving what you were reading where it was, give or
take the line that went. The walk that collects them covers the whole diff
rather than stopping at the nearest change on either side: those always
survive a context-size change, but not everything a re-render can do to a
diff is that considerate.
Under a diff renderer that says nothing about its rows there is nothing to
look for at all, and the view is left at the offset it had instead: often not
the line it was on, but always closer to it than the top of the diff. That is
what the re-render asks for besides the restore, since it is a different
command from the one that produced what is on screen and would otherwise be
taken for a diff the user has never seen.
Co-authored-by: Claude Opus 5 (1M context) <noreply@anthropic.com>
GOCUI - Go Console User Interface
Minimalist Go package aimed at creating Console User Interfaces. A community fork based on the amazing work of jroimartin
Features
- Minimalist API.
- Views (the "windows" in the GUI) implement the interface io.ReadWriter.
- Support for overlapping views.
- The GUI can be modified at runtime (concurrent-safe).
- Global and view-level keybindings.
- Mouse support.
- Colored text.
- Customizable editing mode.
- Easy to build reusable widgets, complex layouts...
About fork
This fork has many improvements over the original work from jroimartin.
- Written ontop of TCell
- Better wide character support
- Support for 1 Line height views
- Better support for running in docker container
- Customize frame colors
- Improved code comments and quality
- Many small improvements
- Change Visibility of views
For information about this org see: awesome-gocui/about.
Installation
Execute:
$ go get github.com/awesome-gocui/gocui
Documentation
Execute:
$ go doc github.com/awesome-gocui/gocui
Or visit godoc.org to read it online.
Example
See the _example folder for more examples
package main
import (
"fmt"
"log"
"github.com/awesome-gocui/gocui"
)
func main() {
g, err := gocui.NewGui(gocui.OutputNormal, true)
if err != nil {
log.Panicln(err)
}
defer g.Close()
g.SetManagerFunc(layout)
if err := g.SetKeybinding("", gocui.KeyCtrlC, gocui.ModNone, quit); err != nil {
log.Panicln(err)
}
if err := g.MainLoop(); err != nil && !gocui.IsQuit(err) {
log.Panicln(err)
}
}
func layout(g *gocui.Gui) error {
maxX, maxY := g.Size()
if v, err := g.SetView("hello", maxX/2-7, maxY/2, maxX/2+7, maxY/2+2, 0); err != nil {
if !gocui.IsUnknownView(err) {
return err
}
if _, err := g.SetCurrentView("hello"); err != nil {
return err
}
fmt.Fprintln(v, "Hello world!")
}
return nil
}
func quit(g *gocui.Gui, v *gocui.View) error {
return gocui.ErrQuit
}
Screenshots
Projects using gocui
- komanda-cli: IRC Client For Developers.
- vuls: Agentless vulnerability scanner for Linux/FreeBSD.
- wuzz: Interactive cli tool for HTTP inspection.
- httplab: Interactive web server.
- domainr: Tool that checks the availability of domains based on keywords.
- gotime: Time tracker for projects and tasks.
- claws: Interactive command line client for testing websockets.
- terminews: Terminal based RSS reader.
- diagram: Tool to convert ascii arts into hand drawn diagrams.
- pody: CLI app to manage Pods in a Kubernetes cluster.
- kubexp: Kubernetes client.
- kcli: Tool for inspecting kafka topics/partitions/messages.
- fac: git merge conflict resolver
- jsonui: Interactive JSON explorer for your terminal.
- cointop: Interactive terminal based UI application for tracking cryptocurrencies.
- lazygit: simple terminal UI for git commands.
- lazydocker: The lazier way to manage everything docker.
Note: if your project is not listed here, let us know! :)