EG/ui/lui_manager.py

import os
import sys
import struct
from pathlib import Path
import panda3d.core as p3d
from panda3d.core import NodePath, CardMaker
from ui.lui_function import luiFunction

# Ensure ui directory is in path and lui is correctly patched
UI_DIR = Path(__file__).resolve().parent
if str(UI_DIR) not in sys.path:
    sys.path.insert(0, str(UI_DIR))

# Add Builtin to path
BUILTIN_DIR = UI_DIR / "Builtin"
if str(BUILTIN_DIR) not in sys.path:
    sys.path.insert(0, str(BUILTIN_DIR))

# Handle DLL loading for lui.pyd
import panda3d
panda_dir = os.path.dirname(panda3d.__file__)
if hasattr(os, "add_dll_directory"):
    try:
        os.add_dll_directory(panda_dir)
        os.add_dll_directory(str(UI_DIR))
    except Exception as e:
        print(f"Warning: Failed to add DLL directory: {e}")

try:
    import lui
    # Monkey patch for Builtin components
    import panda3d
    panda3d.lui = lui
    sys.modules["panda3d.lui"] = lui
    
    from Builtin.LUIRegion import LUIRegion
    from Builtin.LUIInputHandler import LUIInputHandler
    from Builtin.LUIButton import LUIButton
    from Builtin.LUILabel import LUILabel
    from Builtin.LUIInputField import LUIInputField
    from Builtin.LUISlider import LUISlider
    from Builtin.LUIFrame import LUIFrame
    from Builtin.LUISkin import LUIDefaultSkin
    from Builtin.LUISprite import LUISprite
    from Builtin.LUIObject import LUIObject
except ImportError as e:
    print(f"Error: Failed to import LUI: {e}")
    lui = None

from imgui_bundle import imgui, imgui_ctx

class LUIManager:
    """Manager for LUI system integration"""
    def __init__(self, world):
        self.world = world
        self.lui_enabled = (lui is not None)
        # Always initialize selection fields, even when LUI is unavailable.
        self.selected_index = -1
        self._last_selected_index = -1

        self.luiFunction = luiFunction
        
        # Editor State
        self.show_editor = True
        self.play_mode = False
        self._selected_type_index = 0
        
        if not self.lui_enabled:
            print("LUI is not available, LUIManager will be disabled.")
            return

        # 1. 优先注册中文字体 (必须在皮肤加载前)
        self._register_chinese_font()

        # 2. 初始化核心 LUI 区域
        self._init_ui_regions()
        
        # 3. 加载皮肤资源
        self.lui_skin = LUIDefaultSkin()
        self.lui_skin.load()
        
        # 4. 状态管理 - 与engine保持一致
        self.canvases = []
        self.current_canvas_index = -1
        self.canvas_counter = 0
        self.components = []
        self.root_order = []
        self._tree_drag_src = None
        self.selected_index = -1
        self._last_selected_index = -1
        
        # 拖拽和选择状态
        self.dragging_comp = None
        self.pending_drag_comp = None
        self.pending_drag_index = -1
        self.pending_drag_start_mouse = None
        self.pending_drag_start_abs = None
        self.pending_drag_start_parent = None
        self.dragging_index = -1
        self.drag_start_threshold = 6.0
        self.drag_offset = (0, 0)
        
        # 锚点功能相关变量
        self.anchor_popup_open = False
        self.pending_child_creation = False
        self.pending_parent_index = -1
        
        # 子父对齐功能
        self.child_parent_alignment_enabled = True
        
        # Resize handles 相关变量
        self.resize_handles = []
        self.selection_box = []
        self.debug_outlines = {}  # comp_index -> [border sprites]
        self.resizing_handle = None
        self.resize_start_pos = (0, 0)
        self.resize_start_bounds = {}
        self.min_size = 20
        
        # 使用外部字典管理状态，避免修改 C++ 对象属性导致 AttributeError
        self.drag_states = {} 
        self._last_interaction_frame = -1 # 记录最后一次交互的帧数，用于防止事件穿透 
        self._input_enabled = True
        
        # 创建resize handles和selection box（延迟创建，确保在Canvas之后）
        if hasattr(self.world, 'taskMgr'):
            self.world.taskMgr.doMethodLater(0.1, self._delayed_create_resize_handles, "delayed_create_resize_handles")
        else:
            self._create_resize_handles()
        
        # 添加任务来处理拖动和resize handles更新
        if hasattr(self.world, 'taskMgr'):
            self.world.taskMgr.add(self._update_drag, "update_lui_drag")
            self.world.taskMgr.add(self._update_resize_handles, "update_resize_handles")
            self.world.taskMgr.add(self._update_component_outlines, "update_lui_outlines")
        
        print("✓ LUIManager initialized with complete functionality")

    def set_input_enabled(self, enabled):
        """Enable/disable LUI input handling (used to avoid ImGui click-through)."""
        if not self.lui_enabled:
            return

        if enabled == self._input_enabled:
            return

        self._input_enabled = enabled

        try:
            if enabled:
                if hasattr(self, "overlay_handler_node") and self.overlay_handler_node:
                    self.overlay_handler_node.reparent_to(self.world.mouseWatcher)
                if hasattr(self, "overlay_region") and self.overlay_region:
                    self.overlay_region.set_input_handler(self.overlay_handler)
            else:
                if hasattr(self, "overlay_region") and self.overlay_region:
                    self.overlay_region.set_input_handler(None)
                if hasattr(self, "overlay_handler_node") and self.overlay_handler_node:
                    self.overlay_handler_node.detach_node()
        except Exception as e:
            print(f"Warning: Failed to toggle LUI input state: {e}")

    def _register_chinese_font(self):
        """注册支持中文的字体"""
        from panda3d.lui import LUIFontPool
        import os
        
        # 尝试常见的系统路径，确保使用完整的 OS 路径
        candidate_fonts = [
            "C:/Windows/Fonts/msyh.ttc",
            "C:/Windows/Fonts/simhei.ttf",
            "C:/Windows/Fonts/arial.ttf"
        ]
        
        font_registered = False
        for fpath in candidate_fonts:
            if os.path.exists(fpath):
                try:
                    # 在 LUI 中，建议直接用 loader.loadFont 载入后获取动态库指针
                    # 或者直接传递路径字符串
                    font = self.world.loader.loadFont(fpath)
                    if font:
                        LUIFontPool.get_global_ptr().register_font("default", font)
                        LUIFontPool.get_global_ptr().register_font("label", font)
                        print(f"✓ LUI 成功注册字体: {fpath}")
                        font_registered = True
                        break
                except Exception as e:
                    print(f"LUI 字体注册失败 {fpath}: {e}")
        
        if not font_registered:
            # 如果没有系统字体，至少注册一个默认的避免崩溃
            print("⚠️ 警告: 未能找到合适的 LUI 中文字体")

    def _init_ui_regions(self):
        """初始化 LUI 区域 (Overlay, Camera, WorldSpace)"""
        # 渲染层级说明（参考engine/main.py的设置）：
        # - 3D场景（render）默认sort=0
        # - LUI组件设置sort=5，在3D场景之上
        # - pixel2d (ImGui) 默认sort=20，在LUI之上
        # 这样：3D场景 < LUI组件 < ImGui面板
        
        self.overlay_region = LUIRegion.make("OverlayUI", self.world.win)
        self.overlay_handler = LUIInputHandler()
        self.overlay_handler_node = self.world.mouseWatcher.attach_new_node(self.overlay_handler)
        self.overlay_region.set_input_handler(self.overlay_handler)
        self.overlay_region.set_sort(5)  # 在3D场景之上，在ImGui之下（与engine保持一致）
        self.overlay_root = self.overlay_region.root
        
        # 调试输出：确认层级设置
        actual_sort = self.overlay_region.getSort()
        print(f"✓ LUI Overlay Region 层级设置: {actual_sort}")
        
        # 显示所有DisplayRegion的层级信息
        num_regions = self.world.win.getNumDisplayRegions()
        print(f"✓ 窗口总共有 {num_regions} 个DisplayRegion:")
        for i in range(num_regions):
            dr = self.world.win.getDisplayRegion(i)
            sort_value = dr.getSort()
            camera = dr.getCamera()
            camera_name = camera.getName() if not camera.isEmpty() else "无摄像机"
            print(f"  Region {i}: sort={sort_value}, camera={camera_name}")

        # 当前操作的根节点
        self.root = self.overlay_root

    def _make_canvas_draggable(self, canvas_panel):
        """使Canvas可拖拽"""
        def on_canvas_drag_start(event):
            # 检查是否有组件或手柄在当前帧被点击
            current_frame = 0
            if hasattr(p3d, 'ClockObject'):
                current_frame = p3d.ClockObject.getGlobalClock().getFrameCount()
            else:
                current_frame = self.world.taskMgr.globalClock.getFrameCount()
                
            if self._last_interaction_frame == current_frame:
                # 当前帧已经处理了组件或手柄的点击，忽略Canvas点击事件
                return
            
            # 点击空白处：不自动取消选中，避免事件穿透导致闪退
            # self.deselect_all()
            
            # 如果启用填充模式，则自动禁用，以便用户可以自由拖动
            canvas_index = -1
            for i, c in enumerate(self.canvases):
                if c['panel'] == canvas_panel:
                    canvas_index = i
                    break
            
            if canvas_index >= 0:
                canvas_data = self.canvases[canvas_index]
                
                # 如果是固定模式，则禁止拖动初始化
                if canvas_data.get('fixed', False):
                    return

                if canvas_data.get('fill_mode', False):
                    canvas_data['fill_mode'] = False
                    print("✓ 自动禁用填充模式以允许自由拖动")

            # 记录Canvas拖拽状态
            if hasattr(self.world, 'mouseWatcherNode') and self.world.mouseWatcherNode.hasMouse():
                mouse_x = self.world.mouseWatcherNode.getMouseX()
                mouse_y = self.world.mouseWatcherNode.getMouseY()
                
                win_x = self.world.win.getXSize()
                win_y = self.world.win.getYSize()
                pixel_x = (mouse_x + 1) * win_x / 2
                pixel_y = (1 - mouse_y) * win_y / 2
                
                pos = canvas_panel.get_pos()
                self.canvas_drag_offset = (pixel_x - pos.x, pixel_y - pos.y)
                self.dragging_canvas = canvas_panel
        
        canvas_panel.bind("mousedown", on_canvas_drag_start)

    def switch_canvas(self, index):
        """切换到指定Canvas并显示/隐藏相应的UI组件"""
        if index < 0 or index >= len(self.canvases):
            return
            
        self.current_canvas_index = index
        
        # 显示选中的Canvas，隐藏其他Canvas
        for i, canvas in enumerate(self.canvases):
            if i == index:
                canvas['panel'].show()
                canvas['visible'] = True
            else:
                canvas['panel'].hide()
                canvas['visible'] = False
        
        # 显示/隐藏属于不同Canvas的组件（包括子组件）
        visible_count = 0
        hidden_count = 0
        
        for comp in self.components:
            comp_canvas_index = comp.get('canvas_index')
            comp_obj = comp['object']
            comp_name = comp.get('name', 'Unknown')
            
            should_be_visible = (comp_canvas_index == index)
            
            if should_be_visible:
                if hasattr(comp_obj, 'show'):
                    comp_obj.show()
                elif hasattr(comp_obj, 'visible'):
                    comp_obj.visible = True
                visible_count += 1
            else:
                if hasattr(comp_obj, 'hide'):
                    comp_obj.hide()
                elif hasattr(comp_obj, 'visible'):
                    comp_obj.visible = False
                hidden_count += 1
        
        # 更新当前根节点
        if index >= 0:
            self.root = self.canvases[index]['panel']
        
        # 如果选中的组件不属于当前Canvas，取消选中
        if self.selected_index >= 0 and self.selected_index < len(self.components):
            selected_comp = self.components[self.selected_index]
            if selected_comp.get('canvas_index') != index:
                if getattr(self, '_force_keep_selection_frames', 0) > 0:
                    pass
                else:
                    self.selected_index = -1
                    self._hide_selection()
        
        print(f"✓ Switched to Canvas: {self.canvases[index]['name']}")
        print(f"  显示组件: {visible_count}, 隐藏组件: {hidden_count}")

    def _update_canvas_geometry(self, canvas_data):
        """根据填充模式和边距更新Canvas几何信息"""
        if not canvas_data.get('fill_mode', False):
            return

        panel = canvas_data['panel']
        margins = canvas_data.get('margins', {'left':0,'right':0,'top':0,'bottom':0})
        
        win_width = 800
        win_height = 600
        if hasattr(self.world, 'win'):
            win_width = self.world.win.getXSize()
            win_height = self.world.win.getYSize()
            
        new_x = margins['left']
        new_y = margins['top']
        new_width = max(10, win_width - margins['left'] - margins['right'])
        new_height = max(10, win_height - margins['top'] - margins['bottom'])
        
        panel.set_pos(new_x, new_y)
        panel.width = new_width
        panel.height = new_height
        
        if 'background' in canvas_data:
            bg = canvas_data['background']
            bg.width = new_width
            bg.height = new_height

    def _setup_component_drag(self, comp_data, comp_index):
        """为组件设置拖动功能 - 支持Canvas相对坐标系"""
        comp_obj = comp_data['object']
        
        def on_mouse_down(event):
            comp_type = comp_data.get('type')
            if getattr(self, 'play_mode', False):
                # Let runtime widgets handle their own events (especially Slider)
                if comp_type == 'Slider':
                    return
                try:
                    if hasattr(comp_obj, 'on_mousedown'):
                        comp_obj.on_mousedown(event)
                except Exception:
                    pass
                return
            # Prevent re-entrant drag
            if self.dragging_comp is not None:
                return

            # Find current index
            current_index = -1
            for i, c in enumerate(self.components):
                if c is comp_data:
                    current_index = i
                    break

            if current_index == -1:
                return

            # Mark interaction frame
            if hasattr(p3d, 'ClockObject'):
                self._last_interaction_frame = p3d.ClockObject.getGlobalClock().getFrameCount()
            else:
                self._last_interaction_frame = self.world.taskMgr.globalClock.getFrameCount()

            # Select component
            self.selected_index = current_index
            self._last_selected_index = current_index
            self._force_keep_selection_frames = 3

            # Force component to current canvas to avoid immediate deselect
            try:
                comp_data['canvas_index'] = self.current_canvas_index
            except Exception:
                pass

            try:
                if comp_data.get('canvas_index') is None:
                    comp_data['canvas_index'] = self.current_canvas_index
            except Exception:
                pass
            try:
                self._show_and_update_handles(comp_data)
            except Exception:
                pass

            # Slider: allow knob/bar drag in edit mode without hijacking
            if comp_type == 'Slider':
                sender = getattr(event, 'sender', None)
                knob = getattr(comp_obj, '_knob', None)
                bg = getattr(comp_obj, '_slider_bg', None)
                if sender is not None and (sender == knob or sender == bg):
                    # Let slider handle its own drag logic
                    try:
                        if hasattr(comp_obj, '_start_drag'):
                            comp_obj._start_drag(event)
                    except Exception:
                        pass
                    return

            parent_idx = comp_data.get('parent_index')
            if parent_idx is not None and parent_idx >= 0:
                parent_type = self.components[parent_idx].get('type')
                if parent_type in ['VerticalLayout', 'HorizontalLayout']:
                    return

            if not comp_data.get('draggable', True):
                return

            self.pending_drag_comp = comp_data
            self.pending_drag_index = current_index
            self.pending_drag_start_abs = self._get_component_accumulated_pos(current_index)
            self.pending_drag_start_parent = comp_obj.parent
            self._is_drag_reparented = False

            if hasattr(self.world, 'mouseWatcherNode') and self.world.mouseWatcherNode.hasMouse():
                mouse_x = self.world.mouseWatcherNode.getMouseX()
                mouse_y = self.world.mouseWatcherNode.getMouseY()

                win_x = self.world.win.getXSize()
                win_y = self.world.win.getYSize()
                pixel_x = (mouse_x + 1) * win_x / 2
                pixel_y = (1 - mouse_y) * win_y / 2
                self.pending_drag_start_mouse = (pixel_x, pixel_y)
            else:
                self.pending_drag_start_mouse = None

        # Bind mouse event
        comp_obj.bind("mousedown", on_mouse_down)

        # Slider selection bindings: allow clicking knob/bar to select in edit mode
        try:
            if comp_data.get('type') == 'Slider':
                knob = getattr(comp_obj, '_knob', None)
                bg = getattr(comp_obj, '_slider_bg', None)
        except Exception:
            pass

        def on_mouse_up(event):
            if getattr(self, 'play_mode', False):
                try:
                    if hasattr(comp_obj, 'on_mouseup'):
                        comp_obj.on_mouseup(event)
                except Exception:
                    pass
                return

            if comp_data.get('type') == 'Slider':
                sender = getattr(event, 'sender', None)
                knob = getattr(comp_obj, '_knob', None)
                if sender is not None and sender == knob:
                    try:
                        if hasattr(comp_obj, '_stop_drag'):
                            comp_obj._stop_drag(event)
                    except Exception:
                        pass

        comp_obj.bind("mouseup", on_mouse_up)

    def _make_draggable(self, lui_obj):
        """启用 LUI 对象的鼠标拖拽功能 - 兼容旧接口"""
        # 查找对应的组件索引
        comp_index = -1
        for i, comp in enumerate(self.components):
            if comp.get('object') == lui_obj:
                comp_index = i
                break
        
        if comp_index >= 0:
            self._setup_component_drag(self.components[comp_index], comp_index)

    def _get_component_accumulated_pos(self, comp_index):
        """递归计算组件相对于Canvas的累积位置"""
        if comp_index < 0 or comp_index >= len(self.components):
            return 0, 0
            
        comp_data = self.components[comp_index]
        comp_obj = comp_data['object']
        
        # 优先使用递归计算（更可靠）
        left = comp_data.get('left', 0)
        top = comp_data.get('top', 0)
        
        parent_index = comp_data.get('parent_index')
        if parent_index is not None and parent_index >= 0:
            parent_left, parent_top = self._get_component_accumulated_pos(parent_index)
            result_x = parent_left + left
            result_y = parent_top + top
            print(f"[_get_component_accumulated_pos] Component #{comp_index} (has parent #{parent_index}): local=({left:.1f}, {top:.1f}), parent_offset=({parent_left:.1f}, {parent_top:.1f}), result=({result_x:.1f}, {result_y:.1f})")
            return result_x, result_y
        
        # 没有父组件，直接返回局部坐标（相对于Canvas）
        print(f"[_get_component_accumulated_pos] Component #{comp_index} (root): local=({left:.1f}, {top:.1f})")
        return left, top

    def _update_drag(self, task):
        """每帧更新拖动状态 - 支持Canvas边界约束和局部坐标"""
        if getattr(self, 'play_mode', False):
            # Disable editor drag logic while in play mode
            return task.cont

        # 1. 处理Canvas拖动
        if hasattr(self, 'dragging_canvas') and self.dragging_canvas:
            # 查找对应的Canvas数据
            canvas_data = None
            for c in self.canvases:
                if c['panel'] == self.dragging_canvas:
                    canvas_data = c
                    break
            
            # 检查Canvas是否锁定
            if canvas_data and canvas_data.get('fixed', False):
                return task.cont

            if not hasattr(self.world, 'mouseWatcherNode') or not self.world.mouseWatcherNode.hasMouse():
                return task.cont
                
            import panda3d.core as p3d
            if not self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one()):
                self.dragging_canvas = None
                return task.cont

            mouse_x = self.world.mouseWatcherNode.getMouseX()
            mouse_y = self.world.mouseWatcherNode.getMouseY()
            
            win_x = self.world.win.getXSize()
            win_y = self.world.win.getYSize()
            pixel_x = (mouse_x + 1) * win_x / 2
            pixel_y = (1 - mouse_y) * win_y / 2
            
            new_x = pixel_x - self.canvas_drag_offset[0]
            new_y = pixel_y - self.canvas_drag_offset[1]
            
            self.dragging_canvas.set_pos(new_x, new_y)
            return task.cont

        # 2. 处理组件拖动
        if self.dragging_comp is None:
            # Pending drag: only start after threshold
            if self.pending_drag_comp is None:
                return task.cont

            if not hasattr(self.world, 'mouseWatcherNode') or not self.world.mouseWatcherNode.hasMouse():
                return task.cont

            import panda3d.core as p3d
            if not self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one()):
                # click without drag
                self.pending_drag_comp = None
                self.pending_drag_index = -1
                self.pending_drag_start_mouse = None
                self.pending_drag_start_abs = None
                self.pending_drag_start_parent = None
                return task.cont

            mouse_x = self.world.mouseWatcherNode.getMouseX()
            mouse_y = self.world.mouseWatcherNode.getMouseY()
            win_x = self.world.win.getXSize()
            win_y = self.world.win.getYSize()
            pixel_x = (mouse_x + 1) * win_x / 2
            pixel_y = (1 - mouse_y) * win_y / 2

            if self.pending_drag_start_mouse is None:
                self.pending_drag_start_mouse = (pixel_x, pixel_y)
                return task.cont

            dx = pixel_x - self.pending_drag_start_mouse[0]
            dy = pixel_y - self.pending_drag_start_mouse[1]
            if (dx * dx + dy * dy) < (self.drag_start_threshold * self.drag_start_threshold):
                return task.cont

            # Start drag now
            comp_data = self.pending_drag_comp
            self.dragging_comp = comp_data
            self.dragging_index = self.pending_drag_index
            self._original_parent_obj = self.pending_drag_start_parent
            self._is_drag_reparented = False

            acc_left, acc_top = self.pending_drag_start_abs
            if acc_left is None or acc_top is None:
                acc_left, acc_top = self._get_component_accumulated_pos(self.pending_drag_index)

            # If child, reparent to canvas for free drag
            p_idx = comp_data.get('parent_index')
            if p_idx is not None and p_idx >= 0 and self.current_canvas_index >= 0:
                canvas_panel = self.canvases[self.current_canvas_index]['panel']
                comp_obj = comp_data['object']
                if not comp_data.get('visual_parent_canvas'):
                    try:
                        if getattr(comp_obj, 'parent', None) == canvas_panel:
                            pass
                        elif hasattr(comp_obj, 'reparent_to'):
                            comp_obj.reparent_to(canvas_panel)
                            if hasattr(comp_obj, 'set_pos'):
                                comp_obj.set_pos(acc_left, acc_top)
                            else:
                                comp_obj.left = acc_left
                                comp_obj.top = acc_top
                            self._is_drag_reparented = True
                    except Exception:
                        pass

            # Compute drag offset
            canvas_abs_left = 0
            canvas_abs_top = 0
            if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
                canvas_panel = self.canvases[self.current_canvas_index]['panel']
                canvas_abs_left = getattr(canvas_panel, 'left', 0)
                canvas_abs_top = getattr(canvas_panel, 'top', 0)
                if canvas_abs_left == 0 and canvas_abs_top == 0:
                    try:
                        canvas_pos = canvas_panel.get_pos()
                        canvas_abs_left = canvas_pos.x
                        canvas_abs_top = canvas_pos.y
                    except:
                        canvas_abs_left = 300
                        canvas_abs_top = 100

            comp_abs_left = canvas_abs_left + acc_left
            comp_abs_top = canvas_abs_top + acc_top
            self.drag_offset = (pixel_x - comp_abs_left, pixel_y - comp_abs_top)

            # Clear pending state
            self.pending_drag_comp = None
            self.pending_drag_index = -1
            self.pending_drag_start_mouse = None
            self.pending_drag_start_abs = None
            self.pending_drag_start_parent = None

            # Continue with drag in same frame

        
        # 检查鼠标状态
        if not hasattr(self.world, 'mouseWatcherNode') or not self.world.mouseWatcherNode.hasMouse():
            return task.cont
        
        # 检查鼠标左键是否释放
        import panda3d.core as p3d
        if not self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one()):
            if self.dragging_comp:
                comp_data = self.dragging_comp
                print(f"组件移动到: left={comp_data.get('left', 0):.1f}, top={comp_data.get('top', 0):.1f} (局部坐标)")
                
                # 拖动结束：检查是否需要接触父子关系 (Auto-unparent)
                should_unparent = False
                if getattr(self, '_is_drag_reparented', False):
                     comp_obj = comp_data['object']
                     
                     # Check if center of component is outside parent bounds
                     p_idx = comp_data.get('parent_index')
                     if p_idx is not None and p_idx >= 0:
                         parent_data = self.components[p_idx]
                         p_w = parent_data.get('width', 100)
                         p_h = parent_data.get('height', 100)
                         
                         c_w = comp_data.get('width', 0)
                         c_h = comp_data.get('height', 0)
                         
                         # Current comp_data['left'] is LOCAL to parent
                         local_l = comp_data.get('left', 0)
                         local_t = comp_data.get('top', 0)
                         
                         center_x = local_l + c_w / 2
                         center_y = local_t + c_h / 2
                         
                         # Check bounds: center must be in 0..p_w, 0..p_h
                         # Allow some leniency or strict? Let's say if center is outside, unparent.
                         if center_x < 0 or center_x > p_w or center_y < 0 or center_y > p_h:
                             should_unparent = True

                     if should_unparent:
                          # Unparent!
                          # The component is currently visually attached to Canvas (from drag start)
                          # We just need to update the data to reflect this permanent change.
                          
                          # Calculate the new global (canvas-relative) position
                          # current local + parent offset
                          p_off_x, p_off_y = self._get_component_accumulated_pos(p_idx)
                          new_canvas_left = local_l + p_off_x
                          new_canvas_top = local_t + p_off_y
                          
                          comp_data['left'] = new_canvas_left
                          comp_data['top'] = new_canvas_top
                          
                          # Remove parent linkage
                          if 'parent_index' in comp_data:
                              del comp_data['parent_index']
                          if 'anchored_to_parent' in comp_data:
                              del comp_data['anchored_to_parent']
                              
                          print(f"✓ Auto-unparented component from #{p_idx} (Dragged out)")
                          
                     elif hasattr(comp_obj, 'reparent_to') and hasattr(self, '_original_parent_obj'):
                          comp_obj.reparent_to(self._original_parent_obj)
                          # 重新应用计算出的局部坐标
                          comp_obj.left = comp_data.get('left', 0)
                          comp_obj.top = comp_data.get('top', 0)
                          print(f"✓ 组件归位到逻辑父级")
                
                self.dragging_comp = None
            return task.cont
        
        # 获取鼠标位置
        mouse_x = self.world.mouseWatcherNode.getMouseX()
        mouse_y = self.world.mouseWatcherNode.getMouseY()
        
        # 转换为像素坐标
        win_x = self.world.win.getXSize()
        win_y = self.world.win.getYSize()
        pixel_x = (mouse_x + 1) * win_x / 2
        pixel_y = (1 - mouse_y) * win_y / 2
        
        # 计算新的绝对位置（减去偏移量）
        new_abs_left = pixel_x - self.drag_offset[0]
        new_abs_top = pixel_y - self.drag_offset[1]
        
        # 获取Canvas信息
        canvas_abs_left = 0
        canvas_abs_top = 0
        canvas_width = 800
        canvas_height = 600
        
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas_data = self.canvases[self.current_canvas_index]
            canvas_panel = canvas_data['panel']
            
            # 获取Canvas的绝对位置
            canvas_abs_left = getattr(canvas_panel, 'left', 0)
            canvas_abs_top = getattr(canvas_panel, 'top', 0)
            
            if canvas_abs_left == 0 and canvas_abs_top == 0:
                try:
                    pos = canvas_panel.get_pos()
                    canvas_abs_left = pos.x
                    canvas_abs_top = pos.y
                except:
                    # 如果获取失败，使用默认值
                    canvas_abs_left = canvas_data.get('margins', {}).get('left', 240)
                    canvas_abs_top = canvas_data.get('margins', {}).get('top', 89)
            
            # 获取Canvas的实际尺寸
            try:
                if hasattr(canvas_panel, 'width') and canvas_panel.width is not None:
                    canvas_width = float(canvas_panel.width)
                elif hasattr(canvas_panel, 'get_width'):
                    canvas_width = float(canvas_panel.get_width())
                    
                if hasattr(canvas_panel, 'height') and canvas_panel.height is not None:
                    canvas_height = float(canvas_panel.height)
                elif hasattr(canvas_panel, 'get_height'):
                    canvas_height = float(canvas_panel.get_height())
            except Exception as e:
                print(f"Warning: Failed to get canvas size: {e}")
                # 使用窗口尺寸减去边距作为后备
                margins = canvas_data.get('margins', {'left': 240, 'right': 480, 'top': 89, 'bottom': 220})
                canvas_width = win_x - margins.get('left', 0) - margins.get('right', 0)
                canvas_height = win_y - margins.get('top', 0) - margins.get('bottom', 0)
        
        # 转换为Canvas相对坐标 (Global Canvas Pos)
        canvas_relative_left = new_abs_left - canvas_abs_left
        canvas_relative_top = new_abs_top - canvas_abs_top

        # 获取当前拖拽的组件数据
        comp_data = self.dragging_comp
        comp_obj = comp_data['object']

        # 获取组件宽高 (用于边界限制)
        comp_width = comp_data.get('width', 0)
        comp_height = comp_data.get('height', 0)
        
        # 尝试从对象获取更准确的宽高
        if hasattr(comp_obj, 'width') and comp_obj.width is not None and comp_obj.width > 0:
            comp_width = comp_obj.width
        if hasattr(comp_obj, 'height') and comp_obj.height is not None and comp_obj.height > 0:
            comp_height = comp_obj.height

        # 限制在Canvas范围内
        # 确保左边界不小于0
        if canvas_relative_left < 0:
            canvas_relative_left = 0
            
        # 确保上边界不小于0 
        if canvas_relative_top < 0:
            canvas_relative_top = 0
            
        # 确保右边界不超出Canvas宽度
        if canvas_relative_left + comp_width > canvas_width:
            canvas_relative_left = max(0, canvas_width - comp_width)
            
        # 确保下边界不超出Canvas高度
        if canvas_relative_top + comp_height > canvas_height:
            canvas_relative_top = max(0, canvas_height - comp_height)
        
        # 如果有父组件，需要转换为相对于父组件的局部坐标
        comp_data = self.dragging_comp
        parent_index = comp_data.get('parent_index')
        parent_offset_x = 0
        parent_offset_y = 0
        
        if parent_index is not None and parent_index >= 0:
            # 获取父组件相对于Canvas的累积位置
            parent_offset_x, parent_offset_y = self._get_component_accumulated_pos(parent_index)
            
        # 计算新的局部坐标
        new_local_left = canvas_relative_left - parent_offset_x
        new_local_top = canvas_relative_top - parent_offset_y
        
        # 如果物理上已脱离父级（挂在Canvas上），则物理坐标就是Canvas相对坐标
        comp_obj = comp_data['object']
        if getattr(self, '_is_drag_reparented', False):
            # 子组件被重定向到Canvas，使其可以移动到负数局部坐标（即父组件外侧）
            if hasattr(comp_obj, 'set_pos'):
                comp_obj.set_pos(canvas_relative_left, canvas_relative_top)
            else:
                comp_obj.left = canvas_relative_left
                comp_obj.top = canvas_relative_top
            # print(f"Dragging Child (Canvas Rel): {canvas_relative_left:.1f}, {canvas_relative_top:.1f} | Local: {new_local_left:.1f}, {new_local_top:.1f}")
        else:
            # If visual parent is canvas, keep world position while storing local
            if comp_data.get('visual_parent_canvas'):
                abs_left = parent_offset_x + new_local_left
                abs_top = parent_offset_y + new_local_top
                if hasattr(comp_obj, 'set_pos'):
                    comp_obj.set_pos(abs_left, abs_top)
                else:
                    comp_obj.left = abs_left
                    comp_obj.top = abs_top
            else:
                if hasattr(comp_obj, 'set_pos'):
                    comp_obj.set_pos(new_local_left, new_local_top)
                else:
                    comp_obj.left = new_local_left
                    comp_obj.top = new_local_top
            
        # 更新存储的逻辑坐标数据 (保持始终相对于逻辑父级)
        comp_data['left'] = new_local_left
        comp_data['top'] = new_local_top

        # Sync visually-canvas children for non-container parents
        if self.dragging_index is not None and self.dragging_index >= 0:
            self._sync_canvas_children(self.dragging_index)
        
        return task.cont

    def _create_resize_handles(self):
        """创建选择框和8个resize手柄"""
        from Builtin.LUISprite import LUISprite
        from Builtin.LUIObject import LUIObject
        
        print("开始创建resize handles...")
        
        # 先创建4条选择框边线（蓝色，2px宽）
        for i in range(4):
            border = LUISprite(self.overlay_root, "blank", "skin")
            border.color = (0.2, 0.5, 1.0, 1.0)  # 蓝色
            border.visible = False
            
            # 设置选择框层级，在组件之上但在LUI内部
            if hasattr(border, 'z_offset'):
                border.z_offset = 40  # 选中框在普通边框(25)之上
            elif hasattr(border, 'set_sort'):
                border.set_sort(40)
            
            # 确保边框在最后创建，这样在渲染顺序上会在前面
            self.selection_box.append(border)
        
        # 最后创建8个resize手柄（白色圆形，蓝色边框）
        handle_positions = [
            'top-left', 'top', 'top-right', 'right',
            'bottom-right', 'bottom', 'bottom-left', 'left'
        ]
        
        for i, pos in enumerate(handle_positions):
            # 创建容器对象用于接收鼠标事件
            handle_container = LUIObject(parent=self.overlay_root)
            handle_container.width = 10
            handle_container.height = 10
            handle_container.solid = True
            handle_container.visible = False
            
            # 设置手柄层级，在选择框之上但在LUI内部
            if hasattr(handle_container, 'z_offset'):
                handle_container.z_offset = 50  # 在选择框之上
            elif hasattr(handle_container, 'set_sort'):
                handle_container.set_sort(50)  # 在选择框之上
            
            # 创建蓝色边框（外圈）
            handle_border = LUISprite(handle_container, "blank", "skin")
            handle_border.width = 10
            handle_border.height = 10
            handle_border.left = 0
            handle_border.top = 0
            handle_border.color = (0.2, 0.5, 1.0, 1.0)  # 蓝色边框
            
            # 创建白色圆形背景（内圈）
            handle_bg = LUISprite(handle_container, "blank", "skin")
            handle_bg.width = 8
            handle_bg.height = 8
            handle_bg.left = 1
            handle_bg.top = 1
            handle_bg.color = (1.0, 1.0, 1.0, 1.0)  # 白色
            
            # 存储手柄位置信息
            handle_container._resize_position = pos
            handle_container._resize_index = i
            handle_container._bg = handle_bg
            handle_container._border = handle_border
            
            # 绑定鼠标事件
            handle_container.bind("mousedown", lambda event, h=handle_container: self._on_handle_mousedown(event, h))
            
            self.resize_handles.append(handle_container)
        
        print(f"✓ 创建了{len(self.selection_box)}条边框和{len(self.resize_handles)}个手柄")
        
        # 强制将手柄移到最前面（在LUI中，后创建的元素通常在前面）
        for handle in self.resize_handles:
            # 尝试重新设置父节点来强制更新渲染顺序
            if hasattr(handle, 'reparent_to'):
                handle.reparent_to(self.overlay_root)
        
        for border in self.selection_box:
            if hasattr(border, 'reparent_to'):
                border.reparent_to(self.overlay_root)

    def _delayed_create_resize_handles(self, task):
        """延迟创建resize handles，确保在Canvas之后创建"""
        self._create_resize_handles()
        return task.done

    def _on_handle_mousedown(self, event, handle):
        """手柄鼠标按下事件"""
        # 标记交互帧，防止Canvas点击事件触发取消选中
        if hasattr(p3d, 'ClockObject'):
             self._last_interaction_frame = p3d.ClockObject.getGlobalClock().getFrameCount()
        else:
             # Fallback if specific import not avail in this scope (though p3d is imported)
             self._last_interaction_frame = self.world.taskMgr.globalClock.getFrameCount()

        if self.selected_index < 0:
            return

        comp_data = self.components[self.selected_index]
        print(f"✓ 开始resize: 手柄位置={handle._resize_position}")

        # 记录开始调整大小的状态
        self.resizing_handle = handle

        # 获取鼠标位置
        if hasattr(self.world, 'mouseWatcherNode') and self.world.mouseWatcherNode.hasMouse():
            mouse_x = self.world.mouseWatcherNode.getMouseX()
            mouse_y = self.world.mouseWatcherNode.getMouseY()

            win_x = self.world.win.getXSize()
            win_y = self.world.win.getYSize()
            pixel_x = (mouse_x + 1) * win_x / 2
            pixel_y = (1 - mouse_y) * win_y / 2

            self.resize_start_pos = (pixel_x, pixel_y)

        # 记录组件的初始边界
        self.resize_start_bounds = {
            'left': comp_data.get('left', 0),
            'top': comp_data.get('top', 0),
            'width': comp_data.get('width', 100),
            'height': comp_data.get('height', 30),
        }

    def _update_resize_handles(self, task):
        # Restore selection if it was cleared immediately
        if self.selected_index < 0 and getattr(self, '_force_keep_selection_frames', 0) > 0:
            if getattr(self, '_last_selected_index', -1) >= 0:
                self.selected_index = self._last_selected_index

        if getattr(self, '_force_keep_selection_frames', 0) > 0:
            self._force_keep_selection_frames -= 1

        """更新resize handles的位置和可见性"""
        # 检查当前Canvas是否可见
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas = self.canvases[self.current_canvas_index]
            if not canvas.get('visible', True):
                 self._hide_resize_handles()
                 return task.cont

        if self.selected_index < 0 or self.selected_index >= len(self.components):
            # 隐藏所有handles
            self._hide_resize_handles()
            return task.cont
        
        comp_data = self.components[self.selected_index]
        comp_type = comp_data['type']
        
        # 只对Frame、Button、Slider、InputField、Plane、Image显示resize handles
        if comp_type not in ['Frame', 'Button', 'Slider', 'InputField', 'Plane', 'Image', 'Checkbox', 'Text', 'Label', 'Video', 'Progressbar', 'Selectbox', 'ScrollableRegion', 'TabbedFrame', 'VerticalLayout', 'HorizontalLayout']:
            self._hide_resize_handles()
            return task.cont
        
        # 显示并更新handles位置
        self._show_and_update_handles(comp_data)
        
        # 处理resize拖拽
        if self.resizing_handle is not None:
            self._handle_resize_drag()
        
        return task.cont

    def _hide_resize_handles(self):
        """隐藏所有resize handles和selection box"""
        for border in self.selection_box:
            border.visible = False
        for handle in self.resize_handles:
            handle.visible = False

    def _ensure_component_outline(self, comp_index):
        'Create a simple 4-edge outline for a component if not exists.'
        if comp_index in self.debug_outlines:
            return self.debug_outlines[comp_index]

        from Builtin.LUISprite import LUISprite

        borders = []
        for _ in range(4):
            border = LUISprite(self.overlay_root, "blank", "skin")
            border.color = (0.2, 0.7, 1.0, 1.0)
            border.visible = False
            
            # Ensure outline is above components
            if hasattr(border, 'z_offset'):
                border.z_offset = 25
            elif hasattr(border, 'set_sort'):
                border.set_sort(25)
                
            borders.append(border)

        self.debug_outlines[comp_index] = borders
        return borders

    def _update_component_outlines(self, task):
        'Show component outlines in edit mode, hide in play mode.'
        if getattr(self, 'play_mode', False) or not self.lui_enabled or not self.show_editor:
            for borders in self.debug_outlines.values():
                for b in borders:
                    b.visible = False
            return task.cont

        for idx, comp_data in enumerate(self.components):
            # If selected, let the resize handles/selection box handle the outline (Bright Blue)
            # We hide the "debug" outline for the selected item to avoid double-drawing or z-fighting
            if idx == self.selected_index:
                borders = self.debug_outlines.get(idx)
                if borders:
                    for b in borders:
                        b.visible = False
                continue

            comp_obj = comp_data.get('object')
            if comp_obj is None:
                continue

            canvas_index = comp_data.get('canvas_index', self.current_canvas_index)
            if canvas_index is None or canvas_index < 0 or canvas_index >= len(self.canvases):
                # Component not assigned to a valid canvas
                borders = self.debug_outlines.get(idx)
                if borders:
                    for b in borders: b.visible = False
                continue
                
            canvas = self.canvases[canvas_index]
            if not canvas.get('visible', True):
                # Hide outlines for components on hidden canvases
                borders = self.debug_outlines.get(idx)
                if borders:
                    for b in borders:
                        b.visible = False
                continue

            # Determine size
            width = comp_data.get('width', 0)
            height = comp_data.get('height', 0)
            try:
                if hasattr(comp_obj, 'width') and comp_obj.width is not None and comp_obj.width > 0:
                    width = comp_obj.width
                if hasattr(comp_obj, 'height') and comp_obj.height is not None and comp_obj.height > 0:
                    height = comp_obj.height
            except Exception:
                pass

            if width <= 0 or height <= 0:
                continue

            # Determine Position (Absolute)
            canvas_abs_left = 0
            canvas_abs_top = 0
            canvas_panel = self.canvases[canvas_index]['panel']
            canvas_abs_left = getattr(canvas_panel, 'left', 0)
            canvas_abs_top = getattr(canvas_panel, 'top', 0)
            if canvas_abs_left == 0 and canvas_abs_top == 0:
                try:
                    canvas_pos = canvas_panel.get_pos()
                    canvas_abs_left = canvas_pos.x
                    canvas_abs_top = canvas_pos.y
                except Exception:
                    canvas_abs_left = 300
                    canvas_abs_top = 100

            if hasattr(comp_obj, 'get_abs_pos'):
                try:
                    abs_pos = comp_obj.get_abs_pos()
                    abs_left = abs_pos.x
                    abs_top = abs_pos.y
                except Exception:
                    acc_left, acc_top = self._get_component_accumulated_pos(idx)
                    abs_left = canvas_abs_left + acc_left
                    abs_top = canvas_abs_top + acc_top
            else:
                acc_left, acc_top = self._get_component_accumulated_pos(idx)
                abs_left = canvas_abs_left + acc_left
                abs_top = canvas_abs_top + acc_top

            # Draw Outline
            borders = self._ensure_component_outline(idx)
            
            # Style for unselected components: Gray, thinner or same thickness
            for b in borders:
                b.color = (0.7, 0.7, 0.7, 0.5) # Light gray, semi-transparent
                if hasattr(b, 'z_offset'):
                    b.z_offset = 25
                elif hasattr(b, 'set_sort'):
                    b.set_sort(25)
                b.visible = True

            t = 1.0 # Thickness

            borders[0].left = abs_left
            borders[0].top = abs_top - t
            borders[0].width = width
            borders[0].height = t

            borders[1].left = abs_left
            borders[1].top = abs_top + height
            borders[1].width = width
            borders[1].height = t

            borders[2].left = abs_left - t
            borders[2].top = abs_top
            borders[2].width = t
            borders[2].height = height

            borders[3].left = abs_left + width
            borders[3].top = abs_top
            borders[3].width = t
            borders[3].height = height

        return task.cont

    def _show_and_update_handles(self, comp_data):
        """显示并更新handles位置 - 修复坐标系不一致问题"""
        # 每次显示时重新创建手柄，确保它们在最前面
        if not hasattr(self, '_handles_recreated'):
            self._recreate_handles_on_top()
            self._handles_recreated = True
        
        # 获取组件的Canvas相对位置和尺寸
        comp_obj = comp_data['object']
        
        # 获取Canvas的绝对位置用于坐标转换
        canvas_abs_left = 0
        canvas_abs_top = 0
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas_panel = self.canvases[self.current_canvas_index]['panel']
            # 使用LUI对象的left和top属性，而不是get_pos()方法
            canvas_abs_left = getattr(canvas_panel, 'left', 0)
            canvas_abs_top = getattr(canvas_panel, 'top', 0)
            
            # 如果left/top属性不存在，尝试使用get_pos()
            if canvas_abs_left == 0 and canvas_abs_top == 0:
                try:
                    canvas_pos = canvas_panel.get_pos()
                    canvas_abs_left = canvas_pos.x
                    canvas_abs_top = canvas_pos.y
                except:
                    # 如果get_pos()也失败，使用默认值
                    canvas_abs_left = 300  # 默认Canvas位置
                    canvas_abs_top = 100
        
        # 尝试直接获取组件的绝对屏幕坐标
        if hasattr(comp_obj, 'get_abs_pos'):
            try:
                abs_pos = comp_obj.get_abs_pos()
                abs_left = abs_pos.x
                abs_top = abs_pos.y
                # print(f"使用 get_abs_pos(): {abs_left}, {abs_top}")
            except Exception as e:
                print(f"get_abs_pos() 失败: {e}")
                # Fallback to manual calculation
                acc_left, acc_top = self._get_component_accumulated_pos(self.selected_index)
                abs_left = canvas_abs_left + acc_left
                abs_top = canvas_abs_top + acc_top
        else:
            # 递归计算组件的 Canvas 相对位置（累加所有父组件的相对位置）
            # 使用 self.selected_index 似乎最安全，或者反查 comp_data
            if self.selected_index >= 0 and self.components[self.selected_index] == comp_data:
                 acc_left, acc_top = self._get_component_accumulated_pos(self.selected_index)
            else:
                 acc_left = comp_data.get('left', 0)
                 acc_top = comp_data.get('top', 0)
    
            # 转换为绝对屏幕坐标（用于手柄和边框显示）
            abs_left = canvas_abs_left + acc_left
            abs_top = canvas_abs_top + acc_top
        
        # 获取组件尺寸 - 优先从LUI对象获取实际尺寸
        comp_type = comp_data['type']
        width = comp_data.get('width', 100)
        height = comp_data.get('height', 30)
        
        # 尝试从LUI对象获取实际尺寸
        try:
            if hasattr(comp_obj, 'width') and comp_obj.width is not None:
                actual_width = comp_obj.width
                if actual_width > 0:
                    width = actual_width
            if hasattr(comp_obj, 'height') and comp_obj.height is not None:
                actual_height = comp_obj.height
                if actual_height > 0:
                    height = actual_height
        except:
            pass
        
        # 确保宽高是数值类型
        try:
            width = float(width)
            height = float(height)
        except (TypeError, ValueError):
            width = 100.0
            height = 30.0
        
        # 更新comp_data中的尺寸
        comp_data['width'] = width
        comp_data['height'] = height

        # 更新4条边框（使用绝对位置，因为边框在overlay_root下）
        # 确保 selection_box 存在
        if not self.selection_box:
            self._create_resize_handles()
            if not self.selection_box: # Still empty?
                return

        # 上边框
        self.selection_box[0].left = abs_left
        self.selection_box[0].top = abs_top - 2
        self.selection_box[0].width = width
        self.selection_box[0].height = 2
        self.selection_box[0].visible = True

        # 下边框
        self.selection_box[1].left = abs_left
        self.selection_box[1].top = abs_top + height
        self.selection_box[1].width = width
        self.selection_box[1].height = 2
        self.selection_box[1].visible = True

        # 左边框
        self.selection_box[2].left = abs_left - 2
        self.selection_box[2].top = abs_top
        self.selection_box[2].width = 2
        self.selection_box[2].height = height
        self.selection_box[2].visible = True

        # 右边框
        self.selection_box[3].left = abs_left + width
        self.selection_box[3].top = abs_top
        self.selection_box[3].width = 2
        self.selection_box[3].height = height
        self.selection_box[3].visible = True

        # 更新8个手柄位置（使用绝对位置，因为手柄在overlay_root下）
        handle_positions = [
            (abs_left - 5, abs_top - 5),                      # 左上
            (abs_left + width/2 - 5, abs_top - 5),           # 上
            (abs_left + width - 5, abs_top - 5),             # 右上
            (abs_left + width - 5, abs_top + height/2 - 5),  # 右
            (abs_left + width - 5, abs_top + height - 5),    # 右下
            (abs_left + width/2 - 5, abs_top + height - 5),  # 下
            (abs_left - 5, abs_top + height - 5),            # 左下
            (abs_left - 5, abs_top + height/2 - 5),          # 左
        ]

        for i, (h_left, h_top) in enumerate(handle_positions):
            if i < len(self.resize_handles):
                handle = self.resize_handles[i]
                handle.left = h_left
                handle.top = h_top
                handle.visible = True

    def _recreate_handles_on_top(self):
        """重新创建手柄，确保它们在最前面"""
        from Builtin.LUISprite import LUISprite
        from Builtin.LUIObject import LUIObject
        
        # 清除旧的手柄
        for handle in self.resize_handles:
            if hasattr(handle, 'remove'):
                handle.remove()
        for border in self.selection_box:
            if hasattr(border, 'remove'):
                border.remove()
        
        self.resize_handles.clear()
        self.selection_box.clear()
        
        # 重新创建边框
        for i in range(4):
            border = LUISprite(self.overlay_root, "blank", "skin")
            border.color = (0.2, 0.5, 1.0, 1.0)  # 蓝色
            border.visible = False
            
            # 设置选择框层级，在组件之上但在LUI内部
            if hasattr(border, 'z_offset'):
                border.z_offset = 40
            elif hasattr(border, 'set_sort'):
                border.set_sort(40)
            
            self.selection_box.append(border)
        
        # 重新创建手柄
        handle_positions = [
            'top-left', 'top', 'top-right', 'right',
            'bottom-right', 'bottom', 'bottom-left', 'left'
        ]
        
        for i, pos in enumerate(handle_positions):
            handle_container = LUIObject(parent=self.overlay_root)
            handle_container.width = 10
            handle_container.height = 10
            handle_container.solid = True
            handle_container.visible = False
            
            # 设置手柄层级，在选择框之上但在LUI内部
            if hasattr(handle_container, 'z_offset'):
                handle_container.z_offset = 50
            elif hasattr(handle_container, 'set_sort'):
                handle_container.set_sort(50)
            
            # 创建蓝色边框（外圈）
            handle_border = LUISprite(handle_container, "blank", "skin")
            handle_border.width = 10
            handle_border.height = 10
            handle_border.left = 0
            handle_border.top = 0
            handle_border.color = (0.2, 0.5, 1.0, 1.0)  # 蓝色边框
            
            # 创建白色圆形背景（内圈）
            handle_bg = LUISprite(handle_container, "blank", "skin")
            handle_bg.width = 8
            handle_bg.height = 8
            handle_bg.left = 1
            handle_bg.top = 1
            handle_bg.color = (1.0, 1.0, 1.0, 1.0)  # 白色
            
            # 存储手柄位置信息
            handle_container._resize_position = pos
            handle_container._resize_index = i
            handle_container._bg = handle_bg
            handle_container._border = handle_border
            
            # 绑定鼠标事件
            handle_container.bind("mousedown", lambda event, h=handle_container: self._on_handle_mousedown(event, h))
            
            self.resize_handles.append(handle_container)
        
        print("✓ 重新创建了手柄，确保在最前面")

    def _handle_resize_drag(self):
        """处理resize拖拽 - 完整功能实现，支持Shift和Alt键操作"""
        if not hasattr(self.world, 'mouseWatcherNode') or not self.world.mouseWatcherNode.hasMouse():
            return
        
        # 检查鼠标左键是否释放
        import panda3d.core as p3d
        if not self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one()):
            if self.resizing_handle:
                comp_data = self.components[self.selected_index]
                width_val = comp_data.get('width', 0)
                height_val = comp_data.get('height', 0)
                print(f"✓ 组件调整完成: width={width_val:.1f}, height={height_val:.1f}")
                
                # 更新锚点位置（如果有锚点）
                if comp_data.get('anchored_to_parent'):
                    anchor_pos = comp_data.get('anchor_position')
                    if anchor_pos:
                        self._update_component_anchor_position(self.selected_index, anchor_pos)
                
                self.resizing_handle = None
            return
        
        # 获取当前鼠标位置
        mouse_x = self.world.mouseWatcherNode.getMouseX()
        mouse_y = self.world.mouseWatcherNode.getMouseY()
        
        win_x = self.world.win.getXSize()
        win_y = self.world.win.getYSize()
        pixel_x = (mouse_x + 1) * win_x / 2
        pixel_y = (1 - mouse_y) * win_y / 2
        
        # 计算鼠标移动距离
        delta_x = pixel_x - self.resize_start_pos[0]
        delta_y = pixel_y - self.resize_start_pos[1]
        
        # 检查修饰键
        shift_held = self.world.mouseWatcherNode.is_button_down(p3d.KeyboardButton.shift())
        alt_held = self.world.mouseWatcherNode.is_button_down(p3d.KeyboardButton.alt())
        
        # 获取组件数据
        comp_data = self.components[self.selected_index]
        comp_obj = comp_data['object']
        comp_type = comp_data['type']
        
        # 获取初始边界（Canvas相对坐标）
        start_left = self.resize_start_bounds['left']
        start_top = self.resize_start_bounds['top']
        start_width = self.resize_start_bounds['width']
        start_height = self.resize_start_bounds['height']
        
        # 计算初始宽高比
        aspect_ratio = start_width / start_height if start_height > 0 else 1
        
        # 根据手柄位置计算新的边界
        handle_pos = self.resizing_handle._resize_position
        
        new_left = start_left
        new_top = start_top
        new_width = start_width
        new_height = start_height
        
        # 根据手柄位置调整尺寸
        if handle_pos == 'top-left':
            new_left = start_left + delta_x
            new_top = start_top + delta_y
            new_width = start_width - delta_x
            new_height = start_height - delta_y
        elif handle_pos == 'top':
            new_top = start_top + delta_y
            new_height = start_height - delta_y
        elif handle_pos == 'top-right':
            new_top = start_top + delta_y
            new_width = start_width + delta_x
            new_height = start_height - delta_y
        elif handle_pos == 'right':
            new_width = start_width + delta_x
        elif handle_pos == 'bottom-right':
            new_width = start_width + delta_x
            new_height = start_height + delta_y
        elif handle_pos == 'bottom':
            new_height = start_height + delta_y
        elif handle_pos == 'bottom-left':
            new_left = start_left + delta_x
            new_width = start_width - delta_x
            new_height = start_height + delta_y
        elif handle_pos == 'left':
            new_left = start_left + delta_x
            new_width = start_width - delta_x
        
        # 应用最小尺寸限制
        if new_width < self.min_size:
            if handle_pos in ['top-left', 'left', 'bottom-left']:
                new_left = start_left + start_width - self.min_size
            new_width = self.min_size
            
        if new_height < self.min_size:
            if handle_pos in ['top-left', 'top', 'top-right']:
                new_top = start_top + start_height - self.min_size
            new_height = self.min_size
        
        # Shift键：保持宽高比
        if shift_held:
            width_change = abs(new_width - start_width)
            height_change = abs(new_height - start_height)
            
            if width_change > height_change:
                new_height = new_width / aspect_ratio
                if handle_pos in ['top-left', 'top', 'top-right']:
                    new_top = start_top + start_height - new_height
            else:
                new_width = new_height * aspect_ratio
                if handle_pos in ['top-left', 'left', 'bottom-left']:
                    new_left = start_left + start_width - new_width
        
        # Alt键：从中心点缩放
        if alt_held:
            center_x = start_left + start_width / 2
            center_y = start_top + start_height / 2
            
            width_diff = new_width - start_width
            height_diff = new_height - start_height
            
            new_width = start_width + width_diff * 2
            new_height = start_height + height_diff * 2
            new_left = center_x - new_width / 2
            new_top = center_y - new_height / 2
            
            # 再次应用最小尺寸限制
            if new_width < self.min_size:
                new_width = self.min_size
                new_left = center_x - new_width / 2
            if new_height < self.min_size:
                new_height = self.min_size
                new_top = center_y - new_height / 2
        
        # 获取Canvas边界约束
        canvas_width = 800  # 默认Canvas宽度
        canvas_height = 600  # 默认Canvas高度
        
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas_panel = self.canvases[self.current_canvas_index]['panel']
            canvas_width = canvas_panel.get_width()
            canvas_height = canvas_panel.get_height()
        
        
        # 最后的安全检查，防止宽高变为负数
        if new_width < 1.0: new_width = 1.0
        if new_height < 1.0: new_height = 1.0
        
        if self.selected_index < 0:
            return

        comp_data = self.components[self.selected_index]
        parent_index = comp_data.get('parent_index')
        parent_offset_x = 0
        parent_offset_y = 0
        
        if parent_index is not None and parent_index >= 0:
             parent_offset_x, parent_offset_y = self._get_component_accumulated_pos(parent_index)

        # Update component data
        comp_data['left'] = new_left
        comp_data['top'] = new_top
        comp_data['width'] = new_width
        comp_data['height'] = new_height

        # Update component position
        child_parent = getattr(comp_obj, 'parent', None)
        parent_obj = None
        if parent_index is not None and parent_index >= 0:
            parent_obj = self.components[parent_index].get('object')

        # Check if actually parented in LUI scene graph
        is_scene_parented = (child_parent is not None and child_parent == parent_obj)

        if is_scene_parented:
            # Component is physically parented to its logical parent -> Use Relative coords
            comp_obj.left = new_left
            comp_obj.top = new_top
        else:
            # Component is physically root/canvas -> Use Absolute coords (Parent Abs + Relative)
            comp_obj.left = parent_offset_x + new_left
            comp_obj.top = parent_offset_y + new_top

        # Update component size
        try:
            if hasattr(comp_obj, 'width'):
                comp_obj.width = new_width
            if hasattr(comp_obj, 'height'):
                comp_obj.height = new_height

            if comp_type == 'Frame':
                pass
            elif comp_type in ['Plane', 'Image', 'Video']:
                sprite = comp_data.get('sprite')
                if sprite is not None:
                    sprite.width = new_width
                    sprite.height = new_height
            elif comp_type == 'Button':
                if hasattr(comp_obj, 'set_width'):
                    comp_obj.set_width(new_width)
                if hasattr(comp_obj, 'set_height'):
                    comp_obj.set_height(new_height)
                if hasattr(comp_obj, '_apply_stretch_sizes'):
                    comp_obj._apply_stretch_sizes()
            elif comp_type == 'InputField':
                if hasattr(comp_obj, 'set_width'):
                    comp_obj.set_width(new_width)
                if hasattr(comp_obj, 'set_height'):
                    comp_obj.set_height(new_height)
                if hasattr(comp_obj, 'width'):
                    comp_obj.width = new_width
                if hasattr(comp_obj, 'height'):
                    comp_obj.height = new_height
                try:
                    layout = getattr(comp_obj, '_layout', None)
                    if layout is not None:
                        if hasattr(layout, 'width'):
                            layout.width = '100%'
                        if hasattr(layout, 'height'):
                            layout.height = '100%'
                        inner = getattr(layout, '_layout', None)
                        if inner is not None:
                            if hasattr(inner, 'width'):
                                inner.width = '100%'
                            if hasattr(inner, 'height'):
                                inner.height = '100%'
                        for attr in ('_sprite_left', '_sprite_mid', '_sprite_right'):
                            spr = getattr(layout, attr, None)
                            if spr is not None and hasattr(spr, 'height'):
                                spr.height = '100%'
                            if spr is not None and attr == '_sprite_mid' and hasattr(spr, 'width'):
                                spr.width = '100%'
                except Exception:
                    pass
            elif comp_type == 'Slider':
                if hasattr(comp_obj, 'set_width'):
                    comp_obj.set_width(new_width)
                if hasattr(comp_obj, 'set_height'):
                    comp_obj.set_height(new_height)

            if comp_type in ['VerticalLayout', 'HorizontalLayout']:
                self._update_layout_inner(self.selected_index)

            self._update_anchored_children(self.selected_index)

            modifier_info = []
            if shift_held:
                modifier_info.append('Shift(keep ratio)')
            if alt_held:
                modifier_info.append('Alt(center scale)')
            modifier_str = ' + '.join(modifier_info) if modifier_info else 'Normal'
        except Exception as e:
            print(f"⚠ 设置组件尺寸失败 ({comp_type}): {e}")

    def _add_to_scene_tree(self, comp_data):
        """Add a virtual node to represent the LUI component in the scene tree"""
        from panda3d.core import NodePath
        node_name = f"UI_{comp_data['type']}_{len(self.components)}"
        ui_node = NodePath(node_name)
        
        # Reparent to current canvas node if available
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas_node = self.canvases[self.current_canvas_index]['node']
            ui_node.reparent_to(canvas_node)
            comp_data['canvas_index'] = self.current_canvas_index
        else:
            ui_node.reparent_to(self.world.render)
            comp_data['canvas_index'] = None
        
        comp_data['ui_node'] = ui_node
        comp_data['parent_index'] = None
        comp_data['children_indices'] = []

    def _set_parent_child_relationship(self, child_index, parent_index, anchor_position=None, keep_world=False):
        # Set parent-child relationship
        if (child_index < 0 or child_index >= len(self.components) or
            parent_index < 0 or parent_index >= len(self.components)):
            print("Error: invalid component index")
            return

        child_data = self.components[child_index]
        parent_data = self.components[parent_index]

        if parent_data.get('type') in ['VerticalLayout', 'HorizontalLayout']:
            child_data['draggable'] = False

        if child_data.get('parent_index') == parent_index:
            print(f"Component {child_index} already under {parent_index}")
            return

        current_abs_left, current_abs_top = self._get_component_accumulated_pos(child_index)
        
        print(f"[_set_parent_child_relationship] Child #{child_index} -> Parent #{parent_index}")
        print(f"  Current absolute position: ({current_abs_left:.1f}, {current_abs_top:.1f})")

        old_parent_index = child_data.get('parent_index')
        if old_parent_index is not None and old_parent_index >= 0:
            old_parent_data = self.components[old_parent_index]
            if child_index in old_parent_data.get('children_indices', []):
                old_parent_data['children_indices'].remove(child_index)

        child_data['parent_index'] = parent_index
        if 'children_indices' not in parent_data:
            parent_data['children_indices'] = []
        if child_index not in parent_data['children_indices']:
            parent_data['children_indices'].append(child_index)

        parent_abs_left, parent_abs_top = self._get_component_accumulated_pos(parent_index)
        new_local_left = current_abs_left - parent_abs_left
        new_local_top = current_abs_top - parent_abs_top
        
        print(f"  Parent absolute position: ({parent_abs_left:.1f}, {parent_abs_top:.1f})")
        print(f"  Calculated local position: ({new_local_left:.1f}, {new_local_top:.1f})")

        # 在数据结构中存储局部坐标（相对于父组件）
        child_data['left'] = new_local_left
        child_data['top'] = new_local_top

        child_obj = child_data['object']
        parent_obj = parent_data['object']
        parent_type = parent_data.get('type')
        visual_container_types = [
            'Frame', 'Plane', 'Video',
            'ScrollableRegion', 'TabbedFrame',
            'VerticalLayout', 'HorizontalLayout'
        ]
        if parent_data.get('type') == 'ScrollableRegion':
            parent_obj = parent_data['object'].content_node
        elif parent_data.get('type') in ['VerticalLayout', 'HorizontalLayout'] and parent_data.get('layout_obj'):
            if parent_data.get('layout_wrap', True):
                parent_obj = parent_data.get('object')
            else:
                parent_obj = parent_data.get('layout_obj').cell()

        try:
            if parent_type in visual_container_types:
                child_data['visual_parent_canvas'] = False
                # 关键修改：不要调用 reparent_to()，避免破坏内部结构
                # 只更新数据结构，保持原有的父对象关系
                print(f"[_set_parent_child_relationship] Setting parent relationship (data only, no reparenting)")
            else:
                # Keep visual parent on canvas to avoid clipping, but keep logical parent
                child_data['visual_parent_canvas'] = True

            # If not preserving world position, clamp into parent bounds for visibility
            if not keep_world:
                try:
                    parent_w = parent_data.get('width')
                    parent_h = parent_data.get('height')
                    if parent_w is None and hasattr(parent_obj, 'width'):
                        parent_w = parent_obj.width
                    if parent_h is None and hasattr(parent_obj, 'height'):
                        parent_h = parent_obj.height
                    child_w = child_data.get('width')
                    child_h = child_data.get('height')
                    if child_w is None and hasattr(child_obj, 'width'):
                        child_w = child_obj.width
                    if child_h is None and hasattr(child_obj, 'height'):
                        child_h = child_obj.height
                    if parent_w and parent_h and child_w and child_h:
                        max_x = max(0.0, float(parent_w) - float(child_w))
                        max_y = max(0.0, float(parent_h) - float(child_h))
                        new_local_left = max(0.0, min(float(new_local_left), max_x))
                        new_local_top = max(0.0, min(float(new_local_top), max_y))
                        child_data['left'] = new_local_left
                        child_data['top'] = new_local_top
                except Exception:
                    pass

            # 关键修改：由于我们不实际重新父化对象，所有组件都保持相对于Canvas的绝对位置
            # 只在数据结构中记录相对于父组件的局部坐标
            if child_data.get('visual_parent_canvas'):
                # Keep world position
                try:
                    child_data['canvas_index'] = parent_data.get('canvas_index', self.current_canvas_index)
                except Exception:
                    pass
            
            # 根据keep_world参数决定是否保持世界位置
            if keep_world:
                # 保持世界位置：使用绝对坐标
                if hasattr(child_obj, 'left'):
                    child_obj.left = current_abs_left
                if hasattr(child_obj, 'top'):
                    child_obj.top = current_abs_top
                print(f"[_set_parent_child_relationship] Child position kept at absolute: ({current_abs_left:.1f}, {current_abs_top:.1f})")
            else:
                # 不保持世界位置：使用局部坐标（但由于没有实际重新父化，这会导致位置跳变）
                # 为了避免跳变，我们仍然使用绝对坐标
                if hasattr(child_obj, 'left'):
                    child_obj.left = current_abs_left
                if hasattr(child_obj, 'top'):
                    child_obj.top = current_abs_top
                print(f"[_set_parent_child_relationship] Child position set to absolute: ({current_abs_left:.1f}, {current_abs_top:.1f})")

            # Ensure child visuals are visible above parent
            if hasattr(child_obj, 'z_offset'):
                try:
                    parent_z = getattr(parent_obj, 'z_offset', 0)
                    child_obj.z_offset = float(parent_z) + 2.0
                except Exception:
                    pass

            # Special handling for Button: raise internal sprites/label above parent
            if child_data.get('type') == 'Button':
                try:
                    layout = getattr(child_obj, '_layout', None)
                    if layout is not None:
                        for attr in ('_sprite_left', '_sprite_mid', '_sprite_right'):
                            spr = getattr(layout, attr, None)
                            if spr is not None and hasattr(spr, 'z_offset'):
                                spr.z_offset = float(getattr(child_obj, 'z_offset', 0)) + 1.0
                    lbl = getattr(child_obj, '_label', None)
                    if lbl is not None and hasattr(lbl, 'z_offset'):
                        lbl.z_offset = float(getattr(child_obj, 'z_offset', 0)) + 2.0
                    # Ensure label visible
                    if lbl is not None and hasattr(lbl, 'show'):
                        lbl.show()
                except Exception:
                    pass
            
            # Special handling for Frame: ensure visibility
            elif child_data.get('type') == 'Frame':
                try:
                    if hasattr(child_obj, 'show'):
                        child_obj.show()
                    if hasattr(child_obj, 'visible'):
                        child_obj.visible = True
                    print(f"[_set_parent_child_relationship] Frame visibility ensured")
                except Exception as e:
                    print(f"[_set_parent_child_relationship] Error ensuring Frame visibility: {e}")
            
            # Special handling for Plane, Image, Video: ensure sprite visibility
            elif child_data.get('type') in ['Plane', 'Image', 'Video']:
                try:
                    spr = child_data.get('sprite')
                    if spr is not None:
                        if hasattr(spr, 'show'):
                            spr.show()
                        if hasattr(spr, 'visible'):
                            spr.visible = True
                        
                        # Ensure sprite color is not transparent
                        if child_data.get('type') == 'Plane':
                            color = child_data.get('color', (1, 1, 1, 1))
                            if hasattr(spr, 'color'):
                                spr.color = color
                    
                    print(f"[_set_parent_child_relationship] {child_data.get('type')} sprite visibility ensured")
                except Exception as e:
                    print(f"[_set_parent_child_relationship] Error ensuring {child_data.get('type')} visibility: {e}")

            child_sprite = child_data.get('sprite')
            if child_sprite is not None:
                try:
                    if hasattr(child_sprite, 'show'):
                        child_sprite.show()
                    # Ensure sprite is attached to the child object
                    if hasattr(child_sprite, 'parent') and child_sprite.parent != child_obj:
                        child_sprite.parent = child_obj
                    # Restore sprite color if stored
                    if hasattr(child_sprite, 'color') and 'color' in child_data:
                        child_sprite.color = child_data.get('color', child_sprite.color)
                    if hasattr(child_sprite, 'z_offset'):
                        parent_sprite = parent_data.get('sprite')
                        parent_sprite_z = 0.0
                        if parent_sprite is not None and hasattr(parent_sprite, 'z_offset'):
                            parent_sprite_z = float(parent_sprite.z_offset)
                        child_sprite.z_offset = max(parent_sprite_z + 1.0, float(getattr(child_obj, 'z_offset', 0)) + 1.0)
                except Exception:
                    pass
            # Keep child visible above parent visuals
            if hasattr(child_obj, 'z_offset'):
                parent_z = getattr(parent_obj, 'z_offset', 0)
                try:
                    child_obj.z_offset = float(parent_z) + 2.0
                except Exception:
                    pass
            # Ensure child sprite renders above parent visuals
            child_sprite = child_data.get('sprite')
            if child_sprite is not None and hasattr(child_sprite, 'z_offset'):
                parent_sprite_z = 0
                try:
                    parent_sprite = parent_data.get('sprite')
                    if parent_sprite is not None and hasattr(parent_sprite, 'z_offset'):
                        parent_sprite_z = float(parent_sprite.z_offset)
                except Exception:
                    parent_sprite_z = 0
                try:
                    child_sprite.z_offset = max(float(parent_sprite_z) + 1.0, float(getattr(child_obj, 'z_offset', 0)) + 1.0)
                except Exception:
                    pass
            if hasattr(child_obj, 'show'):
                child_obj.show()

        except Exception as e:
            print(f"Reparenting error: {e}")

        # Ensure canvas_index follows parent canvas (visibility)
        parent_canvas = parent_data.get('canvas_index')
        if parent_canvas is not None:
            self._update_canvas_index_recursive(child_index, parent_canvas)

        if parent_data.get('type') in ['HorizontalLayout', 'VerticalLayout'] and parent_data.get('layout_wrap', True):
            self._apply_wrap_layout(parent_index)

        print(f"Set parent: child #{child_index} -> parent #{parent_index}")


    def _set_parent_root(self, child_index, keep_world=False):
        """Detach a component from its parent and move it to root (canvas)."""
        if child_index < 0 or child_index >= len(self.components):
            print("Error: invalid component index")
            return

        child_data = self.components[child_index]
        
        # 保存当前的累积位置（相对于Canvas的绝对位置）
        current_abs_left, current_abs_top = self._get_component_accumulated_pos(child_index)
        
        print(f"[_set_parent_root] Component #{child_index} current accumulated pos: ({current_abs_left:.1f}, {current_abs_top:.1f})")

        old_parent_index = child_data.get('parent_index')
        if old_parent_index is not None and old_parent_index >= 0:
            old_parent_data = self.components[old_parent_index]
            if child_index in old_parent_data.get('children_indices', []):
                old_parent_data['children_indices'].remove(child_index)

        # 更新数据结构
        child_data['parent_index'] = None
        child_data['visual_parent_canvas'] = False
        child_data['draggable'] = True

        # 获取Canvas panel
        parent_obj = None
        canvas_index = self.current_canvas_index
        if canvas_index is not None and canvas_index >= 0 and canvas_index < len(self.canvases):
            parent_obj = self.canvases[canvas_index]['panel']
            child_data['canvas_index'] = canvas_index
        else:
            parent_obj = getattr(self, 'overlay_root', None) or getattr(self.world, 'render', None)

        child_obj = child_data.get('object')
        
        # 关键修改：对于 Button 等复杂组件，不要重新父化！
        # 只更新位置和数据结构
        if child_obj is not None:
            # 更新位置数据
            if keep_world:
                child_data['left'] = current_abs_left
                child_data['top'] = current_abs_top
                
                # 直接设置对象位置，不改变父对象
                if hasattr(child_obj, 'set_pos'):
                    child_obj.set_pos(current_abs_left, current_abs_top)
                else:
                    if hasattr(child_obj, 'left'):
                        child_obj.left = current_abs_left
                    if hasattr(child_obj, 'top'):
                        child_obj.top = current_abs_top
                        
                print(f"[_set_parent_root] Set position to: ({current_abs_left:.1f}, {current_abs_top:.1f}) without reparenting")
            else:
                # 不保持世界位置：使用原有的局部坐标
                if hasattr(child_obj, 'left'):
                    child_obj.left = child_data.get('left', 0)
                if hasattr(child_obj, 'top'):
                    child_obj.top = child_data.get('top', 0)

        # 确保可见性
        if child_obj is not None:
            try:
                if hasattr(child_obj, 'show'):
                    child_obj.show()
                elif hasattr(child_obj, 'visible'):
                    child_obj.visible = True
            except Exception:
                pass

        # 对于 Button，确保内部组件可见
        comp_type = child_data.get('type')
        if comp_type == 'Button' and child_obj is not None:
            try:
                layout = getattr(child_obj, '_layout', None)
                lbl = getattr(child_obj, '_label', None)
                
                if layout is not None:
                    if hasattr(layout, 'show'):
                        layout.show()
                    if hasattr(layout, 'visible'):
                        layout.visible = True
                
                if lbl is not None:
                    if hasattr(lbl, 'show'):
                        lbl.show()
                    if hasattr(lbl, 'visible'):
                        lbl.visible = True
                    
                    # 重新设置文本
                    current_text = child_data.get('text', 'Button')
                    if hasattr(lbl, 'set_text'):
                        lbl.set_text(current_text)
                    elif hasattr(lbl, 'text'):
                        lbl.text = current_text
                
                print(f"[_set_parent_root] Button components visibility ensured")
            except Exception as e:
                print(f"[_set_parent_root] Error ensuring button visibility: {e}")
        
        # 对于 Plane, Image, Video - 确保内部 sprite 可见
        elif comp_type in ['Plane', 'Image', 'Video'] and child_obj is not None:
            try:
                spr = child_data.get('sprite')
                if spr is not None:
                    if hasattr(spr, 'show'):
                        spr.show()
                    if hasattr(spr, 'visible'):
                        spr.visible = True
                    
                    # 确保 sprite 的颜色不是透明的
                    if comp_type == 'Plane':
                        color = child_data.get('color', (1, 1, 1, 1))
                        if hasattr(spr, 'color'):
                            spr.color = color
                
                print(f"[_set_parent_root] {comp_type} sprite visibility ensured")
            except Exception as e:
                print(f"[_set_parent_root] Error ensuring {comp_type} visibility: {e}")
        
        # 对于 Frame - 直接确保可见
        elif comp_type == 'Frame' and child_obj is not None:
            try:
                if hasattr(child_obj, 'show'):
                    child_obj.show()
                if hasattr(child_obj, 'visible'):
                    child_obj.visible = True
                print(f"[_set_parent_root] Frame visibility ensured")
            except Exception as e:
                print(f"[_set_parent_root] Error ensuring Frame visibility: {e}")

        # Update canvas index recursively
        self._update_canvas_index_recursive(child_index, child_data.get('canvas_index'))
        
        # 调试输出：确认组件状态
        print(f"[_set_parent_root] Component #{child_index} ({child_data.get('name', 'Unknown')}) moved to root (data only)")
        print(f"  - Position: ({child_data.get('left', 0):.1f}, {child_data.get('top', 0):.1f})")
        print(f"  - Size: ({child_data.get('width', 0):.1f}, {child_data.get('height', 0):.1f})")
        print(f"  - Canvas index: {child_data.get('canvas_index')}")
        print(f"  - Visible: {getattr(child_obj, 'visible', 'N/A') if child_obj else 'N/A'}")
        print(f"  - Parent (unchanged): {getattr(child_obj, 'parent', 'N/A') if child_obj else 'N/A'}")
    def create_child_component(self, parent_index, comp_type, anchor_position=None):
        # Create child component under parent
        print("\n=== Create child component ===")
        print(f"Parent index: {parent_index}, Type: {comp_type}")

        if parent_index < 0 or parent_index >= len(self.components):
            print("Error: invalid parent index")
            return None

        parent_data = self.components[parent_index]
        parent_obj = parent_data['object']
        if parent_data.get('type') == 'ScrollableRegion':
            parent_obj = parent_data['object'].content_node
        elif parent_data.get('type') in ['VerticalLayout', 'HorizontalLayout'] and parent_data.get('layout_obj'):
            if parent_data.get('layout_wrap', True):
                parent_obj = parent_data.get('object')
            else:
                parent_obj = parent_data.get('layout_obj').cell()

        parent_width = parent_data.get('width', 100)
        parent_height = parent_data.get('height', 30)

        comp_sizes = {
            'Button': (100, 30),
            'Text': (80, 20),
            'Label': (80, 20),
            'CheckBox': (120, 20),
            'InputField': (200, 24),
            'Slider': (200, 16),
            'Frame': (300, 200),
            'Plane': (100, 100),
            'Image': (100, 100),
            'Video': (320, 240),
            'Progressbar': (200, 30),
            'Selectbox': (200, 30),
            'ScrollableRegion': (200, 200),
            'TabbedFrame': (300, 200),
            'VerticalLayout': (300, 200),
            'HorizontalLayout': (300, 200),
        }

        child_w, child_h = comp_sizes.get(comp_type, (80, 20))
        child_x = (parent_width - child_w) / 2
        child_y = (parent_height - child_h) / 2

        if parent_data.get('type') in ['VerticalLayout', 'HorizontalLayout']:
            child_x = 0
            child_y = 0

        child_obj = None
        try:
            if comp_type == 'Button':
                child_obj = self.luiFunction.create_button(self, text="ChildButton", x=child_x, y=child_y, parent=parent_obj)
            elif comp_type in ['Text', 'Label']:
                child_obj = self.luiFunction.create_label(self, text="ChildText", x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'CheckBox':
                child_obj = self.luiFunction.create_checkbox(self, label="ChildCheckbox", x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'InputField':
                child_obj = self.luiFunction.create_input_field(self, text="ChildInput", x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Slider':
                child_obj = self.luiFunction.create_slider(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Frame':
                child_obj = self.luiFunction.create_frame(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Plane':
                child_obj = self.luiFunction.create_plane(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Image':
                child_obj = self.luiFunction.create_image(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Video':
                child_obj = self.luiFunction.create_video(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Progressbar':
                child_obj = self.luiFunction.create_progressbar(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'Selectbox':
                child_obj = self.luiFunction.create_selectbox(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'ScrollableRegion':
                child_obj = self.luiFunction.create_scrollable_region(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'TabbedFrame':
                child_obj = self.luiFunction.create_tabbed_frame(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'VerticalLayout':
                child_obj = self.luiFunction.create_vertical_layout(self, x=child_x, y=child_y, parent=parent_obj)
            elif comp_type == 'HorizontalLayout':
                child_obj = self.luiFunction.create_horizontal_layout(self, x=child_x, y=child_y, parent=parent_obj)
            else:
                print(f"Error: unsupported component type {comp_type}")
                return None

        except Exception as e:
            print(f"Error: create component failed: {e}")
            import traceback
            traceback.print_exc()
            return None

        if child_obj:
            child_index = -1
            for i, comp in enumerate(self.components):
                if comp.get('object') == child_obj:
                    child_index = i
                    break

            if child_index >= 0:
                child_data = self.components[child_index]
                if parent_data.get('type') in ['HorizontalLayout', 'VerticalLayout'] and parent_data.get('layout_wrap', True):
                    self._apply_wrap_layout(parent_index)

                if parent_data.get('type') in ['VerticalLayout', 'HorizontalLayout']:
                    child_data['draggable'] = False

                child_data['parent_index'] = parent_index
                if 'children_indices' not in parent_data:
                    parent_data['children_indices'] = []
                if child_index not in parent_data['children_indices']:
                    parent_data['children_indices'].append(child_index)

                print(f"Linked child #{child_index} -> parent #{parent_index}")
                return child_index
        else:
            print("Child creation failed")
        return None

    def _get_descendants(self, idx):
        """Return set of all descendant indices for a component."""
        desc = set()
        if idx < 0 or idx >= len(self.components):
            return desc
        comp = self.components[idx]
        for c_idx in comp.get('children_indices', []):
            if c_idx in desc:
                continue
            desc.add(c_idx)
            desc.update(self._get_descendants(c_idx))
        return desc

    def _update_canvas_index_recursive(self, idx, canvas_index):
        """Update canvas_index for component and its descendants."""
        if idx < 0 or idx >= len(self.components):
            return
        comp = self.components[idx]
        comp['canvas_index'] = canvas_index
        for c_idx in comp.get('children_indices', []):
            self._update_canvas_index_recursive(c_idx, canvas_index)

    def _reorder_list(self, items, src, target):
        """Move src before target within items list."""
        if src == target:
            return items
        if src not in items or target not in items:
            return items
        items = list(items)
        items.remove(src)
        insert_at = items.index(target)
        items.insert(insert_at, src)
        return items

    def _sync_canvas_children(self, parent_index):
        """Update positions for children that keep visual parent on canvas."""
        if parent_index < 0 or parent_index >= len(self.components):
            return
        
        # Get parent's absolute position
        parent_abs_left, parent_abs_top = self._get_component_accumulated_pos(parent_index)
        parent_data = self.components[parent_index]
        parent_obj = parent_data.get('object')

        for child_idx in parent_data.get('children_indices', []):
            if child_idx < 0 or child_idx >= len(self.components):
                continue
            child = self.components[child_idx]
            child_obj = child.get('object')
            
            if child_obj is None:
                continue

            # Check actual parenting
            child_parent = getattr(child_obj, 'parent', None)
            is_scene_parented = (child_parent is not None and child_parent == parent_obj)

            if not is_scene_parented:
                # If child is NOT physically parented to the parent object (e.g. it is on Canvas),
                # we MUST manually update its absolute position to follow the parent.
                abs_left = parent_abs_left + float(child.get('left', 0))
                abs_top = parent_abs_top + float(child.get('top', 0))
                
                if hasattr(child_obj, 'left'):
                    child_obj.left = abs_left
                if hasattr(child_obj, 'top'):
                    child_obj.top = abs_top
                if hasattr(child_obj, 'set_pos'):
                    child_obj.set_pos(abs_left, abs_top)
            
            # Recurse for grandchildren
            self._sync_canvas_children(child_idx)





    def draw_editor(self):
        """Draw the LUI Editor Window"""
        if not self.lui_enabled or not self.show_editor:
            return

        imgui.set_next_window_size((350, 600), imgui.Cond_.first_use_ever)
        with imgui_ctx.begin("LUI编辑器", True) as (opened, show):
            self.show_editor = opened
            if not show:
                return

            # Play/Stop
            if imgui.button("Play" if not self.play_mode else "Stop", (120, 25)):
                self.play_mode = not self.play_mode
                if self.play_mode:
                    # Clear editor-only state when entering play mode
                    self.selected_index = -1
                    self.dragging_comp = None
                    self.pending_drag_comp = None
                    self.pending_drag_index = -1
                    self.pending_drag_start_mouse = None
                    self.pending_drag_start_abs = None
                    self.pending_drag_start_parent = None
                    self._hide_resize_handles()
                # Keep LUI input enabled for runtime UI interaction
                self.set_input_enabled(True)
            imgui.same_line()
            imgui.text_colored((0.2, 1.0, 0.2, 1.0) if self.play_mode else (1.0, 0.8, 0.2, 1.0),
                               "Running" if self.play_mode else "Editing")
            imgui.separator()

            # In play mode, show toolbar only
            if self.play_mode:
                return
            
            # Canvas Management
            imgui.text("Canvas 管理")
            imgui.separator()
            
            if imgui.button("创建新Canvas", (150, 25)):
                self.luiFunction.create_canvas(self)
            
            imgui.same_line()
            
            # 显示当前Canvas信息
            if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
                current_canvas_name = self.canvases[self.current_canvas_index]['name']
                imgui.text_colored((0.0, 1.0, 0.0, 1.0), f"当前: {current_canvas_name}")
            else:
                imgui.text_colored((1.0, 0.0, 0.0, 1.0), "无Canvas")
            
            if len(self.canvases) > 0:
                canvas_names = [c['name'] for c in self.canvases]
                if self.current_canvas_index >= len(canvas_names):
                    self.current_canvas_index = len(canvas_names) - 1
                
                changed, new_index = imgui.combo("选择Canvas", self.current_canvas_index, canvas_names)
                if changed:
                    self.switch_canvas(new_index)
                
                # Canvas Properties
                if self.current_canvas_index >= 0:
                    canvas = self.canvases[self.current_canvas_index]
                    panel = canvas['panel']
                    imgui.indent()
                    
                    # Visibility
                    is_visible = canvas.get('visible', True)
                    changed, visible = imgui.checkbox("显示Canvas", is_visible)
                    if changed:
                        canvas['visible'] = visible
                        if visible:
                            panel.show()
                        else:
                            panel.hide()
                            
                    
                    # Fill Mode & Margins
                    is_fill_mode = canvas.get('fill_mode', False)
                    imgui.separator()
                    changed, fill_mode = imgui.checkbox("场景填充模式", is_fill_mode)
                    if changed:
                        canvas['fill_mode'] = fill_mode
                        if fill_mode:
                            # 刚切换到填充模式时，更新一次
                            self._update_canvas_geometry(canvas)
                            
                    if fill_mode:
                        imgui.text("场景边距设置 (调整以匹配视口)")
                        margins = canvas.get('margins', {'left':0,'right':0,'top':0,'bottom':0})
                        geometry_changed = False
                        
                        changed, margins['left'] = imgui.drag_float("左边距", margins['left'], 1.0, 0, 1000)
                        if changed: geometry_changed = True
                            
                        changed, margins['right'] = imgui.drag_float("右边距", margins['right'], 1.0, 0, 1000)
                        if changed: geometry_changed = True
                            
                        changed, margins['top'] = imgui.drag_float("顶边距", margins['top'], 1.0, 0, 500)
                        if changed: geometry_changed = True
                            
                        changed, margins['bottom'] = imgui.drag_float("底边距", margins['bottom'], 1.0, 0, 500)
                        if changed: geometry_changed = True
                            
                        if geometry_changed:
                            canvas['margins'] = margins
                            self._update_canvas_geometry(canvas)
                    else:
                        # Manual Position
                        curr_pos_val = panel.get_pos()
                        curr_pos = (curr_pos_val.x, curr_pos_val.y)
                        
                        # 固定开关
                        is_fixed = canvas.get('fixed', False)
                        changed, fixed = imgui.checkbox("锁定位置 (禁止拖动)", is_fixed)
                        if changed:
                            canvas['fixed'] = fixed
                            
                        if not is_fixed:
                            changed, pos = imgui.drag_float2("Canvas位置", curr_pos)
                            if changed:
                                panel.set_pos(pos[0], pos[1])
                            
                        
                        # Manual Size
                        curr_size = (panel.get_width(), panel.get_height())
                        changed, size = imgui.drag_float2("Canvas尺寸", curr_size, 1, 100, 4000)
                        if changed:
                            panel.width = size[0]
                            panel.height = size[1]
                            # 同时更新背景尺寸
                            if 'background' in canvas:
                                bg = canvas['background']
                                bg.width = size[0]
                                bg.height = size[1]
                                
                    # Canvas Color
                    if 'background' in canvas:
                        imgui.separator()
                        bg = canvas['background']
                        # 获取当前颜色 (RGBA)
                        current_color = bg.color
                        # 转换为可编辑的格式 (list)
                        edit_color = [current_color[0], current_color[1], current_color[2], current_color[3]]
                        
                        changed, new_color = imgui.color_edit4("背景颜色/透明度", edit_color)
                        if changed:
                            bg.color = (new_color[0], new_color[1], new_color[2], new_color[3])
                                
                    # Title settings
                    if 'title_label' in canvas:
                        imgui.separator()
                        imgui.text("标题设置")
                        title = canvas['title_label']
                        
                        # Visible
                        is_title_visible = title.visible
                        changed, title_visible = imgui.checkbox("显示标题", is_title_visible)
                        if changed:
                            try:
                                if title_visible:
                                    title.show()
                                else:
                                    title.hide()
                            except:
                                title.visible = title_visible

                        # Text content
                        curr_text = title.text
                        changed, new_text = imgui.input_text("标题文本", curr_text, 128)
                        if changed:
                            title.text = new_text

                        # Position
                        curr_pos_val = title.get_pos()
                        curr_pos = (curr_pos_val.x, curr_pos_val.y)
                        changed, new_pos = imgui.drag_float2("标题位置", curr_pos)
                        if changed:
                            title.set_pos(new_pos[0], new_pos[1])
                            
                    imgui.unindent()
            else:
                imgui.text_colored((1, 1, 0, 1), "请先创建一个Canvas")
            
            imgui.spacing()
            imgui.text("创建组件")
            imgui.separator()
            
            if len(self.canvases) == 0:
                imgui.begin_disabled()
            
            # Component Type Selection
            component_types = ["按钮 (Button)", "文本 (Text)", "复选框 (CheckBox)", "输入框 (InputField)",
                               "滑块 (Slider)", "框架 (Frame)","面板 (Plane)","图片 (Image)","视频 (Video)",
                               "进度条 (Progressbar)", "下拉框 (Selectbox)", "滚动区域 (ScrollableRegion)", "标签页 (TabbedFrame)",
                               "垂直布局组 (VerticalLayout)", "水平布局组 (HorizontalLayout)"]
            
            changed, self._selected_type_index = imgui.combo("组件类型", self._selected_type_index, component_types)
            
            if imgui.button("创建组件", (120, 25)):
                self._create_component_by_type(self._selected_type_index)
            
            if len(self.canvases) == 0:
                imgui.end_disabled()
                
            imgui.spacing()
            imgui.text(f"已创建组件 ({len(self.components)})")
            imgui.separator()
            
            # Component Tree Helper
            # self.draw_component_tree()
            
            imgui.spacing()
            imgui.separator()
            
            # Anchor Popup Handling
            self._handle_anchor_popup()
            
    def draw_component_tree(self):
        """Draw the component tree (can be used in other windows)"""
        # Track tree item rects for drop hit-testing (allows drop on earlier items)
        self._tree_item_rects = {}

        def _store_item_rect(item_key):
            try:
                rmin = imgui.get_item_rect_min()
                rmax = imgui.get_item_rect_max()
                self._tree_item_rects[item_key] = (rmin, rmax)
            except Exception:
                pass

        def _hit_test_tree_item(mx, my):
            for key, (rmin, rmax) in self._tree_item_rects.items():
                try:
                    min_x = rmin.x
                    min_y = rmin.y
                    max_x = rmax.x
                    max_y = rmax.y
                except Exception:
                    min_x = rmin[0]
                    min_y = rmin[1]
                    max_x = rmax[0]
                    max_y = rmax[1]
                if min_x <= mx <= max_x and min_y <= my <= max_y:
                    return key
            return None

        # Root drop target
        if imgui.selectable("ROOT", self.selected_index < 0):
            # ????????
            pass
        _store_item_rect(-1)

        def render_component_tree(idx):
            if idx >= len(self.components): return True
            comp = self.components[idx]
            comp_type = comp.get('type', 'Unknown')
            
            label = f"{comp.get('name', 'N/A')}"
            
            # Determine flags
            flags = imgui.TreeNodeFlags_.open_on_arrow | imgui.TreeNodeFlags_.open_on_double_click | imgui.TreeNodeFlags_.default_open
            if self.selected_index == idx:
                flags |= imgui.TreeNodeFlags_.selected
            
            # Check for children
            children = list(comp.get('children_indices', []))
            if not children:
                flags |= imgui.TreeNodeFlags_.leaf
            else:
                label += f" ({len(children)})"
            
            # Draw tree node
            is_open = imgui.tree_node_ex(f"##node_{idx}", flags, label)
            _store_item_rect(idx)

            # Custom drag/drop (avoid payload capsule issues)
            if imgui.is_item_active() and imgui.is_mouse_dragging(0):
                self._tree_drag_src = idx
                imgui.begin_tooltip()
                imgui.text(f"Move: {label}")
                imgui.end_tooltip()

            # Handle selection
            if imgui.is_item_clicked():
                self.selected_index = idx
                # Clear 3D scene selection
                if hasattr(self.world, 'selection') and self.world.selection:
                    self.world.selection.selectedNode = None
                    self.world.selection.clearSelectionBox()
                    self.world.selection.clearGizmo()
            
            # Right-click menu
            if imgui.begin_popup_context_item(f"##comp_ctx_{idx}"):
                if imgui.menu_item("删除", "", False)[0]:
                    self.luiFunction.delete_component(self, idx)
                    imgui.end_popup()
                    if is_open: imgui.tree_pop()
                    return False
                
                imgui.separator()
                if imgui.begin_menu("创建子组件"):
                    child_types = ['Button', 'Text', 'CheckBox', 'InputField', 'Slider', 'Frame', 'Plane','Image', 'Video','Progressbar','Selectbox','ScrollableRegion','TabbedFrame', 'VerticalLayout', 'HorizontalLayout']
                    cn_names = ['按钮', '标签', '复选框', '输入框', '滑块', '框架', '面板', '图片', '视频','进度条','下拉框','滚动区域','标签页', '垂直布局组', '水平布局组']
                    for ct_idx, ct in enumerate(child_types):
                        if imgui.menu_item(f"{cn_names[ct_idx]}", "", False)[0]:
                            self.create_child_component(idx, ct)
                    imgui.end_menu()
                imgui.end_popup()
            
            # Draw children if open
            if is_open:
                for child_idx in children:
                    # After a deletion, the list might have shifted, 
                    # so we check bounds again or just return False to stop this frame's recursion
                    if child_idx < len(self.components):
                        if not render_component_tree(child_idx):
                            # If a child (or sub-child) was deleted, indices shifted. 
                            # Stopping current rendering frame's branch is safest.
                            imgui.tree_pop()
                            return False
                imgui.tree_pop()
            return True

        # Find root components
        roots = []
        for i, comp in enumerate(self.components):
            p_idx = comp.get('parent_index')
            if p_idx is None or p_idx < 0:
                roots.append(i)

        # Maintain root order for sorting
        if not self.root_order:
            self.root_order = list(roots)
        else:
            self.root_order = [r for r in self.root_order if r in roots]
            for r in roots:
                if r not in self.root_order:
                    self.root_order.append(r)

        # Render roots
        for root_idx in self.root_order:
            if not render_component_tree(root_idx):
                break

        # Handle tree drop after full render (allows drop on earlier items)
        if self._tree_drag_src is not None and imgui.is_mouse_released(0):
            src_idx = self._tree_drag_src
            self._tree_drag_src = None
            mx, my = imgui.get_mouse_pos()
            target_idx = _hit_test_tree_item(mx, my)
            if target_idx is None:
                target_idx = -1
            if 0 <= src_idx < len(self.components):
                if target_idx == -1:
                    self._set_parent_root(src_idx, keep_world=True)
                elif target_idx != src_idx:
                    if target_idx in self._get_descendants(src_idx):
                        print("Invalid drop: cannot parent to descendant")
                    else:
                        src_parent = self.components[src_idx].get('parent_index', -1)
                        tgt_parent = self.components[target_idx].get('parent_index', -1)
                        io = imgui.get_io()
                        want_reorder = bool(getattr(io, 'key_shift', False))
                        if want_reorder and src_parent == tgt_parent:
                            if src_parent is None or src_parent < 0:
                                if not self.root_order:
                                    self.root_order = [i for i, c in enumerate(self.components) if c.get('parent_index') is None or c.get('parent_index') < 0]
                                self.root_order = self._reorder_list(self.root_order, src_idx, target_idx)
                            else:
                                parent_data = self.components[src_parent]
                                children = parent_data.get('children_indices', [])
                                parent_data['children_indices'] = self._reorder_list(children, src_idx, target_idx)
                        else:
                            self._set_parent_child_relationship(src_idx, target_idx, keep_world=True)

        # Clear drag state if released outside any item
        if self._tree_drag_src is not None and imgui.is_mouse_released(0):
            self._tree_drag_src = None
            
            imgui.spacing()
            imgui.separator()
            
            # Property Editing
            if self.selected_index >= 0 and self.selected_index < len(self.components):
                imgui.text("属性编辑")
                imgui.separator()
                self.luiFunction._draw_component_properties(self,self.selected_index)
            else:
                imgui.text_disabled("未选中任何组件")
            
            # Anchor popup
            if self.anchor_popup_open:
                imgui.open_popup("选择锚点位置")
            
            if imgui.begin_popup("选择锚点位置"):
                imgui.text("选择锚点位置:")
                
                # 中文显示名称
                anchor_names = {
                    'top-left': '左上', 'top-center': '中上', 'top-right': '右上',
                    'middle-left': '左中', 'center': '中心', 'middle-right': '右中',
                    'bottom-left': '左下', 'bottom-center': '中下', 'bottom-right': '右下'
                }
                
                anchor_positions = [
                    ['top-left', 'top-center', 'top-right'],
                    ['middle-left', 'center', 'middle-right'],
                    ['bottom-left', 'bottom-center', 'bottom-right']
                ]
                
                for row in anchor_positions:
                    for i, pos in enumerate(row):
                        button_text = anchor_names.get(pos, pos)
                        if imgui.button(f"{button_text}##popup_{pos}", (50, 25)):
                            # 使用新的锚点更新方法
                            if hasattr(self, '_temp_selected_index_for_anchor'):
                                selected_idx = self._temp_selected_index_for_anchor
                                self._update_component_anchor_position(selected_idx, pos)
                            
                            self.anchor_popup_open = False
                            if hasattr(self, '_temp_selected_index_for_anchor'):
                                delattr(self, '_temp_selected_index_for_anchor')
                            imgui.close_current_popup()
                        if i < len(row) - 1:
                            imgui.same_line()
                
                imgui.spacing()
                if imgui.button("取消"):
                    self.anchor_popup_open = False
                    if hasattr(self, '_temp_selected_index_for_anchor'):
                        delattr(self, '_temp_selected_index_for_anchor')
                    imgui.close_current_popup()
                
                imgui.end_popup()

    def _create_component_by_type(self, type_index):
        """Create LUI component by index - 默认生成在Canvas中心"""
        
        # 1. 确定生成位置 (默认 Canvas 中心)
        canvas_relative_x = 100
        canvas_relative_y = 100
        
        if self.current_canvas_index >= 0 and self.current_canvas_index < len(self.canvases):
            canvas_panel = self.canvases[self.current_canvas_index]['panel']
            canvas_width = canvas_panel.get_width()
            canvas_height = canvas_panel.get_height()
            
            # 根据组件类型预测尺寸，以便进行中心点对齐
            # 注意：这些是 lui_function.py 中定义的默认值
            comp_sizes = {
                0: (100, 30),  # Button
                1: (80, 20),   # Text
                2: (120, 20),  # Checkbox
                3: (200, 24),  # InputField
                4: (200, 16),  # Slider
                5: (300, 200), # Frame
                6: (100, 100), # Plane
                7: (100, 100), # Image
                8: (320, 240),  # Video
                9: (200, 30),   # Progressbar
                10: (200, 30),  # Selectbox
                11: (200, 200), # ScrollableRegion
                12: (300, 200), # TabbedFrame
                13: (300, 200), # VerticalLayout
                14: (300, 200)  # HorizontalLayout
            }

            
            w, h = comp_sizes.get(type_index, (100, 100))
            
            # 计算中心位置
            canvas_relative_x = (canvas_width - w) / 2
            canvas_relative_y = (canvas_height - h) / 2
            
            # 确保不超出合理范围 (防止 Canvas 太小时位置为负)
            canvas_relative_x = max(10, canvas_relative_x)
            canvas_relative_y = max(10, canvas_relative_y)
        
        try:
            if type_index == 0:  # Button
                self.luiFunction.create_button(self, text="New Button", x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 1:  # Text
                self.luiFunction.create_label(self, text="New Text", x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 2:  # Checkbox
                self.luiFunction.create_checkbox(self, label="Check box", x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 3:  # InputField
                self.luiFunction.create_input_field(self, text="", x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 4:  # Slider
                self.luiFunction.create_slider(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 5:  # Frame
                self.luiFunction.create_frame(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 6:  # Plane
                self.luiFunction.create_plane(self, x=canvas_relative_x, y=canvas_relative_y, color=(0.8, 0.8, 0.8, 1))
            elif type_index == 7:  # Image
                self.luiFunction.create_image(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 8:  # Video
                self.luiFunction.create_video(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 9:  # Progressbar
                self.luiFunction.create_progressbar(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 10: # Selectbox
                self.luiFunction.create_selectbox(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 11: # ScrollableRegion
                self.luiFunction.create_scrollable_region(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 12: # TabbedFrame
                self.luiFunction.create_tabbed_frame(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 13: # VerticalLayout
                self.luiFunction.create_vertical_layout(self, x=canvas_relative_x, y=canvas_relative_y)
            elif type_index == 14: # HorizontalLayout
                self.luiFunction.create_horizontal_layout(self, x=canvas_relative_x, y=canvas_relative_y)
            
            print(f"✓ 创建组件成功，已重定向至 Canvas 中心: ({canvas_relative_x:.1f}, {canvas_relative_y:.1f})")
            if hasattr(self.world, 'updateSceneTree'):
                self.world.updateSceneTree()
        except Exception as e:
            print(f"创建组件失败: {str(e)}")



    def set_component_anchor(self, comp_index, anchor_position):
        """设置组件锚点 - 保持向后兼容"""
        self._update_component_anchor_position(comp_index, anchor_position)

    def _update_anchored_children(self, parent_index):
        """Recursively update anchored/fill children."""
        if parent_index < 0 or parent_index >= len(self.components):
            return

        print(f"[_update_anchored_children] Updating children of #{parent_index}")
        parent_data = self.components[parent_index]
        children = parent_data.get('children_indices', [])
        for child_idx in children:
            if child_idx < len(self.components):
                child_data = self.components[child_idx]
                # Fill layout has priority over anchored positioning
                if child_data.get('layout_mode') == 'fill':
                    print(f"  -> Child #{child_idx} is FILL mode")
                    self._apply_fill_layout(child_idx)
                elif child_data.get('anchored_to_parent'):
                    anchor_pos = child_data.get('anchor_position')
                    manual_offset = (
                        child_data.get('anchor_manual_offset_x', 0.0),
                        child_data.get('anchor_manual_offset_y', 0.0)
                    )
                    if anchor_pos:
                        self._update_component_anchor_position(child_idx, anchor_pos, manual_offset)

                # Recurse into children
                self._update_anchored_children(child_idx)

    def _apply_fill_layout(self, comp_index):
        """Apply fill layout to component: match parent/canvas size with margins."""
        if comp_index < 0 or comp_index >= len(self.components):
            return

        comp_data = self.components[comp_index]
        comp_obj = comp_data.get('object')
        comp_type = comp_data.get('type', '')

        parent_width = None
        parent_height = None

        parent_index = comp_data.get('parent_index')
        if parent_index is not None and parent_index >= 0 and parent_index < len(self.components):
            parent_data = self.components[parent_index]
            parent_width = parent_data.get('width')
            parent_height = parent_data.get('height')
            parent_obj = parent_data.get('object')
            if parent_width is None and parent_obj is not None and hasattr(parent_obj, 'width'):
                parent_width = parent_obj.width
            if parent_height is None and parent_obj is not None and hasattr(parent_obj, 'height'):
                parent_height = parent_obj.height
        else:
            canvas_index = comp_data.get('canvas_index', self.current_canvas_index)
            if canvas_index is not None and canvas_index >= 0 and canvas_index < len(self.canvases):
                canvas_panel = self.canvases[canvas_index].get('panel')
                if canvas_panel is not None:
                    if hasattr(canvas_panel, 'width'):
                        parent_width = canvas_panel.width
                    elif hasattr(canvas_panel, 'get_width'):
                        parent_width = canvas_panel.get_width()
                    if hasattr(canvas_panel, 'height'):
                        parent_height = canvas_panel.height
                    elif hasattr(canvas_panel, 'get_height'):
                        parent_height = canvas_panel.get_height()

        # DEBUG: Trace fill layout calculations
        # print(f"[_apply_fill_layout] Comp #{comp_index} Parent #{parent_index}: PW={parent_width} PH={parent_height}")
        
        if parent_width is None or parent_height is None:
            # print(f"[_apply_fill_layout] Failed to get parent dimensions for Comp #{comp_index}")
            return

        margin_left = float(comp_data.get('fill_margin_left', 0.0))
        margin_right = float(comp_data.get('fill_margin_right', 0.0))
        margin_top = float(comp_data.get('fill_margin_top', 0.0))
        margin_bottom = float(comp_data.get('fill_margin_bottom', 0.0))

        new_left = margin_left
        new_top = margin_top
        new_width = float(parent_width) - (margin_left + margin_right)
        new_height = float(parent_height) - (margin_top + margin_bottom)

        if new_width < 1.0:
            new_width = 1.0
        if new_height < 1.0:
            new_height = 1.0

        comp_data['left'] = new_left
        comp_data['top'] = new_top
        comp_data['width'] = new_width
        comp_data['height'] = new_height

        if comp_obj is not None:
            # Handle visual_parent_canvas case: convert local to absolute
            abs_left = new_left
            abs_top = new_top
            
            if parent_index is not None and parent_index >= 0 and comp_data.get('visual_parent_canvas'):
                 p_abs_x, p_abs_y = self._get_component_accumulated_pos(parent_index)
                 abs_left = p_abs_x + new_left
                 abs_top = p_abs_y + new_top
            
            if hasattr(comp_obj, 'set_pos'):
                 comp_obj.set_pos(abs_left, abs_top)
            else:
                 if hasattr(comp_obj, 'left'):
                     comp_obj.left = abs_left
                 if hasattr(comp_obj, 'top'):
                     comp_obj.top = abs_top
            if hasattr(comp_obj, 'width'):
                comp_obj.width = new_width
            if hasattr(comp_obj, 'height'):
                comp_obj.height = new_height

        if comp_type in ['Plane', 'Image', 'Video'] and 'sprite' in comp_data:
            comp_data['sprite'].width = new_width
            comp_data['sprite'].height = new_height
        elif comp_type == 'Button':
            if hasattr(comp_obj, 'set_width'):
                comp_obj.set_width(new_width)
            if hasattr(comp_obj, 'set_height'):
                comp_obj.set_height(new_height)
            
            # Force update internal layout for Button to ensure fill works
            try:
                layout = getattr(comp_obj, '_layout', None)
                if layout:
                    if hasattr(layout, 'width'): layout.width = new_width 
                    if hasattr(layout, 'height'): layout.height = new_height
                    
                    # Inner layout
                    inner = getattr(layout, '_layout', None)
                    if inner:
                        if hasattr(inner, 'width'): inner.width = new_width 
                        if hasattr(inner, 'height'): inner.height = new_height
                        
                    # Mid sprite usually stretches
                    spr_mid = getattr(layout, '_sprite_mid', None)
                    if spr_mid:
                        spr_mid.width = new_width
                        spr_mid.height = new_height
            except Exception:
                pass
        elif comp_type == 'InputField':
            if hasattr(comp_obj, 'set_width'):
                comp_obj.set_width(new_width)
        elif comp_type == 'Slider':
            if hasattr(comp_obj, 'set_width'):
                comp_obj.set_width(new_width)


    def _apply_layout_spacing(self, layout_obj, spacing):
        try:
            if hasattr(layout_obj, 'set_spacing'):
                layout_obj.set_spacing(spacing)
            elif hasattr(layout_obj, 'setSpacing'):
                layout_obj.setSpacing(spacing)
            elif hasattr(layout_obj, 'spacing'):
                layout_obj.spacing = spacing
            elif hasattr(layout_obj, '_spacing'):
                layout_obj._spacing = spacing
        except Exception:
            pass

    def _apply_layout_alignment(self, layout_obj, align):
        try:
            if hasattr(layout_obj, 'set_alignment'):
                layout_obj.set_alignment(align)
            elif hasattr(layout_obj, 'alignment'):
                layout_obj.alignment = align
            elif hasattr(layout_obj, 'align'):
                layout_obj.align = align
        except Exception:
            pass

    def _update_layout_inner(self, comp_index):
        if comp_index < 0 or comp_index >= len(self.components):
            return

        comp_data = self.components[comp_index]
        layout_obj = comp_data.get('layout_obj')
        if layout_obj is None:
            return

        width = float(comp_data.get('width', 0.0))
        height = float(comp_data.get('height', 0.0))

        pad_left = float(comp_data.get('layout_padding_left', 0.0))
        pad_right = float(comp_data.get('layout_padding_right', 0.0))
        pad_top = float(comp_data.get('layout_padding_top', 0.0))
        pad_bottom = float(comp_data.get('layout_padding_bottom', 0.0))

        inner_w = max(1.0, width - (pad_left + pad_right))
        inner_h = max(1.0, height - (pad_top + pad_bottom))

        try:
            if hasattr(layout_obj, 'left'):
                layout_obj.left = pad_left
            if hasattr(layout_obj, 'top'):
                layout_obj.top = pad_top
            if hasattr(layout_obj, 'width'):
                layout_obj.width = inner_w
            if hasattr(layout_obj, 'height'):
                layout_obj.height = inner_h
            if hasattr(layout_obj, 'set_size'):
                layout_obj.set_size(inner_w, inner_h)
        except Exception:
            pass

        spacing = float(comp_data.get('layout_spacing', 0.0))
        self._apply_layout_spacing(layout_obj, spacing)

        align = comp_data.get('layout_align', None)
        if align:
            self._apply_layout_alignment(layout_obj, align)


        if comp_data.get('type') in ['HorizontalLayout', 'VerticalLayout']:
            self._apply_wrap_layout(comp_index)

        try:
            if hasattr(layout_obj, 'update'):
                layout_obj.update()
        except Exception:
            pass


    def _reparent_scrollable_children(self, parent_index):
        if parent_index < 0 or parent_index >= len(self.components):
            return
        parent_data = self.components[parent_index]
        if parent_data.get('type') != 'ScrollableRegion':
            return
        parent_obj = parent_data['object']
        try:
            content_node = parent_obj.content_node
        except Exception:
            return

        for child_idx in parent_data.get('children_indices', []):
            if child_idx < 0 or child_idx >= len(self.components):
                continue
            child_data = self.components[child_idx]
            child_obj = child_data.get('object')
            if child_obj is None:
                continue
            try:
                if hasattr(child_obj, 'reparent_to'):
                    child_obj.reparent_to(content_node)
                elif hasattr(child_obj, 'parent'):
                    child_obj.parent = content_node
            except Exception:
                pass

    def _apply_wrap_layout(self, parent_index):
        if parent_index < 0 or parent_index >= len(self.components):
            return

        parent_data = self.components[parent_index]
        layout_type = parent_data.get('type')
        if layout_type not in ['HorizontalLayout', 'VerticalLayout']:
            return
        if not parent_data.get('layout_wrap', True):
            return

        # Get parent absolute position for coordinate conversion
        parent_abs_left, parent_abs_top = self._get_component_accumulated_pos(parent_index)

        width = float(parent_data.get('width', 0.0))
        height = float(parent_data.get('height', 0.0))

        pad_left = float(parent_data.get('layout_padding_left', 0.0))
        pad_right = float(parent_data.get('layout_padding_right', 0.0))
        pad_top = float(parent_data.get('layout_padding_top', 0.0))
        pad_bottom = float(parent_data.get('layout_padding_bottom', 0.0))
        spacing = float(parent_data.get('layout_spacing', 0.0))
        line_spacing = float(parent_data.get('layout_line_spacing', 0.0))

        inner_w = max(1.0, width - (pad_left + pad_right))
        inner_h = max(1.0, height - (pad_top + pad_bottom))

        if layout_type == 'HorizontalLayout':
            x = pad_left
            y = pad_top
            row_h = 0.0

            for child_idx in parent_data.get('children_indices', []):
                if child_idx < 0 or child_idx >= len(self.components):
                    continue
                child = self.components[child_idx]
                child_obj = child.get('object')

                cw = float(child.get('width', 0.0))
                ch = float(child.get('height', 0.0))
                # Allow layout even if size is 0, but usually skip
                # if cw <= 0 or ch <= 0: continue 

                if x > pad_left and (x + cw) > (pad_left + inner_w):
                    x = pad_left
                    y += row_h + line_spacing
                    row_h = 0.0

                # Data stores relative position (to parent)
                child['left'] = x
                child['top'] = y
                
                # Update visual object
                try:
                    child_parent = getattr(child_obj, 'parent', None)
                    parent_obj = parent_data.get('object')
                    
                    if child_parent is not None and child_parent == parent_obj:
                         # Child is parented to layout object: use relative coordinates
                         if hasattr(child_obj, 'left'):
                             child_obj.left = x
                         if hasattr(child_obj, 'top'):
                             child_obj.top = y
                         if hasattr(child_obj, 'set_pos'):
                             child_obj.set_pos(x, y)
                    else:
                        # Child is NOT parented to layout object (e.g. at root): use absolute coordinates
                        abs_x = parent_abs_left + x
                        abs_y = parent_abs_top + y
                        
                        if hasattr(child_obj, 'left'):
                            child_obj.left = abs_x
                        if hasattr(child_obj, 'top'):
                            child_obj.top = abs_y
                        if hasattr(child_obj, 'set_pos'):
                            child_obj.set_pos(abs_x, abs_y)
                except Exception:
                    pass
                
                # Recursively update child layout/visuals
                if child.get('type') in ['HorizontalLayout', 'VerticalLayout'] and child.get('layout_wrap', True):
                    self._apply_wrap_layout(child_idx)
                elif child.get('children_indices'):
                    self._sync_canvas_children(child_idx)

                row_h = max(row_h, ch)
                x += cw + spacing
        else:
            # Vertical wrap: flow top->bottom, then next column
            x = pad_left
            y = pad_top
            col_w = 0.0

            for child_idx in parent_data.get('children_indices', []):
                if child_idx < 0 or child_idx >= len(self.components):
                    continue
                child = self.components[child_idx]
                child_obj = child.get('object')

                cw = float(child.get('width', 0.0))
                ch = float(child.get('height', 0.0))
                
                if y > pad_top and (y + ch) > (pad_top + inner_h):
                    y = pad_top
                    x += col_w + line_spacing
                    col_w = 0.0

                child['left'] = x
                child['top'] = y
                
                try:
                    child_parent = getattr(child_obj, 'parent', None)
                    parent_obj = parent_data.get('object')
                    
                    if child_parent is not None and child_parent == parent_obj:
                         # Child is parented to layout object: use relative coordinates
                         if hasattr(child_obj, 'left'):
                             child_obj.left = x
                         if hasattr(child_obj, 'top'):
                             child_obj.top = y
                         if hasattr(child_obj, 'set_pos'):
                             child_obj.set_pos(x, y)
                    else:
                        # Child is NOT parented to layout object (e.g. at root): use absolute coordinates
                        abs_x = parent_abs_left + x
                        abs_y = parent_abs_top + y
                        
                        if hasattr(child_obj, 'left'):
                            child_obj.left = abs_x
                        if hasattr(child_obj, 'top'):
                            child_obj.top = abs_y
                        if hasattr(child_obj, 'set_pos'):
                            child_obj.set_pos(abs_x, abs_y)
                except Exception:
                    pass
                
                # If child is also a layout, recursively update it
                if child.get('type') in ['HorizontalLayout', 'VerticalLayout'] and child.get('layout_wrap', True):
                    self._apply_wrap_layout(child_idx)
                # If child is NOT a layout but has children (like a Frame with children), update their visual text
                elif child.get('children_indices'):
                    self._sync_canvas_children(child_idx)

                col_w = max(col_w, cw)
                y += ch + spacing

    def get_selected_component(self):
        """获取当前选中的组件"""
        if self.selected_index >= 0 and self.selected_index < len(self.components):
            return self.components[self.selected_index]
        return None

    def select_component(self, index):
        """选中指定索引的组件"""
        if 0 <= index < len(self.components):
            self.selected_index = index
            print(f"✓ 选中组件 #{index}: {self.components[index]['type']}")
        else:
            self.selected_index = -1

    def deselect_all(self):
        """取消选中所有组件"""
        if getattr(self, '_force_keep_selection_frames', 0) > 0:
            return
        self.selected_index = -1
        print("✓ 已取消选中所有组件")

    def _change_image_texture(self, title = "选择文件",filetypes=None,initialdir=None):
        """更改图像组件的纹理"""
        try:
            import tkinter as tk
            from tkinter import filedialog

            root = tk.Tk()
            root.withdraw()
            root.attributes('-topmost',True)

            if filetypes is None:
                filetypes = [("所有文件","*.*")]

            file_path = filedialog.askopenfilename(
                title = title,
                filetypes = filetypes,
                initialdir = initialdir
            )
            root.destroy()

            if file_path:
                return file_path
            return None
            
        except Exception as e:
            print(f"更改纹理失败: {e}")

    def _update_component_anchor_position(self, comp_index, anchor_position, manual_offset=(0.0, 0.0)):
        """更新组件的锚点位置"""
        if comp_index < 0 or comp_index >= len(self.components):
            return
        

        
        comp_data = self.components[comp_index]
        comp_obj = comp_data['object']
        
        # Update data
        comp_data['anchor_position'] = anchor_position
        comp_data['anchored_to_parent'] = True
        comp_data['anchor_manual_offset_x'] = manual_offset[0]
        comp_data['anchor_manual_offset_y'] = manual_offset[1]
        
        # Determine strict parent reference
        parent_index = comp_data.get('parent_index')
        parent_width = 0
        parent_height = 0
        
        if parent_index is not None and parent_index >= 0:
             parent_data = self.components[parent_index]
             parent_width = parent_data.get('width', 100)
             parent_height = parent_data.get('height', 30)
             # Try to get actual object size if available
             p_obj = parent_data.get('object')
             if p_obj:
                 if hasattr(p_obj, 'width') and p_obj.width > 0: parent_width = p_obj.width
                 if hasattr(p_obj, 'height') and p_obj.height > 0: parent_height = p_obj.height
        elif self.current_canvas_index >= 0:
             # Canvas anchor
             canvas = self.canvases[self.current_canvas_index]['panel']
             if hasattr(canvas, 'get_width'):
                 parent_width = canvas.get_width()
                 parent_height = canvas.get_height()
             else:
                 parent_width = canvas.width
                 parent_height = canvas.height
             
        # Calculate anchor point in parent local space
        anchor_ratios = {
            'top-left': (0, 0), 'top-center': (0.5, 0), 'top-right': (1, 0),
            'middle-left': (0, 0.5), 'center': (0.5, 0.5), 'middle-right': (1, 0.5),
            'bottom-left': (0, 1), 'bottom-center': (0.5, 1), 'bottom-right': (1, 1)
        }
        rx, ry = anchor_ratios.get(anchor_position, (0, 0))
        
        anchor_x = parent_width * rx
        anchor_y = parent_height * ry
        
        child_width = comp_data.get('width', 0)
        child_height = comp_data.get('height', 0)
        # Try to get actual object size
        if hasattr(comp_obj, 'width') and comp_obj.width > 0: child_width = comp_obj.width
        if hasattr(comp_obj, 'height') and comp_obj.height > 0: child_height = comp_obj.height
        
        # Center child on anchor (pivot logic)
        child_left = anchor_x - (child_width * rx) + manual_offset[0]
        child_top = anchor_y - (child_height * ry) + manual_offset[1]
        
        # Update logical position data
        comp_data['left'] = child_left
        comp_data['top'] = child_top
        
        # Update visual position
        if parent_index is not None and parent_index >= 0:
             # Check if visually parented to canvas (absolute positioning needed)
             if comp_data.get('visual_parent_canvas'):
                 p_abs_x, p_abs_y = self._get_component_accumulated_pos(parent_index)
                 abs_left = p_abs_x + child_left
                 abs_top = p_abs_y + child_top
                 
                 # Prefer left/top properties for LUI objects
                 if hasattr(comp_obj, 'left') and hasattr(comp_obj, 'top'):
                     comp_obj.left = abs_left
                     comp_obj.top = abs_top
                 elif hasattr(comp_obj, 'set_pos'):
                     try:
                         comp_obj.set_pos(abs_left, abs_top)
                     except TypeError:
                         # Fallback for NodePath-like objects requiring 3 args
                         comp_obj.set_pos(abs_left, abs_top, 0)
             else:
                 # Standard local parenting
                 if hasattr(comp_obj, 'left') and hasattr(comp_obj, 'top'):
                     comp_obj.left = child_left
                     comp_obj.top = child_top
                 elif hasattr(comp_obj, 'set_pos'):
                     try:
                         comp_obj.set_pos(child_left, child_top)
                     except TypeError:
                         comp_obj.set_pos(child_left, child_top, 0)
        else:
             # Canvas root
             if hasattr(comp_obj, 'left') and hasattr(comp_obj, 'top'):
                 comp_obj.left = child_left
                 comp_obj.top = child_top
             elif hasattr(comp_obj, 'set_pos'):
                 try:
                     comp_obj.set_pos(child_left, child_top)
                 except TypeError:
                     comp_obj.set_pos(child_left, child_top, 0)
                     
        print(f"✓ 已更新锚点位置: {anchor_position} -> ({child_left:.1f}, {child_top:.1f})")
        
        # Update children positions (for visual_parent_canvas or anchored children)
        self._sync_canvas_children(comp_index)
        self._update_anchored_children(comp_index)

    def _handle_anchor_popup(self):
        """Handle component anchor selection popup"""
        if imgui.begin_popup("选择锚点位置"):
            imgui.text("选择锚点位置:")
            
            anchor_names = {
                'top-left': '左上', 'top-center': '中上', 'top-right': '右上',
                'middle-left': '左中', 'center': '中心', 'middle-right': '右中',
                'bottom-left': '左下', 'bottom-center': '中下', 'bottom-right': '右下'
            }
            
            anchor_positions = [
                ['top-left', 'top-center', 'top-right'],
                ['middle-left', 'center', 'middle-right'],
                ['bottom-left', 'bottom-center', 'bottom-right']
            ]
            
            for row in anchor_positions:
                for i, pos in enumerate(row):
                    button_text = anchor_names.get(pos, pos)
                    if imgui.button(f"{button_text}##popup_{pos}", (50, 25)):
                        if hasattr(self, '_temp_selected_index_for_anchor'):
                            selected_idx = self._temp_selected_index_for_anchor
                            # Reset manual offset by passing (0,0) explicitly to match original behavior logic
                            self._update_component_anchor_position(selected_idx, pos, manual_offset=(0.0, 0.0))
                            
                            # Clean up temp attribute
                            delattr(self, '_temp_selected_index_for_anchor')
                        
                        # Reset flag if used elsewhere
                        self.anchor_popup_open = False
                        imgui.close_current_popup()
                        
                    if i < len(row) - 1:
                        imgui.same_line()
            
            imgui.spacing()
            if imgui.button("取消", (160, 25)):
                self.anchor_popup_open = False
                if hasattr(self, '_temp_selected_index_for_anchor'):
                    delattr(self, '_temp_selected_index_for_anchor')
                imgui.close_current_popup()
            
            imgui.end_popup()