class FindInFilesWidget(PluginMainWidget):
"""
Find in files widget.
"""
DEFAULT_OPTIONS = {
'case_sensitive': False,
'exclude_case_sensitive': False,
'exclude': EXCLUDE_PATTERNS[0],
'exclude_index': None,
'exclude_regexp': False,
'path_history': [],
'max_results': 1000,
'hist_limit': MAX_PATH_HISTORY,
'more_options': False,
'search_in_index': None,
'search_text': '',
'search_text_regexp': False,
'supported_encodings': ("utf-8", "iso-8859-1", "cp1252"),
'text_color': MAIN_TEXT_COLOR,
}
ENABLE_SPINNER = True
REGEX_INVALID = "background-color:rgb(255, 80, 80);"
REGEX_ERROR = _("Regular expression error")
# Signals
sig_edit_goto_requested = Signal(str, int, str, int, int)
"""
This signal will request to open a file in a given row and column
using a code editor.
Parameters
----------
path: str
Path to file.
row: int
Cursor starting row position.
word: str
Word to select on given row.
start_column: int
Starting column of found word.
end_column:
Ending column of found word.
"""
sig_finished = Signal()
"""
This signal is emitted to inform the search process has finished.
"""
sig_max_results_reached = Signal()
"""
This signal is emitted to inform the search process has finished due
to reaching the maximum number of results.
"""
def __init__(self,
name=None,
plugin=None,
parent=None,
options=DEFAULT_OPTIONS):
super().__init__(name, plugin, parent=parent, options=options)
# Attributes
self.text_color = self.get_option('text_color')
self.supported_encodings = self.get_option('supported_encodings')
self.search_thread = None
self.running = False
self.more_options_action = None
self.extras_toolbar = None
search_text = self.get_option('search_text')
path_history = self.get_option('path_history')
exclude = self.get_option('exclude')
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
if not isinstance(path_history, (list, tuple)):
path_history = [path_history]
# Widgets
self.search_text_edit = PatternComboBox(
self,
search_text,
_("Search pattern"),
)
self.search_in_label = QLabel(_('Search in:'))
self.exclude_label = QLabel(_('Exclude:'))
self.path_selection_combo = SearchInComboBox(path_history, self)
self.exclude_pattern_edit = PatternComboBox(
self,
exclude,
_("Exclude pattern"),
)
self.result_browser = ResultsBrowser(
self,
text_color=self.text_color,
max_results=self.get_option('max_results'),
)
# Setup
self.exclude_label.setBuddy(self.exclude_pattern_edit)
exclude_idx = self.get_option('exclude_index')
if (exclude_idx is not None and exclude_idx >= 0
and exclude_idx < self.exclude_pattern_edit.count()):
self.exclude_pattern_edit.setCurrentIndex(exclude_idx)
search_in_index = self.get_option('search_in_index')
self.path_selection_combo.set_current_searchpath_index(search_in_index)
# Layout
layout = QHBoxLayout()
layout.addWidget(self.result_browser)
self.setLayout(layout)
# Signals
self.path_selection_combo.sig_redirect_stdio_requested.connect(
self.sig_redirect_stdio_requested)
self.search_text_edit.valid.connect(lambda valid: self.find())
self.exclude_pattern_edit.valid.connect(lambda valid: self.find())
self.result_browser.sig_edit_goto_requested.connect(
self.sig_edit_goto_requested)
self.result_browser.sig_max_results_reached.connect(
self.sig_max_results_reached)
self.result_browser.sig_max_results_reached.connect(
self._stop_and_reset_thread)
self.search_text_edit.sig_resized.connect(self._update_size)
# --- PluginMainWidget API
# ------------------------------------------------------------------------
def get_title(self):
return _("Find")
def get_focus_widget(self):
return self.search_text_edit
def setup(self, options=DEFAULT_OPTIONS):
self.search_regexp_action = self.create_action(
FindInFilesWidgetActions.ToggleSearchRegex,
text=_('Regular expression'),
tip=_('Regular expression'),
icon=self.create_icon('regex'),
toggled=lambda val: self.set_option('search_text_regexp', val),
initial=self.get_option('search_text_regexp'),
)
self.case_action = self.create_action(
FindInFilesWidgetActions.ToggleExcludeCase,
text=_("Case sensitive"),
tip=_("Case sensitive"),
icon=self.create_icon("format_letter_case"),
toggled=lambda val: self.set_option('case_sensitive', val),
initial=self.get_option('case_sensitive'),
)
self.find_action = self.create_action(
FindInFilesWidgetActions.Find,
icon_text=_('Search'),
text=_("&Find in files"),
tip=_("Search text in multiple files"),
icon=self.create_icon('find'),
triggered=self.find,
register_shortcut=False,
)
self.exclude_regexp_action = self.create_action(
FindInFilesWidgetActions.ToggleExcludeRegex,
text=_('Regular expression'),
tip=_('Regular expression'),
icon=self.create_icon('regex'),
toggled=lambda val: self.set_option('exclude_regexp', val),
initial=self.get_option('exclude_regexp'),
)
self.exclude_case_action = self.create_action(
FindInFilesWidgetActions.ToggleCase,
text=_("Exclude case sensitive"),
tip=_("Exclude case sensitive"),
icon=self.create_icon("format_letter_case"),
toggled=lambda val: self.set_option('exclude_case_sensitive', val),
initial=self.get_option('exclude_case_sensitive'),
)
self.more_options_action = self.create_action(
FindInFilesWidgetActions.ToggleMoreOptions,
text=_('Show advanced options'),
tip=_('Show advanced options'),
icon=self.create_icon("options_more"),
toggled=lambda val: self.set_option('more_options', val),
initial=self.get_option('more_options'),
)
self.set_max_results_action = self.create_action(
FindInFilesWidgetActions.MaxResults,
text=_('Set maximum number of results'),
tip=_('Set maximum number of results'),
triggered=lambda x=None: self.set_max_results(),
)
# Toolbar
toolbar = self.get_main_toolbar()
for item in [
self.search_text_edit, self.search_regexp_action,
self.case_action, self.more_options_action, self.find_action
]:
self.add_item_to_toolbar(
item,
toolbar=toolbar,
section=FindInFilesWidgetMainToolbarSections.Main,
)
# Exclude Toolbar
self.extras_toolbar = self.create_toolbar(
FindInFilesWidgetToolbars.Exclude)
for item in [
self.exclude_label, self.exclude_pattern_edit,
self.exclude_regexp_action,
self.create_stretcher()
]:
self.add_item_to_toolbar(
item,
toolbar=self.extras_toolbar,
section=FindInFilesWidgetExcludeToolbarSections.Main,
)
# Location toolbar
location_toolbar = self.create_toolbar(
FindInFilesWidgetToolbars.Location)
for item in [self.search_in_label, self.path_selection_combo]:
self.add_item_to_toolbar(
item,
toolbar=location_toolbar,
section=FindInFilesWidgetLocationToolbarSections.Main,
)
menu = self.get_options_menu()
self.add_item_to_menu(
self.set_max_results_action,
menu=menu,
)
def update_actions(self):
stop_text = _('Stop')
search_text = _('Search')
if self.running:
icon_text = stop_text
icon = self.create_icon('stop')
else:
icon_text = search_text
icon = self.create_icon('find')
self.find_action.setIconText(icon_text)
self.find_action.setIcon(icon)
widget = self.get_main_toolbar().widgetForAction(self.find_action)
if widget:
w1 = widget.fontMetrics().width(stop_text)
w2 = widget.fontMetrics().width(search_text)
# Ensure the search/stop button has the same size independent on
# the length of the words.
width = (self.get_options_menu_button().width() + max([w1, w2]) +
EXTRA_BUTTON_PADDING)
widget.setMinimumWidth(width)
if self.extras_toolbar and self.more_options_action:
self.extras_toolbar.setVisible(
self.more_options_action.isChecked())
def on_option_update(self, option, value):
if option == 'more_options':
self.exclude_pattern_edit.setMinimumWidth(
self.search_text_edit.width())
if value:
icon = self.create_icon('options_less')
tip = _('Hide advanced options')
else:
icon = self.create_icon('options_more')
tip = _('Show advanced options')
if self.extras_toolbar:
self.extras_toolbar.setVisible(value)
if self.more_options_action:
self.more_options_action.setIcon(icon)
self.more_options_action.setToolTip(tip)
elif option == 'max_results':
self.result_browser.set_max_results(value)
# --- Private API
# ------------------------------------------------------------------------
def _update_size(self, size, old_size):
self.exclude_pattern_edit.setMinimumWidth(size.width())
def _get_options(self):
"""
Get search options.
"""
text_re = self.search_regexp_action.isChecked()
exclude_re = self.exclude_regexp_action.isChecked()
case_sensitive = self.case_action.isChecked()
# Clear fields
self.search_text_edit.lineEdit().setStyleSheet("")
self.exclude_pattern_edit.lineEdit().setStyleSheet("")
self.exclude_pattern_edit.setToolTip("")
self.search_text_edit.setToolTip("")
utext = str(self.search_text_edit.currentText())
if not utext:
return
try:
texts = [(utext.encode('utf-8'), 'utf-8')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
exclude = str(self.exclude_pattern_edit.currentText())
if not case_sensitive:
texts = [(text[0].lower(), text[1]) for text in texts]
file_search = self.path_selection_combo.is_file_search()
path = self.path_selection_combo.get_current_searchpath()
if not exclude_re:
items = [
fnmatch.translate(item.strip()) for item in exclude.split(",")
if item.strip() != ''
]
exclude = '|'.join(items)
# Validate exclude regular expression
if exclude:
error_msg = regexp_error_msg(exclude)
if error_msg:
exclude_edit = self.exclude_pattern_edit.lineEdit()
exclude_edit.setStyleSheet(self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + ': ' + str(error_msg)
self.exclude_pattern_edit.setToolTip(tooltip)
return None
else:
exclude = re.compile(exclude)
# Validate text regular expression
if text_re:
error_msg = regexp_error_msg(texts[0][0])
if error_msg:
self.search_text_edit.lineEdit().setStyleSheet(
self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + ': ' + str(error_msg)
self.search_text_edit.setToolTip(tooltip)
return None
else:
texts = [(re.compile(x[0]), x[1]) for x in texts]
return (path, file_search, exclude, texts, text_re, case_sensitive)
def _update_options(self):
"""
Extract search options from widgets and set the corresponding option.
"""
hist_limit = self.get_option('hist_limit')
search_texts = [
str(self.search_text_edit.itemText(index))
for index in range(self.search_text_edit.count())
]
excludes = [
str(self.search_text_edit.itemText(index))
for index in range(self.exclude_pattern_edit.count())
]
path_history = self.path_selection_combo.get_external_paths()
self.set_option('path_history', path_history)
self.set_option('search_text', search_texts[:hist_limit])
self.set_option('exclude', excludes[:hist_limit])
self.set_option('path_history', path_history[-hist_limit:])
self.set_option('exclude_index',
self.exclude_pattern_edit.currentIndex())
self.set_option('search_in_index',
self.path_selection_combo.currentIndex())
def _handle_search_complete(self, completed):
"""
Current search thread has finished.
"""
self.result_browser.set_sorting(ON)
self.result_browser.expandAll()
if self.search_thread is None:
return
self.sig_finished.emit()
found = self.search_thread.get_results()
self._stop_and_reset_thread()
if found is not None:
self.result_browser.show()
self.stop_spinner()
self.update_actions()
def _stop_and_reset_thread(self, ignore_results=False):
"""Stop current search thread and clean-up."""
if self.search_thread is not None:
if self.search_thread.isRunning():
if ignore_results:
self.search_thread.sig_finished.disconnect(
self.search_complete)
self.search_thread.stop()
self.search_thread.wait()
self.search_thread.setParent(None)
self.search_thread = None
self.running = False
self.stop_spinner()
self.update_actions()
# --- Public API
# ------------------------------------------------------------------------
@property
def path(self):
"""Return the current path."""
return self.path_selection_combo.path
@property
def project_path(self):
"""Return the current project path."""
return self.path_selection_combo.project_path
@property
def file_path(self):
"""Return the current file path."""
return self.path_selection_combo.file_path
def set_directory(self, directory):
"""
Set directory as current path.
Parameters
----------
directory: str
Directory path string.
"""
self.path_selection_combo.path = osp.abspath(directory)
def set_project_path(self, path):
"""
Set path as current project path.
Parameters
----------
path: str
Project path string.
"""
self.path_selection_combo.set_project_path(path)
def disable_project_search(self):
"""Disable project search path in combobox."""
self.path_selection_combo.set_project_path(None)
def set_file_path(self, path):
"""
Set path as current file path.
Parameters
----------
path: str
File path string.
"""
self.path_selection_combo.file_path = path
def set_search_text(self, text):
"""
Set current search text.
Parameters
----------
text: str
Search string.
Notes
-----
If `text` is empty, focus will be given to the search lineedit and no
search will be performed.
"""
if text:
self.search_text_edit.add_text(text)
self.search_text_edit.lineEdit().selectAll()
self.search_text_edit.setFocus()
def find(self):
"""
Start/stop find action.
Notes
-----
If there is no search running, this will start the search. If there is
a search running, this will stop it.
"""
if self.running:
self.stop()
else:
self.start()
def stop(self):
"""Stop find thread."""
self._stop_and_reset_thread()
def start(self):
"""Start find thread."""
options = self._get_options()
if options is None:
return
self._stop_and_reset_thread(ignore_results=True)
search_text = self.search_text_edit.currentText()
# Update and set options
self._update_options()
# Start
self.running = True
self.start_spinner()
self.search_thread = SearchThread(self, search_text, self.text_color)
self.search_thread.sig_finished.connect(self._handle_search_complete)
self.search_thread.sig_file_match.connect(
self.result_browser.append_file_result)
self.search_thread.sig_line_match.connect(
self.result_browser.append_result)
self.result_browser.clear_title(search_text)
self.search_thread.initialize(*self._get_options())
self.search_thread.start()
self.update_actions()
def add_external_path(self, path):
"""
Parameters
----------
path: str
Path to add to combobox.
"""
self.path_selection_combo.add_external_path(path)
def set_max_results(self, value=None):
"""
Set maximum amount of results to add to the result browser.
Parameters
----------
value: int, optional
Number of results. If None an input dialog will be used.
Default is None.
"""
if value is None:
# Create dialog
dialog = QInputDialog(self)
# Set dialog properties
dialog.setModal(False)
dialog.setWindowTitle(self.get_name())
dialog.setLabelText(_('Set maximum number of results: '))
dialog.setInputMode(QInputDialog.IntInput)
dialog.setIntRange(1, 10000)
dialog.setIntStep(1)
dialog.setIntValue(self.get_option('max_results'))
# Connect slot
dialog.intValueSelected.connect(
lambda value: self.set_option('max_results', value))
dialog.show()
else:
self.set_option('max_results', value)
class FindOptions(QWidget):
"""Find widget with options"""
REGEX_INVALID = "background-color:rgb(255, 80, 80);"
REGEX_ERROR = _("Regular expression error")
find = Signal()
stop = Signal()
redirect_stdio = Signal(bool)
def __init__(self, parent, search_text, search_text_regexp,
exclude, exclude_idx, exclude_regexp,
supported_encodings, more_options,
case_sensitive, external_path_history, options_button=None):
QWidget.__init__(self, parent)
if not isinstance(search_text, (list, tuple)):
search_text = [search_text]
if not isinstance(exclude, (list, tuple)):
exclude = [exclude]
if not isinstance(external_path_history, (list, tuple)):
external_path_history = [external_path_history]
self.supported_encodings = supported_encodings
# Layout 1
hlayout1 = QHBoxLayout()
self.search_text = PatternComboBox(self, search_text,
_("Search pattern"))
self.edit_regexp = create_toolbutton(self,
icon=ima.icon('regex'),
tip=_('Regular expression'))
self.case_button = create_toolbutton(self,
icon=ima.icon(
"format_letter_case"),
tip=_("Case Sensitive"))
self.case_button.setCheckable(True)
self.case_button.setChecked(case_sensitive)
self.edit_regexp.setCheckable(True)
self.edit_regexp.setChecked(search_text_regexp)
self.more_widgets = ()
self.more_options = create_toolbutton(self,
toggled=self.toggle_more_options)
self.more_options.setCheckable(True)
self.more_options.setChecked(more_options)
self.ok_button = create_toolbutton(self, text=_("Search"),
icon=ima.icon('find'),
triggered=lambda: self.find.emit(),
tip=_("Start search"),
text_beside_icon=True)
self.ok_button.clicked.connect(self.update_combos)
self.stop_button = create_toolbutton(self, text=_("Stop"),
icon=ima.icon('stop'),
triggered=lambda:
self.stop.emit(),
tip=_("Stop search"),
text_beside_icon=True)
self.stop_button.setEnabled(False)
for widget in [self.search_text, self.edit_regexp, self.case_button,
self.ok_button, self.stop_button, self.more_options]:
hlayout1.addWidget(widget)
if options_button:
hlayout1.addWidget(options_button)
# Layout 2
hlayout2 = QHBoxLayout()
self.exclude_pattern = PatternComboBox(self, exclude,
_("Exclude pattern"))
if exclude_idx is not None and exclude_idx >= 0 \
and exclude_idx < self.exclude_pattern.count():
self.exclude_pattern.setCurrentIndex(exclude_idx)
self.exclude_regexp = create_toolbutton(self,
icon=ima.icon('regex'),
tip=_('Regular expression'))
self.exclude_regexp.setCheckable(True)
self.exclude_regexp.setChecked(exclude_regexp)
exclude_label = QLabel(_("Exclude:"))
exclude_label.setBuddy(self.exclude_pattern)
for widget in [exclude_label, self.exclude_pattern,
self.exclude_regexp]:
hlayout2.addWidget(widget)
# Layout 3
hlayout3 = QHBoxLayout()
search_on_label = QLabel(_("Search in:"))
self.path_selection_combo = SearchInComboBox(
external_path_history, parent)
hlayout3.addWidget(search_on_label)
hlayout3.addWidget(self.path_selection_combo)
self.search_text.valid.connect(lambda valid: self.find.emit())
self.exclude_pattern.valid.connect(lambda valid: self.find.emit())
vlayout = QVBoxLayout()
vlayout.setContentsMargins(0, 0, 0, 0)
vlayout.addLayout(hlayout1)
vlayout.addLayout(hlayout2)
vlayout.addLayout(hlayout3)
self.more_widgets = (hlayout2,)
self.toggle_more_options(more_options)
self.setLayout(vlayout)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Minimum)
@Slot(bool)
def toggle_more_options(self, state):
for layout in self.more_widgets:
for index in range(layout.count()):
if state and self.isVisible() or not state:
layout.itemAt(index).widget().setVisible(state)
if state:
icon = ima.icon('options_less')
tip = _('Hide advanced options')
else:
icon = ima.icon('options_more')
tip = _('Show advanced options')
self.more_options.setIcon(icon)
self.more_options.setToolTip(tip)
def update_combos(self):
self.search_text.lineEdit().returnPressed.emit()
self.exclude_pattern.lineEdit().returnPressed.emit()
def set_search_text(self, text):
if text:
self.search_text.add_text(text)
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
def get_options(self, to_save=False):
"""Get options"""
text_re = self.edit_regexp.isChecked()
exclude_re = self.exclude_regexp.isChecked()
case_sensitive = self.case_button.isChecked()
# Return current options for them to be saved when closing
# Spyder.
if to_save:
search_text = [to_text_string(self.search_text.itemText(index))
for index in range(self.search_text.count())]
exclude = [to_text_string(self.exclude_pattern.itemText(index))
for index in range(self.exclude_pattern.count())]
exclude_idx = self.exclude_pattern.currentIndex()
path_history = self.path_selection_combo.get_external_paths()
more_options = self.more_options.isChecked()
return (search_text, text_re,
exclude, exclude_idx,
exclude_re, more_options,
case_sensitive, path_history)
# Clear fields
self.search_text.lineEdit().setStyleSheet("")
self.exclude_pattern.lineEdit().setStyleSheet("")
self.search_text.setToolTip("")
self.exclude_pattern.setToolTip("")
utext = to_text_string(self.search_text.currentText())
if not utext:
return
try:
texts = [(utext.encode('utf-8'), 'utf-8')]
except UnicodeEncodeError:
texts = []
for enc in self.supported_encodings:
try:
texts.append((utext.encode(enc), enc))
except UnicodeDecodeError:
pass
exclude = to_text_string(self.exclude_pattern.currentText())
if not case_sensitive:
texts = [(text[0].lower(), text[1]) for text in texts]
file_search = self.path_selection_combo.is_file_search()
path = self.path_selection_combo.get_current_searchpath()
if not exclude_re:
items = [fnmatch.translate(item.strip())
for item in exclude.split(",")
if item.strip() != '']
exclude = '|'.join(items)
# Validate exclude regular expression
if exclude:
error_msg = regexp_error_msg(exclude)
if error_msg:
exclude_edit = self.exclude_pattern.lineEdit()
exclude_edit.setStyleSheet(self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + u': ' + to_text_string(error_msg)
self.exclude_pattern.setToolTip(tooltip)
return None
else:
exclude = re.compile(exclude)
# Validate text regular expression
if text_re:
error_msg = regexp_error_msg(texts[0][0])
if error_msg:
self.search_text.lineEdit().setStyleSheet(self.REGEX_INVALID)
tooltip = self.REGEX_ERROR + u': ' + to_text_string(error_msg)
self.search_text.setToolTip(tooltip)
return None
else:
texts = [(re.compile(x[0]), x[1]) for x in texts]
return (path, file_search, exclude, texts, text_re, case_sensitive)
@property
def path(self):
return self.path_selection_combo.path
def set_directory(self, directory):
self.path_selection_combo.path = osp.abspath(directory)
@property
def project_path(self):
return self.path_selection_combo.project_path
def set_project_path(self, path):
self.path_selection_combo.set_project_path(path)
def disable_project_search(self):
self.path_selection_combo.set_project_path(None)
@property
def file_path(self):
return self.path_selection_combo.file_path
def set_file_path(self, path):
self.path_selection_combo.file_path = path
def keyPressEvent(self, event):
"""Reimplemented to handle key events"""
ctrl = event.modifiers() & Qt.ControlModifier
shift = event.modifiers() & Qt.ShiftModifier
if event.key() in (Qt.Key_Enter, Qt.Key_Return):
self.find.emit()
elif event.key() == Qt.Key_F and ctrl and shift:
# Toggle find widgets
self.parent().toggle_visibility.emit(not self.isVisible())
else:
QWidget.keyPressEvent(self, event)
class FindReplace(QWidget):
"""Find widget"""
STYLE = {
False: "background-color:rgb(255, 175, 90);",
True: "",
None: "",
'regexp_error': "background-color:rgb(255, 80, 80);",
}
TOOLTIP = {
False: _("No matches"),
True: _("Search string"),
None: _("Search string"),
'regexp_error': _("Regular expression error")
}
visibility_changed = Signal(bool)
return_shift_pressed = Signal()
return_pressed = Signal()
def __init__(self, parent, enable_replace=False):
QWidget.__init__(self, parent)
self.enable_replace = enable_replace
self.editor = None
self.is_code_editor = None
glayout = QGridLayout()
glayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(glayout)
self.close_button = create_toolbutton(
self, triggered=self.hide, icon=ima.icon('DialogCloseButton'))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self,
tip=_("Search string"),
adjust_to_minimum=False)
self.return_shift_pressed.connect(
lambda: self.find(changed=False,
forward=False,
rehighlight=False,
multiline_replace_check=False))
self.return_pressed.connect(
lambda: self.find(changed=False,
forward=True,
rehighlight=False,
multiline_replace_check=False))
self.search_text.lineEdit().textEdited.connect(
self.text_has_been_edited)
self.number_matches_text = QLabel(self)
self.previous_button = create_toolbutton(self,
triggered=self.find_previous,
icon=ima.icon('ArrowUp'),
tip=_("Find previous"))
self.next_button = create_toolbutton(self,
triggered=self.find_next,
icon=ima.icon('ArrowDown'),
tip=_("Find next"))
self.next_button.clicked.connect(self.update_search_combo)
self.previous_button.clicked.connect(self.update_search_combo)
self.re_button = create_toolbutton(self,
icon=ima.icon('regex'),
tip=_("Regular expression"))
self.re_button.setCheckable(True)
self.re_button.toggled.connect(lambda state: self.find())
self.case_button = create_toolbutton(
self, icon=ima.icon("format_letter_case"), tip=_("Case Sensitive"))
self.case_button.setCheckable(True)
self.case_button.toggled.connect(lambda state: self.find())
self.words_button = create_toolbutton(self,
icon=get_icon("whole_words.png"),
tip=_("Whole words"))
self.words_button.setCheckable(True)
self.words_button.toggled.connect(lambda state: self.find())
self.highlight_button = create_toolbutton(
self, icon=get_icon("highlight.png"), tip=_("Highlight matches"))
self.highlight_button.setCheckable(True)
self.highlight_button.toggled.connect(self.toggle_highlighting)
hlayout = QHBoxLayout()
self.widgets = [
self.close_button, self.search_text, self.number_matches_text,
self.previous_button, self.next_button, self.re_button,
self.case_button, self.words_button, self.highlight_button
]
for widget in self.widgets[1:]:
hlayout.addWidget(widget)
glayout.addLayout(hlayout, 0, 1)
# Replace layout
replace_with = QLabel(_("Replace with:"))
self.replace_text = PatternComboBox(self,
adjust_to_minimum=False,
tip=_('Replace string'))
self.replace_text.valid.connect(
lambda _: self.replace_find(focus_replace_text=True))
self.replace_button = create_toolbutton(
self,
text=_('Replace/find next'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find,
text_beside_icon=True)
self.replace_sel_button = create_toolbutton(
self,
text=_('Replace in selection'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_selection,
text_beside_icon=True)
self.replace_sel_button.clicked.connect(self.update_replace_combo)
self.replace_sel_button.clicked.connect(self.update_search_combo)
self.replace_all_button = create_toolbutton(
self,
text=_('Replace all'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_all,
text_beside_icon=True)
self.replace_all_button.clicked.connect(self.update_replace_combo)
self.replace_all_button.clicked.connect(self.update_search_combo)
self.replace_layout = QHBoxLayout()
widgets = [
replace_with, self.replace_text, self.replace_button,
self.replace_sel_button, self.replace_all_button
]
for widget in widgets:
self.replace_layout.addWidget(widget)
glayout.addLayout(self.replace_layout, 1, 1)
self.widgets.extend(widgets)
self.replace_widgets = widgets
self.hide_replace()
self.search_text.setTabOrder(self.search_text, self.replace_text)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.shortcuts = self.create_shortcuts(parent)
self.highlight_timer = QTimer(self)
self.highlight_timer.setSingleShot(True)
self.highlight_timer.setInterval(1000)
self.highlight_timer.timeout.connect(self.highlight_matches)
self.search_text.installEventFilter(self)
def eventFilter(self, widget, event):
"""Event filter for search_text widget.
Emits signals when presing Enter and Shift+Enter.
This signals are used for search forward and backward.
Also, a crude hack to get tab working in the Find/Replace boxes.
"""
if event.type() == QEvent.KeyPress:
key = event.key()
shift = event.modifiers() & Qt.ShiftModifier
if key == Qt.Key_Return:
if shift:
self.return_shift_pressed.emit()
else:
self.return_pressed.emit()
if key == Qt.Key_Tab:
if self.search_text.hasFocus():
self.replace_text.set_current_text(
self.search_text.currentText())
self.focusNextChild()
return super(FindReplace, self).eventFilter(widget, event)
def create_shortcuts(self, parent):
"""Create shortcuts for this widget"""
# Configurable
findnext = CONF.config_shortcut(self.find_next,
context='find_replace',
name='Find next',
parent=parent)
findprev = CONF.config_shortcut(self.find_previous,
context='find_replace',
name='Find previous',
parent=parent)
togglefind = CONF.config_shortcut(self.show,
context='find_replace',
name='Find text',
parent=parent)
togglereplace = CONF.config_shortcut(self.show_replace,
context='find_replace',
name='Replace text',
parent=parent)
hide = CONF.config_shortcut(self.hide,
context='find_replace',
name='hide find and replace',
parent=self)
return [findnext, findprev, togglefind, togglereplace, hide]
def get_shortcut_data(self):
"""
Returns shortcut data, a list of tuples (shortcut, text, default)
shortcut (QShortcut or QAction instance)
text (string): action/shortcut description
default (string): default key sequence
"""
return [sc.data for sc in self.shortcuts]
def update_search_combo(self):
self.search_text.lineEdit().returnPressed.emit()
def update_replace_combo(self):
self.replace_text.lineEdit().returnPressed.emit()
@Slot(bool)
def toggle_highlighting(self, state):
"""Toggle the 'highlight all results' feature"""
if self.editor is not None:
if state:
self.highlight_matches()
else:
self.clear_matches()
def show(self, hide_replace=True):
"""Overrides Qt Method"""
QWidget.show(self)
self.visibility_changed.emit(True)
self.change_number_matches()
if self.editor is not None:
if hide_replace:
if self.replace_widgets[0].isVisible():
self.hide_replace()
text = self.editor.get_selected_text()
# When selecting several lines, and replace box is activated the
# text won't be replaced for the selection
if hide_replace or len(text.splitlines()) <= 1:
highlighted = True
# If no text is highlighted for search, use whatever word is
# under the cursor
if not text:
highlighted = False
try:
cursor = self.editor.textCursor()
cursor.select(QTextCursor.WordUnderCursor)
text = to_text_string(cursor.selectedText())
except AttributeError:
# We can't do this for all widgets, e.g. WebView's
pass
# Now that text value is sorted out, use it for the search
if text and not self.search_text.currentText() or highlighted:
self.search_text.setEditText(text)
self.search_text.lineEdit().selectAll()
self.refresh()
else:
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
@Slot()
def hide(self):
"""Overrides Qt Method"""
for widget in self.replace_widgets:
widget.hide()
QWidget.hide(self)
self.visibility_changed.emit(False)
if self.editor is not None:
self.editor.setFocus()
self.clear_matches()
def show_replace(self):
"""Show replace widgets"""
if self.enable_replace:
self.show(hide_replace=False)
for widget in self.replace_widgets:
widget.show()
def hide_replace(self):
"""Hide replace widgets"""
for widget in self.replace_widgets:
widget.hide()
def refresh(self):
"""Refresh widget"""
if self.isHidden():
if self.editor is not None:
self.clear_matches()
return
state = self.editor is not None
for widget in self.widgets:
widget.setEnabled(state)
if state:
self.find()
def set_editor(self, editor, refresh=True):
"""
Set associated editor/web page:
codeeditor.base.TextEditBaseWidget
browser.WebView
"""
self.editor = editor
# Note: This is necessary to test widgets/editor.py
# in Qt builds that don't have web widgets
try:
from qtpy.QtWebEngineWidgets import QWebEngineView
except ImportError:
QWebEngineView = type(None)
self.words_button.setVisible(not isinstance(editor, QWebEngineView))
self.re_button.setVisible(not isinstance(editor, QWebEngineView))
from spyder.plugins.editor.widgets.codeeditor import CodeEditor
self.is_code_editor = isinstance(editor, CodeEditor)
self.highlight_button.setVisible(self.is_code_editor)
if refresh:
self.refresh()
if self.isHidden() and editor is not None:
self.clear_matches()
@Slot()
def find_next(self, set_focus=True):
"""Find next occurrence"""
state = self.find(changed=False,
forward=True,
rehighlight=False,
multiline_replace_check=False)
if set_focus:
self.editor.setFocus()
self.search_text.add_current_text()
return state
@Slot()
def find_previous(self, set_focus=True):
"""Find previous occurrence"""
state = self.find(changed=False,
forward=False,
rehighlight=False,
multiline_replace_check=False)
if set_focus:
self.editor.setFocus()
return state
def text_has_been_edited(self, text):
"""Find text has been edited (this slot won't be triggered when
setting the search pattern combo box text programmatically)"""
self.find(changed=True, forward=True, start_highlight_timer=True)
def highlight_matches(self):
"""Highlight found results"""
if self.is_code_editor and self.highlight_button.isChecked():
text = self.search_text.currentText()
case = self.case_button.isChecked()
word = self.words_button.isChecked()
regexp = self.re_button.isChecked()
self.editor.highlight_found_results(text,
word=word,
regexp=regexp,
case=case)
def clear_matches(self):
"""Clear all highlighted matches"""
if self.is_code_editor:
self.editor.clear_found_results()
def find(self,
changed=True,
forward=True,
rehighlight=True,
start_highlight_timer=False,
multiline_replace_check=True):
"""Call the find function"""
# When several lines are selected in the editor and replace box is
# activated, dynamic search is deactivated to prevent changing the
# selection. Otherwise we show matching items.
if multiline_replace_check and self.replace_widgets[0].isVisible():
sel_text = self.editor.get_selected_text()
if len(to_text_string(sel_text).splitlines()) > 1:
return None
text = self.search_text.currentText()
if len(text) == 0:
self.search_text.lineEdit().setStyleSheet("")
if not self.is_code_editor:
# Clears the selection for WebEngine
self.editor.find_text('')
self.change_number_matches()
return None
else:
case = self.case_button.isChecked()
word = self.words_button.isChecked()
regexp = self.re_button.isChecked()
found = self.editor.find_text(text,
changed,
forward,
case=case,
word=word,
regexp=regexp)
stylesheet = self.STYLE[found]
tooltip = self.TOOLTIP[found]
if not found and regexp:
error_msg = regexp_error_msg(text)
if error_msg: # special styling for regexp errors
stylesheet = self.STYLE['regexp_error']
tooltip = self.TOOLTIP['regexp_error'] + ': ' + error_msg
self.search_text.lineEdit().setStyleSheet(stylesheet)
self.search_text.setToolTip(tooltip)
if self.is_code_editor and found:
block = self.editor.textCursor().block()
TextHelper(self.editor).unfold_if_colapsed(block)
if rehighlight or not self.editor.found_results:
self.highlight_timer.stop()
if start_highlight_timer:
self.highlight_timer.start()
else:
self.highlight_matches()
else:
self.clear_matches()
number_matches = self.editor.get_number_matches(text,
case=case,
regexp=regexp,
word=word)
if hasattr(self.editor, 'get_match_number'):
match_number = self.editor.get_match_number(text,
case=case,
regexp=regexp,
word=word)
else:
match_number = 0
self.change_number_matches(current_match=match_number,
total_matches=number_matches)
return found
class FindReplace(QWidget):
"""Find widget"""
STYLE = {False: "background-color:rgb(255, 175, 90);",
True: "",
None: "",
'regexp_error': "background-color:rgb(255, 80, 80);",
}
TOOLTIP = {False: _("No matches"),
True: _("Search string"),
None: _("Search string"),
'regexp_error': _("Regular expression error")
}
visibility_changed = Signal(bool)
return_shift_pressed = Signal()
return_pressed = Signal()
def __init__(self, parent, enable_replace=False):
QWidget.__init__(self, parent)
self.enable_replace = enable_replace
self.editor = None
self.is_code_editor = None
glayout = QGridLayout()
glayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(glayout)
self.close_button = create_toolbutton(self, triggered=self.hide,
icon=ima.icon('DialogCloseButton'))
glayout.addWidget(self.close_button, 0, 0)
# Find layout
self.search_text = PatternComboBox(self, tip=_("Search string"),
adjust_to_minimum=False)
self.return_shift_pressed.connect(
lambda:
self.find(changed=False, forward=False, rehighlight=False,
multiline_replace_check = False))
self.return_pressed.connect(
lambda:
self.find(changed=False, forward=True, rehighlight=False,
multiline_replace_check = False))
self.search_text.lineEdit().textEdited.connect(
self.text_has_been_edited)
self.number_matches_text = QLabel(self)
self.previous_button = create_toolbutton(self,
triggered=self.find_previous,
icon=ima.icon('ArrowUp'))
self.next_button = create_toolbutton(self,
triggered=self.find_next,
icon=ima.icon('ArrowDown'))
self.next_button.clicked.connect(self.update_search_combo)
self.previous_button.clicked.connect(self.update_search_combo)
self.re_button = create_toolbutton(self, icon=get_icon('regexp.svg'),
tip=_("Regular expression"))
self.re_button.setCheckable(True)
self.re_button.toggled.connect(lambda state: self.find())
self.case_button = create_toolbutton(self,
icon=get_icon("upper_lower.png"),
tip=_("Case Sensitive"))
self.case_button.setCheckable(True)
self.case_button.toggled.connect(lambda state: self.find())
self.words_button = create_toolbutton(self,
icon=get_icon("whole_words.png"),
tip=_("Whole words"))
self.words_button.setCheckable(True)
self.words_button.toggled.connect(lambda state: self.find())
self.highlight_button = create_toolbutton(self,
icon=get_icon("highlight.png"),
tip=_("Highlight matches"))
self.highlight_button.setCheckable(True)
self.highlight_button.toggled.connect(self.toggle_highlighting)
hlayout = QHBoxLayout()
self.widgets = [self.close_button, self.search_text,
self.number_matches_text, self.previous_button,
self.next_button, self.re_button, self.case_button,
self.words_button, self.highlight_button]
for widget in self.widgets[1:]:
hlayout.addWidget(widget)
glayout.addLayout(hlayout, 0, 1)
# Replace layout
replace_with = QLabel(_("Replace with:"))
self.replace_text = PatternComboBox(self, adjust_to_minimum=False,
tip=_('Replace string'))
self.replace_text.valid.connect(
lambda _: self.replace_find(focus_replace_text=True))
self.replace_button = create_toolbutton(self,
text=_('Replace/find next'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find,
text_beside_icon=True)
self.replace_sel_button = create_toolbutton(self,
text=_('Replace selection'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_selection,
text_beside_icon=True)
self.replace_sel_button.clicked.connect(self.update_replace_combo)
self.replace_sel_button.clicked.connect(self.update_search_combo)
self.replace_all_button = create_toolbutton(self,
text=_('Replace all'),
icon=ima.icon('DialogApplyButton'),
triggered=self.replace_find_all,
text_beside_icon=True)
self.replace_all_button.clicked.connect(self.update_replace_combo)
self.replace_all_button.clicked.connect(self.update_search_combo)
self.replace_layout = QHBoxLayout()
widgets = [replace_with, self.replace_text, self.replace_button,
self.replace_sel_button, self.replace_all_button]
for widget in widgets:
self.replace_layout.addWidget(widget)
glayout.addLayout(self.replace_layout, 1, 1)
self.widgets.extend(widgets)
self.replace_widgets = widgets
self.hide_replace()
self.search_text.setTabOrder(self.search_text, self.replace_text)
self.setSizePolicy(QSizePolicy.Expanding, QSizePolicy.Fixed)
self.shortcuts = self.create_shortcuts(parent)
self.highlight_timer = QTimer(self)
self.highlight_timer.setSingleShot(True)
self.highlight_timer.setInterval(1000)
self.highlight_timer.timeout.connect(self.highlight_matches)
self.search_text.installEventFilter(self)
def eventFilter(self, widget, event):
"""Event filter for search_text widget.
Emits signals when presing Enter and Shift+Enter.
This signals are used for search forward and backward.
Also, a crude hack to get tab working in the Find/Replace boxes.
"""
if event.type() == QEvent.KeyPress:
key = event.key()
shift = event.modifiers() & Qt.ShiftModifier
if key == Qt.Key_Return:
if shift:
self.return_shift_pressed.emit()
else:
self.return_pressed.emit()
if key == Qt.Key_Tab:
if self.search_text.hasFocus():
self.replace_text.set_current_text(
self.search_text.currentText())
self.focusNextChild()
return super(FindReplace, self).eventFilter(widget, event)
def create_shortcuts(self, parent):
"""Create shortcuts for this widget"""
# Configurable
findnext = config_shortcut(self.find_next, context='_',
name='Find next', parent=parent)
findprev = config_shortcut(self.find_previous, context='_',
name='Find previous', parent=parent)
togglefind = config_shortcut(self.show, context='_',
name='Find text', parent=parent)
togglereplace = config_shortcut(self.show_replace,
context='_', name='Replace text',
parent=parent)
hide = config_shortcut(self.hide, context='_', name='hide find and replace',
parent=self)
return [findnext, findprev, togglefind, togglereplace, hide]
def get_shortcut_data(self):
"""
Returns shortcut data, a list of tuples (shortcut, text, default)
shortcut (QShortcut or QAction instance)
text (string): action/shortcut description
default (string): default key sequence
"""
return [sc.data for sc in self.shortcuts]
def update_search_combo(self):
self.search_text.lineEdit().returnPressed.emit()
def update_replace_combo(self):
self.replace_text.lineEdit().returnPressed.emit()
def toggle_replace_widgets(self):
if self.enable_replace:
# Toggle replace widgets
if self.replace_widgets[0].isVisible():
self.hide_replace()
self.hide()
else:
self.show_replace()
if len(to_text_string(self.search_text.currentText()))>0:
self.replace_text.setFocus()
@Slot(bool)
def toggle_highlighting(self, state):
"""Toggle the 'highlight all results' feature"""
if self.editor is not None:
if state:
self.highlight_matches()
else:
self.clear_matches()
def show(self, hide_replace=True):
"""Overrides Qt Method"""
QWidget.show(self)
self.visibility_changed.emit(True)
self.change_number_matches()
if self.editor is not None:
if hide_replace:
if self.replace_widgets[0].isVisible():
self.hide_replace()
text = self.editor.get_selected_text()
# When selecting several lines, and replace box is activated the
# text won't be replaced for the selection
if hide_replace or len(text.splitlines())<=1:
highlighted = True
# If no text is highlighted for search, use whatever word is
# under the cursor
if not text:
highlighted = False
try:
cursor = self.editor.textCursor()
cursor.select(QTextCursor.WordUnderCursor)
text = to_text_string(cursor.selectedText())
except AttributeError:
# We can't do this for all widgets, e.g. WebView's
pass
# Now that text value is sorted out, use it for the search
if text and not self.search_text.currentText() or highlighted:
self.search_text.setEditText(text)
self.search_text.lineEdit().selectAll()
self.refresh()
else:
self.search_text.lineEdit().selectAll()
self.search_text.setFocus()
@Slot()
def hide(self):
"""Overrides Qt Method"""
for widget in self.replace_widgets:
widget.hide()
QWidget.hide(self)
self.visibility_changed.emit(False)
if self.editor is not None:
self.editor.setFocus()
self.clear_matches()
def show_replace(self):
"""Show replace widgets"""
self.show(hide_replace=False)
for widget in self.replace_widgets:
widget.show()
def hide_replace(self):
"""Hide replace widgets"""
for widget in self.replace_widgets:
widget.hide()
def refresh(self):
"""Refresh widget"""
if self.isHidden():
if self.editor is not None:
self.clear_matches()
return
state = self.editor is not None
for widget in self.widgets:
widget.setEnabled(state)
if state:
self.find()
def set_editor(self, editor, refresh=True):
"""
Set associated editor/web page:
codeeditor.base.TextEditBaseWidget
browser.WebView
"""
self.editor = editor
# Note: This is necessary to test widgets/editor.py
# in Qt builds that don't have web widgets
try:
from qtpy.QtWebEngineWidgets import QWebEngineView
except ImportError:
QWebEngineView = type(None)
self.words_button.setVisible(not isinstance(editor, QWebEngineView))
self.re_button.setVisible(not isinstance(editor, QWebEngineView))
from spyder.plugins.editor.widgets.codeeditor import CodeEditor
self.is_code_editor = isinstance(editor, CodeEditor)
self.highlight_button.setVisible(self.is_code_editor)
if refresh:
self.refresh()
if self.isHidden() and editor is not None:
self.clear_matches()
@Slot()
def find_next(self):
"""Find next occurrence"""
state = self.find(changed=False, forward=True, rehighlight=False,
multiline_replace_check=False)
self.editor.setFocus()
self.search_text.add_current_text()
return state
@Slot()
def find_previous(self):
"""Find previous occurrence"""
state = self.find(changed=False, forward=False, rehighlight=False,
multiline_replace_check=False)
self.editor.setFocus()
return state
def text_has_been_edited(self, text):
"""Find text has been edited (this slot won't be triggered when
setting the search pattern combo box text programmatically)"""
self.find(changed=True, forward=True, start_highlight_timer=True)
def highlight_matches(self):
"""Highlight found results"""
if self.is_code_editor and self.highlight_button.isChecked():
text = self.search_text.currentText()
words = self.words_button.isChecked()
regexp = self.re_button.isChecked()
self.editor.highlight_found_results(text, words=words,
regexp=regexp)
def clear_matches(self):
"""Clear all highlighted matches"""
if self.is_code_editor:
self.editor.clear_found_results()
def find(self, changed=True, forward=True,
rehighlight=True, start_highlight_timer=False, multiline_replace_check=True):
"""Call the find function"""
# When several lines are selected in the editor and replace box is activated,
# dynamic search is deactivated to prevent changing the selection. Otherwise
# we show matching items.
if multiline_replace_check and self.replace_widgets[0].isVisible() and \
len(to_text_string(self.editor.get_selected_text()).splitlines())>1:
return None
text = self.search_text.currentText()
if len(text) == 0:
self.search_text.lineEdit().setStyleSheet("")
if not self.is_code_editor:
# Clears the selection for WebEngine
self.editor.find_text('')
self.change_number_matches()
return None
else:
case = self.case_button.isChecked()
words = self.words_button.isChecked()
regexp = self.re_button.isChecked()
found = self.editor.find_text(text, changed, forward, case=case,
words=words, regexp=regexp)
stylesheet = self.STYLE[found]
tooltip = self.TOOLTIP[found]
if not found and regexp:
error_msg = regexp_error_msg(text)
if error_msg: # special styling for regexp errors
stylesheet = self.STYLE['regexp_error']
tooltip = self.TOOLTIP['regexp_error'] + ': ' + error_msg
self.search_text.lineEdit().setStyleSheet(stylesheet)
self.search_text.setToolTip(tooltip)
if self.is_code_editor and found:
block = self.editor.textCursor().block()
TextHelper(self.editor).unfold_if_colapsed(block)
if rehighlight or not self.editor.found_results:
self.highlight_timer.stop()
if start_highlight_timer:
self.highlight_timer.start()
else:
self.highlight_matches()
else:
self.clear_matches()
number_matches = self.editor.get_number_matches(text, case=case,
regexp=regexp)
if hasattr(self.editor, 'get_match_number'):
match_number = self.editor.get_match_number(text, case=case,
regexp=regexp)
else:
match_number = 0
self.change_number_matches(current_match=match_number,
total_matches=number_matches)
return found
@Slot()
def replace_find(self, focus_replace_text=False, replace_all=False):
"""Replace and find"""
if (self.editor is not None):
replace_text = to_text_string(self.replace_text.currentText())
search_text = to_text_string(self.search_text.currentText())
re_pattern = None
# Check regexp before proceeding
if self.re_button.isChecked():
try:
re_pattern = re.compile(search_text)
# Check if replace_text can be substituted in re_pattern
# Fixes issue #7177
re_pattern.sub(replace_text, '')
except re.error:
# Do nothing with an invalid regexp
return
case = self.case_button.isChecked()
first = True
cursor = None
while True:
if first:
# First found
seltxt = to_text_string(self.editor.get_selected_text())
cmptxt1 = search_text if case else search_text.lower()
cmptxt2 = seltxt if case else seltxt.lower()
if re_pattern is None:
has_selected = self.editor.has_selected_text()
if has_selected and cmptxt1 == cmptxt2:
# Text was already found, do nothing
pass
else:
if not self.find(changed=False, forward=True,
rehighlight=False):
break
else:
if len(re_pattern.findall(cmptxt2)) > 0:
pass
else:
if not self.find(changed=False, forward=True,
rehighlight=False):
break
first = False
wrapped = False
position = self.editor.get_position('cursor')
position0 = position
cursor = self.editor.textCursor()
cursor.beginEditBlock()
else:
position1 = self.editor.get_position('cursor')
if is_position_inf(position1,
position0 + len(replace_text) -
len(search_text) + 1):
# Identify wrapping even when the replace string
# includes part of the search string
wrapped = True
if wrapped:
if position1 == position or \
is_position_sup(position1, position):
# Avoid infinite loop: replace string includes
# part of the search string
break
if position1 == position0:
# Avoid infinite loop: single found occurrence
break
position0 = position1
if re_pattern is None:
cursor.removeSelectedText()
cursor.insertText(replace_text)
else:
seltxt = to_text_string(cursor.selectedText())
cursor.removeSelectedText()
cursor.insertText(re_pattern.sub(replace_text, seltxt))
if self.find_next():
found_cursor = self.editor.textCursor()
cursor.setPosition(found_cursor.selectionStart(),
QTextCursor.MoveAnchor)
cursor.setPosition(found_cursor.selectionEnd(),
QTextCursor.KeepAnchor)
else:
break
if not replace_all:
break
if cursor is not None:
cursor.endEditBlock()
if focus_replace_text:
self.replace_text.setFocus()
@Slot()
def replace_find_all(self, focus_replace_text=False):
"""Replace and find all matching occurrences"""
self.replace_find(focus_replace_text, replace_all=True)
@Slot()
def replace_find_selection(self, focus_replace_text=False):
"""Replace and find in the current selection"""
if self.editor is not None:
replace_text = to_text_string(self.replace_text.currentText())
search_text = to_text_string(self.search_text.currentText())
case = self.case_button.isChecked()
words = self.words_button.isChecked()
re_flags = re.MULTILINE if case else re.IGNORECASE|re.MULTILINE
re_pattern = None
if self.re_button.isChecked():
pattern = search_text
else:
pattern = re.escape(search_text)
replace_text = re.escape(replace_text)
if words: # match whole words only
pattern = r'\b{pattern}\b'.format(pattern=pattern)
# Check regexp before proceeding
try:
re_pattern = re.compile(pattern, flags=re_flags)
# Check if replace_text can be substituted in re_pattern
# Fixes issue #7177
re_pattern.sub(replace_text, '')
except re.error as e:
# Do nothing with an invalid regexp
return
selected_text = to_text_string(self.editor.get_selected_text())
replacement = re_pattern.sub(replace_text, selected_text)
if replacement != selected_text:
cursor = self.editor.textCursor()
cursor.beginEditBlock()
cursor.removeSelectedText()
if not self.re_button.isChecked():
replacement = re.sub(r'\\(?![nrtf])(.)', r'\1', replacement)
cursor.insertText(replacement)
cursor.endEditBlock()
if focus_replace_text:
self.replace_text.setFocus()
else:
self.editor.setFocus()
def change_number_matches(self, current_match=0, total_matches=0):
"""Change number of match and total matches."""
if current_match and total_matches:
matches_string = u"{} {} {}".format(current_match, _(u"of"),
total_matches)
self.number_matches_text.setText(matches_string)
elif total_matches:
matches_string = u"{} {}".format(total_matches, _(u"matches"))
self.number_matches_text.setText(matches_string)
else:
self.number_matches_text.setText(_(u"no matches"))