IncludeCPP 3.3.20__py3-none-any.whl → 3.4.8__py3-none-any.whl

includecpp/core/project_ui.py

@@ -134,6 +134,7 @@ THEME = {
 
 # Expanded node types with categories
 NODE_CATEGORIES = {
+    'Sources': ['source'],  # Primary - generates actual code files
     'Code Structures': ['class', 'struct', 'enum', 'interface', 'template_class', 'union'],
     'Functions': ['function', 'method', 'constructor', 'destructor', 'lambda', 'operator'],
     'Data': ['object', 'variable', 'constant', 'definition', 'typedef', 'pointer'],
@@ -142,6 +143,9 @@ NODE_CATEGORIES = {
 }
 
 NODE_TYPES = {
+    # Sources - Primary nodes that generate actual code files
+    'source': {'color': '#00e676', 'icon': 'S', 'gradient_start': '#00ff88', 'gradient_end': '#00c853', 'label': 'Source', 'category': 'Sources', 'port_count': 8},
+
     # Code Structures
     'class': {'color': '#4a9eff', 'icon': 'C', 'gradient_start': '#5aaeff', 'gradient_end': '#3a8eef', 'label': 'Class', 'category': 'Code Structures'},
     'struct': {'color': '#9c27b0', 'icon': 'S', 'gradient_start': '#ac37c0', 'gradient_end': '#8c17a0', 'label': 'Struct', 'category': 'Code Structures'},
@@ -217,6 +221,7 @@ class NodeData:
     properties: Dict[str, Any] = field(default_factory=dict)
     ports: List[Dict] = field(default_factory=list)
     group_id: str = ""
+    generated_files: Dict[str, str] = field(default_factory=dict)  # 'python': path, 'plugin': path
     created_at: str = ""
     updated_at: str = ""
 
@@ -583,36 +588,75 @@ if PYQT_AVAILABLE:
             type_rect = self.type_label.boundingRect()
             self.type_label.setPos(w - type_rect.width() - 10, 10)
 
+            # Description area with background (always created, hidden if empty)
+            self.desc_bg = QGraphicsRectItem(5, 36, w - 10, h - 44, self)
+            self.desc_bg.setBrush(QBrush(QColor(0, 0, 0, 40)))
+            self.desc_bg.setPen(QPen(Qt.PenStyle.NoPen))
+
+            self.desc_label = QGraphicsTextItem("", self)
+            self.desc_label.setDefaultTextColor(QColor(255, 255, 255, 200))
+            self.desc_label.setFont(QFont(SYSTEM_FONT, 9))
+            self.desc_label.setTextWidth(w - 20)
+            self.desc_label.setPos(10, 38)
+
             if self.node_data.description:
-                desc_text = self.node_data.description[:80]
-                if len(self.node_data.description) > 80:
+                desc_text = self.node_data.description[:120]
+                if len(self.node_data.description) > 120:
                     desc_text += "..."
-                self.desc_label = QGraphicsTextItem(desc_text, self)
-                self.desc_label.setDefaultTextColor(QColor(255, 255, 255, 180))
-                self.desc_label.setFont(QFont(SYSTEM_FONT, 9))
-                self.desc_label.setTextWidth(w - 20)
-                self.desc_label.setPos(10, 38)
+                self.desc_label.setPlainText(desc_text)
+                self.desc_bg.setVisible(True)
+            else:
+                self.desc_bg.setVisible(False)
 
+            # Connection points - 8 for source nodes, 2 for others
             point_size = 10
             self.connection_points = []
 
-            right_point = QGraphicsEllipseItem(
-                w - point_size/2, h/2 - point_size/2,
-                point_size, point_size, self
-            )
-            right_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
-            right_point.setPen(QPen(self.base_color, 2))
-            right_point.setZValue(2)
-            self.connection_points.append(('right', right_point))
-
-            left_point = QGraphicsEllipseItem(
-                -point_size/2, h/2 - point_size/2,
-                point_size, point_size, self
-            )
-            left_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
-            left_point.setPen(QPen(self.base_color, 2))
-            left_point.setZValue(2)
-            self.connection_points.append(('left', left_point))
+            port_count = self.node_theme.get('port_count', 2)
+
+            if port_count == 8:
+                # Source node: 4 ports on each side
+                for i in range(4):
+                    y_pos = 20 + (h - 40) * (i + 0.5) / 4
+
+                    # Right side ports
+                    right_point = QGraphicsEllipseItem(
+                        w - point_size/2, y_pos - point_size/2,
+                        point_size, point_size, self
+                    )
+                    right_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
+                    right_point.setPen(QPen(self.base_color, 2))
+                    right_point.setZValue(2)
+                    self.connection_points.append((f'right_{i}', right_point))
+
+                    # Left side ports
+                    left_point = QGraphicsEllipseItem(
+                        -point_size/2, y_pos - point_size/2,
+                        point_size, point_size, self
+                    )
+                    left_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
+                    left_point.setPen(QPen(self.base_color, 2))
+                    left_point.setZValue(2)
+                    self.connection_points.append((f'left_{i}', left_point))
+            else:
+                # Standard node: 1 port on each side
+                right_point = QGraphicsEllipseItem(
+                    w - point_size/2, h/2 - point_size/2,
+                    point_size, point_size, self
+                )
+                right_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
+                right_point.setPen(QPen(self.base_color, 2))
+                right_point.setZValue(2)
+                self.connection_points.append(('right', right_point))
+
+                left_point = QGraphicsEllipseItem(
+                    -point_size/2, h/2 - point_size/2,
+                    point_size, point_size, self
+                )
+                left_point.setBrush(QBrush(QColor(THEME['bg_dark'])))
+                left_point.setPen(QPen(self.base_color, 2))
+                left_point.setZValue(2)
+                self.connection_points.append(('left', left_point))
 
             self.bottom_line = QGraphicsRectItem(10, h - 4, w - 20, 2, self)
             self.bottom_line.setBrush(QBrush(self.base_color.lighter(130)))
@@ -715,8 +759,10 @@ if PYQT_AVAILABLE:
             """Update the description"""
             self.node_data.description = desc
             if hasattr(self, 'desc_label'):
-                display_text = desc[:80] + "..." if len(desc) > 80 else desc
+                display_text = desc[:120] + "..." if len(desc) > 120 else desc
                 self.desc_label.setPlainText(display_text)
+            if hasattr(self, 'desc_bg'):
+                self.desc_bg.setVisible(bool(desc))
             self.node_data.updated_at = datetime.now().isoformat()
 
 
@@ -1864,6 +1910,8 @@ if PYQT_AVAILABLE:
                 super().mouseReleaseEvent(event)
 
         def keyPressEvent(self, event: QKeyEvent):
+            move_amount = 50  # Grid step for arrow navigation
+
             if event.key() == Qt.Key.Key_Escape:
                 if self._connecting_mode:
                     self.cancel_connection_mode()
@@ -1878,6 +1926,15 @@ if PYQT_AVAILABLE:
             elif event.key() == Qt.Key.Key_0 and event.modifiers() & Qt.KeyboardModifier.ControlModifier:
                 self._zoom_level = 1.0
                 self.resetTransform()
+            # Arrow key navigation
+            elif event.key() == Qt.Key.Key_Up:
+                self.verticalScrollBar().setValue(self.verticalScrollBar().value() - move_amount)
+            elif event.key() == Qt.Key.Key_Down:
+                self.verticalScrollBar().setValue(self.verticalScrollBar().value() + move_amount)
+            elif event.key() == Qt.Key.Key_Left:
+                self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - move_amount)
+            elif event.key() == Qt.Key.Key_Right:
+                self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() + move_amount)
             else:
                 super().keyPressEvent(event)
 
@@ -1937,6 +1994,7 @@ if PYQT_AVAILABLE:
             if node:
                 props_action = menu.addAction("Properties...")
                 rename_action = menu.addAction("Rename")
+                desc_action = menu.addAction("Add Description...")
                 menu.addSeparator()
 
                 conn_menu = menu.addMenu("Connections")
@@ -1952,11 +2010,34 @@ if PYQT_AVAILABLE:
 
                 menu.addSeparator()
 
+                # Code menu - different options for source nodes
                 code_menu = menu.addMenu("Code")
-                preview_code = code_menu.addAction("Preview Code...")
-                gen_cpp_h = code_menu.addAction("Generate C++ Header")
-                gen_cpp_cpp = code_menu.addAction("Generate C++ Source")
-                gen_python = code_menu.addAction("Generate Python")
+                create_python = None
+                create_plugin = None
+                preview_code = None
+                gen_cpp_h = None
+                gen_cpp_cpp = None
+                gen_python = None
+
+                if node.node_data.node_type == 'source':
+                    # Source nodes get file generation options
+                    if not node.node_data.generated_files.get('python'):
+                        create_python = code_menu.addAction("Create Python")
+                    if not node.node_data.generated_files.get('plugin'):
+                        create_plugin = code_menu.addAction("Create Plugin")
+
+                    if node.node_data.generated_files.get('python') or node.node_data.generated_files.get('plugin'):
+                        code_menu.addSeparator()
+                    if node.node_data.generated_files.get('python'):
+                        code_menu.addAction(f"Python: {Path(node.node_data.generated_files['python']).name}").setEnabled(False)
+                    if node.node_data.generated_files.get('plugin'):
+                        code_menu.addAction(f"Plugin: {Path(node.node_data.generated_files['plugin']).name}").setEnabled(False)
+                else:
+                    # Non-source nodes get preview options
+                    preview_code = code_menu.addAction("Preview Code...")
+                    gen_cpp_h = code_menu.addAction("Generate C++ Header")
+                    gen_cpp_cpp = code_menu.addAction("Generate C++ Source")
+                    gen_python = code_menu.addAction("Generate Python")
 
                 menu.addSeparator()
                 delete_action = menu.addAction("Delete")
@@ -1978,6 +2059,14 @@ if PYQT_AVAILABLE:
                     if ok and name:
                         node.update_name(name)
 
+                elif action == desc_action:
+                    desc, ok = QInputDialog.getMultiLineText(
+                        self, "Description", "Enter description:",
+                        text=node.node_data.description
+                    )
+                    if ok:
+                        node.update_description(desc)
+
                 elif action == connect_action:
                     self.start_connection_mode(node)
 
@@ -1997,21 +2086,27 @@ if PYQT_AVAILABLE:
                     node.setSelected(True)
                     self.duplicate_selected()
 
-                elif action == preview_code:
+                elif action == create_python and create_python:
+                    self._create_python_file(node)
+
+                elif action == create_plugin and create_plugin:
+                    self._create_plugin_files(node)
+
+                elif action == preview_code and preview_code:
                     dialog = CodePreviewDialog(node, self)
                     dialog.exec()
 
-                elif action == gen_cpp_h:
+                elif action == gen_cpp_h and gen_cpp_h:
                     code = CodeGenerator.generate_cpp_header(node.node_data)
                     QApplication.clipboard().setText(code)
                     self.status_message.emit("C++ header copied to clipboard")
 
-                elif action == gen_cpp_cpp:
+                elif action == gen_cpp_cpp and gen_cpp_cpp:
                     code = CodeGenerator.generate_cpp_source(node.node_data)
                     QApplication.clipboard().setText(code)
                     self.status_message.emit("C++ source copied to clipboard")
 
-                elif action == gen_python:
+                elif action == gen_python and gen_python:
                     code = CodeGenerator.generate_python(node.node_data)
                     QApplication.clipboard().setText(code)
                     self.status_message.emit("Python code copied to clipboard")
@@ -2020,6 +2115,10 @@ if PYQT_AVAILABLE:
                     self.delete_node(node)
 
             else:
+                # Quick Source creation at top
+                create_source_action = menu.addAction("+ Create New Source")
+                menu.addSeparator()
+
                 create_menu = menu.addMenu("New")
                 self._create_categorized_menu(create_menu, scene_pos)
 
@@ -2052,7 +2151,12 @@ if PYQT_AVAILABLE:
 
                 action = menu.exec(event.globalPos())
 
-                if action and hasattr(action, 'data') and action.data():
+                if action == create_source_action:
+                    name, ok = QInputDialog.getText(self, "New Source", "Source name:")
+                    if ok and name:
+                        self.add_node('source', name, scene_pos.x(), scene_pos.y())
+
+                elif action and hasattr(action, 'data') and action.data():
                     data = action.data()
                     if isinstance(data, tuple):
                         node_type, pos = data
@@ -2104,6 +2208,441 @@ if PYQT_AVAILABLE:
                     if file_path:
                         self.export_to_image(file_path, "SVG")
 
+        def _get_connected_nodes(self, source_node: VisualNode) -> List[VisualNode]:
+            """Get all nodes connected to this source node (traverses full graph)."""
+            connected = []
+            visited = set()
+
+            def traverse(node):
+                if node.node_data.id in visited:
+                    return
+                visited.add(node.node_data.id)
+                if node != source_node:
+                    connected.append(node)
+                for conn in node.connections:
+                    other = conn.end_node if conn.start_node == node else conn.start_node
+                    traverse(other)
+
+            traverse(source_node)
+            return connected
+
+        def _create_python_file(self, node: VisualNode):
+            """Create Python file from source node with all connected nodes."""
+            name = node.node_data.name.replace(' ', '_').lower()
+            project_path = self._get_project_path()
+            file_path = project_path / f"{name}.py"
+
+            connected = self._get_connected_nodes(node)
+
+            # Build code from connections
+            code_parts = [
+                f'"""',
+                f'{node.node_data.name}',
+                f'{node.node_data.description or "Generated by IncludeCPP CodeMaker"}',
+                f'"""',
+                ''
+            ]
+
+            # Generate classes first
+            for n in connected:
+                if n.node_data.node_type in ('class', 'struct', 'interface', 'enum'):
+                    code_parts.append(CodeGenerator.generate_python(n.node_data))
+                    code_parts.append('')
+
+            # Then functions
+            for n in connected:
+                if n.node_data.node_type in ('function', 'method', 'lambda', 'constructor', 'destructor'):
+                    code_parts.append(CodeGenerator.generate_python(n.node_data))
+                    code_parts.append('')
+
+            # Main entry point
+            code_parts.append('if __name__ == "__main__":')
+            code_parts.append('    pass  # TODO: Entry point')
+
+            try:
+                file_path.write_text('\n'.join(code_parts), encoding='utf-8')
+                node.node_data.generated_files['python'] = str(file_path)
+                self.status_message.emit(f"Created: {file_path.name}")
+            except Exception as e:
+                self.status_message.emit(f"Error: {e}")
+
+        def _create_plugin_files(self, node: VisualNode):
+            """Create Plugin files from source node with all connected nodes."""
+            name = node.node_data.name.replace(' ', '_').lower()
+            project_path = self._get_project_path()
+            connected = self._get_connected_nodes(node)
+
+            # Create directories
+            plugins_dir = project_path / "plugins"
+            include_dir = project_path / "include"
+            plugins_dir.mkdir(exist_ok=True)
+            include_dir.mkdir(exist_ok=True)
+
+            # Gather connected code
+            classes = [n for n in connected if n.node_data.node_type in ('class', 'struct', 'interface', 'enum')]
+            functions = [n for n in connected if n.node_data.node_type in ('function', 'method', 'constructor', 'destructor', 'lambda', 'operator')]
+
+            try:
+                # .h file (include/) - declarations for all connected nodes
+                h_parts = [
+                    '#pragma once',
+                    f'// {node.node_data.name} - Generated by IncludeCPP CodeMaker',
+                    f'// {node.node_data.description or ""}',
+                    ''
+                ]
+                for c in classes:
+                    h_parts.append(CodeGenerator.generate_cpp_header(c.node_data))
+                    h_parts.append('')
+                for f in functions:
+                    h_parts.append(CodeGenerator.generate_cpp_header(f.node_data))
+                    h_parts.append('')
+
+                h_file = include_dir / f"{name}.h"
+                h_file.write_text('\n'.join(h_parts), encoding='utf-8')
+
+                # .cpp file (include/) - implementations
+                cpp_parts = [f'#include "{name}.h"', '']
+                for c in classes:
+                    cpp_parts.append(CodeGenerator.generate_cpp_source(c.node_data))
+                    cpp_parts.append('')
+                for f in functions:
+                    cpp_parts.append(CodeGenerator.generate_cpp_source(f.node_data))
+                    cpp_parts.append('')
+
+                cpp_file = include_dir / f"{name}.cpp"
+                cpp_file.write_text('\n'.join(cpp_parts), encoding='utf-8')
+
+                # .cp file (plugins/) - IncludeCPP plugin entry
+                connected_names = ', '.join(n.node_data.name for n in connected) if connected else 'None'
+                cp_content = f'''// {node.node_data.name} - IncludeCPP Plugin
+// {node.node_data.description or 'Generated by CodeMaker'}
+// Connected elements: {connected_names}
+
+#include "{name}.h"
+
+void {name}_init() {{
+    // Plugin initialization
+}}
+'''
+                cp_file = plugins_dir / f"{name}.cp"
+                cp_file.write_text(cp_content, encoding='utf-8')
+
+                node.node_data.generated_files['plugin'] = str(cp_file)
+                self.status_message.emit(f"Created plugin: {name}.cp, {name}.h, {name}.cpp")
+            except Exception as e:
+                self.status_message.emit(f"Error: {e}")
+
+        def _get_project_path(self) -> Path:
+            """Get the project path from parent window."""
+            for view in self.scene().views():
+                if hasattr(view, 'window') and view.window():
+                    win = view.window()
+                    if hasattr(win, 'project_path'):
+                        return win.project_path
+            return Path.cwd()
+
+        def align_horizontal(self):
+            """Align selected nodes horizontally (same Y position)."""
+            selected = [item for item in self.scene.selectedItems() if isinstance(item, VisualNode)]
+            if len(selected) < 2:
+                self.status_message.emit("Select at least 2 nodes to align")
+                return
+
+            # Use average Y position
+            avg_y = sum(n.pos().y() for n in selected) / len(selected)
+            for node in selected:
+                node.setPos(node.pos().x(), avg_y)
+                node.node_data.y = avg_y
+
+            self.status_message.emit(f"Aligned {len(selected)} nodes horizontally")
+
+        def align_vertical(self):
+            """Align selected nodes vertically (same X position)."""
+            selected = [item for item in self.scene.selectedItems() if isinstance(item, VisualNode)]
+            if len(selected) < 2:
+                self.status_message.emit("Select at least 2 nodes to align")
+                return
+
+            # Use average X position
+            avg_x = sum(n.pos().x() for n in selected) / len(selected)
+            for node in selected:
+                node.setPos(avg_x, node.pos().y())
+                node.node_data.x = avg_x
+
+            self.status_message.emit(f"Aligned {len(selected)} nodes vertically")
+
+        def auto_arrange(self):
+            """Automatically arrange all nodes in a grid layout."""
+            if not self.nodes:
+                return
+
+            nodes_list = list(self.nodes.values())
+            n = len(nodes_list)
+
+            # Calculate grid dimensions
+            cols = max(1, int(n ** 0.5))
+            rows = (n + cols - 1) // cols
+
+            spacing_x = 250
+            spacing_y = 150
+            start_x = -((cols - 1) * spacing_x) / 2
+            start_y = -((rows - 1) * spacing_y) / 2
+
+            for i, node in enumerate(nodes_list):
+                col = i % cols
+                row = i // cols
+                x = start_x + col * spacing_x
+                y = start_y + row * spacing_y
+                node.setPos(x, y)
+                node.node_data.x = x
+                node.node_data.y = y
+
+            self.status_message.emit(f"Arranged {n} nodes in {rows}x{cols} grid")
+
+        def distribute_horizontal(self):
+            """Distribute selected nodes evenly horizontally."""
+            selected = sorted(
+                [item for item in self.scene.selectedItems() if isinstance(item, VisualNode)],
+                key=lambda n: n.pos().x()
+            )
+            if len(selected) < 3:
+                self.status_message.emit("Select at least 3 nodes to distribute")
+                return
+
+            min_x = selected[0].pos().x()
+            max_x = selected[-1].pos().x()
+            spacing = (max_x - min_x) / (len(selected) - 1)
+
+            for i, node in enumerate(selected):
+                new_x = min_x + i * spacing
+                node.setPos(new_x, node.pos().y())
+                node.node_data.x = new_x
+
+            self.status_message.emit(f"Distributed {len(selected)} nodes horizontally")
+
+
+    # ========================================================================
+    # Properties Panel
+    # ========================================================================
+
+    class PropertiesPanel(QFrame):
+        """Dockable panel for editing selected node properties."""
+
+        property_changed = pyqtSignal(str, str, object)  # node_id, property, value
+
+        def __init__(self, parent=None):
+            super().__init__(parent)
+            self.current_node = None
+            self._setup_ui()
+
+        def _setup_ui(self):
+            self.setFixedWidth(260)
+            self.setStyleSheet(f'''
+                QFrame {{
+                    background-color: {THEME['bg_primary']};
+                    border-left: 1px solid {THEME['border']};
+                }}
+            ''')
+
+            layout = QVBoxLayout(self)
+            layout.setContentsMargins(0, 0, 0, 0)
+            layout.setSpacing(0)
+
+            # Header
+            header = QFrame()
+            header.setFixedHeight(40)
+            header.setStyleSheet(f'''
+                QFrame {{
+                    background-color: {THEME['bg_secondary']};
+                    border-bottom: 1px solid {THEME['border']};
+                }}
+            ''')
+            header_layout = QHBoxLayout(header)
+            header_layout.setContentsMargins(12, 0, 12, 0)
+
+            title = QLabel("PROPERTIES")
+            title.setFont(QFont(SYSTEM_FONT, 9, QFont.Weight.Bold))
+            title.setStyleSheet(f'color: {THEME["text_muted"]}; letter-spacing: 1px;')
+            header_layout.addWidget(title)
+            layout.addWidget(header)
+
+            # Content area (scrollable)
+            scroll = QScrollArea()
+            scroll.setWidgetResizable(True)
+            scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
+            scroll.setStyleSheet(f'''
+                QScrollArea {{
+                    background-color: {THEME['bg_primary']};
+                    border: none;
+                }}
+            ''')
+
+            content = QWidget()
+            content.setStyleSheet(f'background-color: {THEME["bg_primary"]};')
+            self.content_layout = QVBoxLayout(content)
+            self.content_layout.setContentsMargins(12, 12, 12, 12)
+            self.content_layout.setSpacing(12)
+
+            # Placeholder text
+            self.placeholder = QLabel("Select a node to edit its properties")
+            self.placeholder.setStyleSheet(f'color: {THEME["text_muted"]}; font-style: italic;')
+            self.placeholder.setWordWrap(True)
+            self.content_layout.addWidget(self.placeholder)
+
+            # Name field
+            self.name_label = QLabel("Name")
+            self.name_label.setStyleSheet(f'color: {THEME["text_secondary"]}; font-size: 10px;')
+            self.name_label.hide()
+            self.content_layout.addWidget(self.name_label)
+
+            self.name_input = QLineEdit()
+            self.name_input.setStyleSheet(f'''
+                QLineEdit {{
+                    background: {THEME['bg_tertiary']};
+                    border: 1px solid {THEME['border']};
+                    border-radius: 4px;
+                    padding: 6px 8px;
+                    color: {THEME['text_primary']};
+                }}
+                QLineEdit:focus {{ border-color: {THEME['accent_blue']}; }}
+            ''')
+            self.name_input.hide()
+            self.name_input.textChanged.connect(self._on_name_changed)
+            self.content_layout.addWidget(self.name_input)
+
+            # Type display
+            self.type_label = QLabel("Type")
+            self.type_label.setStyleSheet(f'color: {THEME["text_secondary"]}; font-size: 10px;')
+            self.type_label.hide()
+            self.content_layout.addWidget(self.type_label)
+
+            self.type_display = QLabel("")
+            self.type_display.setStyleSheet(f'color: {THEME["text_primary"]}; font-weight: bold;')
+            self.type_display.hide()
+            self.content_layout.addWidget(self.type_display)
+
+            # Description field
+            self.desc_label = QLabel("Description")
+            self.desc_label.setStyleSheet(f'color: {THEME["text_secondary"]}; font-size: 10px;')
+            self.desc_label.hide()
+            self.content_layout.addWidget(self.desc_label)
+
+            self.desc_input = QTextEdit()
+            self.desc_input.setMaximumHeight(80)
+            self.desc_input.setStyleSheet(f'''
+                QTextEdit {{
+                    background: {THEME['bg_tertiary']};
+                    border: 1px solid {THEME['border']};
+                    border-radius: 4px;
+                    padding: 6px 8px;
+                    color: {THEME['text_primary']};
+                }}
+                QTextEdit:focus {{ border-color: {THEME['accent_blue']}; }}
+            ''')
+            self.desc_input.hide()
+            self.desc_input.textChanged.connect(self._on_desc_changed)
+            self.content_layout.addWidget(self.desc_input)
+
+            # Code status (for source nodes)
+            self.code_section = QFrame()
+            self.code_section.setStyleSheet(f'''
+                QFrame {{
+                    background: {THEME['bg_secondary']};
+                    border-radius: 6px;
+                    padding: 8px;
+                }}
+            ''')
+            code_layout = QVBoxLayout(self.code_section)
+            code_layout.setContentsMargins(8, 8, 8, 8)
+            code_layout.setSpacing(4)
+
+            code_title = QLabel("CODE STATUS")
+            code_title.setStyleSheet(f'color: {THEME["text_muted"]}; font-size: 9px;')
+            code_layout.addWidget(code_title)
+
+            self.python_status = QLabel("Python: Not created")
+            self.python_status.setStyleSheet(f'color: {THEME["text_secondary"]};')
+            code_layout.addWidget(self.python_status)
+
+            self.plugin_status = QLabel("Plugin: Not created")
+            self.plugin_status.setStyleSheet(f'color: {THEME["text_secondary"]};')
+            code_layout.addWidget(self.plugin_status)
+
+            self.code_section.hide()
+            self.content_layout.addWidget(self.code_section)
+
+            self.content_layout.addStretch()
+
+            scroll.setWidget(content)
+            layout.addWidget(scroll)
+
+        def update_selection(self, node: Optional[VisualNode]):
+            """Update panel to show properties of selected node."""
+            self.current_node = node
+
+            if node is None:
+                self.placeholder.show()
+                self.name_label.hide()
+                self.name_input.hide()
+                self.type_label.hide()
+                self.type_display.hide()
+                self.desc_label.hide()
+                self.desc_input.hide()
+                self.code_section.hide()
+                return
+
+            self.placeholder.hide()
+
+            # Show all fields
+            self.name_label.show()
+            self.name_input.show()
+            self.type_label.show()
+            self.type_display.show()
+            self.desc_label.show()
+            self.desc_input.show()
+
+            # Update values
+            self.name_input.blockSignals(True)
+            self.name_input.setText(node.node_data.name)
+            self.name_input.blockSignals(False)
+
+            node_info = NODE_TYPES.get(node.node_data.node_type, {})
+            self.type_display.setText(node_info.get('label', node.node_data.node_type))
+
+            self.desc_input.blockSignals(True)
+            self.desc_input.setPlainText(node.node_data.description)
+            self.desc_input.blockSignals(False)
+
+            # Code status for source nodes
+            if node.node_data.node_type == 'source':
+                self.code_section.show()
+                py_path = node.node_data.generated_files.get('python', '')
+                plugin_path = node.node_data.generated_files.get('plugin', '')
+
+                if py_path:
+                    self.python_status.setText(f"Python: {Path(py_path).name}")
+                    self.python_status.setStyleSheet(f'color: {THEME["accent_green"]};')
+                else:
+                    self.python_status.setText("Python: Not created")
+                    self.python_status.setStyleSheet(f'color: {THEME["text_secondary"]};')
+
+                if plugin_path:
+                    self.plugin_status.setText(f"Plugin: {Path(plugin_path).name}")
+                    self.plugin_status.setStyleSheet(f'color: {THEME["accent_green"]};')
+                else:
+                    self.plugin_status.setText("Plugin: Not created")
+                    self.plugin_status.setStyleSheet(f'color: {THEME["text_secondary"]};')
+            else:
+                self.code_section.hide()
+
+        def _on_name_changed(self, text):
+            if self.current_node and text:
+                self.current_node.update_name(text)
+
+        def _on_desc_changed(self):
+            if self.current_node:
+                self.current_node.update_description(self.desc_input.toPlainText())
+
 
     # ========================================================================
     # File Tree Panel
@@ -2486,6 +3025,82 @@ if PYQT_AVAILABLE:
             paste_btn.clicked.connect(lambda: self.canvas.paste_nodes() if hasattr(self, 'canvas') else None)
             layout.addWidget(paste_btn)
 
+            layout.addWidget(self._create_separator())
+
+            # Layout/Arrange buttons
+            align_h_btn = QPushButton("Align H")
+            align_h_btn.setStyleSheet(btn_style)
+            align_h_btn.setToolTip("Align selected nodes horizontally")
+            align_h_btn.clicked.connect(lambda: self.canvas.align_horizontal() if hasattr(self, 'canvas') else None)
+            layout.addWidget(align_h_btn)
+
+            align_v_btn = QPushButton("Align V")
+            align_v_btn.setStyleSheet(btn_style)
+            align_v_btn.setToolTip("Align selected nodes vertically")
+            align_v_btn.clicked.connect(lambda: self.canvas.align_vertical() if hasattr(self, 'canvas') else None)
+            layout.addWidget(align_v_btn)
+
+            arrange_btn = QPushButton("Auto-Arrange")
+            arrange_btn.setStyleSheet(btn_style)
+            arrange_btn.setToolTip("Automatically arrange all nodes")
+            arrange_btn.clicked.connect(lambda: self.canvas.auto_arrange() if hasattr(self, 'canvas') else None)
+            layout.addWidget(arrange_btn)
+
+            layout.addWidget(self._create_separator())
+
+            # Quick-add buttons with accent colors
+            source_btn = QPushButton("+ Source")
+            source_btn.setStyleSheet(f'''
+                QPushButton {{
+                    background: {THEME['accent_green']};
+                    border: none;
+                    border-radius: 6px;
+                    color: white;
+                    padding: 6px 12px;
+                    font-size: 11px;
+                    font-weight: bold;
+                }}
+                QPushButton:hover {{
+                    background: #00ff88;
+                }}
+            ''')
+            source_btn.clicked.connect(lambda: self._quick_add_node('source'))
+            layout.addWidget(source_btn)
+
+            class_btn = QPushButton("+ Class")
+            class_btn.setStyleSheet(f'''
+                QPushButton {{
+                    background: {THEME['accent_blue']};
+                    border: none;
+                    border-radius: 6px;
+                    color: white;
+                    padding: 6px 12px;
+                    font-size: 11px;
+                }}
+                QPushButton:hover {{
+                    background: #5abeff;
+                }}
+            ''')
+            class_btn.clicked.connect(lambda: self._quick_add_node('class'))
+            layout.addWidget(class_btn)
+
+            func_btn = QPushButton("+ Function")
+            func_btn.setStyleSheet(f'''
+                QPushButton {{
+                    background: #50c878;
+                    border: none;
+                    border-radius: 6px;
+                    color: white;
+                    padding: 6px 12px;
+                    font-size: 11px;
+                }}
+                QPushButton:hover {{
+                    background: #60d888;
+                }}
+            ''')
+            func_btn.clicked.connect(lambda: self._quick_add_node('function'))
+            layout.addWidget(func_btn)
+
             layout.addStretch()
 
             self.search_input = QLineEdit()
@@ -2635,10 +3250,29 @@ if PYQT_AVAILABLE:
             self.canvas.status_message.connect(
                 lambda msg: self.status_label.setText(msg)
             )
+            # Wire selection changes to properties panel
+            self.canvas.scene.selectionChanged.connect(self._on_selection_changed)
             codemaker_layout.addWidget(self.canvas, 1)
 
+            # Properties panel on the right
+            self.properties_panel = PropertiesPanel()
+            codemaker_layout.addWidget(self.properties_panel)
+
             self.main_stack_layout.addWidget(codemaker)
 
+        def _on_selection_changed(self):
+            """Handle selection change in canvas."""
+            if not hasattr(self, 'canvas') or not hasattr(self, 'properties_panel'):
+                return
+
+            selected = [item for item in self.canvas.scene.selectedItems()
+                       if isinstance(item, VisualNode)]
+
+            if len(selected) == 1:
+                self.properties_panel.update_selection(selected[0])
+            else:
+                self.properties_panel.update_selection(None)
+
         def _load_map(self, file_path: str):
             """Load a map file"""
             try:
@@ -2687,6 +3321,22 @@ if PYQT_AVAILABLE:
         def mouseReleaseEvent(self, event):
             self._drag_pos = None
 
+        def _quick_add_node(self, node_type: str):
+            """Quick-add a node from toolbar button."""
+            if not hasattr(self, 'canvas'):
+                return
+
+            name, ok = QInputDialog.getText(
+                self, f"New {NODE_TYPES[node_type]['label']}",
+                "Name:"
+            )
+            if ok and name:
+                # Add at center of current view
+                center = self.canvas.mapToScene(
+                    self.canvas.viewport().rect().center()
+                )
+                self.canvas.add_node(node_type, name, center.x(), center.y())
+
         def closeEvent(self, event):
             self._save_current()
             super().closeEvent(event)