package gui import ( "io" "os/exec" "strings" "github.com/jesseduffield/gocui" "github.com/jesseduffield/lazygit/pkg/tasks" ) func (gui *Gui) newCmdTask(view *gocui.View, cmd *exec.Cmd, prefix string) error { cmdStr := strings.Join(cmd.Args, " ") gui.Log.WithField( "command", cmdStr, ).Debug("RunCommand") _, height := view.Size() _, oy := view.Origin() manager := gui.getManager(view) start := func() (*exec.Cmd, io.Reader) { r, err := cmd.StdoutPipe() if err != nil { gui.Log.Warn(err) } cmd.Stderr = cmd.Stdout if err := cmd.Start(); err != nil { gui.Log.Warn(err) } return cmd, r } if err := manager.NewTask(manager.NewCmdTask(start, prefix, height+oy+10, nil), cmdStr); err != nil { gui.Log.Warn(err) } return nil } func (gui *Gui) newStringTask(view *gocui.View, str string) error { // using str so that if rendering the exact same thing we don't reset the origin return gui.newStringTaskWithKey(view, str, str) } func (gui *Gui) newStringTaskWithoutScroll(view *gocui.View, str string) error { manager := gui.getManager(view) f := func(stop chan struct{}) error { gui.setViewContent(view, str) return nil } // Using empty key so that on subsequent calls we won't reset the view's origin. // Note this means that we will be scrolling back to the top if we're switching from a different key if err := manager.NewTask(f, ""); err != nil { return err } return nil } func (gui *Gui) newStringTaskWithKey(view *gocui.View, str string, key string) error { manager := gui.getManager(view) f := func(stop chan struct{}) error { return gui.renderString(view, str) } if err := manager.NewTask(f, key); err != nil { return err } return nil } func (gui *Gui) getManager(view *gocui.View) *tasks.ViewBufferManager { manager, ok := gui.viewBufferManagerMap[view.Name()] if !ok { manager = tasks.NewViewBufferManager( gui.Log, view, func() { // we could clear here, but that actually has the effect of causing a flicker // where the view may contain no content momentarily as the gui refreshes. // Instead, we're rewinding the write pointer so that we will just start // overwriting the existing content from the top down. Once we've reached // the end of the content do display, we call view.FlushStaleCells() to // clear out the remaining content from the previous render. view.Reset() }, func() { gui.render() }, func() { // Need to check if the content of the view is well past the origin. // It would be better to use .ViewLinesHeight here (given it considers // wrapping) but when this function is called they haven't been written to yet. linesHeight := view.LinesHeight() _, height := view.Size() _, originY := view.Origin() if linesHeight < originY { newOriginY := linesHeight - height if newOriginY < 0 { newOriginY = 0 } err := view.SetOrigin(0, newOriginY) if err != nil { panic(err) } } view.FlushStaleCells() }, func() { _ = view.SetOrigin(0, 0) }, ) gui.viewBufferManagerMap[view.Name()] = manager } return manager }