PrEditor 0.3.0__py2.py3-none-any.whl → 0.5.0__py2.py3-none-any.whl

preditor/gui/loggerwindow.py

@@ -14,11 +14,11 @@ import __main__
 import six
 from Qt import QtCompat, QtCore, QtWidgets
 from Qt.QtCore import QByteArray, Qt, QTimer, Signal, Slot
-from Qt.QtGui import QCursor, QFont, QFontDatabase, QIcon, QTextCursor
+from Qt.QtGui import QCursor, QFont, QIcon, QTextCursor
 from Qt.QtWidgets import (
     QApplication,
+    QFontDialog,
     QInputDialog,
-    QLabel,
     QMessageBox,
     QTextBrowser,
     QToolTip,
@@ -44,6 +44,7 @@ from ..utils import stylesheets
 from .completer import CompleterMode
 from .level_buttons import LoggingLevelButton
 from .set_text_editor_path_dialog import SetTextEditorPathDialog
+from .status_label import StatusLabel
 
 
 class WorkboxPages:
@@ -75,6 +76,7 @@ class LoggerWindow(Window):
         loadUi(__file__, self)
 
         self.uiConsoleTXT.flash_window = self
+        self.uiConsoleTXT.clearExecutionTime = self.clearExecutionTime
         self.uiConsoleTXT.reportExecutionTime = self.reportExecutionTime
         self.uiClearToLastPromptACT.triggered.connect(
             self.uiConsoleTXT.clearToLastPrompt
@@ -84,7 +86,7 @@ class LoggerWindow(Window):
         self.uiConsoleTXT.uiClearToLastPromptACT.setShortcut('')
 
         # create the status reporting label
-        self.uiStatusLBL = QLabel(self)
+        self.uiStatusLBL = StatusLabel(self)
         self.uiMenuBar.setCornerWidget(self.uiStatusLBL)
 
         # create the workbox tabs
@@ -119,12 +121,38 @@ class LoggerWindow(Window):
         self.uiCloseLoggerACT.triggered.connect(self.closeLogger)
 
         self.uiRunAllACT.triggered.connect(self.execAll)
-        self.uiRunSelectedACT.triggered.connect(self.execSelected)
+        # Even though the RunSelected actions (with shortcuts) are connected
+        # here, this only affects if the action is chosen from the menu. The
+        # shortcuts are always intercepted by the workbox document editor. To
+        # handle this, the workbox.keyPressEvent method will perceive the
+        # shortcut press, and call .execSelected, which will then ultimately call
+        # workbox.__exec_selected__
+        self.uiRunSelectedACT.triggered.connect(
+            partial(self.execSelected, truncate=True)
+        )
+        self.uiRunSelectedDontTruncateACT.triggered.connect(
+            partial(self.execSelected, truncate=False)
+        )
 
-        self.uiAutoCompleteEnabledACT.toggled.connect(self.setAutoCompleteEnabled)
+        self.uiConsoleAutoCompleteEnabledACT.toggled.connect(
+            partial(self.setAutoCompleteEnabled, console=True)
+        )
+        self.uiWorkboxAutoCompleteEnabledACT.toggled.connect(
+            partial(self.setAutoCompleteEnabled, console=False)
+        )
 
         self.uiAutoCompleteCaseSensitiveACT.toggled.connect(self.setCaseSensitive)
 
+        self.uiSelectMonospaceFontACT.triggered.connect(
+            partial(self.selectFont, monospace=True)
+        )
+        self.uiSelectProportionalFontACT.triggered.connect(
+            partial(self.selectFont, proportional=True)
+        )
+        self.uiSelectAllFontACT.triggered.connect(
+            partial(self.selectFont, monospace=True, proportional=True)
+        )
+
         # Setup ability to cycle completer mode, and create action for each mode
         self.completerModeCycle = itertools.cycle(CompleterMode)
         # create CompleterMode submenu
@@ -234,27 +262,9 @@ class LoggerWindow(Window):
         # Make action shortcuts available anywhere in the Logger
         self.addAction(self.uiClearLogACT)
 
+        self.dont_ask_again = []
         self.restorePrefs()
 
-        # add font menu list
-        curFamily = self.console().font().family()
-        fontDB = QFontDatabase()
-        fontFamilies = fontDB.families(QFontDatabase.Latin)
-        monospaceFonts = [fam for fam in fontFamilies if fontDB.isFixedPitch(fam)]
-
-        self.uiMonospaceFontMENU.clear()
-        self.uiProportionalFontMENU.clear()
-
-        for family in fontFamilies:
-            if family in monospaceFonts:
-                action = self.uiMonospaceFontMENU.addAction(family)
-            else:
-                action = self.uiProportionalFontMENU.addAction(family)
-            action.setObjectName(u'ui{}FontACT'.format(family))
-            action.setCheckable(True)
-            action.setChecked(family == curFamily)
-            action.triggered.connect(partial(self.selectFont, action))
-
         # add stylesheet menu options.
         for style_name in stylesheets.stylesheets():
             action = self.uiStyleMENU.addAction(style_name)
@@ -276,6 +286,9 @@ class LoggerWindow(Window):
             )
         )
 
+        self.setWorkboxFontBasedOnConsole()
+        self.setEditorChooserFontBasedOnConsole()
+
         self.setup_run_workbox()
 
         if not standalone:
@@ -429,7 +442,7 @@ class LoggerWindow(Window):
         if not workbox.hasFocus():
             return
 
-        text = workbox.__selected_text__()
+        text, _line = workbox.__selected_text__(selectText=True)
         if not text:
             line, index = workbox.__cursor_position__()
             text = workbox.__text__(line)
@@ -513,15 +526,7 @@ class LoggerWindow(Window):
             newSize = font.pointSize() + delta
             newSize = max(min(newSize, maxSize), minSize)
 
-            font.setPointSize(newSize)
-            self.console().setConsoleFont(font)
-
-            for workbox in self.uiWorkboxTAB.all_widgets():
-                marginsFont = workbox.__margins_font__()
-                marginsFont.setPointSize(newSize)
-                workbox.__set_margins_font__(marginsFont)
-
-                workbox.__set_font__(font)
+            self.setFontSize(newSize)
         else:
             Window.wheelEvent(self, event)
 
@@ -539,41 +544,76 @@ class LoggerWindow(Window):
         menu = action.parentWidget()
         QToolTip.showText(QCursor.pos(), text, menu)
 
-    def findCurrentFontAction(self):
-        """Find and return current font's action"""
-        actions = self.uiMonospaceFontMENU.actions()
-        actions.extend(self.uiProportionalFontMENU.actions())
-
-        action = None
-        for act in actions:
-            if act.isChecked():
-                action = act
-                break
-
-        return action
-
-    def selectFont(self, action):
-        """Set console and workbox font to current font
+    def selectFont(self, monospace=False, proportional=False):
+        """Present a QFontChooser dialog, offering, monospace, proportional, or all
+        fonts, based on user choice. If a font is chosen, set it on the console and
+        workboxes.
 
         Args:
             action (QAction): menu action associated with chosen font
         """
+        origFont = self.console().font()
+        curFontFamily = origFont.family()
+
+        if monospace and proportional:
+            options = QFontDialog.MonospacedFonts | QFontDialog.ProportionalFonts
+            kind = "monospace or proportional "
+        elif monospace:
+            options = QFontDialog.MonospacedFonts
+            kind = "monospace "
+        elif proportional:
+            options = QFontDialog.ProportionalFonts
+            kind = "proportional "
+
+        # Present a QFontDialog for user to choose a font
+        title = "Pick a {} font. Current font is: {}".format(kind, curFontFamily)
+        newFont, okClicked = QFontDialog.getFont(origFont, self, title, options=options)
+
+        if okClicked:
+            self.console().setConsoleFont(newFont)
+            self.setWorkboxFontBasedOnConsole()
+            self.setEditorChooserFontBasedOnConsole()
+
+    def setFontSize(self, newSize):
+        """Update the font size in the console and current workbox.
 
-        actions = self.uiMonospaceFontMENU.actions()
-        actions.extend(self.uiProportionalFontMENU.actions())
+        Args:
+            newSize (int): The new size to set the font
+        """
+        font = self.console().font()
+        font.setPointSize(newSize)
+        self.console().setConsoleFont(font)
 
-        for act in actions:
-            act.setChecked(act == action)
+        self.setWorkboxFontBasedOnConsole()
+        self.setEditorChooserFontBasedOnConsole()
 
-        family = action.text()
+    def setWorkboxFontBasedOnConsole(self):
+        """If the current workbox's font is different to the console's font, set it to
+        match.
+        """
         font = self.console().font()
-        font.setFamily(family)
-        self.console().setConsoleFont(font)
 
-        for workbox in self.uiWorkboxTAB.all_widgets():
+        workboxGroup = self.uiWorkboxTAB.currentWidget()
+        if workboxGroup is None:
+            return
+
+        workbox = workboxGroup.currentWidget()
+        if workbox is None:
+            return
+
+        if workbox.__font__() != font:
             workbox.__set_margins_font__(font)
             workbox.__set_font__(font)
 
+    def setEditorChooserFontBasedOnConsole(self):
+        """Set the EditorChooser font to match console. This helps with legibility when
+        using EditorChooser.
+        """
+        font = self.console().font()
+        for child in self.uiEditorChooserWGT.children():
+            if hasattr(child, "font"):
+                child.setFont(font)
+
     @classmethod
     def _genPrefName(cls, baseName, index):
         if index:
@@ -635,11 +675,21 @@ class LoggerWindow(Window):
             prompt = console.prompt()
             console.startPrompt(prompt)
 
-    def execSelected(self):
-        """Clears the console before executing selected workbox code"""
+    def execSelected(self, truncate=True):
+        """Clears the console before executing selected workbox code.
+
+        NOTE! This method is not called when the uiRunSelectedACT is triggered,
+        because the workbox will always intercept it. So instead, the workbox's
+        keyPressEvent will notice the  shortcut and call this method.
+        """
+
         if self.uiClearBeforeRunningACT.isChecked():
             self.clearLog()
-        self.current_workbox().__exec_selected__()
+
+        self.current_workbox().__exec_selected__(truncate=truncate)
+
+        if self.uiAutoPromptACT.isChecked():
+            self.console().startInputLine()
 
     def keyPressEvent(self, event):
         # Fix 'Maya : Qt tools lose focus' https://redmine.blur.com/issues/34430
@@ -652,9 +702,15 @@ class LoggerWindow(Window):
         if self.uiClearLogOnRefreshACT.isChecked():
             self.clearLog()
 
+    def clearExecutionTime(self):
+        """Update status text with hyphens to indicate execution has begun."""
+        self.setStatusText('Exec: -.- Seconds')
+        QApplication.instance().processEvents()
+
     def reportExecutionTime(self, seconds):
         """Update status text with seconds passed in."""
-        self.setStatusText('Exec: {:0.04f} Seconds'.format(seconds))
+        self.uiStatusLBL.showSeconds(seconds)
+        self.uiMenuBar.adjustSize()
 
     def recordPrefs(self, manual=False):
         if not manual and not self.uiAutoSaveSettingssACT.isChecked():
@@ -670,17 +726,22 @@ class LoggerWindow(Window):
                 'SplitterSize': self.uiSplitterSPLIT.sizes(),
                 'tabIndent': self.uiIndentationsTabsACT.isChecked(),
                 'copyIndentsAsSpaces': self.uiCopyTabsToSpacesACT.isChecked(),
-                'hintingEnabled': self.uiAutoCompleteEnabledACT.isChecked(),
+                'hintingEnabled': self.uiConsoleAutoCompleteEnabledACT.isChecked(),
+                'workboxHintingEnabled': (
+                    self.uiWorkboxAutoCompleteEnabledACT.isChecked()
+                ),
                 'spellCheckEnabled': self.uiSpellCheckEnabledACT.isChecked(),
                 'wordWrap': self.uiWordWrapACT.isChecked(),
                 'clearBeforeRunning': self.uiClearBeforeRunningACT.isChecked(),
                 'clearBeforeEnvRefresh': self.uiClearLogOnRefreshACT.isChecked(),
+                'uiSelectTextACT': self.uiSelectTextACT.isChecked(),
                 'toolbarStates': six.text_type(self.saveState().toHex(), 'utf-8'),
                 'consoleFont': self.console().font().toString(),
                 'uiAutoSaveSettingssACT': self.uiAutoSaveSettingssACT.isChecked(),
                 'uiAutoPromptACT': self.uiAutoPromptACT.isChecked(),
                 'uiLinesInNewWorkboxACT': self.uiLinesInNewWorkboxACT.isChecked(),
                 'uiErrorHyperlinksACT': self.uiErrorHyperlinksACT.isChecked(),
+                'uiStatusLbl_limit': self.uiStatusLBL.limit(),
                 'textEditorPath': self.textEditorPath,
                 'textEditorCmdTempl': self.textEditorCmdTempl,
                 'currentStyleSheet': self._stylesheet,
@@ -691,6 +752,10 @@ class LoggerWindow(Window):
                 ),
                 'find_files_context': self.uiFindInWorkboxesWGT.uiContextSPN.value(),
                 'find_files_text': self.uiFindInWorkboxesWGT.uiFindTXT.text(),
+                'uiHighlightExactCompletionACT': (
+                    self.uiHighlightExactCompletionACT.isChecked()
+                ),
+                'dont_ask_again': self.dont_ask_again,
             }
         )
 
@@ -725,6 +790,15 @@ class LoggerWindow(Window):
         with open(filename, 'w') as fp:
             json.dump(pref, fp, indent=4)
 
+    def maybeDisplayDialog(self, dialog):
+        """If user hasn't previously opted to not show this particular dialog again,
+        show it.
+        """
+        if dialog.objectName() in self.dont_ask_again:
+            return
+
+        dialog.exec_()
+
     def restartLogger(self):
         """Closes this PrEditor instance and starts a new process with the same
         cli arguments.
@@ -774,21 +848,20 @@ class LoggerWindow(Window):
         self.setWindowState(Qt.WindowStates(pref.get('windowState', 0)))
         self.uiIndentationsTabsACT.setChecked(pref.get('tabIndent', True))
         self.uiCopyTabsToSpacesACT.setChecked(pref.get('copyIndentsAsSpaces', False))
-        self.uiAutoCompleteEnabledACT.setChecked(pref.get('hintingEnabled', True))
 
         # completer settings
         self.setCaseSensitive(pref.get('caseSensitive', True))
         completerMode = CompleterMode(pref.get('completerMode', 0))
         self.cycleToCompleterMode(completerMode)
         self.setCompleterMode(completerMode)
+        self.uiHighlightExactCompletionACT.setChecked(
+            pref.get('uiHighlightExactCompletionACT', False)
+        )
 
         self.setSpellCheckEnabled(self.uiSpellCheckEnabledACT.isChecked())
         self.uiSpellCheckEnabledACT.setChecked(pref.get('spellCheckEnabled', False))
         self.uiSpellCheckEnabledACT.setDisabled(False)
 
-        self.uiConsoleTXT.completer().setEnabled(
-            self.uiAutoCompleteEnabledACT.isChecked()
-        )
         self.uiAutoSaveSettingssACT.setChecked(pref.get('uiAutoSaveSettingssACT', True))
 
         self.uiAutoPromptACT.setChecked(pref.get('uiAutoPromptACT', False))
@@ -796,6 +869,7 @@ class LoggerWindow(Window):
             pref.get('uiLinesInNewWorkboxACT', False)
         )
         self.uiErrorHyperlinksACT.setChecked(pref.get('uiErrorHyperlinksACT', True))
+        self.uiStatusLBL.setLimit(pref.get('uiStatusLbl_limit', 5))
 
         # Find Files settings
         self.uiFindInWorkboxesWGT.uiRegexBTN.setChecked(
@@ -811,7 +885,7 @@ class LoggerWindow(Window):
 
         # External text editor filepath and command template
         defaultExePath = r"C:\Program Files\Sublime Text 3\sublime_text.exe"
-        defaultCmd = r"{exePath} {modulePath}:{lineNum}"
+        defaultCmd = r'"{exePath}" "{modulePath}":{lineNum}'
         self.textEditorPath = pref.get('textEditorPath', defaultExePath)
         self.textEditorCmdTempl = pref.get('textEditorCmdTempl', defaultCmd)
 
@@ -820,6 +894,7 @@ class LoggerWindow(Window):
         self.uiClearBeforeRunningACT.setChecked(pref.get('clearBeforeRunning', False))
         self.uiClearLogOnRefreshACT.setChecked(pref.get('clearBeforeEnvRefresh', False))
         self.setClearBeforeRunning(self.uiClearBeforeRunningACT.isChecked())
+        self.uiSelectTextACT.setChecked(pref.get('uiSelectTextACT', True))
 
         self._stylesheet = pref.get('currentStyleSheet', 'Bright')
         if self._stylesheet == 'Custom':
@@ -830,6 +905,13 @@ class LoggerWindow(Window):
 
         self.uiWorkboxTAB.restore_prefs(pref.get('workbox_prefs', {}))
 
+        hintingEnabled = pref.get('hintingEnabled', True)
+        self.uiConsoleAutoCompleteEnabledACT.setChecked(hintingEnabled)
+        self.setAutoCompleteEnabled(hintingEnabled, console=True)
+        workboxHintingEnabled = pref.get('workboxHintingEnabled', True)
+        self.uiWorkboxAutoCompleteEnabledACT.setChecked(workboxHintingEnabled)
+        self.setAutoCompleteEnabled(workboxHintingEnabled, console=False)
+
         # Ensure the correct workbox stack page is shown
         self.update_workbox_stack()
 
@@ -839,6 +921,8 @@ class LoggerWindow(Window):
             if font.fromString(_font):
                 self.console().setConsoleFont(font)
 
+        self.dont_ask_again = pref.get('dont_ask_again', [])
+
     def restoreToolbars(self, pref=None):
         if pref is None:
             pref = self.load_prefs()
@@ -848,10 +932,12 @@ class LoggerWindow(Window):
             state = QByteArray.fromHex(bytes(state, 'utf-8'))
             self.restoreState(state)
 
-    def setAutoCompleteEnabled(self, state):
-        self.uiConsoleTXT.completer().setEnabled(state)
-        for workbox, _, _, _, _ in self.uiWorkboxTAB.all_widgets():
-            workbox.__set_auto_complete_enabled__(state)
+    def setAutoCompleteEnabled(self, state, console=True):
+        if console:
+            self.uiConsoleTXT.completer().setEnabled(state)
+        else:
+            for workbox, _, _, _, _ in self.uiWorkboxTAB.all_widgets():
+                workbox.__set_auto_complete_enabled__(state)
 
     def setSpellCheckEnabled(self, state):
         try:
@@ -876,7 +962,7 @@ class LoggerWindow(Window):
 
     def clearStatusText(self):
         """Clear any displayed status text"""
-        self.uiStatusLBL.setText('')
+        self.uiStatusLBL.clear()
         self.uiMenuBar.adjustSize()
 
     def autoHideStatusText(self):

preditor/gui/set_text_editor_path_dialog.py

@@ -17,7 +17,7 @@ class SetTextEditorPathDialog(QDialog):
         super(SetTextEditorPathDialog, self).__init__(parent)
         loadUi(__file__, self)
 
-        # Rerieve existing data from LoggerWindow
+        # Retrieve existing data from LoggerWindow
         path = self.parent().textEditorPath
         cmdTempl = self.parent().textEditorCmdTempl
 
@@ -29,9 +29,9 @@ class SetTextEditorPathDialog(QDialog):
 
         toolTip = (
             "Examples:\n"
-            "SublimeText: {exePath} {modulePath}:{lineNum}\n"
-            "notepad++: {exePath} {modulePath} -n{lineNum}\n"
-            "vim: {exePath} +{lineNum} {modulePath}"
+            'SublimeText: "{exePath}" "{modulePath}":{lineNum}\n'
+            'notepad++: "{exePath}" "{modulePath}" -n{lineNum}\n'
+            'vim: "{exePath}" + {lineNum} "{modulePath}'
         )
         self.uiTextEditorCommandPatternLE.setToolTip(toolTip)
 

preditor/gui/status_label.py

@@ -0,0 +1,90 @@
+from __future__ import absolute_import
+
+from collections import deque
+
+from Qt.QtCore import QPoint, QTimer
+from Qt.QtWidgets import QInputDialog, QLabel, QMenu
+
+
+class StatusLabel(QLabel):
+    """A label that shows text and an average of code execution times in popup menu."""
+
+    def __init__(self, *args, limit=5, **kwargs):
+        self.render_as_href = False
+        super(StatusLabel, self).__init__(*args, **kwargs)
+        self.times = deque(maxlen=limit)
+
+    def clear(self):
+        self.setText("")
+
+    def clearTimes(self):
+        """"""
+        self.times.clear()
+
+    def chooseLimit(self):
+        limit, success = QInputDialog.getInt(
+            self,
+            "Choose Avg length",
+            "Choose how many execution time history to keep.",
+            value=self.limit(),
+            min=1,
+            max=100,
+        )
+        if limit:
+            self.setLimit(limit)
+
+    def mouseReleaseEvent(self, event):
+        QTimer.singleShot(0, self.showMenu)
+        super(StatusLabel, self).mouseReleaseEvent(event)
+
+    def secondsText(self, seconds):
+        """Generates text to show seconds of exec time."""
+        return 'Exec: {:0.04f} Seconds'.format(seconds)
+
+    def limit(self):
+        return self.times.maxlen
+
+    def setLimit(self, limit):
+        self.times = deque(self.times, maxlen=limit)
+
+    def setText(self, text):
+        if self.render_as_href:
+            text = '<a href="showMenu">{}</a>'.format(text)
+        super(StatusLabel, self).setText(text)
+
+    def showSeconds(self, seconds):
+        self.times.append(seconds)
+        self.setText(self.secondsText(seconds[0]))
+
+    def showMenu(self):
+        menu = QMenu(self)
+        if self.times:
+            # Show the time it took to run the last X code calls
+            times = []
+            for seconds in self.times:
+                secs, cmd = seconds
+                times.append(secs)
+
+                # Add a simplified copy of the command that was run
+                cmd = cmd.strip()
+                cmds = cmd.split("\n")
+                if len(cmds) > 1 or len(cmds[0]) > 50:
+                    cmd = "{} ...".format(cmds[0][:50])
+                # Escape &'s so they dont' get turned into a shortcut'
+                cmd = cmd.replace("&", "&&")
+                menu.addAction("{}:  {}".format(self.secondsText(secs), cmd))
+
+            menu.addSeparator()
+            avg = sum(times) / len(times)
+            menu.addAction("Average: {:0.04f}s".format(avg))
+            act = menu.addAction("Clear")
+            act.triggered.connect(self.clearTimes)
+
+        menu.addSeparator()
+        act = menu.addAction("Set limit...")
+        act.triggered.connect(self.chooseLimit)
+
+        # Position the menu at the bottom of the widget
+        height = self.geometry().height()
+        pos = self.mapToGlobal(QPoint(0, height))
+        menu.popup(pos)

preditor/gui/suggest_path_quotes_dialog.py

@@ -0,0 +1,50 @@
+from __future__ import absolute_import
+
+from Qt.QtWidgets import QDialog
+
+from . import loadUi
+
+
+class SuggestPathQuotesDialog(QDialog):
+    """A dialog to suggest to enclose paths in double-quotes in the cmdTempl which is
+    used to launch an external text editor.
+    """
+
+    def __init__(self, parent, oldCmdTempl, newCmdTempl):
+        super(SuggestPathQuotesDialog, self).__init__(parent)
+        loadUi(__file__, self)
+
+        self.parentWindow = self.parent().window()
+
+        self.uiTextEditorOldCommandPatternLE.setText(oldCmdTempl)
+        self.uiTextEditorNewCommandPatternLE.setText(newCmdTempl)
+
+        toolTip = (
+            "Examples:\n"
+            'SublimeText: "{exePath}" "{modulePath}":{lineNum}\n'
+            'notepad++: "{exePath}" "{modulePath}" -n{lineNum}\n'
+            'vim: "{exePath}" + {lineNum} "{modulePath}'
+        )
+        self.uiTextEditorNewCommandPatternLE.setToolTip(toolTip)
+
+    def accept(self):
+        """Set the parentWindow's textEditorCmdTempl property from the dialog, and
+        optionally add dialog to parent's dont_ask_again list, and accept.
+        """
+
+        cmdTempl = self.uiTextEditorNewCommandPatternLE.text()
+        self.parentWindow.textEditorCmdTempl = cmdTempl
+
+        if self.uiDontAskAgainCHK.isChecked():
+            if hasattr(self.parentWindow, "dont_ask_again"):
+                self.parentWindow.dont_ask_again.append(self.objectName())
+
+        super(SuggestPathQuotesDialog, self).accept()
+
+    def reject(self):
+        """Optionally add dialog to parentWindow's dont_ask_again list, and reject"""
+        if self.uiDontAskAgainCHK.isChecked():
+            if hasattr(self.parentWindow, "dont_ask_again"):
+                self.parentWindow.dont_ask_again.append(self.objectName())
+
+        super(SuggestPathQuotesDialog, self).reject()