def __init__(self, parent, i):
BasePyzoWizardPage.__init__(self, parent, i)
# Create label and checkbox
t1 = translate('wizard',
"This wizard can be opened using 'Help > Pyzo wizard'")
t2 = translate('wizard', "Show this wizard on startup")
self._label_info = QtWidgets.QLabel(t1, self)
#self._check_show = QtWidgets.QCheckBox(t2, self)
#self._check_show.stateChanged.connect(self._setNewUser)
# Create language switcher
self._langLabel = QtWidgets.QLabel(
translate('wizard', "Select language"), self)
#
self._langBox = QtWidgets.QComboBox(self)
self._langBox.setEditable(False)
# Fill
index, theIndex = -1, -1
cur = pyzo.config.settings.language
for lang in sorted(LANGUAGES):
index += 1
self._langBox.addItem(lang)
if lang == LANGUAGE_SYNONYMS.get(cur, cur):
theIndex = index
# Set current index
if theIndex >= 0:
self._langBox.setCurrentIndex(theIndex)
# Bind signal
self._langBox.activated.connect(self.onLanguageChange)
# Init check state
#if pyzo.config.state.newUser:
# self._check_show.setCheckState(QtCore.Qt.Checked)
# Create sublayout
layout = QtWidgets.QHBoxLayout()
layout.addWidget(self._langLabel, 0)
layout.addWidget(self._langBox, 0)
layout.addStretch(2)
self.layout().addLayout(layout)
# Add to layout
self.layout().addSpacing(10)
self.layout().addWidget(self._label_info)
def __add_comboBox(self, key, name, *items):
"""this is a helper method to create a comboBox
it adds the created widget (as a TitledWidget) to the layout and
register a setter and listen to changes
"""
combo = QtWidgets.QComboBox()
combo.addItems(items)
combo.currentTextChanged.connect(
lambda txt, key=key: self.__update(key, txt))
# Note: those setters may become problematic if
# someone use the synonyms (defined in codeeditor/style.py)
# i.e. a stylement is of form "linestyle:dashline"
# instead of the "linestyle:dashed"
self.setters[key] = lambda txt, cmb=combo: cmb.setCurrentText(
txt.capitalize())
self.layout.addWidget(TitledWidget(name, combo))
def __init__(self, parent):
QtWidgets.QFrame.__init__(self, parent)
# Init config
toolId = self.__class__.__name__.lower()
self._config = pyzo.config.tools[toolId]
if not hasattr(self._config, 'zoomFactor'):
self._config.zoomFactor = 1.0
if not hasattr(self._config, 'bookMarks'):
self._config.bookMarks = []
for item in default_bookmarks:
if item not in self._config.bookMarks:
self._config.bookMarks.append(item)
# Get style object (for icons)
style = QtWidgets.QApplication.style()
# Create some buttons
self._back = QtWidgets.QToolButton(self)
self._back.setIcon(style.standardIcon(style.SP_ArrowBack))
self._back.setIconSize(QtCore.QSize(16, 16))
#
self._forward = QtWidgets.QToolButton(self)
self._forward.setIcon(style.standardIcon(style.SP_ArrowForward))
self._forward.setIconSize(QtCore.QSize(16, 16))
# Create address bar
#self._address = QtWidgets.QLineEdit(self)
self._address = QtWidgets.QComboBox(self)
self._address.setEditable(True)
self._address.setInsertPolicy(self._address.NoInsert)
#
for a in self._config.bookMarks:
self._address.addItem(a)
self._address.setEditText('')
# Create web view
if imported_qtwebkit:
self._view = QtWebKit.QWebView(self)
else:
self._view = WebView(self)
#
# self._view.setZoomFactor(self._config.zoomFactor)
# settings = self._view.settings()
# settings.setAttribute(settings.JavascriptEnabled, True)
# settings.setAttribute(settings.PluginsEnabled, True)
# Layout
self._sizer1 = QtWidgets.QVBoxLayout(self)
self._sizer2 = QtWidgets.QHBoxLayout()
#
self._sizer2.addWidget(self._back, 0)
self._sizer2.addWidget(self._forward, 0)
self._sizer2.addWidget(self._address, 1)
#
self._sizer1.addLayout(self._sizer2, 0)
self._sizer1.addWidget(self._view, 1)
#
self._sizer1.setSpacing(2)
self.setLayout(self._sizer1)
# Bind signals
self._back.clicked.connect(self.onBack)
self._forward.clicked.connect(self.onForward)
self._address.lineEdit().returnPressed.connect(self.go)
self._address.activated.connect(self.go)
self._view.loadFinished.connect(self.onLoadEnd)
self._view.loadStarted.connect(self.onLoadStart)
# Start
self._view.show()
self.go('http://docs.python.org')
def __init__(self):
super().__init__()
from pyzo.util.qt import QtPrintSupport
self.printer = QtPrintSupport.QPrinter(
QtPrintSupport.QPrinter.HighResolution, )
# To allow pdf export with color
self.printer.setColorMode(QtPrintSupport.QPrinter.Color)
# Default settings
self.show_line_number = True
self._enable_syntax_highlighting = True
m = QtWidgets.QMessageBox(self)
# Set title
self.setWindowTitle(translate("menu dialog", 'Pdf Export'))
# Set dialog size
size = 1000, 600
offset = 0
size2 = size[0], size[1] + offset
self.resize(*size2)
# self.setMinimumSize(*size2)
# Button to export to pdf
self.validation_button = QtWidgets.QPushButton("Export")
self.validation_button.clicked.connect(self._export_pdf)
# Button to update the preview
self.button_update_preview = QtWidgets.QPushButton(
'Update preview', self)
self.button_update_preview.clicked.connect(self._update_preview)
# Previw widget
self.preview = QtPrintSupport.QPrintPreviewWidget(self.printer)
# Lines numbers option
self.checkbox_line_number = QtWidgets.QCheckBox(
"Print line number", self, checked=self.show_line_number)
self.checkbox_line_number.stateChanged.connect(
self._get_show_line_number)
# Make of copy of the editor
self.current_editor = pyzo.editors.getCurrentEditor()
self.editor_name = self.current_editor.name
self.editor_filename = self.current_editor.filename
self.editor = pyzo.core.editor.PyzoEditor(
pyzo.editors.getCurrentEditor().toPlainText())
# Zoom
# The default zoom is the current zoom used by the editor
self.original_zoom = pyzo.config.view.zoom
self.zoom_slider = QtWidgets.QSlider(QtCore.Qt.Horizontal)
self.zoom_slider.setMinimum(-10) # Maybe too much ?
self.zoom_slider.setMaximum(10)
self.zoom_slider.setTickInterval(1)
self.zoom_selected = self.original_zoom
self.zoom_slider.setValue(self.zoom_selected)
self.zoom_value_label = QtWidgets.QLabel()
self._zoom_value_changed()
self.zoom_slider.valueChanged.connect(self._zoom_value_changed)
# Option for syntax highlighting
self.checkbox_syntax_highlighting = QtWidgets.QCheckBox(
"Enable syntax highlighting",
self,
checked=self._enable_syntax_highlighting)
self.checkbox_syntax_highlighting.stateChanged.connect(
self._change_syntax_highlighting_option)
self.combobox_file_name = QtWidgets.QComboBox(self)
self.combobox_file_name.addItem("Do not print the file name", 0)
self.combobox_file_name.addItem("Print with file name", 1)
self.combobox_file_name.addItem(
"Print with file name and absolute path", 2)
self.combobox_file_name.setCurrentIndex(1)
self.combobox_file_name.setToolTip(
"The title at the top of the document")
# Orientation
self.combobox_orientation = QtWidgets.QComboBox(self)
self.combobox_orientation.addItem("Portrait",
QtPrintSupport.QPrinter.Portrait)
self.combobox_orientation.addItem("Landscape",
QtPrintSupport.QPrinter.Landscape)
self.combobox_orientation.setToolTip("Orientation of the document")
# Layout
self.main_layout = QtWidgets.QHBoxLayout()
self.setLayout(self.main_layout)
self.preview.setSizePolicy(QtWidgets.QSizePolicy.Expanding,
QtWidgets.QSizePolicy.Expanding)
self.right_layout = QtWidgets.QVBoxLayout()
self.option_layout = QtWidgets.QFormLayout()
self.main_layout.addWidget(self.preview)
self.main_layout.addLayout(self.right_layout)
self.right_layout.addLayout(self.option_layout)
self.option_layout.addRow(self.combobox_file_name)
self.option_layout.addRow(self.checkbox_line_number)
self.option_layout.addRow(self.checkbox_syntax_highlighting)
self.option_layout.addRow(self.zoom_value_label, self.zoom_slider)
self.option_layout.addRow(self.combobox_orientation)
self.bottom_layout = QtWidgets.QHBoxLayout()
self.right_layout.addLayout(self.bottom_layout)
self.bottom_layout.addStretch()
self.bottom_layout.addWidget(self.button_update_preview)
self.bottom_layout.addWidget(self.validation_button)
self._update_preview()
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# Make sure there is a configuration entry for this tool
# The pyzo tool manager makes sure that there is an entry in
# config.tools before the tool is instantiated.
toolId = self.__class__.__name__.lower()
self._config = pyzo.config.tools[toolId]
# Set config
if not hasattr(self._config, "hideTypes"):
self._config.hideTypes = []
#
if not hasattr(self._config, "fontSizeTree"):
if sys.platform == "darwin":
self._config.fontSizeTree = 12
else:
self._config.fontSizeTree = 10
if not hasattr(self._config, "fontSizeHelp"):
if sys.platform == "darwin":
self._config.fontSizeHelp = 12
else:
self._config.fontSizeHelp = 10
#
if not hasattr(self._config, "historyMaximum"):
self._config.historyMaximum = 10
# if not hasattr(self._config, "historyFreeze"):
# self._config.historyFreeze = 0
if not hasattr(self._config, "historyClearOnStartup"):
self._config.historyClearOnStartup = 1
style = QtWidgets.qApp.style()
#
self.initText = "<p>{}</p>".format(
"Click an item in the list for Help information.")
# Create empty label
self._empty = QtWidgets.QLabel(self)
self._empty.setText("")
# ----- Layout 1 -----
# Create Home tool button
self._home = QtWidgets.QToolButton(self)
self._home.setIcon(style.standardIcon(style.SP_ArrowUp))
self._home.setIconSize(QtCore.QSize(16, 16))
self._home.setToolTip("Home - return to the beginninig.")
# Create Refresh tool button
self._refresh = QtWidgets.QToolButton(self)
self._refresh.setIcon(style.standardIcon(style.SP_BrowserReload))
self._refresh.setIconSize(QtCore.QSize(16, 16))
self._refresh.setToolTip("Reload the current command.")
# Create Go back tool button
self.back = QtWidgets.QToolButton(self)
self.back.setIcon(style.standardIcon(style.SP_ArrowLeft))
self.back.setIconSize(QtCore.QSize(16, 16))
self.back.setToolTip("Go back to the previous command.")
# Create "path" line edit
self._line = QtWidgets.QLineEdit(self)
self._line.setReadOnly(True)
self._line.setStyleSheet("QLineEdit { background:#ddd; }")
self._line.setFocusPolicy(QtCore.Qt.NoFocus)
# Create selection tool button
self._selection = QtWidgets.QToolButton(self)
self._selection.setIcon(pyzo.icons.layout)
self._selection.setIconSize(QtCore.QSize(16, 16))
self._selection.setToolTip("Get selected objects in the document.")
self._selection.setEnabled(False)
# Create "insert_code" button
self._insert_code = QtWidgets.QToolButton(self)
self._insert_code.setIcon(
style.standardIcon(style.SP_FileDialogDetailedView))
self._insert_code.setToolTip(
"Insert code in the script at the cursor position")
# ----- Layout 2 -----
# Create element_index combo box
self._element_index = QtWidgets.QComboBox(self)
self._element_index.setToolTip(
"Set the argument for getByIndex method.")
self._element_index.setEnabled(False)
# Create element_names combo box
self._element_names = QtWidgets.QComboBox(self)
self._element_names.setToolTip("Get by name")
self._element_names.setEnabled(False)
# Create enumerate combo box
self._enumerate_index = QtWidgets.QComboBox(self)
self._enumerate_index.setToolTip(
"Objects enumerated by createEnumeration method")
self._enumerate_index.setEnabled(False)
# Create history combo box
self._history = QtWidgets.QComboBox(self)
self._history.setToolTip("Show the command history")
self._history.setEnabled(True)
# Create options menu
self._options = QtWidgets.QToolButton(self)
self._options.setToolTip("Tool configuration.")
self._options.setIcon(pyzo.icons.filter)
self._options.setIconSize(QtCore.QSize(16, 16))
self._options.setPopupMode(self._options.InstantPopup)
self._options.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
# main menu
self._options._menu = pyzo.core.menu.Menu(
self, "Main menu") # QtWidgets.QMenu()
# submenus
self._show_hide_menu = pyzo.core.menu.Menu(None, "Show/Hide")
#
self._font_size_menu = pyzo.core.menu.Menu(None, "Font size")
self._font_size_tree_menu = pyzo.core.menu.Menu(None, "Workspace")
self._font_size_help_menu = pyzo.core.menu.Menu(None, "Help")
#
self._history_menu = pyzo.core.menu.Menu(None, "History")
# create menu
self._options.setMenu(self._options._menu)
self.onOptionsPress()
# Show/hide Help button
self._btn_toggle = QtWidgets.QToolButton(self)
self._btn_toggle.setToolTip("Show/hide help")
self._btn_toggle.setIcon(style.standardIcon(style.SP_DialogHelpButton))
self._btn_toggle.setIconSize(QtCore.QSize(16, 16))
self._btn_toggle.setCheckable(True)
self._btn_toggle.setChecked(False)
# ----- Layout 3 -----
# Create tree
self._tree = PyUNOWorkspaceTree(self)
# Create message for when tree is empty
self._initText = QtWidgets.QLabel(
pyzo.translate(
"pyzoWorkspace",
"""Lists the variables in the current shell's namespace.
Currently, there are none. Some of them may be hidden because of the filters you configured.""",
),
self,
)
self._initText.setVisible(False)
self._initText.setWordWrap(True)
# ----- Layout 4 -----
# Create description widget
self._description = QtWidgets.QTextBrowser(self)
self._description.setText(self.initText)
# ----- Layout 5 -----
# Create counter
self._desc_counter = QtWidgets.QLabel(self)
self._desc_counter.setText("0")
# Label
self._desc_of = QtWidgets.QLabel(self)
self._desc_of.setText(" of ")
# Create all items counter
self._desc_all_items = QtWidgets.QLabel(self)
self._desc_all_items.setText("0")
#
self._search_line = QtWidgets.QLineEdit(self)
self._search_line.setReadOnly(False)
self._search_line.setToolTip("Search")
self._search_line.setPlaceholderText("UNO API Search...")
#
self._match = QtWidgets.QCheckBox(self)
self._match.setText("Match")
self._match.setChecked(True)
self._match.setToolTip("Match")
#
self._search = QtWidgets.QToolButton(self)
self._search.setIconSize(QtCore.QSize(16, 16))
self._search.setText("Search")
self._search.setToolTip("Search")
#
self._clear = QtWidgets.QToolButton(self)
self._clear.setIconSize(QtCore.QSize(16, 16))
self._clear.setText("Clear")
self._clear.setToolTip("Clear")
# ------ Set layouts
# Layout 1: Object and insert code layout
layout_1 = QtWidgets.QHBoxLayout()
layout_1.addWidget(self._home, 0)
layout_1.addWidget(self._refresh, 0)
layout_1.addWidget(self.back, 0)
layout_1.addWidget(self._line, 1)
layout_1.addWidget(self._selection, 0)
layout_1.addWidget(self._insert_code, 0)
# Layout 2: Display, arguments, history and option layout
layout_2 = QtWidgets.QHBoxLayout()
layout_2.addWidget(self._element_index, 0)
layout_2.addWidget(self._element_names, 0)
layout_2.addWidget(self._enumerate_index, 0)
layout_2.addWidget(self._history, 1)
layout_2.addWidget(self._options, 0)
layout_2.addWidget(self._btn_toggle, 0)
# Layout 3: Tree layout
layout_3 = QtWidgets.QVBoxLayout()
layout_3.addWidget(self._tree, 0)
# Layout 5: Hidden help layout
self._description_widget = QtWidgets.QWidget(self)
self._description_widget.setVisible(False)
layout_5 = QtWidgets.QVBoxLayout()
layout_5.setSpacing(0)
layout_5.setContentsMargins(0, 0, 0, 0)
# Layout 6: Search layout
layout_6 = QtWidgets.QHBoxLayout()
layout_6.addWidget(self._desc_counter, 0)
layout_6.addWidget(self._desc_of, 0)
layout_6.addWidget(self._desc_all_items, 0)
layout_6.addWidget(self._empty, 0)
layout_6.addWidget(self._search_line, 0)
layout_6.addWidget(self._empty, 0)
layout_6.addWidget(self._match, 0)
layout_6.addWidget(self._search, 0)
layout_6.addWidget(self._clear, 0)
# Layout 7: Help description layout
layout_7 = QtWidgets.QVBoxLayout()
layout_7.addWidget(self._description, 0)
layout_5.addLayout(layout_7, 0)
layout_5.addLayout(layout_6, 0)
layout_7.setSpacing(0)
layout_7.setContentsMargins(0, 0, 0, 0)
# Main Layout
mainLayout = QtWidgets.QVBoxLayout(self)
mainLayout.addLayout(layout_1, 0)
mainLayout.addLayout(layout_2, 0)
mainLayout.addLayout(layout_3, 0)
# add hidden widget
mainLayout.addWidget(self._description_widget)
self._description_widget.setLayout(layout_5)
# set margins
mainLayout.setContentsMargins(0, 0, 0, 0)
self.setLayout(mainLayout)
# ------ Bind events
self._home.pressed.connect(self.onHomePress)
self._refresh.pressed.connect(self.onRefreshPress)
self.back.pressed.connect(self.onBackPress)
#
self._selection.pressed.connect(self.onCurrentSelectionPress)
self._insert_code.pressed.connect(self.onInsertCodeInEditorPress)
#
self._element_names.activated[str].connect(self.onElementNamesPress)
self._element_index.activated[str].connect(self.onElementIndexPress)
self._enumerate_index.activated[str].connect(
self.onEnumerateIndexPress)
self._history.activated[str].connect(self.onHistoryPress)
#
self._options.pressed.connect(self.onOptionsPress)
#
self._show_hide_menu.triggered.connect(self.onShowHideMenuTiggered)
self._font_size_help_menu.triggered.connect(
self.onFontHelpOptionMenuTiggered)
self._font_size_tree_menu.triggered.connect(
self.onFontTreeOptionMenuTiggered)
self._history_menu.triggered.connect(self.onHistoryOptionMenuTiggered)
#
self._btn_toggle.toggled.connect(self.onHelpTogglePress)
#
self._search.pressed.connect(self.onSearchPress)
self._clear.pressed.connect(self.onClearHelpPress)
# Create json result file
createResultFile(),
# Load History
if self._config.historyClearOnStartup:
#self._config.historyFreeze = 0
createHistoryFile()
self.loadHistory()
def __init__(self, themes, *args, editor=None, **kwargs):
super().__init__(*args, **kwargs)
# dict of themes, a deep copy of pyzo.themes
self.themes = themes
# We store the key name separate so we can easier track renames
self.cur_theme_key = ""
# The current theme being changed
self.cur_theme = None
# If an editor is given, connect to it
self.editor = editor
if self.editor is not None:
self.editor.tokenClicked.connect(self.focusOnStyle)
self.styleChanged.connect(self.editor.setStyle)
# Display editables style formats in a scroll area
self.scrollArea = scrollArea = QtWidgets.QScrollArea()
self.scrollArea.setWidgetResizable(True)
formLayout = QtWidgets.QFormLayout()
self.styleEdits = {}
# Add one pair of label and StyleEdit per style element description
# to the formLayout and connect the StyleEdit signals to the updatedStyle method
for styleDesc in pyzo.codeeditor.CodeEditor.getStyleElementDescriptions(
):
label = QtWidgets.QLabel(text=styleDesc.name,
toolTip=styleDesc.description)
label.setWordWrap(True)
styleEdit = StyleEdit(styleDesc, toolTip=styleDesc.description)
styleEdit.styleChanged.connect(self.updatedStyle)
self.styleEdits[styleDesc.key] = styleEdit
formLayout.addRow(label, styleEdit)
wrapper = QtWidgets.QWidget()
wrapper.setLayout(formLayout)
wrapper.setMinimumWidth(650)
scrollArea.setWidget(wrapper)
# Basic theme I/O
curThemeLbl = QtWidgets.QLabel(text="Themes :")
self.curThemeCmb = curThemeCmb = QtWidgets.QComboBox()
current_index = -1
for i, themeName in enumerate(self.themes.keys()):
# We store the themeName in data in case the user renames one
curThemeCmb.addItem(themeName, userData=themeName)
if themeName == pyzo.config.settings.theme.lower():
current_index = i
curThemeCmb.addItem("New...")
loadLayout = QtWidgets.QHBoxLayout()
loadLayout.addWidget(curThemeLbl)
loadLayout.addWidget(curThemeCmb)
self.saveBtn = saveBtn = QtWidgets.QPushButton(text="Save")
saveBtn.clicked.connect(self.saveTheme)
exitBtn = QtWidgets.QPushButton(text="Apply theme")
exitBtn.clicked.connect(self.ok)
exitLayout = QtWidgets.QHBoxLayout()
exitLayout.addWidget(exitBtn)
exitLayout.addWidget(saveBtn)
# Packing it up
mainLayout = QtWidgets.QVBoxLayout()
mainLayout.addLayout(loadLayout)
mainLayout.addWidget(scrollArea)
mainLayout.addLayout(exitLayout)
self.setLayout(mainLayout)
curThemeCmb.currentIndexChanged.connect(self.indexChanged)
curThemeCmb.currentTextChanged.connect(self.setTheme)
# Init
if current_index >= 0:
curThemeCmb.setCurrentIndex(current_index)
self.setTheme(pyzo.config.settings.theme)
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# Make sure there is a configuration entry for this tool
# The pyzo tool manager makes sure that there is an entry in
# config.tools before the tool is instantiated.
tool_id = self.__class__.__name__.lower()
self._config = pyzo.config.tools[tool_id]
if not hasattr(self._config, "fontSize"):
if sys.platform == "darwin":
self._config.fontSize = 12
else:
self._config.fontSize = 10
# Style
theme = pyzo.themes[pyzo.config.settings.theme.lower()]["data"]
background_style = theme["editor.text"].split(",")
background = background_style[1].split(":")[1]
textcolor_style = theme["syntax.identifier"].split(",")
textcolor = textcolor_style[0].split(":")[1]
# Keep track of linter output
self.output = ""
# Folder for linter output file
self.output_folder = os.path.join(pyzo.appDataDir, "tools",
"pyzoLinter")
self.process = None
self.locale_codec = pyzo.QtCore.QTextCodec.codecForLocale()
self.cur_dir_path = ""
# Create button for parsing scope
self._reload = QtWidgets.QToolButton(self)
self._reload.setIcon(pyzo.icons.arrow_refresh)
self._reload.setToolTip("Parse")
# event
self._reload.clicked.connect(self.start)
# Create combo box Scope
scope_list = ["Current document", "Current document directory"]
self._scope = QtWidgets.QComboBox(self)
self._scope.setToolTip("Get by index")
self._scope.addItems(scope_list)
# Create font options menu
self._font_options = QtWidgets.QToolButton(self)
self._font_options.setIcon(pyzo.icons.wrench)
self._font_options.setIconSize(QtCore.QSize(16, 16))
self._font_options.setPopupMode(self._font_options.InstantPopup)
self._font_options.setToolButtonStyle(
QtCore.Qt.ToolButtonTextBesideIcon)
self._font_options._menu = QtWidgets.QMenu()
self._font_options.setMenu(self._font_options._menu)
self.on_font_options_press() # create menu now
# event
self._font_options.pressed.connect(self.on_font_options_press)
self._font_options._menu.triggered.connect(
self.on_font_option_menu_tiggered)
# Create button for opening output file in the editor
self._open_file = QtWidgets.QToolButton(self)
self._open_file.setIcon(pyzo.icons.page_white_text)
self._open_file.setIconSize(QtCore.QSize(16, 16))
self._open_file.setStyleSheet(
"QToolButton { border: none; padding: 0px; }")
self._open_file.setToolTip("Open output file in the editor")
# event
self._open_file.clicked.connect(self.on_open_output_file)
# Ratings label
self._ratings = QtWidgets.QLabel(self)
self._ratings.setText("")
self._ratings.setAlignment(QtCore.Qt.AlignCenter)
style_sheet = "QLabel{color: black;background-color: #FFFFE0;font : bold;}"
self._ratings.setStyleSheet(style_sheet)
# Create radio box All
self._all = QtWidgets.QRadioButton(self)
self._all.setText(ALL)
self._all.setChecked(True)
self._all.setToolTip(ALL)
# Create radio box Convention
self._convention = QtWidgets.QRadioButton(self)
self._convention.setText(CONVENTION)
self._convention.setToolTip(CONVENTION)
# Create radio box Refactor
self._refactor = QtWidgets.QRadioButton(self)
self._refactor.setText(REFACTOR)
self._refactor.setToolTip(REFACTOR)
# Create radio box Warning
self._warning = QtWidgets.QRadioButton(self)
self._warning.setText(WARNING)
self._warning.setToolTip(WARNING)
# Create radio box Error
self._error = QtWidgets.QRadioButton(self)
self._error.setText(ERROR)
self._error.setToolTip(ERROR)
# Radio box event
self._all.toggled.connect(
lambda: self.on_radio_change_state(self._all))
self._convention.toggled.connect(
lambda: self.on_radio_change_state(self._convention))
self._refactor.toggled.connect(
lambda: self.on_radio_change_state(self._refactor))
self._warning.toggled.connect(
lambda: self.on_radio_change_state(self._warning))
self._error.toggled.connect(
lambda: self.on_radio_change_state(self._error))
# Create tree widget
self._tree = QtWidgets.QTreeWidget(self)
self._tree.setColumnCount(5)
self._tree.setHeaderLabels(
["Description", "File", "Code", "Line", "Column"])
self._tree.setColumnWidth(0, 400)
self._tree.setColumnWidth(1, 80)
self._tree.setHeaderHidden(False)
self._tree.setSortingEnabled(True)
self._tree.sortItems(1, QtCore.Qt.AscendingOrder)
self._tree.sortItems(2, QtCore.Qt.AscendingOrder)
self._tree.setRootIsDecorated(False)
# style
# set widget stye
background = self.get_theme_item(item="editor.text")
textcolor = self.get_theme_item(item="syntax.identifier")
style_keys = ["background-color", "color"]
style_values = [background["back"], textcolor["fore"]]
self.set_widget_style_sheet(self._tree, style_keys, style_values)
# event
self._tree.clicked.connect(self.on_item_clicked)
# Create two sizers
self._sizer1 = QtWidgets.QVBoxLayout(self)
self._sizer2 = QtWidgets.QHBoxLayout()
self._sizer4 = QtWidgets.QHBoxLayout()
#
self._sizer1.setSpacing(2)
self._sizer1.setContentsMargins(0, 0, 0, 0)
# Set layout
self._sizer1.addLayout(self._sizer2, 0)
self._sizer1.addLayout(self._sizer4, 0)
self._sizer1.addWidget(self._tree, 1)
#
self._sizer2.addWidget(self._reload, 0)
self._sizer2.addWidget(self._scope, 0)
self._sizer2.addWidget(self._ratings, 0)
self._sizer2.addWidget(self._font_options, 0)
#
self._sizer4.addWidget(self._all, 0)
self._sizer4.addWidget(self._convention, 0)
self._sizer4.addWidget(self._refactor, 0)
self._sizer4.addWidget(self._warning, 0)
self._sizer4.addWidget(self._error, 0)
self._sizer4.addWidget(self._open_file, 0)
#
self.setLayout(self._sizer1)
