copick-shared-ui 0.0.1__py3-none-any.whl

copick_shared_ui/__init__.py

@@ -0,0 +1,12 @@
+__version__ = "0.0.1"
+
+from copick_shared_ui.ui.edit_object_types_dialog import EditObjectTypesDialog, ColorButton
+from copick_shared_ui.util.validation import validate_copick_name, get_invalid_characters, generate_smart_copy_name
+
+__all__ = (
+    "EditObjectTypesDialog",
+    "ColorButton", 
+    "validate_copick_name",
+    "get_invalid_characters",
+    "generate_smart_copy_name",
+)

copick_shared_ui/ui/edit_object_types_dialog.py

@@ -0,0 +1,797 @@
+"""
+Dialog for editing and managing PickableObject types in the copick configuration
+"""
+
+from typing import List, Tuple
+
+from copick.models import PickableObject
+from qtpy.QtCore import Qt
+from qtpy.QtGui import QFont
+from qtpy.QtWidgets import (
+    QCheckBox,
+    QColorDialog,
+    QDialog,
+    QDialogButtonBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QGridLayout,
+    QGroupBox,
+    QHBoxLayout,
+    QHeaderView,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+    QWidget,
+)
+
+from copick_shared_ui.util.validation import validate_copick_name
+
+
+class ColorButton(QPushButton):
+    """Button that displays and allows selection of a color"""
+
+    def __init__(self, color: Tuple[int, int, int, int] = (100, 100, 100, 255), parent=None):
+        super().__init__(parent)
+        self._color = color
+        self.setMaximumSize(30, 30)
+        self.setMinimumSize(30, 30)
+        self.clicked.connect(self._select_color)
+        self._update_appearance()
+
+    def _update_appearance(self):
+        """Update button appearance to show current color"""
+        r, g, b, a = self._color
+        self.setStyleSheet(
+            f"""
+            QPushButton {{
+                background-color: rgba({r}, {g}, {b}, {a});
+                border: 2px solid #666;
+                border-radius: 4px;
+            }}
+            QPushButton:hover {{
+                border: 2px solid #333;
+            }}
+        """,
+        )
+        self.setToolTip(f"RGBA: ({r}, {g}, {b}, {a})")
+
+    def _select_color(self):
+        """Open color dialog to select new color"""
+        from qtpy.QtGui import QColor
+
+        current_color = QColor(*self._color[:3])  # RGB only for QColor
+        color = QColorDialog.getColor(current_color, self, "Select Object Color")
+        if color.isValid():
+            self._color = (color.red(), color.green(), color.blue(), self._color[3])  # Keep alpha
+            self._update_appearance()
+
+    def get_color(self) -> Tuple[int, int, int, int]:
+        """Get the current color"""
+        return self._color
+
+    def set_color(self, color: Tuple[int, int, int, int]):
+        """Set the current color"""
+        self._color = color
+        self._update_appearance()
+
+
+class EditObjectTypesDialog(QDialog):
+    """Dialog for editing and managing PickableObject types"""
+
+    def __init__(self, parent=None, existing_objects=None):
+        super().__init__(parent)
+        self._existing_objects = list(existing_objects) if existing_objects else []
+        self._original_objects = [obj.model_copy(deep=True) for obj in self._existing_objects]  # Keep original state
+        self._selected_object = None
+        self._editing_mode = False  # True when editing, False when adding new
+
+        self.setModal(True)
+        self.setWindowTitle("Edit Object Types")
+        self.setMinimumSize(800, 600)
+        self.resize(900, 700)
+
+        self._setup_ui()
+        self._connect_signals()
+        self._populate_objects_table()
+        self._reset_form()
+        self._update_button_states()
+
+    def _setup_ui(self):
+        """Setup the dialog UI"""
+        main_layout = QVBoxLayout()
+        main_layout.setContentsMargins(12, 12, 12, 12)
+        main_layout.setSpacing(12)
+
+        # Header
+        header = QLabel("✏️ Edit Object Types")
+        header_font = QFont()
+        header_font.setBold(True)
+        header_font.setPointSize(14)
+        header.setFont(header_font)
+        main_layout.addWidget(header)
+
+        # Info label
+        info_label = QLabel("Select an object type from the table to edit, or create a new one using the form below.")
+        info_label.setStyleSheet("color: gray; font-style: italic;")
+        main_layout.addWidget(info_label)
+
+        # Objects table with management buttons
+        self._create_objects_table()
+        main_layout.addWidget(self._objects_group)
+
+        # Form for editing/adding
+        self._create_object_form()
+        main_layout.addWidget(self._form_group)
+
+        # Dialog buttons
+        self._button_box = QDialogButtonBox(QDialogButtonBox.Ok | QDialogButtonBox.Cancel)
+        self._ok_button = self._button_box.button(QDialogButtonBox.Ok)
+        self._ok_button.setText("Save & Close")
+        self._ok_button.setEnabled(False)  # Initially disabled until changes are made
+        self._ok_button.setStyleSheet(
+            """
+            QPushButton {
+                background-color: #4A90E2;
+                color: white;
+                border: none;
+                border-radius: 4px;
+                padding: 6px 12px;
+                font-weight: bold;
+                min-width: 80px;
+            }
+            QPushButton:hover {
+                background-color: #357ABD;
+            }
+            QPushButton:disabled {
+                background-color: #ccc;
+                color: #888;
+            }
+        """,
+        )
+
+        main_layout.addWidget(self._button_box)
+        self.setLayout(main_layout)
+
+    def _create_objects_table(self):
+        """Create the objects management table"""
+        self._objects_group = QGroupBox("Existing Object Types")
+        group_layout = QVBoxLayout()
+
+        # Table management buttons
+        table_buttons_layout = QHBoxLayout()
+        table_buttons_layout.setContentsMargins(0, 0, 0, 5)
+
+        self._edit_button = QPushButton("✏️ Edit Selected")
+        self._edit_button.setEnabled(False)
+        self._edit_button.setToolTip("Edit the selected object type")
+
+        self._delete_button = QPushButton("❌ Delete Selected")
+        self._delete_button.setEnabled(False)
+        self._delete_button.setToolTip("Delete the selected object type")
+
+        self._new_button = QPushButton("📄 Add New")
+        self._new_button.setToolTip("Create a new object type")
+
+        table_buttons_layout.addWidget(self._edit_button)
+        table_buttons_layout.addWidget(self._delete_button)
+        table_buttons_layout.addStretch()
+        table_buttons_layout.addWidget(self._new_button)
+
+        group_layout.addLayout(table_buttons_layout)
+
+        # Objects table
+        self._objects_table = QTableWidget()
+        self._objects_table.setColumnCount(6)
+        self._objects_table.setHorizontalHeaderLabels(["Name", "Type", "Label", "Color", "EMDB/PDB", "Additional Info"])
+
+        # Configure table appearance
+        self._objects_table.setAlternatingRowColors(False)  # Disable alternating colors to use napari default
+        self._objects_table.setSelectionBehavior(QTableWidget.SelectRows)
+        self._objects_table.setSelectionMode(QTableWidget.SingleSelection)
+        self._objects_table.setEditTriggers(QTableWidget.NoEditTriggers)
+        self._objects_table.setMaximumHeight(200)
+
+        # Configure column widths
+        header = self._objects_table.horizontalHeader()
+        header.setSectionResizeMode(0, QHeaderView.ResizeToContents)  # Name
+        header.setSectionResizeMode(1, QHeaderView.ResizeToContents)  # Type
+        header.setSectionResizeMode(2, QHeaderView.ResizeToContents)  # Label
+        header.setSectionResizeMode(3, QHeaderView.Fixed)  # Color
+        header.resizeSection(3, 60)
+        header.setSectionResizeMode(4, QHeaderView.ResizeToContents)  # EMDB/PDB
+        header.setSectionResizeMode(5, QHeaderView.Stretch)  # Additional Info
+
+        group_layout.addWidget(self._objects_table)
+        self._objects_group.setLayout(group_layout)
+
+    def _create_object_form(self):
+        """Create the object form for editing/adding"""
+        self._form_group = QGroupBox("Object Configuration")
+        main_layout = QVBoxLayout()
+
+        # Form status label
+        self._form_status = QLabel("Ready to add new object")
+        self._form_status.setStyleSheet("font-weight: bold; color: #4A90E2; padding: 5px;")
+        main_layout.addWidget(self._form_status)
+
+        # Grid layout for two columns
+        grid_layout = QGridLayout()
+        grid_layout.setColumnStretch(0, 1)
+        grid_layout.setColumnStretch(1, 1)
+        grid_layout.setHorizontalSpacing(20)
+
+        # Left column - Basic properties
+        left_group = QGroupBox("Basic Properties")
+        left_layout = QFormLayout()
+
+        # Object name
+        self._name_edit = QLineEdit()
+        self._name_edit.setPlaceholderText("Enter object name (e.g., 'ribosome', 'membrane')")
+        self._name_edit.setToolTip("Unique name for this pickable object type")
+        left_layout.addRow("Name*:", self._name_edit)
+
+        # Name validation label
+        self._name_validation = QLabel()
+        self._name_validation.setStyleSheet(
+            """
+            QLabel {
+                color: #d32f2f;
+                font-size: 10px;
+                padding: 2px;
+                background-color: rgba(211, 47, 47, 0.1);
+                border: 1px solid rgba(211, 47, 47, 0.3);
+                border-radius: 3px;
+            }
+        """,
+        )
+        self._name_validation.setWordWrap(True)
+        self._name_validation.hide()
+        left_layout.addRow("", self._name_validation)
+
+        # Is particle checkbox
+        self._is_particle_cb = QCheckBox("Is Particle")
+        self._is_particle_cb.setChecked(True)
+        self._is_particle_cb.setToolTip(
+            "Check if this object should be represented by points, uncheck for segmentation masks",
+        )
+        left_layout.addRow("Type:", self._is_particle_cb)
+
+        # Label (numeric ID)
+        self._label_spin = QSpinBox()
+        self._label_spin.setRange(1, 9999)
+        self._label_spin.setValue(1)
+        self._label_spin.setToolTip("Unique numeric identifier for this object type")
+        left_layout.addRow("Label*:", self._label_spin)
+
+        # Label validation
+        self._label_validation = QLabel()
+        self._label_validation.setStyleSheet(
+            """
+            QLabel {
+                color: #d32f2f;
+                font-size: 10px;
+                padding: 2px;
+                background-color: rgba(211, 47, 47, 0.1);
+                border: 1px solid rgba(211, 47, 47, 0.3);
+                border-radius: 3px;
+            }
+        """,
+        )
+        self._label_validation.setWordWrap(True)
+        self._label_validation.hide()
+        left_layout.addRow("", self._label_validation)
+
+        # Color selection
+        color_widget = QWidget()
+        color_layout = QHBoxLayout()
+        color_layout.setContentsMargins(0, 0, 0, 0)
+        color_layout.setSpacing(5)
+
+        self._color_button = ColorButton()
+        color_layout.addWidget(self._color_button)
+        color_layout.addWidget(QLabel("Click to change color"))
+        color_layout.addStretch()
+        color_widget.setLayout(color_layout)
+
+        left_layout.addRow("Color:", color_widget)
+        left_group.setLayout(left_layout)
+
+        # Right column - Optional properties
+        right_group = QGroupBox("Optional Properties")
+        right_layout = QFormLayout()
+
+        # EMDB ID
+        self._emdb_edit = QLineEdit()
+        self._emdb_edit.setPlaceholderText("e.g., EMD-1234")
+        self._emdb_edit.setToolTip("EMDB ID for this object type")
+        right_layout.addRow("EMDB ID:", self._emdb_edit)
+
+        # PDB ID
+        self._pdb_edit = QLineEdit()
+        self._pdb_edit.setPlaceholderText("e.g., 1ABC")
+        self._pdb_edit.setToolTip("PDB ID for this object type")
+        right_layout.addRow("PDB ID:", self._pdb_edit)
+
+        # Identifier (GO/UniProt)
+        self._identifier_edit = QLineEdit()
+        self._identifier_edit.setPlaceholderText("e.g., GO:0005840 or P12345")
+        self._identifier_edit.setToolTip("Gene Ontology ID or UniProtKB accession")
+        right_layout.addRow("Identifier:", self._identifier_edit)
+
+        # Map threshold
+        self._threshold_spin = QDoubleSpinBox()
+        self._threshold_spin.setRange(-9999.0, 9999.0)
+        self._threshold_spin.setDecimals(3)
+        self._threshold_spin.setValue(0.0)
+        self._threshold_spin.setSpecialValueText("None")
+        self._threshold_spin.setToolTip("Threshold for isosurface rendering (set to minimum for None)")
+        right_layout.addRow("Map Threshold:", self._threshold_spin)
+
+        # Radius
+        self._radius_spin = QDoubleSpinBox()
+        self._radius_spin.setRange(0.1, 1000.0)
+        self._radius_spin.setDecimals(1)
+        self._radius_spin.setValue(10.0)
+        self._radius_spin.setSpecialValueText("None")
+        self._radius_spin.setToolTip("Radius for particle display (set to minimum for None)")
+        right_layout.addRow("Radius (Å):", self._radius_spin)
+
+        right_group.setLayout(right_layout)
+
+        # Add groups to grid
+        grid_layout.addWidget(left_group, 0, 0)
+        grid_layout.addWidget(right_group, 0, 1)
+
+        # Form action buttons
+        form_buttons_layout = QHBoxLayout()
+        form_buttons_layout.setContentsMargins(0, 10, 0, 0)
+
+        self._apply_button = QPushButton("✅ Save Object")
+        self._apply_button.setEnabled(False)
+        self._apply_button.setToolTip("Save the current object to the list")
+
+        self._cancel_edit_button = QPushButton("❌ Cancel")
+        self._cancel_edit_button.setEnabled(False)
+        self._cancel_edit_button.setToolTip("Cancel current editing operation")
+
+        form_buttons_layout.addWidget(self._apply_button)
+        form_buttons_layout.addWidget(self._cancel_edit_button)
+        form_buttons_layout.addStretch()
+
+        main_layout.addLayout(grid_layout)
+        main_layout.addLayout(form_buttons_layout)
+        self._form_group.setLayout(main_layout)
+
+    def _connect_signals(self):
+        """Connect widget signals"""
+        # Dialog buttons
+        self._button_box.accepted.connect(self.accept)
+        self._button_box.rejected.connect(self.reject)
+
+        # Table management buttons
+        self._edit_button.clicked.connect(self._edit_selected_object)
+        self._delete_button.clicked.connect(self._delete_selected_object)
+        self._new_button.clicked.connect(self._new_object)
+
+        # Form buttons
+        self._apply_button.clicked.connect(self._apply_changes)
+        self._cancel_edit_button.clicked.connect(self._cancel_edit)
+
+        # Table selection
+        self._objects_table.selectionModel().selectionChanged.connect(self._on_table_selection_changed)
+        self._objects_table.doubleClicked.connect(self._edit_selected_object)
+
+        # Form validation
+        self._name_edit.textChanged.connect(self._validate_form)
+        self._label_spin.valueChanged.connect(self._validate_form)
+
+    def _populate_objects_table(self):
+        """Populate the objects table"""
+        self._objects_table.setRowCount(len(self._existing_objects))
+
+        for row, obj in enumerate(self._existing_objects):
+            # Name
+            name_item = QTableWidgetItem(obj.name)
+            name_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+            self._objects_table.setItem(row, 0, name_item)
+
+            # Type
+            type_text = "Particle" if obj.is_particle else "Segmentation"
+            type_item = QTableWidgetItem(type_text)
+            type_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+            self._objects_table.setItem(row, 1, type_item)
+
+            # Label
+            label_text = str(obj.label) if obj.label is not None else "None"
+            label_item = QTableWidgetItem(label_text)
+            label_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+            self._objects_table.setItem(row, 2, label_item)
+
+            # Color
+            if obj.color:
+                r, g, b, a = obj.color
+                color_widget = QWidget()
+                color_layout = QHBoxLayout()
+                color_layout.setContentsMargins(5, 2, 5, 2)
+                color_button = QPushButton()
+                color_button.setEnabled(False)
+                color_button.setMaximumSize(20, 20)
+                color_button.setStyleSheet(
+                    f"""
+                    QPushButton {{
+                        background-color: rgba({r}, {g}, {b}, {a});
+                        border: 1px solid #666;
+                        border-radius: 2px;
+                    }}
+                """,
+                )
+                color_layout.addWidget(color_button)
+                color_layout.addStretch()
+                color_widget.setLayout(color_layout)
+                self._objects_table.setCellWidget(row, 3, color_widget)
+            else:
+                color_item = QTableWidgetItem("None")
+                color_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+                self._objects_table.setItem(row, 3, color_item)
+
+            # EMDB/PDB
+            ids = []
+            if obj.emdb_id:
+                ids.append(f"EMDB:{obj.emdb_id}")
+            if obj.pdb_id:
+                ids.append(f"PDB:{obj.pdb_id}")
+            id_text = ", ".join(ids) if ids else "None"
+            id_item = QTableWidgetItem(id_text)
+            id_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+            self._objects_table.setItem(row, 4, id_item)
+
+            # Additional Info
+            info_parts = []
+            if obj.identifier:
+                info_parts.append(f"ID:{obj.identifier}")
+            if obj.map_threshold is not None:
+                info_parts.append(f"Threshold:{obj.map_threshold}")
+            if obj.radius is not None:
+                info_parts.append(f"Radius:{obj.radius}Å")
+            info_text = ", ".join(info_parts) if info_parts else "None"
+            info_item = QTableWidgetItem(info_text)
+            info_item.setFlags(Qt.ItemIsEnabled | Qt.ItemIsSelectable)
+            self._objects_table.setItem(row, 5, info_item)
+
+    def _on_table_selection_changed(self):
+        """Handle table selection changes"""
+        self._update_button_states()
+
+    def _update_button_states(self):
+        """Update button states based on current state"""
+        has_selection = len(self._objects_table.selectionModel().selectedRows()) > 0
+        form_valid = self._is_form_valid()
+        
+        self._edit_button.setEnabled(has_selection and not self._editing_mode)
+        self._delete_button.setEnabled(has_selection and not self._editing_mode)
+        self._new_button.setEnabled(not self._editing_mode)
+
+        # Form buttons
+        apply_enabled = self._editing_mode and form_valid
+        self._apply_button.setEnabled(apply_enabled)
+        self._cancel_edit_button.setEnabled(self._editing_mode)
+
+    def _edit_selected_object(self):
+        """Edit the currently selected object"""
+        selected_rows = self._objects_table.selectionModel().selectedRows()
+        if not selected_rows:
+            return
+
+        row = selected_rows[0].row()
+        if 0 <= row < len(self._existing_objects):
+            self._selected_object = self._existing_objects[row]
+            self._editing_mode = True
+            self._populate_form_from_object(self._selected_object)
+            self._form_status.setText(f"Editing: {self._selected_object.name}")
+            self._form_status.setStyleSheet("font-weight: bold; color: #FF8C00; padding: 5px;")
+            self._update_button_states()
+
+    def _delete_selected_object(self):
+        """Delete the currently selected object"""
+        selected_rows = self._objects_table.selectionModel().selectedRows()
+        if not selected_rows:
+            return
+
+        row = selected_rows[0].row()
+        if 0 <= row < len(self._existing_objects):
+            obj_to_delete = self._existing_objects[row]
+
+            # Confirm deletion
+            reply = QMessageBox.question(
+                self,
+                "Delete Object Type",
+                f"Are you sure you want to delete the object type '{obj_to_delete.name}'?\n\n"
+                f"This action cannot be undone.",
+                QMessageBox.Yes | QMessageBox.No,
+                QMessageBox.No,
+            )
+
+            if reply == QMessageBox.Yes:
+                deleted_name = obj_to_delete.name
+                self._existing_objects.pop(row)
+                self._populate_objects_table()
+                self._reset_form()
+                self._update_button_states()
+                
+                # Show feedback and enable OK button
+                self._form_status.setText(f"✅ Object '{deleted_name}' deleted successfully")
+                self._form_status.setStyleSheet("font-weight: bold; color: #28a745; padding: 5px;")
+                self._ok_button.setEnabled(True)
+                self._ok_button.setStyleSheet(
+                    """
+                    QPushButton {
+                        background-color: #28a745;
+                        color: white;
+                        border: none;
+                        border-radius: 4px;
+                        padding: 6px 12px;
+                        font-weight: bold;
+                        min-width: 80px;
+                    }
+                    QPushButton:hover {
+                        background-color: #218838;
+                    }
+                """
+                )
+
+    def _new_object(self):
+        """Start creating a new object"""
+        self._selected_object = None
+        self._editing_mode = True
+        self._reset_form(keep_editing_mode=True)
+        self._populate_initial_data()
+        self._form_status.setText("Creating new object")
+        self._form_status.setStyleSheet("font-weight: bold; color: #4A90E2; padding: 5px;")
+        self._update_button_states()
+        self._name_edit.setFocus()
+
+    def _apply_changes(self):
+        """Apply current form changes"""
+        if not self._is_form_valid():
+            return
+
+        new_object = self._create_object_from_form()
+        object_name = new_object.name
+
+        if self._selected_object:
+            # Update existing object
+            row = self._existing_objects.index(self._selected_object)
+            self._existing_objects[row] = new_object
+            action = "updated"
+        else:
+            # Add new object
+            self._existing_objects.append(new_object)
+            action = "added"
+
+        self._populate_objects_table()
+        self._reset_form()
+        self._update_button_states()
+        
+        # Provide immediate visual feedback
+        self._form_status.setText(f"✅ Object '{object_name}' {action} successfully")
+        self._form_status.setStyleSheet("font-weight: bold; color: #28a745; padding: 5px;")
+        
+        # Enable the OK button to indicate changes are ready to be saved
+        self._ok_button.setEnabled(True)
+        self._ok_button.setStyleSheet(
+            """
+            QPushButton {
+                background-color: #28a745;
+                color: white;
+                border: none;
+                border-radius: 4px;
+                padding: 6px 12px;
+                font-weight: bold;
+                min-width: 80px;
+            }
+            QPushButton:hover {
+                background-color: #218838;
+            }
+        """
+        )
+
+    def _cancel_edit(self):
+        """Cancel current editing operation"""
+        self._reset_form()
+        self._update_button_states()
+
+    def _reset_form(self, keep_editing_mode=False):
+        """Reset form to default state"""
+        self._selected_object = None
+        if not keep_editing_mode:
+            self._editing_mode = False
+            self._form_status.setText("Ready to add new object")
+            self._form_status.setStyleSheet("font-weight: bold; color: #4A90E2; padding: 5px;")
+
+        # Clear form fields
+        self._name_edit.clear()
+        self._is_particle_cb.setChecked(True)
+        self._label_spin.setValue(1)
+        self._color_button.set_color((100, 100, 100, 255))
+        self._emdb_edit.clear()
+        self._pdb_edit.clear()
+        self._identifier_edit.clear()
+        self._threshold_spin.setValue(self._threshold_spin.minimum())
+        self._radius_spin.setValue(self._radius_spin.minimum())
+
+        # Hide validation messages
+        self._name_validation.hide()
+        self._label_validation.hide()
+        self._name_edit.setStyleSheet("")
+        self._label_spin.setStyleSheet("")
+
+    def _populate_form_from_object(self, obj: PickableObject):
+        """Populate form fields from an object"""
+        self._name_edit.setText(obj.name)
+        self._is_particle_cb.setChecked(obj.is_particle)
+
+        if obj.label is not None:
+            self._label_spin.setValue(obj.label)
+
+        if obj.color:
+            self._color_button.set_color(obj.color)
+
+        self._emdb_edit.setText(obj.emdb_id or "")
+        self._pdb_edit.setText(obj.pdb_id or "")
+        self._identifier_edit.setText(obj.identifier or "")
+
+        if obj.map_threshold is not None:
+            self._threshold_spin.setValue(obj.map_threshold)
+        else:
+            self._threshold_spin.setValue(self._threshold_spin.minimum())
+
+        if obj.radius is not None:
+            self._radius_spin.setValue(obj.radius)
+        else:
+            self._radius_spin.setValue(self._radius_spin.minimum())
+
+    def _populate_initial_data(self):
+        """Populate initial data for new object"""
+        existing_labels = {obj.label for obj in self._existing_objects if obj.label is not None}
+        next_label = max(existing_labels) + 1 if existing_labels else 1
+        self._label_spin.setValue(next_label)
+
+    def _create_object_from_form(self) -> PickableObject:
+        """Create PickableObject from current form data"""
+        name = self._name_edit.text().strip()
+        is_particle = self._is_particle_cb.isChecked()
+        label = self._label_spin.value()
+        color = self._color_button.get_color()
+
+        # Handle optional fields
+        emdb_id = self._emdb_edit.text().strip() or None
+        pdb_id = self._pdb_edit.text().strip() or None
+        identifier = self._identifier_edit.text().strip() or None
+
+        # Handle threshold (None if at minimum)
+        threshold = None
+        if self._threshold_spin.value() != self._threshold_spin.minimum():
+            threshold = self._threshold_spin.value()
+
+        # Handle radius (None if at minimum)
+        radius = None
+        if self._radius_spin.value() != self._radius_spin.minimum():
+            radius = self._radius_spin.value()
+
+        return PickableObject(
+            name=name,
+            is_particle=is_particle,
+            label=label,
+            color=color,
+            emdb_id=emdb_id,
+            pdb_id=pdb_id,
+            identifier=identifier,
+            map_threshold=threshold,
+            radius=radius,
+        )
+
+    def _validate_form(self):
+        """Validate the current form state"""
+        name_text = self._name_edit.text().strip()
+
+        # Validate name
+        is_valid, _, error_msg = validate_copick_name(name_text)
+
+        # Check for uniqueness (excluding current object being edited)
+        existing_names = {obj.name.lower() for obj in self._existing_objects if obj != self._selected_object}
+
+        if is_valid and name_text.lower() in existing_names:
+            is_valid = False
+            error_msg = f"Object name '{name_text}' already exists. Please choose a different name."
+
+        # Update name validation display
+        if is_valid:
+            self._name_validation.hide()
+            self._name_edit.setStyleSheet("")
+        else:
+            self._name_validation.setText(error_msg)
+            self._name_validation.show()
+            self._name_edit.setStyleSheet(
+                """
+                QLineEdit {
+                    border: 2px solid #d32f2f;
+                    background-color: rgba(211, 47, 47, 0.05);
+                }
+            """,
+            )
+
+        # Validate label uniqueness
+        label_value = self._label_spin.value()
+        existing_labels = {
+            obj.label for obj in self._existing_objects if obj != self._selected_object and obj.label is not None
+        }
+
+        label_valid = label_value not in existing_labels
+
+        if label_valid:
+            self._label_validation.hide()
+            self._label_spin.setStyleSheet("")
+        else:
+            error_msg = f"Label {label_value} is already in use. Please choose a different label."
+            self._label_validation.setText(error_msg)
+            self._label_validation.show()
+            self._label_spin.setStyleSheet(
+                """
+                QSpinBox {
+                    border: 2px solid #d32f2f;
+                    background-color: rgba(211, 47, 47, 0.05);
+                }
+            """,
+            )
+
+        self._update_button_states()
+        self.adjustSize()
+
+    def _is_form_valid(self) -> bool:
+        """Check if the current form state is valid"""
+        name_text = self._name_edit.text().strip()
+        name_valid, _, _ = validate_copick_name(name_text)
+
+        # Check name uniqueness
+        existing_names = {obj.name.lower() for obj in self._existing_objects if obj != self._selected_object}
+        if name_valid and name_text.lower() in existing_names:
+            name_valid = False
+
+        # Check label uniqueness
+        label_value = self._label_spin.value()
+        existing_labels = {
+            obj.label for obj in self._existing_objects if obj != self._selected_object and obj.label is not None
+        }
+        label_valid = label_value not in existing_labels
+
+        return name_valid and label_valid and bool(name_text)
+
+    def get_objects(self) -> List[PickableObject]:
+        """Get the current list of objects"""
+        return self._existing_objects
+
+    def has_changes(self) -> bool:
+        """Check if there are any changes compared to the original objects"""
+        if len(self._existing_objects) != len(self._original_objects):
+            return True
+
+        for current, original in zip(self._existing_objects, self._original_objects, strict=False):
+            if (
+                current.name != original.name
+                or current.is_particle != original.is_particle
+                or current.label != original.label
+                or current.color != original.color
+                or current.emdb_id != original.emdb_id
+                or current.pdb_id != original.pdb_id
+                or current.identifier != original.identifier
+                or current.map_threshold != original.map_threshold
+                or current.radius != original.radius
+            ):
+                return True
+
+        return False

copick_shared_ui/util/validation.py

@@ -0,0 +1,79 @@
+"""
+Validation utilities for copick entity names using copick.util.escape rules
+"""
+import re
+from typing import Tuple
+
+
+def validate_copick_name(input_str: str) -> Tuple[bool, str, str]:
+    """
+    Validate a string for use as copick object name, user_id or session_id.
+
+    Args:
+        input_str: The input string to validate
+
+    Returns:
+        Tuple of (is_valid, sanitized_name, error_message)
+        - is_valid: True if the original string is valid
+        - sanitized_name: The sanitized version of the input
+        - error_message: Error message if invalid, empty string if valid
+    """
+    if not input_str:
+        return False, "", "Name cannot be empty"
+
+    # Define invalid characters pattern from copick.util.escape
+    # Invalid: <>:"/\|?* (Windows), control chars, spaces, and underscores
+    invalid_chars = r'[<>:"/\\|?*\x00-\x1F\x7F\s_]'
+
+    # Check if string contains invalid characters
+    has_invalid = bool(re.search(invalid_chars, input_str))
+
+    # Create sanitized version
+    sanitized = re.sub(invalid_chars, "-", input_str)
+    sanitized = sanitized.strip("-")
+
+    if sanitized == "":
+        return False, "", "Name cannot consist only of invalid characters"
+
+    if has_invalid:
+        # Get list of invalid characters found
+        invalid_found = set(re.findall(invalid_chars, input_str))
+        invalid_list = ", ".join(f"'{char}'" if char != " " else "'space'" for char in sorted(invalid_found))
+        error_msg = f"Invalid characters: {invalid_list}"
+        return False, sanitized, error_msg
+
+    return True, input_str, ""
+
+
+def get_invalid_characters(input_str: str) -> list:
+    """
+    Get list of invalid characters in the input string.
+
+    Args:
+        input_str: The input string to check
+
+    Returns:
+        List of invalid characters found
+    """
+    invalid_chars = r'[<>:"/\\|?*\x00-\x1F\x7F\s_]'
+    return list(set(re.findall(invalid_chars, input_str)))
+
+
+def generate_smart_copy_name(base_name: str, existing_names: list) -> str:
+    """
+    Generate a smart copy name with auto-increment.
+    Always uses -copy1, -copy2, etc. format.
+
+    Args:
+        base_name: The original name to copy
+        existing_names: List of existing names to check against
+
+    Returns:
+        New unique name with -copy suffix and number
+    """
+    counter = 1
+    while True:
+        candidate = f"{base_name}-copy{counter}"
+        if candidate not in existing_names:
+            return candidate
+        counter += 1

copick_shared_ui-0.0.1.dist-info/METADATA

@@ -0,0 +1,109 @@
+Metadata-Version: 2.4
+Name: copick-shared-ui
+Version: 0.0.1
+Summary: Shared UI components for copick visualization plugins
+Project-URL: Repository, https://github.com/copick/copick-shared-ui
+Project-URL: Issues, https://github.com/copick/copick-shared-ui/issues
+Project-URL: Documentation, https://github.com/copick/copick-shared-ui#README.md
+Project-URL: Bug Tracker, https://github.com/copick/copick-shared-ui/issues
+Project-URL: Source Code, https://github.com/copick/copick-shared-ui
+Project-URL: User Support, https://github.com/copick/copick-shared-ui/issues
+Author-email: "Utz H. Ermel" <utz@ermel.me>, Kyle Harrington <czi@kyleharrington.com>
+License: MIT License
+        
+        Copyright (c) 2025 Utz H. Ermel
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: annotation,copick,cryo-et,cryoet,qt,tomography,ui
+Classifier: Development Status :: 2 - Pre-Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.9
+Requires-Dist: copick>=1.5.0
+Requires-Dist: pydantic>=2
+Requires-Dist: qtpy
+Provides-Extra: dev
+Requires-Dist: black>=25.1.0; extra == 'dev'
+Requires-Dist: hatch-vcs>=0.4.0; extra == 'dev'
+Requires-Dist: hatchling>=1.25.0; extra == 'dev'
+Requires-Dist: pre-commit>=4.2.0; extra == 'dev'
+Requires-Dist: ruff>=0.12.0; extra == 'dev'
+Provides-Extra: testing
+Requires-Dist: pyqt6; extra == 'testing'
+Requires-Dist: pytest; extra == 'testing'
+Requires-Dist: pytest-cov; extra == 'testing'
+Requires-Dist: pytest-qt; extra == 'testing'
+Requires-Dist: tox; extra == 'testing'
+Requires-Dist: tox-gh-actions; extra == 'testing'
+Requires-Dist: tox-uv; extra == 'testing'
+Description-Content-Type: text/markdown
+
+# copick-shared-ui
+
+Shared UI components for copick visualization plugins.
+
+This package provides reusable Qt-based UI components that can be used across different copick visualization plugins 
+(napari-copick, chimerax-copick, etc.).
+
+## Installation
+
+```bash
+uv pip install copick-shared-ui
+```
+
+## Usage
+
+```python
+from copick_shared_ui import EditObjectTypesDialog, validate_copick_name
+
+# Use the object types editor
+dialog = EditObjectTypesDialog(parent=None, existing_objects=my_objects)
+if dialog.exec_() == QDialog.Accepted:
+    updated_objects = dialog.get_objects()
+
+# Validate copick names
+is_valid, sanitized, error_msg = validate_copick_name("my-object-name")
+```
+
+## Components
+
+### EditObjectTypesDialog
+
+A dialog for managing copick PickableObject types with features:
+- Add, edit, and delete object types
+- Real-time validation with visual feedback
+- Color selection and management
+- Support for all `copick.PickableObject` properties (EMDB/PDB IDs, thresholds, etc.)
+
+### Validation
+
+Utilities for validating copick entity names according to copick naming conventions.

copick_shared_ui-0.0.1.dist-info/RECORD

@@ -0,0 +1,9 @@
+copick_shared_ui/__init__.py,sha256=ais7RrMw_Z67Ayu2f5XcNTG2-v2fBOES2g7b7XXf-Tk,384
+copick_shared_ui/ui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+copick_shared_ui/ui/edit_object_types_dialog.py,sha256=tLCuCy9mEW_CVkWpRltLgysIFTvM-jyqUgbntSjarV0,30362
+copick_shared_ui/util/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+copick_shared_ui/util/validation.py,sha256=2zIGJ2h1YIB6z-BAWRnNvh3RfOsIudCO4eeLXom8K7Q,2476
+copick_shared_ui-0.0.1.dist-info/METADATA,sha256=7H6WG2DfaQ9TupLW2U3CtY2Ytcv3NaJS-2l-7zUfi0E,4578
+copick_shared_ui-0.0.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+copick_shared_ui-0.0.1.dist-info/licenses/LICENSE,sha256=_qWGIH60iOE2dQ9QtMKciaXjuqfoRivj03T3iChJy8U,1068
+copick_shared_ui-0.0.1.dist-info/RECORD,,

copick_shared_ui-0.0.1.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

copick_shared_ui-0.0.1.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Utz H. Ermel
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.