def __init__(self, parent=None, command="/bin/bash", font_size=14):
super().__init__(parent)
self._columns = 80
self._rows = 24
self._char_width = [0] * (self._columns + 1)
self._char_height = [0] * (self._rows + 1)
self.setFocusPolicy(Qt.StrongFocus)
self.setAutoFillBackground(False)
self.setAttribute(Qt.WA_OpaquePaintEvent, True)
self.setCursor(Qt.IBeamCursor)
font_name = "Monospace"
if sys.platform == 'darwin':
font_name = "Courier"
font = QFont(font_name)
font.setStyleHint(QFont.TypeWriter)
font.setPixelSize(font_size)
self.setFont(font)
self._session = None
self._last_update = 0
self._screen = []
self._text = []
self._cursor_rect = None
self._cursor_col = 0
self._cursor_row = 0
self._dirty = False
self._blink = False
self._press_pos = None
self._selection = None
self._clipboard = QApplication.clipboard()
self._pixmap = None
def __init__(self, parent):
QPlainTextEdit.__init__(self, parent)
# Set font to monospaced (TypeWriter)
font = QFont('')
font.setStyleHint(font.TypeWriter, font.PreferDefault)
font.setPointSize(8)
self.setFont(font)
def cb_read(result):
self.log_file.release()
self.log_file = None
self.label_download.setVisible(False)
self.progress_download.setVisible(False)
if result.error != None:
self.log('Error: ' + html.escape(str(result.error)),
bold=True)
return
try:
self.content = result.data.decode('utf-8')
except UnicodeDecodeError:
# FIXME: maybe add a encoding guesser here or try some common encodings if UTF-8 fails
self.log('Error: Log file is not UTF-8 encoded', bold=True)
return
self.button_save.setEnabled(True)
if self.continuous:
content = self.content.lstrip()
else:
content = self.content
self.edit_content.setPlainText('')
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
self.edit_content.setFont(font)
self.edit_content.setPlainText(content)
def initUI(self) -> None:
quit_action = QAction(self)
quit_action.setShortcut('Ctrl+Q')
quit_action.triggered.connect(self.close) # type: ignore
self.addAction(quit_action)
font = QFont()
font.setFamily('DejavuSansMono')
font.setStyleHint(QFont.Monospace)
self.editor.setFont(font)
self.code.setFont(font)
self.code.setReadOnly(True)
self.editor.textChanged.connect(self.ccl_changed) # type: ignore
layout = QVBoxLayout(self)
self.language_box.addItems(ccl.generators.BACKENDS)
self.language_box.currentIndexChanged.connect(self.language_changed)
self.language = self.language_box.currentText()
self.language_changed()
layout.addWidget(self.language_box)
layout.addWidget(self.editor)
layout.addWidget(self.status)
layout.addWidget(self.code)
self.setLayout(layout)
self.showMaximized()
def initUI(self):
"""Override."""
layout = QVBoxLayout()
name = QLabel("EXtra-foam")
name_ft = QFont("Helvetica")
name_ft.setStyleHint(QFont.TypeWriter)
name_ft.setPointSize(32)
name_ft.setBold(True)
name.setFont(name_ft)
doc_lb = QLabel(
"<a href = 'https://extra-foam.readthedocs.io/en/stable/'>Documentation</a>"
)
doc_ft = QFont("monospace")
doc_ft.setStyleHint(QFont.TypeWriter)
doc_ft.setPointSize(14)
doc_lb.setFont(doc_ft)
doc_lb.setOpenExternalLinks(True)
copyright_lb = QLabel(
"Copyright (C) European X-Ray Free-Electron Laser Facility GmbH. "
"All rights reserved.")
layout.addWidget(name)
layout.addStretch(10)
layout.addWidget(doc_lb)
layout.addWidget(copyright_lb)
self._cw.setLayout(layout)
def __init__(self, parent=None, command="/bin/bash", font_size=14):
super().__init__(parent)
self._columns = 80
self._rows = 24
self._char_width = [0] * (self._columns + 1)
self._char_height = [0] * (self._rows + 1)
self.setFocusPolicy(Qt.StrongFocus)
self.setAutoFillBackground(False)
self.setAttribute(Qt.WA_OpaquePaintEvent, True)
self.setCursor(Qt.IBeamCursor)
font_name = "Monospace"
if sys.platform == 'darwin':
font_name = "Courier"
font = QFont(font_name)
font.setStyleHint(QFont.TypeWriter)
font.setPixelSize(font_size)
self.setFont(font)
self._session = None
self._last_update = 0
self._screen = []
self._text = []
self._cursor_rect = None
self._cursor_col = 0
self._cursor_row = 0
self._dirty = False
self._blink = False
self._press_pos = None
self._selection = None
self._clipboard = QApplication.clipboard()
self._pixmap = None
def def_layout(self):
left_col = QVBoxLayout()
left_col.addWidget(self.user_def)
left_col.addWidget(self.random_set)
var_time_row = QHBoxLayout()
var_time_row.addWidget(self.var_time)
var_time_row.addWidget(self.var_time_edit)
var_time_row.addWidget(QLabel('Secs'))
right_col = QVBoxLayout()
right_col.addWidget(self.std_time)
right_col.addLayout(var_time_row)
right_col.addWidget(self.relaxed_time)
top_row = QLabel('Let\'s Play CountDown!!!')
top_row.setAlignment(Qt.AlignCenter)
font = QFont()
font.setPointSize(12)
font.setStyleHint(QFont.Helvetica)
top_row.setFont(font)
mid_row = QHBoxLayout()
mid_row.addLayout(left_col)
mid_row.addLayout(right_col)
main_layout = QVBoxLayout()
main_layout.addWidget(top_row)
main_layout.addLayout(mid_row)
main_layout.addWidget(self.next_page)
return main_layout
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.centralwidget = QWidget(self)
self.setWidget(self.centralwidget)
self.entity = None
self.resize(400, 200)
font = QFont()
font.setFamily("Consolas")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(10)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.position = QLineEdit(self.centralwidget)
self.rotation = QLineEdit(self.centralwidget)
self.button_savetext = QPushButton(self.centralwidget)
self.button_savetext.setText("Set Data")
self.button_savetext.setMaximumWidth(400)
self.verticalLayout.addWidget(QLabel("startPos"))
self.verticalLayout.addWidget(self.position)
self.verticalLayout.addWidget(QLabel("startDir"))
self.verticalLayout.addWidget(self.rotation)
self.verticalLayout.addWidget(self.button_savetext)
self.setWindowTitle("Edit startPos/Dir")
def cb_read(result):
self.log_file.release()
self.log_file = None
self.label_download.setVisible(False)
self.progress_download.setVisible(False)
if result.error != None:
self.log('Error: ' + html.escape(str(result.error)), bold=True)
return
try:
self.content = result.data.decode('utf-8')
except UnicodeDecodeError:
# FIXME: maybe add a encoding guesser here or try some common encodings if UTF-8 fails
self.log('Error: Log file is not UTF-8 encoded', bold=True)
return
self.button_save.setEnabled(True)
if self.continuous:
content = self.content.lstrip()
else:
content = self.content
self.edit_content.setPlainText('')
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
self.edit_content.setFont(font)
self.edit_content.setPlainText(content)
class output_box(QTextEdit):
def __init__(self, device_type):
QTextEdit.__init__(self)
self.font = QFont()
self.font.setFamily('Monospace')
self.font.setStyleHint(QFont.Monospace)
self.font.setFixedPitch(True)
self.font.setPointSize(int(12))
self.setFont(self.font)
pal = QPalette()
bgc = QColor(0, 0, 0)
pal.setColor(QPalette.Base, bgc)
textc = QColor(230, 230, 230)
pal.setColor(QPalette.Text, textc)
self.setPalette(pal)
self.device_type = device_type
self.setAcceptRichText(False)
self.setContextMenuPolicy(Qt.NoContextMenu)
#self.setOpenLinks(False)
self.setReadOnly(True)
self.setUndoRedoEnabled(False)
def add_text(self, data):
self.setUpdatesEnabled(False)
cursor = self.textCursor()
cursor.movePosition(cursor.End, cursor.MoveAnchor)
self.setTextCursor(cursor)
cursor.insertHtml(data)
self.ensureCursorVisible()
self.setUpdatesEnabled(True)
def setFontMetrics():
""" Application must be running before you mess
too much with Fonts in Qt5
"""
global SEQUENCEFONT
global SEQUENCEFONTMETRICS
global SEQUENCEFONTCHARWIDTH
global SEQUENCEFONTCHARHEIGHT
global SEQUENCEFONTEXTRAWIDTH
global SEQUENCETEXTXCENTERINGOFFSET
global SEQUENCETEXTYCENTERINGOFFSET
SEQUENCEFONT = QFont("Monaco")
if hasattr(QFont, 'Monospace'):
SEQUENCEFONT.setStyleHint(QFont.Monospace)
SEQUENCEFONT.setFixedPitch(True)
SEQUENCEFONTH = int(PATH_BASE_WIDTH / 3.)
SEQUENCEFONT.setPixelSize(SEQUENCEFONTH)
SEQUENCEFONTMETRICS = QFontMetricsF(SEQUENCEFONT)
SEQUENCEFONTCHARWIDTH = SEQUENCEFONTMETRICS.width("A")
SEQUENCEFONTCHARHEIGHT = SEQUENCEFONTMETRICS.height()
SEQUENCEFONTEXTRAWIDTH = PATH_BASE_WIDTH - SEQUENCEFONTCHARWIDTH
SEQUENCEFONT.setLetterSpacing(QFont.AbsoluteSpacing,
SEQUENCEFONTEXTRAWIDTH)
SEQUENCETEXTXCENTERINGOFFSET = SEQUENCEFONTEXTRAWIDTH / 4.
SEQUENCETEXTYCENTERINGOFFSET = PATH_BASE_WIDTH * 0.6
def create_stdout_box(
self) -> Tuple[QGroupBox, QPlainTextEdit, QSyntaxHighlighter]:
gbox = QGroupBox('Program output')
vbox = QVBoxLayout()
gbox.setLayout(vbox)
text_area = QPlainTextEdit()
vbox.addWidget(text_area)
text_area.setReadOnly(True)
text_area.setWordWrapMode(QTextOption.NoWrap)
palette = text_area.palette() # type: QPalette
palette.setColor(QPalette.Active, QPalette.Base, QColor('#1E1E1E'))
palette.setColor(QPalette.Inactive, QPalette.Base, QColor('#1E1E1E'))
text_area.setPalette(palette)
font = QFont('Monospace', 9)
font.setStyleHint(QFont.TypeWriter)
fmt = QTextCharFormat()
fmt.setFont(font)
fmt.setForeground(QColor(212, 212, 212))
text_area.setCurrentCharFormat(fmt)
doc = text_area.document()
highlighter = LogSeverityHighlighter(doc)
return gbox, text_area, highlighter
def setupUi(self):
self.resize(640, 480)
self.verticalLayout = QVBoxLayout(self)
self.textEdit = QPlainTextEdit(self)
self.closeButton = QPushButton(self)
self.copyButton = QPushButton(self)
self.verticalLayout.addWidget(self.textEdit)
self.horizontalLayout = QHBoxLayout()
self.horizontalLayout.setSizeConstraint(QLayout.SetDefaultConstraint)
spacerItem = QSpacerItem(40, 20, QSizePolicy.Expanding,
QSizePolicy.Minimum)
self.horizontalLayout.addItem(spacerItem)
self.horizontalLayout.addWidget(self.copyButton)
self.horizontalLayout.addWidget(self.closeButton)
self.verticalLayout.addLayout(self.horizontalLayout)
self.closeButton.clicked.connect(self.reject)
font = QFont(CONFIG['text_view_dialog_font'],
CONFIG['text_view_dialog_font_size'])
font.setStyleHint(QFont.Monospace)
self.textEdit.setFont(font)
self.closeButton.setText('Close')
self.copyButton.setText('Copy to clipboard')
self.textEdit.setPlainText(self.text)
self.copyButton.clicked.connect(self.copy_text)
def _get_monospace_font_impl(small=False) -> QFont:
begun = time.monotonic()
multiplier = 0.8 if small else 1.0
min_font_size = min(7, QFont().pointSize())
preferred = [
"Consolas",
"DejaVu Sans Mono",
"Monospace",
"Lucida Console",
"Monaco",
]
for name in preferred:
font = QFont(name)
if QFontInfo(font).fixedPitch():
font.setPointSize(
round(max(min_font_size,
QFont().pointSize() * multiplier)))
_logger.info(
"Selected monospace font (%.6f seconds): %r",
time.monotonic() - begun,
font.toString(),
)
return font
font = QFont()
font.setStyleHint(QFont().Monospace)
font.setFamily("monospace")
_logger.info(
"Using fallback monospace font (%.6f seconds): %r",
time.monotonic() - begun,
font.toString(),
)
return font
def __init__(self):
self.base_color = QColor(40, 41, 35)
self.lines_numbers_border = 10
self.last_save = time.time() - 1
QPlainTextEdit.__init__(self)
pallete = self.palette()
pallete.setColor(QPalette.Base, self.base_color)
pallete.setColor(QPalette.Text, QColor(255, 255, 255))
self.setPalette(pallete)
self.highlighter = PythonHighlighter(self.document())
self.rewrite = None
self.edited = None
self.lineNumberArea = LineNumberArea(self)
font = QFont()
font.setFamily("Monospace")
font.setPointSize(10)
font.setStyleHint(QFont.Monospace)
self.setFont(font)
metrics = QFontMetrics(font)
self.setTabStopWidth(metrics.width(" "))
self.blockCountChanged.connect(self.updateLineNumberAreaWidth)
self.updateRequest.connect(self.updateLineNumberArea)
#self.cursorPositionChanged.connect(self.highlightCurrentLine)
self.updateLineNumberAreaWidth()
def __init__(self, parent=None):
super(CodeEditor, self).__init__(parent)
self.numArea = LineNumArea(self)
# Binding signals to slots
self.blockCountChanged.connect(self.updateNumWidth)
self.updateRequest.connect(self.updateNum)
self.cursorPositionChanged.connect(self.highlightLine)
self.textChanged.connect(self.highlightCode)
# editor config
font = QFont()
font.setFamily("Courier")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(12)
self.setFont(font)
metrics = QFontMetrics(font)
self.setTabStopWidth(4 * metrics.width('a')) # tab width
# highlighter
self.highlighter = Highlighter(self.document())
# init
self.updateNumWidth(0)
self.highlightLine()
def __init__(self, argv):
super(MWin, self).__init__()
font = QFont()
font.setFamily("Courier")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(16)
txt = QPlainTextEdit()
txt.setFont(font)
self.setCentralWidget(txt)
#txt.setPlainText("hello central")
self.txt = txt
self.createActions()
self.createMenus()
self.statusBar = QStatusBar()
self.setStatusBar(self.statusBar)
self.current_setup = None
self.current_fcs_data = None
self.added = False
if len(argv) > 1:
self.open_bdata(argv[1])
def monospace_font() -> QFont:
"""
Returns a monospace font used in the code editor widgets.
:return: QFont instance having a monospace font.
"""
font = QFont("monospace")
font.setStyleHint(QFont.Monospace)
return font
def __init__(self, *args, **kwargs):
if "windowtype" in kwargs:
self.windowname = kwargs["windowtype"]
del kwargs["windowtype"]
else:
self.windowname = "XML Object"
super().__init__(*args, **kwargs)
self.resize(900, 500)
self.setMinimumSize(QSize(300, 300))
self.centralwidget = QWidget(self)
self.setWidget(self.centralwidget)
self.entity = None
font = QFont()
font.setFamily("Consolas")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(10)
self.dummywidget = QWidget(self)
self.dummywidget.setMaximumSize(0,0)
self.verticalLayout = QVBoxLayout(self.centralwidget)
self.verticalLayout.addWidget(self.dummywidget)
self.goto_id_action = ActionWithOwner("Go To ID", self, action_owner=self)
self.addAction(self.goto_id_action)
self.goto_shortcut = QKeySequence(Qt.CTRL+Qt.Key_G)
self.goto_id_action.setShortcut(self.goto_shortcut)
#self.goto_id_action.setShortcutContext(Qt.WidgetShortcut)
self.goto_id_action.setAutoRepeat(False)
self.goto_id_action.triggered_owner.connect(self.open_new_window)
self.textbox_xml = XMLTextEdit(self.centralwidget)
self.button_xml_savetext = QPushButton(self.centralwidget)
self.button_xml_savetext.setText("Save XML")
self.button_xml_savetext.setMaximumWidth(400)
self.textbox_xml.setLineWrapMode(QTextEdit.NoWrap)
self.textbox_xml.setContextMenuPolicy(Qt.CustomContextMenu)
self.textbox_xml.customContextMenuRequested.connect(self.my_context_menu)
metrics = QFontMetrics(font)
self.textbox_xml.setTabStopWidth(4 * metrics.width(' '))
self.textbox_xml.setFont(font)
self.verticalLayout.addWidget(self.textbox_xml)
self.verticalLayout.addWidget(self.button_xml_savetext)
self.setWindowTitle(self.windowname)
def data(self, index, role):
if role == Qt.FontRole:
global _fixed_font
if not _fixed_font:
_fixed_font = QFont("Monospace")
_fixed_font.setStyleHint(QFont.TypeWriter)
return _fixed_font
else:
return GenericTableModel.data(self, index, role)
def __init__(self, parent=None):
super().__init__(parent)
self.setWindowTitle('Prepare Training')
self.horizontal_layout = QtWidgets.QHBoxLayout(self)
self.horizontal_layout.setContentsMargins(10, 10, 10, 10)
self.horizontal_layout.setSpacing(10)
vertical_layout = QtWidgets.QVBoxLayout()
vertical_layout.setContentsMargins(10, 10, 10, 10)
vertical_layout.setSpacing(10)
label = QtWidgets.QLabel(main.load_files_window.summary_string)
font = QFont()
font.setStyleHint(QFont().Monospace)
font.setFamily('monospace')
label.setFont(font)
grid_layout = QtWidgets.QGridLayout()
self.horizontal_layout.addWidget(label)
label_model_name = QtWidgets.QLabel('Model name:')
self.line_edit_model_name = QtWidgets.QLineEdit('Peter')
label_epochs = QtWidgets.QLabel('Epochs:')
self.spinbox_epochs = QtWidgets.QSpinBox()
self.spinbox_epochs.setMaximum(999999999)
self.spinbox_epochs.setValue(20)
label_batch_size = QtWidgets.QLabel('Batch size:')
self.spinbox_batch_size = QtWidgets.QSpinBox()
self.spinbox_batch_size.setMaximum(99999)
self.spinbox_batch_size.setValue(32)
label_validation_split = QtWidgets.QLabel('Validation split:')
self.spinbox_validation_split = QtWidgets.QDoubleSpinBox()
self.spinbox_validation_split.setMaximum(1)
self.spinbox_validation_split.setSingleStep(0.1)
self.spinbox_validation_split.setValue(0.2)
label_early_stop_patience = QtWidgets.QLabel('Early stop patience:')
self.spinbox_early_stop_patience = QtWidgets.QSpinBox()
self.spinbox_early_stop_patience.setMaximum(100)
self.spinbox_early_stop_patience.setValue(10)
self.cancel_flag = False
self.compose_window = None
push_button_start_training = QtWidgets.QPushButton()
push_button_start_training.setText('Start Training')
push_button_start_training.clicked.connect(self.start_training)
grid_layout.addWidget(label_model_name, 0, 0)
grid_layout.addWidget(self.line_edit_model_name, 0, 1)
grid_layout.addWidget(label_epochs, 1, 0)
grid_layout.addWidget(self.spinbox_epochs, 1, 1)
grid_layout.addWidget(label_batch_size, 2, 0)
grid_layout.addWidget(self.spinbox_batch_size, 2, 1)
grid_layout.addWidget(label_validation_split, 3, 0)
grid_layout.addWidget(self.spinbox_validation_split, 3, 1)
grid_layout.addWidget(label_early_stop_patience, 4, 0)
grid_layout.addWidget(self.spinbox_early_stop_patience, 4, 1)
grid_layout.addWidget(push_button_start_training, 5, 1)
self.horizontal_layout.addLayout(grid_layout)
def createStatus(self):
self.status = QTextEdit(self)
self.status.setReadOnly(True)
self.status.move(5, 27)
self.status.resize(self.width()-10, self.height()-32)
font = QFont()
font.setStyleHint(QFont().Monospace)
font.setFamily("monospace")
self.status.setFont(font)
def __init__(self, parent):
self.parent = parent
QTextEdit.__init__(self)
font = QFont("courier new", 8)
font.setStyleHint(QFont.TypeWriter)
self.document().setDefaultFont(font)
self.displayPrompt()
self.initStyle()
self.addhistory()
def hex_representation(self, data: HttpMessage, context, parent_widget):
body = QPlainTextEdit()
font = QFont("Courier")
font.setStyleHint(QFont.Monospace)
body.setFont(font)
body.setPlainText(hexdump(data.body, result="return"))
body.setLineWrapMode(QPlainTextEdit.NoWrap)
body.setReadOnly(True)
return body
def _update_(self):
font = QFont()
font.setFamily('Courier')
font.setFixedPitch(True)
font.setStyleHint(QFont.Monospace)
font.setPointSize(self._font_size)
self.setFont(font)
self.setTabStopWidth(self._tab_stop_width *
self.fontMetrics().width(' '))
def getMonospaceFont() -> QFont:
font = QFont("monospace")
if isFixedPitch(font): return font
font.setStyleHint(QFont.Monospace)
if isFixedPitch(font): return font
font.setStyleHint(QFont.TypeWriter)
if isFixedPitch(font): return font
font.setFamily("courier")
if isFixedPitch(font): return font
return font
def __build_text_browser():
"""Build a text browser."""
edit = QTextBrowser()
edit.setReadOnly(True)
edit.setOpenExternalLinks(True)
font = QFont('Courier')
font.setStyleHint(QFont.Monospace)
font.setPointSize(11)
font.setFixedPitch(True)
edit.setFont(font)
return edit
def get_optimal_font(family_font: str, w, h, text: str) -> QFont:
font = QFont(family_font)
font.setStyleHint(QFont.Courier, QFont.PreferAntialias)
metrics = QFontMetrics(font)
# SOURCE: https://github.com/gil9red/SimplePyScripts/blob/add91e36e1ee59b3956b9fafdcffc9f4ff10ed3d/qt__pyqt__pyside__pyqode/pyqt__QPainter__draw_table.py#L98
factor = w / metrics.boundingRect(0, 0, w, h, Qt.AlignCenter, text).width()
if factor < 1 or factor > 1.25:
font.setPointSizeF(font.pointSizeF() * factor)
return font
def __init__(self, source, parent=None):
super(CompiledView, self).__init__(parent)
self.setWindowTitle("Compiled view")
self.lay = QVBoxLayout()
self.code_area = QTextEdit()
font = QFont("Monospace")
font.setStyleHint(QFont.TypeWriter)
self.code_area.setFont(font)
self.code_area.setText(source)
self.lay.addWidget(self.code_area)
self.setLayout(self.lay)
self.setMinimumWidth(600)
def letterSymbol(self, letter):
sym = QPainterPath()
font = QFont()
font.setStyleHint(QFont.SansSerif, QFont.PreferAntialias)
font.setPointSize(12)
sym.addText(0, 0, font, letter)
# Scale symbol to unit square
box = sym.boundingRect()
scale = 1. / max(box.width(), box.height())
tr = QTransform().scale(scale, scale)
# Center symbol on (0, 0)
tr.translate(-box.x() - box.width() / 2., -box.y() - box.height() / 2.)
return tr.map(sym)
def get_monospace_font():
preferred = ['Consolas', 'DejaVu Sans Mono', 'Monospace', 'Lucida Console', 'Monaco']
for name in preferred:
font = QFont(name)
if QFontInfo(font).fixedPitch():
logger.debug('Preferred monospace font: %r', font.toString())
return font
font = QFont()
font.setStyleHint(QFont().Monospace)
font.setFamily('monospace')
logger.debug('Using fallback monospace font: %r', font.toString())
return font
def get_monospace_font():
preferred = ['Consolas', 'DejaVu Sans Mono', 'Monospace', 'Lucida Console', 'Monaco']
for name in preferred:
font = QFont(name)
if QFontInfo(font).fixedPitch():
logger.debug('Preferred monospace font: %r', font.toString())
return font
font = QFont()
font.setStyleHint(QFont().Monospace)
font.setFamily('monospace')
logger.debug('Using fallback monospace font: %r', font.toString())
return font
def __init__(self):
QMainWindow.__init__(self)
Ui_MainWindow.setupUi(self, self)
self.editFile = File(self, None)
self.editFile.updated.connect(self.editFileUpdated)
# monospace font
font = QFont('')
font.setStyleHint(QFont.TypeWriter)
font.setKerning(True)
self.inputBox.setFont(font)
self.resultDock.setTitleBarWidget(QWidget())
self.translator = Translator()
def __init__(self, display_name, absolute_name, tab, deletable=True):
self.display_name = display_name # is unique
self.absolute_name = absolute_name # is also unique
self.tab = tab
self.deletable = deletable
self.index = -1
self.modified = False
self.content = None
self.edit = QPlainTextEdit()
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
self.edit.setWordWrapMode(QTextOption.NoWrap)
self.edit.setFont(font)
self.edit.textChanged.connect(self.check_content)
def __init__(self, *args, **kwargs):
super(ObjectInspector, self).__init__(*args, **kwargs)
self._selected_widget = None
self._ui = Ui_ObjectInspector()
self._ui.setupUi(self)
# Make everything monospace.
font = QFont('Monospace')
font.setStyleHint(QFont.TypeWriter)
self._ui.teInspectionResults.setFont(font)
# Register signals.
self._update_key = QShortcut(QKeySequence(Qt.Key_F7), self)
self._ui.btnSelectParent.released.connect(self.select_parent)
self._update_key.activated.connect(self.update_inspection)
def set_font_family(self, name, value):
"""Set the given QWebSettings/QWebEngineSettings font family.
With None (the default), QFont is used to get the default font for the
family.
Return:
True if there was a change, False otherwise.
"""
assert value is not configutils.UNSET
family = self._FONT_FAMILIES[name]
if value is None:
font = QFont()
font.setStyleHint(self._FONT_TO_QFONT[family])
value = font.defaultFamily()
old_value = self._settings.fontFamily(family)
self._settings.setFontFamily(family, value)
return value != old_value
def readSettings(self):
font = textformats.formatData('editor').font
self.diff.setFont(font)
diffFont = QFont("Monospace")
diffFont.setStyleHint(QFont.TypeWriter)
self.uni_diff.setFont(diffFont)
def chooseMonospaceFont():
font = QFont('monospace')
font.setStyleHint(QFont.TypeWriter)
return font
def setup_fonts(self):
font = QFont("mono")
font.setStyleHint(QFont.Monospace)
font.setPixelSize(12)
self.setFont(font)
def initUI(self):
self.centralWidget = QWidget()
self.setCentralWidget(self.centralWidget)
self.receivedTextEdit = QTextEdit()
self.receivedTextEdit.setAcceptRichText(False)
monospaceFont = QFont("Monospace")
monospaceFont.setStyleHint(QFont.Monospace)
self.receivedTextEdit.setFont(monospaceFont)
playExerciseButton = QPushButton("Play exercise text")
playExerciseButton.clicked.connect(self.playExercise)
stopButton = QPushButton("Stop playing")
stopButton.clicked.connect(self.stopPlaying)
validateButton = QPushButton("Check input / Generate next exercise")
validateButton.clicked.connect(self.checkInput)
self.wpmLineEdit = QLineEdit("20")
wpmLabel = QLabel("WPM")
self.ewpmLineEdit = QLineEdit("15")
ewpmLabel = QLabel("effective WPM")
self.freqLineEdit = QLineEdit("800")
freqLabel = QLabel("Frequency (Hz)")
self.durationLineEdit = QLineEdit("1")
durationLabel = QLabel("Duration (min)")
lessonBox = QHBoxLayout()
lessonBox.setAlignment(Qt.AlignLeft)
lessonCombo = QComboBox()
lessonCombo.setMaximumWidth(75)
lessonCombo.addItem("1 - K M")
for lesson in range(2, len(KOCH_LETTERS)):
lessonCombo.addItem(str(lesson) + " - " + KOCH_LETTERS[lesson])
lessonCombo.setCurrentIndex(self.lesson-1)
lessonCombo.currentIndexChanged.connect(self.newLessonSelected)
lessonIdLabel = QLabel("Lesson:")
lessonIdLabel.setMaximumWidth(50)
self.lessonLabel = QLabel(' '.join(KOCH_LETTERS[:self.lesson+1]))
lessonBox.addWidget(lessonIdLabel)
lessonBox.addWidget(lessonCombo)
lessonBox.addWidget(self.lessonLabel)
grid = QGridLayout()
grid.setSpacing(10)
grid.addWidget(self.receivedTextEdit, 1, 1, 7, 1)
grid.addWidget(playExerciseButton, 1, 2, 1, 2)
grid.addWidget(stopButton, 2, 2, 1, 2)
grid.addWidget(validateButton, 3, 2, 1, 2)
grid.addWidget(self.wpmLineEdit, 4, 2)
grid.addWidget(wpmLabel, 4, 3)
grid.addWidget(self.ewpmLineEdit, 5, 2)
grid.addWidget(ewpmLabel, 5, 3)
grid.addWidget(self.freqLineEdit, 6, 2)
grid.addWidget(freqLabel, 6, 3)
grid.addWidget(self.durationLineEdit, 7, 2)
grid.addWidget(durationLabel, 7, 3)
grid.addLayout(lessonBox, 8, 1, 1, 3)
self.centralWidget.setLayout(grid)
self.setWindowTitle('PyMorsetrainer')
self.show()
class tab_terminal(QWidget,tab_base):
def __init__(self):
QWidget.__init__(self)
self.tab=QTabWidget()
self.vbox=QHBoxLayout()
self.vbox.addWidget(self.tab)
self.usage=cpu_usage()
self.vbox.addWidget(self.usage)
self.setLayout(self.vbox)
def dataReady(self,i):
cursor = self.terminals[i].textCursor()
cursor.movePosition(cursor.End)
data=str(self.process[i].readAll())
data=data[2:-1]
cursor.insertHtml(data)
self.terminals[i].ensureCursorVisible()
def run(self,path,command):
for i in range(0,self.cpus):
if self.process[i].state()==QProcess.NotRunning:
cursor = self.terminals[i].textCursor()
cursor.insertHtml("Running:"+command+"<br>")
self.process[i].setWorkingDirectory(path)
self.process[i].start(command)
return
print("I could not find a free cpu to run the command on")
def init(self):
self.cpus=multiprocessing.cpu_count()
self.tab.setTabsClosable(True)
self.tab.setMovable(True)
self.tab.setTabBar(QHTabBar())
self.tab.setTabPosition(QTabWidget.West)
self.font = QFont()
self.font.setFamily('Monospace')
self.font.setStyleHint(QFont.Monospace)
self.font.setFixedPitch(True)
self.font.setPointSize(int(12))
self.terminals=[]
self.process=[]
for i in range(0,self.cpus):
term=QTextEdit()
term.setFont(self.font)
pal = QPalette()
bgc = QColor(0, 0, 0)
pal.setColor(QPalette.Base, bgc)
textc = QColor(230, 230, 230)
pal.setColor(QPalette.Text, textc)
term.setPalette(pal)
proc=QProcess(self)
proc.readyRead.connect(functools.partial(self.dataReady,i))
self.process.append(proc)
self.terminals.append(term)
self.tab.addTab(term,"cpu "+str(i))
def help(self):
my_help_class.help_set_help(["command.png","<big><b>The terminal window</b></big>\nThe model will run in this window. You can also use it to enter bash commands."])
def initUI(self):
self.centralWidget = QWidget()
self.setCentralWidget(self.centralWidget)
self.receivedTextEdit = QTextEdit()
self.receivedTextEdit.setAcceptRichText(False)
monospaceFont = QFont("Monospace")
monospaceFont.setStyleHint(QFont.Monospace)
self.receivedTextEdit.setFont(monospaceFont)
playExerciseButton = QPushButton("Play exercise text")
playExerciseButton.clicked.connect(self.playExercise)
stopButton = QPushButton("Stop playing")
stopButton.clicked.connect(self.stopPlaying)
validateButton = QPushButton("Check input / Generate next exercise")
validateButton.clicked.connect(self.checkInput)
self.wpmLineEdit = QLineEdit(self.settings.value("wpm"))
self.wpmLineEdit.textChanged.connect(functools.partial(self.saveChangedText, self.wpmLineEdit, "wpm"))
wpmLabel = QLabel("WPM")
self.ewpmLineEdit = QLineEdit(self.settings.value("effectiveWpm"))
self.ewpmLineEdit.textChanged.connect(functools.partial(self.saveChangedText, self.ewpmLineEdit, "effectiveWpm"))
ewpmLabel = QLabel("effective WPM")
self.freqLineEdit = QLineEdit(self.settings.value("frequency"))
self.freqLineEdit.textChanged.connect(functools.partial(self.saveChangedText, self.freqLineEdit, "frequency"))
freqLabel = QLabel("Frequency (Hz)")
self.durationLineEdit = QLineEdit(self.settings.value("duration"))
self.durationLineEdit.textChanged.connect(functools.partial(self.saveChangedText, self.durationLineEdit, "duration"))
durationLabel = QLabel("Duration (min)")
self.lessonGrid = QGridLayout()
lessonCombo = QComboBox()
lessonCombo.setStyleSheet("combobox-popup: 0;")
lessonCombo.addItem("1 - K M")
for lesson in range(2, len(KOCH_LETTERS)):
lessonCombo.addItem(str(lesson) + " - " + KOCH_LETTERS[lesson])
lessonCombo.setCurrentIndex(int(self.settings.value("currentLesson"))-1)
lessonCombo.currentIndexChanged.connect(self.newLessonSelected)
lessonIdLabel = QLabel("Lesson:")
lessonBox = QHBoxLayout()
lessonBox.addWidget(lessonIdLabel)
lessonBox.addWidget(lessonCombo)
lessonBox.addStretch(-1)
self.createLessonLetterButtons(self.lessonGrid)
mainLayout = QVBoxLayout()
inputAndParameters = QHBoxLayout()
parameterField = QVBoxLayout()
inputAndParameters.addWidget(self.receivedTextEdit, stretch=1)
self.receivedTextEdit.setSizePolicy(QSizePolicy(QSizePolicy.Expanding, QSizePolicy.MinimumExpanding))
inputAndParameters.addLayout(parameterField, stretch=0)
parameterField.addWidget(playExerciseButton)
parameterField.addWidget(stopButton)
parameterField.addWidget(validateButton)
parameterGrid = QGridLayout()
parameterGrid.addWidget(self.wpmLineEdit, 0, 0)
parameterGrid.addWidget(wpmLabel, 0, 1)
parameterGrid.addWidget(self.ewpmLineEdit, 1, 0)
parameterGrid.addWidget(ewpmLabel, 1, 1)
parameterGrid.addWidget(self.freqLineEdit, 2, 0)
parameterGrid.addWidget(freqLabel, 2, 1)
parameterGrid.addWidget(self.durationLineEdit, 3, 0)
parameterGrid.addWidget(durationLabel, 3, 1)
parameterField.addLayout(parameterGrid)
parameterField.insertSpacing(-1, 15)
parameterField.addLayout(lessonBox)
parameterField.insertStretch(-1)
mainLayout.addLayout(inputAndParameters)
mainLayout.addLayout(self.lessonGrid)
self.centralWidget.setLayout(mainLayout)
self.setWindowTitle('PyMorsetrainer')
self.show()
def set_default(self, settings=None):
font = QFont()
font.setStyleHint(self._qfont)
value = font.defaultFamily()
self._set(value, settings=settings)
def __init__(self, parent=None):
super(MainWindow, self).__init__(parent)
self.ui = Ui_MainWindow()
self.ui.setupUi(self)
# Left Browser tabs
self.ui.tabWidgetBrowser.removeTab(1)
self.ui.tabWidgetBrowser.removeTab(1)
self.ui.tabWidgetBrowser.setTabsClosable(True)
self.ui.tabWidgetBrowser.tabCloseRequested.connect(self.closeBrowserTab)
self.ui.tabWidgetBrowser.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetBrowser))
# Left tree views
self.fileTreeModel = QFileSystemModel(self)
self.fileTreeModel.setRootPath(QDir.currentPath() + QDir.separator() + 'test')
self.ui.treeViewFile.setModel(self.fileTreeModel)
self.ui.treeViewFile.setRootIndex(self.fileTreeModel.index(QDir.currentPath() + QDir.separator() + 'test'))
self.ui.treeViewFile.hideColumn(1)
self.ui.treeViewFile.hideColumn(2)
self.ui.treeViewFile.hideColumn(3)
self.ui.treeViewFile.doubleClicked.connect(self.openFileFromTree)
self.ui.treeViewFile.setAnimated(True)
self.ui.treeViewSyntax.setAnimated(True)
self.ui.treeViewToken.setAnimated(True)
self.ui.treeViewFile.setHeaderHidden(True)
self.ui.treeViewSyntax.setHeaderHidden(True)
self.ui.treeViewToken.setHeaderHidden(True)
# Editor tabs
self.currentEditor = self.ui.codeEditor
self.currentEditor.file = None
self.currentEditorTab = self.ui.tabEditor
self.openedEditors = [self.currentEditor]
self.openedEditorTabs = [self.currentEditorTab]
self.currentEditor.setFocus() # set focus
self.ui.tabWidgetEditor.tabCloseRequested.connect(self.closeEditorTab)
self.ui.tabWidgetEditor.tabBarClicked.connect(self.switchEditorTab)
self.ui.tabWidgetEditor.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetEditor))
# Bottom console
font = QFont()
font.setFamily("Courier")
font.setStyleHint(QFont.Monospace)
font.setFixedPitch(True)
font.setPointSize(10)
self.ui.console.setFont(font)
self.ui.console.setReadOnly(True)
self.waitInputCond = QWaitCondition()
self.oldConsoleText = None
# Bottom output tabs
self.ui.tabWidgetOutput.hide()
self.ui.tabWidgetOutput.tabCloseRequested.connect(self.closeOutputTab)
self.ui.tabWidgetOutput.tabBarDoubleClicked.connect(lambda: self.maximizeTabs(self.ui.tabWidgetOutput))
self.ui.tabWidgetOutput.setTabText(0, 'Console')
# Previous opened tabs,for maximizing
self.preOpenedTabs = None
# Initial size of inner splitter
self.ui.splitterInner.setSizes([180, 459 * 2 - 180])
# Menu "File"
self.ui.actionOpen.triggered.connect(self.openFile)
self.ui.actionNew.triggered.connect(self.newFile)
self.ui.actionSave.triggered.connect(self.saveFile)
self.ui.actionSaveAs.triggered.connect(self.saveFileAs)
self.ui.actionQuit.triggered.connect(self.close)
# Menu "Edit"
self.connectMenuEditSlots()
# Menu "View"
self.ui.menuView.triggered.connect(self.manageMenuView)
self.ui.actionAboutQt.triggered.connect(QApplication.aboutQt)
# Menu "Run"
self.ui.actionRun.triggered.connect(self.run)
self.ui.actionBuild.triggered.connect(self.runCompile)
self.ui.actionShowStable.triggered.connect(self.runSemantic)
self.ui.actionRunParser.triggered.connect(self.runParser)
self.ui.actionRunLexer.triggered.connect(self.runLexer)
def __init__(self):
"""
Create the main window.
:return:
"""
super(RF_Qt, self).__init__()
# Define variables
self.fnt_styles = ["Regular", "Italic", "Bold", "Bold Italic"]
self.fnt_sty_combo_list = []
self.fnt_file_name_list = []
self.font_files = None
self.font_info = FontInfo()
# Create a QProcess object, and connect it to appropriate slots
self.cli_process = QProcess(self)
self.cli_process.setProcessChannelMode(QProcess.MergedChannels)
self.cli_process.readyRead.connect(self.read_proc_output)
self.cli_process.started.connect(self.manage_proc)
self.cli_process.finished.connect(self.manage_proc)
self.cli_process.error.connect(self.manage_proc)
# Style for all groupbox labels
gb_style = "QGroupBox { font-weight: bold; }"
# Top level layout manager for the window.
win_layout = QVBoxLayout()
gb_fnt_files = QGroupBox("Font Files")
gb_fnt_files.setStyleSheet(gb_style)
grid_f_f = QGridLayout()
grid_pos = 0
# Font Files and styles #
# Create a grid of font names with their respective font style combo boxes
for i in range(len(self.fnt_styles)):
self.fnt_file_name_list.append(QLabel("Load font file..."))
cmb = QComboBox()
cmb.addItem("")
cmb.addItems(self.fnt_styles)
cmb.setEnabled(False)
cmb.setToolTip(
"<qt/>If not automatically detected when the font is added, allows you to select what font "
"sub-family the font file belongs to"
)
self.fnt_sty_combo_list.append(cmb)
row, col = helper.calc_grid_pos(grid_pos, 2)
grid_f_f.addWidget(self.fnt_file_name_list[i], row, col)
grid_pos += 1
row, col = helper.calc_grid_pos(grid_pos, 2)
grid_f_f.addWidget(self.fnt_sty_combo_list[i], row, col)
grid_pos += 1
grid_f_f.setColumnStretch(0, 1)
gb_fnt_files.setLayout(grid_f_f)
win_layout.addWidget(gb_fnt_files)
# New Font Name #
gb_fnt_name = QGroupBox("Font Family Name")
gb_fnt_name.setStyleSheet(gb_style)
hb_fnt_name = QHBoxLayout()
self.new_fnt_name = QLineEdit()
self.new_fnt_name.setToolTip("Enter a name for the modified font.")
self.new_fnt_name.textEdited[str].connect(self.set_family_name)
hb_fnt_name.addWidget(self.new_fnt_name)
gb_fnt_name.setLayout(hb_fnt_name)
win_layout.addWidget(gb_fnt_name)
# Options #
hb_options = QHBoxLayout()
## Kerning, Panose, Alt. Name ##
gb_basic_opt = QGroupBox("Basic Options")
gb_basic_opt.setStyleSheet(gb_style)
hb_basic_opt = QHBoxLayout()
self.basic_opt_list = []
basic_tooltips = (
"<qt/>Some readers and software require 'legacy', or 'old style' kerning to be "
"present for kerning to work.",
"<qt/>Kobo readers can get confused by PANOSE settings. This option sets all "
"PANOSE information to 0, or 'any'",
"<qt/>Some fonts have issues with renaming. If the generated font does not have "
"the same internal font name as you entered, try enabling this option.",
)
for opt, tip in zip(("Legacy Kerning", "Clear PANOSE", "Alt. Name"), basic_tooltips):
self.basic_opt_list.append(QCheckBox(opt))
self.basic_opt_list[-1].setToolTip(tip)
hb_basic_opt.addWidget(self.basic_opt_list[-1])
gb_basic_opt.setLayout(hb_basic_opt)
hb_options.addWidget(gb_basic_opt)
## Hinting ##
gb_hint_opt = QGroupBox("Hinting Option")
gb_hint_opt.setStyleSheet(gb_style)
hb_hint_opt = QHBoxLayout()
self.hint_opt_list = []
hint_tooltips = (
"<qt/>Keep font hinting as it exists in the orginal font files.<br />"
"In most cases, this will look fine on most ebook reading devices.",
'<qt/>Some fonts are manually, or "hand" hinted for specific display types (such as LCD). '
"These fonts may not look good on other display types such as e-ink, therefore they can be "
"removed.",
"<qt/>If you don't like the original hinting, but you want your font to be hinted, "
"this option will auto hint your font.",
)
for opt, tip in zip(("Keep Existing", "Remove Existing", "AutoHint"), hint_tooltips):
self.hint_opt_list.append(QRadioButton(opt))
self.hint_opt_list[-1].setToolTip(tip)
self.hint_opt_list[-1].toggled.connect(self.set_hint)
hb_hint_opt.addWidget(self.hint_opt_list[-1])
self.hint_opt_list[0].setChecked(Qt.Checked)
gb_hint_opt.setLayout(hb_hint_opt)
hb_options.addWidget(gb_hint_opt)
win_layout.addLayout(hb_options)
## Darken ##
gb_dark_opt = QGroupBox("Darken Options")
gb_dark_opt.setStyleSheet(gb_style)
hb_dark_opt = QHBoxLayout()
self.darken_opt = QCheckBox("Darken Font")
self.darken_opt.setToolTip("<qt/>Darken, or add weight to a font to make it easier to read on e-ink screens.")
self.darken_opt.toggled.connect(self.set_darken_opt)
hb_dark_opt.addWidget(self.darken_opt)
self.mod_bearing_opt = QCheckBox("Modify Bearings")
self.mod_bearing_opt.setToolTip(
"<qt/>By default, adding weight to a font increases glyph width. Enable this "
"option to set the glyph width to be roughly equal to the original.<br/><br/>"
"WARNING: This reduces the spacing between glyphs, and should not be used if "
"you have added too much weight."
)
self.mod_bearing_opt.toggled.connect(self.set_mod_bearing)
self.mod_bearing_opt.setEnabled(False)
hb_dark_opt.addWidget(self.mod_bearing_opt)
self.lbl = QLabel("Darken Amount:")
self.lbl.setEnabled(False)
hb_dark_opt.addWidget(self.lbl)
self.darken_amount_opt = QSlider(Qt.Horizontal)
self.darken_amount_opt.setMinimum(1)
self.darken_amount_opt.setMaximum(50)
self.darken_amount_opt.setValue(12)
self.darken_amount_opt.setEnabled(False)
self.darken_amount_opt.setToolTip(
"<qt/>Set the amount to darken a font by. 50 is considered turning a "
"regular weight font into a bold weight font. It is not recommended to "
"darken a font that much however."
)
self.darken_amount_opt.valueChanged[int].connect(self.set_darken_amount)
hb_dark_opt.addWidget(self.darken_amount_opt)
self.darken_amount_lab = QLabel()
self.darken_amount_lab.setText(str(self.darken_amount_opt.value()))
self.darken_amount_lab.setEnabled(False)
hb_dark_opt.addWidget(self.darken_amount_lab)
gb_dark_opt.setLayout(hb_dark_opt)
win_layout.addWidget(gb_dark_opt)
# Buttons #
hb_buttons = QHBoxLayout()
# hb_buttons.addStretch()
self.gen_ttf_btn = QPushButton("Generate TTF")
self.gen_ttf_btn.setEnabled(False)
self.gen_ttf_btn.setToolTip(
"<qt/>Generate a new TrueType font based on the options chosen in this program. "
"<br /><br />"
"The new fonts are saved in a directory of your choosing."
)
self.gen_ttf_btn.clicked.connect(self.gen_ttf)
hb_buttons.addWidget(self.gen_ttf_btn)
self.load_font_btn = QPushButton("Load Fonts")
self.load_font_btn.setToolTip("<qt/>Load font files to modify.")
self.load_font_btn.clicked.connect(self.load_fonts)
hb_buttons.addWidget(self.load_font_btn)
self.prog_bar = QProgressBar()
self.prog_bar.setRange(0, 100)
hb_buttons.addWidget(self.prog_bar)
win_layout.addLayout(hb_buttons)
# Output Log #
gb_log_win = QGroupBox("Log Window")
gb_log_win.setStyleSheet(gb_style)
vb_log = QVBoxLayout()
out_font = QFont("Courier")
out_font.setStyleHint(QFont.Monospace)
self.log_win = QTextEdit()
self.log_win.setAcceptRichText(False)
self.log_win.setFont(out_font)
vb_log.addWidget(self.log_win)
gb_log_win.setLayout(vb_log)
win_layout.addWidget(gb_log_win)
# Show Window #
self.setCentralWidget(QWidget(self))
self.centralWidget().setLayout(win_layout)
self.setWindowTitle("Readify Font")
self.show()
# Check if fontforge is actually in users PATH. If it isn't, prompt user to provice a location
self.ff_path = helper.which("fontforge")
if not self.ff_path:
self.set_ff_path()
OS_KEY = "Ctrl"
# Font
FONT = QFont("Source Code Pro")
if sys.platform == "darwin":
from PyQt5.QtGui import QKeySequence
from PyQt5.QtCore import Qt
FONT = QFont("Monaco")
OS_KEY = QKeySequence(Qt.CTRL).toString(QKeySequence.NativeText)
IS_MAC_OS = True
elif sys.platform == "win32":
FONT = QFont("Courier")
IS_WINDOWS = True
FONT.setStyleHint(QFont.TypeWriter)
FONT.setPointSize(12)
FONT_ANTIALIASING = True
def detect_python_path():
if (IS_WINDOWS and PYTHON_EXEC_CONFIGURED_BY_USER) or not IS_WINDOWS:
return []
suggested = []
dirs = []
try:
drives = [QDir.toNativeSeparators(d.absolutePath())
for d in QDir.drives()]
