386 lines
14 KiB
GDScript
386 lines
14 KiB
GDScript
class_name EditorContextMenu
|
|
extends PopupPanel
|
|
## Shared Studio List popup used by right-click menus in both standalone editors.
|
|
|
|
signal id_pressed(id: int)
|
|
|
|
enum ItemRole { NORMAL, DESTRUCTIVE }
|
|
|
|
const DEFAULT_EDITOR := &"prop"
|
|
const DEFAULT_MIN_WIDTH := 208
|
|
const DEFAULT_ROW_HEIGHT := 48
|
|
const DEFAULT_GROUP_GAP := 8
|
|
const SHELL_INSET := 8
|
|
const ROW_RADIUS := 6
|
|
const TARGET_GAP := 12.0
|
|
|
|
var _visual_theme: EditorVisualTheme
|
|
var _editor: StringName = DEFAULT_EDITOR
|
|
var _font_size_override: int = -1
|
|
var _shell: MarginContainer
|
|
var _scroll: ScrollContainer
|
|
var _items: VBoxContainer
|
|
var _row_buttons: Array[Button] = []
|
|
var _row_ids: Dictionary = {}
|
|
var _keyboard_navigation_active: bool = false
|
|
var _focused_row_index: int = -1
|
|
|
|
|
|
func _ready() -> void:
|
|
_build_contents()
|
|
if not about_to_popup.is_connected(_reset_keyboard_navigation):
|
|
about_to_popup.connect(_reset_keyboard_navigation)
|
|
if not popup_hide.is_connected(_reset_keyboard_navigation):
|
|
popup_hide.connect(_reset_keyboard_navigation)
|
|
if _visual_theme != null:
|
|
_apply_visual_style()
|
|
|
|
|
|
func configure(visual_theme: EditorVisualTheme, editor: StringName) -> void:
|
|
_visual_theme = visual_theme
|
|
_editor = editor
|
|
if is_node_ready():
|
|
_apply_visual_style()
|
|
|
|
|
|
func set_font_size(size: int) -> void:
|
|
_font_size_override = maxi(1, size)
|
|
if is_node_ready():
|
|
_apply_visual_style()
|
|
|
|
|
|
func clear() -> void:
|
|
_reset_keyboard_navigation()
|
|
_row_buttons.clear()
|
|
_row_ids.clear()
|
|
if _items == null:
|
|
return
|
|
for child: Node in _items.get_children():
|
|
_items.remove_child(child)
|
|
child.free()
|
|
|
|
|
|
func add_item(label: String, id: int, role: ItemRole = ItemRole.NORMAL) -> void:
|
|
if _items == null:
|
|
_build_contents()
|
|
var button := Button.new()
|
|
button.text = label
|
|
button.alignment = HORIZONTAL_ALIGNMENT_LEFT
|
|
button.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
button.custom_minimum_size = Vector2(_menu_min_width(), _menu_row_height())
|
|
button.focus_mode = Control.FOCUS_NONE
|
|
button.mouse_default_cursor_shape = Control.CURSOR_POINTING_HAND
|
|
button.add_theme_font_size_override("font_size", _font_size())
|
|
button.add_theme_color_override("font_color", _text_color(role))
|
|
button.add_theme_color_override("font_hover_color", _text_color(role))
|
|
button.add_theme_color_override("font_pressed_color", _text_color(role))
|
|
button.add_theme_color_override("font_focus_color", _text_color(role))
|
|
button.add_theme_stylebox_override("normal", _make_row_box(Color(0.0, 0.0, 0.0, 0.0), Color(0, 0, 0, 0), 0))
|
|
button.add_theme_stylebox_override("hover", _make_hover_box())
|
|
button.add_theme_stylebox_override("pressed", _make_hover_box(true))
|
|
button.add_theme_stylebox_override("focus", _make_focus_box())
|
|
button.add_theme_stylebox_override("disabled", _make_row_box(Color(0.0, 0.0, 0.0, 0.0), Color(0, 0, 0, 0), 0))
|
|
button.set_meta("context_menu_id", id)
|
|
button.set_meta("context_menu_role", role)
|
|
button.pressed.connect(_on_row_pressed.bind(button))
|
|
button.mouse_entered.connect(_on_row_mouse_entered.bind(button))
|
|
_items.add_child(button)
|
|
_row_buttons.append(button)
|
|
_row_ids[id] = button
|
|
|
|
|
|
func add_destructive_item(label: String, id: int) -> void:
|
|
add_item(label, id, ItemRole.DESTRUCTIVE)
|
|
|
|
|
|
func add_separator() -> void:
|
|
if _items == null:
|
|
_build_contents()
|
|
var spacer := MarginContainer.new()
|
|
spacer.custom_minimum_size.y = float(DEFAULT_GROUP_GAP + 1)
|
|
spacer.add_theme_constant_override("margin_top", int(DEFAULT_GROUP_GAP / 2))
|
|
spacer.add_theme_constant_override("margin_bottom", int(DEFAULT_GROUP_GAP / 2))
|
|
var line := ColorRect.new()
|
|
line.color = _theme_color(&"border", Color(1, 1, 1, 0.2))
|
|
line.custom_minimum_size.y = 1.0
|
|
line.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
spacer.add_child(line)
|
|
_items.add_child(spacer)
|
|
|
|
|
|
func popup_at(global_position: Vector2, avoid_rect: Rect2 = Rect2()) -> void:
|
|
if _items == null:
|
|
_build_contents()
|
|
var parent_viewport: Viewport = get_parent().get_viewport() if get_parent() != null else get_viewport()
|
|
var safe_rect: Rect2 = parent_viewport.get_visible_rect()
|
|
var margin := 8.0
|
|
var popup_size := _items.get_combined_minimum_size() + Vector2(SHELL_INSET * 2, SHELL_INSET * 2)
|
|
var border_width := float(_theme_px(&"normal_border", 1))
|
|
popup_size += Vector2(border_width * 2.0, border_width * 2.0)
|
|
popup_size.x = maxf(popup_size.x, float(_menu_min_width() + SHELL_INSET * 2))
|
|
var max_popup_size := Vector2(maxf(1.0, safe_rect.size.x - margin * 2.0), maxf(1.0, safe_rect.size.y - margin * 2.0))
|
|
popup_size = popup_size.min(max_popup_size)
|
|
if _scroll != null:
|
|
var content_height: float = _items.get_combined_minimum_size().y
|
|
var available_content_height: float = max_popup_size.y - float(SHELL_INSET * 2) - border_width * 2.0
|
|
_scroll.vertical_scroll_mode = ScrollContainer.SCROLL_MODE_AUTO if content_height > available_content_height else ScrollContainer.SCROLL_MODE_DISABLED
|
|
size = Vector2i(popup_size.ceil())
|
|
if _scroll != null:
|
|
_scroll.scroll_vertical = 0
|
|
var max_x := maxf(safe_rect.position.x + margin, safe_rect.end.x - popup_size.x - margin)
|
|
var max_y := maxf(safe_rect.position.y + margin, safe_rect.end.y - popup_size.y - margin)
|
|
var popup_origin := _choose_popup_origin(
|
|
global_position,
|
|
avoid_rect,
|
|
popup_size,
|
|
safe_rect,
|
|
margin,
|
|
max_x,
|
|
max_y
|
|
)
|
|
var popup_position := Vector2i(popup_origin.round())
|
|
popup_on_parent(Rect2i(popup_position, Vector2i.ONE))
|
|
# PopupPanel sizes itself from the child layout on popup. Reapply the measured
|
|
# target size after opening so the scroll region can honor the 48 px rows.
|
|
size = Vector2i(popup_size.ceil())
|
|
var actual_size := Vector2(size)
|
|
if popup_position.x + actual_size.x > safe_rect.end.x - margin:
|
|
popup_origin.x = global_position.x - actual_size.x - margin
|
|
if popup_position.y + actual_size.y > safe_rect.end.y - margin:
|
|
popup_origin.y = global_position.y - actual_size.y - margin
|
|
var actual_max_x := maxf(safe_rect.position.x + margin, safe_rect.end.x - actual_size.x - margin)
|
|
var actual_max_y := maxf(safe_rect.position.y + margin, safe_rect.end.y - actual_size.y - margin)
|
|
popup_origin.x = clampf(popup_origin.x, safe_rect.position.x + margin, actual_max_x)
|
|
popup_origin.y = clampf(popup_origin.y, safe_rect.position.y + margin, actual_max_y)
|
|
position = Vector2i(popup_origin.round())
|
|
|
|
|
|
func _choose_popup_origin(
|
|
global_position: Vector2,
|
|
avoid_rect: Rect2,
|
|
popup_size: Vector2,
|
|
safe_rect: Rect2,
|
|
margin: float,
|
|
max_x: float,
|
|
max_y: float
|
|
) -> Vector2:
|
|
var low_x: float = safe_rect.position.x + margin
|
|
var low_y: float = safe_rect.position.y + margin
|
|
var cursor_fallback := Vector2(
|
|
clampf(global_position.x + margin, low_x, max_x),
|
|
clampf(global_position.y + margin, low_y, max_y)
|
|
)
|
|
if not avoid_rect.has_area():
|
|
return cursor_fallback
|
|
|
|
var aligned_y := clampf(global_position.y - 20.0, low_y, max_y)
|
|
var aligned_x := clampf(global_position.x + margin, low_x, max_x)
|
|
var candidates: Array[Vector2] = [
|
|
Vector2(avoid_rect.end.x + TARGET_GAP, aligned_y),
|
|
Vector2(avoid_rect.position.x - popup_size.x - TARGET_GAP, aligned_y),
|
|
Vector2(aligned_x, avoid_rect.end.y + TARGET_GAP),
|
|
Vector2(aligned_x, avoid_rect.position.y - popup_size.y - TARGET_GAP),
|
|
cursor_fallback,
|
|
]
|
|
for candidate: Vector2 in candidates:
|
|
if candidate.x < low_x or candidate.y < low_y or candidate.x > max_x or candidate.y > max_y:
|
|
continue
|
|
var candidate_rect := Rect2(candidate, popup_size)
|
|
if not candidate_rect.intersects(avoid_rect):
|
|
return candidate
|
|
return cursor_fallback
|
|
|
|
|
|
func get_row_button(id: int) -> Button:
|
|
return _row_ids.get(id) as Button
|
|
|
|
|
|
func _build_contents() -> void:
|
|
if _items != null:
|
|
return
|
|
_shell = MarginContainer.new()
|
|
_shell.name = "MenuShell"
|
|
_shell.add_theme_constant_override("margin_left", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_top", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_right", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_bottom", SHELL_INSET)
|
|
_shell.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
_shell.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
add_child(_shell)
|
|
_scroll = ScrollContainer.new()
|
|
_scroll.name = "MenuScroll"
|
|
_scroll.horizontal_scroll_mode = ScrollContainer.SCROLL_MODE_DISABLED
|
|
_scroll.size_flags_horizontal = Control.SIZE_EXPAND_FILL
|
|
_scroll.size_flags_vertical = Control.SIZE_EXPAND_FILL
|
|
_shell.add_child(_scroll)
|
|
_items = VBoxContainer.new()
|
|
_items.name = "MenuItems"
|
|
_items.add_theme_constant_override("separation", 0)
|
|
_items.custom_minimum_size.x = float(_menu_min_width())
|
|
_scroll.add_child(_items)
|
|
_apply_visual_style()
|
|
|
|
|
|
func _apply_visual_style() -> void:
|
|
if _visual_theme == null:
|
|
return
|
|
var surface := _theme_color(&"surface", Color("#252B38"))
|
|
var border := _theme_color(&"border", Color("#FFFFFF33"))
|
|
var radius := _theme_px(&"panel", 10)
|
|
var panel := StyleBoxFlat.new()
|
|
panel.bg_color = surface
|
|
panel.border_color = border
|
|
panel.set_border_width_all(_theme_px(&"normal_border", 1))
|
|
panel.set_corner_radius_all(radius)
|
|
panel.shadow_color = Color(0.0, 0.0, 0.0, 0.28)
|
|
panel.shadow_size = 8
|
|
panel.shadow_offset = Vector2(0.0, 3.0)
|
|
add_theme_stylebox_override("panel", panel)
|
|
if _shell != null:
|
|
_shell.add_theme_constant_override("margin_left", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_top", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_right", SHELL_INSET)
|
|
_shell.add_theme_constant_override("margin_bottom", SHELL_INSET)
|
|
if _items != null:
|
|
_items.custom_minimum_size.x = float(_menu_min_width())
|
|
for button: Button in _row_buttons:
|
|
if not is_instance_valid(button):
|
|
continue
|
|
button.custom_minimum_size = Vector2(_menu_min_width(), _menu_row_height())
|
|
button.add_theme_font_size_override("font_size", _font_size())
|
|
var role := int(button.get_meta("context_menu_role", ItemRole.NORMAL))
|
|
var item_role: ItemRole = ItemRole.DESTRUCTIVE if role == ItemRole.DESTRUCTIVE else ItemRole.NORMAL
|
|
button.add_theme_color_override("font_color", _text_color(item_role))
|
|
button.add_theme_color_override("font_hover_color", _text_color(item_role))
|
|
button.add_theme_color_override("font_pressed_color", _text_color(item_role))
|
|
button.add_theme_color_override("font_focus_color", _text_color(item_role))
|
|
button.add_theme_stylebox_override("normal", _make_row_box(Color(0.0, 0.0, 0.0, 0.0), Color(0, 0, 0, 0), 0))
|
|
button.add_theme_stylebox_override("hover", _make_hover_box())
|
|
button.add_theme_stylebox_override("pressed", _make_hover_box(true))
|
|
button.add_theme_stylebox_override("focus", _make_focus_box())
|
|
|
|
|
|
func _make_row_box(fill: Color, border: Color, border_width: int) -> StyleBoxFlat:
|
|
var style := StyleBoxFlat.new()
|
|
style.bg_color = fill
|
|
style.border_color = border
|
|
style.set_border_width_all(border_width)
|
|
style.set_corner_radius_all(ROW_RADIUS)
|
|
style.content_margin_left = 12
|
|
style.content_margin_right = 12
|
|
style.content_margin_top = 4
|
|
style.content_margin_bottom = 4
|
|
return style
|
|
|
|
|
|
func _make_hover_box(pressed: bool = false) -> StyleBoxFlat:
|
|
var hover_color := _theme_color(&"surface_hover", Color("#30394A"))
|
|
if pressed:
|
|
hover_color = hover_color.darkened(0.1)
|
|
var style := _make_row_box(hover_color, _theme_color(&"edit", Color("#22C6FF")), 0)
|
|
style.border_width_left = 3
|
|
style.content_margin_left = 9
|
|
return style
|
|
|
|
|
|
func _make_focus_box() -> StyleBoxFlat:
|
|
var style := _make_row_box(Color(0.0, 0.0, 0.0, 0.0), _theme_color(&"focus", Color("#8BD9FF")), 2)
|
|
return style
|
|
|
|
|
|
func _on_row_pressed(button: Button) -> void:
|
|
if not is_instance_valid(button):
|
|
return
|
|
var id: int = int(button.get_meta("context_menu_id", -1))
|
|
id_pressed.emit(id)
|
|
hide()
|
|
|
|
|
|
func _input(event: InputEvent) -> void:
|
|
if not visible or not event is InputEventKey:
|
|
return
|
|
var key_event := event as InputEventKey
|
|
if not key_event.pressed:
|
|
return
|
|
if key_event.keycode == KEY_DOWN:
|
|
_move_keyboard_focus(1)
|
|
get_viewport().set_input_as_handled()
|
|
elif key_event.keycode == KEY_UP:
|
|
_move_keyboard_focus(-1)
|
|
get_viewport().set_input_as_handled()
|
|
|
|
|
|
func _move_keyboard_focus(direction: int) -> void:
|
|
if _row_buttons.is_empty():
|
|
return
|
|
var candidate_index: int
|
|
if not _keyboard_navigation_active:
|
|
candidate_index = 0 if direction > 0 else _row_buttons.size() - 1
|
|
else:
|
|
candidate_index = _focused_row_index + direction
|
|
for _attempt: int in range(_row_buttons.size()):
|
|
candidate_index = posmod(candidate_index, _row_buttons.size())
|
|
var button: Button = _row_buttons[candidate_index]
|
|
if is_instance_valid(button) and button.visible and not button.disabled:
|
|
_enable_keyboard_navigation()
|
|
_focused_row_index = candidate_index
|
|
button.grab_focus()
|
|
return
|
|
candidate_index += direction
|
|
|
|
|
|
func _enable_keyboard_navigation() -> void:
|
|
_keyboard_navigation_active = true
|
|
for button: Button in _row_buttons:
|
|
if is_instance_valid(button):
|
|
button.focus_mode = Control.FOCUS_ALL
|
|
|
|
|
|
func _reset_keyboard_navigation() -> void:
|
|
_keyboard_navigation_active = false
|
|
_focused_row_index = -1
|
|
if not is_node_ready():
|
|
return
|
|
var focus_owner: Control = get_viewport().gui_get_focus_owner()
|
|
if focus_owner != null and _row_buttons.has(focus_owner):
|
|
focus_owner.release_focus()
|
|
for button: Button in _row_buttons:
|
|
if is_instance_valid(button):
|
|
button.focus_mode = Control.FOCUS_NONE
|
|
|
|
|
|
func _on_row_mouse_entered(_button: Button) -> void:
|
|
_reset_keyboard_navigation()
|
|
|
|
|
|
func _theme_color(role: StringName, fallback: Color) -> Color:
|
|
if _visual_theme == null:
|
|
return fallback
|
|
return _visual_theme.chrome_color(role, _editor)
|
|
|
|
|
|
func _theme_px(role: StringName, fallback: int) -> int:
|
|
if _visual_theme == null:
|
|
return fallback
|
|
return _visual_theme.chrome_px(role, _editor)
|
|
|
|
|
|
func _font_size() -> int:
|
|
if _font_size_override > 0:
|
|
return _font_size_override
|
|
return _theme_px(&"context_menu", 20)
|
|
|
|
|
|
func _menu_row_height() -> int:
|
|
return maxi(_theme_px(&"context_menu_row_height", DEFAULT_ROW_HEIGHT), DEFAULT_ROW_HEIGHT)
|
|
|
|
|
|
func _menu_min_width() -> int:
|
|
return maxi(_theme_px(&"context_menu_min_width", DEFAULT_MIN_WIDTH), DEFAULT_MIN_WIDTH)
|
|
|
|
|
|
func _text_color(role: ItemRole) -> Color:
|
|
if role == ItemRole.DESTRUCTIVE:
|
|
return _theme_color(&"destructive", Color("#E66B75"))
|
|
return _theme_color(&"text", Color("#F5F7FA"))
|