PrEditor 0.4.0__py2.py3-none-any.whl → 0.6.0__py2.py3-none-any.whl

preditor/__init__.py

@@ -113,6 +113,11 @@ def configure(name, parent_callback=None, excepthook=True, logging=True, streams
         preditor.debug.BlurExcepthook.install()
 
 
+def get_core_name():
+    """Returns the configured core_name or DEFAULT_CORE_NAME."""
+    return _global_config.get('core_name', DEFAULT_CORE_NAME)
+
+
 def launch(run_workbox=False, app_id=None, name=None, standalone=False):
     """Launches the preditor gui creating the QApplication instance if not
     already created.

preditor/gui/console.py

@@ -9,17 +9,20 @@ import sys
 import time
 import traceback
 from builtins import str as text
+from fractions import Fraction
+from functools import partial
 
 import __main__
 from Qt import QtCompat
-from Qt.QtCore import QPoint, Qt
+from Qt.QtCore import QPoint, Qt, QTimer
 from Qt.QtGui import QColor, QFontMetrics, QTextCharFormat, QTextCursor, QTextDocument
-from Qt.QtWidgets import QAction, QApplication, QTextEdit
+from Qt.QtWidgets import QAbstractItemView, QAction, QApplication, QTextEdit
 
 from .. import debug, settings, stream
 from ..streamhandler_helper import StreamHandlerHelper
 from .codehighlighter import CodeHighlighter
 from .completer import PythonCompleter
+from .suggest_path_quotes_dialog import SuggestPathQuotesDialog
 
 
 class ConsolePrEdit(QTextEdit):
@@ -47,6 +50,7 @@ class ConsolePrEdit(QTextEdit):
         # If still using a #
         self._outputPrompt = '#Result: '
         # Method used to update the gui when code is executed
+        self.clearExecutionTime = None
         self.reportExecutionTime = None
 
         self._firstShow = True
@@ -102,9 +106,46 @@ class ConsolePrEdit(QTextEdit):
         self.clickPos = None
         self.anchor = None
 
+        # Make sure console cursor is visible. It can get it's width set to 0 with
+        # unusual(ie not 100%) os display scaling.
+        if not self.cursorWidth():
+            self.setCursorWidth(1)
+
+    def doubleSingleShotSetScrollValue(self, origPercent):
+        """This double QTimer.singleShot monkey business seems to be the only way
+        to get scroll.maximum() to update properly so that we calc newValue
+        correctly. It's quite silly. Apparently, the important part is that
+        calling scroll.maximum() has had a pause since the font had been set.
+        """
+
+        def singleShotSetScrollValue(self, origPercent):
+            scroll = self.verticalScrollBar()
+            maximum = scroll.maximum()
+            if maximum is not None:
+                newValue = round(origPercent * maximum)
+                QTimer.singleShot(1, partial(scroll.setValue, newValue))
+
+        # The 100 ms timer amount is somewhat arbitrary. It must be more than
+        # some value to work, but what that value is is unknown, and may change
+        # under various circumstances. Briefly disable updates for smoother transition.
+        self.setUpdatesEnabled(False)
+        try:
+            QTimer.singleShot(100, partial(singleShotSetScrollValue, self, origPercent))
+        finally:
+            self.setUpdatesEnabled(True)
+
     def setConsoleFont(self, font):
         """Set the console's font and adjust the tabStopWidth"""
+
+        # Capture the scroll bar's current position (by percentage of max)
+        origPercent = None
+        scroll = self.verticalScrollBar()
+        if scroll.maximum():
+            origPercent = Fraction(scroll.value(), scroll.maximum())
+
+        # Set console and completer popup fonts
         self.setFont(font)
+        self.completer().popup().setFont(font)
 
         # Set the setTabStopWidth for the console's font
         tab_width = 4
@@ -117,6 +158,10 @@ class ConsolePrEdit(QTextEdit):
         fontPixelWidth = QFontMetrics(font).width(" ")
         self.setTabStopWidth(fontPixelWidth * tab_width)
 
+        # Scroll to same relative position where we started
+        if origPercent is not None:
+            self.doubleSingleShotSetScrollValue(origPercent)
+
     def mousePressEvent(self, event):
         """Overload of mousePressEvent to capture click position, so on release, we can
         check release position. If it's the same (ie user clicked vs click-drag to
@@ -213,6 +258,23 @@ class ConsolePrEdit(QTextEdit):
             return
 
         if modulePath:
+            # Check if cmdTempl filepaths aren't wrapped in double=quotes to handle
+            # spaces. If not, suggest to user to update the template, offering the
+            # suggested change.
+            pattern = r"(?<!\")({\w+Path})(?!\")"
+            repl = r'"\g<1>"'
+            quotedCmdTempl = re.sub(pattern, repl, cmdTempl)
+            if quotedCmdTempl != cmdTempl:
+                # Instantiate dialog to maybe show (unless user previously chose "Don't
+                # ask again")
+                dialog = SuggestPathQuotesDialog(
+                    self.window(), cmdTempl, quotedCmdTempl
+                )
+                self.window().maybeDisplayDialog(dialog)
+
+            # Refresh cmdTempl in case user just had it changed.
+            cmdTempl = window.textEditorCmdTempl
+
             # Attempt to create command from template and run the command
             try:
                 command = cmdTempl.format(
@@ -317,6 +379,8 @@ class ConsolePrEdit(QTextEdit):
         self._foregroundColor = color
 
     def executeString(self, commandText, filename='<ConsolePrEdit>', extraPrint=True):
+        if self.clearExecutionTime is not None:
+            self.clearExecutionTime()
         cursor = self.textCursor()
         cursor.select(QTextCursor.BlockUnderCursor)
         line = cursor.selectedText()
@@ -333,18 +397,27 @@ class ConsolePrEdit(QTextEdit):
         # exec which has no Return.
         wasEval = False
         startTime = time.time()
+
         try:
             compiled = compile(commandText, filename, 'eval')
             wasEval = True
         except Exception:
             compiled = compile(commandText, filename, 'exec')
-        if wasEval:
-            cmdresult = eval(compiled, __main__.__dict__, __main__.__dict__)
-        else:
-            exec(compiled, __main__.__dict__, __main__.__dict__)
+
+        # We wrap in try / finally so that elapsed time gets updated, even when an
+        # exception is raised.
+        try:
+            if wasEval:
+                cmdresult = eval(compiled, __main__.__dict__, __main__.__dict__)
+            else:
+                exec(compiled, __main__.__dict__, __main__.__dict__)
+        finally:
+            # Report the total time it took to execute this code.
+            if self.reportExecutionTime is not None:
+                delta = time.time() - startTime
+                self.reportExecutionTime((delta, commandText))
 
         # Provide user feedback when running long code execution.
-        delta = time.time() - startTime
         if self.flash_window and self.flash_time and delta >= self.flash_time:
             if settings.OS_TYPE == "Windows":
                 try:
@@ -356,9 +429,6 @@ class ConsolePrEdit(QTextEdit):
                     hwnd = int(self.flash_window.winId())
                     utils.flash_window(hwnd)
 
-        # Report the total time it took to execute this code.
-        if self.reportExecutionTime is not None:
-            self.reportExecutionTime(delta)
         return cmdresult, wasEval
 
     def executeCommand(self):
@@ -478,6 +548,17 @@ class ConsolePrEdit(QTextEdit):
 
         completer = self.completer()
 
+        # Define prefix so we can determine if the exact prefix is in
+        # completions and highlight it. We must manually add the currently typed
+        # character, or remove it if backspace or delete has just been pressed.
+        key = event.text()
+        _, prefix = completer.currentObject(scope=__main__.__dict__)
+        isBackspaceOrDel = event.key() in (Qt.Key_Backspace, Qt.Key_Delete)
+        if key.isalnum() or key in ("-", "_"):
+            prefix += str(key)
+        elif isBackspaceOrDel and prefix:
+            prefix = prefix[:-1]
+
         if completer and event.key() in (
             Qt.Key_Backspace,
             Qt.Key_Delete,
@@ -560,9 +641,30 @@ class ConsolePrEdit(QTextEdit):
                     or completer.wasCompletingCounter
                 ):
                     completer.refreshList(scope=__main__.__dict__)
-                    completer.popup().setCurrentIndex(
-                        completer.completionModel().index(0, 0)
-                    )
+
+                    model = completer.completionModel()
+                    index = model.index(0, 0)
+
+                    # If option chosen, if the exact prefix exists in the
+                    # possible completions, highlight it, even if it's not the
+                    # topmost completion.
+                    if self.window().uiHighlightExactCompletionACT.isChecked():
+                        for i in range(completer.completionCount()):
+                            completer.setCurrentRow(i)
+                            curCompletion = completer.currentCompletion()
+                            if prefix == curCompletion:
+                                index = model.index(i, 0)
+                                break
+                            elif prefix == curCompletion.lower():
+                                index = model.index(i, 0)
+                                break
+
+                    # Set completer current Row, so finishing the completer will use
+                    # correct text
+                    completer.setCurrentRow(index.row())
+
+                    # Make sure that current selection is visible, ie scroll to it
+                    completer.popup().scrollTo(index, QAbstractItemView.EnsureVisible)
 
                     # show the completer for the rect
                     rect = self.cursorRect()
@@ -640,6 +742,7 @@ class ConsolePrEdit(QTextEdit):
     def startInputLine(self):
         """create a new command prompt line"""
         self.startPrompt(self.prompt())
+        self._prevCommandIndex = 0
 
     def startPrompt(self, prompt):
         """create a new command prompt line with the given prompt
@@ -661,6 +764,11 @@ class ConsolePrEdit(QTextEdit):
 
             self.insertPlainText(inputstr)
 
+        scroll = self.verticalScrollBar()
+        maximum = scroll.maximum()
+        if maximum is not None:
+            scroll.setValue(maximum)
+
     def startOutputLine(self):
         """Create a new line to show output text."""
         self.startPrompt(self._outputPrompt)

preditor/gui/editor_chooser.py

@@ -44,7 +44,7 @@ class EditorChooser(QWidget):
         current = self.editor_name()
         self.uiWorkboxEditorDDL.blockSignals(True)
         self.uiWorkboxEditorDDL.clear()
-        for name, _ in sorted(plugins.editors()):
+        for name, _ in sorted(set(plugins.editors())):
             self.uiWorkboxEditorDDL.addItem(name)
 
         self.uiWorkboxEditorDDL.setCurrentIndex(

preditor/gui/group_tab_widget/__init__.py

@@ -110,7 +110,7 @@ class GroupTabWidget(OneTabWidget):
         # Create the first editor tab and make it visible
         editor = parent.add_new_editor(title)
         self.setCurrentIndex(self.indexOf(parent))
-
+        self.window().focusToWorkbox()
         return parent, editor
 
     def all_widgets(self):

preditor/gui/group_tab_widget/grouped_tab_widget.py

@@ -71,5 +71,8 @@ class GroupedTabWidget(OneTabWidget):
         if editor and editor.isVisible():
             editor.__show__()
 
+        if hasattr(self.window(), "setWorkboxFontBasedOnConsole"):
+            self.window().setWorkboxFontBasedOnConsole()
+
     def update_closable_tabs(self):
         self.setTabsClosable(self.count() != 1)

preditor/gui/loggerwindow.py

@@ -14,9 +14,10 @@ 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,
     QMessageBox,
     QTextBrowser,
@@ -29,6 +30,7 @@ from .. import (
     about_preditor,
     core,
     debug,
+    get_core_name,
     osystem,
     plugins,
     prefs,
@@ -59,7 +61,7 @@ class LoggerWindow(Window):
 
     def __init__(self, parent, name=None, run_workbox=False, standalone=False):
         super(LoggerWindow, self).__init__(parent=parent)
-        self.name = name if name else DEFAULT_CORE_NAME
+        self.name = name if name else get_core_name()
         self.aboutToClearPathsEnabled = False
         self._stylesheet = 'Bright'
 
@@ -75,6 +77,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
@@ -119,12 +122,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 +263,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 +287,9 @@ class LoggerWindow(Window):
             )
         )
 
+        self.setWorkboxFontBasedOnConsole()
+        self.setEditorChooserFontBasedOnConsole()
+
         self.setup_run_workbox()
 
         if not standalone:
@@ -429,7 +443,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)
@@ -506,22 +520,14 @@ class LoggerWindow(Window):
                 delta = event.angleDelta().y()
 
             # convert delta to +1 or -1, depending
-            delta = delta / abs(delta)
+            delta = delta // abs(delta)
             minSize = 5
             maxSize = 50
             font = self.console().font()
             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 +545,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 +676,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,6 +703,11 @@ 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.uiStatusLBL.showSeconds(seconds)
@@ -671,11 +727,15 @@ 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(),
@@ -693,6 +753,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,
             }
         )
 
@@ -727,6 +791,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.
@@ -776,21 +849,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))
@@ -814,7 +886,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)
 
@@ -823,6 +895,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':
@@ -833,6 +906,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()
 
@@ -842,6 +922,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()
@@ -851,10 +933,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: