from jmwright 72b67da

cq_editor/widgets/console.py

@@ -0,0 +1,81 @@
+from PyQt5.QtWidgets import QApplication
+from PyQt5.QtCore import pyqtSlot
+
+from qtconsole.rich_jupyter_widget import RichJupyterWidget
+from qtconsole.inprocess import QtInProcessKernelManager
+
+from ..mixins import ComponentMixin
+
+class ConsoleWidget(RichJupyterWidget,ComponentMixin):
+    
+    name = 'Console'
+
+    def __init__(self, customBanner=None, namespace=dict(), *args, **kwargs):
+        super(ConsoleWidget, self).__init__(*args, **kwargs)
+
+#        if not customBanner is None:
+#            self.banner = customBanner
+
+        self.font_size = 6
+        self.kernel_manager = kernel_manager = QtInProcessKernelManager()
+        kernel_manager.start_kernel(show_banner=False)
+        kernel_manager.kernel.gui = 'qt'
+        kernel_manager.kernel.shell.banner1 = ""
+        
+        self.kernel_client = kernel_client = self._kernel_manager.client()
+        kernel_client.start_channels()
+
+        def stop():
+            kernel_client.stop_channels()
+            kernel_manager.shutdown_kernel()
+            QApplication.instance().exit()
+
+        self.exit_requested.connect(stop)
+        
+        self.clear()
+        
+        self.push_vars(namespace)
+
+    @pyqtSlot(dict)
+    def push_vars(self, variableDict):
+        """
+        Given a dictionary containing name / value pairs, push those variables
+        to the Jupyter console widget
+        """
+        self.kernel_manager.kernel.shell.push(variableDict)
+
+    def clear(self):
+        """
+        Clears the terminal
+        """
+        self._control.clear()
+
+
+    def print_text(self, text):
+        """
+        Prints some plain text to the console
+        """
+        self._append_plain_text(text)
+
+    def execute_command(self, command):
+        """
+        Execute a command in the frame of the console widget
+        """
+        self._execute(command, False)
+        
+    def _banner_default(self):
+        
+        return ''
+
+        
+if __name__ == "__main__":
+   
+    
+    import sys
+    
+    app = QApplication(sys.argv)
+    
+    console = ConsoleWidget(customBanner='IPython console test')
+    console.show()
+    
+    sys.exit(app.exec_())

cq_editor/widgets/cq_object_inspector.py

@@ -0,0 +1,129 @@
+from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QAction
+from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+
+from OCP.AIS import AIS_ColoredShape
+from OCP.gp import gp_Ax3
+
+from cadquery import Vector
+
+from ..mixins import ComponentMixin
+from ..icons import icon
+
+
+        
+class CQChildItem(QTreeWidgetItem):
+    
+    def __init__(self,cq_item,**kwargs):
+        
+        super(CQChildItem,self).\
+            __init__([type(cq_item).__name__,str(cq_item)],**kwargs)
+        
+        self.cq_item = cq_item
+
+class CQStackItem(QTreeWidgetItem):
+    
+    def __init__(self,name,workplane=None,**kwargs):
+        
+        super(CQStackItem,self).__init__([name,''],**kwargs)
+        
+        self.workplane = workplane
+
+
+class CQObjectInspector(QTreeWidget,ComponentMixin):
+    
+    name = 'CQ Object Inspector'
+    
+    sigRemoveObjects = pyqtSignal(list)
+    sigDisplayObjects = pyqtSignal(list,bool)
+    sigShowPlane = pyqtSignal([bool],[bool,float])
+    sigChangePlane = pyqtSignal(gp_Ax3)
+    
+    def  __init__(self,parent):
+        
+        super(CQObjectInspector,self).__init__(parent)
+        self.setHeaderHidden(False)
+        self.setRootIsDecorated(True)
+        self.setContextMenuPolicy(Qt.ActionsContextMenu)
+        self.setColumnCount(2)
+        self.setHeaderLabels(['Type','Value'])
+        
+        self.root = self.invisibleRootItem()
+        self.inspected_items = []
+        
+        self._toolbar_actions = \
+            [QAction(icon('inspect'),'Inspect CQ object',self,\
+                     toggled=self.inspect,checkable=True)]
+        
+        self.addActions(self._toolbar_actions)
+        
+    def menuActions(self):
+        
+        return {'Tools' : self._toolbar_actions}
+    
+    def toolbarActions(self):
+        
+        return self._toolbar_actions
+    
+    @pyqtSlot(bool)
+    def inspect(self,value):
+        
+        if value:
+            self.itemSelectionChanged.connect(self.handleSelection)
+            self.itemSelectionChanged.emit()
+        else:
+            self.itemSelectionChanged.disconnect(self.handleSelection)
+            self.sigRemoveObjects.emit(self.inspected_items)
+            self.sigShowPlane.emit(False)
+            
+    @pyqtSlot()    
+    def handleSelection(self):
+        
+        inspected_items = self.inspected_items
+        self.sigRemoveObjects.emit(inspected_items)
+        inspected_items.clear()
+        
+        items = self.selectedItems()
+        if len(items) == 0:
+            return
+        
+        item = items[-1]
+        if type(item) is CQStackItem:
+            cq_plane = item.workplane.plane
+            dim = item.workplane.largestDimension()
+            plane = gp_Ax3(cq_plane.origin.toPnt(),
+                           cq_plane.zDir.toDir(),
+                           cq_plane.xDir.toDir())
+            self.sigChangePlane.emit(plane)
+            self.sigShowPlane[bool,float].emit(True,dim)
+            
+            for child in (item.child(i) for i in range(item.childCount())):
+                obj = child.cq_item
+                if hasattr(obj,'wrapped') and type(obj) != Vector:
+                    ais = AIS_ColoredShape(obj.wrapped)
+                    inspected_items.append(ais)
+                
+        else:
+            self.sigShowPlane.emit(False)
+            obj = item.cq_item
+            if hasattr(obj,'wrapped') and type(obj) != Vector:
+                ais = AIS_ColoredShape(obj.wrapped)
+                inspected_items.append(ais)
+            
+        self.sigDisplayObjects.emit(inspected_items,False)
+    
+    @pyqtSlot(object)
+    def setObject(self,cq_obj):
+        
+        self.root.takeChildren()
+        
+        # iterate through parent objects if they exist
+        while getattr(cq_obj, 'parent', None):
+            current_frame = CQStackItem(str(cq_obj.plane.origin),workplane=cq_obj)
+            self.root.addChild(current_frame)
+            
+            for obj in cq_obj.objects:
+                current_frame.addChild(CQChildItem(obj))
+            
+            cq_obj = cq_obj.parent
+            
+            

cq_editor/widgets/debugger.py

@@ -0,0 +1,365 @@
+import sys
+from contextlib import ExitStack, contextmanager
+from enum import Enum, auto
+from types import SimpleNamespace, FrameType, ModuleType
+from typing import List
+
+import cadquery as cq
+from PyQt5 import QtCore
+from PyQt5.QtCore import Qt, QObject, pyqtSlot, pyqtSignal, QEventLoop, QAbstractTableModel
+from PyQt5.QtWidgets import (QAction,
+                             QTableView)
+from logbook import info
+from path import Path
+from pyqtgraph.parametertree import Parameter
+from spyder.utils.icon_manager import icon
+
+from ..cq_utils import find_cq_objects, reload_cq
+from ..mixins import ComponentMixin
+
+DUMMY_FILE = '<string>'
+
+
+class DbgState(Enum):
+
+    STEP = auto()
+    CONT = auto()
+    STEP_IN = auto()
+    RETURN = auto()
+
+class DbgEevent(object):
+
+    LINE = 'line'
+    CALL = 'call'
+    RETURN = 'return'
+
+class LocalsModel(QAbstractTableModel):
+
+    HEADER = ('Name','Type', 'Value')
+
+    def __init__(self,parent):
+
+        super(LocalsModel,self).__init__(parent)
+        self.frame = None
+
+    def update_frame(self,frame):
+
+        self.frame = \
+            [(k,type(v).__name__, str(v)) for k,v in frame.items() if not k.startswith('_')]
+
+
+    def rowCount(self,parent=QtCore.QModelIndex()):
+
+        if self.frame:
+            return len(self.frame)
+        else:
+            return 0
+
+    def columnCount(self,parent=QtCore.QModelIndex()):
+
+        return 3
+
+    def headerData(self, section, orientation, role=Qt.DisplayRole):
+        if role == Qt.DisplayRole and orientation == Qt.Horizontal:
+            return self.HEADER[section]
+        return QAbstractTableModel.headerData(self, section, orientation, role)
+
+    def data(self, index, role):
+        if role == QtCore.Qt.DisplayRole:
+            i = index.row()
+            j = index.column()
+            return self.frame[i][j]
+        else:
+            return QtCore.QVariant()
+
+
+class LocalsView(QTableView,ComponentMixin):
+
+    name = 'Variables'
+
+    def __init__(self,parent):
+
+        super(LocalsView,self).__init__(parent)
+        ComponentMixin.__init__(self)
+
+        header = self.horizontalHeader()
+        header.setStretchLastSection(True)
+
+        vheader = self.verticalHeader()
+        vheader.setVisible(False)
+
+    @pyqtSlot(dict)
+    def update_frame(self,frame):
+
+        model = LocalsModel(self)
+        model.update_frame(frame)
+
+        self.setModel(model)
+
+class Debugger(QObject,ComponentMixin):
+
+    name = 'Debugger'
+
+    preferences = Parameter.create(name='Preferences',children=[
+        {'name': 'Reload CQ', 'type': 'bool', 'value': False},
+        {'name': 'Add script dir to path','type': 'bool', 'value': True},
+        {'name': 'Change working dir to script dir','type': 'bool', 'value': True},
+        {'name': 'Reload imported modules', 'type': 'bool', 'value': True},
+    ])
+
+
+    sigRendered = pyqtSignal(dict)
+    sigLocals = pyqtSignal(dict)
+    sigTraceback = pyqtSignal(object,str)
+
+    sigFrameChanged = pyqtSignal(object)
+    sigLineChanged = pyqtSignal(int)
+    sigLocalsChanged = pyqtSignal(dict)
+    sigCQChanged = pyqtSignal(dict,bool)
+    sigDebugging = pyqtSignal(bool)
+
+    _frames : List[FrameType]
+
+    def __init__(self,parent):
+
+        super(Debugger,self).__init__(parent)
+        ComponentMixin.__init__(self)
+
+        self.inner_event_loop = QEventLoop(self)
+
+        self._actions =  \
+            {'Run' : [QAction(icon('run'),
+                              'Render',
+                               self,
+                               shortcut='F5',
+                               triggered=self.render),
+                      QAction(icon('debug'),
+                             'Debug',
+                             self,
+                             checkable=True,
+                             shortcut='ctrl+F5',
+                             triggered=self.debug),
+                      QAction(icon('arrow-step-over'),
+                             'Step',
+                             self,
+                             shortcut='ctrl+F10',
+                             triggered=lambda: self.debug_cmd(DbgState.STEP)),
+                      QAction(icon('arrow-step-in'),
+                             'Step in',
+                             self,
+                             shortcut='ctrl+F11',
+                             triggered=lambda: self.debug_cmd(DbgState.STEP_IN)),
+                      QAction(icon('arrow-continue'),
+                              'Continue',
+                              self,
+                              shortcut='ctrl+F12',
+                              triggered=lambda: self.debug_cmd(DbgState.CONT))
+                      ]}
+            
+        self._frames = []
+
+    def get_current_script(self):
+
+        return self.parent().components['editor'].get_text_with_eol()
+
+    def get_breakpoints(self):
+
+        return self.parent().components['editor'].debugger.get_breakpoints()
+
+    def compile_code(self, cq_script):
+
+        try:
+            module = ModuleType('temp')
+            cq_code = compile(cq_script, '<string>', 'exec')
+            return cq_code, module
+        except Exception:
+            self.sigTraceback.emit(sys.exc_info(), cq_script)
+            return None, None
+
+    def _exec(self, code, locals_dict, globals_dict):
+
+        with ExitStack() as stack:
+            fname = self.parent().components['editor'].filename
+            p = Path(fname if fname else '').abspath().dirname()
+
+            if self.preferences['Add script dir to path'] and p.exists():
+                sys.path.insert(0,p)
+                stack.callback(sys.path.remove, p)
+            if self.preferences['Change working dir to script dir'] and p.exists():
+                stack.enter_context(p)
+            if self.preferences['Reload imported modules']:
+                stack.enter_context(module_manager())
+
+            exec(code, locals_dict, globals_dict)     
+
+    def _inject_locals(self,module):
+
+        cq_objects = {}
+
+        def _show_object(obj,name=None, options={}):
+
+            if name:
+                cq_objects.update({name : SimpleNamespace(shape=obj,options=options)})
+            else:
+                cq_objects.update({str(id(obj)) : SimpleNamespace(shape=obj,options=options)})
+
+        def _debug(obj,name=None):
+
+            _show_object(obj,name,options=dict(color='red',alpha=0.2))
+
+        module.__dict__['show_object'] = _show_object
+        module.__dict__['debug'] = _debug
+        module.__dict__['log'] = lambda x: info(str(x))
+        module.__dict__['cq'] = cq
+
+        return cq_objects, set(module.__dict__)-{'cq'}
+
+    def _cleanup_locals(self,module,injected_names):
+
+        for name in injected_names: module.__dict__.pop(name)
+
+    @pyqtSlot(bool)
+    def render(self):
+
+        if self.preferences['Reload CQ']:
+            reload_cq()
+
+        cq_script = self.get_current_script()
+        cq_code,module = self.compile_code(cq_script)
+
+        if cq_code is None: return
+
+        cq_objects,injected_names = self._inject_locals(module)
+
+        try:
+            self._exec(cq_code, module.__dict__, module.__dict__)
+
+            #remove the special methods
+            self._cleanup_locals(module,injected_names)
+
+            #collect all CQ objects if no explicit show_object was called
+            if len(cq_objects) == 0:
+                cq_objects = find_cq_objects(module.__dict__)
+            self.sigRendered.emit(cq_objects)
+            self.sigTraceback.emit(None,
+                                   cq_script)
+            self.sigLocals.emit(module.__dict__)
+        except Exception:
+            exc_info = sys.exc_info()
+            sys.last_traceback = exc_info[-1]
+            self.sigTraceback.emit(exc_info, cq_script)
+    
+    @property
+    def breakpoints(self):
+        return [ el[0] for el in self.get_breakpoints()]
+
+    @pyqtSlot(bool)
+    def debug(self,value):
+
+        previous_trace = sys.gettrace()
+
+        if value:
+            self.sigDebugging.emit(True)
+            self.state = DbgState.STEP
+
+            self.script = self.get_current_script()
+            code,module = self.compile_code(self.script)
+
+            if code is None:
+                self.sigDebugging.emit(False)
+                self._actions['Run'][1].setChecked(False)
+                return
+
+            cq_objects,injected_names = self._inject_locals(module)
+
+            #clear possible traceback
+            self.sigTraceback.emit(None,
+                                   self.script)
+
+            try:
+                sys.settrace(self.trace_callback)
+                exec(code,module.__dict__,module.__dict__)
+            except Exception:
+                exc_info = sys.exc_info()
+                sys.last_traceback = exc_info[-1]
+                self.sigTraceback.emit(exc_info,
+                                       self.script)
+            finally:
+                sys.settrace(previous_trace)
+                self.sigDebugging.emit(False)
+                self._actions['Run'][1].setChecked(False)
+
+                if len(cq_objects) == 0:
+                    cq_objects = find_cq_objects(module.__dict__)
+                self.sigRendered.emit(cq_objects)
+
+                self._cleanup_locals(module,injected_names)
+                self.sigLocals.emit(module.__dict__)
+                
+                self._frames = []
+        else:
+            sys.settrace(previous_trace)
+            self.inner_event_loop.exit(0)
+
+
+    def debug_cmd(self,state=DbgState.STEP):
+
+        self.state = state
+        self.inner_event_loop.exit(0)
+
+
+    def trace_callback(self,frame,event,arg):
+
+        filename = frame.f_code.co_filename
+
+        if filename==DUMMY_FILE:
+            if not self._frames:
+                self._frames.append(frame)
+            self.trace_local(frame,event,arg)
+            return self.trace_callback
+
+        else:
+            return None
+
+    def trace_local(self,frame,event,arg):
+
+        lineno = frame.f_lineno
+
+        if event in (DbgEevent.LINE,):
+            if (self.state in (DbgState.STEP, DbgState.STEP_IN) and frame is self._frames[-1]) \
+            or (lineno in self.breakpoints):
+                
+                if lineno in self.breakpoints:
+                    self._frames.append(frame)
+                
+                self.sigLineChanged.emit(lineno)
+                self.sigFrameChanged.emit(frame)
+                self.sigLocalsChanged.emit(frame.f_locals)
+                self.sigCQChanged.emit(find_cq_objects(frame.f_locals),True)
+
+                self.inner_event_loop.exec_()
+
+        elif event in (DbgEevent.RETURN):
+            self.sigLocalsChanged.emit(frame.f_locals)
+            self._frames.pop()
+
+        elif event == DbgEevent.CALL:
+            func_filename = frame.f_code.co_filename
+            if self.state == DbgState.STEP_IN and func_filename == DUMMY_FILE:
+                self.sigLineChanged.emit(lineno)
+                self.sigFrameChanged.emit(frame)
+                self.state = DbgState.STEP
+                self._frames.append(frame)
+
+
+@contextmanager
+def module_manager():
+    """ unloads any modules loaded while the context manager is active """
+    loaded_modules = set(sys.modules.keys())
+
+    try:
+        yield
+    finally:
+        new_modules = set(sys.modules.keys()) - loaded_modules
+        for module_name in new_modules:
+            del sys.modules[module_name]

cq_editor/widgets/editor.py

@@ -0,0 +1,290 @@
+import os
+from modulefinder import ModuleFinder
+
+from spyder.plugins.editor.widgets.codeeditor import CodeEditor
+from PyQt5.QtCore import pyqtSignal, QFileSystemWatcher, QTimer
+from PyQt5.QtWidgets import QAction, QFileDialog
+from PyQt5.QtGui import QFontDatabase
+from path import Path
+
+import sys
+
+from pyqtgraph.parametertree import Parameter
+
+from ..mixins import ComponentMixin
+from ..utils import get_save_filename, get_open_filename, confirm
+
+from ..icons import icon
+
+class Editor(CodeEditor,ComponentMixin):
+
+    name = 'Code Editor'
+
+    # This signal is emitted whenever the currently-open file changes and
+    # autoreload is enabled.
+    triggerRerender = pyqtSignal(bool)
+    sigFilenameChanged = pyqtSignal(str)
+
+    preferences = Parameter.create(name='Preferences',children=[
+        {'name': 'Font size', 'type': 'int', 'value': 12},
+        {'name': 'Autoreload', 'type': 'bool', 'value': False},
+        {'name': 'Autoreload delay', 'type': 'int', 'value': 50},
+        {'name': 'Autoreload: watch imported modules', 'type': 'bool', 'value': False},
+        {'name': 'Line wrap', 'type': 'bool', 'value': False},
+        {'name': 'Color scheme', 'type': 'list',
+         'values': ['Spyder','Monokai','Zenburn'], 'value': 'Spyder'}])
+
+    EXTENSIONS = 'py'
+
+    def __init__(self,parent=None):
+
+        self._watched_file = None
+
+        super(Editor,self).__init__(parent)
+        ComponentMixin.__init__(self)
+
+        self.setup_editor(linenumbers=True,
+                          markers=True,
+                          edge_line=False,
+                          tab_mode=False,
+                          show_blanks=True,
+                          font=QFontDatabase.systemFont(QFontDatabase.FixedFont),
+                          language='Python',
+                          filename='')
+
+        self._actions =  \
+                {'File' : [QAction(icon('new'),
+                                  'New',
+                                  self,
+                                  shortcut='ctrl+N',
+                                  triggered=self.new),
+                          QAction(icon('open'),
+                                  'Open',
+                                  self,
+                                  shortcut='ctrl+O',
+                                  triggered=self.open),
+                          QAction(icon('save'),
+                                  'Save',
+                                  self,
+                                  shortcut='ctrl+S',
+                                  triggered=self.save),
+                          QAction(icon('save_as'),
+                                  'Save as',
+                                  self,
+                                  shortcut='ctrl+shift+S',
+                                  triggered=self.save_as),
+                          QAction(icon('autoreload'),
+                                  'Automatic reload and preview',
+                                  self,triggered=self.autoreload,
+                                  checkable=True,
+                                  checked=False,
+                                  objectName='autoreload'),
+                          ]}
+
+        for a in self._actions.values():
+            self.addActions(a)
+
+
+        self._fixContextMenu()
+
+        # autoreload support
+        self._file_watcher = QFileSystemWatcher(self)
+        # we wait for 50ms after a file change for the file to be written completely
+        self._file_watch_timer = QTimer(self)
+        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+        self._file_watch_timer.setSingleShot(True)
+        self._file_watcher.fileChanged.connect(
+                lambda val: self._file_watch_timer.start())
+        self._file_watch_timer.timeout.connect(self._file_changed)
+
+        self.updatePreferences()
+
+    def _fixContextMenu(self):
+
+        menu = self.menu
+
+        menu.removeAction(self.run_cell_action)
+        menu.removeAction(self.run_cell_and_advance_action)
+        menu.removeAction(self.run_selection_action)
+        menu.removeAction(self.re_run_last_cell_action)
+
+    def updatePreferences(self,*args):
+
+        self.set_color_scheme(self.preferences['Color scheme'])
+
+        font = self.font()
+        font.setPointSize(self.preferences['Font size'])
+        self.set_font(font)
+
+        self.findChild(QAction, 'autoreload') \
+            .setChecked(self.preferences['Autoreload'])
+
+        self._file_watch_timer.setInterval(self.preferences['Autoreload delay'])
+
+        self.toggle_wrap_mode(self.preferences['Line wrap'])
+
+        self._clear_watched_paths()
+        self._watch_paths()
+
+    def confirm_discard(self):
+
+        if self.modified:
+            rv =  confirm(self,'Please confirm','Current document is not saved - do you want to continue?')
+        else:
+            rv = True
+
+        return rv
+
+    def new(self):
+
+        if not self.confirm_discard(): return
+
+        self.set_text('')
+        self.filename = ''
+        self.reset_modified()
+
+    def open(self):
+        
+        if not self.confirm_discard(): return
+
+        curr_dir = Path(self.filename).abspath().dirname()
+        fname = get_open_filename(self.EXTENSIONS, curr_dir)
+        if fname != '':
+            self.load_from_file(fname)
+
+    def load_from_file(self,fname):
+
+        self.set_text_from_file(fname)
+        self.filename = fname
+        self.reset_modified()
+
+    def save(self):
+
+        if self._filename != '':
+
+            if self.preferences['Autoreload']:
+                self._file_watcher.blockSignals(True)
+                self._file_watch_timer.stop()
+
+            with open(self._filename, 'w') as f:
+                f.write(self.toPlainText())
+
+            if self.preferences['Autoreload']:
+                self._file_watcher.blockSignals(False)
+                self.triggerRerender.emit(True)
+
+            self.reset_modified()
+
+        else:
+            self.save_as()
+
+    def save_as(self):
+
+        fname = get_save_filename(self.EXTENSIONS)
+        if fname != '':
+            with open(fname,'w') as f:
+                f.write(self.toPlainText())
+                self.filename = fname
+
+            self.reset_modified()
+
+    def _update_filewatcher(self):
+        if self._watched_file and (self._watched_file != self.filename or not self.preferences['Autoreload']):
+            self._clear_watched_paths()
+            self._watched_file = None
+        if self.preferences['Autoreload'] and self.filename and self.filename != self._watched_file:
+            self._watched_file = self._filename
+            self._watch_paths()
+
+    @property
+    def filename(self):
+        return self._filename
+
+    @filename.setter
+    def filename(self, fname):
+        self._filename = fname
+        self._update_filewatcher()
+        self.sigFilenameChanged.emit(fname)
+
+    def _clear_watched_paths(self):
+        paths = self._file_watcher.files()
+        if paths:
+            self._file_watcher.removePaths(paths)
+
+    def _watch_paths(self):
+        if Path(self._filename).exists():
+            self._file_watcher.addPath(self._filename)
+            if self.preferences['Autoreload: watch imported modules']:
+                module_paths =  self.get_imported_module_paths(self._filename)
+                if module_paths:
+                    self._file_watcher.addPaths(module_paths)
+
+    # callback triggered by QFileSystemWatcher
+    def _file_changed(self):
+        # neovim writes a file by removing it first so must re-add each time
+        self._watch_paths()
+        self.set_text_from_file(self._filename)
+        self.triggerRerender.emit(True)
+
+    # Turn autoreload on/off.
+    def autoreload(self, enabled):
+        self.preferences['Autoreload'] = enabled
+        self._update_filewatcher()
+
+    def reset_modified(self):
+
+        self.document().setModified(False)
+        
+    @property
+    def modified(self):
+        
+        return self.document().isModified()
+
+    def saveComponentState(self,store):
+
+        if self.filename != '':
+            store.setValue(self.name+'/state',self.filename)
+
+    def restoreComponentState(self,store):
+
+        filename = store.value(self.name+'/state')
+
+        if filename and self.filename == '':
+            try:
+                self.load_from_file(filename)
+            except IOError:
+                self._logger.warning(f'could not open {filename}')
+
+
+    def get_imported_module_paths(self, module_path):
+
+        finder = ModuleFinder([os.path.dirname(module_path)])
+        imported_modules = []
+
+        try:
+            finder.run_script(module_path)
+        except SyntaxError as err:
+            self._logger.warning(f'Syntax error in {module_path}: {err}')
+        except Exception as err:
+            self._logger.warning(
+                f'Cannot determine imported modules in {module_path}: {type(err).__name__} {err}'
+            )
+        else:
+            for module_name, module in finder.modules.items():
+                if module_name != '__main__':
+                    path = getattr(module, '__file__', None)
+                    if path is not None and os.path.isfile(path):
+                        imported_modules.append(path)
+
+        return imported_modules
+
+
+if __name__ == "__main__":
+
+    from PyQt5.QtWidgets import QApplication
+
+    app = QApplication(sys.argv)
+    editor = Editor()
+    editor.show()
+
+    sys.exit(app.exec_())

cq_editor/widgets/log.py

@@ -0,0 +1,43 @@
+import logbook as logging
+
+from PyQt5.QtWidgets import QPlainTextEdit
+from PyQt5 import QtCore
+
+from ..mixins import ComponentMixin
+
+class QtLogHandler(logging.Handler,logging.StringFormatterHandlerMixin):
+    
+    def __init__(self, log_widget,*args,**kwargs):
+        
+        super(QtLogHandler,self).__init__(*args,**kwargs)
+        logging.StringFormatterHandlerMixin.__init__(self,None)
+        
+        self.log_widget = log_widget
+
+    def emit(self, record):
+        
+        msg = self.format(record)
+        QtCore.QMetaObject\
+            .invokeMethod(self.log_widget,
+                          'appendPlainText',
+                          QtCore.Qt.QueuedConnection,
+                          QtCore.Q_ARG(str, msg))
+
+class LogViewer(QPlainTextEdit, ComponentMixin):
+    
+    name = 'Log viewer'
+    
+    def __init__(self,*args,**kwargs):
+        
+        super(LogViewer,self).__init__(*args,**kwargs)
+        self._MAX_ROWS = 500
+        
+        self.setReadOnly(True)
+        self.setMaximumBlockCount(self._MAX_ROWS)
+        self.setLineWrapMode(QPlainTextEdit.NoWrap)
+        
+        self.handler = QtLogHandler(self)
+        
+    def append(self,msg):
+        
+        self.appendPlainText(msg)

cq_editor/widgets/object_tree.py

@@ -0,0 +1,389 @@
+from PyQt5.QtWidgets import QTreeWidget, QTreeWidgetItem, QAction, QMenu, QWidget, QAbstractItemView
+from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+
+from pyqtgraph.parametertree import Parameter, ParameterTree
+
+from OCP.AIS import AIS_Line
+from OCP.Geom import Geom_Line
+from OCP.gp import gp_Dir, gp_Pnt, gp_Ax1
+
+from ..mixins import ComponentMixin
+from ..icons import icon
+from ..cq_utils import make_AIS, export, to_occ_color, is_obj_empty, get_occ_color
+from ..utils import splitter, layout, get_save_filename
+
+class TopTreeItem(QTreeWidgetItem):
+
+    def __init__(self,*args,**kwargs):
+
+        super(TopTreeItem,self).__init__(*args,**kwargs)
+
+class ObjectTreeItem(QTreeWidgetItem):
+
+    props = [{'name': 'Name', 'type': 'str', 'value': ''},
+             {'name': 'Color', 'type': 'color', 'value': "f4a824"},
+             {'name': 'Alpha', 'type': 'float', 'value': 0, 'limits': (0,1), 'step': 1e-1},
+             {'name': 'Visible', 'type': 'bool','value': True}]
+
+    def __init__(self,
+                 name,
+                 ais=None,
+                 shape=None,
+                 shape_display=None,
+                 sig=None,
+                 alpha=0.,
+                 color='f4a824',
+                 **kwargs):
+
+        super(ObjectTreeItem,self).__init__([name],**kwargs)
+        self.setFlags( self.flags() | Qt.ItemIsUserCheckable)
+        self.setCheckState(0,Qt.Checked)
+
+        self.ais = ais
+        self.shape = shape
+        self.shape_display = shape_display
+        self.sig = sig
+
+        self.properties = Parameter.create(name='Properties',
+                                           children=self.props)
+
+        self.properties['Name'] = name
+        self.properties['Alpha'] = ais.Transparency()
+        self.properties['Color'] = get_occ_color(ais) if ais else color
+        self.properties.sigTreeStateChanged.connect(self.propertiesChanged)
+
+    def propertiesChanged(self,*args):
+
+        self.setData(0,0,self.properties['Name'])
+        self.ais.SetTransparency(self.properties['Alpha'])
+        self.ais.SetColor(to_occ_color(self.properties['Color']))
+        self.ais.Redisplay()
+
+        if self.properties['Visible']:
+            self.setCheckState(0,Qt.Checked)
+        else:
+            self.setCheckState(0,Qt.Unchecked)
+
+        if self.sig:
+            self.sig.emit()
+
+class CQRootItem(TopTreeItem):
+
+    def __init__(self,*args,**kwargs):
+
+        super(CQRootItem,self).__init__(['CQ models'],*args,**kwargs)
+
+
+class HelpersRootItem(TopTreeItem):
+
+    def __init__(self,*args,**kwargs):
+
+        super(HelpersRootItem,self).__init__(['Helpers'],*args,**kwargs)
+
+
+class ObjectTree(QWidget,ComponentMixin):
+
+    name = 'Object Tree'
+    _stash = []
+
+    preferences = Parameter.create(name='Preferences',children=[
+        {'name': 'Preserve properties on reload', 'type': 'bool', 'value': False},
+        {'name': 'Clear all before each run', 'type': 'bool', 'value': True},
+        {'name': 'STL precision','type': 'float', 'value': .1}])
+
+    sigObjectsAdded = pyqtSignal([list],[list,bool])
+    sigObjectsRemoved = pyqtSignal(list)
+    sigCQObjectSelected = pyqtSignal(object)
+    sigAISObjectsSelected = pyqtSignal(list)
+    sigItemChanged = pyqtSignal(QTreeWidgetItem,int)
+    sigObjectPropertiesChanged = pyqtSignal()
+
+    def  __init__(self,parent):
+
+        super(ObjectTree,self).__init__(parent)
+
+        self.tree = tree = QTreeWidget(self,
+                                       selectionMode=QAbstractItemView.ExtendedSelection)
+        self.properties_editor = ParameterTree(self)
+
+        tree.setHeaderHidden(True)
+        tree.setItemsExpandable(False)
+        tree.setRootIsDecorated(False)
+        tree.setContextMenuPolicy(Qt.ActionsContextMenu)
+
+        #forward itemChanged singal
+        tree.itemChanged.connect(\
+            lambda item,col: self.sigItemChanged.emit(item,col))
+        #handle visibility changes form tree
+        tree.itemChanged.connect(self.handleChecked)
+
+        self.CQ = CQRootItem()
+        self.Helpers = HelpersRootItem()
+
+        root = tree.invisibleRootItem()
+        root.addChild(self.CQ)
+        root.addChild(self.Helpers)
+        
+        tree.expandToDepth(1)
+
+        self._export_STL_action = \
+            QAction('Export as STL',
+                    self,
+                    enabled=False,
+                    triggered=lambda: \
+                        self.export('stl',
+                                    self.preferences['STL precision']))
+
+        self._export_STEP_action = \
+            QAction('Export as STEP',
+                    self,
+                    enabled=False,
+                    triggered=lambda: \
+                        self.export('step'))
+
+        self._clear_current_action = QAction(icon('delete'),
+                                             'Clear current',
+                                             self,
+                                             enabled=False,
+                                             triggered=self.removeSelected)
+
+        self._toolbar_actions = \
+            [QAction(icon('delete-many'),'Clear all',self,triggered=self.removeObjects),
+             self._clear_current_action,]
+
+        self.prepareMenu()
+
+        tree.itemSelectionChanged.connect(self.handleSelection)
+        tree.customContextMenuRequested.connect(self.showMenu)
+
+        self.prepareLayout()
+
+
+    def prepareMenu(self):
+
+        self.tree.setContextMenuPolicy(Qt.CustomContextMenu)
+
+        self._context_menu = QMenu(self)
+        self._context_menu.addActions(self._toolbar_actions)
+        self._context_menu.addActions((self._export_STL_action,
+                                       self._export_STEP_action))
+
+    def prepareLayout(self):
+
+        self._splitter = splitter((self.tree,self.properties_editor),
+                                  stretch_factors = (2,1),
+                                  orientation=Qt.Vertical)
+        layout(self,(self._splitter,),top_widget=self)
+
+        self._splitter.show()
+
+    def showMenu(self,position):
+
+        self._context_menu.exec_(self.tree.viewport().mapToGlobal(position))
+
+
+    def menuActions(self):
+
+        return {'Tools' : [self._export_STL_action,
+                           self._export_STEP_action]}
+
+    def toolbarActions(self):
+
+        return self._toolbar_actions
+
+    def addLines(self):
+
+        origin = (0,0,0)
+        ais_list = []
+
+        for name,color,direction in zip(('X','Y','Z'),
+                                        ('red','lawngreen','blue'),
+                                        ((1,0,0),(0,1,0),(0,0,1))):
+            line_placement = Geom_Line(gp_Ax1(gp_Pnt(*origin),
+                                       gp_Dir(*direction)))
+            line = AIS_Line(line_placement)
+            line.SetColor(to_occ_color(color))
+            
+            self.Helpers.addChild(ObjectTreeItem(name,
+                                                 ais=line))
+
+            ais_list.append(line)
+
+        self.sigObjectsAdded.emit(ais_list)
+
+    def _current_properties(self):
+
+        current_params = {}
+        for i in range(self.CQ.childCount()):
+            child = self.CQ.child(i)
+            current_params[child.properties['Name']] = child.properties
+
+        return current_params
+
+    def _restore_properties(self,obj,properties):
+
+        for p in properties[obj.properties['Name']]:
+            obj.properties[p.name()] = p.value()
+
+    @pyqtSlot(dict,bool)
+    @pyqtSlot(dict)
+    def addObjects(self,objects,clean=False,root=None):
+
+        if root is None:
+            root = self.CQ
+
+        request_fit_view = True if root.childCount() == 0 else False
+        preserve_props = self.preferences['Preserve properties on reload']
+        
+        if preserve_props:
+            current_props = self._current_properties()
+
+        if clean or self.preferences['Clear all before each run']:
+            self.removeObjects()
+
+        ais_list = []
+
+        #remove empty objects
+        objects_f = {k:v for k,v in objects.items() if not is_obj_empty(v.shape)}
+
+        for name,obj in objects_f.items():
+            ais,shape_display = make_AIS(obj.shape,obj.options)
+            
+            child = ObjectTreeItem(name,
+                                   shape=obj.shape,
+                                   shape_display=shape_display,
+                                   ais=ais,
+                                   sig=self.sigObjectPropertiesChanged)
+            
+            if preserve_props and name in current_props:
+                self._restore_properties(child,current_props)
+            
+            if child.properties['Visible']:
+                ais_list.append(ais)
+            
+            root.addChild(child)
+
+        if request_fit_view:
+            self.sigObjectsAdded[list,bool].emit(ais_list,True)
+        else:
+            self.sigObjectsAdded[list].emit(ais_list)
+
+    @pyqtSlot(object,str,object)
+    def addObject(self,obj,name='',options={}):
+
+        root = self.CQ
+
+        ais,shape_display = make_AIS(obj, options)
+
+        root.addChild(ObjectTreeItem(name,
+                                     shape=obj,
+                                     shape_display=shape_display,
+                                     ais=ais,
+                                     sig=self.sigObjectPropertiesChanged))
+
+        self.sigObjectsAdded.emit([ais])
+
+    @pyqtSlot(list)
+    @pyqtSlot()
+    def removeObjects(self,objects=None):
+
+        if objects:
+            removed_items_ais = [self.CQ.takeChild(i).ais for i in objects]
+        else:
+            removed_items_ais = [ch.ais for ch in self.CQ.takeChildren()]
+
+        self.sigObjectsRemoved.emit(removed_items_ais)
+
+    @pyqtSlot(bool)
+    def stashObjects(self,action : bool):
+
+        if action:
+            self._stash = self.CQ.takeChildren()
+            removed_items_ais = [ch.ais for ch in self._stash]
+            self.sigObjectsRemoved.emit(removed_items_ais)
+        else:
+            self.removeObjects()
+            self.CQ.addChildren(self._stash)
+            ais_list = [el.ais for el in self._stash]
+            self.sigObjectsAdded.emit(ais_list)
+
+    @pyqtSlot()
+    def removeSelected(self):
+
+        ixs = self.tree.selectedIndexes()
+        rows = [ix.row() for ix in ixs]
+
+        self.removeObjects(rows)
+
+    def export(self,export_type,precision=None):
+
+        items = self.tree.selectedItems()
+
+        # if CQ models is selected get all children
+        if [item for item in items if item is self.CQ]:
+            CQ = self.CQ
+            shapes = [CQ.child(i).shape for i in range(CQ.childCount())]
+        # otherwise collect all selected children of CQ
+        else:
+            shapes = [item.shape for item in items if item.parent() is self.CQ]
+
+        fname = get_save_filename(export_type)
+        if fname != '':
+             export(shapes,export_type,fname,precision)
+
+    @pyqtSlot()
+    def handleSelection(self):
+
+        items =self.tree.selectedItems()
+        if len(items) == 0:
+            self._export_STL_action.setEnabled(False)
+            self._export_STEP_action.setEnabled(False)
+            return
+
+        # emit list of all selected ais objects (might be empty)
+        ais_objects = [item.ais for item in items if item.parent() is self.CQ]
+        self.sigAISObjectsSelected.emit(ais_objects)
+
+        # handle context menu and emit last selected CQ  object (if present)
+        item = items[-1]
+        if item.parent() is self.CQ:
+            self._export_STL_action.setEnabled(True)
+            self._export_STEP_action.setEnabled(True)
+            self._clear_current_action.setEnabled(True)
+            self.sigCQObjectSelected.emit(item.shape)
+            self.properties_editor.setParameters(item.properties,
+                                                 showTop=False)
+            self.properties_editor.setEnabled(True)
+        elif item is self.CQ and item.childCount()>0:
+            self._export_STL_action.setEnabled(True)
+            self._export_STEP_action.setEnabled(True)
+        else:
+            self._export_STL_action.setEnabled(False)
+            self._export_STEP_action.setEnabled(False)
+            self._clear_current_action.setEnabled(False)
+            self.properties_editor.setEnabled(False)
+            self.properties_editor.clear()
+
+    @pyqtSlot(list)
+    def handleGraphicalSelection(self,shapes):
+
+        self.tree.clearSelection()
+
+        CQ = self.CQ
+        for i in range(CQ.childCount()):
+            item = CQ.child(i)
+            for shape in shapes:
+                if item.ais.Shape().IsEqual(shape):
+                    item.setSelected(True)
+
+    @pyqtSlot(QTreeWidgetItem,int)
+    def handleChecked(self,item,col):
+
+        if type(item) is ObjectTreeItem:
+            if item.checkState(0):
+                item.properties['Visible'] = True
+            else:
+                item.properties['Visible'] = False
+
+
+

cq_editor/widgets/occt_widget.py

@@ -0,0 +1,173 @@
+from sys import platform
+
+
+from PyQt5.QtWidgets import QWidget, QApplication
+from PyQt5.QtCore import pyqtSlot, pyqtSignal, Qt, QEvent
+
+import OCP
+
+from OCP.Aspect import Aspect_DisplayConnection, Aspect_TypeOfTriedronPosition
+from OCP.OpenGl import OpenGl_GraphicDriver
+from OCP.V3d import V3d_Viewer
+from OCP.AIS import AIS_InteractiveContext, AIS_DisplayMode
+from OCP.Quantity import Quantity_Color
+
+
+ZOOM_STEP = 0.9
+
+   
+class OCCTWidget(QWidget):
+    
+    sigObjectSelected = pyqtSignal(list)
+    
+    def __init__(self,parent=None):
+        
+        super(OCCTWidget,self).__init__(parent)
+        
+        self.setAttribute(Qt.WA_NativeWindow)
+        self.setAttribute(Qt.WA_PaintOnScreen)
+        self.setAttribute(Qt.WA_NoSystemBackground)
+        
+        self._initialized = False
+        self._needs_update = False
+        
+        #OCCT secific things
+        self.display_connection = Aspect_DisplayConnection()
+        self.graphics_driver = OpenGl_GraphicDriver(self.display_connection)
+        
+        self.viewer = V3d_Viewer(self.graphics_driver)
+        self.view = self.viewer.CreateView()
+        self.context = AIS_InteractiveContext(self.viewer)
+        
+        #Trihedorn, lights, etc
+        self.prepare_display()
+        
+    def prepare_display(self):
+        
+        view = self.view
+        
+        params = view.ChangeRenderingParams()
+        params.NbMsaaSamples = 8
+        params.IsAntialiasingEnabled = True
+        
+        view.TriedronDisplay(
+            Aspect_TypeOfTriedronPosition.Aspect_TOTP_RIGHT_LOWER,
+            Quantity_Color(), 0.1)
+        
+        viewer = self.viewer
+        
+        viewer.SetDefaultLights()
+        viewer.SetLightOn()
+        
+        ctx = self.context
+        
+        ctx.SetDisplayMode(AIS_DisplayMode.AIS_Shaded, True)
+        ctx.DefaultDrawer().SetFaceBoundaryDraw(True)
+        
+    def wheelEvent(self, event):
+        
+        delta = event.angleDelta().y()
+        factor = ZOOM_STEP if delta<0 else 1/ZOOM_STEP
+        
+        self.view.SetZoom(factor)
+        
+    def mousePressEvent(self,event):
+        
+        pos = event.pos()
+        
+        if event.button() == Qt.LeftButton:
+            self.view.StartRotation(pos.x(), pos.y())
+        elif event.button() == Qt.RightButton:
+            self.view.StartZoomAtPoint(pos.x(), pos.y())
+        
+        self.old_pos = pos
+            
+    def mouseMoveEvent(self,event):
+        
+        pos = event.pos()
+        x,y = pos.x(),pos.y()
+        
+        if event.buttons() == Qt.LeftButton:
+            self.view.Rotation(x,y)
+            
+        elif event.buttons() == Qt.MiddleButton:
+            self.view.Pan(x - self.old_pos.x(),
+                          self.old_pos.y() - y, theToStart=True)
+            
+        elif event.buttons() == Qt.RightButton:
+            self.view.ZoomAtPoint(self.old_pos.x(), y,
+                                  x, self.old_pos.y())
+        
+        self.old_pos = pos
+        
+    def mouseReleaseEvent(self,event):
+        
+        if event.button() == Qt.LeftButton:
+            pos = event.pos()
+            x,y = pos.x(),pos.y()
+            
+            self.context.MoveTo(x,y,self.view,True)
+            
+            self._handle_selection()
+            
+    def _handle_selection(self):
+        
+        self.context.Select(True)
+        self.context.InitSelected()
+        
+        selected = []
+        if self.context.HasSelectedShape():
+            selected.append(self.context.SelectedShape())
+        
+        self.sigObjectSelected.emit(selected)
+
+    def paintEngine(self):
+    
+        return None
+    
+    def paintEvent(self, event):
+        
+        if not self._initialized:
+            self._initialize()
+        else:
+            self.view.Redraw()
+
+    def showEvent(self, event):
+    
+        super(OCCTWidget,self).showEvent(event)
+        
+    def resizeEvent(self, event):
+        
+        super(OCCTWidget,self).resizeEvent(event)
+        
+        self.view.MustBeResized()
+    
+    def _initialize(self):
+
+        wins = {
+            'darwin' : self._get_window_osx,
+            'linux'  : self._get_window_linux,
+            'win32': self._get_window_win           
+        }
+
+        self.view.SetWindow(wins.get(platform,self._get_window_linux)(self.winId()))
+
+        self._initialized = True
+        
+    def _get_window_win(self,wid):
+    
+        from OCP.WNT import WNT_Window
+        
+        return WNT_Window(wid.ascapsule())
+
+    def _get_window_linux(self,wid):
+        
+        from OCP.Xw import Xw_Window
+        
+        return Xw_Window(self.display_connection,int(wid))
+    
+    def _get_window_osx(self,wid):
+        
+        from OCP.Cocoa import Cocoa_Window
+        
+        return Cocoa_Window(wid.ascapsule())

cq_editor/widgets/traceback_viewer.py

@@ -0,0 +1,97 @@
+from traceback import extract_tb, format_exception_only
+
+from PyQt5.QtWidgets import (QWidget, QTreeWidget, QTreeWidgetItem, QAction,
+                             QLabel)
+from PyQt5.QtCore import Qt, pyqtSlot, pyqtSignal
+
+from ..mixins import ComponentMixin
+from ..utils import layout
+
+class TracebackTree(QTreeWidget):
+
+    name = 'Traceback Viewer'
+    
+    def  __init__(self,parent):
+        
+        super(TracebackTree,self).__init__(parent)   
+        self.setHeaderHidden(False)
+        self.setItemsExpandable(False)
+        self.setRootIsDecorated(False)
+        self.setContextMenuPolicy(Qt.ActionsContextMenu)
+        
+        self.setColumnCount(3)
+        self.setHeaderLabels(['File','Line','Code'])
+        
+        
+        self.root = self.invisibleRootItem()
+
+class TracebackPane(QWidget,ComponentMixin):
+    
+    sigHighlightLine = pyqtSignal(int)
+    
+    def __init__(self,parent):
+        
+        super(TracebackPane,self).__init__(parent)
+        
+        self.tree = TracebackTree(self)
+        self.current_exception = QLabel(self)
+        self.current_exception.setStyleSheet(\
+            "QLabel {color : red; }");
+        
+        layout(self,
+               (self.current_exception,
+                self.tree),
+               self)
+               
+        self.tree.currentItemChanged.connect(self.handleSelection)
+        
+    @pyqtSlot(object,str)
+    def addTraceback(self,exc_info,code):
+        
+        self.tree.clear()
+        
+        if exc_info:
+            t,exc,tb = exc_info
+            
+            root = self.tree.root
+            code = code.splitlines()
+            tb = [t for t in extract_tb(tb) if '<string>' in t.filename] #ignore highest frames (debug, exec)
+            
+            for el in tb:
+                #workaround of the traceback module
+                if el.line == '':
+                    line = code[el.lineno-1].strip()
+                else:
+                    line = el.line
+                
+                root.addChild(QTreeWidgetItem([el.filename,
+                                               str(el.lineno),
+                                               line]))
+
+            exc_name = t.__name__
+            exc_msg = str(exc)
+            exc_msg = exc_msg.replace('<', '&lt;').replace('>', '&gt;') #replace <> 
+
+            self.current_exception.\
+                setText('<b>{}</b>: {}'.format(exc_name,exc_msg))
+            
+            # handle the special case of a SyntaxError
+            if t is SyntaxError: 
+                root.addChild(QTreeWidgetItem(
+                  [exc.filename,
+                   str(exc.lineno),
+                   exc.text.strip() if exc.text else '']
+                ))
+        else:
+            self.current_exception.setText('')
+
+    @pyqtSlot(QTreeWidgetItem,QTreeWidgetItem)          
+    def handleSelection(self,item,*args):
+        
+        if item:
+            f,line = item.data(0,0),int(item.data(1,0))
+            
+            if '<string>' in f:
+                self.sigHighlightLine.emit(line)
+    
+        

cq_editor/widgets/viewer.py

@@ -0,0 +1,379 @@
+# -*- coding: utf-8 -*-
+
+from OCP.Graphic3d import Graphic3d_Camera, Graphic3d_StereoMode
+from PyQt5.QtWidgets import (QWidget, QPushButton, QDialog, QTreeWidget,
+                             QTreeWidgetItem, QVBoxLayout, QFileDialog,
+                             QHBoxLayout, QFrame, QLabel, QApplication,
+                             QToolBar, QAction)
+
+from PyQt5.QtCore import QSize, pyqtSlot, pyqtSignal, QMetaObject, Qt
+from PyQt5.QtGui import QIcon
+
+from OCP.AIS import AIS_Shaded,AIS_WireFrame, AIS_ColoredShape, \
+    AIS_Axis, AIS_Line
+from OCP.Aspect import Aspect_GDM_Lines, Aspect_GT_Rectangular, Aspect_GFM_VER
+from OCP.Quantity import Quantity_NOC_BLACK as BLACK, \
+    Quantity_TOC_RGB as TOC_RGB, Quantity_Color
+from OCP.Geom import Geom_CylindricalSurface, Geom_Plane, Geom_Circle,\
+     Geom_TrimmedCurve, Geom_Axis1Placement, Geom_Axis2Placement, Geom_Line
+from OCP.gp import gp_Trsf, gp_Vec, gp_Ax3, gp_Dir, gp_Pnt, gp_Ax1
+
+from ..utils import layout, get_save_filename
+from ..mixins import ComponentMixin
+from ..icons import icon
+from ..cq_utils import to_occ_color, make_AIS
+
+from .occt_widget import OCCTWidget
+
+from pyqtgraph.parametertree import Parameter
+import qtawesome as qta
+
+
+class OCCViewer(QWidget,ComponentMixin):
+
+    name = '3D Viewer'
+
+    preferences = Parameter.create(name='Pref',children=[
+        {'name': 'Fit automatically', 'type': 'bool', 'value': True},
+        {'name': 'Use gradient', 'type': 'bool', 'value': False},
+        {'name': 'Background color', 'type': 'color', 'value': (95,95,95)},
+        {'name': 'Background color (aux)', 'type': 'color', 'value': (30,30,30)},
+        {'name': 'Default object color', 'type': 'color', 'value': "FF0"},
+        {'name': 'Deviation', 'type': 'float', 'value': 1e-5, 'dec': True, 'step': 1},
+        {'name': 'Angular deviation', 'type': 'float', 'value': 0.1, 'dec': True, 'step': 1},
+        {'name': 'Projection Type', 'type': 'list', 'value': 'Orthographic',
+         'values': ['Orthographic', 'Perspective', 'Stereo', 'MonoLeftEye', 'MonoRightEye']},
+        {'name': 'Stereo Mode', 'type': 'list', 'value': 'QuadBuffer',
+         'values': ['QuadBuffer', 'Anaglyph', 'RowInterlaced', 'ColumnInterlaced',
+                    'ChessBoard', 'SideBySide', 'OverUnder']}])
+    IMAGE_EXTENSIONS = 'png'
+
+    sigObjectSelected = pyqtSignal(list)
+
+    def __init__(self,parent=None):
+
+        super(OCCViewer,self).__init__(parent)
+        ComponentMixin.__init__(self)
+
+        self.canvas = OCCTWidget()
+        self.canvas.sigObjectSelected.connect(self.handle_selection)
+
+        self.create_actions(self)
+
+        self.layout_ = layout(self,
+                             [self.canvas,],
+                             top_widget=self,
+                             margin=0)
+        
+        self.updatePreferences()
+
+    def updatePreferences(self,*args):
+
+        color1 = to_occ_color(self.preferences['Background color'])
+        color2 = to_occ_color(self.preferences['Background color (aux)'])
+
+        if not self.preferences['Use gradient']:
+            color2 = color1
+        self.canvas.view.SetBgGradientColors(color1,color2,theToUpdate=True)
+        
+        self.canvas.update()
+        
+        ctx = self.canvas.context
+        ctx.SetDeviationCoefficient(self.preferences['Deviation'])
+        ctx.SetDeviationAngle(self.preferences['Angular deviation'])
+
+        v = self._get_view()
+        camera = v.Camera()
+        projection_type = self.preferences['Projection Type']
+        camera.SetProjectionType(getattr(Graphic3d_Camera, f'Projection_{projection_type}',
+                                         Graphic3d_Camera.Projection_Orthographic))
+
+        # onle relevant for stereo projection
+        stereo_mode = self.preferences['Stereo Mode']
+        params = v.ChangeRenderingParams()
+        params.StereoMode = getattr(Graphic3d_StereoMode, f'Graphic3d_StereoMode_{stereo_mode}',
+                                    Graphic3d_StereoMode.Graphic3d_StereoMode_QuadBuffer)
+
+    def create_actions(self,parent):
+
+        self._actions =  \
+                {'View' : [QAction(qta.icon('fa.arrows-alt'),
+                                   'Fit (Shift+F1)',
+                                   parent,
+                                   shortcut='shift+F1',
+                                   triggered=self.fit),
+                          QAction(QIcon(':/images/icons/isometric_view.svg'),
+                                  'Iso (Shift+F2)',
+                                  parent,
+                                  shortcut='shift+F2',
+                                  triggered=self.iso_view),
+                          QAction(QIcon(':/images/icons/top_view.svg'),
+                                  'Top (Shift+F3)',
+                                  parent,
+                                  shortcut='shift+F3',
+                                  triggered=self.top_view),
+                          QAction(QIcon(':/images/icons/bottom_view.svg'),
+                                  'Bottom (Shift+F4)',
+                                  parent,
+                                  shortcut='shift+F4',
+                                  triggered=self.bottom_view),
+                          QAction(QIcon(':/images/icons/front_view.svg'),
+                                  'Front (Shift+F5)',
+                                  parent,
+                                  shortcut='shift+F5',
+                                  triggered=self.front_view),
+                          QAction(QIcon(':/images/icons/back_view.svg'),
+                                  'Back (Shift+F6)',
+                                  parent,
+                                  shortcut='shift+F6',
+                                  triggered=self.back_view),
+                          QAction(QIcon(':/images/icons/left_side_view.svg'),
+                                  'Left (Shift+F7)',
+                                  parent,
+                                  shortcut='shift+F7',
+                                  triggered=self.left_view),
+                          QAction(QIcon(':/images/icons/right_side_view.svg'),
+                                  'Right (Shift+F8)',
+                                  parent,
+                                  shortcut='shift+F8',
+                                  triggered=self.right_view),
+                          QAction(qta.icon('fa.square-o'),
+                                  'Wireframe (Shift+F9)',
+                                  parent,
+                                  shortcut='shift+F9',
+                                  triggered=self.wireframe_view),
+                                  QAction(qta.icon('fa.square'),
+                                          'Shaded (Shift+F10)',
+                                          parent,
+                                          shortcut='shift+F10',
+                                          triggered=self.shaded_view)],
+                 'Tools' : [QAction(icon('screenshot'),
+                                   'Screenshot',
+                                   parent,
+                                   triggered=self.save_screenshot)]}
+
+    def toolbarActions(self):
+
+        return self._actions['View']
+
+
+    def clear(self):
+
+        self.displayed_shapes = []
+        self.displayed_ais = []
+        self.canvas.context.EraseAll(True)
+        context = self._get_context()
+        context.PurgeDisplay()
+        context.RemoveAll(True)
+
+    def _display(self,shape):
+
+        ais = make_AIS(shape)
+        self.canvas.context.Display(shape,True)
+
+        self.displayed_shapes.append(shape)
+        self.displayed_ais.append(ais)
+
+        #self.canvas._display.Repaint()
+
+    @pyqtSlot(object)
+    def display(self,ais):
+
+        context = self._get_context()
+        context.Display(ais,True)
+
+        if self.preferences['Fit automatically']: self.fit()
+
+    @pyqtSlot(list)
+    @pyqtSlot(list,bool)
+    def display_many(self,ais_list,fit=None):
+
+        context = self._get_context()
+        for ais in ais_list:
+            context.Display(ais,True)
+
+        if self.preferences['Fit automatically'] and fit is None:
+            self.fit()
+        elif fit:
+            self.fit()
+
+    @pyqtSlot(QTreeWidgetItem,int)
+    def update_item(self,item,col):
+
+        ctx = self._get_context()
+        if item.checkState(0):
+            ctx.Display(item.ais,True)
+        else:
+            ctx.Erase(item.ais,True)
+
+    @pyqtSlot(list)
+    def remove_items(self,ais_items):
+
+        ctx = self._get_context()
+        for ais in ais_items: ctx.Erase(ais,True)
+
+    @pyqtSlot()
+    def redraw(self):
+
+        self._get_viewer().Redraw()
+
+    def fit(self):
+
+        self.canvas.view.FitAll()
+
+    def iso_view(self):
+
+        v = self._get_view()
+        v.SetProj(1,-1,1)
+        v.SetTwist(0)
+
+    def bottom_view(self):
+
+        v = self._get_view()
+        v.SetProj(0,0,-1)
+        v.SetTwist(0)
+
+    def top_view(self):
+
+        v = self._get_view()
+        v.SetProj(0,0,1)
+        v.SetTwist(0)
+
+    def front_view(self):
+
+        v = self._get_view()
+        v.SetProj(0,1,0)
+        v.SetTwist(0)
+
+    def back_view(self):
+
+        v = self._get_view()
+        v.SetProj(0,-1,0)
+        v.SetTwist(0)
+
+    def left_view(self):
+
+        v = self._get_view()
+        v.SetProj(-1,0,0)
+        v.SetTwist(0)
+
+    def right_view(self):
+
+        v = self._get_view()
+        v.SetProj(1,0,0)
+        v.SetTwist(0)
+
+    def shaded_view(self):
+
+        c = self._get_context()
+        c.SetDisplayMode(AIS_Shaded, True)
+
+    def wireframe_view(self):
+
+        c = self._get_context()
+        c.SetDisplayMode(AIS_WireFrame, True)
+
+    def show_grid(self,
+                  step=1.,
+                  size=10.+1e-6,
+                  color1=(.7,.7,.7),
+                  color2=(0,0,0)):
+
+        viewer = self._get_viewer()
+        viewer.ActivateGrid(Aspect_GT_Rectangular,
+                            Aspect_GDM_Lines)
+        viewer.SetRectangularGridGraphicValues(size, size, 0)
+        viewer.SetRectangularGridValues(0, 0, step, step, 0)
+        grid = viewer.Grid()
+        grid.SetColors(Quantity_Color(*color1,TOC_RGB),
+                       Quantity_Color(*color2,TOC_RGB))
+
+    def hide_grid(self):
+
+        viewer = self._get_viewer()
+        viewer.DeactivateGrid()
+
+    @pyqtSlot(bool,float)
+    @pyqtSlot(bool)
+    def toggle_grid(self,
+                    value : bool,
+                    dim : float = 10.):
+
+        if value:
+            self.show_grid(step=dim/20,size=dim+1e-9)
+        else:
+            self.hide_grid()
+
+    @pyqtSlot(gp_Ax3)
+    def set_grid_orientation(self,orientation : gp_Ax3):
+
+        viewer = self._get_viewer()
+        viewer.SetPrivilegedPlane(orientation)
+
+    def show_axis(self,origin = (0,0,0), direction=(0,0,1)):
+
+        ax_placement = Geom_Axis1Placement(gp_Ax1(gp_Pnt(*origin),
+                                                  gp_Dir(*direction)))
+        ax = AIS_Axis(ax_placement)
+        self._display_ais(ax)
+
+    def save_screenshot(self):
+
+        fname = get_save_filename(self.IMAGE_EXTENSIONS)
+        if fname != '':
+             self._get_view().Dump(fname)
+
+    def _display_ais(self,ais):
+
+        self._get_context().Display(ais)
+
+
+    def _get_view(self):
+
+        return self.canvas.view
+
+    def _get_viewer(self):
+
+        return self.canvas.viewer
+
+    def _get_context(self):
+
+        return self.canvas.context
+
+    @pyqtSlot(list)
+    def handle_selection(self,obj):
+
+        self.sigObjectSelected.emit(obj)
+
+    @pyqtSlot(list)
+    def set_selected(self,ais):
+
+        ctx = self._get_context()
+        ctx.ClearSelected(False)
+
+        for obj in ais:
+            ctx.AddOrRemoveSelected(obj,False)
+
+        self.redraw()
+
+
+if __name__ == "__main__":
+
+    import sys
+    from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox
+
+    app = QApplication(sys.argv)
+    viewer = OCCViewer()
+
+    dlg = QDialog()
+    dlg.setFixedHeight(400)
+    dlg.setFixedWidth(600)
+
+    layout(dlg,(viewer,),dlg)
+    dlg.show()
+
+    box = BRepPrimAPI_MakeBox(20,20,30)
+    box_ais = AIS_ColoredShape(box.Shape())
+    viewer.display(box_ais)
+
+    sys.exit(app.exec_())