"""Widgets for manipulating git stashes""" from qtpy.QtCore import Qt from ..i18n import N_ from ..interaction import Interaction from ..models import stash from ..qtutils import get from .. import cmds from .. import hotkeys from .. import icons from .. import qtutils from . import defs from . import diff from . import standard from . import text def view(context, show=True): """Launches a stash dialog using the provided model + view""" model = stash.StashModel(context) stash_view = StashView(context, model, parent=qtutils.active_window()) if show: stash_view.show() stash_view.raise_() return stash_view class StashView(standard.Dialog): def __init__(self, context, model, parent=None): standard.Dialog.__init__(self, parent=parent) self.context = context self.model = model self.stashes = [] self.revids = [] self.names = [] self.setWindowTitle(N_('Stash')) if parent is not None: self.setWindowModality(Qt.WindowModal) self.stash_list = standard.ListWidget(parent=self) self.stash_text = diff.DiffTextEdit(context, self) self.rename_button = qtutils.create_button( text=N_('Rename'), tooltip=N_('Rename the selected stash'), icon=icons.edit(), ) self.apply_button = qtutils.create_button( text=N_('Apply'), tooltip=N_('Apply the selected stash'), icon=icons.ok() ) self.save_button = qtutils.create_button( text=N_('Save'), tooltip=N_('Save modified state to new stash'), icon=icons.save(), default=True, ) self.drop_button = qtutils.create_button( text=N_('Drop'), tooltip=N_('Drop the selected stash'), icon=icons.discard() ) self.pop_button = qtutils.create_button( text=N_('Pop'), tooltip=N_('Apply and drop the selected stash (git stash pop)'), icon=icons.discard(), ) self.help_button = qtutils.create_button( text=N_('Help'), tooltip=N_('Show help\nShortcut: ?'), icon=icons.question() ) self.close_button = qtutils.close_button() # A list of tuples [(display_text, tooltip), ...] containing the save modes. save_modes = stash.SaveModes.get() self.save_modes = qtutils.combo([mode[0] for mode in save_modes]) # Change the combobox's tooltip when the selection changes. self.save_modes.currentIndexChanged.connect( lambda idx: self.save_modes.setToolTip(save_modes[idx][1]) ) # Set tooltips for the individual items in the tooltip. for idx, mode in enumerate(save_modes): self.save_modes.setItemData(idx, mode[1], Qt.ToolTipRole) self.recreate_index = qtutils.checkbox( text=N_('Recreate Index'), tooltip=N_('Recreate the index when restoring stashes'), ) # Arrange layouts self.splitter = qtutils.splitter( Qt.Horizontal, self.stash_list, self.stash_text ) self.splitter.setChildrenCollapsible(False) self.action_layout = qtutils.hbox( defs.no_margin, defs.button_spacing, self.rename_button, self.pop_button, self.drop_button, self.apply_button, qtutils.STRETCH, self.save_modes, self.save_button, ) self.bottom_layout = qtutils.hbox( defs.margin, defs.button_spacing, self.help_button, self.recreate_index, qtutils.STRETCH, self.close_button, ) self.main_layt = qtutils.vbox( defs.margin, defs.spacing, self.splitter, self.action_layout, self.bottom_layout, ) self.setLayout(self.main_layt) self.splitter.setSizes([self.width() // 3, self.width() * 2 // 3]) # Save stash with Ctrl+S self.save_action = qtutils.add_action( self, N_('Save'), self.stash_save, hotkeys.SAVE ) # Apply stash with Ctrl+Enter self.apply_action = qtutils.add_action( self, N_('Apply'), self.stash_apply, hotkeys.APPLY ) # Pop stash with Ctrl+Backspace self.pop_action = qtutils.add_action( self, N_('Pop'), self.stash_pop, hotkeys.DELETE_FILE_SECONDARY ) # Drop stash with Ctrl+Shift+Backspace self.drop_action = qtutils.add_action( self, N_('Delete'), self.stash_drop, hotkeys.DELETE_FILE ) self.choose_all_changes_action = qtutils.add_action( self, N_('All changes'), lambda: self.save_modes.set_index_if_enabled(stash.SaveModes.ALL), hotkeys.CTRL_1, hotkeys.STASH_ALL, ) self.choose_staged_only_action = qtutils.add_action( self, N_('Staged only'), lambda: self.save_modes.set_index_if_enabled(stash.SaveModes.STAGED), hotkeys.CTRL_2, hotkeys.STASH_STAGED, ) self.choose_unstaged_only_action = qtutils.add_action( self, N_('Unstaged only'), lambda: self.save_modes.set_index_if_enabled(stash.SaveModes.UNSTAGED), hotkeys.CTRL_3, hotkeys.STASH_UNSTAGED, ) self.show_help_action = qtutils.add_action( self, N_('Show Help'), lambda: show_help(context), hotkeys.QUESTION ) self.stash_list.itemSelectionChanged.connect(self.item_selected) qtutils.connect_button(self.save_button, self.stash_save) qtutils.connect_button(self.rename_button, self.stash_rename) qtutils.connect_button(self.apply_button, self.stash_apply) qtutils.connect_button(self.pop_button, self.stash_pop) qtutils.connect_button(self.drop_button, self.stash_drop) qtutils.connect_button(self.close_button, self.close_and_rescan) qtutils.connect_button(self.help_button, lambda: show_help(context)) self.init_size(parent=parent) self.update_from_model() self.update_actions() def close_and_rescan(self): cmds.do(cmds.Rescan, self.context) self.reject() def selected_stash(self): """Returns the stash name of the currently selected stash""" list_widget = self.stash_list stash_list = self.revids return qtutils.selected_item(list_widget, stash_list) def selected_name(self): list_widget = self.stash_list stash_list = self.names return qtutils.selected_item(list_widget, stash_list) def item_selected(self): """Shows the current stash in the main view.""" self.update_actions() selection = self.selected_stash() if not selection: return diff_text = self.model.stash_diff(selection) self.stash_text.setPlainText(diff_text) def update_actions(self): is_staged = self.model.is_staged() is_changed = self.model.is_changed() self.save_modes.set_item_enabled(stash.SaveModes.STAGED, is_staged) self.save_modes.set_item_enabled(stash.SaveModes.UNSTAGED, is_staged) self.save_modes.setEnabled(is_changed) self.save_button.setEnabled(is_changed) is_selected = bool(self.selected_stash()) self.apply_action.setEnabled(is_selected) self.drop_action.setEnabled(is_selected) self.pop_action.setEnabled(is_selected) self.recreate_index.setEnabled(is_selected) self.rename_button.setEnabled(is_selected) self.apply_button.setEnabled(is_selected) self.drop_button.setEnabled(is_selected) self.pop_button.setEnabled(is_selected) def update_from_model(self): """Initiates git queries on the model and updates the view""" stashes, revids, author_dates, names = self.model.stash_info() self.stashes = stashes self.revids = revids self.names = names displayed = False self.stash_list.clear() self.stash_list.addItems(self.stashes) if self.stash_list.count() > 0: for i in range(self.stash_list.count()): self.stash_list.item(i).setToolTip(author_dates[i]) item = self.stash_list.item(0) self.stash_list.setCurrentItem(item) displayed = True # "Stash Index" depends on staged changes, so disable this option # if there are no staged changes. is_staged = self.model.is_staged() if stash.should_stash_staged(self.save_modes.current_index()) and not is_staged: self.save_modes.set_index(stash.SaveModes.ALL) return displayed def stash_rename(self): """Renames the currently selected stash""" selection = self.selected_stash() name = self.selected_name() new_name, ok = qtutils.prompt( N_('Enter a new name for the stash'), text=name, title=N_('Rename Stash'), parent=self, ) if not ok or not new_name: return if new_name == name: Interaction.information( N_('No change made'), N_('The stash has not been renamed') ) return context = self.context cmds.do(stash.RenameStash, context, selection, new_name) self.update_from_model() def stash_pop(self): self.stash_apply(pop=True) def stash_apply(self, pop=False): """Applies the currently selected stash""" selection = self.selected_stash() if not selection: return context = self.context index = get(self.recreate_index) cmds.do(stash.ApplyStash, context, selection, index, pop) self.update_from_model() def stash_save(self): """Saves the worktree in a stash This prompts the user for a stash name and creates a git stash named accordingly. """ stash_name, ok = qtutils.prompt( N_('Enter a name for the stash'), title=N_('Save Stash'), parent=self ) if not ok or not stash_name: return context = self.context keep_index = stash.should_keep_index(self.save_modes.current_index()) stash_index = stash.should_stash_staged(self.save_modes.current_index()) if stash_index: cmds.do(stash.StashIndex, context, stash_name) else: cmds.do(stash.SaveStash, context, stash_name, keep_index) self.update_from_model() def stash_drop(self): """Drops the currently selected stash""" selection = self.selected_stash() name = self.selected_name() if not selection: return if not Interaction.confirm( N_('Drop Stash?'), N_('Recovering a dropped stash is not possible.'), N_('Drop the "%s" stash?') % name, N_('Drop Stash'), default=True, icon=icons.discard(), ): return cmds.do(stash.DropStash, self.context, selection) if not self.update_from_model(): self.stash_text.setPlainText('') def export_state(self): """Export persistent settings""" state = super().export_state() current_index = self.save_modes.current_index() state['keep_index'] = stash.should_keep_index(current_index) state['stash_index'] = stash.should_stash_staged(current_index) state['recreate_index'] = get(self.recreate_index) state['sizes'] = get(self.splitter) return state def apply_state(self, state): """Apply persistent settings""" result = super().apply_state(state) keep_index = bool(state.get('keep_index', True)) recreate_index = bool(state.get('recreate_index', True)) stash_index = bool(state.get('stash_index', False)) # It would be simpler to have a "save_mode" instead of individual booleans. # This is done for compatibility with older versions. self.recreate_index.setChecked(recreate_index) if stash_index: self.save_modes.set_index(stash.SaveModes.STAGED) elif keep_index: self.save_modes.set_index(stash.SaveModes.UNSTAGED) else: self.save_modes.set_index(stash.SaveModes.ALL) try: self.splitter.setSizes(state['sizes']) except (KeyError, ValueError, AttributeError): pass return result def show_help(context): help_text = N_( """ Keyboard Shortcuts Actions ------------------ -------------------------------- ? show help esc close and exit ctrl + 1, alt + a set save mode to "All changes" ctrl + 2, alt + s set save mode to "Staged only" ctrl + 3, alt + u set save mode to "Unstaged only" ctrl + enter apply stash ctrl + s save stash """ ) title = N_('Help') return text.text_dialog(context, help_text, title)