"""Provides quick switcher""" from qtpy import QtCore from qtpy import QtGui from qtpy import QtWidgets from qtpy.QtCore import Qt from qtpy.QtCore import Signal from .. import qtutils from ..widgets import defs from ..widgets import standard from ..widgets import text def switcher_inner_view( context, entries, title=None, place_holder=None, enter_action=None, parent=None ): dialog = SwitcherInnerView( context, entries, title, place_holder, enter_action, parent ) dialog.show() return dialog def switcher_outer_view(context, entries, place_holder=None, parent=None): dialog = SwitcherOuterView(context, entries, place_holder, parent) dialog.show() return dialog def switcher_item(key, icon=None, name=None): return SwitcherListItem(key, icon, name) def moving_keys(): selection_move_keys = [ Qt.Key_Enter, Qt.Key_Return, Qt.Key_Up, Qt.Key_Down, Qt.Key_Home, Qt.Key_End, Qt.Key_PageUp, Qt.Key_PageDown, ] return selection_move_keys class Switcher(standard.Dialog): """ Quick switcher base class. This contains input field, filter proxy model. This will be inherited by outer-view class(SwitcherOuterView) or inner-view class (SwitcherInnerView). The inner-view class is a quick-switcher widget including view. In this case, this switcher will have switcher_list field, and show the items list in itself. The outer-view class is a quick-switcher widget without view(only input field), which shares model with other view class. The switcher_selection_move signal is the event that the selection move actions emit while the input field is focused. """ def __init__( self, context, entries_model, place_holder=None, parent=None, ): standard.Dialog.__init__(self, parent=parent) self.context = context self.entries_model = entries_model self.filter_input = SwitcherLineEdit(place_holder=place_holder, parent=self) self.proxy_model = SwitcherSortFilterProxyModel(entries_model, parent=self) self.switcher_list = None self.filter_input.textChanged.connect(self.filter_input_changed) def filter_input_changed(self): """Update the proxy model filter when the input text changes""" input_text = self.filter_input.text() # Use a case-sensitive search when the input text is ALL_CAPS or mixedCaps. if input_text.upper() == input_text or input_text.lower() != input_text: self.proxy_model.setFilterCaseSensitivity(Qt.CaseSensitive) else: self.proxy_model.setFilterCaseSensitivity(Qt.CaseInsensitive) self.proxy_model.setFilterWildcard(input_text) class SwitcherInnerView(Switcher): def __init__( self, context, entries_model, title, place_holder=None, enter_action=None, parent=None, ): Switcher.__init__( self, context, entries_model, place_holder=place_holder, parent=parent, ) self.setWindowTitle(title) self.path = None if parent is not None: self.setWindowModality(Qt.WindowModal) self.enter_action = enter_action self.switcher_list = SwitcherTreeView( self.proxy_model, self.enter_selected_item, parent=self ) self.main_layout = qtutils.vbox( defs.no_margin, defs.spacing, self.filter_input, self.switcher_list ) self.setLayout(self.main_layout) # moving key has pressed while focusing on input field self.filter_input.switcher_selection_move.connect( self.switcher_list.keyPressEvent ) # escape key pressed while focusing on input field self.filter_input.switcher_escape.connect(self.close) self.filter_input.switcher_accept.connect(self.accept_selected_item) # some key except moving key has pressed while focusing on list view self.switcher_list.switcher_inner_text.connect(self.filter_input.keyPressEvent) # default selection for first index first_proxy_idx = self.proxy_model.index(0, 0) self.switcher_list.setCurrentIndex(first_proxy_idx) self.set_initial_geometry(parent) def accept_selected_item(self): item = self.switcher_list.selected_item() if item: self.path = item.key self.enter_action(item) self.accept() def set_initial_geometry(self, parent): """Set the initial size and position""" if parent is None: return # Size width = parent.width() height = parent.height() self.resize(max(width * 2 // 3, 320), max(height * 2 // 3, 240)) def enter_selected_item(self, index): item = self.switcher_list.model().itemFromIndex(index) if item: self.path = item.key self.enter_action(item) self.accept() def worktree(self): """Return the selected worktree""" result = self.exec_() if result == QtWidgets.QDialog.Accepted: return self.path return None class SwitcherOuterView(Switcher): def __init__(self, context, entries_model, place_holder=None, parent=None): Switcher.__init__( self, context, entries_model, place_holder=place_holder, parent=parent, ) self.filter_input.hide() self.main_layout = qtutils.vbox(defs.no_margin, defs.spacing, self.filter_input) self.setLayout(self.main_layout) self.filter_input.editingFinished.connect(self.filter_input_edited) def filter_input_edited(self): """Hide the filter input when editing is complete and the text is empty""" input_text = self.filter_input.text() if not input_text: self.filter_input.hide() class SwitcherLineEdit(text.LineEdit): """Quick switcher input line class""" # signal is for the event that selection move key like UP, DOWN has pressed # while focusing on this line edit widget switcher_selection_move = Signal(QtGui.QKeyEvent) switcher_visible = Signal(bool) switcher_accept = Signal() switcher_escape = Signal() def __init__(self, place_holder=None, parent=None): text.LineEdit.__init__(self, parent=parent) if place_holder: self.setPlaceholderText(place_holder) def keyPressEvent(self, event): """ To be able to move the selection while focus on the input field, input text field should be able to filter pressed key. If pressed key is moving selection key like UP or DOWN, the switcher_selection_move signal will be emitted and the view selection will be moved regardless whether Switcher is inner-view or outer-view. Or else, simply act like text input to the field. """ selection_moving_keys = moving_keys() pressed_key = event.key() if pressed_key == Qt.Key_Escape: self.switcher_escape.emit() elif pressed_key in (Qt.Key_Enter, Qt.Key_Return): self.switcher_accept.emit() elif pressed_key in selection_moving_keys: self.switcher_selection_move.emit(event) else: super().keyPressEvent(event) class SwitcherSortFilterProxyModel(QtCore.QSortFilterProxyModel): """Filtering class for candidate items.""" def __init__(self, entries, parent=None): QtCore.QSortFilterProxyModel.__init__(self, parent) self.entries = entries self.setDynamicSortFilter(True) self.setSourceModel(entries) self.setFilterCaseSensitivity(Qt.CaseInsensitive) def itemFromIndex(self, index): return self.entries.itemFromIndex(self.mapToSource(index)) class SwitcherTreeView(standard.TreeView): """Tree view class for showing proxy items in SwitcherSortFilterProxyModel""" # signal is for the event that some key except moving key has pressed # while focusing this view switcher_inner_text = Signal(QtGui.QKeyEvent) def __init__(self, entries_proxy_model, enter_action, parent=None): standard.TreeView.__init__(self, parent) self.setHeaderHidden(True) self.setModel(entries_proxy_model) self.doubleClicked.connect(enter_action) def keyPressEvent(self, event): """hooks when a key has pressed while focusing on list view""" selection_moving_keys = moving_keys() pressed_key = event.key() if pressed_key in selection_moving_keys or pressed_key == Qt.Key_Escape: super().keyPressEvent(event) else: self.switcher_inner_text.emit(event) class SwitcherListItem(QtGui.QStandardItem): """Item class for SwitcherTreeView and SwitcherSortFilterProxyModel""" def __init__(self, key, icon=None, name=None): QtGui.QStandardItem.__init__(self) self.key = key if not name: name = key self.setText(name) if icon: self.setIcon(icon)