def show():
"""
An example of embedding a RichJupyterWidget with an in-process kernel.
We recommend using a kernel in a separate process as the normal option - see
embed_qtconsole.py for more information. In-process kernels are not well
supported.
To run this example:
python3 inprocess_qtconsole.py
"""
#global ipython_widget # Prevent from being garbage collected
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=True)
# kernel = kernel_manager.kernel
# kernel.gui = 'qt5'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
return ipython_widget
def createConsole(parent):
"""
disclaimer: this code is not mine. I copied it to get an embedded console
It will be modified at some point to attempt interactability
source: https://stackoverflow.com/a/26676570
:param parent:
:return:
"""
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
kernel_client.namespace = parent
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
layout = QVBoxLayout(parent)
widget = RichJupyterWidget(parent=parent)
layout.addWidget(widget, Qt.AlignRight)
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
ipython_widget = widget
ipython_widget.show()
kernel.shell.push({'widget': widget, 'kernel': kernel, 'parent': parent})
return {'widget': widget, 'kernel': kernel}
def createConsoleTab(self):
""" Initialize a python console and return its widget """
from qtconsole.rich_jupyter_widget import RichJupyterWidget
from qtconsole.manager import QtKernelManager
kernel_manager = QtKernelManager(kernel_name='python3')
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
kernel_client.namespace = self
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
widget = RichJupyterWidget(parent=self)
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
ipython_widget = widget
ipython_widget.show()
self.kernel_client = kernel_client
#kernel_client.execute("import devices.demo.demo")
return widget
def make_jupyter_widget_with_kernel():
"""Start a kernel, connect to it, and create a RichJupyterWidget to use it
"""
kernel_manager = QtKernelManager(kernel_name=USE_KERNEL)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget()
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
return jupyter_widget
def create(user_ns):
"""Create an in-process kernel."""
manager = QtInProcessKernelManager()
manager.start_kernel(show_banner=False)
kernel = manager.kernel
kernel.gui = 'qt4'
kernel.user_ns = user_ns
client = manager.client()
client.start_channels()
widget = RichJupyterWidget()
widget.kernel_manager = manager
widget.kernel_client = client
return widget
def make_jupyter_widget_with_kernel(self):
"""Start a kernel, connect to it, and create a RichJupyterWidget to use it
"""
USE_KERNEL = 'python3'
kernel_manager = QtKernelManager(kernel_name=USE_KERNEL)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget()
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
jupyter_widget._display_banner = False
return jupyter_widget
def start_kernel(self, kernel: str):
kernel_manager = QtKernelManager(kernel_name=kernel)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget()
jupyter_widget.style_sheet = get_theme_contents(
"dracula", "jupyter.css")
jupyter_widget.syntax_style = "dracula"
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
return jupyter_widget # Binding this to a variable won't work.
def show():
global ipython_widget # Prevent from being garbage collected
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
ipython_widget.show()
def show():
global ipython_widget # Prevent from being garbage collected
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
ipython_widget.show()
def make_jupyter_widget():
"""Start a kernel, connect to it, and create a RichJupyterWidget to use it
"""
global ipython_widget
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
return ipython_widget
def make_jupyter_widget_with_kernel():
"""
Start a kernel, connect to it, and create a RichJupyterWidget to use it
"""
kernel_manager = QtInProcessKernelManager(kernel_name='python3')
kernel_manager.start_kernel(show_banner=True)
kernel = kernel_manager.kernel
kernel.io_loop = app.get().asyncio_loop()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget(gui_completion="droplist")
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
return jupyter_widget
def independent_qtconsole():
kernel_manager = QtKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
ipython_widget.show()
return ipython_widget
def __init__(self):
# # Enforce global style within the console
# with open('xicam/gui/style.stylesheet', 'r') as f:
# style = f.read()
# style = (qdarkstyle.load_stylesheet() + style)
# Setup the kernel
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
kernel = self.kernel_manager.kernel
kernel.gui = 'qt'
# Push Xi-cam variables into the kernel
kernel.shell.push({
plugin.name: plugin
for plugin in pluginmanager.get_plugins_of_type("GUIPlugin") +
pluginmanager.get_plugins_of_type("EZPlugin")
})
# Observe plugin changes
pluginmanager.attach(self.pluginsChanged)
# Continue kernel setuppluginmanager.getPluginsOfCategory("GUIPlugin")
self.kernel_client = self.kernel_manager.client()
threads.invoke_in_main_thread(self.kernel_client.start_channels)
# Setup console widget
def stop():
self.kernel_client.stop_channels()
self.kernel_manager.shutdown_kernel()
control = RichJupyterWidget()
control.kernel_manager = self.kernel_manager
threads.invoke_in_main_thread(setattr, control, "kernel_client",
self.kernel_client)
control.exit_requested.connect(stop)
# control.style_sheet = style
control.syntax_style = u'monokai'
control.set_default_style(colors='Linux')
# Setup layout
self.stages = {'Terminal': GUILayout(control)}
# Save for later
self.kernel = kernel
super(IPythonPlugin, self).__init__()
def __init__(self, namespace, windowtitle=None):
from .. import qt_error
if qt_error is not None:
self._dummy = True
return
self.namespace = namespace
self.kernel_manager = MyQtInProcessKernelManager()
self.kernel_manager.start_kernel(namespace)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
control = RichJupyterWidget()
self.control = control
control.kernel_manager = self.kernel_manager
control.kernel_client = self.kernel_client
if windowtitle is not None:
control.setWindowTitle("Seamless shell: " + windowtitle)
control.show()
def show_console(self):
global ipython_widget # Prevent from being garbage collected
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
ipython_widget.show()
ipython_widget.append_stream("from ConsoleInterface import *\n")
def terminal_widget(**kwargs):
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push(kwargs)
kernel_client = kernel_manager.client()
kernel_client.start_channels()
control = RichJupyterWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
return control
def terminal_widget(**kwargs):
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push(kwargs)
kernel_client = kernel_manager.client()
kernel_client.start_channels()
control = RichJupyterWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
return control
def _make_jupyter_widget_with_kernel(kernel_name):
"""
Start a kernel, connect to it, and create a RichJupyterWidget to use it.
Parameters
----------
kernel_name : str
Kernel name to use.
"""
kernel_manager = QtKernelManager(kernel_name=kernel_name)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget()
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
return jupyter_widget
def __init__(self, layout, sim, gui):
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.write("Welcome to AO Sim!")
config = sim.config
#Pass some useful objects to the user
usefulObjects = {
"sim": sim,
"gui": gui,
"config": config,
"simConfig": sim.config.sim,
"telConfig": sim.config.tel,
"atmosConfig": sim.config.atmos
}
for i in range(sim.config.sim.nGS):
usefulObjects["wfs{}Config".format(i)] = sim.config.wfss[i]
for i in range(sim.config.sim.nDM):
usefulObjects["dm{}Config".format(i)] = sim.config.dms[i]
for i in range(sim.config.sim.nSci):
usefulObjects["sci{}Config".format(i)] = sim.config.scis[i]
self.kernel.shell.push(usefulObjects)
#kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
control = RichIPythonWidget()
control.kernel_manager = self.kernel_manager
control.kernel_client = self.kernel_client
control.exit_requested.connect(self.stop)
layout.addWidget(control)
self.kernel.shell.ex("")
def __init__(self, layout, sim, gui):
# Create an in-process kernel
self.kernel_manager = QtInProcessKernelManager()
# self.kernel_manager = QtKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
# self.kernel.shell.write("Welcome to AO Sim!\n")
config = sim.config
#Pass some useful objects to the user
usefulObjects = {
"sim": sim,
"gui": gui,
"config": config,
"simConfig": sim.config.sim,
"telConfig": sim.config.tel,
"atmosConfig": sim.config.atmos,
"np": numpy,
"plt": pyplot
}
for i in range(sim.config.sim.nGS):
usefulObjects["wfs{}Config".format(i)] = sim.config.wfss[i]
for i in range(sim.config.sim.nDM):
usefulObjects["dm{}Config".format(i)] = sim.config.dms[i]
for i in range(sim.config.sim.nSci):
usefulObjects["sci{}Config".format(i)] = sim.config.scis[i]
self.kernel.shell.push(usefulObjects)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
control = RichIPythonWidget()
control.kernel_manager = self.kernel_manager
control.kernel_client = self.kernel_client
control.exit_requested.connect(self.stop)
layout.addWidget(control)
def __init__(self, layout, sim, gui):
# Create an in-process kernel
# >>> print_process_id()
# will print the same process ID as the main process
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.gui = 'qt4'
self.kernel.shell.write("Welcome to AO Sim!")
config = sim.config
#Pass some useful objects to the user
usefulObjects = { "sim" : sim,
"gui" : gui,
"config" : config,
"simConfig" : sim.config.sim,
"telConfig" : sim.config.tel,
"atmosConfig" : sim.config.atmos}
for i in range(sim.config.sim.nGS):
usefulObjects["wfs{}Config".format(i)] = sim.config.wfss[i]
for i in range(sim.config.sim.nDM):
usefulObjects["dm{}Config".format(i)] = sim.config.dms[i]
for i in range(sim.config.sim.nSci):
usefulObjects["sci{}Config".format(i)] = sim.config.scis[i]
self.kernel.shell.push(usefulObjects)
#kernel.shell.push({'foo': 43, 'print_process_id': print_process_id})
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
control = RichIPythonWidget()
control.kernel_manager = self.kernel_manager
control.kernel_client = self.kernel_client
control.exit_requested.connect(self.stop)
layout.addWidget(control)
self.kernel.shell.ex("")
def __init__(self, project: 'Project') -> None:
super(JupyterConsoleDockWidget, self).__init__("Console")
self.setAllowedAreas(QtCore.Qt.BottomDockWidgetArea)
self.project = project
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.shell.push({'project': project})
kernel_client = kernel_manager.client()
kernel_client.start_channels()
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
self.setWidget(ipython_widget)
def __init__(self, layout, sim, gui):
# Create an in-process kernel
self.kernel_manager = QtInProcessKernelManager()
self.kernel_manager.start_kernel()
self.kernel = self.kernel_manager.kernel
self.kernel.shell.write("Welcome to AO Sim!\n")
config = sim.config
#Pass some useful objects to the user
usefulObjects = { "sim" : sim,
"gui" : gui,
"config" : config,
"simConfig" : sim.config.sim,
"telConfig" : sim.config.tel,
"atmosConfig" : sim.config.atmos,
"np" : numpy,
"plt" : pyplot}
for i in range(sim.config.sim.nGS):
usefulObjects["wfs{}Config".format(i)] = sim.config.wfss[i]
for i in range(sim.config.sim.nDM):
usefulObjects["dm{}Config".format(i)] = sim.config.dms[i]
for i in range(sim.config.sim.nSci):
usefulObjects["sci{}Config".format(i)] = sim.config.scis[i]
self.kernel.shell.push(usefulObjects)
self.kernel_client = self.kernel_manager.client()
self.kernel_client.start_channels()
control = RichIPythonWidget()
control.kernel_manager = self.kernel_manager
control.kernel_client = self.kernel_client
control.exit_requested.connect(self.stop)
layout.addWidget(control)
self.kernel.shell.ex("")
def __init__(self, *args, **kwargs):
with open('xicam/gui/style.stylesheet', 'r') as f:
style = f.read()
style = (qdarkstyle.load_stylesheet() + style)
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push(dict(plugins.plugins))
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
control = RichJupyterWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.style_sheet = style
control.syntax_style = u'monokai'
control.set_default_style(colors='Linux')
self.centerwidget = control
self.rightwidget = None
self.featureform = None
self.bottomwidget = None
self.leftwidget = None
self.toolbar = None
super(IPythonPlugin, self).__init__(*args, **kwargs)
def __init__(self, parent, customBanner=None, *args, **kwargs):
super(QIPythonWidget, self).__init__(parent)
self.plugin = parent
if customBanner is not None:
self.banner = customBanner
kernel_manager = QtKernelManager(kernel_name=USE_KERNEL)
kernel_manager.start_kernel()
kernel_client = kernel_manager.client()
kernel_client.start_channels()
jupyter_widget = RichJupyterWidget()
jupyter_widget.kernel_manager = kernel_manager
jupyter_widget.kernel_client = kernel_client
layout = QVBoxLayout()
layout.addWidget(jupyter_widget)
self.setLayout(layout)
def inprocess_qtconsole(self):
#w = QtGui.QWidget()
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False)
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
self.kernel_manager = kernel_manager
kernel_client = kernel_manager.client()
kernel_client.start_channels()
self.kernel_client = kernel_client
ipython_widget = RichJupyterWidget()
ipython_widget.kernel_manager = kernel_manager
ipython_widget.kernel_client = kernel_client
ipython_widget.exit_requested.connect(self.stop_inprocess)
ipython_widget.show()
self.ipython_widget = ipython_widget
return ipython_widget
def embed_ipy(parent, passthrough=None):
"""
Embed an ipython kernel into the parent widget using a RichJupyterWidget
:param parent: Qt Widget to receive the RichJupyterWidget
:param passthrough: dict containing variables to pass into scope of the IPython Kernel
Use this with caution; strange things can happen if you pass GUI elements to the IPython scope
and then call any of their show() or draw() methods.
:return: dict with reference to jupyter widget and ipython kernel
"""
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel_client = kernel_manager.client()
kernel_client.start_channels()
kernel_client.namespace = parent
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
layout = QtGui.QVBoxLayout(parent)
widget = RichJupyterWidget(parent=parent)
layout.addWidget(widget)
widget.kernel_manager = kernel_manager
widget.kernel_client = kernel_client
widget.exit_requested.connect(stop)
ipython_widget = widget
ipython_widget.show()
kernel.shell.push({'widget': widget, 'kernel': kernel, 'parent': parent})
# pass variables from main GUI environment into IPython Kernel namespace
if passthrough is not None:
kernel.shell.push(passthrough)
# variables stored in this dict are now accessible in the IPython shell
return {'widget': widget, 'kernel': kernel}
def __init__(self, args):
"""Initializes application"""
super(QSceneGraphEditor, self).__init__(args)
self._mainWindow = QtGui.QMainWindow()
self._editor = QSceneGraphEditorWindow()
self._mainWindow.setCentralWidget(self._editor)
exitAction = QtGui.QAction('&Exit', self._mainWindow)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self._mainWindow.close)
newAction = QtGui.QAction('&New', self._mainWindow)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('Creates a simple default scene')
newAction.triggered.connect(self._editor.new)
openAction = QtGui.QAction('&Open...', self._mainWindow)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open scene graph from file')
openAction.triggered.connect(self._editor.open)
saveAction = QtGui.QAction('&Save', self._mainWindow)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Save scene graph')
saveAction.triggered.connect(self._editor.save)
saveAsAction = QtGui.QAction('&Save As...', self._mainWindow)
saveAsAction.setStatusTip('Save scene graph to another file')
saveAsAction.triggered.connect(self._editor.saveAs)
insertObjectAction = QtGui.QAction('&Insert...', self._mainWindow)
insertObjectAction.setShortcut('Ctrl+I')
insertObjectAction.setStatusTip(
'Inserts new scene object before current one')
insertObjectAction.triggered.connect(
self._editor.inspectorWidget.insertObject)
appendObjectAction = QtGui.QAction('&Append...', self._mainWindow)
appendObjectAction.setShortcut('Ctrl+K')
appendObjectAction.setStatusTip(
'Inserts new scene object after current one')
appendObjectAction.triggered.connect(
self._editor.inspectorWidget.appendObject)
deleteObjectAction = QtGui.QAction('&Delete', self._mainWindow)
deleteObjectAction.setShortcut('DEL')
deleteObjectAction.setStatusTip(
'Deletes currently selected scene object')
deleteObjectAction.triggered.connect(
self._editor.inspectorWidget.deleteObject)
refreshObjectAction = QtGui.QAction('&Refresh', self._mainWindow)
refreshObjectAction.setShortcut('F5')
refreshObjectAction.setStatusTip('Recreates tree view from root node')
refreshObjectAction.triggered.connect(self._editor.refresh)
viewAllAction = QtGui.QAction('View &All', self._mainWindow)
viewAllAction.setShortcut('Ctrl+A')
viewAllAction.setStatusTip(
'Resets camera in scene so all object are visible')
viewAllAction.triggered.connect(
self._editor.previewWidget.sceneManager.view_all)
viewManipAction = QtGui.QAction('Camera &Manipulation',
self._mainWindow)
viewManipAction.setShortcut('Ctrl+M')
viewManipAction.setStatusTip(
'Enables manipulation of camera in the scene')
viewManipAction.setCheckable(True)
viewManipAction.setChecked(True)
viewManipAction.connect(
QtCore.SIGNAL("triggered(bool)"),
self._editor.previewWidget.sceneManager.interaction)
self._editor.previewWidget.sceneManager.interaction(True)
#self._mainWindow.statusBar()
menubar = self._mainWindow.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(saveAction)
fileMenu.addAction(saveAsAction)
fileMenu.addSeparator()
fileMenu.addAction(exitAction)
objectsMenu = menubar.addMenu('&Scene Object')
objectsMenu.addAction(insertObjectAction)
objectsMenu.addAction(appendObjectAction)
objectsMenu.addAction(deleteObjectAction)
objectsMenu.addSeparator()
objectsMenu.addAction(refreshObjectAction)
viewMenu = menubar.addMenu('&View')
viewMenu.addAction(viewAllAction)
viewMenu.addAction(viewManipAction)
if "--console" in self.arguments() or "--ipython" in self.arguments():
# start with IPython console at bottom of application
from qtconsole.rich_jupyter_widget import RichJupyterWidget
from qtconsole.inprocess import QtInProcessKernelManager
import inventor
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push({
'iv': inventor,
'root': self._editor._root,
'view': self._editor.previewWidget.sceneManager
})
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
self.exit()
control = RichJupyterWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.font = QtGui.QFont(control.font.family(), 10)
self.addVerticalWidget(control)
# load default scene or from file if argument is given
file = "#Inventor V2.1 ascii\n\nSeparator { " \
"DirectionalLight {} OrthographicCamera { position 0 0 5 height 5 }" \
"TrackballManip {} Material { diffuseColor 1 0 0 }" \
"Cone {} }"
if (len(self.arguments()) > 1) and ("." in self.arguments()[-1]):
extension = self.arguments()[-1].split('.')[-1].lower()
if extension in ['iv', 'vrml', '3ds', 'stl']:
file = self.arguments()[-1]
self._editor.load(file)
label.move(64, 64) layout.addWidget(label) # Create an in-process kernel kernel_manager = QtInProcessKernelManager() kernel_manager.start_kernel(show_banner=False) kernel = kernel_manager.kernel # Populate the kernel with names kernel.shell.user_ns.update(kman=kernel_manager, **names) kernel.gui = 'qt' kernel_client = kernel_manager.client() kernel_client.start_channels() ipython_widget = RichJupyterWidget() ipython_widget.kernel_manager = kernel_manager ipython_widget.kernel_client = kernel_client # # They can't currently work well together for some reason # USE_OPACITY = False # if USE_OPACITY: # # Transparency: # op = QGraphicsOpacityEffect(ipython_widget) # op.setOpacity(0.8) #0 to 1 will cause the fade effect to kick in # ipython_widget.setGraphicsEffect(op) # else: # # SET THE COLOR THEME: # # https://bitbucket.org/joon/color-schemes-for-jupyter-qt-console # color_theme = 'blackboard'
def __init__(self, args):
"""Initializes application"""
super(QSceneGraphEditor, self).__init__(args)
self._mainWindow = QtGui.QMainWindow()
self._editor = QSceneGraphEditorWindow()
self._mainWindow.setCentralWidget(self._editor)
exitAction = QtGui.QAction('&Exit', self._mainWindow)
exitAction.setShortcut('Ctrl+Q')
exitAction.setStatusTip('Exit application')
exitAction.triggered.connect(self._mainWindow.close)
newAction = QtGui.QAction('&New', self._mainWindow)
newAction.setShortcut('Ctrl+N')
newAction.setStatusTip('Creates a simple default scene')
newAction.triggered.connect(self._editor.new)
openAction = QtGui.QAction('&Open...', self._mainWindow)
openAction.setShortcut('Ctrl+O')
openAction.setStatusTip('Open scene graph from file')
openAction.triggered.connect(self._editor.open)
saveAction = QtGui.QAction('&Save', self._mainWindow)
saveAction.setShortcut('Ctrl+S')
saveAction.setStatusTip('Save scene graph')
saveAction.triggered.connect(self._editor.save)
saveAsAction = QtGui.QAction('&Save As...', self._mainWindow)
saveAsAction.setStatusTip('Save scene graph to another file')
saveAsAction.triggered.connect(self._editor.saveAs)
insertObjectAction = QtGui.QAction('&Insert...', self._mainWindow)
insertObjectAction.setShortcut('Ctrl+I')
insertObjectAction.setStatusTip('Inserts new scene object before current one')
insertObjectAction.triggered.connect(self._editor.inspectorWidget.insertObject)
appendObjectAction = QtGui.QAction('&Append...', self._mainWindow)
appendObjectAction.setShortcut('Ctrl+K')
appendObjectAction.setStatusTip('Inserts new scene object after current one')
appendObjectAction.triggered.connect(self._editor.inspectorWidget.appendObject)
deleteObjectAction = QtGui.QAction('&Delete', self._mainWindow)
deleteObjectAction.setShortcut('DEL')
deleteObjectAction.setStatusTip('Deletes currently selected scene object')
deleteObjectAction.triggered.connect(self._editor.inspectorWidget.deleteObject)
refreshObjectAction = QtGui.QAction('&Refresh', self._mainWindow)
refreshObjectAction.setShortcut('F5')
refreshObjectAction.setStatusTip('Recreates tree view from root node')
refreshObjectAction.triggered.connect(self._editor.refresh)
viewAllAction = QtGui.QAction('View &All', self._mainWindow)
viewAllAction.setShortcut('Ctrl+A')
viewAllAction.setStatusTip('Resets camera in scene so all object are visible')
viewAllAction.triggered.connect(self._editor.previewWidget.sceneManager.view_all)
viewManipAction = QtGui.QAction('Camera &Manipulation', self._mainWindow)
viewManipAction.setShortcut('Ctrl+M')
viewManipAction.setStatusTip('Enables manipulation of camera in the scene')
viewManipAction.setCheckable(True)
viewManipAction.setChecked(True)
viewManipAction.connect(QtCore.SIGNAL("triggered(bool)"), self._editor.previewWidget.sceneManager.interaction)
self._editor.previewWidget.sceneManager.interaction(True)
#self._mainWindow.statusBar()
menubar = self._mainWindow.menuBar()
fileMenu = menubar.addMenu('&File')
fileMenu.addAction(newAction)
fileMenu.addAction(openAction)
fileMenu.addAction(saveAction)
fileMenu.addAction(saveAsAction)
fileMenu.addSeparator()
fileMenu.addAction(exitAction)
objectsMenu = menubar.addMenu('&Scene Object')
objectsMenu.addAction(insertObjectAction)
objectsMenu.addAction(appendObjectAction)
objectsMenu.addAction(deleteObjectAction)
objectsMenu.addSeparator()
objectsMenu.addAction(refreshObjectAction)
viewMenu = menubar.addMenu('&View')
viewMenu.addAction(viewAllAction)
viewMenu.addAction(viewManipAction)
if "--console" in self.arguments() or "--ipython" in self.arguments():
# start with IPython console at bottom of application
from qtconsole.rich_jupyter_widget import RichJupyterWidget
from qtconsole.inprocess import QtInProcessKernelManager
import inventor
# Create an in-process kernel
kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel()
kernel = kernel_manager.kernel
kernel.gui = 'qt4'
kernel.shell.push({'iv': inventor, 'root': self._editor._root, 'view': self._editor.previewWidget.sceneManager })
kernel_client = kernel_manager.client()
kernel_client.start_channels()
def stop():
kernel_client.stop_channels()
kernel_manager.shutdown_kernel()
self.exit()
control = RichJupyterWidget()
control.kernel_manager = kernel_manager
control.kernel_client = kernel_client
control.exit_requested.connect(stop)
control.font = QtGui.QFont(control.font.family(), 10);
self.addVerticalWidget(control)
# load default scene or from file if argument is given
file = "#Inventor V2.1 ascii\n\nSeparator { " \
"DirectionalLight {} OrthographicCamera { position 0 0 5 height 5 }" \
"TrackballManip {} Material { diffuseColor 1 0 0 }" \
"Cone {} }"
if (len(self.arguments()) > 1) and ("." in self.arguments()[-1]):
extension = self.arguments()[-1].split('.')[-1].lower()
if extension in [ 'iv', 'vrml', '3ds', 'stl' ]:
file = self.arguments()[-1];
self._editor.load(file)
