1564 lines
64 KiB
Python
1564 lines
64 KiB
Python
"""LUIManager interaction and resize mixin."""
|
||
|
||
import struct
|
||
from pathlib import Path
|
||
|
||
import panda3d.core as p3d
|
||
from imgui_bundle import imgui, imgui_ctx
|
||
|
||
|
||
class LUIManagerInteractionMixin:
|
||
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 _clear_pending_drag_state(self):
|
||
"""清空 pending 拖拽状态。"""
|
||
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
|
||
|
||
def _has_mouse_for_drag(self):
|
||
"""检查是否存在可用鼠标输入。"""
|
||
return hasattr(self.world, 'mouseWatcherNode') and self.world.mouseWatcherNode.hasMouse()
|
||
|
||
def _is_left_mouse_down(self):
|
||
"""检查鼠标左键是否按下。"""
|
||
import panda3d.core as p3d
|
||
return self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one())
|
||
|
||
def _get_mouse_pixel_data(self):
|
||
"""获取鼠标像素坐标及窗口尺寸。"""
|
||
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
|
||
return pixel_x, pixel_y, win_x, win_y
|
||
|
||
def _find_canvas_data_by_panel(self, canvas_panel):
|
||
"""按 panel 对象查找 canvas 配置。"""
|
||
for c in self.canvases:
|
||
if c['panel'] == canvas_panel:
|
||
return c
|
||
return None
|
||
|
||
def _process_canvas_drag(self):
|
||
"""处理 Canvas 拖动，返回是否已处理该帧。"""
|
||
if not (hasattr(self, 'dragging_canvas') and self.dragging_canvas):
|
||
return False
|
||
|
||
canvas_data = self._find_canvas_data_by_panel(self.dragging_canvas)
|
||
if canvas_data and canvas_data.get('fixed', False):
|
||
return True
|
||
|
||
if not self._has_mouse_for_drag():
|
||
return True
|
||
|
||
if not self._is_left_mouse_down():
|
||
self.dragging_canvas = None
|
||
return True
|
||
|
||
pixel_x, pixel_y, _, _ = self._get_mouse_pixel_data()
|
||
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 True
|
||
|
||
def _try_start_pending_component_drag(self):
|
||
"""处理 pending 拖拽转正，返回是否需要本帧提前结束。"""
|
||
if self.dragging_comp is not None:
|
||
return False
|
||
|
||
if self.pending_drag_comp is None:
|
||
return True
|
||
|
||
if not self._has_mouse_for_drag():
|
||
return True
|
||
|
||
if not self._is_left_mouse_down():
|
||
# click without drag
|
||
self._clear_pending_drag_state()
|
||
return True
|
||
|
||
pixel_x, pixel_y, _, _ = self._get_mouse_pixel_data()
|
||
|
||
if self.pending_drag_start_mouse is None:
|
||
self.pending_drag_start_mouse = (pixel_x, pixel_y)
|
||
return True
|
||
|
||
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 True
|
||
|
||
# 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 Exception:
|
||
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)
|
||
|
||
self._clear_pending_drag_state()
|
||
return False
|
||
|
||
def _finish_component_drag_if_released(self):
|
||
"""在鼠标释放时完成拖拽收尾，返回是否已处理该帧。"""
|
||
if not self._is_left_mouse_down():
|
||
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 True
|
||
return False
|
||
|
||
def _resolve_canvas_metrics_for_drag(self, win_x, win_y):
|
||
"""获取当前 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 Exception:
|
||
# 如果获取失败，使用默认值
|
||
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)
|
||
|
||
return canvas_abs_left, canvas_abs_top, canvas_width, canvas_height
|
||
|
||
def _update_active_component_drag(self, pixel_x, pixel_y, win_x, win_y):
|
||
"""更新已开始拖拽的组件位置。"""
|
||
# 计算新的绝对位置（减去偏移量）
|
||
new_abs_left = pixel_x - self.drag_offset[0]
|
||
new_abs_top = pixel_y - self.drag_offset[1]
|
||
|
||
# 获取Canvas信息
|
||
canvas_abs_left, canvas_abs_top, canvas_width, canvas_height = self._resolve_canvas_metrics_for_drag(win_x, win_y)
|
||
|
||
# 转换为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)
|
||
|
||
# 如果有父组件，需要转换为相对于父组件的局部坐标
|
||
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相对坐标
|
||
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)
|
||
|
||
def _update_drag(self, task):
|
||
"""每帧更新拖动状态 - 支持Canvas边界约束和局部坐标"""
|
||
if getattr(self, 'play_mode', False):
|
||
# Disable editor drag logic while in play mode
|
||
return task.cont
|
||
|
||
if self._process_canvas_drag():
|
||
return task.cont
|
||
|
||
if self._try_start_pending_component_drag():
|
||
return task.cont
|
||
|
||
if not self._has_mouse_for_drag():
|
||
return task.cont
|
||
|
||
if self._finish_component_drag_if_released():
|
||
return task.cont
|
||
|
||
pixel_x, pixel_y, win_x, win_y = self._get_mouse_pixel_data()
|
||
self._update_active_component_drag(pixel_x, pixel_y, win_x, win_y)
|
||
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', 'HttpText']:
|
||
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 _update_http_components_task(self, task):
|
||
"""Drive async updates for HttpText components."""
|
||
if not self.lui_enabled:
|
||
return task.cont
|
||
try:
|
||
self.luiFunction.update_http_components(self)
|
||
except Exception:
|
||
pass
|
||
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 拖拽（编排入口）。"""
|
||
self._handle_resize_drag_core()
|
||
|
||
def _handle_resize_drag_core(self):
|
||
"""处理resize拖拽 - 完整功能实现，支持Shift和Alt键操作"""
|
||
if not hasattr(self.world, 'mouseWatcherNode') or not self.world.mouseWatcherNode.hasMouse():
|
||
return
|
||
|
||
import panda3d.core as p3d
|
||
if self._finish_resize_drag_if_released(p3d):
|
||
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']
|
||
|
||
new_left, new_top, new_width, new_height = self._compute_resize_drag_bounds(
|
||
delta_x, delta_y, shift_held, alt_held
|
||
)
|
||
|
||
if self.selected_index < 0:
|
||
return
|
||
|
||
comp_data = self.components[self.selected_index]
|
||
self._apply_resize_drag_updates(
|
||
comp_data, comp_obj, comp_type,
|
||
new_left, new_top, new_width, new_height,
|
||
shift_held, alt_held,
|
||
)
|
||
|
||
def _finish_resize_drag_if_released(self, p3d):
|
||
"""鼠标释放时结束缩放并执行收尾同步。"""
|
||
if self.world.mouseWatcherNode.is_button_down(p3d.MouseButton.one()):
|
||
return False
|
||
|
||
if self.resizing_handle and self.selected_index >= 0 and self.selected_index < len(self.components):
|
||
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 True
|
||
|
||
def _compute_resize_drag_bounds(self, delta_x, delta_y, shift_held, alt_held):
|
||
"""根据当前手柄/修饰键计算新的 left/top/width/height。"""
|
||
start_left, start_top, start_width, start_height, aspect_ratio = self._get_resize_start_values()
|
||
handle_pos = self.resizing_handle._resize_position
|
||
|
||
new_left, new_top, new_width, new_height = self._apply_resize_handle_delta(
|
||
handle_pos, start_left, start_top, start_width, start_height, delta_x, delta_y
|
||
)
|
||
new_left, new_top, new_width, new_height = self._apply_resize_min_size_clamp(
|
||
handle_pos, start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height,
|
||
)
|
||
|
||
if shift_held:
|
||
new_left, new_top, new_width, new_height = self._apply_shift_keep_ratio_resize(
|
||
handle_pos, start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height, aspect_ratio,
|
||
)
|
||
|
||
if alt_held:
|
||
new_left, new_top, new_width, new_height = self._apply_alt_center_resize(
|
||
start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height,
|
||
)
|
||
|
||
self._cache_resize_canvas_bounds()
|
||
return self._sanitize_resize_dimensions(new_left, new_top, new_width, new_height)
|
||
|
||
def _apply_resize_drag_updates(
|
||
self, comp_data, comp_obj, comp_type,
|
||
new_left, new_top, new_width, new_height,
|
||
shift_held, alt_held,
|
||
):
|
||
"""将缩放结果写回组件数据与渲染对象。"""
|
||
parent_index, parent_offset_x, parent_offset_y, is_scene_parented = self._resolve_resize_parent_context(
|
||
comp_data, comp_obj
|
||
)
|
||
_ = parent_index
|
||
|
||
self._write_resize_component_data(comp_data, new_left, new_top, new_width, new_height)
|
||
self._apply_resize_component_position(
|
||
comp_obj, new_left, new_top, parent_offset_x, parent_offset_y, is_scene_parented
|
||
)
|
||
|
||
try:
|
||
self._apply_resize_component_size_by_type(comp_data, comp_obj, comp_type, new_width, new_height)
|
||
self._post_resize_component_sync(comp_type, shift_held, alt_held)
|
||
except Exception as e:
|
||
print(f"⚠ 设置组件尺寸失败 ({comp_type}): {e}")
|
||
|
||
def _get_resize_start_values(self):
|
||
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
|
||
return start_left, start_top, start_width, start_height, aspect_ratio
|
||
|
||
def _apply_resize_handle_delta(
|
||
self, handle_pos, start_left, start_top, start_width, start_height, delta_x, delta_y
|
||
):
|
||
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
|
||
|
||
return new_left, new_top, new_width, new_height
|
||
|
||
def _apply_resize_min_size_clamp(
|
||
self, handle_pos, start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height,
|
||
):
|
||
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
|
||
|
||
return new_left, new_top, new_width, new_height
|
||
|
||
def _apply_shift_keep_ratio_resize(
|
||
self, handle_pos, start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height, aspect_ratio,
|
||
):
|
||
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
|
||
|
||
return new_left, new_top, new_width, new_height
|
||
|
||
def _apply_alt_center_resize(
|
||
self, start_left, start_top, start_width, start_height,
|
||
new_left, new_top, new_width, new_height,
|
||
):
|
||
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
|
||
|
||
return new_left, new_top, new_width, new_height
|
||
|
||
def _cache_resize_canvas_bounds(self):
|
||
canvas_width = 800
|
||
canvas_height = 600
|
||
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()
|
||
_ = (canvas_width, canvas_height)
|
||
|
||
def _sanitize_resize_dimensions(self, new_left, new_top, new_width, new_height):
|
||
if new_width < 1.0:
|
||
new_width = 1.0
|
||
if new_height < 1.0:
|
||
new_height = 1.0
|
||
return new_left, new_top, new_width, new_height
|
||
|
||
def _resolve_resize_parent_context(self, comp_data, comp_obj):
|
||
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)
|
||
|
||
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')
|
||
is_scene_parented = (child_parent is not None and child_parent == parent_obj)
|
||
return parent_index, parent_offset_x, parent_offset_y, is_scene_parented
|
||
|
||
def _write_resize_component_data(self, comp_data, new_left, new_top, new_width, new_height):
|
||
comp_data['left'] = new_left
|
||
comp_data['top'] = new_top
|
||
comp_data['width'] = new_width
|
||
comp_data['height'] = new_height
|
||
|
||
def _apply_resize_component_position(
|
||
self, comp_obj, new_left, new_top, parent_offset_x, parent_offset_y, is_scene_parented
|
||
):
|
||
if is_scene_parented:
|
||
comp_obj.left = new_left
|
||
comp_obj.top = new_top
|
||
else:
|
||
comp_obj.left = parent_offset_x + new_left
|
||
comp_obj.top = parent_offset_y + new_top
|
||
|
||
def _apply_resize_component_size_by_type(self, comp_data, comp_obj, comp_type, new_width, new_height):
|
||
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', 'HttpText']:
|
||
sprite = comp_data.get('sprite')
|
||
if sprite is not None:
|
||
sprite.width = new_width
|
||
sprite.height = new_height
|
||
if comp_type == 'HttpText':
|
||
self.luiFunction.sync_http_text_layout(self, comp_data)
|
||
elif comp_type == 'Button':
|
||
self._apply_button_resize_size(comp_obj, new_width, new_height)
|
||
elif comp_type == 'InputField':
|
||
self._apply_input_field_resize_size(comp_obj, new_width, new_height)
|
||
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)
|
||
|
||
def _apply_button_resize_size(self, comp_obj, new_width, new_height):
|
||
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()
|
||
|
||
def _apply_input_field_resize_size(self, comp_obj, new_width, new_height):
|
||
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
|
||
self._sync_input_field_layout_stretch(comp_obj)
|
||
|
||
def _sync_input_field_layout_stretch(self, comp_obj):
|
||
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
|
||
|
||
def _post_resize_component_sync(self, comp_type, shift_held, alt_held):
|
||
if comp_type in ['VerticalLayout', 'HorizontalLayout']:
|
||
self._update_layout_inner(self.selected_index)
|
||
|
||
self._update_anchored_children(self.selected_index)
|
||
modifier_str = self._get_resize_modifier_info(shift_held, alt_held)
|
||
_ = modifier_str
|
||
|
||
def _get_resize_modifier_info(self, shift_held, alt_held):
|
||
modifier_info = []
|
||
if shift_held:
|
||
modifier_info.append('Shift(keep ratio)')
|
||
if alt_held:
|
||
modifier_info.append('Alt(center scale)')
|
||
return ' + '.join(modifier_info) if modifier_info else 'Normal'
|