godotengine
/
godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
godot/editor/editor_dock_manager.cpp

717 lines
23 KiB
C++
Raw Blame History

/**************************************************************************/
/* editor_dock_manager.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 "editor_dock_manager.h"
#include "scene/gui/box_container.h"
#include "scene/gui/button.h"
#include "scene/gui/label.h"
#include "scene/gui/popup.h"
#include "scene/gui/split_container.h"
#include "scene/gui/tab_container.h"
#include "scene/main/window.h"
#include "editor/editor_node.h"
#include "editor/editor_settings.h"
#include "editor/editor_string_names.h"
#include "editor/filesystem_dock.h"
#include "editor/themes/editor_scale.h"
#include "editor/window_wrapper.h"
EditorDockManager *EditorDockManager::singleton = nullptr;
void DockSplitContainer::_update_visibility() {
if (is_updating) {
return;
}
is_updating = true;
bool any_visible = false;
for (int i = 0; i < 2; i++) {
Control *split = get_containable_child(i);
if (split && split->is_visible()) {
any_visible = true;
break;
}
}
set_visible(any_visible);
is_updating = false;
}
void DockSplitContainer::add_child_notify(Node *p_child) {
SplitContainer::add_child_notify(p_child);
Control *child_control = nullptr;
for (int i = 0; i < 2; i++) {
Control *split = get_containable_child(i);
if (p_child == split) {
child_control = split;
break;
}
}
if (!child_control) {
return;
}
child_control->connect("visibility_changed", callable_mp(this, &DockSplitContainer::_update_visibility));
_update_visibility();
}
void DockSplitContainer::remove_child_notify(Node *p_child) {
SplitContainer::remove_child_notify(p_child);
Control *child_control = nullptr;
for (int i = 0; i < 2; i++) {
Control *split = get_containable_child(i);
if (p_child == split) {
child_control = split;
break;
}
}
if (!child_control) {
return;
}
child_control->disconnect("visibility_changed", callable_mp(this, &DockSplitContainer::_update_visibility));
_update_visibility();
}
void EditorDockManager::_dock_select_popup_theme_changed() {
if (dock_float) {
dock_float->set_icon(dock_select_popup->get_editor_theme_icon(SNAME("MakeFloating")));
}
if (dock_select_popup->is_layout_rtl()) {
dock_tab_move_left->set_icon(dock_select_popup->get_editor_theme_icon(SNAME("Forward")));
dock_tab_move_right->set_icon(dock_select_popup->get_editor_theme_icon(SNAME("Back")));
} else {
dock_tab_move_left->set_icon(dock_select_popup->get_editor_theme_icon(SNAME("Back")));
dock_tab_move_right->set_icon(dock_select_popup->get_editor_theme_icon(SNAME("Forward")));
}
}
void EditorDockManager::_dock_popup_exit() {
dock_select_rect_over_idx = -1;
dock_select->queue_redraw();
}
void EditorDockManager::_dock_pre_popup(int p_dock_slot) {
dock_popup_selected_idx = p_dock_slot;
}
void EditorDockManager::_dock_move_left() {
if (dock_popup_selected_idx < 0 || dock_popup_selected_idx >= DOCK_SLOT_MAX) {
return;
}
Control *current_ctl = dock_slot[dock_popup_selected_idx]->get_tab_control(dock_slot[dock_popup_selected_idx]->get_current_tab());
Control *prev_ctl = dock_slot[dock_popup_selected_idx]->get_tab_control(dock_slot[dock_popup_selected_idx]->get_current_tab() - 1);
if (!current_ctl || !prev_ctl) {
return;
}
dock_slot[dock_popup_selected_idx]->move_child(current_ctl, prev_ctl->get_index(false));
dock_select->queue_redraw();
_edit_current();
emit_signal(SNAME("layout_changed"));
}
void EditorDockManager::_dock_move_right() {
if (dock_popup_selected_idx < 0 || dock_popup_selected_idx >= DOCK_SLOT_MAX) {
return;
}
Control *current_ctl = dock_slot[dock_popup_selected_idx]->get_tab_control(dock_slot[dock_popup_selected_idx]->get_current_tab());
Control *next_ctl = dock_slot[dock_popup_selected_idx]->get_tab_control(dock_slot[dock_popup_selected_idx]->get_current_tab() + 1);
if (!current_ctl || !next_ctl) {
return;
}
dock_slot[dock_popup_selected_idx]->move_child(next_ctl, current_ctl->get_index(false));
dock_select->queue_redraw();
_edit_current();
emit_signal(SNAME("layout_changed"));
}
void EditorDockManager::_dock_select_input(const Ref<InputEvent> &p_input) {
Ref<InputEventMouse> me = p_input;
if (me.is_valid()) {
Vector2 point = me->get_position();
int nrect = -1;
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
if (dock_select_rect[i].has_point(point)) {
nrect = i;
break;
}
}
if (nrect != dock_select_rect_over_idx) {
dock_select->queue_redraw();
dock_select_rect_over_idx = nrect;
}
if (nrect == -1) {
return;
}
Ref<InputEventMouseButton> mb = me;
if (mb.is_valid() && mb->get_button_index() == MouseButton::LEFT && mb->is_pressed() && dock_popup_selected_idx != nrect) {
dock_slot[nrect]->move_tab_from_tab_container(dock_slot[dock_popup_selected_idx], dock_slot[dock_popup_selected_idx]->get_current_tab(), dock_slot[nrect]->get_tab_count());
if (dock_slot[dock_popup_selected_idx]->get_tab_count() == 0) {
dock_slot[dock_popup_selected_idx]->hide();
} else {
dock_slot[dock_popup_selected_idx]->set_current_tab(0);
}
dock_popup_selected_idx = nrect;
dock_slot[nrect]->show();
dock_select->queue_redraw();
update_dock_slots_visibility(true);
_edit_current();
emit_signal(SNAME("layout_changed"));
}
}
}
void EditorDockManager::_dock_select_draw() {
Size2 s = dock_select->get_size();
s.y /= 2.0;
s.x /= 6.0;
Color used = Color(0.6, 0.6, 0.6, 0.8);
Color used_selected = Color(0.8, 0.8, 0.8, 0.8);
Color tab_selected = dock_select->get_theme_color(SNAME("mono_color"), EditorStringName(Editor));
Color unused = used;
unused.a = 0.4;
Color unusable = unused;
unusable.a = 0.1;
Rect2 unr(s.x * 2, 0, s.x * 2, s.y * 2);
unr.position += Vector2(2, 5);
unr.size -= Vector2(4, 7);
dock_select->draw_rect(unr, unusable);
dock_tab_move_left->set_disabled(true);
dock_tab_move_right->set_disabled(true);
if (dock_popup_selected_idx != -1 && dock_slot[dock_popup_selected_idx]->get_tab_count()) {
dock_tab_move_left->set_disabled(dock_slot[dock_popup_selected_idx]->get_current_tab() == 0);
dock_tab_move_right->set_disabled(dock_slot[dock_popup_selected_idx]->get_current_tab() >= dock_slot[dock_popup_selected_idx]->get_tab_count() - 1);
}
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
Vector2 ofs;
switch (i) {
case DOCK_SLOT_LEFT_UL: {
} break;
case DOCK_SLOT_LEFT_BL: {
ofs.y += s.y;
} break;
case DOCK_SLOT_LEFT_UR: {
ofs.x += s.x;
} break;
case DOCK_SLOT_LEFT_BR: {
ofs += s;
} break;
case DOCK_SLOT_RIGHT_UL: {
ofs.x += s.x * 4;
} break;
case DOCK_SLOT_RIGHT_BL: {
ofs.x += s.x * 4;
ofs.y += s.y;
} break;
case DOCK_SLOT_RIGHT_UR: {
ofs.x += s.x * 4;
ofs.x += s.x;
} break;
case DOCK_SLOT_RIGHT_BR: {
ofs.x += s.x * 4;
ofs += s;
} break;
}
Rect2 r(ofs, s);
dock_select_rect[i] = r;
r.position += Vector2(2, 5);
r.size -= Vector2(4, 7);
if (i == dock_select_rect_over_idx) {
dock_select->draw_rect(r, used_selected);
} else if (dock_slot[i]->get_tab_count() == 0) {
dock_select->draw_rect(r, unused);
} else {
dock_select->draw_rect(r, used);
}
for (int j = 0; j < MIN(3, dock_slot[i]->get_tab_count()); j++) {
int xofs = (r.size.width / 3) * j;
Color c = used;
if (i == dock_popup_selected_idx && (dock_slot[i]->get_current_tab() > 3 || dock_slot[i]->get_current_tab() == j)) {
c = tab_selected;
}
dock_select->draw_rect(Rect2(2 + ofs.x + xofs, ofs.y, r.size.width / 3 - 1, 3), c);
}
}
}
void EditorDockManager::_dock_split_dragged(int p_offset) {
EditorNode::get_singleton()->save_editor_layout_delayed();
}
void EditorDockManager::_dock_tab_changed(int p_tab) {
// Update visibility but don't set current tab.
update_dock_slots_visibility(true);
}
void EditorDockManager::_edit_current() {
EditorNode::get_singleton()->edit_current();
}
void EditorDockManager::_dock_floating_close_request(WindowWrapper *p_wrapper) {
int dock_slot_num = p_wrapper->get_meta("dock_slot");
int dock_slot_index = p_wrapper->get_meta("dock_index");
// Give back the dock to the original owner.
Control *dock = p_wrapper->release_wrapped_control();
int target_index = MIN(dock_slot_index, dock_slot[dock_slot_num]->get_tab_count());
dock_slot[dock_slot_num]->add_child(dock);
dock_slot[dock_slot_num]->move_child(dock, target_index);
dock_slot[dock_slot_num]->set_current_tab(target_index);
floating_docks.erase(p_wrapper);
p_wrapper->queue_free();
update_dock_slots_visibility(true);
_edit_current();
}
void EditorDockManager::_dock_make_selected_float() {
Control *dock = dock_slot[dock_popup_selected_idx]->get_current_tab_control();
_dock_make_float(dock, dock_popup_selected_idx);
dock_select_popup->hide();
_edit_current();
}
void EditorDockManager::_dock_make_float(Control *p_dock, int p_slot_index, bool p_show_window) {
ERR_FAIL_NULL(p_dock);
Size2 borders = Size2(4, 4) * EDSCALE;
// Remember size and position before removing it from the main window.
Size2 dock_size = p_dock->get_size() + borders * 2;
Point2 dock_screen_pos = p_dock->get_screen_position();
int dock_index = p_dock->get_index() - 1;
dock_slot[p_slot_index]->remove_child(p_dock);
WindowWrapper *wrapper = memnew(WindowWrapper);
wrapper->set_window_title(vformat(TTR("%s - Godot Engine"), p_dock->get_name()));
wrapper->set_margins_enabled(true);
EditorNode::get_singleton()->get_gui_base()->add_child(wrapper);
wrapper->set_wrapped_control(p_dock);
wrapper->set_meta("dock_slot", p_slot_index);
wrapper->set_meta("dock_index", dock_index);
wrapper->set_meta("dock_name", p_dock->get_name().operator String());
p_dock->show();
wrapper->connect("window_close_requested", callable_mp(this, &EditorDockManager::_dock_floating_close_request).bind(wrapper));
dock_select_popup->hide();
if (p_show_window) {
wrapper->restore_window(Rect2i(dock_screen_pos, dock_size), EditorNode::get_singleton()->get_gui_base()->get_window()->get_current_screen());
}
update_dock_slots_visibility(true);
floating_docks.push_back(wrapper);
_edit_current();
}
void EditorDockManager::_restore_floating_dock(const Dictionary &p_dock_dump, Control *p_dock, int p_slot_index) {
WindowWrapper *wrapper = Object::cast_to<WindowWrapper>(p_dock);
if (!wrapper) {
_dock_make_float(p_dock, p_slot_index, false);
wrapper = floating_docks[floating_docks.size() - 1];
}
wrapper->restore_window_from_saved_position(
p_dock_dump.get("window_rect", Rect2i()),
p_dock_dump.get("window_screen", -1),
p_dock_dump.get("window_screen_rect", Rect2i()));
}
void EditorDockManager::save_docks_to_config(Ref<ConfigFile> p_layout, const String &p_section) const {
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
String names;
for (int j = 0; j < dock_slot[i]->get_tab_count(); j++) {
String name = dock_slot[i]->get_tab_control(j)->get_name();
if (!names.is_empty()) {
names += ",";
}
names += name;
}
String config_key = "dock_" + itos(i + 1);
if (p_layout->has_section_key(p_section, config_key)) {
p_layout->erase_section_key(p_section, config_key);
}
if (!names.is_empty()) {
p_layout->set_value(p_section, config_key, names);
}
int selected_tab_idx = dock_slot[i]->get_current_tab();
if (selected_tab_idx >= 0) {
p_layout->set_value(p_section, "dock_" + itos(i + 1) + "_selected_tab_idx", selected_tab_idx);
}
}
Dictionary floating_docks_dump;
for (WindowWrapper *wrapper : floating_docks) {
Control *dock = wrapper->get_wrapped_control();
Dictionary dock_dump;
dock_dump["window_rect"] = wrapper->get_window_rect();
int screen = wrapper->get_window_screen();
dock_dump["window_screen"] = wrapper->get_window_screen();
dock_dump["window_screen_rect"] = DisplayServer::get_singleton()->screen_get_usable_rect(screen);
String name = dock->get_name();
floating_docks_dump[name] = dock_dump;
int dock_slot_id = wrapper->get_meta("dock_slot");
String config_key = "dock_" + itos(dock_slot_id + 1);
String names = p_layout->get_value(p_section, config_key, "");
if (names.is_empty()) {
names = name;
} else {
names += "," + name;
}
p_layout->set_value(p_section, config_key, names);
}
p_layout->set_value(p_section, "dock_floating", floating_docks_dump);
for (int i = 0; i < vsplits.size(); i++) {
if (vsplits[i]->is_visible_in_tree()) {
p_layout->set_value(p_section, "dock_split_" + itos(i + 1), vsplits[i]->get_split_offset());
}
}
for (int i = 0; i < hsplits.size(); i++) {
p_layout->set_value(p_section, "dock_hsplit_" + itos(i + 1), hsplits[i]->get_split_offset());
}
FileSystemDock::get_singleton()->save_layout_to_config(p_layout, p_section);
}
void EditorDockManager::load_docks_from_config(Ref<ConfigFile> p_layout, const String &p_section) {
Dictionary floating_docks_dump = p_layout->get_value(p_section, "dock_floating", Dictionary());
bool restore_window_on_load = EDITOR_GET("interface/multi_window/restore_windows_on_load");
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
if (!p_layout->has_section_key(p_section, "dock_" + itos(i + 1))) {
continue;
}
Vector<String> names = String(p_layout->get_value(p_section, "dock_" + itos(i + 1))).split(",");
for (int j = names.size() - 1; j >= 0; j--) {
String name = names[j];
// FIXME: Find it, in a horribly inefficient way.
int atidx = -1;
Control *node = nullptr;
for (int k = 0; k < DOCK_SLOT_MAX; k++) {
if (!dock_slot[k]->has_node(name)) {
continue;
}
node = Object::cast_to<Control>(dock_slot[k]->get_node(name));
if (!node) {
continue;
}
atidx = k;
break;
}
if (atidx == -1) {
// Try floating docks.
for (WindowWrapper *wrapper : floating_docks) {
if (wrapper->get_meta("dock_name") == name) {
if (restore_window_on_load && floating_docks_dump.has(name)) {
_restore_floating_dock(floating_docks_dump[name], wrapper, i);
} else {
atidx = wrapper->get_meta("dock_slot");
node = wrapper->get_wrapped_control();
wrapper->set_window_enabled(false);
}
break;
}
}
}
if (!node) {
// Well, it's not anywhere.
continue;
}
if (atidx == i) {
dock_slot[i]->move_child(node, 0);
} else if (atidx != -1) {
dock_slot[i]->set_block_signals(true);
dock_slot[atidx]->set_block_signals(true);
dock_slot[i]->move_tab_from_tab_container(dock_slot[atidx], dock_slot[atidx]->get_tab_idx_from_control(node), 0);
dock_slot[i]->set_block_signals(false);
dock_slot[atidx]->set_block_signals(false);
}
WindowWrapper *wrapper = Object::cast_to<WindowWrapper>(node);
if (restore_window_on_load && floating_docks_dump.has(name)) {
if (!dock_slot[i]->is_tab_hidden(dock_slot[i]->get_tab_idx_from_control(node))) {
_restore_floating_dock(floating_docks_dump[name], node, i);
}
} else if (wrapper) {
wrapper->set_window_enabled(false);
}
}
if (!p_layout->has_section_key(p_section, "dock_" + itos(i + 1) + "_selected_tab_idx")) {
continue;
}
int selected_tab_idx = p_layout->get_value(p_section, "dock_" + itos(i + 1) + "_selected_tab_idx");
if (selected_tab_idx >= 0 && selected_tab_idx < dock_slot[i]->get_tab_count()) {
callable_mp(dock_slot[i], &TabContainer::set_current_tab).call_deferred(selected_tab_idx);
}
}
for (int i = 0; i < vsplits.size(); i++) {
if (!p_layout->has_section_key(p_section, "dock_split_" + itos(i + 1))) {
continue;
}
int ofs = p_layout->get_value(p_section, "dock_split_" + itos(i + 1));
vsplits[i]->set_split_offset(ofs);
}
for (int i = 0; i < hsplits.size(); i++) {
if (!p_layout->has_section_key(p_section, "dock_hsplit_" + itos(i + 1))) {
continue;
}
int ofs = p_layout->get_value(p_section, "dock_hsplit_" + itos(i + 1));
hsplits[i]->set_split_offset(ofs);
}
update_dock_slots_visibility(false);
FileSystemDock::get_singleton()->load_layout_from_config(p_layout, p_section);
}
void EditorDockManager::update_dock_slots_visibility(bool p_keep_selected_tabs) {
if (!docks_visible) {
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
dock_slot[i]->hide();
}
} else {
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
int first_tab_visible = -1;
for (int j = 0; j < dock_slot[i]->get_tab_count(); j++) {
if (!dock_slot[i]->is_tab_hidden(j)) {
first_tab_visible = j;
break;
}
}
if (first_tab_visible >= 0) {
dock_slot[i]->show();
if (p_keep_selected_tabs) {
int current_tab = dock_slot[i]->get_current_tab();
if (dock_slot[i]->is_tab_hidden(current_tab)) {
dock_slot[i]->set_block_signals(true);
dock_slot[i]->select_next_available();
dock_slot[i]->set_block_signals(false);
}
} else {
dock_slot[i]->set_block_signals(true);
dock_slot[i]->set_current_tab(first_tab_visible);
dock_slot[i]->set_block_signals(false);
}
} else {
dock_slot[i]->hide();
}
}
}
}
void EditorDockManager::close_all_floating_docks() {
for (WindowWrapper *wrapper : floating_docks) {
wrapper->set_window_enabled(false);
}
}
void EditorDockManager::add_control_to_dock(DockSlot p_slot, Control *p_control, const String &p_name) {
ERR_FAIL_INDEX(p_slot, DOCK_SLOT_MAX);
dock_slot[p_slot]->add_child(p_control);
if (!p_name.is_empty()) {
dock_slot[p_slot]->set_tab_title(dock_slot[p_slot]->get_tab_idx_from_control(p_control), p_name);
}
}
void EditorDockManager::remove_control_from_dock(Control *p_control) {
// If the dock is floating, close it first.
for (WindowWrapper *wrapper : floating_docks) {
if (p_control == wrapper->get_wrapped_control()) {
wrapper->set_window_enabled(false);
break;
}
}
Control *dock = nullptr;
for (int i = 0; i < DOCK_SLOT_MAX; i++) {
if (p_control->get_parent() == dock_slot[i]) {
dock = dock_slot[i];
break;
}
}
ERR_FAIL_NULL_MSG(dock, "Control is not in a dock.");
dock->remove_child(p_control);
update_dock_slots_visibility();
}
void EditorDockManager::set_docks_visible(bool p_show) {
docks_visible = p_show;
update_dock_slots_visibility(true);
}
bool EditorDockManager::are_docks_visible() const {
return docks_visible;
}
void EditorDockManager::add_vsplit(DockSplitContainer *p_split) {
vsplits.push_back(p_split);
p_split->connect("dragged", callable_mp(this, &EditorDockManager::_dock_split_dragged));
}
void EditorDockManager::add_hsplit(DockSplitContainer *p_split) {
hsplits.push_back(p_split);
p_split->connect("dragged", callable_mp(this, &EditorDockManager::_dock_split_dragged));
}
void EditorDockManager::register_dock_slot(DockSlot p_dock_slot, TabContainer *p_tab_container) {
ERR_FAIL_NULL(p_tab_container);
ERR_FAIL_INDEX(p_dock_slot, DOCK_SLOT_MAX);
dock_slot[p_dock_slot] = p_tab_container;
p_tab_container->set_custom_minimum_size(Size2(170, 0) * EDSCALE);
p_tab_container->set_v_size_flags(Control::SIZE_EXPAND_FILL);
p_tab_container->set_popup(dock_select_popup);
p_tab_container->connect("pre_popup_pressed", callable_mp(this, &EditorDockManager::_dock_pre_popup).bind(p_dock_slot));
p_tab_container->set_drag_to_rearrange_enabled(true);
p_tab_container->set_tabs_rearrange_group(1);
p_tab_container->connect("tab_changed", callable_mp(this, &EditorDockManager::_dock_tab_changed));
p_tab_container->set_use_hidden_tabs_for_min_size(true);
}
int EditorDockManager::get_vsplit_count() const {
return vsplits.size();
}
void EditorDockManager::_bind_methods() {
ADD_SIGNAL(MethodInfo("layout_changed"));
}
EditorDockManager::EditorDockManager() {
singleton = this;
dock_select_popup = memnew(PopupPanel);
EditorNode::get_singleton()->get_gui_base()->add_child(dock_select_popup);
VBoxContainer *dock_vb = memnew(VBoxContainer);
dock_select_popup->add_child(dock_vb);
dock_select_popup->connect("theme_changed", callable_mp(this, &EditorDockManager::_dock_select_popup_theme_changed));
HBoxContainer *dock_hb = memnew(HBoxContainer);
dock_tab_move_left = memnew(Button);
dock_tab_move_left->set_flat(true);
dock_tab_move_left->set_focus_mode(Control::FOCUS_NONE);
dock_tab_move_left->connect("pressed", callable_mp(this, &EditorDockManager::_dock_move_left));
dock_hb->add_child(dock_tab_move_left);
Label *dock_label = memnew(Label);
dock_label->set_text(TTR("Dock Position"));
dock_label->set_h_size_flags(Control::SIZE_EXPAND_FILL);
dock_label->set_horizontal_alignment(HORIZONTAL_ALIGNMENT_CENTER);
dock_hb->add_child(dock_label);
dock_tab_move_right = memnew(Button);
dock_tab_move_right->set_flat(true);
dock_tab_move_right->set_focus_mode(Control::FOCUS_NONE);
dock_tab_move_right->connect("pressed", callable_mp(this, &EditorDockManager::_dock_move_right));
dock_hb->add_child(dock_tab_move_right);
dock_vb->add_child(dock_hb);
dock_select = memnew(Control);
dock_select->set_custom_minimum_size(Size2(128, 64) * EDSCALE);
dock_select->connect("gui_input", callable_mp(this, &EditorDockManager::_dock_select_input));
dock_select->connect("draw", callable_mp(this, &EditorDockManager::_dock_select_draw));
dock_select->connect("mouse_exited", callable_mp(this, &EditorDockManager::_dock_popup_exit));
dock_select->set_v_size_flags(Control::SIZE_EXPAND_FILL);
dock_vb->add_child(dock_select);
if (!SceneTree::get_singleton()->get_root()->is_embedding_subwindows() && !EDITOR_GET("interface/editor/single_window_mode") && EDITOR_GET("interface/multi_window/enable")) {
dock_float = memnew(Button);
dock_float->set_text(TTR("Make Floating"));
dock_float->set_focus_mode(Control::FOCUS_NONE);
dock_float->set_h_size_flags(Control::SIZE_SHRINK_CENTER);
dock_float->connect("pressed", callable_mp(this, &EditorDockManager::_dock_make_selected_float));
dock_vb->add_child(dock_float);
}
dock_select_popup->reset_size();
}
Reference in New Issue View Git Blame Copy Permalink