lots more refactoring

pkg/gui/controllers/command_log_controller.go

@@ -0,0 +1,42 @@
+package controllers
+
+import (
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+)
+
+type CommandLogController struct {
+	baseController
+	*controllerCommon
+}
+
+var _ types.IController = &CommandLogController{}
+
+func NewCommandLogController(
+	common *controllerCommon,
+) *CommandLogController {
+	return &CommandLogController{
+		baseController:   baseController{},
+		controllerCommon: common,
+	}
+}
+
+func (self *CommandLogController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
+	bindings := []*types.Binding{}
+
+	return bindings
+}
+
+func (self *CommandLogController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
+	return func(types.OnFocusLostOpts) error {
+		self.c.Views().Extras.Autoscroll = true
+		return nil
+	}
+}
+
+func (self *CommandLogController) Context() types.Context {
+	return self.context()
+}
+
+func (self *CommandLogController) context() types.Context {
+	return self.contexts.CommandLog
+}

pkg/gui/controllers/commit_message_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )
 
@@ -31,28 +32,39 @@ func NewCommitMessageController(
 	}
 }
 
+// TODO: merge that commit panel PR because we're not currently showing how to add a newline as it's
+// handled by the editor func rather than by the controller here.
 func (self *CommitMessageController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
 	bindings := []*types.Binding{
 		{
-			Key:     opts.GetKey(opts.Config.Universal.SubmitEditorText),
-			Handler: self.confirm,
+			Key:         opts.GetKey(opts.Config.Universal.SubmitEditorText),
+			Handler:     self.confirm,
+			Description: self.c.Tr.LcConfirm,
 		},
 		{
-			Key:     opts.GetKey(opts.Config.Universal.Return),
-			Handler: self.close,
+			Key:         opts.GetKey(opts.Config.Universal.Return),
+			Handler:     self.close,
+			Description: self.c.Tr.LcClose,
 		},
 	}
 
 	return bindings
 }
 
+func (self *CommitMessageController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
+	return func(types.OnFocusLostOpts) error {
+		self.context().RenderCommitLength()
+		return nil
+	}
+}
+
 func (self *CommitMessageController) Context() types.Context {
 	return self.context()
 }
 
 // this method is pointless in this context but I'm keeping it consistent
 // with other contexts so that when generics arrive it's easier to refactor
-func (self *CommitMessageController) context() types.Context {
+func (self *CommitMessageController) context() *context.CommitMessageContext {
 	return self.contexts.CommitMessage
 }
 

pkg/gui/controllers/confirmation_controller.go

@@ -1,6 +1,7 @@
 package controllers
 
 import (
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )
 
@@ -21,14 +22,36 @@ func NewConfirmationController(
 }
 
 func (self *ConfirmationController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
-	bindings := []*types.Binding{}
+	bindings := []*types.Binding{
+		{
+			Key:         opts.GetKey(opts.Config.Universal.Confirm),
+			Handler:     func() error { return self.context().State.OnConfirm() },
+			Description: self.c.Tr.LcConfirm,
+			Display:     true,
+		},
+		{
+			Key:         opts.GetKey(opts.Config.Universal.Return),
+			Handler:     func() error { return self.context().State.OnClose() },
+			Description: self.c.Tr.LcCloseCancel,
+			Display:     true,
+		},
+		{
+			Key: opts.GetKey(opts.Config.Universal.TogglePanel),
+			Handler: func() error {
+				if len(self.contexts.Suggestions.State.Suggestions) > 0 {
+					return self.c.ReplaceContext(self.contexts.Suggestions)
+				}
+				return nil
+			},
+		},
+	}
 
 	return bindings
 }
 
 func (self *ConfirmationController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
 	return func(types.OnFocusLostOpts) error {
-		deactivateConfirmationPrompt(self.controllerCommon)
+		self.helpers.Confirmation.DeactivateConfirmationPrompt()
 		return nil
 	}
 }
@@ -37,17 +60,6 @@ func (self *ConfirmationController) Context() types.Context {
 	return self.context()
 }
 
-func (self *ConfirmationController) context() types.Context {
+func (self *ConfirmationController) context() *context.ConfirmationContext {
 	return self.contexts.Confirmation
 }
-
-func deactivateConfirmationPrompt(c *controllerCommon) {
-	c.mutexes.PopupMutex.Lock()
-	c.c.State().GetRepoState().SetCurrentPopupOpts(nil)
-	c.mutexes.PopupMutex.Unlock()
-
-	c.c.Views().Confirmation.Visible = false
-	c.c.Views().Suggestions.Visible = false
-
-	gui.clearConfirmationViewKeyBindings()
-}

pkg/gui/controllers/helpers/confirmation_helper.go

@@ -0,0 +1,321 @@
+package helpers
+
+import (
+	goContext "context"
+	"fmt"
+	"strings"
+
+	"github.com/jesseduffield/gocui"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
+
+	"github.com/jesseduffield/lazygit/pkg/gui/style"
+	"github.com/jesseduffield/lazygit/pkg/gui/types"
+	"github.com/jesseduffield/lazygit/pkg/theme"
+	"github.com/mattn/go-runewidth"
+)
+
+type ConfirmationHelper struct {
+	c        *types.HelperCommon
+	contexts *context.ContextTree
+}
+
+func NewConfirmationHelper(
+	c *types.HelperCommon,
+	contexts *context.ContextTree,
+) *ConfirmationHelper {
+	return &ConfirmationHelper{
+		c:        c,
+		contexts: contexts,
+	}
+}
+
+// This file is for the rendering of confirmation panels along with setting and handling associated
+// keybindings.
+
+func (self *ConfirmationHelper) wrappedConfirmationFunction(cancel goContext.CancelFunc, function func() error) func() error {
+	return func() error {
+		cancel()
+
+		if err := self.c.PopContext(); err != nil {
+			return err
+		}
+
+		if function != nil {
+			if err := function(); err != nil {
+				return self.c.Error(err)
+			}
+		}
+
+		return nil
+	}
+}
+
+func (self *ConfirmationHelper) wrappedPromptConfirmationFunction(cancel goContext.CancelFunc, function func(string) error, getResponse func() string) func() error {
+	return self.wrappedConfirmationFunction(cancel, func() error {
+		return function(getResponse())
+	})
+}
+
+func (self *ConfirmationHelper) DeactivateConfirmationPrompt() {
+	self.c.Mutexes().PopupMutex.Lock()
+	self.c.State().GetRepoState().SetCurrentPopupOpts(nil)
+	self.c.Mutexes().PopupMutex.Unlock()
+
+	self.c.Views().Confirmation.Visible = false
+	self.c.Views().Suggestions.Visible = false
+
+	self.clearConfirmationViewKeyBindings()
+}
+
+func getMessageHeight(wrap bool, message string, width int) int {
+	lines := strings.Split(message, "\n")
+	lineCount := 0
+	// if we need to wrap, calculate height to fit content within view's width
+	if wrap {
+		for _, line := range lines {
+			lineCount += runewidth.StringWidth(line)/width + 1
+		}
+	} else {
+		lineCount = len(lines)
+	}
+	return lineCount
+}
+
+func (self *ConfirmationHelper) getConfirmationPanelDimensions(wrap bool, prompt string) (int, int, int, int) {
+	panelWidth := self.getConfirmationPanelWidth()
+	panelHeight := getMessageHeight(wrap, prompt, panelWidth)
+	return self.getConfirmationPanelDimensionsAux(panelWidth, panelHeight)
+}
+
+func (self *ConfirmationHelper) getConfirmationPanelDimensionsForContentHeight(panelWidth, contentHeight int) (int, int, int, int) {
+	return self.getConfirmationPanelDimensionsAux(panelWidth, contentHeight)
+}
+
+func (self *ConfirmationHelper) getConfirmationPanelDimensionsAux(panelWidth int, panelHeight int) (int, int, int, int) {
+	width, height := self.c.GocuiGui().Size()
+	if panelHeight > height*3/4 {
+		panelHeight = height * 3 / 4
+	}
+	return width/2 - panelWidth/2,
+		height/2 - panelHeight/2 - panelHeight%2 - 1,
+		width/2 + panelWidth/2,
+		height/2 + panelHeight/2
+}
+
+func (self *ConfirmationHelper) getConfirmationPanelWidth() int {
+	width, _ := self.c.GocuiGui().Size()
+	// we want a minimum width up to a point, then we do it based on ratio.
+	panelWidth := 4 * width / 7
+	minWidth := 80
+	if panelWidth < minWidth {
+		if width-2 < minWidth {
+			panelWidth = width - 2
+		} else {
+			panelWidth = minWidth
+		}
+	}
+
+	return panelWidth
+}
+
+func (self *ConfirmationHelper) prepareConfirmationPanel(
+	ctx goContext.Context,
+	opts types.ConfirmOpts,
+) error {
+	self.c.Views().Confirmation.HasLoader = opts.HasLoader
+	if opts.HasLoader {
+		self.c.GocuiGui().StartTicking(ctx)
+	}
+	self.c.Views().Confirmation.Title = opts.Title
+	// for now we do not support wrapping in our editor
+	self.c.Views().Confirmation.Wrap = !opts.Editable
+	self.c.Views().Confirmation.FgColor = theme.GocuiDefaultTextColor
+	self.c.Views().Confirmation.Mask = runeForMask(opts.Mask)
+	_ = self.c.Views().Confirmation.SetOrigin(0, 0)
+
+	suggestionsContext := self.contexts.Suggestions
+	suggestionsContext.State.FindSuggestions = opts.FindSuggestionsFunc
+	if opts.FindSuggestionsFunc != nil {
+		suggestionsView := self.c.Views().Suggestions
+		suggestionsView.Wrap = false
+		suggestionsView.FgColor = theme.GocuiDefaultTextColor
+		suggestionsContext.SetSuggestions(opts.FindSuggestionsFunc(""))
+		suggestionsView.Visible = true
+		suggestionsView.Title = fmt.Sprintf(self.c.Tr.SuggestionsTitle, self.c.UserConfig.Keybinding.Universal.TogglePanel)
+	}
+
+	self.ResizeConfirmationPanel()
+	return nil
+}
+
+func runeForMask(mask bool) rune {
+	if mask {
+		return '*'
+	}
+	return 0
+}
+
+func (self *ConfirmationHelper) CreatePopupPanel(ctx goContext.Context, opts types.CreatePopupPanelOpts) error {
+	self.c.Mutexes().PopupMutex.Lock()
+	defer self.c.Mutexes().PopupMutex.Unlock()
+
+	ctx, cancel := goContext.WithCancel(ctx)
+
+	// we don't allow interruptions of non-loader popups in case we get stuck somehow
+	// e.g. a credentials popup never gets its required user input so a process hangs
+	// forever.
+	// The proper solution is to have a queue of popup options
+	currentPopupOpts := self.c.State().GetRepoState().GetCurrentPopupOpts()
+	if currentPopupOpts != nil && !currentPopupOpts.HasLoader {
+		self.c.Log.Error("ignoring create popup panel because a popup panel is already open")
+		cancel()
+		return nil
+	}
+
+	// remove any previous keybindings
+	self.clearConfirmationViewKeyBindings()
+
+	err := self.prepareConfirmationPanel(
+		ctx,
+		types.ConfirmOpts{
+			Title:               opts.Title,
+			Prompt:              opts.Prompt,
+			HasLoader:           opts.HasLoader,
+			FindSuggestionsFunc: opts.FindSuggestionsFunc,
+			Editable:            opts.Editable,
+			Mask:                opts.Mask,
+		})
+	if err != nil {
+		cancel()
+		return err
+	}
+	confirmationView := self.c.Views().Confirmation
+	confirmationView.Editable = opts.Editable
+
+	if opts.Editable {
+		textArea := confirmationView.TextArea
+		textArea.Clear()
+		textArea.TypeString(opts.Prompt)
+		self.ResizeConfirmationPanel()
+		confirmationView.RenderTextArea()
+	} else {
+		self.c.ResetViewOrigin(confirmationView)
+		self.c.SetViewContent(confirmationView, style.AttrBold.Sprint(opts.Prompt))
+	}
+
+	if err := self.setKeyBindings(cancel, opts); err != nil {
+		cancel()
+		return err
+	}
+
+	self.c.State().GetRepoState().SetCurrentPopupOpts(&opts)
+
+	return self.c.PushContext(self.contexts.Confirmation)
+}
+
+func (self *ConfirmationHelper) setKeyBindings(cancel goContext.CancelFunc, opts types.CreatePopupPanelOpts) error {
+	var onConfirm func() error
+	if opts.HandleConfirmPrompt != nil {
+		onConfirm = self.wrappedPromptConfirmationFunction(cancel, opts.HandleConfirmPrompt, func() string { return self.c.Views().Confirmation.TextArea.GetContent() })
+	} else {
+		onConfirm = self.wrappedConfirmationFunction(cancel, opts.HandleConfirm)
+	}
+
+	onSuggestionConfirm := self.wrappedPromptConfirmationFunction(
+		cancel,
+		opts.HandleConfirmPrompt,
+		self.getSelectedSuggestionValue,
+	)
+
+	onClose := self.wrappedConfirmationFunction(cancel, opts.HandleClose)
+
+	self.contexts.Confirmation.State.OnConfirm = onConfirm
+	self.contexts.Confirmation.State.OnClose = onClose
+	self.contexts.Suggestions.State.OnConfirm = onSuggestionConfirm
+	self.contexts.Suggestions.State.OnClose = onClose
+
+	return nil
+}
+
+func (self *ConfirmationHelper) clearConfirmationViewKeyBindings() {
+	noop := func() error { return nil }
+	self.contexts.Confirmation.State.OnConfirm = noop
+	self.contexts.Confirmation.State.OnClose = noop
+	self.contexts.Suggestions.State.OnConfirm = noop
+	self.contexts.Suggestions.State.OnClose = noop
+}
+
+func (self *ConfirmationHelper) getSelectedSuggestionValue() string {
+	selectedSuggestion := self.contexts.Suggestions.GetSelected()
+
+	if selectedSuggestion != nil {
+		return selectedSuggestion.Value
+	}
+
+	return ""
+}
+
+func (self *ConfirmationHelper) ResizeConfirmationPanel() {
+	suggestionsViewHeight := 0
+	if self.c.Views().Suggestions.Visible {
+		suggestionsViewHeight = 11
+	}
+	panelWidth := self.getConfirmationPanelWidth()
+	prompt := self.c.Views().Confirmation.Buffer()
+	wrap := true
+	if self.c.Views().Confirmation.Editable {
+		prompt = self.c.Views().Confirmation.TextArea.GetContent()
+		wrap = false
+	}
+	panelHeight := getMessageHeight(wrap, prompt, panelWidth) + suggestionsViewHeight
+	x0, y0, x1, y1 := self.getConfirmationPanelDimensionsAux(panelWidth, panelHeight)
+	confirmationViewBottom := y1 - suggestionsViewHeight
+	_, _ = self.c.GocuiGui().SetView(self.c.Views().Confirmation.Name(), x0, y0, x1, confirmationViewBottom, 0)
+
+	suggestionsViewTop := confirmationViewBottom + 1
+	_, _ = self.c.GocuiGui().SetView(self.c.Views().Suggestions.Name(), x0, suggestionsViewTop, x1, suggestionsViewTop+suggestionsViewHeight, 0)
+}
+
+func (self *ConfirmationHelper) ResizeCurrentPopupPanel() error {
+	v := self.c.GocuiGui().CurrentView()
+	if v == nil {
+		return nil
+	}
+
+	if v == self.c.Views().Menu {
+		self.resizeMenu()
+	} else if v == self.c.Views().Confirmation || v == self.c.Views().Suggestions {
+		self.ResizeConfirmationPanel()
+	} else if self.IsPopupPanel(v.Name()) {
+		return self.ResizePopupPanel(v, v.Buffer())
+	}
+
+	return nil
+}
+
+func (self *ConfirmationHelper) ResizePopupPanel(v *gocui.View, content string) error {
+	x0, y0, x1, y1 := self.getConfirmationPanelDimensions(v.Wrap, content)
+	_, err := self.c.GocuiGui().SetView(v.Name(), x0, y0, x1, y1, 0)
+	return err
+}
+
+func (self *ConfirmationHelper) resizeMenu() {
+	itemCount := self.contexts.Menu.GetList().Len()
+	offset := 3
+	panelWidth := self.getConfirmationPanelWidth()
+	x0, y0, x1, y1 := self.getConfirmationPanelDimensionsForContentHeight(panelWidth, itemCount+offset)
+	menuBottom := y1 - offset
+	_, _ = self.c.GocuiGui().SetView(self.c.Views().Menu.Name(), x0, y0, x1, menuBottom, 0)
+
+	tooltipTop := menuBottom + 1
+	tooltipHeight := getMessageHeight(true, self.contexts.Menu.GetSelected().Tooltip, panelWidth) + 2 // plus 2 for the frame
+	_, _ = self.c.GocuiGui().SetView(self.c.Views().Tooltip.Name(), x0, tooltipTop, x1, tooltipTop+tooltipHeight-1, 0)
+}
+
+func (self *ConfirmationHelper) IsPopupPanel(viewName string) bool {
+	return viewName == "commitMessage" || viewName == "confirmation" || viewName == "menu"
+}
+
+func (self *ConfirmationHelper) IsPopupPanelFocused() bool {
+	return self.IsPopupPanel(self.c.CurrentContext().GetViewName())
+}

pkg/gui/controllers/helpers/helpers.go

@@ -25,6 +25,7 @@ type Helpers struct {
 	Window          *WindowHelper
 	View            *ViewHelper
 	Refresh         *RefreshHelper
+	Confirmation    *ConfirmationHelper
 }
 
 func NewStubHelpers() *Helpers {
@@ -52,5 +53,6 @@ func NewStubHelpers() *Helpers {
 		Window:          &WindowHelper{},
 		View:            &ViewHelper{},
 		Refresh:         &RefreshHelper{},
+		Confirmation:    &ConfirmationHelper{},
 	}
 }

pkg/gui/controllers/helpers/merge_conflicts_helper.go

@@ -1,11 +1,8 @@
 package helpers
 
 import (
-	"fmt"
-
 	"github.com/jesseduffield/lazygit/pkg/commands"
 	"github.com/jesseduffield/lazygit/pkg/gui/context"
-	"github.com/jesseduffield/lazygit/pkg/gui/keybindings"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 )
 
@@ -27,18 +24,6 @@ func NewMergeConflictsHelper(
 	}
 }
 
-func (self *MergeConflictsHelper) GetMergingOptions() map[string]string {
-	keybindingConfig := self.c.UserConfig.Keybinding
-
-	return map[string]string{
-		fmt.Sprintf("%s %s", keybindings.Label(keybindingConfig.Universal.PrevItem), keybindings.Label(keybindingConfig.Universal.NextItem)):   self.c.Tr.LcSelectHunk,
-		fmt.Sprintf("%s %s", keybindings.Label(keybindingConfig.Universal.PrevBlock), keybindings.Label(keybindingConfig.Universal.NextBlock)): self.c.Tr.LcNavigateConflicts,
-		keybindings.Label(keybindingConfig.Universal.Select):   self.c.Tr.LcPickHunk,
-		keybindings.Label(keybindingConfig.Main.PickBothHunks): self.c.Tr.LcPickAllHunks,
-		keybindings.Label(keybindingConfig.Universal.Undo):     self.c.Tr.LcUndo,
-	}
-}
-
 func (self *MergeConflictsHelper) SetMergeState(path string) (bool, error) {
 	self.context().GetMutex().Lock()
 	defer self.context().GetMutex().Unlock()

pkg/gui/controllers/helpers/suggestions_helper.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/jesseduffield/generics/slices"
 	"github.com/jesseduffield/lazygit/pkg/commands/models"
+	"github.com/jesseduffield/lazygit/pkg/gui/context"
 	"github.com/jesseduffield/lazygit/pkg/gui/presentation"
 	"github.com/jesseduffield/lazygit/pkg/gui/types"
 	"github.com/jesseduffield/lazygit/pkg/utils"
@@ -35,8 +36,8 @@ type ISuggestionsHelper interface {
 type SuggestionsHelper struct {
 	c *types.HelperCommon
 
-	model                *types.Model
-	refreshSuggestionsFn func()
+	model    *types.Model
+	contexts *context.ContextTree
 }
 
 var _ ISuggestionsHelper = &SuggestionsHelper{}
@@ -44,12 +45,12 @@ var _ ISuggestionsHelper = &SuggestionsHelper{}
 func NewSuggestionsHelper(
 	c *types.HelperCommon,
 	model *types.Model,
-	refreshSuggestionsFn func(),
+	contexts *context.ContextTree,
 ) *SuggestionsHelper {
 	return &SuggestionsHelper{
-		c:                    c,
-		model:                model,
-		refreshSuggestionsFn: refreshSuggestionsFn,
+		c:        c,
+		model:    model,
+		contexts: contexts,
 	}
 }
 
@@ -127,7 +128,7 @@ func (self *SuggestionsHelper) GetFilePathSuggestionsFunc() func(string) []*type
 		// cache the trie for future use
 		self.model.FilesTrie = trie
 
-		self.refreshSuggestionsFn()
+		self.contexts.Suggestions.RefreshSuggestions()
 
 		return err
 	})

pkg/gui/controllers/menu_controller.go

@@ -28,12 +28,16 @@ func (self *MenuController) GetKeybindings(opts types.KeybindingsOpts) []*types.
 			Handler: self.press,
 		},
 		{
-			Key:     opts.GetKey(opts.Config.Universal.Confirm),
-			Handler: self.press,
+			Key:         opts.GetKey(opts.Config.Universal.Confirm),
+			Handler:     self.press,
+			Description: self.c.Tr.LcExecute,
+			Display:     true,
 		},
 		{
-			Key:     opts.GetKey(opts.Config.Universal.Return),
-			Handler: self.close,
+			Key:         opts.GetKey(opts.Config.Universal.Return),
+			Handler:     self.close,
+			Description: self.c.Tr.LcClose,
+			Display:     true,
 		},
 	}
 

pkg/gui/controllers/merge_conflicts_controller.go

@@ -41,21 +41,25 @@ func (self *MergeConflictsController) GetKeybindings(opts types.KeybindingsOpts)
 			Key:         opts.GetKey(opts.Config.Universal.PrevBlock),
 			Handler:     self.withRenderAndFocus(self.PrevConflict),
 			Description: self.c.Tr.PrevConflict,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Universal.NextBlock),
 			Handler:     self.withRenderAndFocus(self.NextConflict),
 			Description: self.c.Tr.NextConflict,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Universal.PrevItem),
 			Handler:     self.withRenderAndFocus(self.PrevConflictHunk),
 			Description: self.c.Tr.SelectPrevHunk,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Universal.NextItem),
 			Handler:     self.withRenderAndFocus(self.NextConflictHunk),
 			Description: self.c.Tr.SelectNextHunk,
+			Display:     true,
 		},
 		{
 			Key:     opts.GetKey(opts.Config.Universal.PrevBlockAlt),
@@ -89,6 +93,7 @@ func (self *MergeConflictsController) GetKeybindings(opts types.KeybindingsOpts)
 			Key:         opts.GetKey(opts.Config.Universal.Undo),
 			Handler:     self.withRenderAndFocus(self.HandleUndo),
 			Description: self.c.Tr.LcUndo,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Files.OpenMergeTool),
@@ -99,11 +104,13 @@ func (self *MergeConflictsController) GetKeybindings(opts types.KeybindingsOpts)
 			Key:         opts.GetKey(opts.Config.Universal.Select),
 			Handler:     self.withRenderAndFocus(self.HandlePickHunk),
 			Description: self.c.Tr.PickHunk,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Main.PickBothHunks),
 			Handler:     self.withRenderAndFocus(self.HandlePickAllHunks),
 			Description: self.c.Tr.PickAllHunks,
+			Display:     true,
 		},
 		{
 			Key:         opts.GetKey(opts.Config.Universal.Return),

pkg/gui/controllers/patch_building_controller.go

@@ -59,6 +59,27 @@ func (self *PatchBuildingController) GetMouseKeybindings(opts types.KeybindingsO
 	return []*gocui.ViewMouseBinding{}
 }
 
+func (self *PatchBuildingController) GetOnFocus() func(types.OnFocusOpts) error {
+	return func(opts types.OnFocusOpts) error {
+		// no need to change wrap on the secondary view because it can't be interacted with
+		self.c.Views().PatchBuilding.Wrap = false
+
+		return self.helpers.PatchBuilding.RefreshPatchBuildingPanel(opts)
+	}
+}
+
+func (self *PatchBuildingController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
+	return func(opts types.OnFocusLostOpts) error {
+		self.c.Views().PatchBuilding.Wrap = true
+
+		if self.git.Patch.PatchBuilder.IsEmpty() {
+			self.git.Patch.PatchBuilder.Reset()
+		}
+
+		return nil
+	}
+}
+
 func (self *PatchBuildingController) OpenFile() error {
 	self.context().GetMutex().Lock()
 	defer self.context().GetMutex().Unlock()

pkg/gui/controllers/staging_controller.go

@@ -99,6 +99,29 @@ func (self *StagingController) GetMouseKeybindings(opts types.KeybindingsOpts) [
 	return []*gocui.ViewMouseBinding{}
 }
 
+func (self *StagingController) GetOnFocus() func(types.OnFocusOpts) error {
+	return func(opts types.OnFocusOpts) error {
+		self.c.Views().Staging.Wrap = false
+		self.c.Views().StagingSecondary.Wrap = false
+
+		return self.helpers.Staging.RefreshStagingPanel(opts)
+	}
+}
+
+func (self *StagingController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
+	return func(opts types.OnFocusLostOpts) error {
+		self.context.SetState(nil)
+
+		if opts.NewContextKey != self.otherContext.GetKey() {
+			self.c.Views().Staging.Wrap = true
+			self.c.Views().StagingSecondary.Wrap = true
+			_ = self.contexts.Staging.Render(false)
+			_ = self.contexts.StagingSecondary.Render(false)
+		}
+		return nil
+	}
+}
+
 func (self *StagingController) OpenFile() error {
 	self.context.GetMutex().Lock()
 	defer self.context.GetMutex().Unlock()

pkg/gui/controllers/sub_commits_controller.go

@@ -53,8 +53,8 @@ func (self *SubCommitsController) GetOnRenderToMain() func() error {
 	}
 }
 
-func (self *SubCommitsController) GetOnFocus() func() error {
-	return func() error {
+func (self *SubCommitsController) GetOnFocus() func(types.OnFocusOpts) error {
+	return func(types.OnFocusOpts) error {
 		context := self.context
 		if context.GetSelectedLineIdx() > COMMIT_THRESHOLD && context.GetLimitCommits() {
 			context.SetLimitCommits(false)

pkg/gui/controllers/suggestions_controller.go

@@ -22,14 +22,27 @@ func NewSuggestionsController(
 }
 
 func (self *SuggestionsController) GetKeybindings(opts types.KeybindingsOpts) []*types.Binding {
-	bindings := []*types.Binding{}
+	bindings := []*types.Binding{
+		{
+			Key:     opts.GetKey(opts.Config.Universal.Confirm),
+			Handler: func() error { return self.context().State.OnConfirm() },
+		},
+		{
+			Key:     opts.GetKey(opts.Config.Universal.Return),
+			Handler: func() error { return self.context().State.OnClose() },
+		},
+		{
+			Key:     opts.GetKey(opts.Config.Universal.TogglePanel),
+			Handler: func() error { return self.c.ReplaceContext(self.contexts.Confirmation) },
+		},
+	}
 
 	return bindings
 }
 
 func (self *SuggestionsController) GetOnFocusLost() func(types.OnFocusLostOpts) error {
 	return func(types.OnFocusLostOpts) error {
-		deactivateConfirmationPrompt
+		self.helpers.Confirmation.DeactivateConfirmationPrompt()
 		return nil
 	}
 }