def __init__(self, parent=None):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle("Install a conda env?")
self.setModal(True)
text = "Pyzo is only an editor. To execute code, you need a Python environment.\n\n"
text += "Do you want Pyzo to install a Python environment (miniconda)?\n"
text += "If not, you must arrange for a Python interpreter yourself"
if not sys.platform.startswith("win"):
text += " or use the system Python"
text += "."
text += "\n(You can always launch the installer from the shell menu.)"
self._label = QtWidgets.QLabel(text, self)
self._no = QtWidgets.QPushButton("No thanks (dont ask again)")
self._yes = QtWidgets.QPushButton("Yes, please install Python!")
self._no.clicked.connect(self.reject)
self._yes.clicked.connect(self.accept)
vbox = QtWidgets.QVBoxLayout(self)
hbox = QtWidgets.QHBoxLayout()
self.setLayout(vbox)
vbox.addWidget(self._label, 1)
vbox.addLayout(hbox, 0)
hbox.addWidget(self._no, 2)
hbox.addWidget(self._yes, 2)
self._yes.setDefault(1)
def __init__(self, parent, i):
QtWidgets.QWizardPage.__init__(self, parent)
self._i = i
# Create label for description
self._text_label = QtWidgets.QLabel(self)
self._text_label.setTextFormat(QtCore.Qt.RichText)
self._text_label.setWordWrap(True)
# Create label for image
self._comicLabel = QtWidgets.QLabel(self)
pm = QtGui.QPixmap()
if "logo" in self._image_filename:
pm.load(
os.path.join(
pyzo.pyzoDir, "resources", "appicons", self._image_filename
)
)
elif self._image_filename:
pm.load(
os.path.join(pyzo.pyzoDir, "resources", "images", self._image_filename)
)
self._comicLabel.setPixmap(pm)
self._comicLabel.setAlignment(QtCore.Qt.AlignHCenter | QtCore.Qt.AlignVCenter)
# Layout
theLayout = QtWidgets.QVBoxLayout(self)
self.setLayout(theLayout)
#
theLayout.addWidget(self._text_label)
theLayout.addStretch()
theLayout.addWidget(self._comicLabel)
theLayout.addStretch()
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# Get config
toolId = self.__class__.__name__.lower(
) + "2" # This is v2 of the file browser
if toolId not in pyzo.config.tools:
pyzo.config.tools[toolId] = ssdf.new()
self.config = pyzo.config.tools[toolId]
# Ensure three main attributes in config
for name in ["expandedDirs", "starredDirs"]:
if name not in self.config:
self.config[name] = []
# Ensure path in config
if "path" not in self.config or not isdir(self.config.path):
self.config.path = op.expanduser("~")
# Check expandedDirs and starredDirs.
# Make path objects and remove invalid dirs. Also normalize case,
# should not be necessary, but maybe the config was manually edited.
expandedDirs, starredDirs = [], []
for d in self.config.starredDirs:
if "path" in d and "name" in d and "addToPythonpath" in d:
if isdir(d.path):
d.path = op.normcase(cleanpath(d.path))
starredDirs.append(d)
for p in set([str(p) for p in self.config.expandedDirs]):
if isdir(p):
p = op.normcase(cleanpath(p))
# Add if it is a subdir of a starred dir
for d in starredDirs:
if p.startswith(d.path):
expandedDirs.append(p)
break
self.config.expandedDirs, self.config.starredDirs = expandedDirs, starredDirs
# Create browser(s).
self._browsers = []
for i in [0]:
self._browsers.append(Browser(self, self.config))
# Layout
layout = QtWidgets.QVBoxLayout(self)
self.setLayout(layout)
layout.addWidget(self._browsers[0])
layout.setSpacing(0)
# set margins
margin = pyzo.config.view.widgetMargin
layout.setContentsMargins(margin, margin, margin, margin)
def __init__(self, parent):
super().__init__(parent)
self._label = QtWidgets.QLabel("hello world")
self._label.setTextFormat(QtCore.Qt.RichText)
self._label.setWordWrap(True)
# self._label.setOpenExternalLinks(True)
self._label.linkActivated.connect(self.handle_link)
font = self._label.font()
font.setPointSize(font.pointSize() + 2)
self._label.setFont(font)
layout = QtWidgets.QVBoxLayout()
self.setLayout(layout)
layout.addWidget(self._label, 1)
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# logger widget
self._logger_shell = PyzoLoggerShell(self)
# set layout
self.layout = QtWidgets.QVBoxLayout(self)
self.layout.addWidget(self._logger_shell, 1)
# spacing of widgets
self.layout.setSpacing(0)
# set margins
margin = pyzo.config.view.widgetMargin
self.layout.setContentsMargins(margin, margin, margin, margin)
self.setLayout(self.layout)
def __init__(self, parent=None):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle("Install miniconda")
self.setModal(True)
self.resize(500, 500)
text = translate(
"bootstrapconda",
"This will download and install miniconda on your computer.",
)
self._label = QtWidgets.QLabel(text, self)
self._scipystack = QtWidgets.QCheckBox(
translate("bootstrapconda", "Also install scientific packages"), self
)
self._scipystack.setChecked(True)
self._path = QtWidgets.QLineEdit(default_conda_dir, self)
self._progress = QtWidgets.QProgressBar(self)
self._outputLine = QtWidgets.QLabel(self)
self._output = QtWidgets.QPlainTextEdit(self)
self._output.setReadOnly(True)
self._button = QtWidgets.QPushButton("Install", self)
self._outputLine.setSizePolicy(
QtWidgets.QSizePolicy.Ignored, QtWidgets.QSizePolicy.Fixed
)
vbox = QtWidgets.QVBoxLayout(self)
self.setLayout(vbox)
vbox.addWidget(self._label, 0)
vbox.addWidget(self._path, 0)
vbox.addWidget(self._scipystack, 0)
vbox.addWidget(self._progress, 0)
vbox.addWidget(self._outputLine, 0)
vbox.addWidget(self._output, 1)
vbox.addWidget(self._button, 0)
self._button.clicked.connect(self.go)
self.addOutput(translate("bootstrapconda", "Waiting to start installation.\n"))
self._progress.setVisible(False)
self.lineFromStdOut.connect(self.setStatus)
def __init__(self, engine):
super().__init__()
self._engine = engine
layout = QtWidgets.QVBoxLayout(self)
add_button = QtWidgets.QPushButton("Add")
del_button = QtWidgets.QPushButton("Delete")
self._view = QtWidgets.QListView()
layout.addWidget(self._view)
layout2 = QtWidgets.QHBoxLayout()
layout2.addWidget(add_button)
layout2.addWidget(del_button)
layout.addLayout(layout2)
self._model = QtCore.QStringListModel()
self._view.setModel(self._model)
self._model.setStringList(self._engine.registeredDocumentations())
add_button.clicked.connect(self.add_doc)
del_button.clicked.connect(self.del_doc)
def __init__(self, parent):
QtWidgets.QDialog.__init__(self, parent)
self.setWindowTitle(pyzo.translate("menu dialog", "About Pyzo"))
self.resize(600, 500)
# Layout
layout = QtWidgets.QVBoxLayout(self)
self.setLayout(layout)
# Create image and title
im = QtGui.QPixmap(
os.path.join(pyzo.pyzoDir, "resources", "appicons",
"pyzologo64.png"))
imlabel = QtWidgets.QLabel(self)
imlabel.setPixmap(im)
textlabel = QtWidgets.QLabel(self)
textlabel.setText("<h3>Pyzo: the Interactive Editor for Python</h3>")
#
titleLayout = QtWidgets.QHBoxLayout()
titleLayout.addWidget(imlabel, 0)
titleLayout.addWidget(textlabel, 1)
#
layout.addLayout(titleLayout, 0)
# Create tab bar
self._tabs = QtWidgets.QTabWidget(self)
self._tabs.setDocumentMode(True)
layout.addWidget(self._tabs, 1)
# Create button box
self._butBox = QtWidgets.QDialogButtonBox(self)
self._butBox.setOrientation(QtCore.Qt.Horizontal)
self._butBox.setStandardButtons(self._butBox.Close)
layout.addWidget(self._butBox, 0)
# Signals
self._butBox.rejected.connect(self.close)
# Create tabs
self.createGeneralTab()
def __init__(self, parent, distro=None):
QtWidgets.QWidget.__init__(self, parent)
self.setMinimumSize(360, 256) # Ensure title fits nicely
# Create label widget and costumize
self._label = QtWidgets.QLabel(self)
self._label.setTextFormat(QtCore.Qt.RichText)
self._label.setOpenExternalLinks(True)
self._label.setWordWrap(True)
self._label.setMargin(20)
# Set font size (absolute value)
font = self._label.font()
font.setPointSize(11) # (font.pointSize()+1)
self._label.setFont(font)
# Build
text_title = translate(
"splash",
"This is <b>Pyzo</b><br />the Python IDE for scientific computing")
text_version = translate("splash", "Version")
text_os = translate(
"splash",
"Pyzo is open source software and freely available for everyone.")
text = splash_text.format(
version=pyzo.__version__,
text_title=text_title,
text_version=text_version,
text_os=text_os,
)
# Set text
self._label.setText(text)
layout = QtWidgets.QVBoxLayout(self)
self.setLayout(layout)
layout.addStretch(1)
layout.addWidget(self._label, 0)
layout.addStretch(1)
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# create toolbar
self._toolbar = QtWidgets.QToolBar(self)
self._toolbar.setMaximumHeight(26)
self._toolbar.setIconSize(QtCore.QSize(16, 16))
# create stack
self._stack = QtWidgets.QStackedWidget(self)
# Populate toolbar
self._shellButton = ShellControl(self._toolbar, self._stack)
self._debugmode = 0
self._dbs = DebugStack(self._toolbar)
#
self._toolbar.addWidget(self._shellButton)
self._toolbar.addSeparator()
# self._toolbar.addWidget(self._dbc) -> delayed, see addContextMenu()
self._interpreterhelp = InterpreterHelper(self)
# widget layout
layout = QtWidgets.QVBoxLayout()
layout.setSpacing(0)
# set margins
margin = pyzo.config.view.widgetMargin
layout.setContentsMargins(margin, margin, margin, margin)
layout.addWidget(self._toolbar)
layout.addWidget(self._stack, 0)
layout.addWidget(self._interpreterhelp, 0)
self.setLayout(layout)
# make callbacks
self._stack.currentChanged.connect(self.onCurrentChanged)
self.showInterpreterHelper()
def __init__(self, parent=None, collection_filename=None):
"""
Initializes an assistance instance.
When collection_file is none, it is determined from the
appDataDir.
"""
from pyzo.qt import QtHelp
super().__init__(parent)
self.setWindowTitle("Help")
pyzoDir, appDataDir, appConfigDir = getResourceDirs()
if collection_filename is None:
# Collection file is stored in pyzo data dir:
collection_filename = os.path.join(appDataDir, "tools", "docs.qhc")
self._engine = QtHelp.QHelpEngine(collection_filename)
# Important, call setup data to load the files:
self._engine.setupData()
# If no files are loaded, register at least the pyzo docs:
if len(self._engine.registeredDocumentations()) == 0:
doc_file = os.path.join(pyzoDir, "resources", "pyzo.qch")
self._engine.registerDocumentation(doc_file)
# The main players:
self._content = self._engine.contentWidget()
self._index = self._engine.indexWidget()
self._indexTab = QtWidgets.QWidget()
il = QtWidgets.QVBoxLayout(self._indexTab)
filter_text = QtWidgets.QLineEdit()
il.addWidget(filter_text)
il.addWidget(self._index)
self._helpBrowser = HelpBrowser(self._engine)
self._searchEngine = self._engine.searchEngine()
self._settings = Settings(self._engine)
self._progress = QtWidgets.QWidget()
pl = QtWidgets.QHBoxLayout(self._progress)
bar = QtWidgets.QProgressBar()
bar.setMaximum(0)
pl.addWidget(QtWidgets.QLabel("Indexing"))
pl.addWidget(bar)
self._searchResultWidget = self._searchEngine.resultWidget()
self._searchQueryWidget = self._searchEngine.queryWidget()
self._searchTab = QtWidgets.QWidget()
search_layout = QtWidgets.QVBoxLayout(self._searchTab)
search_layout.addWidget(self._searchQueryWidget)
search_layout.addWidget(self._searchResultWidget)
tab = QtWidgets.QTabWidget()
tab.addTab(self._content, "Contents")
tab.addTab(self._indexTab, "Index")
tab.addTab(self._searchTab, "Search")
tab.addTab(self._settings, "Settings")
splitter = QtWidgets.QSplitter(self)
splitter.addWidget(tab)
splitter.addWidget(self._helpBrowser)
layout = QtWidgets.QVBoxLayout(self)
layout.addWidget(splitter)
layout.addWidget(self._progress)
# Connect clicks:
self._content.linkActivated.connect(self._helpBrowser.setSource)
self._index.linkActivated.connect(self._helpBrowser.setSource)
self._searchEngine.searchingFinished.connect(self.onSearchFinish)
self._searchEngine.indexingStarted.connect(self.onIndexingStarted)
self._searchEngine.indexingFinished.connect(self.onIndexingFinished)
filter_text.textChanged.connect(self._index.filterIndices)
self._searchResultWidget.requestShowLink.connect(
self._helpBrowser.setSource)
self._searchQueryWidget.search.connect(self.goSearch)
# Always re-index on startup:
self._searchEngine.reindexDocumentation()
self._search_term = None
# Show initial page:
# self.showHelpForTerm('welcome to pyzo')
self._helpBrowser.setHtml(help_help)
def __init__(self, parent):
QtWidgets.QWidget.__init__(self, parent)
# Create text field, checkbox, and button
self._text = QtWidgets.QLineEdit(self)
self._printBut = QtWidgets.QPushButton("Print", self)
style = QtWidgets.qApp.style()
self._backBut = QtWidgets.QToolButton(self)
self._backBut.setIcon(style.standardIcon(style.SP_ArrowLeft))
self._backBut.setIconSize(QtCore.QSize(16, 16))
self._backBut.setPopupMode(self._backBut.DelayedPopup)
self._backBut.setMenu(
PyzoInteractiveHelpHistoryMenu("Backward menu", self, False))
self._forwBut = QtWidgets.QToolButton(self)
self._forwBut.setIcon(style.standardIcon(style.SP_ArrowRight))
self._forwBut.setIconSize(QtCore.QSize(16, 16))
self._forwBut.setPopupMode(self._forwBut.DelayedPopup)
self._forwBut.setMenu(
PyzoInteractiveHelpHistoryMenu("Forward menu", self, True))
# Create options button
self._options = QtWidgets.QToolButton(self)
self._options.setIcon(pyzo.icons.wrench)
self._options.setIconSize(QtCore.QSize(16, 16))
self._options.setPopupMode(self._options.InstantPopup)
self._options.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
# Create options menu
self._options._menu = QtWidgets.QMenu()
self._options.setMenu(self._options._menu)
# Create browser
self._browser = QtWidgets.QTextBrowser(self)
self._browser_text = initText
self._browser.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self._browser.customContextMenuRequested.connect(self.showMenu)
# Create two sizers
self._sizer1 = QtWidgets.QVBoxLayout(self)
self._sizer2 = QtWidgets.QHBoxLayout()
# Put the elements together
self._sizer2.addWidget(self._backBut, 1)
self._sizer2.addWidget(self._forwBut, 2)
self._sizer2.addWidget(self._text, 4)
self._sizer2.addWidget(self._printBut, 0)
self._sizer2.addWidget(self._options, 3)
#
self._sizer1.addLayout(self._sizer2, 0)
self._sizer1.addWidget(self._browser, 1)
#
self._sizer1.setSpacing(2)
# set margins
margin = pyzo.config.view.widgetMargin
self._sizer1.setContentsMargins(margin, margin, margin, margin)
self.setLayout(self._sizer1)
# Set config
toolId = self.__class__.__name__.lower()
self._config = config = pyzo.config.tools[toolId]
#
if not hasattr(config, "smartNewlines"):
config.smartNewlines = True
if not hasattr(config, "fontSize"):
if sys.platform == "darwin":
config.fontSize = 12
else:
config.fontSize = 10
# Create callbacks
self._text.returnPressed.connect(self.queryDoc)
self._printBut.clicked.connect(self.printDoc)
self._backBut.clicked.connect(self.goBack)
self._forwBut.clicked.connect(self.goForward)
#
self._options.pressed.connect(self.onOptionsPress)
self._options._menu.triggered.connect(self.onOptionMenuTiggered)
# Start
self._history = []
self._histindex = 0
self.setText() # Set default text
self.onOptionsPress() # Fill menu
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]
if not hasattr(self._config, "showTypes"):
self._config.showTypes = ["class", "def", "cell", "todo"]
if not hasattr(self._config, "level"):
self._config.level = 2
# Keep track of clicks so we can "go back"
self._nav = {} # editor-id -> Navigation object
# Create buttons for navigation
self._navbut_back = QtWidgets.QToolButton(self)
self._navbut_back.setIcon(pyzo.icons.arrow_left)
self._navbut_back.setIconSize(QtCore.QSize(16, 16))
self._navbut_back.setStyleSheet(
"QToolButton { border: none; padding: 0px; }")
self._navbut_back.clicked.connect(self.onNavBack)
#
self._navbut_forward = QtWidgets.QToolButton(self)
self._navbut_forward.setIcon(pyzo.icons.arrow_right)
self._navbut_forward.setIconSize(QtCore.QSize(16, 16))
self._navbut_forward.setStyleSheet(
"QToolButton { border: none; padding: 0px; }")
self._navbut_forward.clicked.connect(self.onNavForward)
# # Create icon for slider
# self._sliderIcon = QtWidgets.QToolButton(self)
# self._sliderIcon.setIcon(pyzo.icons.text_align_right)
# self._sliderIcon.setIconSize(QtCore.QSize(16,16))
# self._sliderIcon.setStyleSheet("QToolButton { border: none; padding: 0px; }")
# Create slider
self._slider = QtWidgets.QSlider(QtCore.Qt.Horizontal, self)
self._slider.setTickPosition(QtWidgets.QSlider.TicksBelow)
self._slider.setSingleStep(1)
self._slider.setPageStep(1)
self._slider.setRange(1, 5)
self._slider.setValue(self._config.level)
self._slider.valueChanged.connect(self.updateStructure)
# Create options button
# self._options = QtWidgets.QPushButton(self)
# self._options.setText('Options'))
# self._options.setToolTip("What elements to show.")
self._options = QtWidgets.QToolButton(self)
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)
# Create options menu
self._options._menu = QtWidgets.QMenu()
self._options.setMenu(self._options._menu)
# Create tree widget
self._tree = QtWidgets.QTreeWidget(self)
self._tree.setHeaderHidden(True)
self._tree.itemCollapsed.connect(self.updateStructure) # keep expanded
self._tree.itemClicked.connect(self.onItemClick)
# Create two sizers
self._sizer1 = QtWidgets.QVBoxLayout(self)
self._sizer2 = QtWidgets.QHBoxLayout()
self._sizer1.setSpacing(2)
# set margins
margin = pyzo.config.view.widgetMargin
self._sizer1.setContentsMargins(margin, margin, margin, margin)
# Set layout
self._sizer1.addLayout(self._sizer2, 0)
self._sizer1.addWidget(self._tree, 1)
# self._sizer2.addWidget(self._sliderIcon, 0)
self._sizer2.addWidget(self._navbut_back, 0)
self._sizer2.addWidget(self._navbut_forward, 0)
self._sizer2.addStretch(1)
self._sizer2.addWidget(self._slider, 6)
self._sizer2.addStretch(1)
self._sizer2.addWidget(self._options, 0)
#
self.setLayout(self._sizer1)
# Init current-file name
self._currentEditorId = 0
# Bind to events
pyzo.editors.currentChanged.connect(self.onEditorsCurrentChanged)
pyzo.editors.parserDone.connect(self.updateStructure)
self._options.pressed.connect(self.onOptionsPress)
self._options._menu.triggered.connect(self.onOptionMenuTiggered)
# Start
# When the tool is loaded, the editorStack is already done loading
# all previous files and selected the appropriate file.
self.onOptionsPress() # Create menu now
self.onEditorsCurrentChanged()
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)
# set margins
margin = pyzo.config.view.widgetMargin
self._sizer1.setContentsMargins(margin, margin, margin, margin)
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, 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, *args):
QtWidgets.QDialog.__init__(self, *args)
self.setModal(True)
# Set title
self.setWindowTitle(pyzo.translate("shell", "Shell configurations"))
# Create tab widget
self._tabs = QtWidgets.QTabWidget(self)
# self._tabs = CompactTabWidget(self, padding=(4,4,5,5))
# self._tabs.setDocumentMode(False)
self._tabs.setMovable(True)
# Get known interpreters (sorted them by version)
# Do this here so we only need to do it once ...
from pyzo.util.interpreters import get_interpreters
self.interpreters = list(reversed(get_interpreters("2.4")))
# Introduce an entry if there's none
if not pyzo.config.shellConfigs2:
w = ShellInfoTab(self._tabs)
self._tabs.addTab(w, "---")
w.setInfo()
# Fill tabs
for item in pyzo.config.shellConfigs2:
w = ShellInfoTab(self._tabs)
self._tabs.addTab(w, "---")
w.setInfo(item)
# Enable making new tabs and closing tabs
self._add = QtWidgets.QToolButton(self)
self._tabs.setCornerWidget(self._add)
self._add.clicked.connect(self.onAdd)
self._add.setToolButtonStyle(QtCore.Qt.ToolButtonTextBesideIcon)
self._add.setIcon(pyzo.icons.add)
self._add.setText(translate("shell", "Add config"))
#
# self._tabs.setTabsClosable(True)
self._tabs.tabCloseRequested.connect(self.onTabClose)
# Create buttons
cancelBut = QtWidgets.QPushButton("Cancel", self)
okBut = QtWidgets.QPushButton("Done", self)
cancelBut.clicked.connect(self.close)
okBut.clicked.connect(self.applyAndClose)
# Layout for buttons
buttonLayout = QtWidgets.QHBoxLayout()
buttonLayout.addStretch(1)
buttonLayout.addWidget(cancelBut)
buttonLayout.addSpacing(10)
buttonLayout.addWidget(okBut)
# Layout the widgets
mainLayout = QtWidgets.QVBoxLayout(self)
mainLayout.addSpacing(8)
mainLayout.addWidget(self._tabs, 0)
mainLayout.addLayout(buttonLayout, 0)
self.setLayout(mainLayout)
# Prevent resizing
self.show()
self.setMinimumSize(500, 400)
self.resize(640, 500)
def __init__(self):
super().__init__()
from pyzo.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
# 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", 0)
self.combobox_orientation.addItem("Landscape", 1)
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) # orientation appears to be broken
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]
if not hasattr(self._config, "hideTypes"):
self._config.hideTypes = []
# <kludge 2>
# configuring the typeTranslation dictionary
if not hasattr(self._config, "typeTranslation"):
# to prevent the exception to be raised, one could init to :
# {"method": "function", "function": "function", "type": "type", "private": "private", "module": "module"}
self._config.typeTranslation = {}
# Defaults
self._config.typeTranslation["method"] = "function"
self._config.typeTranslation["builtin_function_or_method"] = "function"
# <kludge 2>
# Create tool button
self._up = QtWidgets.QToolButton(self)
style = QtWidgets.qApp.style()
self._up.setIcon(style.standardIcon(style.SP_ArrowLeft))
self._up.setIconSize(QtCore.QSize(16, 16))
# 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 options menu
self._options = QtWidgets.QToolButton(self)
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)
#
self._options._menu = QtWidgets.QMenu()
self._options.setMenu(self._options._menu)
self.onOptionsPress() # create menu now
# Create tree
self._tree = WorkspaceTree(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)
# Set layout
layout = QtWidgets.QHBoxLayout()
layout.addWidget(self._up, 0)
layout.addWidget(self._line, 1)
layout.addWidget(self._options, 0)
#
mainLayout = QtWidgets.QVBoxLayout(self)
mainLayout.addLayout(layout, 0)
mainLayout.addWidget(self._initText, 1)
mainLayout.addWidget(self._tree, 2)
mainLayout.setSpacing(2)
# set margins
margin = pyzo.config.view.widgetMargin
mainLayout.setContentsMargins(margin, margin, margin, margin)
self.setLayout(mainLayout)
# Bind events
self._up.pressed.connect(self._tree._proxy.goUp)
self._options.pressed.connect(self.onOptionsPress)
self._options._menu.triggered.connect(self.onOptionMenuTiggered)
def __init__(self, parent=None):
super().__init__(parent)
# Widgets
self._search = QtWidgets.QLineEdit(self)
self._list = QtWidgets.QListWidget(self)
# Set monospace
font = self._list.font()
font.setFamily(pyzo.config.view.fontname)
self._list.setFont(font)
# Layout
layout = QtWidgets.QVBoxLayout(self)
self.setLayout(layout)
layout.addWidget(self._search, 0)
layout.addWidget(self._list, 1)
# set margins
margin = pyzo.config.view.widgetMargin
layout.setContentsMargins(margin, margin, margin, margin)
# Customize line edit
self._search.setPlaceholderText(translate("menu", "Search"))
self._search.textChanged.connect(self._on_search)
# Drag/drop
self._list.setSelectionMode(self._list.ExtendedSelection)
self._list.setDragEnabled(True)
self._list.doubleClicked.connect(self._onDoubleClicked)
# Context menu
self._menu = Menu(self, translate("menu", "History"))
self._menu.addItem(
translate("menu", "Copy ::: Copy selected lines"),
pyzo.icons.page_white_copy,
self.copy,
"copy",
)
self._menu.addItem(
translate("menu", "Run ::: Run selected lines in current shell"),
pyzo.icons.run_lines,
self.runSelection,
"run",
)
self._menu.addItem(
translate("menu", "Remove ::: Remove selected history items(s)"),
pyzo.icons.delete,
self.removeSelection,
"remove",
)
self._list.setContextMenuPolicy(QtCore.Qt.CustomContextMenu)
self._list.customContextMenuRequested.connect(
self._onCustomContextMenuRequested)
# Populate
for command in pyzo.command_history.get_commands():
self._list.addItem(command)
# Scroll to end of list on start up
self._list.setCurrentRow(self._list.count() - 1)
item = self._list.currentItem()
self._list.scrollToItem(item)
# Keep up to date ...
pyzo.command_history.command_added.connect(self._on_command_added)
pyzo.command_history.command_removed.connect(self._on_command_removed)
pyzo.command_history.commands_reset.connect(self._on_commands_reset)