h3n3/jmwright-CQ-Editor
1
0
Fork 0
mirror of https://github.com/jdegenstein/jmwright-CQ-Editor.git synced 2025-12-19 22:24:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

more testing of pyside6

Browse Source
This commit is contained in:
jdegenstein
2023-10-11 12:11:37 -05:00
parent 8fca86e2c9
commit 960c9fe5ca
13 changed files with 1090 additions and 1035 deletions
Download Patch File Download Diff File Expand all files Collapse all files

195
cq_editor/editor.py
View File

@@ -3,7 +3,7 @@ import spyder.utils.encoding
from modulefinder import ModuleFinder from modulefinder import ModuleFinder
from spyder.plugins.editor.widgets.codeeditor import CodeEditor from spyder.plugins.editor.widgets.codeeditor import CodeEditor
from PySide6.QtCore import pyqtSignal, QFileSystemWatcher, QTimer from PySide6.QtCore import Signal as pyqtSignal, QFileSystemWatcher, QTimer
from PySide6.QtWidgets import QAction, QFileDialog from PySide6.QtWidgets import QAction, QFileDialog
from PySide6.QtGui import QFontDatabase from PySide6.QtGui import QFontDatabase
from path import Path from path import Path
@@ -17,91 +17,104 @@ from ..utils import get_save_filename, get_open_filename, confirm
from ..icons import icon from ..icons import icon
class Editor(CodeEditor,ComponentMixin):
name = 'Code Editor' class Editor(CodeEditor, ComponentMixin):
name = "Code Editor"
# This signal is emitted whenever the currently-open file changes and # This signal is emitted whenever the currently-open file changes and
# autoreload is enabled. # autoreload is enabled.
triggerRerender = pyqtSignal(bool) triggerRerender = pyqtSignal(bool)
sigFilenameChanged = pyqtSignal(str) sigFilenameChanged = pyqtSignal(str)
preferences = Parameter.create(name='Preferences',children=[ preferences = Parameter.create(
{'name': 'Font size', 'type': 'int', 'value': 12}, name="Preferences",
{'name': 'Autoreload', 'type': 'bool', 'value': False}, children=[
{'name': 'Autoreload delay', 'type': 'int', 'value': 50}, {"name": "Font size", "type": "int", "value": 12},
{'name': 'Autoreload: watch imported modules', 'type': 'bool', 'value': False}, {"name": "Autoreload", "type": "bool", "value": False},
{'name': 'Line wrap', 'type': 'bool', 'value': False}, {"name": "Autoreload delay", "type": "int", "value": 50},
{'name': 'Color scheme', 'type': 'list', {
'values': ['Spyder','Monokai','Zenburn'], 'value': 'Spyder'}]) "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' EXTENSIONS = "py"
def __init__(self, parent=None): def __init__(self, parent=None):
self._watched_file = None self._watched_file = None
super(Editor, self).__init__(parent) super(Editor, self).__init__(parent)
ComponentMixin.__init__(self) ComponentMixin.__init__(self)
self.setup_editor(linenumbers=True, self.setup_editor(
linenumbers=True,
markers=True, markers=True,
edge_line=False, edge_line=False,
tab_mode=False, tab_mode=False,
show_blanks=True, show_blanks=True,
font=QFontDatabase.systemFont(QFontDatabase.FixedFont), font=QFontDatabase.systemFont(QFontDatabase.FixedFont),
language='Python', language="Python",
filename='') filename="",
)
self._actions = \ self._actions = {
{'File' : [QAction(icon('new'), "File": [
'New', 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, self,
shortcut='ctrl+N', shortcut="ctrl+shift+S",
triggered=self.new), triggered=self.save_as,
QAction(icon('open'), ),
'Open', QAction(
icon("autoreload"),
"Automatic reload and preview",
self, self,
shortcut='ctrl+O', triggered=self.autoreload,
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, checkable=True,
checked=False, checked=False,
objectName='autoreload'), objectName="autoreload",
]} ),
]
}
for a in self._actions.values(): for a in self._actions.values():
self.addActions(a) self.addActions(a)
self._fixContextMenu() self._fixContextMenu()
# autoreload support # autoreload support
self._file_watcher = QFileSystemWatcher(self) self._file_watcher = QFileSystemWatcher(self)
# we wait for 50ms after a file change for the file to be written completely # 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 = QTimer(self)
self._file_watch_timer.setInterval(self.preferences['Autoreload delay']) self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
self._file_watch_timer.setSingleShot(True) self._file_watch_timer.setSingleShot(True)
self._file_watcher.fileChanged.connect( self._file_watcher.fileChanged.connect(
lambda val: self._file_watch_timer.start()) lambda val: self._file_watch_timer.start()
)
self._file_watch_timer.timeout.connect(self._file_changed) self._file_watch_timer.timeout.connect(self._file_changed)
self.updatePreferences() self.updatePreferences()
def _fixContextMenu(self): def _fixContextMenu(self):
menu = self.menu menu = self.menu
menu.removeAction(self.run_cell_action) menu.removeAction(self.run_cell_action)
@@ -110,51 +123,51 @@ class Editor(CodeEditor,ComponentMixin):
menu.removeAction(self.re_run_last_cell_action) menu.removeAction(self.re_run_last_cell_action)
def updatePreferences(self, *args): def updatePreferences(self, *args):
self.set_color_scheme(self.preferences["Color scheme"])
self.set_color_scheme(self.preferences['Color scheme'])
font = self.font() font = self.font()
font.setPointSize(self.preferences['Font size']) font.setPointSize(self.preferences["Font size"])
self.set_font(font) self.set_font(font)
self.findChild(QAction, 'autoreload') \ self.findChild(QAction, "autoreload").setChecked(self.preferences["Autoreload"])
.setChecked(self.preferences['Autoreload'])
self._file_watch_timer.setInterval(self.preferences['Autoreload delay']) self._file_watch_timer.setInterval(self.preferences["Autoreload delay"])
self.toggle_wrap_mode(self.preferences['Line wrap']) self.toggle_wrap_mode(self.preferences["Line wrap"])
self._clear_watched_paths() self._clear_watched_paths()
self._watch_paths() self._watch_paths()
def confirm_discard(self): def confirm_discard(self):
if self.modified: if self.modified:
rv = confirm(self,'Please confirm','Current document is not saved - do you want to continue?') rv = confirm(
self,
"Please confirm",
"Current document is not saved - do you want to continue?",
)
else: else:
rv = True rv = True
return rv return rv
def new(self): def new(self):
if not self.confirm_discard():
return
if not self.confirm_discard(): return self.set_text("")
self.filename = ""
self.set_text('')
self.filename = ''
self.reset_modified() self.reset_modified()
def open(self): def open(self):
if not self.confirm_discard():
if not self.confirm_discard(): return return
curr_dir = Path(self.filename).abspath().dirname() curr_dir = Path(self.filename).abspath().dirname()
fname = get_open_filename(self.EXTENSIONS, curr_dir) fname = get_open_filename(self.EXTENSIONS, curr_dir)
if fname != '': if fname != "":
self.load_from_file(fname) self.load_from_file(fname)
def load_from_file(self, fname): def load_from_file(self, fname):
self.set_text_from_file(fname) self.set_text_from_file(fname)
self.filename = fname self.filename = fname
self.reset_modified() self.reset_modified()
@@ -164,24 +177,22 @@ class Editor(CodeEditor,ComponentMixin):
# this function returns the encoding spyder used to read the file # this function returns the encoding spyder used to read the file
_, encoding = spyder.utils.encoding.read(fname) _, encoding = spyder.utils.encoding.read(fname)
# spyder returns a -guessed suffix in some cases # spyder returns a -guessed suffix in some cases
return encoding.replace('-guessed', '') return encoding.replace("-guessed", "")
else: else:
return 'utf-8' return "utf-8"
def save(self): def save(self):
if self._filename != "":
if self._filename != '': if self.preferences["Autoreload"]:
if self.preferences['Autoreload']:
self._file_watcher.blockSignals(True) self._file_watcher.blockSignals(True)
self._file_watch_timer.stop() self._file_watch_timer.stop()
encoding = self.determine_encoding(self._filename) encoding = self.determine_encoding(self._filename)
encoded = self.toPlainText().encode(encoding) encoded = self.toPlainText().encode(encoding)
with open(self._filename, 'wb') as f: with open(self._filename, "wb") as f:
f.write(encoded) f.write(encoded)
if self.preferences['Autoreload']: if self.preferences["Autoreload"]:
self._file_watcher.blockSignals(False) self._file_watcher.blockSignals(False)
self.triggerRerender.emit(True) self.triggerRerender.emit(True)
@@ -191,21 +202,26 @@ class Editor(CodeEditor,ComponentMixin):
self.save_as() self.save_as()
def save_as(self): def save_as(self):
fname = get_save_filename(self.EXTENSIONS) fname = get_save_filename(self.EXTENSIONS)
if fname != '': if fname != "":
encoded = self.toPlainText().encode('utf-8') encoded = self.toPlainText().encode("utf-8")
with open(fname, 'wb') as f: with open(fname, "wb") as f:
f.write(encoded) f.write(encoded)
self.filename = fname self.filename = fname
self.reset_modified() self.reset_modified()
def _update_filewatcher(self): def _update_filewatcher(self):
if self._watched_file and (self._watched_file != self.filename or not self.preferences['Autoreload']): if self._watched_file and (
self._watched_file != self.filename or not self.preferences["Autoreload"]
):
self._clear_watched_paths() self._clear_watched_paths()
self._watched_file = None self._watched_file = None
if self.preferences['Autoreload'] and self.filename and self.filename != self._watched_file: if (
self.preferences["Autoreload"]
and self.filename
and self.filename != self._watched_file
):
self._watched_file = self._filename self._watched_file = self._filename
self._watch_paths() self._watch_paths()
@@ -227,7 +243,7 @@ class Editor(CodeEditor,ComponentMixin):
def _watch_paths(self): def _watch_paths(self):
if Path(self._filename).exists(): if Path(self._filename).exists():
self._file_watcher.addPath(self._filename) self._file_watcher.addPath(self._filename)
if self.preferences['Autoreload: watch imported modules']: if self.preferences["Autoreload: watch imported modules"]:
module_paths = self.get_imported_module_paths(self._filename) module_paths = self.get_imported_module_paths(self._filename)
if module_paths: if module_paths:
self._file_watcher.addPaths(module_paths) self._file_watcher.addPaths(module_paths)
@@ -241,51 +257,45 @@ class Editor(CodeEditor,ComponentMixin):
# Turn autoreload on/off. # Turn autoreload on/off.
def autoreload(self, enabled): def autoreload(self, enabled):
self.preferences['Autoreload'] = enabled self.preferences["Autoreload"] = enabled
self._update_filewatcher() self._update_filewatcher()
def reset_modified(self): def reset_modified(self):
self.document().setModified(False) self.document().setModified(False)
@property @property
def modified(self): def modified(self):
return self.document().isModified() return self.document().isModified()
def saveComponentState(self, store): def saveComponentState(self, store):
if self.filename != "":
if self.filename != '': store.setValue(self.name + "/state", self.filename)
store.setValue(self.name+'/state',self.filename)
def restoreComponentState(self, store): def restoreComponentState(self, store):
filename = store.value(self.name + "/state")
filename = store.value(self.name+'/state') if filename and self.filename == "":
if filename and self.filename == '':
try: try:
self.load_from_file(filename) self.load_from_file(filename)
except IOError: except IOError:
self._logger.warning(f'could not open {filename}') self._logger.warning(f"could not open {filename}")
def get_imported_module_paths(self, module_path): def get_imported_module_paths(self, module_path):
finder = ModuleFinder([os.path.dirname(module_path)]) finder = ModuleFinder([os.path.dirname(module_path)])
imported_modules = [] imported_modules = []
try: try:
finder.run_script(module_path) finder.run_script(module_path)
except SyntaxError as err: except SyntaxError as err:
self._logger.warning(f'Syntax error in {module_path}: {err}') self._logger.warning(f"Syntax error in {module_path}: {err}")
except Exception as err: except Exception as err:
self._logger.warning( self._logger.warning(
f'Cannot determine imported modules in {module_path}: {type(err).__name__} {err}' f"Cannot determine imported modules in {module_path}: {type(err).__name__} {err}"
) )
else: else:
for module_name, module in finder.modules.items(): for module_name, module in finder.modules.items():
if module_name != '__main__': if module_name != "__main__":
path = getattr(module, '__file__', None) path = getattr(module, "__file__", None)
if path is not None and os.path.isfile(path): if path is not None and os.path.isfile(path):
imported_modules.append(path) imported_modules.append(path)
@@ -293,7 +303,6 @@ class Editor(CodeEditor,ComponentMixin):
if __name__ == "__main__": if __name__ == "__main__":
from PySide6.QtWidgets import QApplication from PySide6.QtWidgets import QApplication
app = QApplication(sys.argv) app = QApplication(sys.argv)

387
cq_editor/main_window.py
View File

@@ -1,6 +1,8 @@
import sys import sys
from PySide6.QtWidgets import (QLabel, QMainWindow, QToolBar, QDockWidget, QAction) from PySide6.QtWidgets import QLabel, QMainWindow, QToolBar, QDockWidget
from PySide6.QtGui import QAction
from PySide6.QtCore import Signal as pyqtSignal
from logbook import Logger from logbook import Logger
import cadquery as cq import cadquery as cq
@@ -14,7 +16,14 @@ from .widgets.cq_object_inspector import CQObjectInspector
from .widgets.log import LogViewer from .widgets.log import LogViewer
from . import __version__ from . import __version__
from .utils import dock, add_actions, open_url, about_dialog, check_gtihub_for_updates, confirm from .utils import (
dock,
add_actions,
open_url,
about_dialog,
check_gtihub_for_updates,
confirm,
)
from .mixins import MainMixin from .mixins import MainMixin
from .icons import icon from .icons import icon
from .preferences import PreferencesWidget from .preferences import PreferencesWidget
@@ -23,6 +32,9 @@ from .preferences import PreferencesWidget
from PySide6.QtCore import Qt from PySide6.QtCore import Qt
from PySide6.QtWidgets import QApplication from PySide6.QtWidgets import QApplication
from PySide6.QtGui import QPalette, QColor from PySide6.QtGui import QPalette, QColor
app = QApplication.instance()
if app == None:
app = QApplication([]) app = QApplication([])
# Force the style to be the same on all OSs: # Force the style to be the same on all OSs:
app.setStyle("Fusion") app.setStyle("Fusion")
@@ -43,54 +55,51 @@ palette.setColor(QPalette.Highlight, QColor(42, 130, 218))
palette.setColor(QPalette.HighlightedText, Qt.black) palette.setColor(QPalette.HighlightedText, Qt.black)
app.setPalette(palette) app.setPalette(palette)
class MainWindow(QMainWindow,MainMixin):
name = 'CQ-Editor' class MainWindow(QMainWindow, MainMixin):
org = 'CadQuery' name = "CQ-Editor"
org = "CadQuery"
def __init__(self, parent=None, filename=None): def __init__(self, parent=None, filename=None):
super(MainWindow, self).__init__(parent) super(MainWindow, self).__init__(parent)
MainMixin.__init__(self) MainMixin.__init__(self)
self.setWindowIcon(icon('app')) self.setWindowIcon(icon("app"))
self.viewer = OCCViewer(self) self.viewer = OCCViewer(self)
self.setCentralWidget(self.viewer.canvas) # self.setCentralWidget(self.viewer.canvas)
self.prepare_panes() # self.prepare_panes()
self.registerComponent('viewer',self.viewer) # self.registerComponent("viewer", self.viewer)
self.prepare_toolbar() # self.prepare_toolbar()
self.prepare_menubar() # self.prepare_menubar()
self.prepare_statusbar() # self.prepare_statusbar()
self.prepare_actions() # self.prepare_actions()
self.components['object_tree'].addLines() # self.components["object_tree"].addLines()
self.prepare_console() # self.prepare_console()
self.fill_dummy() # self.fill_dummy()
self.setup_logging() # self.setup_logging()
self.restorePreferences() # self.restorePreferences()
self.restoreWindow() # self.restoreWindow()
if filename: # if filename:
self.components['editor'].load_from_file(filename) # self.components["editor"].load_from_file(filename)
self.restoreComponentState() # self.restoreComponentState()
def closeEvent(self, event): def closeEvent(self, event):
self.saveWindow() self.saveWindow()
self.savePreferences() self.savePreferences()
self.saveComponentState() self.saveComponentState()
if self.components['editor'].document().isModified(): if self.components["editor"].document().isModified():
rv = confirm(self, "Confirm close", "Close without saving?")
rv = confirm(self, 'Confirm close', 'Close without saving?')
if rv: if rv:
event.accept() event.accept()
@@ -101,81 +110,74 @@ class MainWindow(QMainWindow,MainMixin):
super(MainWindow, self).closeEvent(event) super(MainWindow, self).closeEvent(event)
def prepare_panes(self): def prepare_panes(self):
self.registerComponent(
self.registerComponent('editor', "editor",
Editor(self), Editor(self),
lambda c : dock(c, lambda c: dock(c, "Editor", self, defaultArea="left"),
'Editor', )
self,
defaultArea='left'))
self.registerComponent('object_tree', self.registerComponent(
"object_tree",
ObjectTree(self), ObjectTree(self),
lambda c: dock(c, lambda c: dock(c, "Objects", self, defaultArea="right"),
'Objects', )
self,
defaultArea='right'))
self.registerComponent('console', self.registerComponent(
"console",
ConsoleWidget(self), ConsoleWidget(self),
lambda c: dock(c, lambda c: dock(c, "Console", self, defaultArea="bottom"),
'Console', )
self,
defaultArea='bottom'))
self.registerComponent('traceback_viewer', self.registerComponent(
"traceback_viewer",
TracebackPane(self), TracebackPane(self),
lambda c: dock(c, lambda c: dock(c, "Current traceback", self, defaultArea="bottom"),
'Current traceback', )
self,
defaultArea='bottom'))
self.registerComponent('debugger',Debugger(self)) self.registerComponent("debugger", Debugger(self))
self.registerComponent('variables_viewer',LocalsView(self), self.registerComponent(
lambda c: dock(c, "variables_viewer",
'Variables', LocalsView(self),
self, lambda c: dock(c, "Variables", self, defaultArea="right"),
defaultArea='right')) )
self.registerComponent('cq_object_inspector', self.registerComponent(
"cq_object_inspector",
CQObjectInspector(self), CQObjectInspector(self),
lambda c: dock(c, lambda c: dock(c, "CQ object inspector", self, defaultArea="right"),
'CQ object inspector', )
self, self.registerComponent(
defaultArea='right')) "log",
self.registerComponent('log',
LogViewer(self), LogViewer(self),
lambda c: dock(c, lambda c: dock(c, "Log viewer", self, defaultArea="bottom"),
'Log viewer', )
self,
defaultArea='bottom'))
for d in self.docks.values(): for d in self.docks.values():
d.show() d.show()
def prepare_menubar(self): def prepare_menubar(self):
menu = self.menuBar() menu = self.menuBar()
menu_file = menu.addMenu('&File') menu_file = menu.addMenu("&File")
menu_edit = menu.addMenu('&Edit') menu_edit = menu.addMenu("&Edit")
menu_tools = menu.addMenu('&Tools') menu_tools = menu.addMenu("&Tools")
menu_run = menu.addMenu('&Run') menu_run = menu.addMenu("&Run")
menu_view = menu.addMenu('&View') menu_view = menu.addMenu("&View")
menu_help = menu.addMenu('&Help') menu_help = menu.addMenu("&Help")
# per component menu elements # per component menu elements
menus = {'File' : menu_file, menus = {
'Edit' : menu_edit, "File": menu_file,
'Run' : menu_run, "Edit": menu_edit,
'Tools': menu_tools, "Run": menu_run,
'View' : menu_view, "Tools": menu_tools,
'Help' : menu_help} "View": menu_view,
"Help": menu_help,
}
for comp in self.components.values(): for comp in self.components.values():
self.prepare_menubar_component(menus, self.prepare_menubar_component(menus, comp.menuActions())
comp.menuActions())
# global menu elements # global menu elements
menu_view.addSeparator() menu_view.addSeparator()
@@ -186,37 +188,37 @@ class MainWindow(QMainWindow,MainMixin):
for t in self.findChildren(QToolBar): for t in self.findChildren(QToolBar):
menu_view.addAction(t.toggleViewAction()) menu_view.addAction(t.toggleViewAction())
menu_edit.addAction( \ menu_edit.addAction(
QAction(icon('preferences'), QAction(
'Preferences', icon("preferences"),
self,triggered=self.edit_preferences)) "Preferences",
self,
triggered=self.edit_preferences,
)
)
menu_help.addAction( \ menu_help.addAction(
QAction(icon('help'), QAction(icon("help"), "Documentation", self, triggered=self.documentation)
'Documentation', )
self,triggered=self.documentation))
menu_help.addAction( \ menu_help.addAction(
QAction('CQ documentation', QAction("CQ documentation", self, triggered=self.cq_documentation)
self,triggered=self.cq_documentation)) )
menu_help.addAction( \ menu_help.addAction(QAction(icon("about"), "About", self, triggered=self.about))
QAction(icon('about'),
'About',
self,triggered=self.about))
menu_help.addAction( \ menu_help.addAction(
QAction('Check for CadQuery updates', QAction(
self,triggered=self.check_for_cq_updates)) "Check for CadQuery updates", self, triggered=self.check_for_cq_updates
)
)
def prepare_menubar_component(self, menus, comp_menu_dict): def prepare_menubar_component(self, menus, comp_menu_dict):
for name, action in comp_menu_dict.items(): for name, action in comp_menu_dict.items():
menus[name].addActions(action) menus[name].addActions(action)
def prepare_toolbar(self): def prepare_toolbar(self):
self.toolbar = QToolBar("Main toolbar", self, objectName="Main toolbar")
self.toolbar = QToolBar('Main toolbar',self,objectName='Main toolbar')
for c in self.components.values(): for c in self.components.values():
add_actions(self.toolbar, c.toolbarActions()) add_actions(self.toolbar, c.toolbarActions())
@@ -224,143 +226,162 @@ class MainWindow(QMainWindow,MainMixin):
self.addToolBar(self.toolbar) self.addToolBar(self.toolbar)
def prepare_statusbar(self): def prepare_statusbar(self):
self.status_label = QLabel("", parent=self)
self.status_label = QLabel('',parent=self)
self.statusBar().insertPermanentWidget(0, self.status_label) self.statusBar().insertPermanentWidget(0, self.status_label)
def prepare_actions(self): def prepare_actions(self):
self.components["debugger"].sigRendered.connect(
self.components["object_tree"].addObjects
)
self.components["debugger"].sigTraceback.connect(
self.components["traceback_viewer"].addTraceback
)
self.components["debugger"].sigLocals.connect(
self.components["variables_viewer"].update_frame
)
self.components["debugger"].sigLocals.connect(
self.components["console"].push_vars
)
self.components['debugger'].sigRendered\ self.components["object_tree"].sigObjectsAdded[list].connect(
.connect(self.components['object_tree'].addObjects) self.components["viewer"].display_many
self.components['debugger'].sigTraceback\ )
.connect(self.components['traceback_viewer'].addTraceback) self.components["object_tree"].sigObjectsAdded2[list, bool].connect(
self.components['debugger'].sigLocals\ self.components["viewer"].display_many
.connect(self.components['variables_viewer'].update_frame) )
self.components['debugger'].sigLocals\ self.components["object_tree"].sigItemChanged.connect(
.connect(self.components['console'].push_vars) self.components["viewer"].update_item
)
self.components["object_tree"].sigObjectsRemoved.connect(
self.components["viewer"].remove_items
)
self.components["object_tree"].sigCQObjectSelected.connect(
self.components["cq_object_inspector"].setObject
)
self.components["object_tree"].sigObjectPropertiesChanged.connect(
self.components["viewer"].redraw
)
self.components["object_tree"].sigAISObjectsSelected.connect(
self.components["viewer"].set_selected
)
self.components['object_tree'].sigObjectsAdded[list]\ self.components["viewer"].sigObjectSelected.connect(
.connect(self.components['viewer'].display_many) self.components["object_tree"].handleGraphicalSelection
self.components['object_tree'].sigObjectsAdded[list,bool]\ )
.connect(self.components['viewer'].display_many)
self.components['object_tree'].sigItemChanged.\
connect(self.components['viewer'].update_item)
self.components['object_tree'].sigObjectsRemoved\
.connect(self.components['viewer'].remove_items)
self.components['object_tree'].sigCQObjectSelected\
.connect(self.components['cq_object_inspector'].setObject)
self.components['object_tree'].sigObjectPropertiesChanged\
.connect(self.components['viewer'].redraw)
self.components['object_tree'].sigAISObjectsSelected\
.connect(self.components['viewer'].set_selected)
self.components['viewer'].sigObjectSelected\ self.components["traceback_viewer"].sigHighlightLine.connect(
.connect(self.components['object_tree'].handleGraphicalSelection) self.components["editor"].go_to_line
)
self.components['traceback_viewer'].sigHighlightLine\ self.components["cq_object_inspector"].sigDisplayObjects.connect(
.connect(self.components['editor'].go_to_line) self.components["viewer"].display_many
)
self.components["cq_object_inspector"].sigRemoveObjects.connect(
self.components["viewer"].remove_items
)
self.components["cq_object_inspector"].sigShowPlane.connect(
self.components["viewer"].toggle_grid
)
self.components["cq_object_inspector"].sigShowPlane2[bool, float].connect(
self.components["viewer"].toggle_grid
)
self.components["cq_object_inspector"].sigChangePlane.connect(
self.components["viewer"].set_grid_orientation
)
self.components['cq_object_inspector'].sigDisplayObjects\ self.components["debugger"].sigLocalsChanged.connect(
.connect(self.components['viewer'].display_many) self.components["variables_viewer"].update_frame
self.components['cq_object_inspector'].sigRemoveObjects\ )
.connect(self.components['viewer'].remove_items) self.components["debugger"].sigLineChanged.connect(
self.components['cq_object_inspector'].sigShowPlane\ self.components["editor"].go_to_line
.connect(self.components['viewer'].toggle_grid) )
self.components['cq_object_inspector'].sigShowPlane[bool,float]\ self.components["debugger"].sigDebugging.connect(
.connect(self.components['viewer'].toggle_grid) self.components["object_tree"].stashObjects
self.components['cq_object_inspector'].sigChangePlane\ )
.connect(self.components['viewer'].set_grid_orientation) self.components["debugger"].sigCQChanged.connect(
self.components["object_tree"].addObjects
self.components['debugger'].sigLocalsChanged\ )
.connect(self.components['variables_viewer'].update_frame) self.components["debugger"].sigTraceback.connect(
self.components['debugger'].sigLineChanged\ self.components["traceback_viewer"].addTraceback
.connect(self.components['editor'].go_to_line) )
self.components['debugger'].sigDebugging\
.connect(self.components['object_tree'].stashObjects)
self.components['debugger'].sigCQChanged\
.connect(self.components['object_tree'].addObjects)
self.components['debugger'].sigTraceback\
.connect(self.components['traceback_viewer'].addTraceback)
# trigger re-render when file is modified externally or saved # trigger re-render when file is modified externally or saved
self.components['editor'].triggerRerender \ self.components["editor"].triggerRerender.connect(
.connect(self.components['debugger'].render) self.components["debugger"].render
self.components['editor'].sigFilenameChanged\ )
.connect(self.handle_filename_change) self.components["editor"].sigFilenameChanged.connect(
self.handle_filename_change
)
def prepare_console(self): def prepare_console(self):
console = self.components["console"]
console = self.components['console'] obj_tree = self.components["object_tree"]
obj_tree = self.components['object_tree']
# application related items # application related items
console.push_vars({'self' : self}) console.push_vars({"self": self})
# CQ related items # CQ related items
console.push_vars({'show' : obj_tree.addObject, console.push_vars(
'show_object' : obj_tree.addObject, {
'rand_color' : self.components['debugger']._rand_color, "show": obj_tree.addObject,
'cq' : cq, "show_object": obj_tree.addObject,
'log' : Logger(self.name).info}) "rand_color": self.components["debugger"]._rand_color,
"cq": cq,
"log": Logger(self.name).info,
}
)
def fill_dummy(self): def fill_dummy(self):
self.components["editor"].set_text(
self.components['editor']\ 'import cadquery as cq\nresult = cq.Workplane("XY" ).box(3, 3, 0.5).edges("|Z").fillet(0.125)'
.set_text('import cadquery as cq\nresult = cq.Workplane("XY" ).box(3, 3, 0.5).edges("|Z").fillet(0.125)') )
def setup_logging(self): def setup_logging(self):
from logbook.compat import redirect_logging from logbook.compat import redirect_logging
from logbook import INFO, Logger from logbook import INFO, Logger
redirect_logging() redirect_logging()
self.components['log'].handler.level = INFO self.components["log"].handler.level = INFO
self.components['log'].handler.push_application() self.components["log"].handler.push_application()
self._logger = Logger(self.name) self._logger = Logger(self.name)
def handle_exception(exc_type, exc_value, exc_traceback): def handle_exception(exc_type, exc_value, exc_traceback):
if issubclass(exc_type, KeyboardInterrupt): if issubclass(exc_type, KeyboardInterrupt):
sys.__excepthook__(exc_type, exc_value, exc_traceback) sys.__excepthook__(exc_type, exc_value, exc_traceback)
return return
self._logger.error("Uncaught exception occurred", self._logger.error(
exc_info=(exc_type, exc_value, exc_traceback)) "Uncaught exception occurred",
exc_info=(exc_type, exc_value, exc_traceback),
)
sys.excepthook = handle_exception sys.excepthook = handle_exception
def edit_preferences(self): def edit_preferences(self):
prefs = PreferencesWidget(self, self.components) prefs = PreferencesWidget(self, self.components)
prefs.exec_() prefs.exec_()
def about(self): def about(self):
about_dialog( about_dialog(
self, self,
f'About CQ-editor', f"About CQ-editor",
f'PyQt GUI for CadQuery.\nVersion: {__version__}.\nSource Code: https://github.com/CadQuery/CQ-editor', f"PyQt GUI for CadQuery.\nVersion: {__version__}.\nSource Code: https://github.com/CadQuery/CQ-editor",
) )
def check_for_cq_updates(self): def check_for_cq_updates(self):
check_gtihub_for_updates(self, cq) check_gtihub_for_updates(self, cq)
def documentation(self): def documentation(self):
open_url("https://github.com/CadQuery")
open_url('https://github.com/CadQuery')
def cq_documentation(self): def cq_documentation(self):
open_url("https://cadquery.readthedocs.io/en/latest/")
open_url('https://cadquery.readthedocs.io/en/latest/')
def handle_filename_change(self, fname): def handle_filename_change(self, fname):
new_title = fname if fname else "*" new_title = fname if fname else "*"
self.setWindowTitle(f"{self.name}: {new_title}") self.setWindowTitle(f"{self.name}: {new_title}")
if __name__ == "__main__":
if __name__ == "__main__":
pass pass

57
cq_editor/mixins.py
View File

@@ -10,72 +10,67 @@ from functools import reduce
from operator import add from operator import add
from logbook import Logger from logbook import Logger
from PySide6.QtCore import pyqtSlot, QSettings from PySide6.QtCore import QSettings
from PySide6.QtCore import Slot as pyqtSlot
class MainMixin(object): class MainMixin(object):
name = "Main"
name = 'Main' org = "Unknown"
org = 'Unknown'
components = {} components = {}
docks = {} docks = {}
preferences = None preferences = None
def __init__(self): def __init__(self):
self.settings = QSettings(self.org, self.name) self.settings = QSettings(self.org, self.name)
def registerComponent(self, name, component, dock=None): def registerComponent(self, name, component, dock=None):
self.components[name] = component self.components[name] = component
if dock: if dock:
self.docks[name] = dock(component) self.docks[name] = dock(component)
def saveWindow(self): def saveWindow(self):
self.settings.setValue("geometry", self.saveGeometry())
self.settings.setValue('geometry',self.saveGeometry()) self.settings.setValue("windowState", self.saveState())
self.settings.setValue('windowState',self.saveState())
def restoreWindow(self): def restoreWindow(self):
if self.settings.value("geometry"):
if self.settings.value('geometry'): self.restoreGeometry(self.settings.value("geometry"))
self.restoreGeometry(self.settings.value('geometry')) if self.settings.value("windowState"):
if self.settings.value('windowState'): self.restoreState(self.settings.value("windowState"))
self.restoreState(self.settings.value('windowState'))
def savePreferences(self): def savePreferences(self):
settings = self.settings settings = self.settings
if self.preferences: if self.preferences:
settings.setValue('General',self.preferences.saveState()) settings.setValue("General", self.preferences.saveState())
for comp in (c for c in self.components.values() if c.preferences): for comp in (c for c in self.components.values() if c.preferences):
settings.setValue(comp.name, comp.preferences.saveState()) settings.setValue(comp.name, comp.preferences.saveState())
def restorePreferences(self): def restorePreferences(self):
settings = self.settings settings = self.settings
if self.preferences and settings.value('General'): if self.preferences and settings.value("General"):
self.preferences.restoreState(settings.value('General'), self.preferences.restoreState(
removeChildren=False) settings.value("General"), removeChildren=False
)
for comp in (c for c in self.components.values() if c.preferences): for comp in (c for c in self.components.values() if c.preferences):
if settings.value(comp.name): if settings.value(comp.name):
comp.preferences.restoreState(settings.value(comp.name), comp.preferences.restoreState(
removeChildren=False) settings.value(comp.name), removeChildren=False
)
def saveComponentState(self): def saveComponentState(self):
settings = self.settings settings = self.settings
for comp in self.components.values(): for comp in self.components.values():
comp.saveComponentState(settings) comp.saveComponentState(settings)
def restoreComponentState(self): def restoreComponentState(self):
settings = self.settings settings = self.settings
for comp in self.components.values(): for comp in self.components.values():
@@ -83,28 +78,21 @@ class MainMixin(object):
class ComponentMixin(object): class ComponentMixin(object):
name = "Component"
name = 'Component'
preferences = None preferences = None
_actions = {} _actions = {}
def __init__(self): def __init__(self):
if self.preferences: if self.preferences:
self.preferences.sigTreeStateChanged.\ self.preferences.sigTreeStateChanged.connect(self.updatePreferences)
connect(self.updatePreferences)
self._logger = Logger(self.name) self._logger = Logger(self.name)
def menuActions(self): def menuActions(self):
return self._actions return self._actions
def toolbarActions(self): def toolbarActions(self):
if len(self._actions) > 0: if len(self._actions) > 0:
return reduce(add, [a for a in self._actions.values()]) return reduce(add, [a for a in self._actions.values()])
else: else:
@@ -112,13 +100,10 @@ class ComponentMixin(object):
@pyqtSlot(object, object) @pyqtSlot(object, object)
def updatePreferences(self, *args): def updatePreferences(self, *args):
pass pass
def saveComponentState(self, store): def saveComponentState(self, store):
pass pass
def restoreComponentState(self, store): def restoreComponentState(self, store):
pass pass

34
cq_editor/preferences.py
View File

@@ -1,6 +1,5 @@
from PySide6.QtWidgets import (QTreeWidget, QTreeWidgetItem, from PySide6.QtWidgets import QTreeWidget, QTreeWidgetItem, QStackedWidget, QDialog
QStackedWidget, QDialog) from PySide6.QtCore import Slot as pyqtSlot, Qt
from PySide6.QtCore import pyqtSlot, Qt
from pyqtgraph.parametertree import ParameterTree from pyqtgraph.parametertree import ParameterTree
@@ -8,32 +7,35 @@ from .utils import splitter, layout
class PreferencesTreeItem(QTreeWidgetItem): class PreferencesTreeItem(QTreeWidgetItem):
def __init__(
def __init__(self,name,widget,): self,
name,
widget,
):
super(PreferencesTreeItem, self).__init__(name) super(PreferencesTreeItem, self).__init__(name)
self.widget = widget self.widget = widget
class PreferencesWidget(QDialog): class PreferencesWidget(QDialog):
def __init__(self, parent, components): def __init__(self, parent, components):
super(PreferencesWidget, self).__init__( super(PreferencesWidget, self).__init__(
parent, parent,
Qt.Window | Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint, Qt.Window | Qt.CustomizeWindowHint | Qt.WindowCloseButtonHint,
windowTitle='Preferences') windowTitle="Preferences",
)
self.stacked = QStackedWidget(self) self.stacked = QStackedWidget(self)
self.preferences_tree = QTreeWidget(self, self.preferences_tree = QTreeWidget(
self,
headerHidden=True, headerHidden=True,
itemsExpandable=False, itemsExpandable=False,
rootIsDecorated=False, rootIsDecorated=False,
columnCount=1) columnCount=1,
)
self.root = self.preferences_tree.invisibleRootItem() self.root = self.preferences_tree.invisibleRootItem()
self.add('General', self.add("General", parent)
parent)
for v in parent.components.values(): for v in parent.components.values():
self.add(v.name, v) self.add(v.name, v)
@@ -44,19 +46,15 @@ class PreferencesWidget(QDialog):
self.preferences_tree.currentItemChanged.connect(self.handleSelection) self.preferences_tree.currentItemChanged.connect(self.handleSelection)
def add(self, name, component): def add(self, name, component):
if component.preferences: if component.preferences:
widget = ParameterTree() widget = ParameterTree()
widget.setHeaderHidden(True) widget.setHeaderHidden(True)
widget.setParameters(component.preferences, showTop=False) widget.setParameters(component.preferences, showTop=False)
self.root.addChild(PreferencesTreeItem((name,), self.root.addChild(PreferencesTreeItem((name,), widget))
widget))
self.stacked.addWidget(widget) self.stacked.addWidget(widget)
@pyqtSlot(QTreeWidgetItem, QTreeWidgetItem) @pyqtSlot(QTreeWidgetItem, QTreeWidgetItem)
def handleSelection(self, item, *args): def handleSelection(self, item, *args):
if item: if item:
self.stacked.setCurrentWidget(item.widget) self.stacked.setCurrentWidget(item.widget)

109
cq_editor/utils.py
View File

@@ -7,17 +7,22 @@ from PySide6.QtGui import QDesktopServices
from PySide6.QtCore import QUrl from PySide6.QtCore import QUrl
from PySide6.QtWidgets import QFileDialog, QMessageBox from PySide6.QtWidgets import QFileDialog, QMessageBox
DOCK_POSITIONS = {'right' : QtCore.Qt.RightDockWidgetArea, DOCK_POSITIONS = {
'left' : QtCore.Qt.LeftDockWidgetArea, "right": QtCore.Qt.RightDockWidgetArea,
'top' : QtCore.Qt.TopDockWidgetArea, "left": QtCore.Qt.LeftDockWidgetArea,
'bottom' : QtCore.Qt.BottomDockWidgetArea} "top": QtCore.Qt.TopDockWidgetArea,
"bottom": QtCore.Qt.BottomDockWidgetArea,
}
def layout(parent,items,
def layout(
parent,
items,
top_widget=None, top_widget=None,
layout_type=QtWidgets.QVBoxLayout, layout_type=QtWidgets.QVBoxLayout,
margin=2, margin=2,
spacing = 0): spacing=0,
):
if not top_widget: if not top_widget:
top_widget = QtWidgets.QWidget(parent) top_widget = QtWidgets.QWidget(parent)
top_widget_was_none = True top_widget_was_none = True
@@ -26,7 +31,8 @@ def layout(parent,items,
layout = layout_type(top_widget) layout = layout_type(top_widget)
top_widget.setLayout(layout) top_widget.setLayout(layout)
for item in items: layout.addWidget(item) for item in items:
layout.addWidget(item)
layout.setSpacing(spacing) layout.setSpacing(spacing)
layout.setContentsMargins(margin, margin, margin, margin) layout.setContentsMargins(margin, margin, margin, margin)
@@ -36,99 +42,112 @@ def layout(parent,items,
else: else:
return layout return layout
def splitter(items,
stretch_factors = None,
orientation=QtCore.Qt.Horizontal):
def splitter(items, stretch_factors=None, orientation=QtCore.Qt.Horizontal):
sp = QtWidgets.QSplitter(orientation) sp = QtWidgets.QSplitter(orientation)
for item in items: sp.addWidget(item) for item in items:
sp.addWidget(item)
if stretch_factors: if stretch_factors:
for i, s in enumerate(stretch_factors): for i, s in enumerate(stretch_factors):
sp.setStretchFactor(i, s) sp.setStretchFactor(i, s)
return sp return sp
def dock(widget,
def dock(
widget,
title, title,
parent, parent,
allowedAreas=QtCore.Qt.AllDockWidgetAreas, allowedAreas=QtCore.Qt.AllDockWidgetAreas,
defaultArea = 'right', defaultArea="right",
name=None, name=None,
icon = None): icon=None,
):
dock = QtWidgets.QDockWidget(title, parent, objectName=title) dock = QtWidgets.QDockWidget(title, parent, objectName=title)
if name: dock.setObjectName(name) if name:
if icon: dock.toggleViewAction().setIcon(icon) dock.setObjectName(name)
if icon:
dock.toggleViewAction().setIcon(icon)
dock.setAllowedAreas(allowedAreas) dock.setAllowedAreas(allowedAreas)
dock.setWidget(widget) dock.setWidget(widget)
action = dock.toggleViewAction() action = dock.toggleViewAction()
action.setText(title) action.setText(title)
dock.setFeatures(QtWidgets.QDockWidget.DockWidgetFeatures(\ dock.setFeatures(
QtWidgets.QDockWidget.AllDockWidgetFeatures)) QtWidgets.QDockWidget.DockWidgetFeatures(
QtWidgets.QDockWidget.DockWidgetFloatable
)
)
parent.addDockWidget(DOCK_POSITIONS[defaultArea], parent.addDockWidget(DOCK_POSITIONS[defaultArea], dock)
dock)
return dock return dock
def add_actions(menu,actions):
def add_actions(menu, actions):
if len(actions) > 0: if len(actions) > 0:
menu.addActions(actions) menu.addActions(actions)
menu.addSeparator() menu.addSeparator()
def open_url(url):
def open_url(url):
QDesktopServices.openUrl(QUrl(url)) QDesktopServices.openUrl(QUrl(url))
def about_dialog(parent,title,text):
def about_dialog(parent, title, text):
QtWidgets.QMessageBox.about(parent, title, text) QtWidgets.QMessageBox.about(parent, title, text)
def get_save_filename(suffix): def get_save_filename(suffix):
rv, _ = QFileDialog.getSaveFileName(filter="*.{}".format(suffix))
rv,_ = QFileDialog.getSaveFileName(filter='*.{}'.format(suffix)) if rv != "" and not rv.endswith(suffix):
if rv != '' and not rv.endswith(suffix): rv += '.'+suffix rv += "." + suffix
return rv return rv
def get_open_filename(suffix, curr_dir): def get_open_filename(suffix, curr_dir):
rv, _ = QFileDialog.getOpenFileName(
rv,_ = QFileDialog.getOpenFileName(directory=curr_dir, filter='*.{}'.format(suffix)) directory=curr_dir, filter="*.{}".format(suffix)
if rv != '' and not rv.endswith(suffix): rv += '.'+suffix )
if rv != "" and not rv.endswith(suffix):
rv += "." + suffix
return rv return rv
def check_gtihub_for_updates(parent,
mod,
github_org='cadquery',
github_proj='cadquery'):
url = f'https://api.github.com/repos/{github_org}/{github_proj}/releases' def check_gtihub_for_updates(
parent, mod, github_org="cadquery", github_proj="cadquery"
):
url = f"https://api.github.com/repos/{github_org}/{github_proj}/releases"
resp = requests.get(url).json() resp = requests.get(url).json()
newer = [el['tag_name'] for el in resp if not el['draft'] and \ newer = [
parse_version(el['tag_name']) > parse_version(mod.__version__)] el["tag_name"]
for el in resp
if not el["draft"]
and parse_version(el["tag_name"]) > parse_version(mod.__version__)
]
if newer: if newer:
title='Updates available' title = "Updates available"
text=f'There are newer versions of {github_proj} ' \ text = (
f'available on github:\n' + '\n'.join(newer) f"There are newer versions of {github_proj} "
f"available on github:\n" + "\n".join(newer)
)
else: else:
title='No updates available' title = "No updates available"
text=f'You are already using the latest version of {github_proj}' text = f"You are already using the latest version of {github_proj}"
QtWidgets.QMessageBox.about(parent, title, text) QtWidgets.QMessageBox.about(parent, title, text)
def confirm(parent,title,msg):
def confirm(parent, title, msg):
rv = QMessageBox.question(parent, title, msg, QMessageBox.Yes, QMessageBox.No) rv = QMessageBox.question(parent, title, msg, QMessageBox.Yes, QMessageBox.No)
return True if rv == QMessageBox.Yes else False return True if rv == QMessageBox.Yes else False

22
cq_editor/widgets/console.py
View File

@@ -1,14 +1,14 @@
from PySide6.QtWidgets import QApplication from PySide6.QtWidgets import QApplication
from PySide6.QtCore import pyqtSlot from PySide6.QtCore import Slot as pyqtSlot
from qtconsole.rich_jupyter_widget import RichJupyterWidget from qtconsole.rich_jupyter_widget import RichJupyterWidget
from qtconsole.inprocess import QtInProcessKernelManager from qtconsole.inprocess import QtInProcessKernelManager
from ..mixins import ComponentMixin from ..mixins import ComponentMixin
class ConsoleWidget(RichJupyterWidget,ComponentMixin):
name = 'Console' class ConsoleWidget(RichJupyterWidget, ComponentMixin):
name = "Console"
def __init__(self, customBanner=None, namespace=dict(), *args, **kwargs): def __init__(self, customBanner=None, namespace=dict(), *args, **kwargs):
super(ConsoleWidget, self).__init__(*args, **kwargs) super(ConsoleWidget, self).__init__(*args, **kwargs)
@@ -17,7 +17,7 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
# self.banner = customBanner # self.banner = customBanner
self.font_size = 6 self.font_size = 6
self.style_sheet = '''<style> self.style_sheet = """<style>
QPlainTextEdit, QTextEdit { QPlainTextEdit, QTextEdit {
background-color: #3f3f3f; background-color: #3f3f3f;
background-clip: padding; background-clip: padding;
@@ -34,12 +34,12 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
.in-prompt { color: navy; } .in-prompt { color: navy; }
.out-prompt { color: darkred; } .out-prompt { color: darkred; }
</style> </style>
''' """
self.syntax_style = 'zenburn' #CHANGES FOR DARKMODE self.syntax_style = "zenburn" # CHANGES FOR DARKMODE
self.kernel_manager = kernel_manager = QtInProcessKernelManager() self.kernel_manager = kernel_manager = QtInProcessKernelManager()
kernel_manager.start_kernel(show_banner=False) kernel_manager.start_kernel(show_banner=False)
kernel_manager.kernel.gui = 'qt' kernel_manager.kernel.gui = "qt"
kernel_manager.kernel.shell.banner1 = "" kernel_manager.kernel.shell.banner1 = ""
self.kernel_client = kernel_client = self._kernel_manager.client() self.kernel_client = kernel_client = self._kernel_manager.client()
@@ -70,7 +70,6 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
""" """
self._control.clear() self._control.clear()
def print_text(self, text): def print_text(self, text):
""" """
Prints some plain text to the console Prints some plain text to the console
@@ -84,18 +83,15 @@ class ConsoleWidget(RichJupyterWidget,ComponentMixin):
self._execute(command, False) self._execute(command, False)
def _banner_default(self): def _banner_default(self):
return ""
return ''
if __name__ == "__main__": if __name__ == "__main__":
import sys import sys
app = QApplication(sys.argv) app = QApplication(sys.argv)
console = ConsoleWidget(customBanner='IPython console test') console = ConsoleWidget(customBanner="IPython console test")
console.show() console.show()
sys.exit(app.exec_()) sys.exit(app.exec_())

61
cq_editor/widgets/cq_object_inspector.py
View File

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

7
cq_editor/widgets/debugger.py
View File

@@ -9,12 +9,13 @@ from PySide6 import QtCore
from PySide6.QtCore import ( from PySide6.QtCore import (
Qt, Qt,
QObject, QObject,
pyqtSlot, Slot as pyqtSlot,
pyqtSignal, Signal as pyqtSignal,
QEventLoop, QEventLoop,
QAbstractTableModel, QAbstractTableModel,
) )
from PySide6.QtWidgets import QAction, QTableView from PySide6.QtWidgets import QTableView
from PySide6.QtGui import QAction
from logbook import info from logbook import info
from path import Path from path import Path
from pyqtgraph.parametertree import Parameter from pyqtgraph.parametertree import Parameter

195
cq_editor/widgets/editor.py
View File

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

7
cq_editor/widgets/object_tree.py
View File

@@ -1,12 +1,12 @@
from PySide6.QtWidgets import ( from PySide6.QtWidgets import (
QTreeWidget, QTreeWidget,
QTreeWidgetItem, QTreeWidgetItem,
QAction,
QMenu, QMenu,
QWidget, QWidget,
QAbstractItemView, QAbstractItemView,
) )
from PySide6.QtCore import Qt, pyqtSlot, pyqtSignal from PySide6.QtGui import QAction
from PySide6.QtCore import Qt, Slot as pyqtSlot, Signal as pyqtSignal
from pyqtgraph.parametertree import Parameter, ParameterTree from pyqtgraph.parametertree import Parameter, ParameterTree
from OCP.AIS import AIS_Line from OCP.AIS import AIS_Line
@@ -114,7 +114,8 @@ class ObjectTree(QWidget, ComponentMixin):
], ],
) )
sigObjectsAdded = pyqtSignal([list], [list, bool]) sigObjectsAdded = pyqtSignal(list)
sigObjectsAdded2 = pyqtSignal(list, bool)
sigObjectsRemoved = pyqtSignal(list) sigObjectsRemoved = pyqtSignal(list)
sigCQObjectSelected = pyqtSignal(object) sigCQObjectSelected = pyqtSignal(object)
sigAISObjectsSelected = pyqtSignal(list) sigAISObjectsSelected = pyqtSignal(list)

35
cq_editor/widgets/occt_widget.py
View File

@@ -2,7 +2,7 @@ from sys import platform
from PySide6.QtWidgets import QWidget, QApplication from PySide6.QtWidgets import QWidget, QApplication
from PySide6.QtCore import pyqtSlot, pyqtSignal, Qt, QEvent from PySide6.QtCore import Slot as pyqtSlot, Signal as pyqtSignal, Qt, QEvent
import OCP import OCP
@@ -17,11 +17,9 @@ ZOOM_STEP = 0.9
class OCCTWidget(QWidget): class OCCTWidget(QWidget):
sigObjectSelected = pyqtSignal(list) sigObjectSelected = pyqtSignal(list)
def __init__(self, parent=None): def __init__(self, parent=None):
super(OCCTWidget, self).__init__(parent) super(OCCTWidget, self).__init__(parent)
self.setAttribute(Qt.WA_NativeWindow) self.setAttribute(Qt.WA_NativeWindow)
@@ -43,7 +41,6 @@ class OCCTWidget(QWidget):
self.prepare_display() self.prepare_display()
def prepare_display(self): def prepare_display(self):
view = self.view view = self.view
params = view.ChangeRenderingParams() params = view.ChangeRenderingParams()
@@ -51,8 +48,8 @@ class OCCTWidget(QWidget):
params.IsAntialiasingEnabled = True params.IsAntialiasingEnabled = True
view.TriedronDisplay( view.TriedronDisplay(
Aspect_TypeOfTriedronPosition.Aspect_TOTP_RIGHT_LOWER, Aspect_TypeOfTriedronPosition.Aspect_TOTP_RIGHT_LOWER, Quantity_Color(), 0.1
Quantity_Color(), 0.1) )
view.ZBufferTriedronSetup(Quantity_Color(*(0.2, 0.0, 0.0), TOC_RGB)) view.ZBufferTriedronSetup(Quantity_Color(*(0.2, 0.0, 0.0), TOC_RGB))
@@ -67,14 +64,12 @@ class OCCTWidget(QWidget):
ctx.DefaultDrawer().SetFaceBoundaryDraw(True) ctx.DefaultDrawer().SetFaceBoundaryDraw(True)
def wheelEvent(self, event): def wheelEvent(self, event):
delta = event.angleDelta().y() delta = event.angleDelta().y()
factor = ZOOM_STEP if delta < 0 else 1 / ZOOM_STEP factor = ZOOM_STEP if delta < 0 else 1 / ZOOM_STEP
self.view.SetZoom(factor) self.view.SetZoom(factor)
def mousePressEvent(self, event): def mousePressEvent(self, event):
pos = event.pos() pos = event.pos()
if event.button() == Qt.LeftButton: if event.button() == Qt.LeftButton:
@@ -85,7 +80,6 @@ class OCCTWidget(QWidget):
self.old_pos = pos self.old_pos = pos
def mouseMoveEvent(self, event): def mouseMoveEvent(self, event):
pos = event.pos() pos = event.pos()
x, y = pos.x(), pos.y() x, y = pos.x(), pos.y()
@@ -93,17 +87,14 @@ class OCCTWidget(QWidget):
self.view.Rotation(x, y) self.view.Rotation(x, y)
elif event.buttons() == Qt.MiddleButton: elif event.buttons() == Qt.MiddleButton:
self.view.Pan(x - self.old_pos.x(), self.view.Pan(x - self.old_pos.x(), self.old_pos.y() - y, theToStart=True)
self.old_pos.y() - y, theToStart=True)
elif event.buttons() == Qt.RightButton: elif event.buttons() == Qt.RightButton:
self.view.Pan(x - self.old_pos.x(), self.view.Pan(x - self.old_pos.x(), self.old_pos.y() - y, theToStart=True)
self.old_pos.y() - y, theToStart=True)
self.old_pos = pos self.old_pos = pos
def mouseReleaseEvent(self, event): def mouseReleaseEvent(self, event):
if event.button() == Qt.LeftButton: if event.button() == Qt.LeftButton:
pos = event.pos() pos = event.pos()
x, y = pos.x(), pos.y() x, y = pos.x(), pos.y()
@@ -113,7 +104,6 @@ class OCCTWidget(QWidget):
self._handle_selection() self._handle_selection()
def _handle_selection(self): def _handle_selection(self):
self.context.Select(True) self.context.Select(True)
self.context.InitSelected() self.context.InitSelected()
@@ -124,32 +114,27 @@ class OCCTWidget(QWidget):
self.sigObjectSelected.emit(selected) self.sigObjectSelected.emit(selected)
def paintEngine(self): def paintEngine(self):
return None return None
def paintEvent(self, event): def paintEvent(self, event):
if not self._initialized: if not self._initialized:
self._initialize() self._initialize()
else: else:
self.view.Redraw() self.view.Redraw()
def showEvent(self, event): def showEvent(self, event):
super(OCCTWidget, self).showEvent(event) super(OCCTWidget, self).showEvent(event)
def resizeEvent(self, event): def resizeEvent(self, event):
super(OCCTWidget, self).resizeEvent(event) super(OCCTWidget, self).resizeEvent(event)
self.view.MustBeResized() self.view.MustBeResized()
def _initialize(self): def _initialize(self):
wins = { wins = {
'darwin' : self._get_window_osx, "darwin": self._get_window_osx,
'linux' : self._get_window_linux, "linux": self._get_window_linux,
'win32': self._get_window_win "win32": self._get_window_win,
} }
self.view.SetWindow(wins.get(platform, self._get_window_linux)(self.winId())) self.view.SetWindow(wins.get(platform, self._get_window_linux)(self.winId()))
@@ -157,19 +142,17 @@ class OCCTWidget(QWidget):
self._initialized = True self._initialized = True
def _get_window_win(self, wid): def _get_window_win(self, wid):
from OCP.WNT import WNT_Window from OCP.WNT import WNT_Window
print(wid)
return WNT_Window(wid.ascapsule()) return WNT_Window(wid.ascapsule())
def _get_window_linux(self, wid): def _get_window_linux(self, wid):
from OCP.Xw import Xw_Window from OCP.Xw import Xw_Window
return Xw_Window(self.display_connection, int(wid)) return Xw_Window(self.display_connection, int(wid))
def _get_window_osx(self, wid): def _get_window_osx(self, wid):
from OCP.Cocoa import Cocoa_Window from OCP.Cocoa import Cocoa_Window
return Cocoa_Window(wid.ascapsule()) return Cocoa_Window(wid.ascapsule())

60
cq_editor/widgets/traceback_viewer.py
View File

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

318
cq_editor/widgets/viewer.py
View File

@@ -1,14 +1,21 @@
from PySide6.QtWidgets import QWidget, QDialog, QTreeWidgetItem, QApplication, QAction from PySide6.QtWidgets import QWidget, QDialog, QTreeWidgetItem, QApplication
from PySide6.QtCore import pyqtSlot, pyqtSignal from PySide6.QtCore import Slot as pyqtSlot, Signal as pyqtSignal
from PySide6.QtGui import QIcon from PySide6.QtGui import QIcon, QAction
from OCP.Graphic3d import Graphic3d_Camera, Graphic3d_StereoMode, Graphic3d_NOM_JADE,\ from OCP.Graphic3d import (
Graphic3d_MaterialAspect Graphic3d_Camera,
Graphic3d_StereoMode,
Graphic3d_NOM_JADE,
Graphic3d_MaterialAspect,
)
from OCP.AIS import AIS_Shaded, AIS_WireFrame, AIS_ColoredShape, AIS_Axis from OCP.AIS import AIS_Shaded, AIS_WireFrame, AIS_ColoredShape, AIS_Axis
from OCP.Aspect import Aspect_GDM_Lines, Aspect_GT_Rectangular from OCP.Aspect import Aspect_GDM_Lines, Aspect_GT_Rectangular
from OCP.Quantity import Quantity_NOC_BLACK as BLACK, Quantity_TOC_RGB as TOC_RGB,\ from OCP.Quantity import (
Quantity_Color Quantity_NOC_BLACK as BLACK,
Quantity_TOC_RGB as TOC_RGB,
Quantity_Color,
)
from OCP.Geom import Geom_Axis1Placement from OCP.Geom import Geom_Axis1Placement
from OCP.gp import gp_Ax3, gp_Dir, gp_Pnt, gp_Ax1 from OCP.gp import gp_Ax3, gp_Dir, gp_Pnt, gp_Ax1
@@ -25,29 +32,65 @@ import qtawesome as qta
DEFAULT_EDGE_COLOR = Quantity_Color(BLACK) DEFAULT_EDGE_COLOR = Quantity_Color(BLACK)
DEFAULT_EDGE_WIDTH = 2 DEFAULT_EDGE_WIDTH = 2
class OCCViewer(QWidget, ComponentMixin): class OCCViewer(QWidget, ComponentMixin):
name = "3D Viewer"
name = '3D Viewer' preferences = Parameter.create(
name="Pref",
preferences = Parameter.create(name='Pref',children=[ children=[
{'name': 'Fit automatically', 'type': 'bool', 'value': True}, {"name": "Fit automatically", "type": "bool", "value": True},
{'name': 'Use gradient', 'type': 'bool', 'value': False}, {"name": "Use gradient", "type": "bool", "value": False},
{'name': 'Background color', 'type': 'color', 'value': (95,95,95)}, {"name": "Background color", "type": "color", "value": (95, 95, 95)},
{'name': 'Background color (aux)', 'type': 'color', 'value': (30,30,30)}, {"name": "Background color (aux)", "type": "color", "value": (30, 30, 30)},
{'name': 'Default object color', 'type': 'color', 'value': "#FF0"}, {"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": "Deviation",
{'name': 'Projection Type', 'type': 'list', 'value': 'Orthographic', "type": "float",
'values': ['Orthographic', 'Perspective', 'Stereo', 'MonoLeftEye', 'MonoRightEye']}, "value": 1e-5,
{'name': 'Stereo Mode', 'type': 'list', 'value': 'QuadBuffer', "dec": True,
'values': ['QuadBuffer', 'Anaglyph', 'RowInterlaced', 'ColumnInterlaced', "step": 1,
'ChessBoard', 'SideBySide', 'OverUnder']}]) },
IMAGE_EXTENSIONS = 'png' {
"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) sigObjectSelected = pyqtSignal(list)
def __init__(self, parent=None): def __init__(self, parent=None):
super(OCCViewer, self).__init__(parent) super(OCCViewer, self).__init__(parent)
ComponentMixin.__init__(self) ComponentMixin.__init__(self)
@@ -56,15 +99,18 @@ class OCCViewer(QWidget,ComponentMixin):
self.create_actions(self) self.create_actions(self)
self.layout_ = layout(self, self.layout_ = layout(
[self.canvas,], self,
[
self.canvas,
],
top_widget=self, top_widget=self,
margin=0) margin=0,
)
self.setup_default_drawer() # misspelled in original self.setup_default_drawer() # misspelled in original
self.updatePreferences() self.updatePreferences()
def setup_default_drawer(self): def setup_default_drawer(self):
# set the default color and material # set the default color and material
material = Graphic3d_MaterialAspect(Graphic3d_NOM_JADE) material = Graphic3d_MaterialAspect(Graphic3d_NOM_JADE)
@@ -78,97 +124,127 @@ class OCCViewer(QWidget,ComponentMixin):
line_aspect.SetColor(DEFAULT_EDGE_COLOR) line_aspect.SetColor(DEFAULT_EDGE_COLOR)
def updatePreferences(self, *args): def updatePreferences(self, *args):
color1 = to_occ_color(self.preferences["Background color"])
color2 = to_occ_color(self.preferences["Background color (aux)"])
color1 = to_occ_color(self.preferences['Background color']) if not self.preferences["Use gradient"]:
color2 = to_occ_color(self.preferences['Background color (aux)'])
if not self.preferences['Use gradient']:
color2 = color1 color2 = color1
self.canvas.view.SetBgGradientColors(color1, color2, theToUpdate=True) self.canvas.view.SetBgGradientColors(color1, color2, theToUpdate=True)
self.canvas.update() self.canvas.update()
ctx = self.canvas.context ctx = self.canvas.context
ctx.SetDeviationCoefficient(self.preferences['Deviation']) ctx.SetDeviationCoefficient(self.preferences["Deviation"])
ctx.SetDeviationAngle(self.preferences['Angular deviation']) ctx.SetDeviationAngle(self.preferences["Angular deviation"])
v = self._get_view() v = self._get_view()
camera = v.Camera() camera = v.Camera()
projection_type = self.preferences['Projection Type'] projection_type = self.preferences["Projection Type"]
camera.SetProjectionType(getattr(Graphic3d_Camera, f'Projection_{projection_type}', camera.SetProjectionType(
Graphic3d_Camera.Projection_Orthographic)) getattr(
Graphic3d_Camera,
f"Projection_{projection_type}",
Graphic3d_Camera.Projection_Orthographic,
)
)
# onle relevant for stereo projection # onle relevant for stereo projection
stereo_mode = self.preferences['Stereo Mode'] stereo_mode = self.preferences["Stereo Mode"]
params = v.ChangeRenderingParams() params = v.ChangeRenderingParams()
params.StereoMode = getattr(Graphic3d_StereoMode, f'Graphic3d_StereoMode_{stereo_mode}', params.StereoMode = getattr(
Graphic3d_StereoMode.Graphic3d_StereoMode_QuadBuffer) Graphic3d_StereoMode,
f"Graphic3d_StereoMode_{stereo_mode}",
Graphic3d_StereoMode.Graphic3d_StereoMode_QuadBuffer,
)
def create_actions(self, parent): def create_actions(self, parent):
self._actions = {
self._actions = \ "View": [
{'View' : [QAction(qta.icon('fa.arrows-alt'), QAction(
'Fit (Shift+F1)', qta.icon("fa.arrows-alt"),
"Fit (Shift+F1)",
parent, parent,
shortcut='shift+F1', shortcut="shift+F1",
triggered=self.fit), triggered=self.fit,
QAction(QIcon(':/images/icons/isometric_view.svg'), ),
'Iso (Shift+F2)', QAction(
QIcon(":/images/icons/isometric_view.svg"),
"Iso (Shift+F2)",
parent, parent,
shortcut='shift+F2', shortcut="shift+F2",
triggered=self.iso_view), triggered=self.iso_view,
QAction(QIcon(':/images/icons/top_view.svg'), ),
'Top (Shift+F3)', QAction(
QIcon(":/images/icons/top_view.svg"),
"Top (Shift+F3)",
parent, parent,
shortcut='shift+F3', shortcut="shift+F3",
triggered=self.top_view), triggered=self.top_view,
QAction(QIcon(':/images/icons/bottom_view.svg'), ),
'Bottom (Shift+F4)', QAction(
QIcon(":/images/icons/bottom_view.svg"),
"Bottom (Shift+F4)",
parent, parent,
shortcut='shift+F4', shortcut="shift+F4",
triggered=self.bottom_view), triggered=self.bottom_view,
QAction(QIcon(':/images/icons/front_view.svg'), ),
'Front (Shift+F5)', QAction(
QIcon(":/images/icons/front_view.svg"),
"Front (Shift+F5)",
parent, parent,
shortcut='shift+F5', shortcut="shift+F5",
triggered=self.front_view), triggered=self.front_view,
QAction(QIcon(':/images/icons/back_view.svg'), ),
'Back (Shift+F6)', QAction(
QIcon(":/images/icons/back_view.svg"),
"Back (Shift+F6)",
parent, parent,
shortcut='shift+F6', shortcut="shift+F6",
triggered=self.back_view), triggered=self.back_view,
QAction(QIcon(':/images/icons/left_side_view.svg'), ),
'Left (Shift+F7)', QAction(
QIcon(":/images/icons/left_side_view.svg"),
"Left (Shift+F7)",
parent, parent,
shortcut='shift+F7', shortcut="shift+F7",
triggered=self.left_view), triggered=self.left_view,
QAction(QIcon(':/images/icons/right_side_view.svg'), ),
'Right (Shift+F8)', QAction(
QIcon(":/images/icons/right_side_view.svg"),
"Right (Shift+F8)",
parent, parent,
shortcut='shift+F8', shortcut="shift+F8",
triggered=self.right_view), triggered=self.right_view,
QAction(qta.icon('fa.square-o'), ),
'Wireframe (Shift+F9)', QAction(
qta.icon("fa.square-o"),
"Wireframe (Shift+F9)",
parent, parent,
shortcut='shift+F9', shortcut="shift+F9",
triggered=self.wireframe_view), triggered=self.wireframe_view,
QAction(qta.icon('fa.square'), ),
'Shaded (Shift+F10)', QAction(
qta.icon("fa.square"),
"Shaded (Shift+F10)",
parent, parent,
shortcut='shift+F10', shortcut="shift+F10",
triggered=self.shaded_view)], triggered=self.shaded_view,
'Tools' : [QAction(icon('screenshot'), ),
'Screenshot', ],
"Tools": [
QAction(
icon("screenshot"),
"Screenshot",
parent, parent,
triggered=self.save_screenshot)]} triggered=self.save_screenshot,
)
],
}
def toolbarActions(self): def toolbarActions(self):
return self._actions["View"]
return self._actions['View']
def clear(self): def clear(self):
self.displayed_shapes = [] self.displayed_shapes = []
self.displayed_ais = [] self.displayed_ais = []
self.canvas.context.EraseAll(True) self.canvas.context.EraseAll(True)
@@ -177,7 +253,6 @@ class OCCViewer(QWidget,ComponentMixin):
context.RemoveAll(True) context.RemoveAll(True)
def _display(self, shape): def _display(self, shape):
ais = make_AIS(shape) ais = make_AIS(shape)
self.canvas.context.Display(shape, True) self.canvas.context.Display(shape, True)
@@ -188,28 +263,26 @@ class OCCViewer(QWidget,ComponentMixin):
@pyqtSlot(object) @pyqtSlot(object)
def display(self, ais): def display(self, ais):
context = self._get_context() context = self._get_context()
context.Display(ais, True) context.Display(ais, True)
if self.preferences['Fit automatically']: self.fit() if self.preferences["Fit automatically"]:
self.fit()
@pyqtSlot(list) @pyqtSlot(list)
@pyqtSlot(list, bool) @pyqtSlot(list, bool)
def display_many(self, ais_list, fit=None): def display_many(self, ais_list, fit=None):
context = self._get_context() context = self._get_context()
for ais in ais_list: for ais in ais_list:
context.Display(ais, True) context.Display(ais, True)
if self.preferences['Fit automatically'] and fit is None: if self.preferences["Fit automatically"] and fit is None:
self.fit() self.fit()
elif fit: elif fit:
self.fit() self.fit()
@pyqtSlot(QTreeWidgetItem, int) @pyqtSlot(QTreeWidgetItem, int)
def update_item(self, item, col): def update_item(self, item, col):
ctx = self._get_context() ctx = self._get_context()
if item.checkState(0): if item.checkState(0):
ctx.Display(item.ais, True) ctx.Display(item.ais, True)
@@ -218,97 +291,79 @@ class OCCViewer(QWidget,ComponentMixin):
@pyqtSlot(list) @pyqtSlot(list)
def remove_items(self, ais_items): def remove_items(self, ais_items):
ctx = self._get_context() ctx = self._get_context()
for ais in ais_items: ctx.Erase(ais,True) for ais in ais_items:
ctx.Erase(ais, True)
@pyqtSlot() @pyqtSlot()
def redraw(self): def redraw(self):
self._get_viewer().Redraw() self._get_viewer().Redraw()
def fit(self): def fit(self):
self.canvas.view.FitAll() self.canvas.view.FitAll()
def iso_view(self): def iso_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(1, -1, 1) v.SetProj(1, -1, 1)
v.SetTwist(0) v.SetTwist(0)
def bottom_view(self): def bottom_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(0, 0, -1) v.SetProj(0, 0, -1)
v.SetTwist(0) v.SetTwist(0)
def top_view(self): def top_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(0, 0, 1) v.SetProj(0, 0, 1)
v.SetTwist(0) v.SetTwist(0)
def front_view(self): def front_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(0, -1, 0) v.SetProj(0, -1, 0)
v.SetTwist(0) v.SetTwist(0)
def back_view(self): def back_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(0, 1, 0) v.SetProj(0, 1, 0)
v.SetTwist(0) v.SetTwist(0)
def left_view(self): def left_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(-1, 0, 0) v.SetProj(-1, 0, 0)
v.SetTwist(0) v.SetTwist(0)
def right_view(self): def right_view(self):
v = self._get_view() v = self._get_view()
v.SetProj(1, 0, 0) v.SetProj(1, 0, 0)
v.SetTwist(0) v.SetTwist(0)
def shaded_view(self): def shaded_view(self):
c = self._get_context() c = self._get_context()
c.SetDisplayMode(AIS_Shaded, True) c.SetDisplayMode(AIS_Shaded, True)
def wireframe_view(self): def wireframe_view(self):
c = self._get_context() c = self._get_context()
c.SetDisplayMode(AIS_WireFrame, True) c.SetDisplayMode(AIS_WireFrame, True)
def show_grid(self, def show_grid(
step=1., self, step=1.0, size=10.0 + 1e-6, color1=(0.7, 0.7, 0.7), color2=(0, 0, 0)
size=10.+1e-6, ):
color1=(.7,.7,.7),
color2=(0,0,0)):
viewer = self._get_viewer() viewer = self._get_viewer()
viewer.ActivateGrid(Aspect_GT_Rectangular, viewer.ActivateGrid(Aspect_GT_Rectangular, Aspect_GDM_Lines)
Aspect_GDM_Lines)
viewer.SetRectangularGridGraphicValues(size, size, 0) viewer.SetRectangularGridGraphicValues(size, size, 0)
viewer.SetRectangularGridValues(0, 0, step, step, 0) viewer.SetRectangularGridValues(0, 0, step, step, 0)
grid = viewer.Grid() grid = viewer.Grid()
grid.SetColors(Quantity_Color(*color1,TOC_RGB), grid.SetColors(
Quantity_Color(*color2,TOC_RGB)) Quantity_Color(*color1, TOC_RGB), Quantity_Color(*color2, TOC_RGB)
)
def hide_grid(self): def hide_grid(self):
viewer = self._get_viewer() viewer = self._get_viewer()
viewer.DeactivateGrid() viewer.DeactivateGrid()
@pyqtSlot(bool, float) @pyqtSlot(bool, float)
@pyqtSlot(bool) @pyqtSlot(bool)
def toggle_grid(self, def toggle_grid(self, value: bool, dim: float = 10.0):
value : bool,
dim : float = 10.):
if value: if value:
self.show_grid(step=dim / 20, size=dim + 1e-9) self.show_grid(step=dim / 20, size=dim + 1e-9)
else: else:
@@ -316,48 +371,37 @@ class OCCViewer(QWidget,ComponentMixin):
@pyqtSlot(gp_Ax3) @pyqtSlot(gp_Ax3)
def set_grid_orientation(self, orientation: gp_Ax3): def set_grid_orientation(self, orientation: gp_Ax3):
viewer = self._get_viewer() viewer = self._get_viewer()
viewer.SetPrivilegedPlane(orientation) viewer.SetPrivilegedPlane(orientation)
def show_axis(self, origin=(0, 0, 0), direction=(0, 0, 1)): 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_placement = Geom_Axis1Placement(gp_Ax1(gp_Pnt(*origin),
gp_Dir(*direction)))
ax = AIS_Axis(ax_placement) ax = AIS_Axis(ax_placement)
self._display_ais(ax) self._display_ais(ax)
def save_screenshot(self): def save_screenshot(self):
fname = get_save_filename(self.IMAGE_EXTENSIONS) fname = get_save_filename(self.IMAGE_EXTENSIONS)
if fname != '': if fname != "":
self._get_view().Dump(fname) self._get_view().Dump(fname)
def _display_ais(self, ais): def _display_ais(self, ais):
self._get_context().Display(ais) self._get_context().Display(ais)
def _get_view(self): def _get_view(self):
return self.canvas.view return self.canvas.view
def _get_viewer(self): def _get_viewer(self):
return self.canvas.viewer return self.canvas.viewer
def _get_context(self): def _get_context(self):
return self.canvas.context return self.canvas.context
@pyqtSlot(list) @pyqtSlot(list)
def handle_selection(self, obj): def handle_selection(self, obj):
self.sigObjectSelected.emit(obj) self.sigObjectSelected.emit(obj)
@pyqtSlot(list) @pyqtSlot(list)
def set_selected(self, ais): def set_selected(self, ais):
ctx = self._get_context() ctx = self._get_context()
ctx.ClearSelected(False) ctx.ClearSelected(False)
@@ -368,7 +412,7 @@ class OCCViewer(QWidget,ComponentMixin):
if __name__ == "__main__": if __name__ == "__main__":
# pass
import sys import sys
from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox from OCP.BRepPrimAPI import BRepPrimAPI_MakeBox