def main(): kernel = create_kernel() client1 = QtInProcessKernelClient(kernel=kernel) client1.session.key = kernel.session.key client1.start_channels() client2 = QtInProcessKernelClient(kernel=kernel) client2.session.key = kernel.session.key client2.start_channels() app = QtGui.QApplication(sys.argv) window = QtGui.QWidget() vbox = QtGui.QVBoxLayout() widget1 = RichJupyterWidget(buffer_size=10000) widget1.kernel_client = client1 vbox.addWidget(widget1) widget2 = RichJupyterWidget(buffer_size=10000) widget2.kernel_client = client2 vbox.addWidget(widget2) window.setGeometry(QtCore.QRect(300, 300, 1000, 800)) window.setWindowTitle('Two QT consoles connected to the same kernel') window.setLayout(vbox) window.show() window.activateWindow() window.raise_() sys.exit(app.exec_())
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 main(): # logging.basicConfig(level=logging.DEBUG) kernel = create_kernel() client1 = ShellableQtInProcessKernelClient(kernel=kernel) client1.shell = kernel.shell client1.session.key = kernel.session.key client1.start_channels() # Create another shell and a client to drive it shell, _ = kernel.create_shell() client2 = QtInProcessKernelClient(kernel=kernel) client2.shell = shell client2.session.key = kernel.session.key client2.start_channels() app = QtGui.QApplication(sys.argv) window = QtGui.QWidget() vbox = QtGui.QVBoxLayout() widget1 = RichJupyterWidget(buffer_size=10000) widget1.kernel_client = client1 vbox.addWidget(widget1) widget2 = RichJupyterWidget(buffer_size=10000) widget2.kernel_client = client2 vbox.addWidget(widget2) window.setGeometry(QtCore.QRect(300, 300, 1000, 800)) window.setWindowTitle('Two QT consoles connected to the same kernel') window.setLayout(vbox) window.show() window.activateWindow() window.raise_() sys.exit(app.exec_())
def main(): logging.basicConfig(level=logging.DEBUG) app = QtGui.QApplication(sys.argv) window = QtGui.QWidget() vbox = QtGui.QVBoxLayout() manager = MultiKernelManager() client1 = create_kernel_client(manager) widget1 = RichJupyterWidget(buffer_size=10000) widget1.kernel_client = client1 client2 = create_kernel_client(manager) widget2 = RichJupyterWidget(buffer_size=10000) widget2.kernel_client = client2 vbox.addWidget(widget1) vbox.addWidget(widget2) button1 = QtGui.QPushButton("Set up #1") button1.clicked.connect(lambda: setup_environment(widget1)) button2 = QtGui.QPushButton("Set up #2") button2.clicked.connect(lambda: setup_environment(widget2)) hbox = QtGui.QHBoxLayout() hbox.addWidget(button1) hbox.addWidget(button2) vbox.addLayout(hbox) window.setGeometry(QtCore.QRect(300, 300, 1000, 800)) window.setWindowTitle('Two QT consoles connected to the same kernel') window.setLayout(vbox) window.show() window.activateWindow() window.raise_() sys.exit(app.exec_())
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 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 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 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 __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): # # 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.getPluginsOfCategory("GUIPlugin")}) # Observe plugin changes pluginobservers.append(self) # Continue kernel setuppluginmanager.getPluginsOfCategory("GUIPlugin") self.kernel_client = self.kernel_manager.client() 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 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, 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, 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 _run_embedded_qtconsole(conn_filename): # This is launched as a new process. # # Wait max. ten seconds for the IPython kernel to be up and running, # which is done by checking for presence of the connection file # containing the kernels Zero Message Queue sockets and credentials. # # Then, start a new QApplication running the Jupyter Console client # widget connected to the kernel via the connection file. # for i in range(100): try: st = os.stat(conn_filename) except OSError as e: if e.errno != errno.ENOENT: # No such file exception is ignored, all others re-raised raise else: if st.st_size > 0: # OK, connection file found, kernel seems to be running break time.sleep(0.1) app = QtGui.QApplication(["Plot Workbench Console"]) kernel_client = QtKernelClient(connection_file=conn_filename) kernel_client.load_connection_file() kernel_client.start_channels() def exit(): kernel_client.shutdown() kernel_client.stop_channels() app.exit() ipython_widget = RichJupyterWidget() ipython_widget.kernel_client = kernel_client ipython_widget.exit_requested.connect(exit) ipython_widget.show() app.exec_()
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)
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' # ipython_widget.style_sheet = open(f'C:/Users/samuel.wilder/Coding/Projects/Spire/res/stylesheets/{color_theme}.css').read()
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)