mirror of
https://github.com/jesseduffield/lazygit.git
synced 2026-09-10 15:46:26 -04:00
3b6568cf9f
Increasing or decreasing the diff context size (the `{`/`}` keybindings)
re-renders the diff with a different `git diff -U<n>` command. Because the
command key changes, the render reset the main view to the top — losing the
spot the user was reading, which is exactly the spot the context change is
about.
Preserve it instead, reusing the identity-based restore built for the escape
path. This is its sibling consumer: capture the lines around the anchor (the
selection, or the top visible line when there's none) as restore candidates,
and after the re-render land on the nearest one that survived, put back at the
same screen row. Prefer the anchor line itself, falling back outward only when
it didn't survive: a context line vanishes when the context size shrinks,
whereas additions and deletions always survive, so expansion stops at the
first change line in each direction and the candidate list always contains a
survivor. Landing on the nearest survivor keeps scrolling to a minimum, and a
context line that is still in the patch stays put (or stays selected).
This generalizes the shared restore helper to take a prioritized candidate
list (the escape path passes a single candidate). It covers the focused main
view and every side panel's diff, since they all render into the same "main"
view through the same path. A showing selection is re-established on the landed
line; otherwise the view stays in scroll mode.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
104 lines
3.2 KiB
Go
104 lines
3.2 KiB
Go
package controllers
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
|
|
"github.com/jesseduffield/lazygit/pkg/gui/context"
|
|
"github.com/jesseduffield/lazygit/pkg/gui/types"
|
|
)
|
|
|
|
// This controller lets you change the context size for diffs. The 'context' in 'context size' refers to the conventional meaning of the word 'context' in a diff, as opposed to lazygit's own idea of a 'context'.
|
|
|
|
type ContextLinesController struct {
|
|
baseController
|
|
c *ControllerCommon
|
|
}
|
|
|
|
var _ types.IController = &ContextLinesController{}
|
|
|
|
func NewContextLinesController(
|
|
c *ControllerCommon,
|
|
) *ContextLinesController {
|
|
return &ContextLinesController{
|
|
baseController: baseController{},
|
|
c: c,
|
|
}
|
|
}
|
|
|
|
func (self *ContextLinesController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
|
|
bindings := []*types.Binding{
|
|
{
|
|
Keys: opts.GetKeys(opts.Config.Universal.IncreaseContextInDiffView),
|
|
Handler: self.Increase,
|
|
Description: self.c.Tr.IncreaseContextInDiffView,
|
|
Tooltip: self.c.Tr.IncreaseContextInDiffViewTooltip,
|
|
},
|
|
{
|
|
Keys: opts.GetKeys(opts.Config.Universal.DecreaseContextInDiffView),
|
|
Handler: self.Decrease,
|
|
Description: self.c.Tr.DecreaseContextInDiffView,
|
|
Tooltip: self.c.Tr.DecreaseContextInDiffViewTooltip,
|
|
},
|
|
}
|
|
|
|
return bindings
|
|
}
|
|
|
|
func (self *ContextLinesController) Context() types.Context {
|
|
return nil
|
|
}
|
|
|
|
func (self *ContextLinesController) Increase() error {
|
|
if err := self.checkCanChangeContext(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if self.c.UserConfig().Git.DiffContextSize < math.MaxUint64 {
|
|
self.c.UserConfig().Git.DiffContextSize++
|
|
}
|
|
return self.applyChange()
|
|
}
|
|
|
|
func (self *ContextLinesController) Decrease() error {
|
|
if err := self.checkCanChangeContext(); err != nil {
|
|
return err
|
|
}
|
|
|
|
if self.c.UserConfig().Git.DiffContextSize > 0 {
|
|
self.c.UserConfig().Git.DiffContextSize--
|
|
}
|
|
return self.applyChange()
|
|
}
|
|
|
|
func (self *ContextLinesController) applyChange() error {
|
|
self.c.Toast(fmt.Sprintf(self.c.Tr.DiffContextSizeChanged, self.c.UserConfig().Git.DiffContextSize))
|
|
|
|
currentContext := self.c.Context().CurrentSide()
|
|
switch currentContext.GetKey() {
|
|
// we make an exception for our staging and patch building contexts because they actually need to refresh their state afterwards.
|
|
case context.PATCH_BUILDING_MAIN_CONTEXT_KEY:
|
|
self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.PATCH_BUILDING}})
|
|
case context.STAGING_MAIN_CONTEXT_KEY, context.STAGING_SECONDARY_CONTEXT_KEY:
|
|
self.c.Refresh(types.RefreshOptions{Scope: []types.RefreshableView{types.STAGING}})
|
|
default:
|
|
// The new context size re-renders the diff with a different git command, which
|
|
// would otherwise reset the main view to the top. Preserve where it was
|
|
// scrolled (and its selection, if the focused main view is showing one)
|
|
// instead. This covers both the focused main view and the side panels, since
|
|
// they all render their diff into the same "main" view.
|
|
self.c.Helpers().Staging.PreserveDiffPositionOnRerender(self.c.Contexts().Normal.GetView())
|
|
currentContext.HandleRenderToMain()
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (self *ContextLinesController) checkCanChangeContext() error {
|
|
if self.c.Git().Patch.PatchBuilder.Active() {
|
|
return errors.New(self.c.Tr.CantChangeContextSizeError)
|
|
}
|
|
|
|
return nil
|
|
}
|