diff options
Diffstat (limited to 'editor/window_wrapper.cpp')
| -rw-r--r-- | editor/window_wrapper.cpp | 474 |
1 files changed, 474 insertions, 0 deletions
diff --git a/editor/window_wrapper.cpp b/editor/window_wrapper.cpp new file mode 100644 index 0000000000..21b0a1a21d --- /dev/null +++ b/editor/window_wrapper.cpp @@ -0,0 +1,474 @@ +/**************************************************************************/ +/* window_wrapper.cpp */ +/**************************************************************************/ +/* This file is part of: */ +/* GODOT ENGINE */ +/* https://godotengine.org */ +/**************************************************************************/ +/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */ +/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */ +/* */ +/* Permission is hereby granted, free of charge, to any person obtaining */ +/* a copy of this software and associated documentation files (the */ +/* "Software"), to deal in the Software without restriction, including */ +/* without limitation the rights to use, copy, modify, merge, publish, */ +/* distribute, sublicense, and/or sell copies of the Software, and to */ +/* permit persons to whom the Software is furnished to do so, subject to */ +/* the following conditions: */ +/* */ +/* The above copyright notice and this permission notice shall be */ +/* included in all copies or substantial portions of the Software. */ +/* */ +/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ +/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ +/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */ +/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ +/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ +/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ +/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ +/**************************************************************************/ + +#include "window_wrapper.h" + +#include "editor/editor_node.h" +#include "editor/editor_scale.h" +#include "editor/editor_settings.h" +#include "scene/gui/box_container.h" +#include "scene/gui/label.h" +#include "scene/gui/panel.h" +#include "scene/gui/popup.h" +#include "scene/main/window.h" + +// WindowWrapper + +// Capture all shortcut events not handled by other nodes. +class ShortcutBin : public Node { + GDCLASS(ShortcutBin, Node); + + virtual void _notification(int what) { + switch (what) { + case NOTIFICATION_READY: + set_process_shortcut_input(true); + break; + } + } + + virtual void shortcut_input(const Ref<InputEvent> &p_event) override { + if (!get_window()->is_visible()) { + return; + } + Window *grandparent_window = get_window()->get_parent_visible_window(); + ERR_FAIL_COND(!grandparent_window); + + if (Object::cast_to<InputEventKey>(p_event.ptr()) || Object::cast_to<InputEventShortcut>(p_event.ptr())) { + // HACK: Propagate the window input to the editor main window to handle global shortcuts. + grandparent_window->push_input(p_event); + + if (grandparent_window->is_input_handled()) { + get_viewport()->set_input_as_handled(); + } + } + } +}; + +Rect2 WindowWrapper::_get_default_window_rect() const { + // Assume that the control rect is the desidered one for the window. + return wrapped_control->get_screen_rect(); +} + +Node *WindowWrapper::_get_wrapped_control_parent() const { + if (margins) { + return margins; + } + return window; +} + +void WindowWrapper::_set_window_enabled_with_rect(bool p_visible, const Rect2 p_rect) { + ERR_FAIL_NULL(wrapped_control); + + if (!is_window_available()) { + return; + } + + if (window->is_visible() == p_visible) { + if (p_visible) { + window->grab_focus(); + } + return; + } + + Node *parent = _get_wrapped_control_parent(); + + if (wrapped_control->get_parent() != parent) { + // Move the control to the window. + wrapped_control->reparent(parent, false); + + _set_window_rect(p_rect); + wrapped_control->set_anchors_and_offsets_preset(PRESET_FULL_RECT); + + } else if (!p_visible) { + // Remove control from window. + wrapped_control->reparent(this, false); + } + + window->set_visible(p_visible); + if (!p_visible) { + emit_signal("window_close_requested"); + } + emit_signal("window_visibility_changed", p_visible); +} + +void WindowWrapper::_set_window_rect(const Rect2 p_rect) { + // Set the window rect even when the window is maximized to have a good default size + // when the user remove the maximized mode. + window->set_position(p_rect.position); + window->set_size(p_rect.size); + + if (EDITOR_GET("interface/multi_window/maximize_window")) { + window->set_mode(Window::MODE_MAXIMIZED); + } +} + +void WindowWrapper::_bind_methods() { + ADD_SIGNAL(MethodInfo("window_visibility_changed", PropertyInfo(Variant::BOOL, "visible"))); + ADD_SIGNAL(MethodInfo("window_close_requested")); +} + +void WindowWrapper::_notification(int p_what) { + if (!is_window_available()) { + return; + } + switch (p_what) { + case NOTIFICATION_VISIBILITY_CHANGED: { + if (get_window_enabled() && is_visible()) { + // Grab the focus when WindowWrapper.set_visible(true) is called + // and the window is showing. + window->grab_focus(); + } + } break; + case NOTIFICATION_READY: { + set_process_shortcut_input(true); + } break; + case NOTIFICATION_THEME_CHANGED: { + window_background->add_theme_style_override("panel", get_theme_stylebox("PanelForeground", "EditorStyles")); + } break; + } +} + +void WindowWrapper::shortcut_input(const Ref<InputEvent> &p_event) { + if (enable_shortcut.is_valid() && enable_shortcut->matches_event(p_event)) { + set_window_enabled(true); + } +} + +void WindowWrapper::set_wrapped_control(Control *p_control, const Ref<Shortcut> &p_enable_shortcut) { + ERR_FAIL_NULL(p_control); + ERR_FAIL_COND(wrapped_control); + + wrapped_control = p_control; + enable_shortcut = p_enable_shortcut; + add_child(p_control); +} + +Control *WindowWrapper::get_wrapped_control() const { + return wrapped_control; +} + +Control *WindowWrapper::release_wrapped_control() { + set_window_enabled(false); + if (wrapped_control) { + Control *old_wrapped = wrapped_control; + wrapped_control->get_parent()->remove_child(wrapped_control); + wrapped_control = nullptr; + + return old_wrapped; + } + return nullptr; +} + +bool WindowWrapper::is_window_available() const { + return window != nullptr; +} + +bool WindowWrapper::get_window_enabled() const { + return is_window_available() ? window->is_visible() : false; +} + +void WindowWrapper::set_window_enabled(bool p_enabled) { + _set_window_enabled_with_rect(p_enabled, _get_default_window_rect()); +} + +Rect2i WindowWrapper::get_window_rect() const { + ERR_FAIL_COND_V(!get_window_enabled(), Rect2i()); + return Rect2i(window->get_position(), window->get_size()); +} + +int WindowWrapper::get_window_screen() const { + ERR_FAIL_COND_V(!get_window_enabled(), -1); + return window->get_current_screen(); +} + +void WindowWrapper::restore_window(const Rect2i &p_rect, int p_screen) { + ERR_FAIL_COND(!is_window_available()); + ERR_FAIL_INDEX(p_screen, DisplayServer::get_singleton()->get_screen_count()); + + _set_window_enabled_with_rect(true, p_rect); + window->set_current_screen(p_screen); +} + +void WindowWrapper::restore_window_from_saved_position(const Rect2 p_window_rect, int p_screen, const Rect2 p_screen_rect) { + ERR_FAIL_COND(!is_window_available()); + + Rect2 window_rect = p_window_rect; + int screen = p_screen; + Rect2 restored_screen_rect = p_screen_rect; + + if (screen < 0 || screen >= DisplayServer::get_singleton()->get_screen_count()) { + // Fallback to the main window screen if the saved screen is not available. + screen = get_window()->get_window_id(); + } + + Rect2i real_screen_rect = DisplayServer::get_singleton()->screen_get_usable_rect(screen); + + if (restored_screen_rect == Rect2i()) { + // Fallback to the target screen rect. + restored_screen_rect = real_screen_rect; + } + + if (window_rect == Rect2i()) { + // Fallback to a standard rect. + window_rect = Rect2i(restored_screen_rect.position + restored_screen_rect.size / 4, restored_screen_rect.size / 2); + } + + // Adjust the window rect size in case the resolution changes. + Vector2 screen_ratio = Vector2(real_screen_rect.size) / Vector2(restored_screen_rect.size); + + // The screen positioning may change, so remove the original screen position. + window_rect.position -= restored_screen_rect.position; + window_rect = Rect2i(window_rect.position * screen_ratio, window_rect.size * screen_ratio); + window_rect.position += real_screen_rect.position; + + // All good, restore the window. + window->set_current_screen(p_screen); + if (window->is_visible()) { + _set_window_rect(window_rect); + } else { + _set_window_enabled_with_rect(true, window_rect); + } +} + +void WindowWrapper::enable_window_on_screen(int p_screen, bool p_auto_scale) { + int current_screen = Object::cast_to<Window>(get_viewport())->get_current_screen(); + int screen = p_screen < 0 ? current_screen : p_screen; + + bool auto_scale = p_auto_scale && !EDITOR_GET("interface/multi_window/maximize_window"); + + if (auto_scale && current_screen != screen) { + Rect2 control_rect = _get_default_window_rect(); + + Rect2i source_screen_rect = DisplayServer::get_singleton()->screen_get_usable_rect(current_screen); + Rect2i dest_screen_rect = DisplayServer::get_singleton()->screen_get_usable_rect(screen); + + // Adjust the window rect size in case the resolution changes. + Vector2 screen_ratio = Vector2(source_screen_rect.size) / Vector2(dest_screen_rect.size); + + // The screen positioning may change, so remove the original screen position. + control_rect.position -= source_screen_rect.position; + control_rect = Rect2i(control_rect.position * screen_ratio, control_rect.size * screen_ratio); + control_rect.position += dest_screen_rect.position; + + restore_window(control_rect, p_screen); + } else { + window->set_current_screen(p_screen); + set_window_enabled(true); + } +} + +void WindowWrapper::set_window_title(const String p_title) { + if (!is_window_available()) { + return; + } + window->set_title(p_title); +} + +void WindowWrapper::set_margins_enabled(bool p_enabled) { + if (!is_window_available()) { + return; + } + + if (!p_enabled && margins) { + margins->queue_free(); + margins = nullptr; + } else if (p_enabled && !margins) { + Size2 borders = Size2(4, 4) * EDSCALE; + margins = memnew(MarginContainer); + margins->add_theme_constant_override("margin_right", borders.width); + margins->add_theme_constant_override("margin_top", borders.height); + margins->add_theme_constant_override("margin_left", borders.width); + margins->add_theme_constant_override("margin_bottom", borders.height); + + window->add_child(margins); + margins->set_anchors_and_offsets_preset(PRESET_FULL_RECT); + } +} + +WindowWrapper::WindowWrapper() { + if (SceneTree::get_singleton()->get_root()->is_embedding_subwindows() || !EDITOR_GET("interface/multi_window/enable")) { + return; + } + + window = memnew(Window); + window->set_wrap_controls(true); + + add_child(window); + window->hide(); + + window->connect("close_requested", callable_mp(this, &WindowWrapper::set_window_enabled).bind(false)); + + ShortcutBin *capturer = memnew(ShortcutBin); + window->add_child(capturer); + + window_background = memnew(Panel); + window_background->set_anchors_and_offsets_preset(PRESET_FULL_RECT); + window->add_child(window_background); +} + +// ScreenSelect + +void ScreenSelect::_build_advanced_menu() { + // Clear old screen list. + while (screen_list->get_child_count(false) > 0) { + Node *child = screen_list->get_child(0); + screen_list->remove_child(child); + child->queue_free(); + } + + // Populate screen list. + const real_t height = real_t(get_theme_font_size("font_size")) * 1.5; + + int current_screen = get_window()->get_current_screen(); + for (int i = 0; i < DisplayServer::get_singleton()->get_screen_count(); i++) { + Button *button = memnew(Button); + + Size2 screen_size = Size2(DisplayServer::get_singleton()->screen_get_size(i)); + Size2 button_size = Size2(height * (screen_size.x / screen_size.y), height); + button->set_custom_minimum_size(button_size); + screen_list->add_child(button); + + button->set_text(itos(i)); + button->set_text_alignment(HORIZONTAL_ALIGNMENT_CENTER); + button->set_tooltip_text(vformat(TTR("Make this panel floating in the screen %d."), i)); + + if (i == current_screen) { + Color accent_color = get_theme_color("accent_color", "Editor"); + button->add_theme_color_override("font_color", accent_color); + } + + button->connect("pressed", callable_mp(this, &ScreenSelect::_emit_screen_signal).bind(i)); + button->connect("pressed", callable_mp(static_cast<BaseButton *>(this), &ScreenSelect::set_pressed).bind(false)); + button->connect("pressed", callable_mp(static_cast<Window *>(popup), &Popup::hide)); + } +} + +void ScreenSelect::_emit_screen_signal(int p_screen_idx) { + emit_signal("request_open_in_screen", p_screen_idx); +} + +void ScreenSelect::_bind_methods() { + ADD_SIGNAL(MethodInfo("request_open_in_screen", PropertyInfo(Variant::INT, "screen"))); +} + +void ScreenSelect::_notification(int p_what) { + switch (p_what) { + case NOTIFICATION_READY: { + connect("gui_input", callable_mp(this, &ScreenSelect::_handle_mouse_shortcut)); + } break; + case NOTIFICATION_THEME_CHANGED: { + set_icon(EditorNode::get_singleton()->get_gui_base()->get_theme_icon("MakeFloating", "EditorIcons")); + popup_background->add_theme_style_override("panel", get_theme_stylebox("PanelForeground", "EditorStyles")); + + const real_t popup_height = real_t(get_theme_font_size("font_size")) * 2.0; + popup->set_min_size(Size2(0, popup_height * 3)); + } break; + } +} + +void ScreenSelect::_handle_mouse_shortcut(const Ref<InputEvent> &p_event) { + const Ref<InputEventMouseButton> mouse_button = p_event; + if (mouse_button.is_valid()) { + if (mouse_button->is_pressed() && mouse_button->get_button_index() == MouseButton::LEFT) { + _emit_screen_signal(get_window()->get_current_screen()); + accept_event(); + } + } +} + +void ScreenSelect::_show_popup() { + // Adapted from /scene/gui/menu_button.cpp::show_popup + if (!get_viewport()) { + return; + } + + Size2 size = get_size() * get_viewport()->get_canvas_transform().get_scale(); + + popup->set_size(Size2(size.width, 0)); + Point2 gp = get_screen_position(); + gp.y += size.y; + if (is_layout_rtl()) { + gp.x += size.width - popup->get_size().width; + } + popup->set_position(gp); + popup->popup(); +} + +void ScreenSelect::pressed() { + if (popup->is_visible()) { + popup->hide(); + return; + } + + _build_advanced_menu(); + _show_popup(); +} + +ScreenSelect::ScreenSelect() { + set_text(TTR("Make Floating")); + set_tooltip_text(TTR("Make this panel floating.\nRight click to open the screen selector.")); + set_button_mask(MouseButtonMask::RIGHT); + set_flat(true); + set_toggle_mode(true); + set_focus_mode(FOCUS_NONE); + set_action_mode(ACTION_MODE_BUTTON_PRESS); + + // Create the popup. + const Size2 borders = Size2(4, 4) * EDSCALE; + + popup = memnew(Popup); + popup->connect("popup_hide", callable_mp(static_cast<BaseButton *>(this), &ScreenSelect::set_pressed).bind(false)); + add_child(popup); + + popup_background = memnew(Panel); + popup_background->set_anchors_and_offsets_preset(PRESET_FULL_RECT); + popup->add_child(popup_background); + + MarginContainer *popup_root = memnew(MarginContainer); + popup_root->add_theme_constant_override("margin_right", borders.width); + popup_root->add_theme_constant_override("margin_top", borders.height); + popup_root->add_theme_constant_override("margin_left", borders.width); + popup_root->add_theme_constant_override("margin_bottom", borders.height); + popup->add_child(popup_root); + + VBoxContainer *vb = memnew(VBoxContainer); + vb->set_alignment(BoxContainer::ALIGNMENT_CENTER); + popup_root->add_child(vb); + + Label *description = memnew(Label(TTR("Select Screen"))); + description->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER); + vb->add_child(description); + + screen_list = memnew(HBoxContainer); + screen_list->set_alignment(BoxContainer::ALIGNMENT_CENTER); + vb->add_child(screen_list); + + popup_root->set_anchors_and_offsets_preset(PRESET_FULL_RECT); +} |