1725 lines
79 KiB
Python
1725 lines
79 KiB
Python
"""LUIManager tree/editor/layout mixin."""
|
||
|
||
import struct
|
||
from pathlib import Path
|
||
|
||
import panda3d.core as p3d
|
||
from imgui_bundle import imgui, imgui_ctx
|
||
|
||
|
||
class LUIManagerEditorMixin:
|
||
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', 'HttpText',
|
||
'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', 'HttpText']:
|
||
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', 'HttpText'] 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),
|
||
'HttpText': (320, 120),
|
||
'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 == 'HttpText':
|
||
child_obj = self.luiFunction.create_http_text(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)", "HTTP文本 (HttpText)",
|
||
"进度条 (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', 'HttpText', 'Progressbar','Selectbox','ScrollableRegion','TabbedFrame', 'VerticalLayout', 'HorizontalLayout']
|
||
cn_names = ['按钮', '标签', '复选框', '输入框', '滑块', '框架', '面板', '图片', '视频', 'HTTP文本', '进度条','下拉框','滚动区域','标签页', '垂直布局组', '水平布局组']
|
||
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: (320, 120), # HttpText
|
||
10: (200, 30), # Progressbar
|
||
11: (200, 30), # Selectbox
|
||
12: (200, 200), # ScrollableRegion
|
||
13: (300, 200), # TabbedFrame
|
||
14: (300, 200), # VerticalLayout
|
||
15: (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: # HttpText
|
||
self.luiFunction.create_http_text(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 10: # Progressbar
|
||
self.luiFunction.create_progressbar(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 11: # Selectbox
|
||
self.luiFunction.create_selectbox(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 12: # ScrollableRegion
|
||
self.luiFunction.create_scrollable_region(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 13: # TabbedFrame
|
||
self.luiFunction.create_tabbed_frame(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 14: # VerticalLayout
|
||
self.luiFunction.create_vertical_layout(self, x=canvas_relative_x, y=canvas_relative_y)
|
||
elif type_index == 15: # 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', 'HttpText'] and 'sprite' in comp_data:
|
||
comp_data['sprite'].width = new_width
|
||
comp_data['sprite'].height = new_height
|
||
if comp_type == 'HttpText':
|
||
self.luiFunction.sync_http_text_layout(self, comp_data)
|
||
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()
|