def _create_header_context_menu(self, menu, idx):
if idx == self.idx_staged:
menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage All'),
cmds.run(cmds.UnstageAll))
return menu
elif idx == self.idx_unmerged:
action = menu.addAction(qtutils.icon('add.svg'),
cmds.StageUnmerged.name(),
cmds.run(cmds.StageUnmerged))
action.setShortcut(cmds.StageUnmerged.SHORTCUT)
return menu
elif idx == self.idx_modified:
action = menu.addAction(qtutils.icon('add.svg'),
cmds.StageModified.name(),
cmds.run(cmds.StageModified))
action.setShortcut(cmds.StageModified.SHORTCUT)
return menu
elif idx == self.idx_untracked:
action = menu.addAction(qtutils.icon('add.svg'),
cmds.StageUntracked.name(),
cmds.run(cmds.StageUntracked))
action.setShortcut(cmds.StageUntracked.SHORTCUT)
return menu
def __init__(self, parent, titlebar):
DiffTextEdit.__init__(self, parent)
self.model = model = main.model()
# "Diff Options" tool menu
self.diff_ignore_space_at_eol_action = add_action(
self, N_('Ignore changes in whitespace at EOL'),
self._update_diff_opts)
self.diff_ignore_space_at_eol_action.setCheckable(True)
self.diff_ignore_space_change_action = add_action(
self, N_('Ignore changes in amount of whitespace'),
self._update_diff_opts)
self.diff_ignore_space_change_action.setCheckable(True)
self.diff_ignore_all_space_action = add_action(
self, N_('Ignore all whitespace'), self._update_diff_opts)
self.diff_ignore_all_space_action.setCheckable(True)
self.diff_function_context_action = add_action(
self, N_('Show whole surrounding functions of changes'),
self._update_diff_opts)
self.diff_function_context_action.setCheckable(True)
self.diffopts_button = create_action_button(tooltip=N_('Diff Options'),
icon=options_icon())
self.diffopts_menu = create_menu(N_('Diff Options'),
self.diffopts_button)
self.diffopts_menu.addAction(self.diff_ignore_space_at_eol_action)
self.diffopts_menu.addAction(self.diff_ignore_space_change_action)
self.diffopts_menu.addAction(self.diff_ignore_all_space_action)
self.diffopts_menu.addAction(self.diff_function_context_action)
self.diffopts_button.setMenu(self.diffopts_menu)
qtutils.hide_button_menu_indicator(self.diffopts_button)
titlebar.add_corner_widget(self.diffopts_button)
self.action_apply_selection = qtutils.add_action(
self, '', self.apply_selection, Qt.Key_S)
self.action_revert_selection = qtutils.add_action(
self, '', self.revert_selection)
self.action_revert_selection.setIcon(qtutils.icon('undo.svg'))
self.launch_editor = qtutils.add_action(self, cmds.LaunchEditor.name(),
run(cmds.LaunchEditor),
cmds.LaunchEditor.SHORTCUT,
'Return', 'Enter')
self.launch_editor.setIcon(qtutils.options_icon())
self.launch_difftool = qtutils.add_action(self,
cmds.LaunchDifftool.name(),
run(cmds.LaunchDifftool),
cmds.LaunchDifftool.SHORTCUT)
self.launch_difftool.setIcon(qtutils.icon('git.svg'))
model.add_observer(model.message_diff_text_changed, self._emit_text)
self.connect(self, SIGNAL('set_text'), self.setPlainText)
def _create_unstaged_context_menu(self, menu, s):
modified_submodule = (s.modified and
s.modified[0] in self.m.submodules)
if modified_submodule:
return self._create_modified_submodule_context_menu(menu, s)
if self.unstaged():
action = menu.addAction(qtutils.options_icon(),
cmds.LaunchEditor.name(),
cmds.run(cmds.LaunchEditor))
action.setShortcut(cmds.Edit.SHORTCUT)
if s.modified and self.m.stageable():
action = menu.addAction(qtutils.git_icon(),
cmds.LaunchDifftool.name(),
cmds.run(cmds.LaunchDifftool))
action.setShortcut(cmds.LaunchDifftool.SHORTCUT)
if self.m.stageable():
menu.addSeparator()
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
if s.modified and self.m.stageable():
if self.m.undoable():
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Unstaged Edits...'),
self._revert_unstaged_edits)
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Uncommited Edits...'),
lambda: self._revert_uncommitted_edits(
self.modified()))
if self.unstaged() and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.unstaged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if s.untracked:
menu.addSeparator()
menu.addAction(qtutils.discard_icon(),
N_('Delete File(s)...'), self._delete_files)
menu.addSeparator()
menu.addAction(qtutils.icon('edit-clear.svg'),
N_('Add to .gitignore'),
cmds.run(cmds.Ignore,
map(lambda x: '/' + x, self.untracked())))
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _create_unstaged_context_menu(self, menu, s):
modified_submodule = (s.modified and
s.modified[0] in self.m.submodules)
if modified_submodule:
return self._create_modified_submodule_context_menu(menu, s)
if self.unstaged():
action = menu.addAction(qtutils.options_icon(),
cmds.LaunchEditor.name(),
cmds.run(cmds.LaunchEditor))
action.setShortcut(cmds.Edit.SHORTCUT)
if s.modified and self.m.stageable():
action = menu.addAction(qtutils.git_icon(),
cmds.LaunchDifftool.name(),
cmds.run(cmds.LaunchDifftool))
action.setShortcut(cmds.LaunchDifftool.SHORTCUT)
if self.m.stageable():
menu.addSeparator()
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
if s.modified and self.m.stageable():
if self.m.undoable():
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Unstaged Edits...'),
self._revert_unstaged_edits)
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Uncommited Edits...'),
lambda: self._revert_uncommitted_edits(
self.modified()))
if self.unstaged() and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.unstaged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if s.untracked:
menu.addSeparator()
menu.addAction(qtutils.discard_icon(),
N_('Delete File(s)...'), self._delete_files)
menu.addSeparator()
menu.addAction(qtutils.icon('edit-clear.svg'),
N_('Add to .gitignore'),
cmds.run(cmds.Ignore,
map(lambda x: '/' + x, self.untracked())))
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def __init__(self, parent, titlebar):
DiffTextEdit.__init__(self, parent)
self.model = model = main.model()
# "Diff Options" tool menu
self.diff_ignore_space_at_eol_action = add_action(self,
N_('Ignore changes in whitespace at EOL'),
self._update_diff_opts)
self.diff_ignore_space_at_eol_action.setCheckable(True)
self.diff_ignore_space_change_action = add_action(self,
N_('Ignore changes in amount of whitespace'),
self._update_diff_opts)
self.diff_ignore_space_change_action.setCheckable(True)
self.diff_ignore_all_space_action = add_action(self,
N_('Ignore all whitespace'),
self._update_diff_opts)
self.diff_ignore_all_space_action.setCheckable(True)
self.diff_function_context_action = add_action(self,
N_('Show whole surrounding functions of changes'),
self._update_diff_opts)
self.diff_function_context_action.setCheckable(True)
self.diffopts_button = create_action_button(
tooltip=N_('Diff Options'), icon=options_icon())
self.diffopts_menu = create_menu(N_('Diff Options'),
self.diffopts_button)
self.diffopts_menu.addAction(self.diff_ignore_space_at_eol_action)
self.diffopts_menu.addAction(self.diff_ignore_space_change_action)
self.diffopts_menu.addAction(self.diff_ignore_all_space_action)
self.diffopts_menu.addAction(self.diff_function_context_action)
self.diffopts_button.setMenu(self.diffopts_menu)
qtutils.hide_button_menu_indicator(self.diffopts_button)
titlebar.add_corner_widget(self.diffopts_button)
self.action_apply_selection = qtutils.add_action(self, '',
self.apply_selection, Qt.Key_S)
self.action_revert_selection = qtutils.add_action(self, '',
self.revert_selection)
self.action_revert_selection.setIcon(qtutils.icon('undo.svg'))
self.launch_editor = qtutils.add_action(self,
cmds.LaunchEditor.name(), run(cmds.LaunchEditor),
cmds.LaunchEditor.SHORTCUT,
'Return', 'Enter')
self.launch_editor.setIcon(qtutils.options_icon())
self.launch_difftool = qtutils.add_action(self,
cmds.LaunchDifftool.name(), run(cmds.LaunchDifftool),
cmds.LaunchDifftool.SHORTCUT)
self.launch_difftool.setIcon(qtutils.icon('git.svg'))
model.add_observer(model.message_diff_text_changed, self._emit_text)
self.connect(self, SIGNAL('set_text'), self.setPlainText)
def _create_staged_context_menu(self, menu, s):
if s.staged[0] in self.m.submodules:
return self._create_staged_submodule_context_menu(menu, s)
if self.m.unstageable():
action = menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage Selected'),
cmds.run(cmds.Unstage, self.staged()))
action.setShortcut(cmds.Unstage.SHORTCUT)
menu.addAction(self.launch_editor)
menu.addAction(self.launch_difftool)
if not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.staged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Uncommited Edits...'),
lambda: self._revert_uncommitted_edits(
self.staged()))
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _create_unstaged_context_menu(self, menu, s):
modified_submodule = (s.modified and
s.modified[0] in self.m.submodules)
if modified_submodule:
return self._create_modified_submodule_context_menu(menu, s)
if self.m.stageable():
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
# Do all of the selected items exist?
unstaged_items = self.unstaged_items()
all_exist = all([i.exists for i in unstaged_items])
if all_exist and self.unstaged():
menu.addAction(self.launch_editor_action)
if all_exist and s.modified and self.m.stageable():
menu.addAction(self.launch_difftool_action)
if s.modified and self.m.stageable():
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Uncommited Edits...'),
lambda: self._revert_uncommitted_edits(
self.modified()))
if all_exist and self.unstaged() and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.unstaged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if all_exist and s.untracked:
menu.addSeparator()
if self.move_to_trash_action is not None:
menu.addAction(self.move_to_trash_action)
menu.addAction(self.delete_untracked_files_action)
menu.addSeparator()
menu.addAction(qtutils.icon('edit-clear.svg'),
N_('Add to .gitignore'),
cmds.run(cmds.Ignore,
map(lambda x: '/' + x, self.untracked())))
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _create_unstaged_context_menu(self, menu, s):
modified_submodule = (s.modified and
s.modified[0] in self.m.submodules)
if modified_submodule:
return self._create_modified_submodule_context_menu(menu, s)
if self.m.stageable():
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
# Do all of the selected items exist?
all_exist = all(not i in self.m.unstaged_deleted and core.exists(i)
for i in self.staged())
if all_exist and self.unstaged():
menu.addAction(self.launch_editor_action)
if all_exist and s.modified and self.m.stageable():
menu.addAction(self.launch_difftool_action)
if s.modified and self.m.stageable():
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addAction(self.revert_uncommitted_edits_action)
if all_exist and self.unstaged() and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.unstaged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if all_exist and s.untracked:
menu.addSeparator()
if self.move_to_trash_action is not None:
menu.addAction(self.move_to_trash_action)
menu.addAction(self.delete_untracked_files_action)
menu.addSeparator()
menu.addAction(qtutils.icon('edit-clear.svg'),
N_('Add to .gitignore'),
cmds.run(cmds.Ignore,
map(lambda x: '/' + x, self.untracked())))
menu.addSeparator()
menu.addAction(self.copy_path_action)
menu.addAction(self.copy_relpath_action)
return menu
def _create_unstaged_context_menu(self, menu, s):
modified_submodule = s.modified and s.modified[0] in self.m.submodules
if modified_submodule:
return self._create_modified_submodule_context_menu(menu, s)
if self.m.stageable():
action = menu.addAction(
qtutils.icon("add.svg"), N_("Stage Selected"), cmds.run(cmds.Stage, self.unstaged())
)
action.setShortcut(cmds.Stage.SHORTCUT)
# Do all of the selected items exist?
unstaged_items = self.unstaged_items()
all_exist = all([i.exists for i in unstaged_items])
if all_exist and self.unstaged():
menu.addAction(self.launch_editor)
if all_exist and s.modified and self.m.stageable():
menu.addAction(self.launch_difftool)
if s.modified and self.m.stageable():
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addAction(
qtutils.icon("undo.svg"),
N_("Revert Uncommited Edits..."),
lambda: self._revert_uncommitted_edits(self.modified()),
)
if all_exist and self.unstaged() and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(
qtutils.file_icon(), cmds.OpenDefaultApp.name(), cmds.run(cmds.OpenDefaultApp, self.unstaged())
)
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(), cmds.OpenParentDir.name(), self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if all_exist and s.untracked:
menu.addSeparator()
menu.addAction(qtutils.discard_icon(), N_("Delete File(s)..."), self._delete_files)
menu.addSeparator()
menu.addAction(
qtutils.icon("edit-clear.svg"),
N_("Add to .gitignore"),
cmds.run(cmds.Ignore, map(lambda x: "/" + x, self.untracked())),
)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def __init__(self, parent):
DiffTextEdit.__init__(self, parent)
self.model = model = main.model()
self.mode = self.model.mode_none
self.action_process_section = qtutils.add_action(self,
N_('Process Section'),
self.apply_section, Qt.Key_H)
self.action_process_selection = qtutils.add_action(self,
N_('Process Selection'),
self.apply_selection, Qt.Key_S)
self.launch_editor = qtutils.add_action(self,
cmds.LaunchEditor.name(), run(cmds.LaunchEditor),
cmds.LaunchEditor.SHORTCUT,
'Return', 'Enter')
self.launch_editor.setIcon(qtutils.options_icon())
self.launch_difftool = qtutils.add_action(self,
cmds.LaunchDifftool.name(), run(cmds.LaunchDifftool),
cmds.LaunchDifftool.SHORTCUT)
self.launch_difftool.setIcon(qtutils.icon('git.svg'))
self.action_stage_selection = qtutils.add_action(self,
N_('Stage &Selected Lines'),
self.stage_selection)
self.action_stage_selection.setIcon(qtutils.icon('add.svg'))
self.action_stage_selection.setShortcut(Qt.Key_S)
self.action_revert_selection = qtutils.add_action(self,
N_('Revert Selected Lines...'),
self.revert_selection)
self.action_revert_selection.setIcon(qtutils.icon('undo.svg'))
self.action_unstage_selection = qtutils.add_action(self,
N_('Unstage &Selected Lines'),
self.unstage_selection)
self.action_unstage_selection.setIcon(qtutils.icon('remove.svg'))
self.action_unstage_selection.setShortcut(Qt.Key_S)
self.action_apply_selection = qtutils.add_action(self,
N_('Apply Diff Selection to Work Tree'),
self.stage_selection)
self.action_apply_selection.setIcon(qtutils.apply_icon())
model.add_observer(model.message_mode_about_to_change,
self._mode_about_to_change)
model.add_observer(model.message_diff_text_changed, self._emit_text)
self.connect(self, SIGNAL('copyAvailable(bool)'),
self.enable_selection_actions)
self.connect(self, SIGNAL('set_text'), self.setPlainText)
def _revert_unstaged_edits(self, staged=False):
if not self.m.undoable():
return
if staged:
items_to_undo = self.staged()
else:
items_to_undo = self.modified()
if items_to_undo:
if not qtutils.confirm('Revert Unstaged Changes?',
'This operation drops unstaged changes.'
'\nThese changes cannot be recovered.',
'Revert the unstaged changes?',
'Revert Unstaged Changes',
default=True,
icon=qtutils.icon('undo.svg')):
return
args = []
if not staged and self.m.amending():
args.append(self.m.head)
cola.notifier().broadcast(signals.checkout,
args + ['--'] + items_to_undo)
else:
qtutils.log(1, self.tr('No files selected for '
'checkout from HEAD.'))
def __init__(self, parent):
standard.Dialog.__init__(self, parent=parent)
self.model = settings.Settings()
self.resize(494, 238)
self.setWindowTitle(N_('Bookmarks'))
if parent is not None:
self.setWindowModality(Qt.WindowModal)
self.layt = QtGui.QVBoxLayout(self)
self.layt.setMargin(defs.margin)
self.layt.setSpacing(defs.spacing)
self.bookmarks = QtGui.QListWidget(self)
self.bookmarks.setAlternatingRowColors(True)
self.bookmarks.setSelectionMode(QtGui.QAbstractItemView
.ExtendedSelection)
self.layt.addWidget(self.bookmarks)
self.button_layout = QtGui.QHBoxLayout()
self.open_button = QtGui.QPushButton(self)
self.open_button.setText(N_('Open'))
self.open_button.setIcon(qtutils.open_icon())
self.open_button.setEnabled(False)
self.button_layout.addWidget(self.open_button)
self.add_button = QtGui.QPushButton(self)
self.add_button.setText(N_('Add'))
self.add_button.setIcon(qtutils.icon('add.svg'))
self.button_layout.addWidget(self.add_button)
self.delete_button = QtGui.QPushButton(self)
self.delete_button.setText(N_('Delete'))
self.delete_button.setIcon(qtutils.discard_icon())
self.delete_button.setEnabled(False)
self.button_layout.addWidget(self.delete_button)
self.button_layout.addStretch()
self.save_button = QtGui.QPushButton(self)
self.save_button.setText(N_('Save'))
self.save_button.setIcon(qtutils.save_icon())
self.save_button.setEnabled(False)
self.button_layout.addWidget(self.save_button)
self.close_button = QtGui.QPushButton(self)
self.close_button.setText(N_('Close'))
self.button_layout.addWidget(self.close_button)
self.layt.addLayout(self.button_layout)
self.connect(self.bookmarks, SIGNAL('itemSelectionChanged()'),
self.item_selection_changed)
qtutils.connect_button(self.open_button, self.open_repo)
qtutils.connect_button(self.add_button, self.add)
qtutils.connect_button(self.delete_button, self.delete)
qtutils.connect_button(self.save_button, self.save)
qtutils.connect_button(self.close_button, self.accept)
self.update_bookmarks()
def _create_unmerged_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(), self.tr('Launch Merge Tool'),
cmds.run(cmds.Mergetool, self.unmerged()))
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addSeparator()
action = menu.addAction(qtutils.options_icon(),
self.tr(cmds.LaunchEditor.NAME),
cmds.run(cmds.LaunchEditor))
action.setShortcut(cmds.LaunchEditor.SHORTCUT)
if not utils.is_win32():
menu.addSeparator()
action = menu.addAction(
qtutils.file_icon(), self.tr(cmds.OpenDefaultApp.NAME),
cmds.run(cmds.OpenDefaultApp, self.unmerged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
self.tr(cmds.OpenParentDir.NAME),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _revert_unstaged_edits(self, staged=False):
if not self.m.undoable():
return
if staged:
items_to_undo = self.staged()
else:
items_to_undo = self.modified()
if items_to_undo:
if not qtutils.confirm(
N_('Revert Unstaged Changes?'),
N_('This operation drops unstaged changes.\n'
'These changes cannot be recovered.'),
N_('Revert the unstaged changes?'),
N_('Revert Unstaged Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
args = []
if not staged and self.m.amending():
args.append(self.m.head)
cmds.do(cmds.Checkout, args + ['--'] + items_to_undo)
else:
msg = N_('No files selected for checkout from HEAD.')
Interaction.log(msg)
def _create_unmerged_context_menu(self, menu, s):
menu.addAction(self.launch_difftool_action)
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addSeparator()
menu.addAction(self.launch_editor_action)
if not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.unmerged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
menu.addAction(self.copy_relpath_action)
return menu
def create_branch(self):
"""Creates a branch; called by the "Create Branch" button"""
self.getopts()
revision = self.opts.revision
branch = self.opts.branch
no_update = self.no_update_radio.isChecked()
ffwd_only = self.ffwd_only_radio.isChecked()
existing_branches = gitcmds.branch_list()
check_branch = False
if not branch or not revision:
qtutils.critical(N_('Missing Data'),
N_('Please provide both a branch '
'name and revision expression.'))
return
if branch in existing_branches:
if no_update:
msg = N_('Branch "%s" already exists.') % branch
qtutils.critical(N_('Branch Exists'), msg)
return
# Whether we should prompt the user for lost commits
commits = gitcmds.rev_list_range(revision, branch)
check_branch = bool(commits)
if check_branch:
msg = (N_('Resetting "%(branch)s" to "%(revision)s" '
'will lose commits.') %
dict(branch=branch, revision=revision))
if ffwd_only:
qtutils.critical(N_('Branch Exists'), msg)
return
lines = [msg]
for idx, commit in enumerate(commits):
subject = commit[1][0:min(len(commit[1]),16)]
if len(subject) < len(commit[1]):
subject += '...'
lines.append('\t' + commit[0][:8]
+'\t' + subject)
if idx >= 5:
skip = len(commits) - 5
lines.append('\t(%s)' % (N_('%d skipped') % skip))
break
line = N_('Recovering lost commits may not be easy.')
lines.append(line)
if not qtutils.confirm(N_('Reset Branch?'),
'\n'.join(lines),
(N_('Reset "%(branch)s" to "%(revision)s"?') %
dict(branch=branch, revision=revision)),
N_('Reset Branch'),
default=False,
icon=qtutils.icon('undo.svg')):
return
self.setEnabled(False)
self.progress.setEnabled(True)
QtGui.QApplication.setOverrideCursor(Qt.WaitCursor)
# Show a nice progress bar
self.progress.setLabelText(N_('Updating...'))
self.progress.show()
self.thread.start()
def _create_unmerged_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(),
self.tr('Launch Merge Tool'),
cmds.run(cmds.Mergetool, self.unmerged()))
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addSeparator()
action = menu.addAction(qtutils.options_icon(),
self.tr(cmds.LaunchEditor.NAME),
cmds.run(cmds.LaunchEditor))
action.setShortcut(cmds.LaunchEditor.SHORTCUT)
if not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
self.tr(cmds.OpenDefaultApp.NAME),
cmds.run(cmds.OpenDefaultApp, self.unmerged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
self.tr(cmds.OpenParentDir.NAME),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def add_item(self, txt, path, hide=False):
"""Create a new top-level item in the status tree."""
item = QtGui.QTreeWidgetItem(self)
item.setText(0, self.tr(txt))
item.setIcon(0, qtutils.icon(path))
if hide:
self.setItemHidden(item, True)
def contextMenuEvent(self, event):
"""Create the context menu for the diff display."""
menu = QtGui.QMenu(self)
staged, modified, unmerged, untracked = cola.selection()
if self.mode == self.model.mode_worktree:
if modified and modified[0] in cola.model().submodules:
menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage'),
SLOT(signals.stage, modified))
menu.addAction(qtutils.git_icon(),
self.tr('Launch git-cola'),
SLOT(signals.open_repo,
os.path.abspath(modified[0])))
elif modified:
menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Section'),
self.stage_section)
menu.addAction(self.action_stage_selection)
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
self.tr('Revert Section...'),
self.revert_section)
menu.addAction(self.action_revert_selection)
elif self.mode == self.model.mode_index:
if staged and staged[0] in cola.model().submodules:
menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage'),
SLOT(signals.unstage, staged))
menu.addAction(qtutils.git_icon(),
self.tr('Launch git-cola'),
SLOT(signals.open_repo,
os.path.abspath(staged[0])))
else:
menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage Section'),
self.unstage_section)
menu.addAction(self.action_unstage_selection)
elif self.mode == self.model.mode_branch:
menu.addAction(qtutils.apply_icon(),
self.tr('Apply Diff to Work Tree'),
self.stage_section)
menu.addAction(self.action_apply_selection)
elif self.mode == self.model.mode_grep:
menu.addAction(qtutils.icon('open.svg'),
self.tr('Launch Editor'),
lambda: guicmds.goto_grep(self.selected_line()))
menu.addSeparator()
menu.addAction(qtutils.icon('edit-copy.svg'),
'Copy', self.copy)
menu.addAction(qtutils.icon('edit-select-all.svg'),
'Select All', self.selectAll)
menu.exec_(self.mapToGlobal(event.pos()))
def __init__(self, parent):
standard.Dialog.__init__(self, parent)
self.model = settings.Settings()
self.resize(494, 238)
self.setWindowTitle(N_('Bookmarks'))
self.setWindowModality(Qt.WindowModal)
self.layt = QtGui.QVBoxLayout(self)
self.layt.setMargin(defs.margin)
self.layt.setSpacing(defs.spacing)
self.bookmarks = QtGui.QListWidget(self)
self.bookmarks.setAlternatingRowColors(True)
self.bookmarks.setSelectionMode(
QtGui.QAbstractItemView.ExtendedSelection)
self.layt.addWidget(self.bookmarks)
self.button_layout = QtGui.QHBoxLayout()
self.open_button = QtGui.QPushButton(self)
self.open_button.setText(N_('Open'))
self.open_button.setIcon(qtutils.open_icon())
self.open_button.setEnabled(False)
self.button_layout.addWidget(self.open_button)
self.add_button = QtGui.QPushButton(self)
self.add_button.setText(N_('Add'))
self.add_button.setIcon(qtutils.icon('add.svg'))
self.button_layout.addWidget(self.add_button)
self.delete_button = QtGui.QPushButton(self)
self.delete_button.setText(N_('Delete'))
self.delete_button.setIcon(qtutils.discard_icon())
self.delete_button.setEnabled(False)
self.button_layout.addWidget(self.delete_button)
self.button_layout.addStretch()
self.save_button = QtGui.QPushButton(self)
self.save_button.setText(N_('Save'))
self.save_button.setIcon(qtutils.save_icon())
self.save_button.setEnabled(False)
self.button_layout.addWidget(self.save_button)
self.close_button = QtGui.QPushButton(self)
self.close_button.setText(N_('Close'))
self.button_layout.addWidget(self.close_button)
self.layt.addLayout(self.button_layout)
self.connect(self.bookmarks, SIGNAL('itemSelectionChanged()'),
self.item_selection_changed)
qtutils.connect_button(self.open_button, self.open_repo)
qtutils.connect_button(self.add_button, self.add)
qtutils.connect_button(self.delete_button, self.delete)
qtutils.connect_button(self.save_button, self.save)
qtutils.connect_button(self.close_button, self.accept)
self.update_bookmarks()
def create_branch(self):
"""Creates a branch; called by the "Create Branch" button"""
self.getopts()
revision = self.opts.revision
branch = self.opts.branch
no_update = self.no_update_radio.isChecked()
ffwd_only = self.ffwd_only_radio.isChecked()
existing_branches = gitcmds.branch_list()
check_branch = False
if not branch or not revision:
qtutils.critical(
'Missing Data', 'Please provide both a branch '
'name and revision expression.')
return
if branch in existing_branches:
if no_update:
msg = self.tr("Branch '%s' already exists.")
msg = unicode(msg) % branch
qtutils.critical('Branch Exists', msg)
return
# Whether we should prompt the user for lost commits
commits = gitcmds.rev_list_range(revision, branch)
check_branch = bool(commits)
if check_branch:
qmsg = self.tr("Resetting '%s' to '%s' will lose commits.")
msg = unicode(qmsg) % (branch, revision)
if ffwd_only:
qtutils.critical('Branch Exists', msg)
return
lines = [msg]
for idx, commit in enumerate(commits):
subject = commit[1][0:min(len(commit[1]), 16)]
if len(subject) < len(commit[1]):
subject += '...'
lines.append('\t' + commit[0][:8] + '\t' + subject)
if idx >= 5:
skip = len(commits) - 5
lines.append('\t(%d skipped)' % skip)
break
line = unicode(self.tr('Recovering lost commits may not be easy.'))
lines.append(line)
if not qtutils.confirm('Reset Branch?',
'\n'.join(lines),
'Reset "%s" to "%s"?' % (branch, revision),
'Reset Branch',
default=False,
icon=qtutils.icon('undo.svg')):
return
self.setEnabled(False)
self.progress.setEnabled(True)
QtGui.QApplication.setOverrideCursor(Qt.WaitCursor)
# Show a nice progress bar
self.progress.setLabelText('Updating...')
self.progress.show()
self.thread.start()
def contextMenuEvent(self, event):
"""Create the context menu for the diff display."""
menu = QtGui.QMenu(self)
s = selection.selection()
if self.model.stageable():
if s.modified and s.modified[0] in main.model().submodules:
action = menu.addAction(qtutils.icon('add.svg'),
cmds.Stage.name(),
cmds.run(cmds.Stage, s.modified))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addAction(qtutils.git_icon(),
N_('Launch git-cola'),
cmds.run(cmds.OpenRepo,
core.abspath(s.modified[0])))
elif s.modified:
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Section'),
self.stage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_stage_selection)
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Section...'),
self.revert_section)
menu.addAction(self.action_revert_selection)
if self.model.unstageable():
if s.staged and s.staged[0] in main.model().submodules:
action = menu.addAction(qtutils.icon('remove.svg'),
cmds.Unstage.name(),
cmds.do(cmds.Unstage, s.staged))
action.setShortcut(cmds.Unstage.SHORTCUT)
menu.addAction(qtutils.git_icon(),
N_('Launch git-cola'),
cmds.do(cmds.OpenRepo,
core.abspath(s.staged[0])))
elif s.staged:
action = menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage Section'),
self.unstage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_unstage_selection)
if self.model.stageable() or self.model.unstageable():
menu.addSeparator()
menu.addAction(self.launch_editor)
menu.addAction(self.launch_difftool)
menu.addSeparator()
action = menu.addAction(qtutils.icon('edit-copy.svg'),
N_('Copy'), self.copy)
action.setShortcut(QtGui.QKeySequence.Copy)
action = menu.addAction(qtutils.icon('edit-select-all.svg'),
N_('Select All'), self.selectAll)
action.setShortcut(QtGui.QKeySequence.SelectAll)
menu.exec_(self.mapToGlobal(event.pos()))
def contextMenuEvent(self, event):
"""Create the context menu for the diff display."""
menu = QtGui.QMenu(self)
s = selection.selection()
if self.model.stageable():
if s.modified and s.modified[0] in main.model().submodules:
action = menu.addAction(qtutils.icon('add.svg'),
cmds.Stage.name(),
cmds.run(cmds.Stage, s.modified))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addAction(qtutils.git_icon(),
N_('Launch git-cola'),
cmds.run(cmds.OpenRepo,
core.abspath(s.modified[0])))
elif s.modified:
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Section'),
self.stage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_stage_selection)
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
N_('Revert Section...'),
self.revert_section)
menu.addAction(self.action_revert_selection)
if self.model.unstageable():
if s.staged and s.staged[0] in main.model().submodules:
action = menu.addAction(qtutils.icon('remove.svg'),
cmds.Unstage.name(),
cmds.do(cmds.Unstage, s.staged))
action.setShortcut(cmds.Unstage.SHORTCUT)
menu.addAction(qtutils.git_icon(),
N_('Launch git-cola'),
cmds.do(cmds.OpenRepo,
core.abspath(s.staged[0])))
elif s.staged:
action = menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage Section'),
self.unstage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_unstage_selection)
if self.model.stageable() or self.model.unstageable():
menu.addSeparator()
menu.addAction(self.launch_editor)
menu.addAction(self.launch_difftool)
menu.addSeparator()
action = menu.addAction(qtutils.icon('edit-copy.svg'),
N_('Copy'), self.copy)
action.setShortcut(QtGui.QKeySequence.Copy)
action = menu.addAction(qtutils.icon('edit-select-all.svg'),
N_('Select All'), self.selectAll)
action.setShortcut(QtGui.QKeySequence.SelectAll)
menu.exec_(self.mapToGlobal(event.pos()))
def __init__(self, parent):
DiffTextEdit.__init__(self, parent)
self.model = model = cola.model()
self.mode = self.model.mode_none
# Install diff shortcut keys for stage/unstage
self.action_process_section = qtutils.add_action(self,
'Process Section',
self.apply_section, Qt.Key_H)
self.action_process_selection = qtutils.add_action(self,
'Process Selection',
self.apply_selection, Qt.Key_S)
# Context menu actions
self.action_stage_selection = qtutils.add_action(self,
self.tr('Stage &Selected Lines'),
self.stage_selection)
self.action_stage_selection.setIcon(qtutils.icon('add.svg'))
self.action_stage_selection.setShortcut(Qt.Key_S)
self.action_revert_selection = qtutils.add_action(self,
self.tr('Revert Selected Lines...'),
self.revert_selection)
self.action_revert_selection.setIcon(qtutils.icon('undo.svg'))
self.action_unstage_selection = qtutils.add_action(self,
self.tr('Unstage &Selected Lines'),
self.unstage_selection)
self.action_unstage_selection.setIcon(qtutils.icon('remove.svg'))
self.action_unstage_selection.setShortcut(Qt.Key_S)
self.action_apply_selection = qtutils.add_action(self,
self.tr('Apply Diff Selection to Work Tree'),
self.stage_selection)
self.action_apply_selection.setIcon(qtutils.apply_icon())
model.add_observer(model.message_mode_about_to_change,
self._mode_about_to_change)
model.add_observer(model.message_diff_text_changed, self.setPlainText)
self.connect(self, SIGNAL('copyAvailable(bool)'),
self.enable_selection_actions)
def revert_selection(self):
"""Destructively check out content for the selected file from $head."""
if not qtutils.confirm(N_('Revert Selected Lines?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Selected Lines'),
default=True,
icon=qtutils.icon('undo.svg')):
return
self.process_diff_selection(staged=False, apply_to_worktree=True,
reverse=True, selected=True)
def abort_merge():
"""Prompts before aborting a merge in progress
"""
title = N_('Abort Merge...')
txt = N_('Aborting the current merge will cause '
'*ALL* uncommitted changes to be lost.\n'
'Recovering uncommitted changes is not possible.')
info_txt = N_('Aborting the current merge?')
ok_txt = N_('Abort Merge')
if qtutils.confirm(title, txt, info_txt, ok_txt,
default=False, icon=qtutils.icon('undo.svg')):
gitcmds.abort_merge()
def revert_section(self):
"""Destructively remove a section from a worktree file."""
if not qtutils.confirm(N_('Revert Section?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Section'),
default=True,
icon=qtutils.icon('undo.svg')):
return
self.process_diff_selection(staged=False, apply_to_worktree=True,
reverse=True)
def revert_selection(self):
"""Destructively check out content for the selected file from $head."""
if not qtutils.confirm(N_('Revert Selected Lines?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Selected Lines'),
default=True,
icon=qtutils.icon('undo.svg')):
return
self.process_diff_selection(staged=False, apply_to_worktree=True,
reverse=True, selected=True)
def revert(self):
"""Signal that we should revert changes to a path."""
if not qtutils.confirm(N_('Revert Uncommitted Changes?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Uncommitted Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
paths = self.selected_tracked_paths()
cmds.do(cmds.Checkout, ['HEAD', '--'] + paths)
def abort_merge():
"""Prompts before aborting a merge in progress
"""
title = qtutils.tr('Abort Merge...')
txt = ('Aborting the current merge will cause '
'*ALL* uncommitted changes to be lost.\n'
'Recovering uncommitted changes is not possible.')
info_txt = 'Aborting the current merge?'
ok_txt = 'Abort Merge'
if qtutils.confirm(title, txt, info_txt, ok_txt,
default=False, icon=qtutils.icon('undo.svg')):
gitcmds.abort_merge()
def revert(self):
"""Signal that we should revert changes to a path."""
if not qtutils.confirm('Revert Uncommitted Changes?',
'This operation drops uncommitted changes.'
'\nThese changes cannot be recovered.',
'Revert the uncommitted changes?',
'Revert Uncommitted Changes',
default=True,
icon=qtutils.icon('undo.svg')):
return
paths = self.selected_tracked_paths()
cola.notifier().broadcast(signals.checkout, ['HEAD', '--'] + paths)
def revert_section(self):
"""Destructively remove a section from a worktree file."""
if not qtutils.confirm(N_('Revert Diff Region?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Diff Region'),
default=True,
icon=qtutils.icon('undo.svg')):
return
self.process_diff_selection(staged=False, apply_to_worktree=True,
reverse=True)
def revert(self):
"""Signal that we should revert changes to a path."""
if not qtutils.confirm(N_('Revert Uncommitted Changes?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Uncommitted Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
paths = self.selected_tracked_paths()
cmds.do(cmds.Checkout, ['HEAD', '--'] + paths)
def _create_staged_context_menu(self, menu, s):
if s.staged[0] in self.m.submodules:
return self._create_staged_submodule_context_menu(menu, s)
if self.m.unstageable():
action = menu.addAction(
qtutils.icon("remove.svg"), N_("Unstage Selected"), cmds.run(cmds.Unstage, self.staged())
)
action.setShortcut(cmds.Unstage.SHORTCUT)
# Do all of the selected items exist?
staged_items = self.staged_items()
all_exist = all([i.exists for i in staged_items])
if all_exist:
menu.addAction(self.launch_editor)
menu.addAction(self.launch_difftool)
if all_exist and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(
qtutils.file_icon(), cmds.OpenDefaultApp.name(), cmds.run(cmds.OpenDefaultApp, self.staged())
)
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(), cmds.OpenParentDir.name(), self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addAction(
qtutils.icon("undo.svg"),
N_("Revert Uncommited Edits..."),
lambda: self._revert_uncommitted_edits(self.staged()),
)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def abort_merge():
"""Prompts before aborting a merge in progress
"""
title = qtutils.tr("Abort Merge...")
txt = (
"Aborting the current merge will cause "
"*ALL* uncommitted changes to be lost.\n"
"Recovering uncommitted changes is not possible."
)
info_txt = "Aborting the current merge?"
ok_txt = "Abort Merge"
if qtutils.confirm(title, txt, info_txt, ok_txt, default=False, icon=qtutils.icon("undo.svg")):
gitcmds.abort_merge()
def revert(self):
"""Signal that we should revert changes to a path."""
if not qtutils.confirm('Revert Uncommitted Changes?',
'This operation drops uncommitted changes.'
'\nThese changes cannot be recovered.',
'Revert the uncommitted changes?',
'Revert Uncommitted Changes',
default=False,
icon=qtutils.icon('undo.svg')):
return
paths = self.selected_tracked_paths()
cola.notifier().broadcast(signals.checkout,
['HEAD', '--'] + paths)
def revert(self):
"""Signal that we should revert changes to a path."""
if not qtutils.confirm(
N_("Revert Uncommitted Changes?"),
N_("This operation drops uncommitted changes.\n" "These changes cannot be recovered."),
N_("Revert the uncommitted changes?"),
N_("Revert Uncommitted Changes"),
default=True,
icon=qtutils.icon("undo.svg"),
):
return
paths = self.selected_tracked_paths()
cmds.do(cmds.Checkout, ["HEAD", "--"] + paths)
def contextMenuEvent(self, event):
"""Create the context menu for the diff display."""
menu = QtGui.QMenu(self)
s = cola.selection()
if self.model.stageable():
if s.modified and s.modified[0] in cola.model().submodules:
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage'),
SLOT(signals.stage, s.modified))
action.setShortcut(defs.stage_shortcut)
menu.addAction(qtutils.git_icon(),
self.tr('Launch git-cola'),
SLOT(signals.open_repo,
os.path.abspath(s.modified[0])))
elif s.modified:
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Section'),
self.stage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_stage_selection)
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
self.tr('Revert Section...'),
self.revert_section)
menu.addAction(self.action_revert_selection)
if self.model.unstageable():
if s.staged and s.staged[0] in cola.model().submodules:
action = menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage'),
SLOT(signals.unstage, s.staged))
action.setShortcut(defs.stage_shortcut)
menu.addAction(qtutils.git_icon(),
self.tr('Launch git-cola'),
SLOT(signals.open_repo,
os.path.abspath(s.staged[0])))
elif s.staged:
action = menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage Section'),
self.unstage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_unstage_selection)
menu.addSeparator()
action = menu.addAction(qtutils.icon('edit-copy.svg'),
'Copy', self.copy)
action.setShortcut(QtGui.QKeySequence.Copy)
action = menu.addAction(qtutils.icon('edit-select-all.svg'),
'Select All', self.selectAll)
action.setShortcut(QtGui.QKeySequence.SelectAll)
menu.exec_(self.mapToGlobal(event.pos()))
def _create_staged_submodule_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(), N_("Launch git-cola"), cmds.run(cmds.OpenRepo, core.abspath(s.staged[0])))
menu.addAction(self.launch_editor)
menu.addSeparator()
action = menu.addAction(
qtutils.icon("remove.svg"), N_("Unstage Selected"), cmds.run(cmds.Unstage, self.staged())
)
action.setShortcut(cmds.Unstage.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def __init__(self, parent):
DiffTextEdit.__init__(self, parent)
self.model = model = cola.model()
self.mode = self.model.mode_none
# Install diff shortcut keys for stage/unstage
self.action_process_section = qtutils.add_action(
self, 'Process Section', self.apply_section, Qt.Key_H)
self.action_process_selection = qtutils.add_action(
self, 'Process Selection', self.apply_selection, Qt.Key_S)
# Context menu actions
self.action_stage_selection = qtutils.add_action(
self, self.tr('Stage &Selected Lines'), self.stage_selection)
self.action_stage_selection.setIcon(qtutils.icon('add.svg'))
self.action_stage_selection.setShortcut(Qt.Key_S)
self.action_revert_selection = qtutils.add_action(
self, self.tr('Revert Selected Lines...'), self.revert_selection)
self.action_revert_selection.setIcon(qtutils.icon('undo.svg'))
self.action_unstage_selection = qtutils.add_action(
self, self.tr('Unstage &Selected Lines'), self.unstage_selection)
self.action_unstage_selection.setIcon(qtutils.icon('remove.svg'))
self.action_unstage_selection.setShortcut(Qt.Key_S)
self.action_apply_selection = qtutils.add_action(
self, self.tr('Apply Diff Selection to Work Tree'),
self.stage_selection)
self.action_apply_selection.setIcon(qtutils.apply_icon())
model.add_observer(model.message_mode_about_to_change,
self._mode_about_to_change)
model.add_observer(model.message_diff_text_changed, self.setPlainText)
self.connect(self, SIGNAL('copyAvailable(bool)'),
self.enable_selection_actions)
def update_widgets(self, left=True):
"""Updates the list of available revisions for comparison
"""
# This callback can be triggered by either the 'start'
# listwidget or the 'end' list widget. The behavior
# is identical; the only difference is the attribute names.
if left:
tree_widget = self.view.descriptions_start
revisions_param = 'revisions_start'
revision_param = 'revision_start'
else:
tree_widget = self.view.descriptions_end
revisions_param = 'revisions_end'
revision_param = 'revision_end'
# Is anything selected?
id_num, selected = qtutils.selected_treeitem(tree_widget)
if not selected:
return
# Is this a valid revision?
revisionlist = self.model.param(revisions_param)
if id_num < len(revisionlist):
revision = self.model.param(revisions_param)[id_num]
self.model.set_param(revision_param, revision)
# get the changed files list
start = self.model.revision_start
end = self.model.revision_end
files = gitcmds.changed_files(start, end)
# get the old name of any renamed files, and prune them
# from the changes list
renamed_files = gitcmds.renamed_files(start, end)
for renamed in renamed_files:
try:
files.remove(renamed)
except:
pass
# Sets the "changed files" list
self.model.set_compare_files(files)
# Updates the listwidget's icons
icon = qtutils.icon('script.png')
for idx in xrange(0, self.view.compare_files.topLevelItemCount()):
item = self.view.compare_files.topLevelItem(idx)
item.setIcon(0, icon)
# Throw the selected SHA-1 into the clipboard
qtutils.set_clipboard(self.model.param(revision_param))
def _revert_uncommitted_edits(self, items_to_undo):
if items_to_undo:
if not qtutils.confirm(
N_('Revert Uncommitted Changes?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Uncommitted Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
cmds.do(cmds.Checkout, [self.m.head, '--'] + items_to_undo)
else:
msg = N_('No files selected for checkout from HEAD.')
Interaction.log(msg)
def _create_staged_submodule_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(), N_('Launch git-cola'),
cmds.run(cmds.OpenRepo, core.abspath(s.staged[0])))
menu.addAction(self.launch_editor)
menu.addSeparator()
action = menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage Selected'),
cmds.run(cmds.Unstage, self.staged()))
action.setShortcut(cmds.Unstage.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _revert_uncommitted_edits(self, items_to_undo):
if items_to_undo:
if not qtutils.confirm(
N_('Revert Uncommitted Changes?'),
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
N_('Revert Uncommitted Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
cmds.do(cmds.Checkout, [self.m.head, '--'] + items_to_undo)
else:
msg = N_('No files selected for checkout from HEAD.')
Interaction.log(msg)
def _revert_uncommitted_edits(self, items_to_undo):
if items_to_undo:
if not qtutils.confirm(
N_("Revert Uncommitted Changes?"),
N_("This operation drops uncommitted changes.\n" "These changes cannot be recovered."),
N_("Revert the uncommitted changes?"),
N_("Revert Uncommitted Changes"),
default=True,
icon=qtutils.icon("undo.svg"),
):
return
cmds.do(cmds.Checkout, [self.m.head, "--"] + items_to_undo)
else:
msg = N_("No files selected for checkout from HEAD.")
Interaction.log(msg)
def contextMenuEvent(self, event):
"""Create the context menu for the diff display."""
menu = QtGui.QMenu(self)
s = cola.selection()
if self.model.stageable():
if s.modified and s.modified[0] in cola.model().submodules:
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage'),
SLOT(signals.stage, s.modified))
action.setShortcut(defs.stage_shortcut)
menu.addAction(
qtutils.git_icon(), self.tr('Launch git-cola'),
SLOT(signals.open_repo, os.path.abspath(s.modified[0])))
elif s.modified:
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Section'),
self.stage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_stage_selection)
menu.addSeparator()
menu.addAction(qtutils.icon('undo.svg'),
self.tr('Revert Section...'),
self.revert_section)
menu.addAction(self.action_revert_selection)
if self.model.unstageable():
if s.staged and s.staged[0] in cola.model().submodules:
action = menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage'),
SLOT(signals.unstage, s.staged))
action.setShortcut(defs.stage_shortcut)
menu.addAction(
qtutils.git_icon(), self.tr('Launch git-cola'),
SLOT(signals.open_repo, os.path.abspath(s.staged[0])))
elif s.staged:
action = menu.addAction(qtutils.icon('remove.svg'),
self.tr('Unstage Section'),
self.unstage_section)
action.setShortcut(Qt.Key_H)
menu.addAction(self.action_unstage_selection)
menu.addSeparator()
action = menu.addAction(qtutils.icon('edit-copy.svg'), 'Copy',
self.copy)
action.setShortcut(QtGui.QKeySequence.Copy)
action = menu.addAction(qtutils.icon('edit-select-all.svg'),
'Select All', self.selectAll)
action.setShortcut(QtGui.QKeySequence.SelectAll)
menu.exec_(self.mapToGlobal(event.pos()))
def _revert_uncommitted_edits(self):
items_to_undo = self.modified()
if items_to_undo:
if not qtutils.confirm('Revert Uncommitted Changes?',
'This operation drops uncommitted changes.'
'\nThese changes cannot be recovered.',
'Revert the uncommitted changes?',
'Revert Uncommitted Changes',
default=True,
icon=qtutils.icon('undo.svg')):
return
cola.notifier().broadcast(signals.checkout,
[self.m.head, '--'] + items_to_undo)
else:
qtutils.log(1, self.tr('No files selected for '
'checkout from HEAD.'))
def _create_modified_submodule_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(), N_('Launch git-cola'),
cmds.run(cmds.OpenRepo, core.abspath(s.modified[0])))
menu.addAction(self.launch_editor_action)
if self.m.stageable():
menu.addSeparator()
action = menu.addAction(qtutils.icon('add.svg'),
N_('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
menu.addAction(self.copy_relpath_action)
return menu
def revert_selection(self):
"""Destructively revert selected lines or hunk from a worktree file."""
if self.has_selection():
title = N_('Revert Selected Lines?')
ok_text = N_('Revert Selected Lines')
else:
title = N_('Revert Diff Hunk?')
ok_text = N_('Revert Diff Hunk')
if not qtutils.confirm(title,
N_('This operation drops uncommitted changes.\n'
'These changes cannot be recovered.'),
N_('Revert the uncommitted changes?'),
ok_text,
default=True,
icon=qtutils.icon('undo.svg')):
return
self.process_diff_selection(reverse=True, apply_to_worktree=True)
def _create_modified_submodule_context_menu(self, menu, s):
menu.addAction(qtutils.git_icon(), self.tr('Launch git-cola'),
cmds.run(cmds.OpenRepo, os.path.abspath(s.modified[0])))
action = menu.addAction(qtutils.options_icon(),
self.tr(cmds.LaunchEditor.NAME),
cmds.run(cmds.LaunchEditor))
action.setShortcut(cmds.Edit.SHORTCUT)
if self.m.stageable():
menu.addSeparator()
action = menu.addAction(qtutils.icon('add.svg'),
self.tr('Stage Selected'),
cmds.run(cmds.Stage, self.unstaged()))
action.setShortcut(cmds.Stage.SHORTCUT)
menu.addSeparator()
menu.addAction(self.copy_path_action)
return menu
def _create_staged_context_menu(self, menu, s):
if s.staged[0] in self.m.submodules:
return self._create_staged_submodule_context_menu(menu, s)
if self.m.unstageable():
action = menu.addAction(qtutils.icon('remove.svg'),
N_('Unstage Selected'),
cmds.run(cmds.Unstage, self.staged()))
action.setShortcut(cmds.Unstage.SHORTCUT)
# Do all of the selected items exist?
all_exist = all(not i in self.m.staged_deleted and core.exists(i)
for i in self.staged())
if all_exist:
menu.addAction(self.launch_editor_action)
menu.addAction(self.launch_difftool_action)
if all_exist and not utils.is_win32():
menu.addSeparator()
action = menu.addAction(qtutils.file_icon(),
cmds.OpenDefaultApp.name(),
cmds.run(cmds.OpenDefaultApp, self.staged()))
action.setShortcut(cmds.OpenDefaultApp.SHORTCUT)
action = menu.addAction(qtutils.open_file_icon(),
cmds.OpenParentDir.name(),
self._open_parent_dir)
action.setShortcut(cmds.OpenParentDir.SHORTCUT)
if self.m.undoable():
menu.addSeparator()
menu.addAction(self.revert_unstaged_edits_action)
menu.addSeparator()
menu.addAction(self.copy_path_action)
menu.addAction(self.copy_relpath_action)
return menu
def _revert_unstaged_edits(self, staged=False):
if not self.m.undoable():
return
if staged:
items_to_undo = self.staged()
else:
items_to_undo = self.modified()
if items_to_undo:
if not qtutils.confirm(N_('Revert Unstaged Changes?'),
N_('This operation drops unstaged changes.\n'
'These changes cannot be recovered.'),
N_('Revert the unstaged changes?'),
N_('Revert Unstaged Changes'),
default=True,
icon=qtutils.icon('undo.svg')):
return
args = []
if not staged and self.m.amending():
args.append(self.m.head)
cmds.do(cmds.Checkout, args + ['--'] + items_to_undo)
else:
msg = N_('No files selected for checkout from HEAD.')
Interaction.log(msg)
def __init__(self, parent):
QtGui.QTreeWidget.__init__(self, parent)
self.setSelectionMode(QtGui.QAbstractItemView.ExtendedSelection)
self.headerItem().setHidden(True)
self.setAllColumnsShowFocus(True)
self.setSortingEnabled(False)
self.setUniformRowHeights(True)
self.setAnimated(True)
self.setRootIsDecorated(False)
self.setIndentation(0)
self.add_item(N_('Staged'), hide=True)
self.add_item(N_('Unmerged'), hide=True)
self.add_item(N_('Modified'), hide=True)
self.add_item(N_('Untracked'), hide=True)
# Used to restore the selection
self.old_scroll = None
self.old_selection = None
self.old_contents = None
self.old_current_item = None
self.expanded_items = set()
self.process_selection = qtutils.add_action(self,
N_('Stage / Unstage'),
self._process_selection,
cmds.Stage.SHORTCUT)
self.revert_unstaged_edits_action = qtutils.add_action(
self, N_('Revert Unstaged Edits...'),
cmds.run(cmds.RevertUnstagedEdits),
cmds.RevertUnstagedEdits.SHORTCUT)
self.revert_unstaged_edits_action.setIcon(qtutils.icon('undo.svg'))
self.launch_difftool = qtutils.add_action(
self, cmds.LaunchDifftool.name(), cmds.run(cmds.LaunchDifftool),
cmds.LaunchDifftool.SHORTCUT)
self.launch_difftool.setIcon(qtutils.icon('git.svg'))
self.launch_editor = qtutils.add_action(self, cmds.LaunchEditor.name(),
cmds.run(cmds.LaunchEditor),
cmds.LaunchEditor.SHORTCUT,
'Return', 'Enter')
self.launch_editor.setIcon(qtutils.options_icon())
if not utils.is_win32():
self.open_using_default_app = qtutils.add_action(
self, cmds.OpenDefaultApp.name(), self._open_using_default_app,
cmds.OpenDefaultApp.SHORTCUT)
self.open_using_default_app.setIcon(qtutils.file_icon())
self.open_parent_dir = qtutils.add_action(
self, cmds.OpenParentDir.name(), self._open_parent_dir,
cmds.OpenParentDir.SHORTCUT)
self.open_parent_dir.setIcon(qtutils.open_file_icon())
self.up = qtutils.add_action(self, N_('Move Up'), self.move_up,
Qt.Key_K)
self.down = qtutils.add_action(self, N_('Move Down'), self.move_down,
Qt.Key_J)
self.copy_path_action = qtutils.add_action(
self, N_('Copy Path to Clipboard'), self.copy_path,
QtGui.QKeySequence.Copy)
self.copy_path_action.setIcon(qtutils.theme_icon('edit-copy.svg'))
self.connect(self, SIGNAL('about_to_update'), self._about_to_update)
self.connect(self, SIGNAL('updated'), self._updated)
self.m = main.model()
self.m.add_observer(self.m.message_about_to_update,
self.about_to_update)
self.m.add_observer(self.m.message_updated, self.updated)
self.connect(self, SIGNAL('itemSelectionChanged()'),
self.show_selection)
self.connect(self, SIGNAL('itemDoubleClicked(QTreeWidgetItem*,int)'),
self.double_clicked)
self.connect(self, SIGNAL('itemCollapsed(QTreeWidgetItem*)'),
lambda x: self.update_column_widths())
self.connect(self, SIGNAL('itemExpanded(QTreeWidgetItem*)'),
lambda x: self.update_column_widths())
def set_diff_files(self, files):
mk = FileItem
icon = qtutils.icon('script.png')
self.diff_files.clear()
self.diff_files.addTopLevelItems([mk(f, icon) for f in files])
