| |
|
|
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """Widget for browsing Tool Library assets with filtering and sorting.""" |
|
|
| import yaml |
| from typing import cast, List, Optional |
| from PySide import QtCore, QtGui |
| from PySide.QtGui import QMenu, QAction, QKeySequence |
| import FreeCAD |
| import Path |
| from ...assets import AssetManager, AssetUri |
| from ...toolbit import ToolBit |
| from ...toolbit.ui import ToolBitEditor |
| from ...toolbit.ui.util import natural_sort_key |
| from ...toolbit.ui.browser import ToolBitBrowserWidget, ToolBitUriRole |
| from ...toolbit.serializers import YamlToolBitSerializer |
| from ..models.library import Library |
|
|
|
|
| Path.Log.setLevel(Path.Log.Level.INFO, Path.Log.thisModule()) |
| Path.Log.trackModule(Path.Log.thisModule()) |
|
|
|
|
| class LibraryBrowserWidget(ToolBitBrowserWidget): |
| """ |
| A widget to browse, filter, and select Tool Library assets from the |
| AssetManager, with sorting and batch insertion, using a current library. |
| """ |
|
|
| current_library_changed = QtCore.Signal() |
|
|
| def __init__( |
| self, |
| asset_manager: AssetManager, |
| store: str = "local", |
| parent=None, |
| compact=True, |
| ): |
| super().__init__( |
| asset_manager=asset_manager, |
| store=store, |
| parent=parent, |
| tool_no_factory=self.get_tool_no_from_current_library, |
| compact=compact, |
| ) |
| self.current_library: Optional[Library] = None |
| self._selected_tool_type: Optional[str] = None |
| self.layout().setContentsMargins(0, 0, 0, 0) |
|
|
| |
| self._tool_type_combo = QtGui.QComboBox() |
| self._tool_type_combo.setSizePolicy( |
| QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred |
| ) |
| self._top_layout.insertWidget(0, self._tool_type_combo, 1) |
| self._tool_type_combo.currentTextChanged.connect(self._on_tool_type_combo_changed) |
|
|
| self.restore_last_sort_order() |
| self.load_last_library() |
|
|
| def setDragEnabled(self, enabled: bool = True): |
| """Enable or disable drag-and-drop support for the tool list.""" |
| self._tool_list_widget.setDragEnabled(enabled) |
|
|
| def load_last_library(self): |
| """Loads the last selected library from preferences.""" |
| library_uri = Path.Preferences.getLastToolLibrary() |
| if library_uri: |
| try: |
| library = self._asset_manager.get(library_uri, store="local", depth=1) |
| self.set_current_library(library) |
| except Exception as e: |
| Path.Log.warning(f"Failed to load last tool library: {e}") |
|
|
| def restore_last_sort_order(self): |
| """Sets the sort mode and updates the tool list.""" |
| last_sort_key = Path.Preferences.getLastToolLibrarySortKey() |
| if last_sort_key: |
| self.set_sort_order(last_sort_key) |
|
|
| def set_sort_order(self, key: str): |
| super().set_sort_order(key) |
| Path.Preferences.setLastToolLibrarySortKey(self._sort_key) |
|
|
| def _get_state(self): |
| """Gets the current library URI, selected toolbit URI, and scroll |
| position.""" |
| current_library_uri_str = ( |
| str(self.current_library.get_uri()) if self.current_library else None |
| ) |
|
|
| selected_toolbit_uris = [] |
| selected_items = self._tool_list_widget.selectedItems() |
| if selected_items: |
| selected_toolbit_uris = [item.data(ToolBitUriRole) for item in selected_items] |
|
|
| scroll_pos = self._tool_list_widget.verticalScrollBar().value() |
|
|
| return { |
| "library_uri": current_library_uri_str, |
| "toolbit_uris": selected_toolbit_uris, |
| "scroll_pos": scroll_pos, |
| } |
|
|
| def _set_state(self, selection_data): |
| """Restores the library selection, toolbit selection, and scroll |
| position.""" |
| library_uri_str = selection_data.get("library_uri") |
| toolbit_uris = selection_data.get("toolbit_uris", []) |
| scroll_pos = selection_data.get("scroll_pos", 0) |
|
|
| |
| if library_uri_str: |
| try: |
| library_uri = AssetUri(library_uri_str) |
| library = self._asset_manager.get(library_uri, store=self._store_name, depth=1) |
| self.set_current_library(library) |
| except FileNotFoundError: |
| Path.Log.error(f"Library {library_uri_str} not found.") |
| self.set_current_library(None) |
| else: |
| self.set_current_library(None) |
|
|
| |
| if toolbit_uris: |
| for uri in toolbit_uris: |
| for i in range(self._tool_list_widget.count()): |
| item = self._tool_list_widget.item(i) |
| if item.data(ToolBitUriRole) == uri: |
| item.setSelected(True) |
|
|
| |
| self._tool_list_widget.verticalScrollBar().setValue(scroll_pos) |
|
|
| def refresh(self): |
| """Refreshes the toolbits for the current library from disk.""" |
| Path.Log.debug("refresh(): Fetching and populating toolbits.") |
| if self.current_library: |
| library_uri = self.current_library.get_uri() |
| try: |
| self.current_library = cast( |
| Library, self._asset_manager.get(library_uri, store=self._store_name, depth=1) |
| ) |
| except FileNotFoundError: |
| Path.Log.error(f"Library {library_uri} not found.") |
| self.current_library = None |
| self._update_tool_list() |
|
|
| def get_tool_no_from_current_library(self, toolbit): |
| """ |
| Retrieves the tool number for a toolbit based on the current library. |
| """ |
| if not self.current_library: |
| return None |
| tool_no = self.current_library.get_bit_no_from_bit(toolbit) |
| return tool_no |
|
|
| def set_current_library(self, library): |
| """Sets the current library and updates the tool list.""" |
| self.current_library = library |
| self._update_tool_list() |
| self.current_library_changed.emit() |
|
|
| |
| if library: |
| Path.Preferences.setLastToolLibrary(str(library.get_uri())) |
|
|
| def _get_available_tool_types(self): |
| """Get all available tool types from the current assets.""" |
| tool_types = set() |
| |
| if not hasattr(self, "_all_assets") or not self._all_assets: |
| return [] |
|
|
| for asset in self._all_assets: |
| |
| if hasattr(asset, "get_shape_name"): |
| tool_type = asset.get_shape_name() |
| if tool_type: |
| tool_types.add(tool_type) |
|
|
| return sorted(tool_types) |
|
|
| def _get_filtered_assets(self): |
| """Get assets filtered by tool type if a specific type is selected.""" |
| if self._tool_type_combo.currentIndex() == 0: |
| return self._all_assets |
|
|
| filtered_assets = [] |
| for asset in self._all_assets: |
| if hasattr(asset, "get_shape_name"): |
| tool_type = asset.get_shape_name() |
| if tool_type == self._selected_tool_type: |
| filtered_assets.append(asset) |
| return filtered_assets |
|
|
| def _update_tool_list(self): |
| """Updates the tool list based on the current library.""" |
| if self.current_library: |
| self._all_assets = [t for t in self.current_library] |
| else: |
| |
| all_toolbits = self._asset_manager.fetch(asset_type="toolbit", depth=0) |
| self._all_assets = cast(List[ToolBit], all_toolbits) |
| self._sort_assets() |
| self._tool_list_widget.clear_list() |
| |
| if hasattr(self, "_tool_type_combo"): |
| self._update_tool_type_combo() |
| self._update_list() |
|
|
| def _update_list(self): |
| """Updates the list widget with filtered assets.""" |
| self._tool_list_widget.clear_list() |
| filtered_assets = self._get_filtered_assets() |
|
|
| |
| search_term = self._search_edit.text().lower() |
| if search_term: |
| search_filtered = [] |
| for asset in filtered_assets: |
| if search_term in asset.label.lower(): |
| search_filtered.append(asset) |
| continue |
| |
| if hasattr(asset, "get_shape_name"): |
| tool_type = asset.get_shape_name() |
| if tool_type and search_term in tool_type.lower(): |
| search_filtered.append(asset) |
| filtered_assets = search_filtered |
|
|
| for asset in filtered_assets: |
| self._tool_list_widget.add_toolbit(asset) |
|
|
| def _add_shortcuts(self): |
| """Adds keyboard shortcuts for common actions.""" |
| Path.Log.debug("LibraryBrowserWidget._add_shortcuts: Called.") |
| super()._add_shortcuts() |
|
|
| cut_action = QAction(self) |
| cut_action.setShortcuts(QKeySequence.Cut) |
| cut_action.triggered.connect(self._on_cut_requested) |
| self.addAction(cut_action) |
|
|
| duplicate_action = QAction(self) |
| duplicate_action.setShortcut(QKeySequence("Ctrl+D")) |
| duplicate_action.triggered.connect(self._on_duplicate_requested) |
| self.addAction(duplicate_action) |
|
|
| remove_action = QAction(self) |
| remove_action.setShortcut(QKeySequence.Delete) |
| remove_action.triggered.connect(self._on_remove_from_library_requested) |
| self.addAction(remove_action) |
|
|
| paste_action = QAction(self) |
| paste_action.setShortcuts(QKeySequence.Paste) |
| paste_action.triggered.connect(self._on_paste_requested) |
| self.addAction(paste_action) |
|
|
| def _show_context_menu(self, position): |
| """Shows the context menu at the given position.""" |
| context_menu = QMenu(self) |
|
|
| selected_items = self._tool_list_widget.selectedItems() |
| has_selection = bool(selected_items) |
| has_library = self.current_library is not None |
|
|
| |
| edit_action = context_menu.addAction("Edit", self._on_edit_requested) |
| edit_action.setEnabled(has_selection) |
|
|
| context_menu.addSeparator() |
|
|
| action = context_menu.addAction("Copy", self._on_copy_requested) |
| action.setShortcut(QtGui.QKeySequence("Ctrl+C")) |
|
|
| action = context_menu.addAction("Cut", self._on_cut_requested) |
| action.setShortcut(QtGui.QKeySequence("Ctrl+X")) |
|
|
| action = context_menu.addAction("Paste", self._on_paste_requested) |
| action.setShortcut(QtGui.QKeySequence("Ctrl+V")) |
|
|
| |
| clipboard = QtGui.QApplication.clipboard() |
| mime_type = "application/x-freecad-toolbit-list-yaml" |
| action.setEnabled(clipboard.mimeData().hasFormat(mime_type)) |
|
|
| action = context_menu.addAction("Duplicate", self._on_duplicate_requested) |
| action.setShortcut(QtGui.QKeySequence("Ctrl+D")) |
|
|
| context_menu.addSeparator() |
|
|
| |
| if has_library: |
| action = context_menu.addAction( |
| "Remove from Library", self._on_remove_from_library_requested |
| ) |
| action.setShortcut(QtGui.QKeySequence.Delete) |
|
|
| |
| if not has_library: |
| action = context_menu.addAction("Delete from disk", self._on_delete_requested) |
| action.setShortcut(QtGui.QKeySequence("Shift+Delete")) |
|
|
| |
| context_menu.exec_(self._tool_list_widget.mapToGlobal(position)) |
|
|
| def get_current_library(self) -> Library | None: |
| """Helper to get the current library.""" |
| return self.current_library |
|
|
| def _on_edit_requested(self): |
| """Opens the ToolBitEditor for the selected toolbit.""" |
| toolbit = self._get_first_selected_bit() |
| if not toolbit: |
| return |
|
|
| |
| tool_no = self.get_tool_no_from_current_library(toolbit) |
| editor = ToolBitEditor(toolbit, tool_no, parent=self) |
| result = editor.show() |
| if result != QtGui.QDialog.Accepted: |
| return |
|
|
| |
| self._asset_manager.add(toolbit) |
| Path.Log.info(f"Toolbit {toolbit.get_id()} saved.") |
| editor._restore_original_schema() |
|
|
| |
| if self.current_library and tool_no != editor.tool_no: |
| self.current_library.assign_new_bit_no(toolbit, editor.tool_no) |
| self._asset_manager.add(self.current_library) |
|
|
| state = self._get_state() |
| self.refresh() |
| self._update_list() |
| self._set_state(state) |
|
|
| def _on_cut_requested(self): |
| """Handles cut request by copying and marking for removal from library.""" |
| uris = self.get_selected_bit_uris() |
| library = self.get_current_library() |
| if not library or not uris: |
| return |
|
|
| |
| extra_data = {"source_library_uri": str(library.get_uri())} |
| self._to_clipboard(uris, mode="cut", extra_data=extra_data) |
|
|
| def _on_duplicate_requested(self): |
| """Handles duplicate request by duplicating and adding to library.""" |
| Path.Log.debug("LibraryBrowserWidget._on_duplicate_requested: Called.\n") |
| uris = self.get_selected_bit_uris() |
| library = self.get_current_library() |
| if not library or not uris: |
| Path.Log.debug( |
| "LibraryBrowserWidget._on_duplicate_requested: No library or URIs selected. Returning." |
| ) |
| return |
|
|
| new_uris = set() |
| for uri_string in uris: |
| toolbit = cast(ToolBit, self._asset_manager.get(AssetUri(uri_string), depth=0)) |
| if not toolbit: |
| Path.Log.warning(f"Toolbit {uri_string} not found.\n") |
| continue |
|
|
| |
| toolbit.set_id() |
| toolbit.label = toolbit.label + " (copy)" |
| added_uri = self._asset_manager.add(toolbit) |
| if added_uri: |
| new_uris.add(str(toolbit.get_uri())) |
|
|
| |
| library.add_bit(toolbit) |
|
|
| self._asset_manager.add(library) |
| self.refresh() |
|
|
| self.select_by_uri(list(new_uris)) |
|
|
| def _on_paste_requested(self): |
| """Handles paste request by adding toolbits to the current library.""" |
| current_library = self.get_current_library() |
| if not current_library: |
| return |
|
|
| clipboard = QtGui.QApplication.clipboard() |
| mime_type = "application/x-freecad-toolbit-list-yaml" |
| mime_data = clipboard.mimeData() |
|
|
| if not mime_data.hasFormat(mime_type): |
| return |
|
|
| try: |
| clipboard_content_yaml = mime_data.data(mime_type).data().decode("utf-8") |
| clipboard_data_dict = yaml.safe_load(clipboard_content_yaml) |
|
|
| if ( |
| not isinstance(clipboard_data_dict, dict) |
| or "toolbits" not in clipboard_data_dict |
| or not isinstance(clipboard_data_dict["toolbits"], list) |
| ): |
| return |
|
|
| serialized_toolbits_data = clipboard_data_dict["toolbits"] |
| mode = clipboard_data_dict.get("operation", "copy") |
| source_library_uri_str = clipboard_data_dict.get("source_library_uri") |
|
|
| if mode == "copy": |
| self._on_copy_paste(current_library, serialized_toolbits_data) |
| elif mode == "cut" and source_library_uri_str: |
| self._on_cut_paste( |
| current_library, serialized_toolbits_data, source_library_uri_str |
| ) |
|
|
| except Exception as e: |
| Path.Log.warning(f"An unexpected error occurred during paste: {e}") |
|
|
| def _on_copy_paste(self, current_library: Library, serialized_toolbits_data: list): |
| """Handles pasting toolbits that were copied.""" |
| new_uris = set() |
| for toolbit_yaml_str in serialized_toolbits_data: |
| if not isinstance(toolbit_yaml_str, str) or not toolbit_yaml_str.strip(): |
| continue |
|
|
| toolbit_data_bytes = toolbit_yaml_str.encode("utf-8") |
| toolbit = YamlToolBitSerializer.deserialize(toolbit_data_bytes, dependencies=None) |
|
|
| |
| original_id = toolbit.id |
| Path.Log.info(f"COPY PASTE: Attempting to paste toolbit with original_id={original_id}") |
|
|
| |
| toolbit_uri = toolbit.get_uri() |
| existing_toolbit = None |
| try: |
| existing_toolbit = self._asset_manager.get( |
| toolbit_uri, store=["local", "builtin"], depth=0 |
| ) |
| Path.Log.info(f"COPY PASTE: Found existing toolbit {original_id}, using reference") |
| except FileNotFoundError: |
| |
| Path.Log.info(f"COPY PASTE: Toolbit {original_id} not found, creating new one") |
| self._asset_manager.add(toolbit) |
| existing_toolbit = toolbit |
|
|
| |
| added_toolbit = current_library.add_bit(existing_toolbit) |
| if added_toolbit: |
| new_uris.add(str(existing_toolbit.get_uri())) |
|
|
| if new_uris: |
| self._asset_manager.add(current_library) |
| self.refresh() |
| self.select_by_uri(list(new_uris)) |
|
|
| def _on_cut_paste( |
| self, |
| current_library: Library, |
| serialized_toolbits_data: list, |
| source_library_uri_str: str, |
| ): |
| """Handles pasting toolbits that were cut.""" |
| source_library_uri = AssetUri(source_library_uri_str) |
| if source_library_uri == current_library.get_uri(): |
| |
| return |
|
|
| try: |
| source_library = cast( |
| Library, |
| self._asset_manager.get(source_library_uri, store=self._store_name, depth=1), |
| ) |
| except FileNotFoundError: |
| Path.Log.warning(f"Source library {source_library_uri_str} not found.\n") |
| return |
|
|
| new_uris = set() |
| for toolbit_yaml_str in serialized_toolbits_data: |
| if not isinstance(toolbit_yaml_str, str) or not toolbit_yaml_str.strip(): |
| continue |
|
|
| toolbit_data_bytes = toolbit_yaml_str.encode("utf-8") |
| toolbit = YamlToolBitSerializer.deserialize(toolbit_data_bytes, dependencies=None) |
|
|
| |
| original_id = toolbit.id |
| Path.Log.info(f"CUT PASTE: Moving toolbit with original_id={original_id}") |
|
|
| toolbit_uri = toolbit.get_uri() |
| try: |
| existing_toolbit = self._asset_manager.get( |
| toolbit_uri, store=["local", "builtin"], depth=0 |
| ) |
| Path.Log.info(f"CUT PASTE: Found existing toolbit {original_id}, using reference") |
|
|
| |
| source_library.remove_bit(existing_toolbit) |
| added_toolbit = current_library.add_bit(existing_toolbit) |
| if added_toolbit: |
| new_uris.add(str(existing_toolbit.get_uri())) |
| except FileNotFoundError: |
| Path.Log.warning(f"CUT PASTE: Toolbit {original_id} not found in asset manager") |
|
|
| if new_uris: |
| |
| self._asset_manager.add(current_library) |
| self._asset_manager.add(source_library) |
| self.refresh() |
| self.select_by_uri(list(new_uris)) |
|
|
| def _on_remove_from_library_requested(self): |
| """Handles request to remove selected toolbits from the current library.""" |
| Path.Log.debug("_on_remove_from_library_requested: Called.") |
| uris = self.get_selected_bit_uris() |
| library = self.get_current_library() |
| if not library or not uris: |
| return |
|
|
| |
| reply = QtGui.QMessageBox.question( |
| self, |
| FreeCAD.Qt.translate("CAM", "Confirm Removal"), |
| FreeCAD.Qt.translate( |
| "CAM", "Are you sure you want to remove the selected toolbit(s) from the library?" |
| ), |
| QtGui.QMessageBox.Yes | QtGui.QMessageBox.No, |
| QtGui.QMessageBox.No, |
| ) |
|
|
| if reply == QtGui.QMessageBox.Yes: |
| self._remove_toolbits_from_library(library, uris) |
|
|
| def _remove_toolbits_from_library(self, library: Library, uris: List[str]): |
| """Removes toolbits with the given URIs from the specified library.""" |
| removed_count = 0 |
| for uri_string in uris: |
| try: |
| |
| library.remove_bit_by_uri(uri_string) |
| removed_count += 1 |
| except Exception as e: |
| Path.Log.error(f"Failed to remove toolbit {uri_string} from library: {e}\n") |
|
|
| if removed_count > 0: |
| self._asset_manager.add(library) |
| self.refresh() |
|
|
| def _update_tool_type_combo(self): |
| """Update the tool type combo box with available types.""" |
| current_selection = self._tool_type_combo.currentText() |
| self._tool_type_combo.blockSignals(True) |
| try: |
| self._tool_type_combo.clear() |
| self._tool_type_combo.addItem(FreeCAD.Qt.translate("CAM", "All Toolbit Types")) |
|
|
| for tool_type in self._get_available_tool_types(): |
| self._tool_type_combo.addItem(tool_type) |
|
|
| |
| index = self._tool_type_combo.findText(current_selection) |
| if index >= 0: |
| self._tool_type_combo.setCurrentIndex(index) |
| else: |
| self._tool_type_combo.setCurrentIndex(0) |
| finally: |
| self._tool_type_combo.blockSignals(False) |
|
|
| def _on_tool_type_combo_changed(self, tool_type): |
| """Handle tool type filter selection change.""" |
| self._selected_tool_type = tool_type |
| self._update_list() |
|
|
|
|
| class LibraryBrowserWithCombo(LibraryBrowserWidget): |
| """ |
| A widget extending LibraryBrowserWidget with a combo box for library selection. |
| """ |
|
|
| def __init__( |
| self, |
| asset_manager: AssetManager, |
| store: str = "local", |
| parent=None, |
| compact=True, |
| ): |
| super().__init__( |
| asset_manager=asset_manager, |
| store=store, |
| parent=parent, |
| compact=compact, |
| ) |
|
|
| |
| |
| layout = self.layout() |
| self._top_layout.removeWidget(self._search_edit) |
| layout.insertWidget(1, self._search_edit, 20) |
|
|
| |
| self._library_combo = QtGui.QComboBox() |
| self._library_combo.setSizePolicy(QtGui.QSizePolicy.Expanding, QtGui.QSizePolicy.Preferred) |
| self._top_layout.insertWidget(0, self._library_combo, 1) |
| self._library_combo.currentIndexChanged.connect(self._on_library_combo_changed) |
|
|
| self._top_layout.removeWidget(self._tool_type_combo) |
| self._top_layout.insertWidget(1, self._tool_type_combo, 1) |
|
|
| self.current_library_changed.connect(self._on_current_library_changed) |
|
|
| self._in_refresh = False |
| self.refresh() |
|
|
| def _on_library_combo_changed(self, index): |
| """Handles library selection change from the combo box.""" |
| if self._in_refresh: |
| return |
|
|
| selected_library = cast(Library, self._library_combo.itemData(index)) |
| if not selected_library: |
| return |
|
|
| |
| uri = selected_library.get_uri() |
| library = self._asset_manager.get(uri, store=self._store_name, depth=1) |
| self.set_current_library(library) |
|
|
| def _on_current_library_changed(self): |
| """Updates the combo box when the current library changes externally.""" |
| if self.current_library: |
| for i in range(self._library_combo.count()): |
| lib = self._library_combo.itemData(i) |
| if lib.get_uri() == self.current_library.get_uri(): |
| self._library_combo.setCurrentIndex(i) |
| return |
| Path.Log.warning( |
| f"Current library {self.current_library.get_uri()} not found in combo box." |
| ) |
|
|
| def refresh(self): |
| """Reads available libraries and refreshes the combo box and toolbits.""" |
| Path.Log.debug("refresh(): Fetching and populating libraries and toolbits.") |
| libraries = self._asset_manager.fetch("toolbitlibrary", store=self._store_name, depth=0) |
| self._in_refresh = True |
| try: |
| self._library_combo.clear() |
| for library in sorted(libraries, key=lambda x: natural_sort_key(x.label)): |
| self._library_combo.addItem(library.label, userData=library) |
| finally: |
| self._in_refresh = False |
|
|
| super().refresh() |
|
|
| if not libraries: |
| return |
| if not self.current_library: |
| first_library = self._library_combo.itemData(0) |
| if first_library: |
| uri = first_library.get_uri() |
| library = self._asset_manager.get(uri, store=self._store_name, depth=1) |
| self.set_current_library(library) |
| self._library_combo.setCurrentIndex(0) |
| return |
|
|
| for i in range(self._library_combo.count()): |
| lib = self._library_combo.itemData(i) |
| if lib.get_uri() == self.current_library.get_uri(): |
| self._library_combo.setCurrentIndex(i) |
| break |
| else: |
| self._library_combo.setCurrentIndex(0) |
|
|
