def _update_model(self, completions):
"""
Creates a QStandardModel that holds the suggestion from the completion
models for the QCompleter
:param completionPrefix:
"""
# build the completion model
cc_model = QtGui.QStandardItemModel()
self._tooltips.clear()
for completion in completions:
name = completion['name']
item = QtGui.QStandardItem()
item.setData(name, QtCore.Qt.DisplayRole)
if 'tooltip' in completion and completion['tooltip']:
self._tooltips[name] = completion['tooltip']
if 'icon' in completion:
icon = completion['icon']
if isinstance(icon, list):
icon = QtGui.QIcon.fromTheme(icon[0], QtGui.QIcon(icon[1]))
else:
icon = QtGui.QIcon(icon)
item.setData(QtGui.QIcon(icon), QtCore.Qt.DecorationRole)
cc_model.appendRow(item)
try:
self._completer.setModel(cc_model)
except RuntimeError:
self._create_completer()
self._completer.setModel(cc_model)
return cc_model
def icon(theme_name='', path='', qta_name='', qta_options=None, use_qta=None):
"""
Creates an icon from qtawesome, from theme or from path.
:param theme_name: icon name in the current theme (GNU/Linux only)
:param path: path of the icon (from file system or qrc)
:param qta_name: icon name in qtawesome
:param qta_options: the qtawesome options to use for controlling icon
rendering. If None, QTA_OPTIONS are used.
:param use_qta: True to use qtawesome, False to use icon from theme/path.
None to use the global setting: USE_QTAWESOME.
:returns: QtGui.QIcon
"""
ret_val = None
if use_qta is None:
use_qta = USE_QTAWESOME
if qta_options is None:
qta_options = QTA_OPTIONS
if qta is not None and use_qta is True:
ret_val = qta.icon(qta_name, **qta_options)
else:
if theme_name and path:
ret_val = QtGui.QIcon.fromTheme(theme_name, QtGui.QIcon(path))
elif theme_name:
ret_val = QtGui.QIcon.fromTheme(theme_name)
elif path:
ret_val = QtGui.QIcon(path)
return ret_val
def _on_document_changed(self):
def flatten(results):
"""
Flattens the document structure tree as a simple sequential list.
"""
ret_val = []
for de in results:
ret_val.append(de)
for sub_d in de.children:
nd = Definition(sub_d.name, sub_d.line, sub_d.column,
sub_d.icon)
nd.name = " " + nd.name
ret_val.append(nd)
return ret_val
if not self or not self.editor:
return
mode = self.editor.modes.get('OutlineMode')
definitions = flatten(mode.definitions)
self.combo_box.clear()
if definitions:
self.combo_box.addItem(" < Select a symbol >")
else:
self.combo_box.addItem("No symbols")
for d in definitions:
try:
self.combo_box.addItem(QtGui.QIcon(d.icon), d.name, d)
except TypeError:
self.combo_box.addItem(
QtGui.QIcon.fromTheme(d.icon[0], QtGui.QIcon(d.icon[1])),
d.name, d)
self._definitions = definitions
self._sync_combo_box(TextHelper(self.editor).current_line_nbr())
def convert(name, editor, to_collapse):
ti = QtWidgets.QTreeWidgetItem()
ti.setText(0, name.name)
if isinstance(name.icon, list):
icon = QtGui.QIcon.fromTheme(name.icon[0],
QtGui.QIcon(name.icon[1]))
else:
icon = QtGui.QIcon(name.icon)
ti.setIcon(0, icon)
name.block = editor.document().findBlockByNumber(name.line)
ti.setData(0, QtCore.Qt.UserRole, name)
ti.setToolTip(0, name.description)
name.tree_item = ti
block_data = name.block.userData()
if block_data is None:
block_data = TextBlockUserData()
name.block.setUserData(block_data)
block_data.tree_item = ti
if to_collapse is not None and \
TextBlockHelper.is_collapsed(name.block):
to_collapse.append(ti)
for ch in name.children:
ti_ch, to_collapse = convert(ch, editor, to_collapse)
if ti_ch:
ti.addChild(ti_ch)
return ti, to_collapse
def __init__(self, parent):
super().__init__(parent)
self.setupUi(self)
themes = system.icon_themes()
if themes:
self.comboBoxIconTheme.addItems(themes)
else:
self.comboBoxIconTheme.hide()
self.lblIconTheme.hide()
self.tabWidget.setTabIcon(2, QtGui.QIcon.fromTheme(
'application-x-executable',
QtGui.QIcon(':/ide-icons/rc/application-x-executable.png')))
self.tabWidget.setTabIcon(1, QtGui.QIcon.fromTheme(
'applications-graphics',
QtGui.QIcon(':/ide-icons/rc/applications-graphics.png')))
self.tabWidget.setTabIcon(3, QtGui.QIcon.fromTheme(
'media-playback-start', QtGui.QIcon(':/ide-icons/rc/media-playback-start.png')))
self.buttonBox.button(self.buttonBox.Reset).clicked.connect(self.reset)
self.buttonBox.button(self.buttonBox.RestoreDefaults).clicked.connect(
self.restore_defaults)
self.checkBoxRunExtTerm.stateChanged.connect(
self.lineEditRunTerm.setEnabled)
self.checkBoxCustomPath.stateChanged.connect(
self.lineEditCompilerPath.setEnabled)
self.listWidgetColorSchemes.currentItemChanged.connect(
self.update_color_scheme_preview)
self.plainTextEdit.setPlainText(''' * Author:
* Date:
* Purpose:
* Tectonics: cobc
IDENTIFICATION DIVISION.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
PROGRAM-ID. YOUR-PROGRAM-NAME.
ENVIRONMENT DIVISION.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
CONFIGURATION SECTION.
*-----------------------
INPUT-OUTPUT SECTION.
*-----------------------
DATA DIVISION.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
FILE SECTION.
*-----------------------
WORKING-STORAGE SECTION.
*-----------------------
PROCEDURE DIVISION.
*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
MAIN-PROCEDURE.
**
* The main procedure of the program
**
DISPLAY "Hello world"
STOP RUN.
** add other procedures here
END PROGRAM YOUR-PROGRAM-NAME.
''', '', '')
self.reset(all_tabs=True)
def _make_icon(cls, status):
"""
Make icon from icon filename/tuple (if you want to use a theme)
"""
icon = cls.ICONS[status]
if isinstance(icon, tuple):
return QtGui.QIcon.fromTheme(icon[0], QtGui.QIcon(icon[1]))
elif isinstance(icon, str):
return QtGui.QIcon(icon)
else:
return None
def __init__(self, parent=None):
super(DlgPreferredEncodingsEditor, self).__init__(parent)
self.ui = dlg_preferred_encodings_editor_ui.Ui_Dialog()
self.ui.setupUi(self)
self._load_preferred()
self.ui.pushButtonAdd.clicked.connect(self._add)
self.ui.pushButtonAdd.setIcon(QtGui.QIcon.fromTheme(
"go-next", QtGui.QIcon(':/pyqode-icons/rc/go-next.png')))
self.ui.pushButtonRemove.clicked.connect(self._remove)
self.ui.pushButtonRemove.setIcon(QtGui.QIcon.fromTheme(
"go-previous", QtGui.QIcon(':/pyqode-icons/rc/go-previous.png')))
def make_marker_icon(icon):
"""
Make (and memoize) an icon from an icon filename.
:param icon: Icon filename or tuple (to use a theme).
"""
if isinstance(icon, tuple):
return icon[0], QtGui.QIcon.fromTheme(
icon[0], QtGui.QIcon(icon[1]))
elif isinstance(icon, str):
return icon, QtGui.QIcon(icon)
else:
return None, None
def get_new_user_actions(self):
# New module
self.action_new_module = QtWidgets.QAction('&Module', self)
self.action_new_module.setIcon(QtGui.QIcon(icons.python_mimetype))
self.action_new_module.triggered.connect(self._on_new_module_triggered)
# New package
self.action_new_package = QtWidgets.QAction('&Package', self)
self.action_new_package.setIcon(QtGui.QIcon(icons.folder))
self.action_new_package.triggered.connect(
self._on_new_package_triggered)
# separator with the regular entries
action = QtWidgets.QAction(self)
action.setSeparator(True)
return [self.action_new_module, self.action_new_package, action]
def icon(self):
"""
Gets the icon file name. Read-only.
"""
if isinstance(self._icon, str):
if QtGui.QIcon.hasThemeIcon(self._icon):
return QtGui.QIcon.fromTheme(self._icon)
else:
return QtGui.QIcon(self._icon)
elif isinstance(self._icon, tuple):
return QtGui.QIcon.fromTheme(self._icon[0],
QtGui.QIcon(self._icon[1]))
elif isinstance(self._icon, QtGui.QIcon):
return self._icon
return QtGui.QIcon()
def __init__(self):
super(CheckerPanel, self).__init__()
self._previous_line = -1
self.scrollable = True
self._job_runner = DelayJobRunner(delay=100)
self.setMouseTracking(True)
#: Info icon
self.info_icon = QtGui.QIcon.fromTheme(
'dialog-info', QtGui.QIcon(':pyqode-icons/rc/dialog-info.png'))
#: Warning icon
self.warning_icon = QtGui.QIcon.fromTheme(
'dialog-warning',
QtGui.QIcon(':pyqode-icons/rc/dialog-warning.png'))
#: Error icon
self.error_icon = QtGui.QIcon.fromTheme(
'dialog-error', QtGui.QIcon(':pyqode-icons/rc/dialog-error.png'))
def icon(self, file_infos):
try:
if '.%s' % file_infos.suffix() in CobolCodeEdit.all_extensions():
return QtGui.QIcon(icons.ICON_MIMETYPE)
except AttributeError:
pass
return super().icon(file_infos)
def setupUi(self, Dialog):
Dialog.setObjectName("Dialog")
Dialog.resize(452, 172)
icon = QtGui.QIcon()
icon.addPixmap(QtGui.QPixmap(":/ide-icons/rc/silex-192x192.png"),
QtGui.QIcon.Normal, QtGui.QIcon.Off)
Dialog.setWindowIcon(icon)
self.verticalLayout = QtWidgets.QVBoxLayout(Dialog)
self.verticalLayout.setObjectName("verticalLayout")
self.formLayout = QtWidgets.QFormLayout()
self.formLayout.setObjectName("formLayout")
self.label = QtWidgets.QLabel(Dialog)
self.label.setObjectName("label")
self.formLayout.setWidget(0, QtWidgets.QFormLayout.LabelRole,
self.label)
self.plainTextEdit = QtWidgets.QPlainTextEdit(Dialog)
self.plainTextEdit.setReadOnly(True)
self.plainTextEdit.setObjectName("plainTextEdit")
self.formLayout.setWidget(0, QtWidgets.QFormLayout.FieldRole,
self.plainTextEdit)
self.verticalLayout.addLayout(self.formLayout)
self.buttonBox = QtWidgets.QDialogButtonBox(Dialog)
self.buttonBox.setOrientation(QtCore.Qt.Horizontal)
self.buttonBox.setStandardButtons(QtWidgets.QDialogButtonBox.Apply
| QtWidgets.QDialogButtonBox.Close)
self.buttonBox.setCenterButtons(False)
self.buttonBox.setObjectName("buttonBox")
self.verticalLayout.addWidget(self.buttonBox)
self.retranslateUi(Dialog)
self.buttonBox.accepted.connect(Dialog.accept)
self.buttonBox.rejected.connect(Dialog.reject)
QtCore.QMetaObject.connectSlotsByName(Dialog)
def _on_changed(self):
"""
Update the tree items
"""
self._updating = True
to_collapse = []
self.clear()
if self._editor and self._analyser and self._folding_panel:
items, to_collapse = self._analyser.to_tree_widget_items(
to_collapse=to_collapse)
if len(items):
self.addTopLevelItems(items)
self.expandAll()
for item in reversed(to_collapse):
self.collapseItem(item)
self._updating = False
return
# no data
root = QtWidgets.QTreeWidgetItem()
root.setText(0, 'No data')
root.setIcon(
0,
QtGui.QIcon.fromTheme(
'dialog-information',
QtGui.QIcon(':/pyqode-icons/rc/dialog-info.png')))
self.addTopLevelItem(root)
self._updating = False
def mimetype_icon(path, fallback=None):
"""
Tries to create an icon from theme using the file mimetype.
E.g.::
return self.mimetype_icon(
path, fallback=':/icons/text-x-python.png')
:param path: file path for which the icon must be created
:param fallback: fallback icon path (qrc or file system)
:returns: QIcon or None if the file mimetype icon could not be found.
"""
mime = mimetypes.guess_type(path)[0]
if mime:
icon = mime.replace('/', '-')
# if system.WINDOWS:
# return icons.file()
if QtGui.QIcon.hasThemeIcon(icon):
icon = QtGui.QIcon.fromTheme(icon)
if not icon.isNull():
return icon
if fallback:
return QtGui.QIcon(fallback)
return QtGui.QIcon.fromTheme('text-x-generic')
def __init__(self):
super(QuickDocPanel, self).__init__()
# layouts
layout = QtWidgets.QHBoxLayout()
self.setLayout(layout)
child_layout = QtWidgets.QVBoxLayout()
# A QTextEdit to show the doc
self.text_edit = QtWidgets.QTextEdit()
self.text_edit.setReadOnly(True)
self.text_edit.setAcceptRichText(True)
layout.addWidget(self.text_edit)
# A QPushButton (inside a child layout for a better alignment)
# to close the panel
self.bt_close = QtWidgets.QPushButton()
self.bt_close.setIcon(QtGui.QIcon.fromTheme(
'window-close', QtGui.QIcon(':/pyqode-icons/rc/close.png')))
self.bt_close.setIconSize(QtCore.QSize(16, 16))
self.bt_close.clicked.connect(self.hide)
child_layout.addWidget(self.bt_close)
child_layout.addStretch()
layout.addLayout(child_layout)
# Action
self.action_quick_doc = QtWidgets.QAction('Show documentation', self)
self.action_quick_doc.setShortcut('Alt+Q')
self.action_quick_doc.triggered.connect(
self._on_action_quick_doc_triggered)
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.checkBoxVerbose.setChecked(Settings().verbose)
self.tabWidget.setCurrentIndex(0)
self.tbwVersions.setColumnCount(1)
self.tbwVersions.setRowCount(len(self.HEADERS))
self.tbwVersions.setVerticalHeaderLabels(self.HEADERS)
self.tbwVersions.setHorizontalHeaderLabels(['Version'])
self.tbwVersions.verticalHeader().setStretchLastSection(False)
self.labelMain.setText(self.labelMain.text() % __version__)
self.setMinimumWidth(640)
self.setMinimumHeight(480)
self.setWindowIcon(
QtGui.QIcon.fromTheme(
'help-about',
QtGui.QIcon(':/ide-icons/rc/dialog-information.png')))
try:
import qdarkstyle
except ImportError:
qdarkstyle_version = 'Not installed'
else:
qdarkstyle_version = qdarkstyle.__version__
versions = [
GnuCobolCompiler().get_version(), QtCore.QT_VERSION_STR,
QtCore.PYQT_VERSION_STR, pyqode.core.__version__,
pyqode.cobol.__version__, pygments.__version__, qdarkstyle_version
]
for i, version in enumerate(versions):
item = QtWidgets.QTableWidgetItem(version)
self.tbwVersions.setItem(i, 0, item)
with open(logger.get_path(), 'r') as f:
self.textEditLog.setText(f.read())
self.checkBoxVerbose.toggled.connect(self._on_verbose_toggled)
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.checkBoxVerbose.setChecked(Settings().verbose)
self.tabWidget.setCurrentIndex(0)
self.tbwVersions.setColumnCount(1)
self.tbwVersions.setRowCount(len(self.HEADERS))
self.tbwVersions.setVerticalHeaderLabels(self.HEADERS)
self.tbwVersions.setHorizontalHeaderLabels(['Version'])
self.tbwVersions.verticalHeader().setStretchLastSection(False)
self.labelMain.setText(self.labelMain.text() % __version__)
self.setMinimumWidth(640)
self.setMinimumHeight(480)
self.setWindowIcon(
QtGui.QIcon.fromTheme(
'help-about',
QtGui.QIcon(':/ide-icons/rc/dialog-information.png')))
try:
import qdarkstyle
except ImportError:
qdarkstyle_version = 'Not installed'
else:
qdarkstyle_version = qdarkstyle.__version__
versions = [
GnuCobolCompiler().get_version(), QtCore.QT_VERSION_STR,
QtCore.PYQT_VERSION_STR, pyqode.core.__version__,
pyqode.cobol.__version__, pygments.__version__, qdarkstyle_version
]
for i, version in enumerate(versions):
item = QtWidgets.QTableWidgetItem(version)
self.tbwVersions.setItem(i, 0, item)
with open(logger.get_path(), 'r') as f:
self.textEditLog.setText(f.read())
self.checkBoxVerbose.toggled.connect(self._on_verbose_toggled)
self.edit_compiler_infos.setFont(QtGui.QFont(Settings().font, 9))
# from pyqode.core._forms.pyqode_core_rc
QtGui.QFontDatabase.addApplicationFont(
':/fonts/rc/SourceCodePro-Regular.ttf')
QtGui.QFontDatabase.addApplicationFont(
':/fonts/rc/SourceCodePro-Bold.ttf')
template = '''cobc --info
============
%(cobc_infos)s
cobcrun --runtime-env
=====================
%(cobcrun_infos)s
'''
gnucobol_infos = template % {
'cobc_infos': GnuCobolCompiler.get_cobc_infos(),
'cobcrun_infos': GnuCobolCompiler.get_cobcrun_infos()
}
self.edit_compiler_infos.setPlainText(gnucobol_infos)
def icon(self, file_infos):
try:
if '.%s' % file_infos.suffix().lower() in Settings(
).all_extensions:
return QtGui.QIcon(icons.ICON_MIMETYPE)
except AttributeError:
pass
return super().icon(file_infos)
def icon(path, theme=None):
"""
Creates an icon from theme and fallback to a fully specified icon path.
Theme can be None if you don't want use icons from system theme.
:param path: fallback icon, in case the icon could not be found in the
icons theme
:param theme: Icon theme
:return: QIcon
"""
if theme and path:
return QtGui.QIcon.fromTheme(theme, QtGui.QIcon(path))
else:
assert path is not None
return QtGui.QIcon(path)
def __init__(self, window):
super(PyFileSystemContextMenu, self).__init__()
self.window = window
# Create run config action
self.action_create_run_cfg = QtWidgets.QAction(
'&Create run configuration', self)
self.action_create_run_cfg.setIcon(QtGui.QIcon(icons.configure))
self.action_create_run_cfg.triggered.connect(
self._on_action_create_run_cfg_triggered)
# Run script action
self.action_run = QtWidgets.QAction('&Run', self)
self.action_run.setIcon(QtGui.QIcon(icons.run))
self.action_run.triggered.connect(self._on_action_run_triggered)
self.addSeparator()
self.addAction(self.action_create_run_cfg)
self.addAction(self.action_run)
def icon(self, type_or_info):
if isinstance(type_or_info, QtCore.QFileInfo):
# COBOL file
if ('.' + type_or_info.suffix().lower()
in Settings().all_extensions):
return QtGui.QIcon(icons.ICON_MIMETYPE)
if 'linux' not in sys.platform:
# use hardcoded icon on windows/OSX
if type_or_info.isDir():
return QtGui.QIcon(':/ide-icons/rc/folder.png')
else:
return QtGui.QIcon(':/ide-icons/rc/file.png')
else:
if 'linux' not in sys.platform:
if type_or_info == self.Folder:
return QtGui.QIcon(':/ide-icons/rc/file.png')
elif type_or_info == self.File:
return QtGui.QIcon('')
return super().icon(type_or_info)
def __init__(self, parent=None):
super().__init__(parent)
self.setupUi(self)
self.tabWidget.setCurrentIndex(0)
self.tbwVersions.setColumnCount(1)
self.tbwVersions.setRowCount(len(self.HEADERS))
self.tbwVersions.setVerticalHeaderLabels(self.HEADERS)
self.tbwVersions.setHorizontalHeaderLabels(['Version'])
self.tbwVersions.verticalHeader().setStretchLastSection(False)
self.labelMain.setText(self.labelMain.text() % __version__)
self.setMinimumWidth(640)
self.setMinimumHeight(480)
self.setWindowIcon(
QtGui.QIcon.fromTheme(
'help-about',
QtGui.QIcon(':/ide-icons/rc/dialog-information.png')))
for i, (name, version) in enumerate(
sorted(list(DlgAbout.get_runtime_env().items()),
key=lambda x: x[0])):
item = QtWidgets.QTableWidgetItem(name)
self.tbwVersions.setVerticalHeaderItem(i, item)
item = QtWidgets.QTableWidgetItem(version)
self.tbwVersions.setItem(i, 0, item)
try:
with open(logger.get_path(), 'r') as f:
self.textEditLog.setPlainText('\n'.join(
f.read().splitlines()[-1000:]))
except FileNotFoundError:
self.textEditLog.setPlainText('')
self.edit_compiler_infos.setFont(QtGui.QFont(Settings().font, 9))
# from pyqode.core._forms.pyqode_core_rc
QtGui.QFontDatabase.addApplicationFont(
':/fonts/rc/SourceCodePro-Regular.ttf')
QtGui.QFontDatabase.addApplicationFont(
':/fonts/rc/SourceCodePro-Bold.ttf')
self.edit_compiler_infos.setPlainText(DlgAbout.get_cobc_runtime_env())
try:
name = LEVEL_NAMES[Settings().log_level]
except KeyError:
name = 'INFO'
self.combo_log_level.setCurrentText(name)
self.combo_log_level.currentIndexChanged.connect(
self._on_log_level_changed)
self.bt_clear_logs.clicked.connect(self._clear_logs)
def _on_document_changed(self):
if not self or not self.editor:
return
mode = self.editor.modes.get('DocumentAnalyserMode')
definitions = mode.flattened_results
self.combo_box.clear()
if definitions:
self.combo_box.addItem(" < Select a symbol >")
else:
self.combo_box.addItem("No symbols")
for d in definitions:
self.combo_box.addItem(QtGui.QIcon(d.icon), d.name, d)
self._definitions = definitions
self._sync_combo_box(TextHelper(self.editor).current_line_nbr())
def __init__(self, app):
super().__init__(app)
self.ui.tabWidgetEditors.editors.clear()
self.ui.tabWidgetEditors.fallback_editor = GenericCodeEdit
for editor_type in self.editor_types:
self.ui.tabWidgetEditors.register_code_edit(editor_type)
self.ui.tabWidgetEditors.current_changed.connect(
self._current_changed)
self.ui.tabWidgetEditors.last_tab_closed.connect(
self._on_last_tab_closed)
self.ui.tableWidgetOffsets.show_requested.connect(
self.ui.dockWidgetOffsets.show)
self.ui.actionPreferences.triggered.connect(self.edit_preferences)
self.ui.btPreferences.clicked.connect(self.edit_preferences)
self.ui.actionPreferences.setShortcut(QtGui.QKeySequence.Preferences)
if self.ui.actionPreferences.shortcut().toString().strip() == '':
self.ui.actionPreferences.setShortcut('F2')
self._setup_status_bar()
self.ui.consoleOutput.apply_color_scheme(
ColorScheme(Settings().color_scheme))
self.ui.tvFileSystem.activated.connect(self._on_tvFileSystem_activated)
self.ui.tvFileSystem.setHeaderHidden(True)
self.ui.bt_fs_up.setIcon(QtGui.QIcon.fromTheme(
'go-up', QtGui.QIcon(':/pyqode-icons/rc/go-up.png')))
self.ui.bt_fs_up.clicked.connect(self._fs_go_up)
for i in range(1, 4):
self.ui.tvFileSystem.hideColumn(i)
self.ui.tvFileSystem.add_ignore_patterns('bin', '.oci*.cbl')
mnu = FSContextMenu(self.app)
self.ui.tvFileSystem.set_context_menu(mnu)
self.ui.tvFileSystem.file_created.connect(self.app.file.open_file)
self.ui.tvFileSystem.file_renamed.connect(
self.ui.tabWidgetEditors.rename_document)
self.ui.tvFileSystem.file_deleted.connect(
self.ui.tabWidgetEditors.close_document)
lock_fs_path = Settings().lock_fs_path
if lock_fs_path and os.path.exists(lock_fs_path):
self.ui.tvFileSystem.set_root_path(lock_fs_path)
else:
Settings().lock_fs_path = ''
self.ui.btFSLock.setChecked(lock_fs_path != '')
self.ui.btFSLock.toggled.connect(self._on_fs_path_lock_toggled)
self.ui.btNavLock.toggled.connect(self._on_navlock_toggled)
self.ui.btNavLock.setChecked(not self.ui.twNavigation.sync_with_editor)
self.ui.twNavigation.sync_with_editor_changed.connect(
self._on_nav_sync_changed)
self.ui.actionEnableLinter.toggled.connect(
self._on_enable_linter_toggled)
def show_context_menu(self, pt):
"""
Shows the recent files list context menu which allow to remove an item
from the list or to clear the entire list.
"""
actionRemove = QtWidgets.QAction('Remove from recent files list', self)
actionClear = QtWidgets.QAction('Clear recent files list', self)
actionRemove.triggered.connect(self.remove_current_requested)
actionClear.triggered.connect(self.clear_requested)
actionClear.setIcon(
QtGui.QIcon.fromTheme(
'edit-clear', QtGui.QIcon(':/ide-icons/rc/edit-clear.png')))
menu = QtWidgets.QMenu()
menu.addAction(actionRemove)
menu.addAction(actionClear)
menu.exec_(self.mapToGlobal(pt))
def __init__(self, app):
super().__init__(app)
self.recent_files_manager = widgets.RecentFilesManager(
'OpenCobolIDE', 'OpenCobolIDE4')
self.menu_recents = widgets.MenuRecentFiles(
self.ui.menuFile,
title='Recents',
recent_files_manager=self.recent_files_manager,
icon_provider=FileIconProvider())
self.menu_recents.setIcon(
QtGui.QIcon.fromTheme('document-open-recent'))
self.menu_recents.clear_icon = QtGui.QIcon.fromTheme(
'edit-clear', QtGui.QIcon(':/ide-icons/rc/edit-clear.png'))
self.menu_recents.open_requested.connect(self.open_file)
self.menu_recents.clear_requested.connect(
self.recent_files_manager.clear)
self.ui.menuFile.clear()
self.ui.menuFile.addAction(self.ui.actionNew)
self.ui.menuFile.addAction(self.ui.actionOpen)
self.ui.menuFile.addSeparator()
self.ui.menuFile.addMenu(self.menu_recents)
self.ui.menuFile.addSeparator()
self.ui.menuFile.addAction(self.ui.actionImport_preferences)
self.ui.menuFile.addAction(self.ui.actionExport_preferences)
self.ui.menuFile.addSeparator()
self.ui.menuFile.addAction(self.ui.actionSave)
self.ui.menuFile.addAction(self.ui.actionSaveAs)
self.ui.menuFile.addSeparator()
self.ui.menuFile.addAction(self.ui.actionQuit)
self.menu_recents.update_actions()
self.recent_files_manager.updated.connect(
self.menu_recents.update_actions)
self.ui.actionOpen.triggered.connect(self.request_open)
self.ui.actionNew.triggered.connect(self.request_new)
self.ui.actionSave.triggered.connect(self.save_current)
self.ui.actionImport_preferences.triggered.connect(
self.import_preferences)
self.ui.actionExport_preferences.triggered.connect(
self.export_preferences)
self.ui.actionSaveAs.triggered.connect(self.save_as)
self.ui.actionQuit.triggered.connect(self.quit)
self.ui.tabWidgetEditors.register_code_edit(CobolCodeEdit)
self.ui.tabWidgetEditors.icon_provider_klass = FileIconProvider
self.ui.tvFileSystem.set_icon_provider(FileIconProvider())
self._warning_unc = False
def __init__(self, app):
self.ui = win_script_ui.Ui_MainWindow()
super(ScriptWindow, self).__init__(self.ui, app)
self.setMinimumWidth(600)
self.setMinimumHeight(480)
self.ui.classExplorer.set_editor(self.ui.codeEdit)
self.restore_state()
self.ui.dockWidgetProgramOutput.hide()
self.ui.codeEdit.dirty_changed.connect(self._on_dirty_changed)
# Edit menu
mnu = self.ui.codeEdit.get_context_menu()
self.addActions(self.ui.menuFile.actions())
self.addActions(mnu.actions())
self.ui.menuEdit.addActions(self.ui.codeEdit.actions())
self.ui.actionConfigureRun.triggered.connect(self.configure_run)
self.ui.actionRun.triggered.connect(self.on_action_run_triggered)
self.ui.textEditPgmOutput.process_finished.connect(
self._on_script_finished)
self.ui.textEditPgmOutput.open_file_requested.connect(
self._goto_requested)
mode = self.ui.codeEdit.modes.get('GoToAssignmentsMode')
mode.out_of_doc.connect(self._goto_requested)
for a in self.createPopupMenu().actions():
if a.text() == 'Structure':
a.setIcon(icons.class_browser)
if a.text() == 'Python console':
a.setIcon(icons.python_interpreter)
if a.text() == 'Program output':
a.setIcon(
QtGui.QIcon.fromTheme(
'media-playback-start',
QtGui.QIcon(':/icons/media-playback-start.png')))
self.ui.dockWidgetClassExplorer.setWindowIcon(icons.class_browser)
self.ui.dockWidgetProgramOutput.setWindowIcon(icons.run)
self.ui.dockWidgetPyConsole.setWindowIcon(icons.python_interpreter)
self.apply_preferences(show_panels=False)
self.dock_manager_right.add_dock_widget(
self.ui.dockWidgetClassExplorer)
self.dock_manager_bottom.add_dock_widget(
self.ui.dockWidgetProgramOutput)
self.dock_manager_bottom.add_dock_widget(self.ui.dockWidgetPyConsole)
def _update_recents(self):
"""
Updates the recent files list.
"""
self.ui.listWidgetRecents.clear()
for file in self.app.file.recent_files_manager.get_recent_files():
item = QtWidgets.QListWidgetItem()
if ('.' + QtCore.QFileInfo(file).suffix().upper()
in CobolCodeEdit.extensions):
icon = QtGui.QIcon(icons.ICON_MIMETYPE)
else:
icon = QtWidgets.QFileIconProvider().icon(
QtCore.QFileInfo(file))
item.setText(QtCore.QFileInfo(file).fileName())
item.setToolTip(file)
item.setIcon(icon)
item.setData(QtCore.Qt.UserRole, file)
self.ui.listWidgetRecents.addItem(item)
def _draw_fold_indicator(self, top, mouse_over, collapsed, painter):
"""Draw the fold indicator/trigger (arrow).
Args:
top (int): Top position
mouse_over (bool): Whether the mouse is over the indicator
collapsed (bool): Whether the trigger is collapsed or not.
painter (PySide.QtGui.QPainter): QPainter
"""
rect = QtCore.QRect(0, top,
self.sizeHint().width(),
self.sizeHint().height())
self._native = False
index = 0
if not collapsed:
index = 2
if mouse_over:
index += 1
QtGui.QIcon(self._custom_indicators[index]).paint(painter, rect)
