def __free_move(self):
"""Menu of free move mode."""
free_move_mode_menu = QMenu(self)
def free_move_mode_func(j: int, icon_qt: QIcon):
@Slot()
def func() -> None:
self.free_move_button.setIcon(icon_qt)
self.main_canvas.set_free_move(j)
self.entities_tab.setCurrentIndex(0)
self.inputs_widget.variable_stop.click()
return func
for i, (text, icon, tip) in enumerate([
("View mode", "free_move_off", "Disable free move mode."),
("Translate mode", "translate", "Edit by 2 DOF moving."),
("Rotate mode", "rotate", "Edit by 1 DOF moving."),
("Reflect mode", "reflect", "Edit by flip axis."),
]):
action = QAction(QIcon(QPixmap(f":/icons/{icon}.png")), text, self)
action.triggered.connect(free_move_mode_func(i, action.icon()))
action.setShortcut(QKeySequence(f"Ctrl+{i + 1}"))
action.setShortcutContext(Qt.WindowShortcut)
action.setStatusTip(tip)
free_move_mode_menu.addAction(action)
if i == 0:
self.free_move_disable = action
self.free_move_button.setMenu(free_move_mode_menu)
# "Link adjust" function
self.link_free_move_confirm.clicked.connect(
self.main_canvas.emit_free_move_all)
def __zoom(self):
"""Zoom functions.
+ 'zoom to fit' function connections.
+ Zoom text buttons
"""
self.action_zoom_to_fit.triggered.connect(self.main_canvas.zoom_to_fit)
self.ResetCanvas.clicked.connect(self.main_canvas.zoom_to_fit)
zoom_menu = QMenu(self)
def zoom_level(value: int):
"""Return a function that set the specified zoom value."""
@Slot()
def func():
self.zoom_bar.setValue(value)
return func
for level in range(
self.zoom_bar.minimum() - self.zoom_bar.minimum() % 100 + 100,
500 + 1, 100):
action = QAction(f'{level}%', self)
action.triggered.connect(zoom_level(level))
zoom_menu.addAction(action)
action = QAction("customize", self)
action.triggered.connect(self.customize_zoom)
zoom_menu.addAction(action)
self.zoom_button.setMenu(zoom_menu)
def __free_move(self):
"""Menu of free move mode."""
free_move_mode_menu = QMenu(self)
def free_move_mode_func(j: int, icon_qt: QIcon):
@pyqtSlot()
def func():
self.free_move_button.setIcon(icon_qt)
self.MainCanvas.setFreeMove(j)
self.EntitiesTab.setCurrentIndex(0)
self.InputsWidget.variable_stop.click()
return func
for i, (text, icon, tip) in enumerate((
("View mode", "free_move_off", "Disable free move mode."),
("Translate mode", "translate", "Edit by 2 DOF moving."),
("Rotate mode", "rotate", "Edit by 1 DOF moving."),
("Reflect mode", "reflect", "Edit by flip axis."),
)):
action = QAction(QIcon(QPixmap(f":/icons/{icon}.png")), text, self)
action.triggered.connect(free_move_mode_func(i, action.icon()))
action.setShortcut(QKeySequence(f"Ctrl+{i + 1}"))
action.setShortcutContext(Qt.WindowShortcut)
action.setStatusTip(tip)
free_move_mode_menu.addAction(action)
if i == 0:
self.free_move_disable = action
self.free_move_button.setMenu(free_move_mode_menu)
# Link free move by expression table.
self.link_free_move_slider.sliderReleased.connect(
self.MainCanvas.emit_free_move_all)
class MainWindow(QMainWindow, Ui_MainWindow):
"""Main window of the program."""
def __init__(self):
super(MainWindow, self).__init__()
self.setupUi(self)
self.nc_editor = NCEditor(self)
self.nc_code_layout.addWidget(self.nc_editor)
h_size = 15
self.parameter_table = MathTableWidget([
r"$a$",
r"$b$",
r"$\zeta$",
r"$\omega_n$",
], h_size, self)
self.parameter_table.verticalHeader().hide()
self.parameter_table.setRowCount(1)
self.parameter_table.setFixedHeight(h_size * 4)
self.parameter_table.setHorizontalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
self.parameter_table.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
for i, v in enumerate([1., 20., 0.707, 1000.]):
self.parameter_table.setCellWidget(0, i, _spinbox(v))
self.nc_code_layout.insertWidget(1, self.parameter_table)
self.env = ""
self.file_name = ""
self.set_locate(QStandardPaths.writableLocation(QStandardPaths.DesktopLocation))
# Default RE compiler.
self.re_compiler.setPlaceholderText(DEFAULT_NC_SYNTAX)
# Chart widgets.
self.charts = [QChart() for _ in range(8)]
for chart, layout in zip(self.charts, [self.s_layout, self.v_layout, self.a_layout, self.j_layout] * 2):
chart.setTheme(QChart.ChartThemeLight)
view = QChartView(chart)
view.setContextMenuPolicy(Qt.CustomContextMenu)
view.customContextMenuRequested.connect(self.__save_chart_func(view))
view.setRenderHint(QPainter.Antialiasing)
layout.addWidget(view)
# Chart menu
self.chart_menu = QMenu(self)
self.save_chart_action = QAction("Save as image", self)
self.chart_menu.addAction(self.save_chart_action)
self.copy_chart_action = QAction("Copy as pixmap", self)
self.chart_menu.addAction(self.copy_chart_action)
# Splitter
self.main_splitter.setSizes([300, 500])
def output_to(self, format_name: str, format_choose: Sequence[str]) -> str:
"""Simple to support multiple format."""
file_name, suffix = QFileDialog.getSaveFileName(
self,
f"Save to {format_name}...",
self.env + '/Untitled',
';;'.join(format_choose)
)
if file_name:
suffix = str_between(suffix, '(', ')').split('*')[-1]
print(f"Format: {suffix}")
if QFileInfo(file_name).completeSuffix() != suffix[1:]:
file_name += suffix
return file_name
def input_from(self, format_name: str, format_choose: Sequence[str]) -> str:
"""Get file name(s)."""
file_name_s, suffix = QFileDialog.getOpenFileName(
self,
f"Open {format_name} file...",
self.env,
';;'.join(format_choose)
)
if file_name_s:
suffix = str_between(suffix, '(', ')').split('*')[-1]
print(f"Format: {suffix}")
self.set_locate(QFileInfo(file_name_s).absolutePath())
self.set_file_name(file_name_s)
return file_name_s
def set_locate(self, locate: str):
"""Set environment variables."""
if locate == self.env:
# If no changed.
return
self.env = locate
print(f"~Set workplace to: [\"{self.env}\"]")
def set_file_name(self, new_name: str):
"""Set default file name."""
self.file_name = new_name
def dragEnterEvent(self, event):
"""Drag file in to our window."""
mime_data = event.mimeData()
if not mime_data.hasUrls():
return
for url in mime_data.urls():
suffix = QFileInfo(url.toLocalFile()).completeSuffix()
if suffix in {'nc', 'g'}:
event.acceptProposedAction()
def dropEvent(self, event):
"""Drop file in to our window."""
file_name = event.mimeData().urls()[-1].toLocalFile()
self.__load_nc_code(file_name)
event.acceptProposedAction()
@pyqtSlot(name='on_nc_load_button_clicked')
def __load_nc_code(self, file_name: str = ""):
if not file_name:
file_name = self.input_from("NC code", [
"Numerical Control programming language (*.nc)",
"Preparatory code (*.g)",
])
if not file_name:
return
self.nc_file_path.setText(file_name)
with open(file_name, 'r', encoding='utf-8') as f:
self.nc_editor.setText(f.read())
@pyqtSlot(name='on_nc_save_button_clicked')
def __save_nc_code(self):
"""Save current NC code."""
if self.nc_file_path.text() != self.file_name or not self.file_name:
file_name = self.output_to("NC code", [
"Numerical control programming language (*.nc)",
"Preparatory code (*.g)",
])
if not file_name:
return
self.file_name = file_name
with open(self.file_name, 'w', encoding='utf-8') as f:
f.write(self.nc_editor.text())
def __save_chart_func(self, chart: QChartView) -> Callable[[QPoint], None]:
"""Save chart context menu."""
@pyqtSlot(QPoint)
def save_chart(pos: QPoint):
self.chart_menu.popup(chart.mapToGlobal(pos))
action = self.chart_menu.exec()
if action not in {self.save_chart_action, self.copy_chart_action}:
return
pixmap: QPixmap = chart.grab()
if action == self.copy_chart_action:
QApplication.clipboard().setPixmap(pixmap)
return
file_name = self.output_to("Image", qt_image_format)
if not file_name:
return
pixmap.save(file_name)
return save_chart
@pyqtSlot(name='on_nc_compile_clicked')
def __nc_compile(self):
"""Compile NC code."""
self.__clear_charts()
lines = []
for name in [
"Position",
"Velocity",
"Accelerate",
"Jerk",
"Original Position",
"Velocity of X",
"Velocity of Y",
"Accelerate of X",
"Accelerate of Y",
"Jerk of X",
"Jerk of Y",
"Simulated Position",
]:
line = QLineSeries()
line.setName(name)
lines.append(line)
syntax = self.re_compiler.text() or self.re_compiler.placeholderText()
if self.trapezoid_option.isChecked():
strategy = Trapezoid
else:
strategy = SShape
i = 0.
sx_plot = []
sy_plot = []
ts = None
for tp in graph_chart(self.nc_editor.text(), syntax, strategy):
for s, v, a, j, (sx, sy), (vx, vy), (ax, ay), (jx, jy) in tp.iter(
tp.s,
tp.v,
tp.a,
tp.j,
tp.s_xy,
tp.v_xy,
tp.a_xy,
tp.j_xy,
):
lines[0].append(i, s)
lines[1].append(i, v)
lines[2].append(i, a)
lines[3].append(i, j)
lines[4].append(sx, sy)
lines[5].append(i, vx)
lines[6].append(i, vy)
lines[7].append(i, ax)
lines[8].append(i, ay)
lines[9].append(i, jx)
lines[10].append(i, jy)
sx_plot.append(sx)
sy_plot.append(sy)
i += tp.t_s
if ts is None:
ts = tp.t_s
for ssx, ssy in zip(*self.__simulation_output(sx_plot, sy_plot, ts or 1e-3)):
lines[-1].append(ssx, ssy)
for line, chart in zip(lines, [
self.charts[0],
self.charts[1],
self.charts[2],
self.charts[3],
self.charts[4],
self.charts[5],
self.charts[5],
self.charts[6],
self.charts[6],
self.charts[7],
self.charts[7],
self.charts[4],
]):
chart.addSeries(line)
self.__reset_axis()
def __simulation_output(self, sx_plot, sy_plot, t_s):
parameter = []
for c in range(self.parameter_table.columnCount()):
parameter.append(self.parameter_table.cellWidget(0, c).value())
num, den = model_system(*parameter)
_, xout = control_num_den(num, den, t_s, sx_plot)
_, yout = control_num_den(num, den, t_s, sy_plot)
return xout, yout
def __clear_charts(self):
"""Clear all charts."""
for chart in self.charts:
chart.removeAllSeries()
for axis in chart.axes():
chart.removeAxis(axis)
def __reset_axis(self):
"""Reset all axis of charts."""
units = [" (mm)", " (mm/s)", " (mm/s^2)", " (mm/s^3)"]
vaj = ["Velocity", "Accelerate", "Jerk"]
for chart, x_axis, y_axis in zip(
self.charts,
["Time (s)"] * 4 + ["X (mm)"] + ["Time (s)"] * 3,
map(lambda y, u: y + u, ["Position"] + vaj + ["Y"] + vaj, units * 2),
):
chart.createDefaultAxes()
chart.axisX().setTitleText(x_axis)
chart.axisY().setTitleText(y_axis)
class MainWindow(QMainWindow, Ui_MainWindow):
"""Main window of kmol editor."""
def __init__(self):
super(MainWindow, self).__init__(None)
self.setupUi(self)
# Start new window.
@pyqtSlot()
def new_main_window():
XStream.back()
run = self.__class__()
run.show()
self.action_New_Window.triggered.connect(new_main_window)
# Text editor
self.text_editor = TextEditor(self)
self.h_splitter.addWidget(self.text_editor)
self.text_editor.word_changed.connect(self.__set_not_saved_title)
self.edge_line_option.toggled.connect(self.text_editor.setEdgeMode)
self.trailing_blanks_option.toggled.connect(self.text_editor.set_remove_trailing_blanks)
# Highlighters
self.highlighter_option.addItems(sorted(QSCIHIGHLIGHTERS))
self.highlighter_option.setCurrentText("Markdown")
self.highlighter_option.currentTextChanged.connect(
self.text_editor.set_highlighter
)
# Tree widget context menu.
self.tree_widget.customContextMenuRequested.connect(
self.on_tree_widget_context_menu
)
self.popMenu_tree = QMenu(self)
self.popMenu_tree.setSeparatorsCollapsible(True)
self.popMenu_tree.addAction(self.action_new_project)
self.popMenu_tree.addAction(self.action_open)
self.tree_add = QAction("&Add Node", self)
self.tree_add.triggered.connect(self.add_node)
self.tree_add.setShortcut("Ctrl+I")
self.tree_add.setShortcutContext(Qt.WindowShortcut)
self.popMenu_tree.addAction(self.tree_add)
self.popMenu_tree.addSeparator()
self.tree_path = QAction("Set Path", self)
self.tree_path.triggered.connect(self.set_path)
self.popMenu_tree.addAction(self.tree_path)
self.tree_refresh = QAction("&Refresh from Path", self)
self.tree_refresh.triggered.connect(self.refresh_proj)
self.popMenu_tree.addAction(self.tree_refresh)
self.tree_openurl = QAction("&Open from Path", self)
self.tree_openurl.triggered.connect(self.open_path)
self.popMenu_tree.addAction(self.tree_openurl)
self.action_save.triggered.connect(self.save_proj)
self.popMenu_tree.addAction(self.action_save)
self.tree_copy = QAction("Co&py", self)
self.tree_copy.triggered.connect(self.copy_node)
self.popMenu_tree.addAction(self.tree_copy)
self.tree_clone = QAction("C&lone", self)
self.tree_clone.triggered.connect(self.clone_node)
self.popMenu_tree.addAction(self.tree_clone)
self.tree_copy_tree = QAction("Recursive Copy", self)
self.tree_copy_tree.triggered.connect(self.copy_node_recursive)
self.popMenu_tree.addAction(self.tree_copy_tree)
self.tree_clone_tree = QAction("Recursive Clone", self)
self.tree_clone_tree.triggered.connect(self.clone_node_recursive)
self.popMenu_tree.addAction(self.tree_clone_tree)
self.popMenu_tree.addSeparator()
self.tree_delete = QAction("&Delete", self)
self.tree_delete.triggered.connect(self.delete_node)
self.popMenu_tree.addAction(self.tree_delete)
self.tree_close = QAction("&Close", self)
self.tree_close.triggered.connect(self.close_file)
self.popMenu_tree.addAction(self.tree_close)
self.tree_main.header().setSectionResizeMode(QHeaderView.ResizeToContents)
# Console
self.console.setFont(self.text_editor.font)
if not ARGUMENTS.debug_mode:
XStream.stdout().messageWritten.connect(self.__append_to_console)
XStream.stderr().messageWritten.connect(self.__append_to_console)
for info in INFO:
print(info)
print('-' * 7)
# Searching function.
find_next = QShortcut(QKeySequence("F3"), self)
find_next.activated.connect(self.find_next_button.click)
find_previous = QShortcut(QKeySequence("F4"), self)
find_previous.activated.connect(self.find_previous_button.click)
find_tab = QShortcut(QKeySequence("Ctrl+F"), self)
find_tab.activated.connect(lambda: self.panel_widget.setCurrentIndex(1))
find_project = QShortcut(QKeySequence("Ctrl+Shift+F"), self)
find_project.activated.connect(self.find_project_button.click)
# Replacing function.
replace = QShortcut(QKeySequence("Ctrl+R"), self)
replace.activated.connect(self.replace_node_button.click)
replace_project = QShortcut(QKeySequence("Ctrl+Shift+R"), self)
replace_project.activated.connect(self.replace_project_button.click)
# Translator.
self.panel_widget.addTab(TranslatorWidget(self), "Translator")
# Node edit function. (Ctrl + ArrowKey)
move_up_node = QShortcut(QKeySequence("Ctrl+Up"), self)
move_up_node.activated.connect(self.__move_up_node)
move_down_node = QShortcut(QKeySequence("Ctrl+Down"), self)
move_down_node.activated.connect(self.__move_down_node)
move_right_node = QShortcut(QKeySequence("Ctrl+Right"), self)
move_right_node.activated.connect(self.__move_right_node)
move_left_node = QShortcut(QKeySequence("Ctrl+Left"), self)
move_left_node.activated.connect(self.__move_left_node)
# Run script button.
run_sript = QShortcut(QKeySequence("F5"), self)
run_sript.activated.connect(self.exec_button.click)
self.macros_toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
# Splitter
self.h_splitter.setStretchFactor(0, 10)
self.h_splitter.setStretchFactor(1, 60)
self.v_splitter.setStretchFactor(0, 30)
self.v_splitter.setStretchFactor(1, 10)
# Data
self.data = DataDict()
self.data.not_saved.connect(self.__set_not_saved_title)
self.data.all_saved.connect(self.__set_saved_title)
self.env = QStandardPaths.writableLocation(QStandardPaths.DesktopLocation)
for filename in ARGUMENTS.r:
filename = QFileInfo(filename).canonicalFilePath()
if not filename:
return
root_node = QTreeRoot(QFileInfo(filename).baseName(), filename, '')
self.tree_main.addTopLevelItem(root_node)
parse(root_node, self.data)
self.__add_macros()
def dragEnterEvent(self, event):
"""Drag file in to our window."""
if event.mimeData().hasUrls():
event.acceptProposedAction()
def dropEvent(self, event):
"""Drop file in to our window."""
for url in event.mimeData().urls():
filename = url.toLocalFile()
root_node = QTreeRoot(QFileInfo(filename).baseName(), filename, '')
self.tree_main.addTopLevelItem(root_node)
parse(root_node, self.data)
self.tree_main.setCurrentItem(root_node)
self.__add_macros()
event.acceptProposedAction()
@pyqtSlot()
def __set_not_saved_title(self):
"""Show star sign on window title."""
if '*' not in self.windowTitle():
self.setWindowTitle(self.windowTitle() + '*')
@pyqtSlot()
def __set_saved_title(self):
"""Remove star sign on window title."""
self.setWindowTitle(self.windowTitle().replace('*', ''))
@pyqtSlot(str)
def __append_to_console(self, log):
"""After inserted the text, move cursor to end."""
self.console.moveCursor(QTextCursor.End)
self.console.insertPlainText(log)
self.console.moveCursor(QTextCursor.End)
@pyqtSlot(QPoint, name='on_tree_widget_context_menu')
def __tree_context_menu(self, point: QPoint):
"""Operations."""
self.__action_changed()
self.popMenu_tree.exec_(self.tree_widget.mapToGlobal(point))
@pyqtSlot(name='on_action_new_project_triggered')
def new_proj(self):
"""New file."""
filename, _ = QFileDialog.getSaveFileName(
self,
"New Project",
self.env,
SUPPORT_FILE_FORMATS
)
if not filename:
return
self.env = QFileInfo(filename).absolutePath()
root_node = QTreeRoot(
QFileInfo(filename).baseName(),
filename,
str(self.data.new_num())
)
suffix_text = file_suffix(filename)
if suffix_text == 'md':
root_node.setIcon(0, file_icon("markdown"))
elif suffix_text == 'html':
root_node.setIcon(0, file_icon("html"))
elif suffix_text == 'kmol':
root_node.setIcon(0, file_icon("kmol"))
else:
root_node.setIcon(0, file_icon("txt"))
self.tree_main.addTopLevelItem(root_node)
@pyqtSlot(name='on_action_open_triggered')
def open_proj(self):
"""Open file."""
file_names, ok = QFileDialog.getOpenFileNames(
self,
"Open Projects",
self.env,
SUPPORT_FILE_FORMATS
)
if not ok:
return
def in_widget(path: str) -> int:
"""Is name in tree widget."""
for i in range(self.tree_main.topLevelItemCount()):
if path == self.tree_main.topLevelItem(i).text(1):
return i
return -1
for file_name in file_names:
self.env = QFileInfo(file_name).absolutePath()
index = in_widget(file_name)
if index == -1:
root_node = QTreeRoot(QFileInfo(file_name).baseName(), file_name, '')
self.tree_main.addTopLevelItem(root_node)
parse(root_node, self.data)
self.tree_main.setCurrentItem(root_node)
else:
self.tree_main.setCurrentItem(self.tree_main.topLevelItem(index))
self.__add_macros()
@pyqtSlot()
def refresh_proj(self):
"""Re-parse the file node."""
node = self.tree_main.currentItem()
if not node.text(1):
QMessageBox.warning(
self,
"No path",
"Can only refresh from valid path."
)
parse(node, self.data)
self.tree_main.setCurrentItem(node)
self.text_editor.setText(self.data[int(node.text(2))])
@pyqtSlot()
def open_path(self):
"""Open path of current node."""
node = self.tree_main.currentItem()
filename = getpath(node)
QDesktopServices.openUrl(QUrl(filename))
print("Open: {}".format(filename))
@pyqtSlot()
def add_node(self):
"""Add a node at current item."""
node = self.tree_main.currentItem()
new_node = QTreeItem(
"New node",
"",
str(self.data.new_num())
)
if node.childCount() or node.text(1):
node.addChild(new_node)
return
parent = node.parent()
if parent:
parent.insertChild(parent.indexOfChild(node) + 1, new_node)
return
self.tree_main.indexOfTopLevelItem(
self.tree_main.indexOfTopLevelItem(node) + 1,
new_node
)
@pyqtSlot()
def set_path(self):
"""Set file directory."""
node = self.tree_main.currentItem()
filename, ok = QFileDialog.getOpenFileName(
self,
"Open File",
self.env,
SUPPORT_FILE_FORMATS
)
if not ok:
return
self.env = QFileInfo(filename).absolutePath()
project_path = QDir(_get_root(node).text(1))
project_path.cdUp()
node.setText(1, project_path.relativeFilePath(filename))
@pyqtSlot()
def copy_node(self):
"""Copy current node."""
node_origin = self.tree_main.currentItem()
parent = node_origin.parent()
node = node_origin.clone()
node.takeChildren()
code = self.data.new_num()
self.data[code] = self.data[int(node.text(2))]
node.setText(2, str(code))
parent.insertChild(parent.indexOfChild(node_origin) + 1, node)
@pyqtSlot()
def clone_node(self):
"""Copy current node with same pointer."""
node_origin = self.tree_main.currentItem()
parent = node_origin.parent()
node = node_origin.clone()
node.takeChildren()
parent.insertChild(parent.indexOfChild(node_origin) + 1, node)
@pyqtSlot()
def copy_node_recursive(self):
"""Copy current node and its sub-nodes."""
node_origin = self.tree_main.currentItem()
parent = node_origin.parent()
node_origin_copy = node_origin.clone()
def new_pointer(node: QTreeWidgetItem):
"""Give a new pointer code for node."""
code = self.data.new_num()
self.data[code] = self.data[int(node.text(2))]
node.setText(2, str(code))
for i in range(node.childCount()):
new_pointer(node.child(i))
new_pointer(node_origin_copy)
parent.insertChild(parent.indexOfChild(node_origin) + 1, node_origin_copy)
@pyqtSlot()
def clone_node_recursive(self):
"""Copy current node and its sub-nodes with same pointer."""
node_origin = self.tree_main.currentItem()
parent = node_origin.parent()
parent.insertChild(parent.indexOfChild(node_origin) + 1, node_origin.clone())
@pyqtSlot()
def save_proj(self, index: Optional[int] = None, *, for_all: bool = False):
"""Save project and files."""
if for_all:
for row in range(self.tree_main.topLevelItemCount()):
self.save_proj(row)
return
node = self.tree_main.currentItem()
if not node:
return
if index is None:
root = _get_root(node)
else:
root = self.tree_main.topLevelItem(index)
self.__save_current()
save_file(root, self.data)
self.data.save_all()
def __save_current(self):
"""Save the current text of editor."""
self.text_editor.remove_trailing_blanks()
item = self.tree_main.currentItem()
if item:
self.data[int(item.text(2))] = self.text_editor.text()
@pyqtSlot()
def delete_node(self):
"""Delete the current item."""
node = self.tree_main.currentItem()
parent = node.parent()
self.tree_main.setCurrentItem(parent)
self.__delete_node_data(node)
parent.removeChild(node)
def __delete_node_data(self, node: QTreeWidgetItem):
"""Delete data from data structure."""
name = node.text(0)
if name.startswith('@'):
for action in self.macros_toolbar.actions():
if action.text() == name[1:]:
self.macros_toolbar.removeAction(action)
del self.data[int(node.text(2))]
for i in range(node.childCount()):
self.__delete_node_data(node.child(i))
@pyqtSlot()
def close_file(self):
"""Close project node."""
if not self.data.is_all_saved():
reply = QMessageBox.question(
self,
"Not saved",
"Do you went to save the project?",
QMessageBox.Save | QMessageBox.Discard | QMessageBox.Cancel,
QMessageBox.Save
)
if reply == QMessageBox.Save:
self.save_proj()
elif reply == QMessageBox.Cancel:
return
root = self.tree_main.currentItem()
self.__delete_node_data(root)
self.tree_main.takeTopLevelItem(self.tree_main.indexOfTopLevelItem(root))
self.text_editor.clear()
@pyqtSlot()
def __move_up_node(self):
"""Move up current node."""
node = self.tree_main.currentItem()
if not node:
return
tree_main = node.treeWidget()
parent = node.parent()
if parent:
# Is sub-node.
index = parent.indexOfChild(node)
if index == 0:
return
parent.removeChild(node)
parent.insertChild(index - 1, node)
else:
# Is root.
index = tree_main.indexOfTopLevelItem(node)
if index == 0:
return
tree_main.takeTopLevelItem(index)
tree_main.insertTopLevelItem(index - 1, node)
tree_main.setCurrentItem(node)
self.__root_unsaved()
@pyqtSlot()
def __move_down_node(self):
"""Move down current node."""
node = self.tree_main.currentItem()
if not node:
return
tree_main = node.treeWidget()
parent = node.parent()
if parent:
# Is sub-node.
index = parent.indexOfChild(node)
if index == parent.childCount() - 1:
return
parent.removeChild(node)
parent.insertChild(index + 1, node)
else:
# Is root.
index = tree_main.indexOfTopLevelItem(node)
if index == tree_main.topLevelItemCount() - 1:
return
tree_main.takeTopLevelItem(index)
tree_main.insertTopLevelItem(index + 1, node)
tree_main.setCurrentItem(node)
self.__root_unsaved()
@pyqtSlot()
def __move_right_node(self):
"""Move right current node."""
node = self.tree_main.currentItem()
if not node:
return
tree_main = node.treeWidget()
parent = node.parent()
if parent:
# Is sub-node.
index = parent.indexOfChild(node)
if index == 0:
return
parent.removeChild(node)
parent.child(index - 1).addChild(node)
else:
# Is root.
index = tree_main.indexOfTopLevelItem(node)
if index == 0:
return
tree_main.takeTopLevelItem(index)
tree_main.topLevelItem(index - 1).addChild(node)
tree_main.setCurrentItem(node)
self.__root_unsaved()
@pyqtSlot()
def __move_left_node(self):
"""Move left current node."""
node = self.tree_main.currentItem()
if not node:
return
tree_main = node.treeWidget()
parent = node.parent()
if not parent:
return
# Must be a sub-node.
grand_parent = parent.parent()
if not grand_parent:
return
index = grand_parent.indexOfChild(parent)
parent.removeChild(node)
grand_parent.insertChild(index + 1, node)
tree_main.setCurrentItem(node)
self.__root_unsaved()
@pyqtSlot(name='on_action_about_qt_triggered')
def __about_qt(self):
"""Qt about."""
QMessageBox.aboutQt(self)
@pyqtSlot(name='on_action_about_triggered')
def __about(self):
"""Kmol editor about."""
QMessageBox.about(self, "About Kmol Editor", '\n'.join(INFO + (
'',
"Author: " + __author__,
"Email: " + __email__,
__copyright__,
"License: " + __license__,
)))
@pyqtSlot(name='on_action_mde_tw_triggered')
def __mde_tw(self):
"""Mde website."""
QDesktopServices.openUrl(QUrl("http://mde.tw"))
@pyqtSlot(name='on_exec_button_clicked')
def __exec(self):
"""Run the script from current text editor."""
self.__exec_script(self.text_editor.text())
def __exec_script(self, code: Union[int, str]):
"""Run a script in a new thread."""
self.__save_current()
variables = {
# Qt file operation classes.
'QStandardPaths': QStandardPaths,
'QFileInfo': QFileInfo,
'QDir': QDir,
}
node = self.tree_main.currentItem()
variables['node'] = node
if node:
root = _get_root(node)
variables['root'] = root
variables['root_path'] = QFileInfo(root.text(1)).absoluteFilePath()
variables['node_path'] = getpath(node)
def chdir_tree(path: str):
if QFileInfo(path).isDir():
chdir(path)
elif QFileInfo(path).isFile():
chdir(QFileInfo(path).absolutePath())
variables['chdir'] = chdir_tree
thread = Thread(
target=exec,
args=(self.data[code] if type(code) == int else code, variables)
)
thread.start()
@pyqtSlot(QTreeWidgetItem, QTreeWidgetItem, name='on_tree_main_currentItemChanged')
def __switch_data(
self,
current: QTreeWidgetItem,
previous: QTreeWidgetItem
):
"""Switch node function.
+ Auto collapse and expand function.
+ Important: Store the string data.
"""
if self.auto_expand_option.isChecked():
self.tree_main.expandItem(current)
self.tree_main.scrollToItem(current)
if previous:
self.data[int(previous.text(2))] = self.text_editor.text()
if current:
# Auto highlight.
path = current.text(1)
filename = QFileInfo(path).fileName()
suffix = QFileInfo(filename).suffix()
if current.text(0).startswith('@'):
self.highlighter_option.setCurrentText("Python")
else:
self.highlighter_option.setCurrentText("Markdown")
if path:
for name_m, suffix_m in HIGHLIGHTER_SUFFIX.items():
if suffix in suffix_m:
self.highlighter_option.setCurrentText(name_m)
break
else:
for name_m, filename_m in HIGHLIGHTER_FILENAME.items():
if filename in filename_m:
self.highlighter_option.setCurrentText(name_m)
break
self.text_editor.setText(self.data[int(current.text(2))])
self.__action_changed()
@pyqtSlot(QTreeWidgetItem, int, name='on_tree_main_itemChanged')
def __reload_nodes(self, node: QTreeWidgetItem, _: int):
"""Mark edited node as unsaved."""
name = node.text(0)
code = int(node.text(2))
if name.startswith('@'):
self.__add_macro(name[1:], code)
self.__root_unsaved()
def __root_unsaved(self):
"""Let tree to re-save."""
node = self.tree_main.currentItem()
if node:
self.data.set_saved(int(_get_root(node).text(2)), False)
def __action_changed(self):
node = self.tree_main.currentItem()
has_item = bool(node)
is_root = (not node.parent()) if has_item else False
for action in (
self.action_open,
self.action_new_project,
):
action.setVisible(is_root or not has_item)
self.tree_close.setVisible(has_item and is_root)
for action in (
self.tree_add,
self.tree_refresh,
self.tree_openurl,
self.action_save,
):
action.setVisible(has_item)
for action in (
self.tree_copy,
self.tree_clone,
self.tree_copy_tree,
self.tree_clone_tree,
self.tree_path,
self.tree_delete,
):
action.setVisible(has_item and not is_root)
def __add_macros(self):
"""Add macro buttons from data structure."""
for name, code in self.data.macros():
self.__add_macro(name, code)
def __add_macro(self, name: str, code: Union[int, Hashable]):
"""Add macro button."""
for action in self.macros_toolbar.actions():
if action.text() == name:
break
else:
action = self.macros_toolbar.addAction(QIcon(QPixmap(":icons/python.png")), name)
action.triggered.connect(lambda: self.__exec_script(code))
def __find_text(self, forward: bool):
"""Find text by options."""
if not self.search_bar.text():
self.search_bar.setText(self.search_bar.placeholderText())
pos = self.text_editor.positionFromLineIndex(
*self.text_editor.getCursorPosition()
)
if not self.text_editor.findFirst(
self.search_bar.text(),
self.re_option.isChecked(),
self.match_case_option.isChecked(),
self.whole_word_option.isChecked(),
self.wrap_around.isChecked(),
forward,
*self.text_editor.lineIndexFromPosition(pos if forward else pos - 1)
):
QMessageBox.information(
self,
"Text not found.",
"\"{}\" is not in current document".format(
self.search_bar.text()
)
)
@pyqtSlot(name='on_find_next_button_clicked')
def __find_next(self):
"""Find to next."""
self.__find_text(True)
@pyqtSlot(name='on_find_previous_button_clicked')
def __find_previous(self):
"""Find to previous."""
self.__find_text(False)
@pyqtSlot(name='on_replace_node_button_clicked')
def __replace(self):
"""Replace current text by replace bar."""
self.text_editor.replace(self.replace_bar.text())
self.text_editor.findNext()
@pyqtSlot(name='on_find_project_button_clicked')
def __find_project(self):
"""Find in all project."""
self.find_list.clear()
node_current = self.tree_main.currentItem()
if not node_current:
return
root = _get_root(node_current)
if not self.search_bar.text():
self.search_bar.setText(self.search_bar.placeholderText())
text = self.search_bar.text()
flags = re.MULTILINE
if not self.re_option.isChecked():
text = re.escape(text)
if self.whole_word_option.isChecked():
text = r'\b' + text + r'\b'
if not self.match_case_option.isChecked():
flags |= re.IGNORECASE
def add_find_result(code: int, last_name: str, start: int, end: int):
"""Add result to list."""
item = QListWidgetItem("{}: [{}, {}]".format(code, start, end))
item.setToolTip(last_name)
self.find_list.addItem(item)
def find_in_nodes(node: QTreeWidgetItem, last_name: str = ''):
"""Find the word in all nodes."""
last_name += node.text(0)
if node.childCount():
last_name += '->'
code = int(node.text(2))
doc = self.data[code]
pattern = re.compile(text, flags)
for m in pattern.finditer(doc):
add_find_result(code, last_name, *m.span())
for i in range(node.childCount()):
find_in_nodes(node.child(i), last_name)
find_in_nodes(root)
@pyqtSlot(
QListWidgetItem,
QListWidgetItem,
name='on_find_list_currentItemChanged')
def __find_results(self, *_: QListWidgetItem):
"""TODO: Switch to target node."""
class MainWindowBase(QMainWindow, Ui_MainWindow, metaclass=QABCMeta):
"""External UI settings."""
@abstractmethod
def __init__(self):
super(MainWindowBase, self).__init__()
self.setupUi(self)
self.setAttribute(Qt.WA_DeleteOnClose)
# Initialize custom UI
self.__undo_redo()
self.__appearance()
self.__free_move()
self.__options()
self.__zoom()
self.__point_context_menu()
self.__link_context_menu()
self.__canvas_context_menu()
# Environment path
self.env = ""
if ARGUMENTS.c:
self.set_locate(QFileInfo(ARGUMENTS.c).canonicalFilePath())
else:
desktop = QStandardPaths.writableLocation(
QStandardPaths.DesktopLocation)
self.set_locate(self.settings.value("ENV", desktop, type=str))
def show(self):
"""Overridden function to zoom the canvas's size after startup."""
super(MainWindowBase, self).show()
self.main_canvas.zoom_to_fit()
def set_locate(self, locate: str):
"""Set environment variables."""
if locate == self.env:
# If no changed.
return
self.env = locate
logger.debug(f"~Set workplace to: [\"{self.env}\"]")
def __undo_redo(self):
"""Undo list settings.
+ Undo stack.
+ Undo view widget.
+ Hot keys.
"""
self.command_stack = QUndoStack(self)
self.command_stack.setUndoLimit(self.undo_limit_option.value())
self.undo_limit_option.valueChanged.connect(
self.command_stack.setUndoLimit)
self.command_stack.indexChanged.connect(self.command_reload)
self.undo_view = QUndoView(self.command_stack)
self.undo_view.setEmptyLabel("~ Start Pyslvs")
self.undo_redo_layout.addWidget(self.undo_view)
self.action_redo = self.command_stack.createRedoAction(self, "Redo")
self.action_undo = self.command_stack.createUndoAction(self, "Undo")
self.action_redo.setShortcuts([
QKeySequence("Ctrl+Shift+Z"),
QKeySequence("Ctrl+Y"),
])
self.action_redo.setStatusTip("Backtracking undo action.")
self.action_redo.setIcon(QIcon(QPixmap(":/icons/redo.png")))
self.action_undo.setShortcut("Ctrl+Z")
self.action_undo.setStatusTip("Recover last action.")
self.action_undo.setIcon(QIcon(QPixmap(":/icons/undo.png")))
self.menu_edit.addAction(self.action_undo)
self.menu_edit.addAction(self.action_redo)
def __appearance(self):
"""Start up and initialize custom widgets."""
# Version label
self.version_label.setText(__version__)
# Entities tables
self.entities_tab.tabBar().setStatusTip(
"Switch the tabs to change to another view mode.")
self.entities_point = PointTableWidget(self.entities_point_widget)
self.entities_point.cellDoubleClicked.connect(self.edit_point)
self.entities_point.delete_request.connect(self.delete_selected_points)
self.entities_point_layout.addWidget(self.entities_point)
self.entities_link = LinkTableWidget(self.entities_link_widget)
self.entities_link.cellDoubleClicked.connect(self.edit_link)
self.entities_link.delete_request.connect(self.delete_selected_links)
self.entities_link_layout.addWidget(self.entities_link)
self.entities_expr = ExprTableWidget(self.EntitiesExpr_widget)
self.entities_expr_layout.insertWidget(0, self.entities_expr)
# Select all button on the Point and Link tab as corner widget.
select_all_button = QPushButton()
select_all_button.setIcon(QIcon(QPixmap(":/icons/select_all.png")))
select_all_button.setToolTip("Select all")
select_all_button.setStatusTip("Select all item of point table.")
@Slot()
def table_select_all():
"""Distinguish table by tab index."""
tables: List[BaseTableWidget] = [
self.entities_point,
self.entities_link,
self.entities_expr,
]
tables[self.entities_tab.currentIndex()].selectAll()
select_all_button.clicked.connect(table_select_all)
self.entities_tab.setCornerWidget(select_all_button)
select_all_action = QAction("Select all point", self)
select_all_action.triggered.connect(table_select_all)
select_all_action.setShortcut("Ctrl+A")
select_all_action.setShortcutContext(Qt.WindowShortcut)
self.addAction(select_all_action)
# QPainter canvas window
self.main_canvas = DynamicCanvas(self)
select_tips = QLabel(self, Qt.ToolTip)
self.entities_tab.currentChanged.connect(
self.main_canvas.set_selection_mode)
@Slot(QPoint, str)
def show_select_tips(pos: QPoint, text: str):
select_tips.setText(text)
select_tips.move(pos - QPoint(0, select_tips.height()))
select_tips.show()
self.main_canvas.selected_tips.connect(show_select_tips)
self.main_canvas.selected_tips_hide.connect(select_tips.hide)
@Slot(tuple, bool)
def table_set_selection(selections: Sequence[int], key_detect: bool):
"""Distinguish table by tab index."""
tables: List[BaseTableWidget] = [
self.entities_point,
self.entities_link,
self.entities_expr,
]
tables[self.entities_tab.currentIndex()].set_selections(
selections, key_detect)
self.main_canvas.selected.connect(table_set_selection)
self.entities_point.row_selection_changed.connect(
self.main_canvas.set_selection)
@Slot()
def table_clear_selection():
"""Distinguish table by tab index."""
tables: List[BaseTableWidget] = [
self.entities_point,
self.entities_link,
self.entities_expr,
]
tables[self.entities_tab.currentIndex()].clearSelection()
self.main_canvas.noselected.connect(table_clear_selection)
clean_selection_action = QAction("Clean selection", self)
clean_selection_action.triggered.connect(table_clear_selection)
clean_selection_action.setShortcut("Esc")
clean_selection_action.setShortcutContext(Qt.WindowShortcut)
self.addAction(clean_selection_action)
self.main_canvas.free_moved.connect(self.set_free_move)
self.main_canvas.alt_add.connect(self.q_add_normal_point)
self.main_canvas.doubleclick_edit.connect(self.edit_point)
self.main_canvas.zoom_changed.connect(self.zoom_bar.setValue)
self.main_canvas.tracking.connect(self.set_mouse_pos)
self.canvas_splitter.insertWidget(0, self.main_canvas)
self.canvas_splitter.setSizes([600, 10, 30])
# Selection label on status bar right side
selection_label = SelectionLabel(self)
self.entities_point.selectionLabelUpdate.connect(
selection_label.update_select_point)
self.main_canvas.browse_tracking.connect(
selection_label.update_mouse_position)
self.status_bar.addPermanentWidget(selection_label)
# FPS label on status bar right side
fps_label = FPSLabel(self)
self.main_canvas.fps_updated.connect(fps_label.update_text)
self.status_bar.addPermanentWidget(fps_label)
# Inputs widget
self.inputs_widget = InputsWidget(self)
self.inputs_tab_layout.addWidget(self.inputs_widget)
self.free_move_button.toggled.connect(
self.inputs_widget.variable_value_reset)
self.inputs_widget.about_to_resolve.connect(self.resolve)
@Slot(tuple, bool)
def inputs_set_selection(selections: Sequence[int], _: bool):
"""Distinguish table by tab index."""
self.inputs_widget.clear_selection()
if self.entities_tab.currentIndex() == 0:
self.inputs_widget.set_selection(selections)
self.main_canvas.selected.connect(inputs_set_selection)
self.main_canvas.noselected.connect(self.inputs_widget.clear_selection)
self.inputs_widget.update_preview_button.clicked.connect(
self.main_canvas.update_preview_path)
# Number and type synthesis
self.structure_synthesis = StructureSynthesis(self)
self.synthesis_tab_widget.addTab(self.structure_synthesis,
self.structure_synthesis.windowIcon(),
"Structural")
# Synthesis collections
self.collection_tab_page = Collections(self)
self.synthesis_tab_widget.addTab(self.collection_tab_page,
self.collection_tab_page.windowIcon(),
"Collections")
self.structure_synthesis.addCollection = (
self.collection_tab_page.structure_widget.add_collection)
# Dimensional synthesis
self.dimensional_synthesis = DimensionalSynthesis(self)
self.main_canvas.set_target_point.connect(
self.dimensional_synthesis.set_point)
self.synthesis_tab_widget.addTab(
self.dimensional_synthesis,
self.dimensional_synthesis.windowIcon(), "Dimensional")
@Slot()
def set_design_progress():
"""Synthesis progress bar."""
pos = self.synthesis_tab_widget.currentIndex()
if pos == 1:
pos += self.collection_tab_page.tab_widget.currentIndex()
elif pos == 2:
pos += 1
self.synthesis_progress.setValue(pos)
self.synthesis_tab_widget.currentChanged.connect(set_design_progress)
self.collection_tab_page.tab_widget.currentChanged.connect(
set_design_progress)
# File widget settings
self.database_widget = DatabaseWidget(self)
self.vc_layout.addWidget(self.database_widget)
self.database_widget.commit_add.clicked.connect(self.commit)
self.database_widget.branch_add.clicked.connect(self.commit_branch)
self.action_stash.triggered.connect(self.database_widget.stash)
# YAML editor
self.yaml_editor = YamlEditor(self)
# Console dock will hide when startup
self.console_widget.hide()
# Connect to GUI button
self.console_disconnect_button.setEnabled(not ARGUMENTS.debug_mode)
self.console_connect_button.setEnabled(ARGUMENTS.debug_mode)
# Splitter stretch factor
self.main_splitter.setStretchFactor(0, 4)
self.main_splitter.setStretchFactor(1, 15)
self.mechanism_panel_splitter.setSizes([500, 200])
# Enable mechanism menu actions when shows.
self.menu_mechanism.aboutToShow.connect(self.enable_mechanism_actions)
@Slot()
def new_main_window():
"""Start a new window."""
run = self.__class__()
run.show()
self.action_new_window.triggered.connect(new_main_window)
def __free_move(self):
"""Menu of free move mode."""
free_move_mode_menu = QMenu(self)
def free_move_mode_func(j: int, icon_qt: QIcon):
@Slot()
def func() -> None:
self.free_move_button.setIcon(icon_qt)
self.main_canvas.set_free_move(j)
self.entities_tab.setCurrentIndex(0)
self.inputs_widget.variable_stop.click()
return func
for i, (text, icon, tip) in enumerate([
("View mode", "free_move_off", "Disable free move mode."),
("Translate mode", "translate", "Edit by 2 DOF moving."),
("Rotate mode", "rotate", "Edit by 1 DOF moving."),
("Reflect mode", "reflect", "Edit by flip axis."),
]):
action = QAction(QIcon(QPixmap(f":/icons/{icon}.png")), text, self)
action.triggered.connect(free_move_mode_func(i, action.icon()))
action.setShortcut(QKeySequence(f"Ctrl+{i + 1}"))
action.setShortcutContext(Qt.WindowShortcut)
action.setStatusTip(tip)
free_move_mode_menu.addAction(action)
if i == 0:
self.free_move_disable = action
self.free_move_button.setMenu(free_move_mode_menu)
# "Link adjust" function
self.link_free_move_confirm.clicked.connect(
self.main_canvas.emit_free_move_all)
def __options(self):
"""Signal connection for option widgets.
+ Spin boxes
+ Combo boxes
+ Check boxes
"""
# While value change, update the canvas widget.
self.settings = QSettings(
QStandardPaths.writableLocation(QStandardPaths.HomeLocation) +
'/.pyslvs.ini', QSettings.IniFormat, self)
self.zoom_bar.valueChanged.connect(self.main_canvas.set_zoom)
self.line_width_option.valueChanged.connect(
self.main_canvas.set_link_width)
self.path_width_option.valueChanged.connect(
self.main_canvas.set_path_width)
self.font_size_option.valueChanged.connect(
self.main_canvas.set_font_size)
self.action_show_point_mark.toggled.connect(
self.main_canvas.set_point_mark)
self.action_show_dimensions.toggled.connect(
self.main_canvas.set_show_dimension)
self.selection_radius_option.valueChanged.connect(
self.main_canvas.set_selection_radius)
self.link_trans_option.valueChanged.connect(
self.main_canvas.set_transparency)
self.margin_factor_option.valueChanged.connect(
self.main_canvas.set_margin_factor)
self.joint_size_option.valueChanged.connect(
self.main_canvas.set_joint_size)
self.zoom_by_option.currentIndexChanged.connect(
self.main_canvas.set_zoom_by)
self.snap_option.valueChanged.connect(self.main_canvas.set_snap)
self.background_option.textChanged.connect(
self.main_canvas.set_background)
self.background_opacity_option.valueChanged.connect(
self.main_canvas.set_background_opacity)
self.background_scale_option.valueChanged.connect(
self.main_canvas.set_background_scale)
self.background_offset_x_option.valueChanged.connect(
self.main_canvas.set_background_offset_x)
self.background_offset_y_option.valueChanged.connect(
self.main_canvas.set_background_offset_y)
self.monochrome_option.toggled.connect(
self.main_canvas.set_monochrome_mode)
self.monochrome_option.toggled.connect(
self.collection_tab_page.configure_widget.configure_canvas.
set_monochrome_mode)
self.monochrome_option.toggled.connect(
self.dimensional_synthesis.preview_canvas.set_monochrome_mode)
# Resolve after change current kernel.
self.planar_solver_option.addItems(kernel_list)
self.path_preview_option.addItems(kernel_list +
("Same as solver kernel", ))
self.planar_solver_option.currentIndexChanged.connect(self.solve)
self.path_preview_option.currentIndexChanged.connect(self.solve)
self.settings_reset.clicked.connect(self.reset_options)
def __zoom(self):
"""Zoom functions.
+ 'zoom to fit' function connections.
+ Zoom text buttons
"""
self.action_zoom_to_fit.triggered.connect(self.main_canvas.zoom_to_fit)
self.ResetCanvas.clicked.connect(self.main_canvas.zoom_to_fit)
zoom_menu = QMenu(self)
def zoom_level(value: int):
"""Return a function that set the specified zoom value."""
@Slot()
def func():
self.zoom_bar.setValue(value)
return func
for level in range(
self.zoom_bar.minimum() - self.zoom_bar.minimum() % 100 + 100,
500 + 1, 100):
action = QAction(f'{level}%', self)
action.triggered.connect(zoom_level(level))
zoom_menu.addAction(action)
action = QAction("customize", self)
action.triggered.connect(self.customize_zoom)
zoom_menu.addAction(action)
self.zoom_button.setMenu(zoom_menu)
def __point_context_menu(self):
"""EntitiesPoint context menu
+ Add
///////
+ New Link
+ Edit
+ Grounded
+ Multiple joint
- Point0
- Point1
- ...
+ Copy table data
+ Copy coordinate
+ Clone
-------
+ Delete
"""
self.entities_point_widget.customContextMenuRequested.connect(
self.point_context_menu)
self.pop_menu_point = QMenu(self)
self.pop_menu_point.setSeparatorsCollapsible(True)
self.action_point_context_add = QAction("&Add", self)
self.action_point_context_add.triggered.connect(self.new_point)
self.pop_menu_point.addAction(self.action_point_context_add)
# New Link
self.pop_menu_point.addAction(self.action_new_link)
self.action_point_context_edit = QAction("&Edit", self)
self.action_point_context_edit.triggered.connect(self.edit_point)
self.pop_menu_point.addAction(self.action_point_context_edit)
self.action_point_context_lock = QAction("&Grounded", self)
self.action_point_context_lock.setCheckable(True)
self.action_point_context_lock.triggered.connect(self.lock_points)
self.pop_menu_point.addAction(self.action_point_context_lock)
self.pop_menu_point_merge = QMenu(self)
self.pop_menu_point_merge.setTitle("Multiple joint")
self.pop_menu_point.addMenu(self.pop_menu_point_merge)
self.action_point_context_copydata = QAction("&Copy table data", self)
self.action_point_context_copydata.triggered.connect(
self.copy_points_table)
self.pop_menu_point.addAction(self.action_point_context_copydata)
self.action_point_context_copy_coord = QAction("&Copy coordinate",
self)
self.action_point_context_copy_coord.triggered.connect(self.copy_coord)
self.pop_menu_point.addAction(self.action_point_context_copy_coord)
self.action_point_context_clone = QAction("C&lone", self)
self.action_point_context_clone.triggered.connect(self.clone_point)
self.pop_menu_point.addAction(self.action_point_context_clone)
self.pop_menu_point.addSeparator()
self.action_point_context_delete = QAction("&Delete", self)
self.action_point_context_delete.triggered.connect(
self.delete_selected_points)
self.pop_menu_point.addAction(self.action_point_context_delete)
def __link_context_menu(self):
"""EntitiesLink context menu
+ Add
+ Edit
+ Merge links
- Link0
- Link1
- ...
+ Copy table data
+ Release
+ Constrain
-------
+ Delete
"""
self.entities_link_widget.customContextMenuRequested.connect(
self.link_context_menu)
self.pop_menu_link = QMenu(self)
self.pop_menu_link.setSeparatorsCollapsible(True)
self.action_link_context_add = QAction("&Add", self)
self.action_link_context_add.triggered.connect(self.new_link)
self.pop_menu_link.addAction(self.action_link_context_add)
self.action_link_context_edit = QAction("&Edit", self)
self.action_link_context_edit.triggered.connect(self.edit_link)
self.pop_menu_link.addAction(self.action_link_context_edit)
self.pop_menu_link_merge = QMenu(self)
self.pop_menu_link_merge.setTitle("Merge links")
self.pop_menu_link.addMenu(self.pop_menu_link_merge)
self.action_link_context_copydata = QAction("&Copy table data", self)
self.action_link_context_copydata.triggered.connect(
self.copy_links_table)
self.pop_menu_link.addAction(self.action_link_context_copydata)
self.action_link_context_release = QAction("&Release", self)
self.action_link_context_release.triggered.connect(self.release_ground)
self.pop_menu_link.addAction(self.action_link_context_release)
self.action_link_context_constrain = QAction("C&onstrain", self)
self.action_link_context_constrain.triggered.connect(
self.constrain_link)
self.pop_menu_link.addAction(self.action_link_context_constrain)
self.pop_menu_link.addSeparator()
self.action_link_context_delete = QAction("&Delete", self)
self.action_link_context_delete.triggered.connect(
self.delete_selected_links)
self.pop_menu_link.addAction(self.action_link_context_delete)
def __canvas_context_menu(self):
"""MainCanvas context menus,
switch the actions when selection mode changed.
+ Actions set of points.
+ Actions set of links.
"""
self.main_canvas.setContextMenuPolicy(Qt.CustomContextMenu)
self.main_canvas.customContextMenuRequested.connect(
self.canvas_context_menu)
"""
Actions set of points:
+ Add
///////
+ New Link
+ Add [fixed]
+ Add [target path]
///////
+ Edit
+ Grounded
+ Multiple joint
- Point0
- Point1
- ...
+ Clone
+ Copy coordinate
-------
+ Delete
"""
self.pop_menu_canvas_p = QMenu(self)
self.pop_menu_canvas_p.setSeparatorsCollapsible(True)
self.action_canvas_context_add = QAction("&Add", self)
self.action_canvas_context_add.triggered.connect(self.add_normal_point)
self.pop_menu_canvas_p.addAction(self.action_canvas_context_add)
# New Link
self.pop_menu_canvas_p.addAction(self.action_new_link)
self.action_canvas_context_grounded_add = QAction(
"Add [grounded]", self)
self.action_canvas_context_grounded_add.triggered.connect(
self.add_fixed_point)
self.pop_menu_canvas_p.addAction(
self.action_canvas_context_grounded_add)
self.action_canvas_context_path = QAction("Add [target path]", self)
self.action_canvas_context_path.triggered.connect(
self.add_target_point)
self.pop_menu_canvas_p.addAction(self.action_canvas_context_path)
# The following actions will be shown when points selected.
self.pop_menu_canvas_p.addAction(self.action_point_context_edit)
self.pop_menu_canvas_p.addAction(self.action_point_context_lock)
self.pop_menu_canvas_p.addMenu(self.pop_menu_point_merge)
self.pop_menu_canvas_p.addAction(self.action_point_context_copy_coord)
self.pop_menu_canvas_p.addAction(self.action_point_context_clone)
self.pop_menu_canvas_p.addSeparator()
self.pop_menu_canvas_p.addAction(self.action_point_context_delete)
"""
Actions set of links:
+ Add
///////
+ Add [target path]
///////
+ Edit
+ Merge links
- Link0
- Link1
- ...
+ Release / Constrain
-------
+ Delete
"""
self.pop_menu_canvas_l = QMenu(self)
self.pop_menu_canvas_l.setSeparatorsCollapsible(True)
self.pop_menu_canvas_l.addAction(self.action_link_context_add)
self.pop_menu_canvas_l.addAction(self.action_link_context_edit)
self.pop_menu_canvas_l.addMenu(self.pop_menu_link_merge)
self.pop_menu_canvas_l.addAction(self.action_link_context_constrain)
self.pop_menu_canvas_l.addSeparator()
self.pop_menu_canvas_l.addAction(self.action_link_context_delete)
@Slot(int, name='on_entities_tab_currentChanged')
def __set_selection_mode(self, index: int):
"""Connect selection signal for main canvas."""
# Set selection from click table items.
tables: List[BaseTableWidget] = [
self.entities_point,
self.entities_link,
self.entities_expr,
]
try:
for table in tables:
table.row_selection_changed.disconnect()
except TypeError:
pass
tables[index].row_selection_changed.connect(
self.main_canvas.set_selection)
# Double click signal.
try:
self.main_canvas.doubleclick_edit.disconnect()
except TypeError:
pass
if index == 0:
self.main_canvas.doubleclick_edit.connect(self.edit_point)
elif index == 1:
self.main_canvas.doubleclick_edit.connect(self.edit_link)
# Clear all selections.
for table in tables:
table.clearSelection()
self.inputs_widget.clear_selection()
@abstractmethod
def command_reload(self, index: int) -> None:
...
@abstractmethod
def new_point(self) -> None:
...
@abstractmethod
def add_normal_point(self) -> None:
...
@abstractmethod
def add_fixed_point(self) -> None:
...
@abstractmethod
def edit_point(self) -> None:
...
@abstractmethod
def delete_selected_points(self) -> None:
...
@abstractmethod
def lock_points(self) -> None:
...
@abstractmethod
def new_link(self) -> None:
...
@abstractmethod
def edit_link(self) -> None:
...
@abstractmethod
def delete_selected_links(self) -> None:
...
@abstractmethod
def constrain_link(self) -> None:
...
@abstractmethod
def release_ground(self) -> None:
...
@abstractmethod
def add_target_point(self) -> None:
...
@abstractmethod
def set_free_move(
self, args: Sequence[Tuple[int, Tuple[float, float,
float]]]) -> None:
...
@abstractmethod
def q_add_normal_point(self, x: float, y: float) -> None:
...
@abstractmethod
def set_mouse_pos(self, x: float, y: float) -> None:
...
@abstractmethod
def solve(self) -> None:
...
@abstractmethod
def resolve(self) -> None:
...
@abstractmethod
def commit(self, is_branch: bool = False) -> None:
...
@abstractmethod
def commit_branch(self) -> None:
...
@abstractmethod
def enable_mechanism_actions(self) -> None:
...
@abstractmethod
def clone_point(self) -> None:
...
@abstractmethod
def copy_coord(self) -> None:
...
@abstractmethod
def copy_points_table(self) -> None:
...
@abstractmethod
def copy_links_table(self) -> None:
...
@abstractmethod
def canvas_context_menu(self, point: QPoint) -> None:
...
@abstractmethod
def link_context_menu(self, point: QPoint) -> None:
...
@abstractmethod
def customize_zoom(self) -> None:
...
@abstractmethod
def reset_options(self) -> None:
...
@abstractmethod
def preview_path(self, auto_preview: List[List[_Coord]],
slider_auto_preview: Dict[int, List[_Coord]],
vpoints: Sequence[VPoint]) -> None:
...
@abstractmethod
def reload_canvas(self) -> None:
...
@abstractmethod
def output_to(self, format_name: str, format_choose: Sequence[str]) -> str:
...
@abstractmethod
def right_input(self) -> bool:
...
@abstractmethod
def set_coords_as_current(self) -> None:
...
@abstractmethod
def dof(self) -> int:
...
@abstractmethod
def save_reply_box(self, title: str, file_name: str) -> None:
...
@abstractmethod
def input_from(self,
format_name: str,
format_choose: Sequence[str],
multiple: bool = False) -> str:
...
@abstractmethod
def get_graph(
self
) -> Tuple[Graph, List[int], List[Tuple[int, int]], Dict[int, _Coord],
Dict[int, int], Dict[int, int]]:
...
@abstractmethod
def get_configure(self) -> Dict[str, Any]:
...
@abstractmethod
def workbook_no_save(self) -> None:
...
@abstractmethod
def workbook_saved(self) -> bool:
...
@abstractmethod
def merge_result(self, expr: str,
path: Sequence[Sequence[_Coord]]) -> None:
...
@abstractmethod
def check_file_changed(self) -> bool:
...
@abstractmethod
def get_storage(self) -> Dict[str, str]:
...
@abstractmethod
def add_empty_links(self, link_color: Dict[str, str]) -> None:
...
@abstractmethod
def parse_expression(self, expr: str) -> None:
...
@abstractmethod
def add_multiple_storage(self, exprs: Sequence[Tuple[str, str]]) -> None:
...
@abstractmethod
def clear(self) -> None:
...
@abstractmethod
def add_points(
self, p_attr: Sequence[Tuple[float, float, str, str, int,
float]]) -> None:
...
class InputsWidget(QWidget, Ui_Form):
"""There has following functions:
+ Function of mechanism variables settings.
+ Path recording.
"""
def __init__(self, parent):
super(InputsWidget, self).__init__(parent)
self.setupUi(self)
#parent's pointer.
self.freemode_button = parent.freemode_button
self.EntitiesPoint = parent.EntitiesPoint
self.EntitiesLink = parent.EntitiesLink
self.MainCanvas = parent.MainCanvas
self.resolve = parent.resolve
self.reloadCanvas = parent.reloadCanvas
self.outputTo = parent.outputTo
self.ConflictGuide = parent.ConflictGuide
self.DOF = lambda: parent.DOF
self.rightInput = parent.rightInput
self.CommandStack = parent.CommandStack
#self widgets.
self.dial = QDial()
self.dial.setEnabled(False)
self.dial.valueChanged.connect(self.__updateVar)
self.dial_spinbox.valueChanged.connect(self.__setVar)
self.inputs_dial_layout.addWidget(RotatableView(self.dial))
self.variable_stop.clicked.connect(self.variableValueReset)
self.inputs_playShaft = QTimer(self)
self.inputs_playShaft.setInterval(10)
self.inputs_playShaft.timeout.connect(self.__changeIndex)
self.variable_list.currentRowChanged.connect(self.__dialOk)
'''Inputs record context menu
+ Copy data from Point{}
+ ...
'''
self.record_list.customContextMenuRequested.connect(
self.on_record_list_context_menu)
self.popMenu_record_list = QMenu(self)
self.pathData = {}
def clear(self):
self.pathData.clear()
for i in range(self.record_list.count() - 1):
self.record_list.takeItem(1)
self.variable_list.clear()
@pyqtSlot(tuple)
def setSelection(self, selections):
"""Set one selection from canvas."""
self.joint_list.setCurrentRow(selections[0] if selections[0] in self.
EntitiesPoint.selectedRows() else -1)
@pyqtSlot()
def clearSelection(self):
"""Clear the points selection."""
self.joint_list.setCurrentRow(-1)
@pyqtSlot(int)
def on_joint_list_currentRowChanged(self, row: int):
"""Change the point row from input widget."""
self.base_link_list.clear()
if not row > -1:
return
if row not in self.EntitiesPoint.selectedRows():
self.EntitiesPoint.setSelections((row, ), False)
for linkName in self.EntitiesPoint.item(row, 1).text().split(','):
if not linkName:
continue
self.base_link_list.addItem(linkName)
@pyqtSlot(int)
def on_base_link_list_currentRowChanged(self, row: int):
"""Set the drive links from base link."""
self.drive_link_list.clear()
if not row > -1:
return
inputs_point = self.joint_list.currentRow()
linkNames = self.EntitiesPoint.item(inputs_point, 1).text().split(',')
for linkName in linkNames:
if linkName == self.base_link_list.currentItem().text():
continue
self.drive_link_list.addItem(linkName)
@pyqtSlot(int)
def on_drive_link_list_currentRowChanged(self, row: int):
"""Set enable of 'add variable' button."""
if not row > -1:
self.variable_list_add.setEnabled(False)
return
typeText = self.joint_list.currentItem().text().split()[0]
self.variable_list_add.setEnabled(typeText == '[R]')
@pyqtSlot()
def on_variable_list_add_clicked(self):
"""Add inputs variable from click button."""
self.__addInputsVariable(self.joint_list.currentRow(),
self.base_link_list.currentItem().text(),
self.drive_link_list.currentItem().text())
def __addInputsVariable(self, point: int, base_link: str, drive_link: str):
"""Add variable with '->' sign."""
if not self.DOF() > 0:
return
for vlink in self.EntitiesLink.data():
if (vlink.name in {base_link, drive_link
}) and (len(vlink.points) < 2):
return
name = 'Point{}'.format(point)
vars = [
name, base_link, drive_link,
"{:.02f}".format(self.__getLinkAngle(point, drive_link))
]
for n, base, drive, a in self.getInputsVariables():
if {base_link, drive_link} == {base, drive}:
return
self.CommandStack.beginMacro("Add variable of {}".format(name))
self.CommandStack.push(AddVariable('->'.join(vars),
self.variable_list))
self.CommandStack.endMacro()
def addInputsVariables(self, variables: Tuple[Tuple[int, str, str]]):
"""Add from database."""
for variable in variables:
self.__addInputsVariable(*variable)
@pyqtSlot(int)
def __dialOk(self, p0=None):
"""Set the angle of base link and drive link."""
row = self.variable_list.currentRow()
enabled = row > -1
rotatable = (enabled and not self.freemode_button.isChecked()
and self.rightInput())
self.dial.setEnabled(rotatable)
self.dial_spinbox.setEnabled(rotatable)
self.oldVar = self.dial.value() / 100.
self.variable_play.setEnabled(rotatable)
self.variable_speed.setEnabled(rotatable)
self.dial.setValue(
float(self.variable_list.currentItem().text().split('->')[-1]) *
100 if enabled else 0)
def variableExcluding(self, row: int = None):
"""Remove variable if the point was been deleted.
Default: all.
"""
one_row = row is not None
for i, variable in enumerate(self.getInputsVariables()):
row_ = variable[0]
#If this is not origin point any more.
if one_row and (row != row_):
continue
self.CommandStack.beginMacro(
"Remove variable of Point{}".format(row))
self.CommandStack.push(DeleteVariable(i, self.variable_list))
self.CommandStack.endMacro()
@pyqtSlot()
def on_variable_remove_clicked(self):
"""Remove and reset angle."""
row = self.variable_list.currentRow()
if not row > -1:
return
reply = QMessageBox.question(self, "Remove variable",
"Do you want to remove this variable?")
if reply != QMessageBox.Yes:
return
self.variable_stop.click()
self.CommandStack.beginMacro("Remove variable of Point{}".format(row))
self.CommandStack.push(DeleteVariable(row, self.variable_list))
self.CommandStack.endMacro()
self.EntitiesPoint.getBackPosition()
self.resolve()
def __getLinkAngle(self, row: int, link: str) -> float:
"""Get the angle of base link and drive link."""
points = self.EntitiesPoint.dataTuple()
links = self.EntitiesLink.dataTuple()
link_names = [vlink.name for vlink in links]
relate = links[link_names.index(link)].points
base = points[row]
drive = points[relate[relate.index(row) - 1]]
return base.slopeAngle(drive)
def getInputsVariables(self) -> Tuple[int, str, str, float]:
"""A generator use to get variables.
[0]: point num
[1]: base link
[2]: drive link
[3]: angle
"""
for row in range(self.variable_list.count()):
variable = self.variable_list.item(row).text().split('->')
variable[0] = int(variable[0].replace('Point', ''))
variable[3] = float(variable[3])
yield tuple(variable)
def inputCount(self) -> int:
"""Use to show input variable count."""
return self.variable_list.count()
def inputPair(self) -> Tuple[int, int]:
"""Back as point number code."""
vlinks = {
vlink.name: set(vlink.points)
for vlink in self.EntitiesLink.data()
}
for vars in self.getInputsVariables():
points = vlinks[vars[2]].copy()
points.remove(vars[0])
yield (vars[0], points.pop())
def variableReload(self):
"""Auto check the points and type."""
self.joint_list.clear()
for i in range(self.EntitiesPoint.rowCount()):
text = "[{}] Point{}".format(
self.EntitiesPoint.item(i, 2).text(), i)
self.joint_list.addItem(text)
self.variableValueReset()
@pyqtSlot(float)
def __setVar(self, value):
self.dial.setValue(int(value % 360 * 100))
@pyqtSlot(int)
def __updateVar(self, value):
"""Update the value when rotating QDial."""
item = self.variable_list.currentItem()
value /= 100.
self.dial_spinbox.setValue(value)
if item:
itemText = item.text().split('->')
itemText[-1] = "{:.02f}".format(value)
item.setText('->'.join(itemText))
self.resolve()
if (self.record_start.isChecked()
and abs(self.oldVar - value) > self.record_interval.value()):
self.MainCanvas.recordPath()
self.oldVar = value
def variableValueReset(self):
"""Reset the value of QDial."""
if self.inputs_playShaft.isActive():
self.variable_play.setChecked(False)
self.inputs_playShaft.stop()
self.EntitiesPoint.getBackPosition()
for i, variable in enumerate(self.getInputsVariables()):
point = variable[0]
text = '->'.join([
'Point{}'.format(point), variable[1], variable[2],
"{:.02f}".format(self.__getLinkAngle(point, variable[2]))
])
self.variable_list.item(i).setText(text)
self.__dialOk()
self.resolve()
@pyqtSlot(bool)
def on_variable_play_toggled(self, toggled):
"""Triggered when play button was changed."""
self.dial.setEnabled(not toggled)
self.dial_spinbox.setEnabled(not toggled)
if toggled:
self.inputs_playShaft.start()
else:
self.inputs_playShaft.stop()
@pyqtSlot()
def __changeIndex(self):
"""QTimer change index."""
index = self.dial.value()
speed = self.variable_speed.value()
extremeRebound = (self.ConflictGuide.isVisible()
and self.extremeRebound.isChecked())
if extremeRebound:
speed *= -1
self.variable_speed.setValue(speed)
index += int(speed * 6 * (3 if extremeRebound else 1))
index %= self.dial.maximum()
self.dial.setValue(index)
@pyqtSlot(bool)
def on_record_start_toggled(self, toggled):
"""Save to file path data."""
if toggled:
self.MainCanvas.recordStart(int(360 /
self.record_interval.value()))
return
path = self.MainCanvas.getRecordPath()
name, ok = QInputDialog.getText(self, "Recording completed!",
"Please input name tag:")
if (not name) or (name in self.pathData):
i = 0
while "Record_{}".format(i) in self.pathData:
i += 1
QMessageBox.information(self, "Record",
"The name tag is being used or empty.")
name = "Record_{}".format(i)
self.addPath(name, path)
def addPath(self, name: str, path: Tuple[Tuple[float, float]]):
"""Add path function."""
self.CommandStack.beginMacro("Add {{Path: {}}}".format(name))
self.CommandStack.push(
AddPath(self.record_list, name, self.pathData, path))
self.CommandStack.endMacro()
self.record_list.setCurrentRow(self.record_list.count() - 1)
def loadPaths(self, paths: Tuple[Tuple[Tuple[float, float]]]):
"""Add multiple path."""
for name, path in paths.items():
self.addPath(name, path)
@pyqtSlot()
def on_record_remove_clicked(self):
"""Remove path data."""
row = self.record_list.currentRow()
if not row > 0:
return
self.CommandStack.beginMacro("Delete {{Path: {}}}".format(
self.record_list.item(row).text()))
self.CommandStack.push(DeletePath(row, self.record_list,
self.pathData))
self.CommandStack.endMacro()
self.record_list.setCurrentRow(self.record_list.count() - 1)
self.reloadCanvas()
@pyqtSlot(QListWidgetItem)
def on_record_list_itemDoubleClicked(self, item):
"""View path data."""
name = item.text().split(":")[0]
try:
data = self.pathData[name]
except KeyError:
return
reply = QMessageBox.question(
self, "Path data", "This path data including {}.".format(", ".join(
"Point{}".format(i) for i in range(len(data)) if data[i])),
(QMessageBox.Save | QMessageBox.Close), QMessageBox.Close)
if reply != QMessageBox.Save:
return
file_name = self.outputTo(
"path data",
["Comma-Separated Values (*.csv)", "Text file (*.txt)"])
if not file_name:
return
with open(file_name, 'w', newline='') as stream:
writer = csv.writer(stream)
for point in data:
for coordinate in point:
writer.writerow(coordinate)
writer.writerow(())
print("Output path data: {}".format(file_name))
@pyqtSlot(QPoint)
def on_record_list_context_menu(self, point):
"""Show the context menu.
Show path [0], [1], ...
Or copy path coordinates.
"""
row = self.record_list.currentRow()
if row > -1:
action = self.popMenu_record_list.addAction("Show all")
action.index = -1
name = self.record_list.item(row).text().split(":")[0]
try:
data = self.pathData[name]
except KeyError:
return
for action_text in ("Show", "Copy data from"):
self.popMenu_record_list.addSeparator()
for i in range(len(data)):
if data[i]:
action = self.popMenu_record_list.addAction(
"{} Point{}".format(action_text, i))
action.index = i
action = self.popMenu_record_list.exec_(
self.record_list.mapToGlobal(point))
if action:
if "Copy data from" in action.text():
QApplication.clipboard().setText('\n'.join(
"{},{}".format(x, y) for x, y in data[action.index]))
elif "Show" in action.text():
if action.index == -1:
self.record_show.setChecked(True)
self.MainCanvas.setPathShow(action.index)
self.popMenu_record_list.clear()
@pyqtSlot()
def on_record_show_clicked(self):
"""Show all paths or hide."""
if self.record_show.isChecked():
show = -1
else:
show = -2
self.MainCanvas.setPathShow(show)
@pyqtSlot(int)
def on_record_list_currentRowChanged(self, row):
"""Reload the canvas when switch the path."""
if self.record_show.isChecked():
self.MainCanvas.setPathShow(-1)
self.reloadCanvas()
def currentPath(self):
"""Return current path data to main canvas.
+ No path.
+ Show path data.
+ Auto preview.
"""
row = self.record_list.currentRow()
if row == -1:
self.MainCanvas.setAutoPath(False)
return ()
elif row > 0:
self.MainCanvas.setAutoPath(False)
name = self.record_list.item(row).text()
return self.pathData.get(name.split(':')[0], ())
elif row == 0:
self.MainCanvas.setAutoPath(True)
return ()
class MainWindowUiInterface(QMainWindow, Ui_MainWindow, metaclass=QAbcMeta):
"""External UI settings."""
def __init__(self):
super(MainWindowUiInterface, self).__init__()
self.setupUi(self)
self.setAttribute(Qt.WA_DeleteOnClose)
self.env = ""
self.setLocate(
QFileInfo(ARGUMENTS.c).canonicalFilePath() if ARGUMENTS.c else
QStandardPaths.writableLocation(QStandardPaths.DesktopLocation))
# Undo stack stream.
self.CommandStack = QUndoStack(self)
# Initialize custom UI.
self.__undo_redo()
self.__appearance()
self.__free_move()
self.__options()
self.__zoom()
self.__point_context_menu()
self.__link_context_menu()
self.__canvas_context_menu()
def show(self):
"""Overridden function to zoom the canvas's size after startup."""
super(MainWindowUiInterface, self).show()
self.MainCanvas.zoomToFit()
def setLocate(self, locate: str):
"""Set environment variables."""
if locate == self.env:
# If no changed.
return
self.env = locate
print(f"~Set workplace to: [\"{self.env}\"]")
def __undo_redo(self):
"""Undo list settings.
+ Undo stack.
+ Undo view widget.
+ Hot keys.
"""
self.CommandStack.setUndoLimit(self.undolimit_option.value())
self.undolimit_option.valueChanged.connect(
self.CommandStack.setUndoLimit)
self.CommandStack.indexChanged.connect(self.commandReload)
self.undoView = QUndoView(self.CommandStack)
self.undoView.setEmptyLabel("~ Start Pyslvs")
self.UndoRedoLayout.addWidget(self.undoView)
self.action_Redo = self.CommandStack.createRedoAction(self, "Redo")
self.action_Undo = self.CommandStack.createUndoAction(self, "Undo")
self.action_Redo.setShortcuts([
QKeySequence("Ctrl+Shift+Z"),
QKeySequence("Ctrl+Y"),
])
self.action_Redo.setStatusTip("Backtracking undo action.")
self.action_Redo.setIcon(QIcon(QPixmap(":/icons/redo.png")))
self.action_Undo.setShortcut("Ctrl+Z")
self.action_Undo.setStatusTip("Recover last action.")
self.action_Undo.setIcon(QIcon(QPixmap(":/icons/undo.png")))
self.menu_Edit.addAction(self.action_Undo)
self.menu_Edit.addAction(self.action_Redo)
def __appearance(self):
"""Start up and initialize custom widgets."""
# Version label
self.version_label.setText(f"v{_major}.{_minor}.{_build} ({_label})")
# Entities tables.
self.EntitiesTab.tabBar().setStatusTip(
"Switch the tabs to change to another view mode.")
self.EntitiesPoint = PointTableWidget(self.EntitiesPoint_widget)
self.EntitiesPoint.cellDoubleClicked.connect(self.editPoint)
self.EntitiesPoint.deleteRequest.connect(self.deletePoints)
self.EntitiesPoint_layout.addWidget(self.EntitiesPoint)
self.EntitiesLink = LinkTableWidget(self.EntitiesLink_widget)
self.EntitiesLink.cellDoubleClicked.connect(self.editLink)
self.EntitiesLink.deleteRequest.connect(self.deleteLinks)
self.EntitiesLink_layout.addWidget(self.EntitiesLink)
self.EntitiesExpr = ExprTableWidget(self.EntitiesExpr_widget)
self.EntitiesExpr.reset.connect(self.link_free_move_widget.setEnabled)
self.EntitiesExpr.free_move_request.connect(self.setLinkFreeMove)
self.EntitiesExpr_layout.insertWidget(0, self.EntitiesExpr)
# Link free mode slide bar.
self.link_free_move_slider.valueChanged.connect(
self.link_free_move_spinbox.setValue)
self.link_free_move_spinbox.valueChanged.connect(
self.link_free_move_slider.setValue)
self.link_free_move_slider.rangeChanged.connect(
self.link_free_move_spinbox.setRange)
# Select all button on the Point and Link tab as corner widget.
select_all_button = QPushButton()
select_all_button.setIcon(QIcon(QPixmap(":/icons/select_all.png")))
select_all_button.setToolTip("Select all")
select_all_button.setStatusTip("Select all item of point table.")
@pyqtSlot()
def table_select_all():
"""Distinguish table by tab index."""
tables = (self.EntitiesPoint, self.EntitiesLink, self.EntitiesExpr)
tables[self.EntitiesTab.currentIndex()].selectAll()
select_all_button.clicked.connect(table_select_all)
self.EntitiesTab.setCornerWidget(select_all_button)
select_all_action = QAction("Select all point", self)
select_all_action.triggered.connect(table_select_all)
select_all_action.setShortcut("Ctrl+A")
select_all_action.setShortcutContext(Qt.WindowShortcut)
self.addAction(select_all_action)
# QPainter canvas window
self.MainCanvas = DynamicCanvas(self)
self.EntitiesTab.currentChanged.connect(
self.MainCanvas.setSelectionMode)
@pyqtSlot(tuple, bool)
def table_set_selection(selections: Tuple[int], key_detect: bool):
"""Distinguish table by tab index."""
tables = (self.EntitiesPoint, self.EntitiesLink, self.EntitiesExpr)
tables[self.EntitiesTab.currentIndex()].setSelections(
selections, key_detect)
self.MainCanvas.selected.connect(table_set_selection)
self.EntitiesPoint.rowSelectionChanged.connect(
self.MainCanvas.setSelection)
@pyqtSlot()
def table_clear_selection():
"""Distinguish table by tab index."""
tables = (self.EntitiesPoint, self.EntitiesLink, self.EntitiesExpr)
tables[self.EntitiesTab.currentIndex()].clearSelection()
self.MainCanvas.noselected.connect(table_clear_selection)
clean_selection_action = QAction("Clean selection", self)
clean_selection_action.triggered.connect(table_clear_selection)
clean_selection_action.setShortcut("Esc")
clean_selection_action.setShortcutContext(Qt.WindowShortcut)
self.addAction(clean_selection_action)
self.MainCanvas.free_moved.connect(self.setFreeMove)
self.MainCanvas.alt_add.connect(self.qAddNormalPoint)
self.MainCanvas.doubleclick_edit.connect(self.editPoint)
self.MainCanvas.zoom_changed.connect(self.ZoomBar.setValue)
self.MainCanvas.tracking.connect(self.setMousePos)
self.canvasSplitter.insertWidget(0, self.MainCanvas)
self.canvasSplitter.setSizes([600, 10, 30])
# Selection label on status bar right side.
selection_label = SelectionLabel(self)
self.EntitiesPoint.selectionLabelUpdate.connect(
selection_label.updateSelectPoint)
self.MainCanvas.browse_tracking.connect(
selection_label.updateMousePosition)
self.status_bar.addPermanentWidget(selection_label)
# FPS label on status bar right side.
fps_label = FPSLabel(self)
self.MainCanvas.fps_updated.connect(fps_label.updateText)
self.status_bar.addPermanentWidget(fps_label)
# Inputs widget.
self.InputsWidget = InputsWidget(self)
self.inputs_tab_layout.addWidget(self.InputsWidget)
self.free_move_button.toggled.connect(
self.InputsWidget.variableValueReset)
self.InputsWidget.aboutToResolve.connect(self.resolve)
@pyqtSlot(tuple, bool)
def inputs_set_selection(selections: Tuple[int], _: bool):
"""Distinguish table by tab index."""
self.InputsWidget.clearSelection()
if self.EntitiesTab.currentIndex() == 0:
self.InputsWidget.setSelection(selections)
self.MainCanvas.selected.connect(inputs_set_selection)
self.MainCanvas.noselected.connect(self.InputsWidget.clearSelection)
self.InputsWidget.update_preview_button.clicked.connect(
self.MainCanvas.updatePreviewPath)
# Number and type synthesis.
self.StructureSynthesis = StructureSynthesis(self)
self.SynthesisTab.addTab(self.StructureSynthesis,
self.StructureSynthesis.windowIcon(),
"Structural")
# Synthesis collections
self.CollectionTabPage = Collections(self)
self.SynthesisTab.addTab(self.CollectionTabPage,
self.CollectionTabPage.windowIcon(),
"Collections")
self.StructureSynthesis.addCollection = (
self.CollectionTabPage.StructureWidget.addCollection)
# Dimensional synthesis
self.DimensionalSynthesis = DimensionalSynthesis(self)
self.MainCanvas.set_target_point.connect(
self.DimensionalSynthesis.setPoint)
self.SynthesisTab.addTab(self.DimensionalSynthesis,
self.DimensionalSynthesis.windowIcon(),
"Dimensional")
# File widget settings.
self.DatabaseWidget = DatabaseWidget(self)
self.SCMLayout.addWidget(self.DatabaseWidget)
self.DatabaseWidget.commit_add.clicked.connect(self.commit)
self.DatabaseWidget.branch_add.clicked.connect(self.commit_branch)
self.action_stash.triggered.connect(self.DatabaseWidget.stash)
# YAML editor.
self.YamlEditor = YamlEditor(self)
# Console dock will hide when startup.
self.ConsoleWidget.hide()
# Connect to GUI button switching.
self.console_disconnect_button.setEnabled(not ARGUMENTS.debug_mode)
self.console_connect_button.setEnabled(ARGUMENTS.debug_mode)
# Splitter stretch factor.
self.MainSplitter.setStretchFactor(0, 4)
self.MainSplitter.setStretchFactor(1, 15)
self.MechanismPanelSplitter.setSizes([500, 200])
self.synthesis_splitter.setSizes([100, 500])
# Enable mechanism menu actions when shows.
self.menu_Mechanism.aboutToShow.connect(self.enableMechanismActions)
# Start a new window.
@pyqtSlot()
def new_main_window():
run = self.__class__()
run.show()
self.action_new_window.triggered.connect(new_main_window)
def __free_move(self):
"""Menu of free move mode."""
free_move_mode_menu = QMenu(self)
def free_move_mode_func(j: int, icon_qt: QIcon):
@pyqtSlot()
def func():
self.free_move_button.setIcon(icon_qt)
self.MainCanvas.setFreeMove(j)
self.EntitiesTab.setCurrentIndex(0)
self.InputsWidget.variable_stop.click()
return func
for i, (text, icon, tip) in enumerate((
("View mode", "free_move_off", "Disable free move mode."),
("Translate mode", "translate", "Edit by 2 DOF moving."),
("Rotate mode", "rotate", "Edit by 1 DOF moving."),
("Reflect mode", "reflect", "Edit by flip axis."),
)):
action = QAction(QIcon(QPixmap(f":/icons/{icon}.png")), text, self)
action.triggered.connect(free_move_mode_func(i, action.icon()))
action.setShortcut(QKeySequence(f"Ctrl+{i + 1}"))
action.setShortcutContext(Qt.WindowShortcut)
action.setStatusTip(tip)
free_move_mode_menu.addAction(action)
if i == 0:
self.free_move_disable = action
self.free_move_button.setMenu(free_move_mode_menu)
# Link free move by expression table.
self.link_free_move_slider.sliderReleased.connect(
self.MainCanvas.emit_free_move_all)
def __options(self):
"""Signal connection for option widgets.
+ Spin boxes
+ Combo boxes
+ Check boxes
"""
# While value change, update the canvas widget.
self.settings = QSettings('Kmol', 'Pyslvs')
self.ZoomBar.valueChanged.connect(self.MainCanvas.setZoom)
self.linewidth_option.valueChanged.connect(
self.MainCanvas.setLinkWidth)
self.pathwidth_option.valueChanged.connect(
self.MainCanvas.setPathWidth)
self.fontsize_option.valueChanged.connect(self.MainCanvas.setFontSize)
self.action_show_point_mark.toggled.connect(
self.MainCanvas.setPointMark)
self.action_show_dimensions.toggled.connect(
self.MainCanvas.setShowDimension)
self.selectionradius_option.valueChanged.connect(
self.MainCanvas.setSelectionRadius)
self.linktrans_option.valueChanged.connect(
self.MainCanvas.setTransparency)
self.marginfactor_option.valueChanged.connect(
self.MainCanvas.setMarginFactor)
self.jointsize_option.valueChanged.connect(
self.MainCanvas.setJointSize)
self.zoomby_option.currentIndexChanged.connect(
self.MainCanvas.setZoomBy)
self.snap_option.valueChanged.connect(self.MainCanvas.setSnap)
self.background_option.textChanged.connect(
self.MainCanvas.setBackground)
self.background_opacity_option.valueChanged.connect(
self.MainCanvas.setBackgroundOpacity)
self.background_scale_option.valueChanged.connect(
self.MainCanvas.setBackgroundScale)
self.background_offset_x_option.valueChanged.connect(
self.MainCanvas.setBackgroundOffsetX)
self.background_offset_y_option.valueChanged.connect(
self.MainCanvas.setBackgroundOffsetY)
# Resolve after change current kernel.
self.planarsolver_option.addItems(kernel_list)
self.pathpreview_option.addItems(kernel_list +
("Same as solver kernel", ))
self.planarsolver_option.currentIndexChanged.connect(self.solve)
self.pathpreview_option.currentIndexChanged.connect(self.solve)
self.settings_reset.clicked.connect(self.resetOptions)
def __zoom(self):
"""Zoom functions.
+ 'zoom to fit' function connections.
+ Zoom text buttons
"""
self.action_zoom_to_fit.triggered.connect(self.MainCanvas.zoomToFit)
self.ResetCanvas.clicked.connect(self.MainCanvas.zoomToFit)
zoom_menu = QMenu(self)
def zoom_level(value: int):
"""Return a function that set the specified zoom value."""
@pyqtSlot()
def func():
return self.ZoomBar.setValue(value)
return func
for level in range(
self.ZoomBar.minimum() - self.ZoomBar.minimum() % 100 + 100,
500 + 1, 100):
action = QAction(f'{level}%', self)
action.triggered.connect(zoom_level(level))
zoom_menu.addAction(action)
action = QAction("customize", self)
action.triggered.connect(self.customizeZoom)
zoom_menu.addAction(action)
self.zoom_button.setMenu(zoom_menu)
def __point_context_menu(self):
"""EntitiesPoint context menu
+ Add
///////
+ New Link
+ Edit
+ Grounded
+ Multiple joint
- Point0
- Point1
- ...
+ Copy table data
+ Clone
-------
+ Delete
"""
self.EntitiesPoint_widget.customContextMenuRequested.connect(
self.point_context_menu)
self.pop_menu_point = QMenu(self)
self.pop_menu_point.setSeparatorsCollapsible(True)
self.action_point_context_add = QAction("&Add", self)
self.action_point_context_add.triggered.connect(self.newPoint)
self.pop_menu_point.addAction(self.action_point_context_add)
# New Link
self.pop_menu_point.addAction(self.action_new_link)
self.action_point_context_edit = QAction("&Edit", self)
self.action_point_context_edit.triggered.connect(self.editPoint)
self.pop_menu_point.addAction(self.action_point_context_edit)
self.action_point_context_lock = QAction("&Grounded", self)
self.action_point_context_lock.setCheckable(True)
self.action_point_context_lock.triggered.connect(self.lockPoints)
self.pop_menu_point.addAction(self.action_point_context_lock)
self.pop_menu_point_merge = QMenu(self)
self.pop_menu_point_merge.setTitle("Multiple joint")
self.pop_menu_point.addMenu(self.pop_menu_point_merge)
self.action_point_context_copydata = QAction("&Copy table data", self)
self.action_point_context_copydata.triggered.connect(
self.copyPointsTable)
self.pop_menu_point.addAction(self.action_point_context_copydata)
self.action_point_context_copyCoord = QAction("&Copy coordinate", self)
self.action_point_context_copyCoord.triggered.connect(self.copyCoord)
self.pop_menu_point.addAction(self.action_point_context_copyCoord)
self.action_point_context_copyPoint = QAction("C&lone", self)
self.action_point_context_copyPoint.triggered.connect(self.clonePoint)
self.pop_menu_point.addAction(self.action_point_context_copyPoint)
self.pop_menu_point.addSeparator()
self.action_point_context_delete = QAction("&Delete", self)
self.action_point_context_delete.triggered.connect(self.deletePoints)
self.pop_menu_point.addAction(self.action_point_context_delete)
def __link_context_menu(self):
"""EntitiesLink context menu
+ Add
+ Edit
+ Merge links
- Link0
- Link1
- ...
+ Copy table data
+ Release / Constrain
-------
+ Delete
"""
self.EntitiesLink_widget.customContextMenuRequested.connect(
self.link_context_menu)
self.pop_menu_link = QMenu(self)
self.pop_menu_link.setSeparatorsCollapsible(True)
self.action_link_context_add = QAction("&Add", self)
self.action_link_context_add.triggered.connect(self.newLink)
self.pop_menu_link.addAction(self.action_link_context_add)
self.action_link_context_edit = QAction("&Edit", self)
self.action_link_context_edit.triggered.connect(self.editLink)
self.pop_menu_link.addAction(self.action_link_context_edit)
self.pop_menu_link_merge = QMenu(self)
self.pop_menu_link_merge.setTitle("Merge links")
self.pop_menu_link.addMenu(self.pop_menu_link_merge)
self.action_link_context_copydata = QAction("&Copy table data", self)
self.action_link_context_copydata.triggered.connect(
self.copyLinksTable)
self.pop_menu_link.addAction(self.action_link_context_copydata)
self.action_link_context_release = QAction("&Release", self)
self.action_link_context_release.triggered.connect(self.releaseGround)
self.pop_menu_link.addAction(self.action_link_context_release)
self.action_link_context_constrain = QAction("C&onstrain", self)
self.action_link_context_constrain.triggered.connect(
self.constrainLink)
self.pop_menu_link.addAction(self.action_link_context_constrain)
self.pop_menu_link.addSeparator()
self.action_link_context_delete = QAction("&Delete", self)
self.action_link_context_delete.triggered.connect(self.deleteLinks)
self.pop_menu_link.addAction(self.action_link_context_delete)
def __canvas_context_menu(self):
"""MainCanvas context menus,
switch the actions when selection mode changed.
+ Actions set of points.
+ Actions set of links.
"""
self.MainCanvas.setContextMenuPolicy(Qt.CustomContextMenu)
self.MainCanvas.customContextMenuRequested.connect(
self.canvas_context_menu)
"""
Actions set of points:
+ Add
///////
+ New Link
+ Add [fixed]
+ Add [target path]
///////
+ Edit
+ Grounded
+ Multiple joint
- Point0
- Point1
- ...
+ Clone
+ Copy coordinate
-------
+ Delete
"""
self.pop_menu_canvas_p = QMenu(self)
self.pop_menu_canvas_p.setSeparatorsCollapsible(True)
self.action_canvas_context_add = QAction("&Add", self)
self.action_canvas_context_add.triggered.connect(self.addNormalPoint)
self.pop_menu_canvas_p.addAction(self.action_canvas_context_add)
# New Link
self.pop_menu_canvas_p.addAction(self.action_new_link)
self.action_canvas_context_grounded_add = QAction(
"Add [grounded]", self)
self.action_canvas_context_grounded_add.triggered.connect(
self.addFixedPoint)
self.pop_menu_canvas_p.addAction(
self.action_canvas_context_grounded_add)
self.action_canvas_context_path = QAction("Add [target path]", self)
self.action_canvas_context_path.triggered.connect(self.addTargetPoint)
self.pop_menu_canvas_p.addAction(self.action_canvas_context_path)
# The following actions will be shown when points selected.
self.pop_menu_canvas_p.addAction(self.action_point_context_edit)
self.pop_menu_canvas_p.addAction(self.action_point_context_lock)
self.pop_menu_canvas_p.addMenu(self.pop_menu_point_merge)
self.pop_menu_canvas_p.addAction(self.action_point_context_copyCoord)
self.pop_menu_canvas_p.addAction(self.action_point_context_copyPoint)
self.pop_menu_canvas_p.addSeparator()
self.pop_menu_canvas_p.addAction(self.action_point_context_delete)
"""
Actions set of links:
+ Add
///////
+ Add [target path]
///////
+ Edit
+ Merge links
- Link0
- Link1
- ...
+ Release / Constrain
-------
+ Delete
"""
self.pop_menu_canvas_l = QMenu(self)
self.pop_menu_canvas_l.setSeparatorsCollapsible(True)
self.pop_menu_canvas_l.addAction(self.action_link_context_add)
self.pop_menu_canvas_l.addAction(self.action_link_context_edit)
self.pop_menu_canvas_l.addMenu(self.pop_menu_link_merge)
self.pop_menu_canvas_l.addAction(self.action_link_context_constrain)
self.pop_menu_canvas_l.addSeparator()
self.pop_menu_canvas_l.addAction(self.action_link_context_delete)
@abstractmethod
def commandReload(self, index: int) -> None:
...
@abstractmethod
def newPoint(self) -> None:
...
@abstractmethod
def addNormalPoint(self) -> None:
...
@abstractmethod
def addFixedPoint(self) -> None:
...
@abstractmethod
def editPoint(self) -> None:
...
@abstractmethod
def deletePoints(self) -> None:
...
@abstractmethod
def lockPoints(self) -> None:
...
@abstractmethod
def newLink(self) -> None:
...
@abstractmethod
def editLink(self) -> None:
...
@abstractmethod
def deleteLinks(self) -> None:
...
@abstractmethod
def constrainLink(self) -> None:
...
@abstractmethod
def releaseGround(self) -> None:
...
@abstractmethod
def addTargetPoint(self) -> None:
...
@abstractmethod
def setLinkFreeMove(self, enable: bool) -> None:
...
@abstractmethod
def setFreeMove(
self, args: Sequence[Tuple[int, Tuple[float, float,
float]]]) -> None:
...
@abstractmethod
def qAddNormalPoint(self, x: float, y: float) -> None:
...
@abstractmethod
def setMousePos(self, x: float, y: float) -> None:
...
@abstractmethod
def solve(self) -> None:
...
@abstractmethod
def resolve(self) -> None:
...
@abstractmethod
def commit(self, is_branch: bool = False) -> None:
...
@abstractmethod
def commit_branch(self) -> None:
...
@abstractmethod
def enableMechanismActions(self) -> None:
...
@abstractmethod
def clonePoint(self) -> None:
...
@abstractmethod
def copyCoord(self) -> None:
...
@abstractmethod
def copyPointsTable(self) -> None:
...
@abstractmethod
def copyLinksTable(self) -> None:
...
@abstractmethod
def canvas_context_menu(self, point: QPoint) -> None:
...
@abstractmethod
def link_context_menu(self, point: QPoint) -> None:
...
@abstractmethod
def customizeZoom(self) -> None:
...
@abstractmethod
def resetOptions(self) -> None:
...
class InputsWidget(QWidget, Ui_Form):
"""There has following functions:
+ Function of mechanism variables settings.
+ Path recording.
"""
about_to_resolve = Signal()
def __init__(self, parent: MainWindowBase):
super(InputsWidget, self).__init__(parent)
self.setupUi(self)
# parent's function pointer.
self.free_move_button = parent.free_move_button
self.EntitiesPoint = parent.entities_point
self.EntitiesLink = parent.entities_link
self.MainCanvas = parent.main_canvas
self.solve = parent.solve
self.reload_canvas = parent.reload_canvas
self.output_to = parent.output_to
self.conflict = parent.conflict
self.dof = parent.dof
self.right_input = parent.right_input
self.CommandStack = parent.command_stack
self.set_coords_as_current = parent.set_coords_as_current
# Angle panel
self.dial = QDial()
self.dial.setStatusTip("Input widget of rotatable joint.")
self.dial.setEnabled(False)
self.dial.valueChanged.connect(self.__update_var)
self.dial_spinbox.valueChanged.connect(self.__set_var)
self.inputs_dial_layout.addWidget(RotatableView(self.dial))
# Angle panel available check
self.variable_list.currentRowChanged.connect(self.__dial_ok)
# Play button.
action = QShortcut(QKeySequence("F5"), self)
action.activated.connect(self.variable_play.click)
self.variable_stop.clicked.connect(self.variable_value_reset)
# Timer for play button.
self.inputs_play_shaft = QTimer()
self.inputs_play_shaft.setInterval(10)
self.inputs_play_shaft.timeout.connect(self.__change_index)
# Change the point coordinates with current position.
self.update_pos.clicked.connect(self.set_coords_as_current)
# Inputs record context menu
self.pop_menu_record_list = QMenu(self)
self.record_list.customContextMenuRequested.connect(
self.__record_list_context_menu
)
self.__path_data: Dict[str, Sequence[_Coord]] = {}
def clear(self):
"""Clear function to reset widget status."""
self.__path_data.clear()
for _ in range(self.record_list.count() - 1):
self.record_list.takeItem(1)
self.variable_list.clear()
def __set_angle_mode(self):
"""Change to angle input."""
self.dial.setMinimum(0)
self.dial.setMaximum(36000)
self.dial_spinbox.setMinimum(0)
self.dial_spinbox.setMaximum(360)
def __set_unit_mode(self):
"""Change to unit input."""
self.dial.setMinimum(-50000)
self.dial.setMaximum(50000)
self.dial_spinbox.setMinimum(-500)
self.dial_spinbox.setMaximum(500)
def path_data(self):
"""Return current path data."""
return self.__path_data
@Slot(tuple)
def set_selection(self, selections: Sequence[int]):
"""Set one selection from canvas."""
self.joint_list.setCurrentRow(selections[0])
@Slot()
def clear_selection(self):
"""Clear the points selection."""
self.driver_list.clear()
self.joint_list.setCurrentRow(-1)
@Slot(int, name='on_joint_list_currentRowChanged')
def __update_relate_points(self, _: int):
"""Change the point row from input widget."""
self.driver_list.clear()
item: Optional[QListWidgetItem] = self.joint_list.currentItem()
if item is None:
return
p0 = _variable_int(item.text())
vpoints = self.EntitiesPoint.data_tuple()
type_int = vpoints[p0].type
if type_int == VJoint.R:
for i, vpoint in enumerate(vpoints):
if i == p0:
continue
if vpoints[p0].same_link(vpoint):
if vpoints[p0].grounded() and vpoint.grounded():
continue
self.driver_list.addItem(f"[{vpoint.type_str}] Point{i}")
elif type_int in {VJoint.P, VJoint.RP}:
self.driver_list.addItem(f"[{vpoints[p0].type_str}] Point{p0}")
@Slot(int, name='on_driver_list_currentRowChanged')
def __set_add_var_enabled(self, _: int):
"""Set enable of 'add variable' button."""
driver = self.driver_list.currentIndex()
self.variable_add.setEnabled(driver != -1)
@Slot(name='on_variable_add_clicked')
def __add_inputs_variable(self, p0: Optional[int] = None, p1: Optional[int] = None):
"""Add variable with '->' sign."""
if p0 is None:
item: Optional[QListWidgetItem] = self.joint_list.currentItem()
if item is None:
return
p0 = _variable_int(item.text())
if p1 is None:
item: Optional[QListWidgetItem] = self.driver_list.currentItem()
if item is None:
return
p1 = _variable_int(item.text())
# Check DOF.
if self.dof() <= self.input_count():
QMessageBox.warning(
self,
"Wrong DOF",
"The number of variable must no more than degrees of freedom."
)
return
# Check same link.
vpoints = self.EntitiesPoint.data_tuple()
if not vpoints[p0].same_link(vpoints[p1]):
QMessageBox.warning(
self,
"Wrong pair",
"The base point and driver point should at the same link."
)
return
# Check repeated pairs.
for p0_, p1_, a in self.input_pairs():
if {p0, p1} == {p0_, p1_} and vpoints[p0].type == VJoint.R:
QMessageBox.warning(
self,
"Wrong pair",
"There already have a same pair."
)
return
name = f'Point{p0}'
self.CommandStack.beginMacro(f"Add variable of {name}")
if p0 == p1:
# One joint by offset.
value = vpoints[p0].true_offset()
else:
# Two joints by angle.
value = vpoints[p0].slope_angle(vpoints[p1])
self.CommandStack.push(AddVariable('->'.join((
name,
f'Point{p1}',
f"{value:.02f}",
)), self.variable_list))
self.CommandStack.endMacro()
def add_inputs_variables(self, variables: Sequence[Tuple[int, int]]):
"""Add from database."""
for p0, p1 in variables:
self.__add_inputs_variable(p0, p1)
@Slot()
def __dial_ok(self):
"""Set the angle of base link and drive link."""
row = self.variable_list.currentRow()
enabled = row > -1
rotatable = (
enabled and
not self.free_move_button.isChecked() and
self.right_input()
)
self.dial.setEnabled(rotatable)
self.dial_spinbox.setEnabled(rotatable)
self.oldVar = self.dial.value() / 100.
self.variable_play.setEnabled(rotatable)
self.variable_speed.setEnabled(rotatable)
item: Optional[QListWidgetItem] = self.variable_list.currentItem()
if item is None:
return
expr = item.text().split('->')
p0 = int(expr[0].replace('Point', ''))
p1 = int(expr[1].replace('Point', ''))
value = float(expr[2])
if p0 == p1:
self.__set_unit_mode()
else:
self.__set_angle_mode()
self.dial.setValue(value * 100 if enabled else 0)
def variable_excluding(self, row: Optional[int] = None):
"""Remove variable if the point was been deleted. Default: all."""
one_row: bool = row is not None
for i, (b, d, a) in enumerate(self.input_pairs()):
# If this is not origin point any more.
if one_row and (row != b):
continue
self.CommandStack.beginMacro(f"Remove variable of Point{row}")
self.CommandStack.push(DeleteVariable(i, self.variable_list))
self.CommandStack.endMacro()
@Slot(name='on_variable_remove_clicked')
def remove_var(self, row: int = -1):
"""Remove and reset angle."""
if row == -1:
row = self.variable_list.currentRow()
if not row > -1:
return
self.variable_stop.click()
self.CommandStack.beginMacro(f"Remove variable of Point{row}")
self.CommandStack.push(DeleteVariable(row, self.variable_list))
self.CommandStack.endMacro()
self.EntitiesPoint.get_back_position()
self.solve()
def interval(self) -> float:
"""Return interval value."""
return self.record_interval.value()
def input_count(self) -> int:
"""Use to show input variable count."""
return self.variable_list.count()
def input_pairs(self) -> Iterator[Tuple[int, int, float]]:
"""Back as point number code."""
for row in range(self.variable_list.count()):
var = self.variable_list.item(row).text().split('->')
p0 = int(var[0].replace('Point', ''))
p1 = int(var[1].replace('Point', ''))
angle = float(var[2])
yield (p0, p1, angle)
def variable_reload(self):
"""Auto check the points and type."""
self.joint_list.clear()
for i in range(self.EntitiesPoint.rowCount()):
type_text = self.EntitiesPoint.item(i, 2).text()
self.joint_list.addItem(f"[{type_text}] Point{i}")
self.variable_value_reset()
@Slot(float)
def __set_var(self, value: float):
self.dial.setValue(int(value * 100 % self.dial.maximum()))
@Slot(int)
def __update_var(self, value: int):
"""Update the value when rotating QDial."""
item = self.variable_list.currentItem()
value /= 100.
self.dial_spinbox.blockSignals(True)
self.dial_spinbox.setValue(value)
self.dial_spinbox.blockSignals(False)
if item:
item_text = item.text().split('->')
item_text[-1] = f"{value:.02f}"
item.setText('->'.join(item_text))
self.about_to_resolve.emit()
if (
self.record_start.isChecked() and
abs(self.oldVar - value) > self.record_interval.value()
):
self.MainCanvas.record_path()
self.oldVar = value
def variable_value_reset(self):
"""Reset the value of QDial."""
if self.inputs_play_shaft.isActive():
self.variable_play.setChecked(False)
self.inputs_play_shaft.stop()
self.EntitiesPoint.get_back_position()
vpoints = self.EntitiesPoint.data_tuple()
for i, (p0, p1, a) in enumerate(self.input_pairs()):
self.variable_list.item(i).setText('->'.join([
f'Point{p0}',
f'Point{p1}',
f"{vpoints[p0].slope_angle(vpoints[p1]):.02f}",
]))
self.__dial_ok()
self.solve()
@Slot(bool, name='on_variable_play_toggled')
def __play(self, toggled: bool):
"""Triggered when play button was changed."""
self.dial.setEnabled(not toggled)
self.dial_spinbox.setEnabled(not toggled)
if toggled:
self.inputs_play_shaft.start()
else:
self.inputs_play_shaft.stop()
if self.update_pos_option.isChecked():
self.set_coords_as_current()
@Slot()
def __change_index(self):
"""QTimer change index."""
index = self.dial.value()
speed = self.variable_speed.value()
extreme_rebound = (
self.conflict.isVisible() and
self.extremeRebound.isChecked()
)
if extreme_rebound:
speed = -speed
self.variable_speed.setValue(speed)
index += int(speed * 6 * (3 if extreme_rebound else 1))
index %= self.dial.maximum()
self.dial.setValue(index)
@Slot(bool, name='on_record_start_toggled')
def __start_record(self, toggled: bool):
"""Save to file path data."""
if toggled:
self.MainCanvas.record_start(int(
self.dial_spinbox.maximum() / self.record_interval.value()
))
return
path = self.MainCanvas.get_record_path()
name, ok = QInputDialog.getText(
self,
"Recording completed!",
"Please input name tag:"
)
i = 0
name = name or f"Record_{i}"
while name in self.__path_data:
name = f"Record_{i}"
i += 1
QMessageBox.information(
self,
"Record",
"The name tag is being used or empty."
)
self.add_path(name, path)
def add_path(self, name: str, path: Sequence[_Coord]):
"""Add path function."""
self.CommandStack.beginMacro(f"Add {{Path: {name}}}")
self.CommandStack.push(AddPath(
self.record_list,
name,
self.__path_data,
path
))
self.CommandStack.endMacro()
self.record_list.setCurrentRow(self.record_list.count() - 1)
def load_paths(self, paths: Dict[str, Sequence[_Coord]]):
"""Add multiple path."""
for name, path in paths.items():
self.add_path(name, path)
@Slot(name='on_record_remove_clicked')
def __remove_path(self):
"""Remove path data."""
row = self.record_list.currentRow()
if not row > 0:
return
name = self.record_list.item(row).text()
self.CommandStack.beginMacro(f"Delete {{Path: {name}}}")
self.CommandStack.push(DeletePath(
row,
self.record_list,
self.__path_data
))
self.CommandStack.endMacro()
self.record_list.setCurrentRow(self.record_list.count() - 1)
self.reload_canvas()
@Slot(QListWidgetItem, name='on_record_list_itemDoubleClicked')
def __path_dlg(self, item: QListWidgetItem):
"""View path data."""
name = item.text().split(":")[0]
try:
data = self.__path_data[name]
except KeyError:
return
points_text = ", ".join(f"Point{i}" for i in range(len(data)))
if QMessageBox.question(
self,
"Path data",
f"This path data including {points_text}.",
(QMessageBox.Save | QMessageBox.Close),
QMessageBox.Close
) != QMessageBox.Save:
return
file_name = self.output_to(
"path data",
["Comma-Separated Values (*.csv)", "Text file (*.txt)"]
)
if not file_name:
return
with open(file_name, 'w', encoding='utf-8', newline='') as stream:
writer = csv.writer(stream)
for point in data:
for coordinate in point:
writer.writerow(coordinate)
writer.writerow(())
logger.info(f"Output path data: {file_name}")
@Slot(QPoint)
def __record_list_context_menu(self, point):
"""Show the context menu.
Show path [0], [1], ...
Or copy path coordinates.
"""
row = self.record_list.currentRow()
if not row > -1:
return
showall_action = self.pop_menu_record_list.addAction("Show all")
showall_action.index = -1
copy_action = self.pop_menu_record_list.addAction("Copy as new")
name = self.record_list.item(row).text().split(':')[0]
try:
data = self.__path_data[name]
except KeyError:
# Auto preview path.
data = self.MainCanvas.Path.path
showall_action.setEnabled(False)
else:
for action_text in ("Show", "Copy data from"):
self.pop_menu_record_list.addSeparator()
for i in range(len(data)):
if data[i]:
action = self.pop_menu_record_list.addAction(
f"{action_text} Point{i}"
)
action.index = i
action_exec = self.pop_menu_record_list.exec(
self.record_list.mapToGlobal(point)
)
if action_exec:
if action_exec == copy_action:
# Copy path data.
num = 0
name_copy = f"{name}_{num}"
while name_copy in self.__path_data:
name_copy = f"{name}_{num}"
num += 1
self.add_path(name_copy, data)
elif "Copy data from" in action_exec.text():
# Copy data to clipboard.
QApplication.clipboard().setText('\n'.join(
f"{x},{y}" for x, y in data[action_exec.index]
))
elif "Show" in action_exec.text():
# Switch points enabled status.
if action_exec.index == -1:
self.record_show.setChecked(True)
self.MainCanvas.set_path_show(action_exec.index)
self.pop_menu_record_list.clear()
@Slot(bool, name='on_record_show_toggled')
def __set_path_show(self, toggled: bool):
"""Show all paths or hide."""
self.MainCanvas.set_path_show(-1 if toggled else -2)
@Slot(int, name='on_record_list_currentRowChanged')
def __set_path(self, _: int):
"""Reload the canvas when switch the path."""
if not self.record_show.isChecked():
self.record_show.setChecked(True)
self.reload_canvas()
def current_path(self):
"""Return current path data to main canvas.
+ No path.
+ Show path data.
+ Auto preview.
"""
row = self.record_list.currentRow()
if row in {0, -1}:
return ()
path_name = self.record_list.item(row).text().split(':')[0]
return self.__path_data.get(path_name, ())
@Slot(name='on_variable_up_clicked')
@Slot(name='on_variable_down_clicked')
def __set_variable_priority(self):
row = self.variable_list.currentRow()
if not row > -1:
return
item = self.variable_list.currentItem()
self.variable_list.insertItem(
row + (-1 if self.sender() == self.variable_up else 1),
self.variable_list.takeItem(row)
)
self.variable_list.setCurrentItem(item)
class MainWindowBase(QMainWindow, Ui_MainWindow, metaclass=QABCMeta):
"""Base class of main window."""
@abstractmethod
def __init__(self):
super(MainWindowBase, self).__init__()
self.setupUi(self)
# Start new window
@Slot()
def new_main_window():
XStream.back()
run = self.__class__()
run.show()
self.action_New_Window.triggered.connect(new_main_window)
# Settings
self.settings = QSettings("Kmol", "Kmol Editor")
# Text editor
self.text_editor = TextEditor(self)
self.h2_splitter.addWidget(self.text_editor)
self.html_previewer = QWebEngineView()
self.html_previewer.setContextMenuPolicy(Qt.NoContextMenu)
self.html_previewer.setContent(b"", "text/plain")
self.h2_splitter.addWidget(self.html_previewer)
self.text_editor.word_changed.connect(self.reload_html_viewer)
self.text_editor.word_changed.connect(self.set_not_saved_title)
self.edge_line_option.toggled.connect(self.text_editor.setEdgeMode)
self.trailing_blanks_option.toggled.connect(
self.text_editor.set_remove_trailing_blanks)
# Highlighters
self.highlighter_option.addItems(sorted(QSCI_HIGHLIGHTERS))
self.highlighter_option.setCurrentText("Markdown")
self.highlighter_option.currentTextChanged.connect(
self.text_editor.set_highlighter)
self.highlighter_option.currentTextChanged.connect(
self.reload_html_viewer)
# Tree widget context menu
self.tree_widget.customContextMenuRequested.connect(
self.tree_context_menu)
self.pop_menu_tree = QMenu(self)
self.pop_menu_tree.setSeparatorsCollapsible(True)
self.pop_menu_tree.addAction(self.action_new_project)
self.pop_menu_tree.addAction(self.action_open)
self.tree_add = QAction("&Add Node", self)
self.tree_add.triggered.connect(self.add_node)
self.tree_add.setShortcutContext(Qt.WindowShortcut)
self.pop_menu_tree.addAction(self.tree_add)
self.pop_menu_tree.addSeparator()
self.tree_path = QAction("Set Path", self)
self.tree_path.triggered.connect(self.set_path)
self.pop_menu_tree.addAction(self.tree_path)
self.tree_refresh = QAction("&Refresh from Path", self)
self.tree_refresh.triggered.connect(self.refresh_proj)
self.pop_menu_tree.addAction(self.tree_refresh)
self.tree_openurl = QAction("&Open from Path", self)
self.tree_openurl.triggered.connect(self.open_path)
self.pop_menu_tree.addAction(self.tree_openurl)
self.action_save.triggered.connect(self.save_proj)
self.pop_menu_tree.addAction(self.action_save)
self.tree_copy = QAction("Co&py", self)
self.tree_copy.triggered.connect(self.copy_node)
self.pop_menu_tree.addAction(self.tree_copy)
self.tree_clone = QAction("C&lone", self)
self.tree_clone.triggered.connect(self.clone_node)
self.pop_menu_tree.addAction(self.tree_clone)
self.tree_copy_tree = QAction("Recursive Copy", self)
self.tree_copy_tree.triggered.connect(self.copy_node_recursive)
self.pop_menu_tree.addAction(self.tree_copy_tree)
self.tree_clone_tree = QAction("Recursive Clone", self)
self.tree_clone_tree.triggered.connect(self.clone_node_recursive)
self.pop_menu_tree.addAction(self.tree_clone_tree)
self.pop_menu_tree.addSeparator()
self.tree_delete = QAction("&Delete", self)
self.tree_delete.triggered.connect(self.delete_node)
self.pop_menu_tree.addAction(self.tree_delete)
self.tree_close = QAction("&Close", self)
self.tree_close.triggered.connect(self.close_proj)
self.pop_menu_tree.addAction(self.tree_close)
self.tree_main.header().setSectionResizeMode(
QHeaderView.ResizeToContents)
# Console
self.console.setFont(self.text_editor.font)
if not ARGUMENTS.debug_mode:
XStream.stdout().message_written.connect(self.append_to_console)
XStream.stderr().message_written.connect(self.append_to_console)
for info in INFO:
print(info)
print('-' * 7)
# Searching function
find_next = QShortcut(QKeySequence("F3"), self)
find_next.activated.connect(self.find_next_button.click)
find_previous = QShortcut(QKeySequence("F4"), self)
find_previous.activated.connect(self.find_previous_button.click)
find_tab = QShortcut(QKeySequence("Ctrl+F"), self)
find_tab.activated.connect(self.start_finder)
find_project = QShortcut(QKeySequence("Ctrl+Shift+F"), self)
find_project.activated.connect(self.find_project_button.click)
self.find_list_node: Dict[int, QTreeWidgetItem] = {}
# Replacing function
replace = QShortcut(QKeySequence("Ctrl+R"), self)
replace.activated.connect(self.replace_node_button.click)
replace_project = QShortcut(QKeySequence("Ctrl+Shift+R"), self)
replace_project.activated.connect(self.replace_project_button.click)
# Node edit function (Ctrl + ArrowKey)
new_node = QShortcut(QKeySequence("Ctrl+Ins"), self)
new_node.activated.connect(self.add_node)
del_node = QShortcut(QKeySequence("Ctrl+Del"), self)
del_node.activated.connect(self.delete_node)
move_up_node = QShortcut(QKeySequence("Ctrl+Up"), self)
move_up_node.activated.connect(self.move_up_node)
move_down_node = QShortcut(QKeySequence("Ctrl+Down"), self)
move_down_node.activated.connect(self.move_down_node)
move_right_node = QShortcut(QKeySequence("Ctrl+Right"), self)
move_right_node.activated.connect(self.move_right_node)
move_left_node = QShortcut(QKeySequence("Ctrl+Left"), self)
move_left_node.activated.connect(self.move_left_node)
# Run script button
run_sript = QShortcut(QKeySequence("F5"), self)
run_sript.activated.connect(self.exec_button.click)
self.macros_toolbar.setToolButtonStyle(Qt.ToolButtonTextBesideIcon)
# File keeper
self.keeper = None
# Data
self.data = DataDict()
self.data.not_saved.connect(self.set_not_saved_title)
self.data.all_saved.connect(self.set_saved_title)
self.env = QStandardPaths.writableLocation(
QStandardPaths.DesktopLocation)
@abstractmethod
def reload_html_viewer(self) -> None:
...
@abstractmethod
def set_not_saved_title(self) -> None:
...
@abstractmethod
def tree_context_menu(self, point: QPoint) -> None:
...
@abstractmethod
def add_node(self) -> None:
...
@abstractmethod
def set_path(self) -> None:
...
@abstractmethod
def refresh_proj(self, node: Optional[QTreeWidgetItem] = None) -> None:
...
@abstractmethod
def open_path(self) -> None:
...
@abstractmethod
def save_proj(self,
index: Optional[int] = None,
*,
for_all: bool = False) -> None:
...
@abstractmethod
def copy_node(self) -> None:
...
@abstractmethod
def clone_node(self) -> None:
...
@abstractmethod
def copy_node_recursive(self) -> None:
...
@abstractmethod
def clone_node_recursive(self) -> None:
...
@abstractmethod
def delete_node(self) -> None:
...
@abstractmethod
def close_proj(self) -> None:
...
@abstractmethod
def append_to_console(self, log: str) -> None:
...
@abstractmethod
def move_up_node(self) -> None:
...
@abstractmethod
def move_down_node(self) -> None:
...
@abstractmethod
def move_right_node(self) -> None:
...
@abstractmethod
def move_left_node(self) -> None:
...
@abstractmethod
def set_saved_title(self) -> None:
...
@abstractmethod
def start_finder(self):
...