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

1565 lines
52 KiB
C++
Raw Blame History

/*************************************************************************/
/* project_settings.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/*************************************************************************/
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
/* */
/* 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 "project_settings.h"
#include "editor_node.h"
#include "global_constants.h"
#include "globals.h"
#include "os/keyboard.h"
#include "scene/gui/margin_container.h"
#include "scene/gui/tab_container.h"
#include "translation.h"
ProjectSettings *ProjectSettings::singleton = NULL;
static const char *_button_names[JOY_BUTTON_MAX] = {
"PS Cross, XBox A, Nintendo B",
"PS Circle, XBox B, Nintendo A",
"PS Square, XBox X, Nintendo Y",
"PS Triangle, XBox Y, Nintendo X",
"L, L1",
"R, R1",
"L2",
"R2",
"L3",
"R3",
"Select, Nintendo -",
"Start, Nintendo +",
"D-Pad Up",
"D-Pad Down",
"D-Pad Left",
"D-Pad Right"
};
static const char *_axis_names[JOY_AXIS_MAX * 2] = {
" (Left Stick Left)",
" (Left Stick Right)",
" (Left Stick Up)",
" (Left Stick Down)",
" (Right Stick Left)",
" (Right Stick Right)",
" (Right Stick Up)",
" (Right Stick Down)",
"", "", "", "",
"", " (L2)",
"", " (R2)"
};
void ProjectSettings::_notification(int p_what) {
if (p_what == NOTIFICATION_ENTER_TREE) {
globals_editor->edit(Globals::get_singleton());
search_button->set_icon(get_icon("Zoom", "EditorIcons"));
clear_button->set_icon(get_icon("Close", "EditorIcons"));
translation_list->connect("button_pressed", this, "_translation_delete");
_update_actions();
popup_add->add_icon_item(get_icon("Keyboard", "EditorIcons"), TTR("Key "), InputEvent::KEY); //"Key " - because the word 'key' has already been used as a key animation
popup_add->add_icon_item(get_icon("JoyButton", "EditorIcons"), TTR("Joy Button"), InputEvent::JOYSTICK_BUTTON);
popup_add->add_icon_item(get_icon("JoyAxis", "EditorIcons"), TTR("Joy Axis"), InputEvent::JOYSTICK_MOTION);
popup_add->add_icon_item(get_icon("Mouse", "EditorIcons"), TTR("Mouse Button"), InputEvent::MOUSE_BUTTON);
List<String> tfn;
ResourceLoader::get_recognized_extensions_for_type("Translation", &tfn);
for (List<String>::Element *E = tfn.front(); E; E = E->next()) {
translation_file_open->add_filter("*." + E->get());
}
List<String> rfn;
ResourceLoader::get_recognized_extensions_for_type("Resource", &rfn);
for (List<String>::Element *E = rfn.front(); E; E = E->next()) {
translation_res_file_open->add_filter("*." + E->get());
translation_res_option_file_open->add_filter("*." + E->get());
}
}
}
void ProjectSettings::_action_selected() {
TreeItem *ti = input_editor->get_selected();
if (!ti || !ti->is_editable(0))
return;
add_at = "input/" + ti->get_text(0);
}
void ProjectSettings::_action_edited() {
TreeItem *ti = input_editor->get_selected();
if (!ti)
return;
String new_name = ti->get_text(0);
String old_name = add_at.substr(add_at.find("/") + 1, add_at.length());
if (new_name == old_name)
return;
if (new_name.find("/") != -1 || new_name.find(":") != -1 || new_name == "") {
ti->set_text(0, old_name);
add_at = "input/" + old_name;
message->set_text(TTR("Invalid action (anything goes but '/' or ':')."));
message->popup_centered(Size2(300, 100));
return;
}
String action_prop = "input/" + new_name;
if (Globals::get_singleton()->has(action_prop)) {
ti->set_text(0, old_name);
add_at = "input/" + old_name;
message->set_text(vformat(TTR("Action '%s' already exists!"), new_name));
message->popup_centered(Size2(300, 100));
return;
}
int order = Globals::get_singleton()->get_order(add_at);
Array va = Globals::get_singleton()->get(add_at);
bool persisting = Globals::get_singleton()->is_persisting(add_at);
setting = true;
undo_redo->create_action(TTR("Rename Input Action Event"));
undo_redo->add_do_method(Globals::get_singleton(), "clear", add_at);
undo_redo->add_do_method(Globals::get_singleton(), "set", action_prop, va);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", action_prop, persisting);
undo_redo->add_do_method(Globals::get_singleton(), "set_order", action_prop, order);
undo_redo->add_undo_method(Globals::get_singleton(), "clear", action_prop);
undo_redo->add_undo_method(Globals::get_singleton(), "set", add_at, va);
undo_redo->add_undo_method(Globals::get_singleton(), "set_persisting", add_at, persisting);
undo_redo->add_undo_method(Globals::get_singleton(), "set_order", add_at, order);
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
setting = false;
add_at = action_prop;
}
void ProjectSettings::_device_input_add() {
InputEvent ie;
String name = add_at;
Variant old_val = Globals::get_singleton()->get(name);
Array arr = old_val;
ie.device = device_id->get_val();
ie.type = add_type;
switch (add_type) {
case InputEvent::MOUSE_BUTTON: {
ie.mouse_button.button_index = device_index->get_selected() + 1;
for (int i = 0; i < arr.size(); i++) {
InputEvent aie = arr[i];
if (aie.device == ie.device && aie.type == InputEvent::MOUSE_BUTTON && aie.mouse_button.button_index == ie.mouse_button.button_index) {
return;
}
}
} break;
case InputEvent::JOYSTICK_MOTION: {
ie.joy_motion.axis = device_index->get_selected() >> 1;
ie.joy_motion.axis_value = device_index->get_selected() & 1 ? 1 : -1;
for (int i = 0; i < arr.size(); i++) {
InputEvent aie = arr[i];
if (aie.device == ie.device && aie.type == InputEvent::JOYSTICK_MOTION && aie.joy_motion.axis == ie.joy_motion.axis && aie.joy_motion.axis_value == ie.joy_motion.axis_value) {
return;
}
}
} break;
case InputEvent::JOYSTICK_BUTTON: {
ie.joy_button.button_index = device_index->get_selected();
for (int i = 0; i < arr.size(); i++) {
InputEvent aie = arr[i];
if (aie.device == ie.device && aie.type == InputEvent::JOYSTICK_BUTTON && aie.joy_button.button_index == ie.joy_button.button_index) {
return;
}
}
} break;
default: {
}
}
arr.push_back(ie);
undo_redo->create_action(TTR("Add Input Action Event"));
undo_redo->add_do_method(Globals::get_singleton(), "set", name, arr);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", name, true);
undo_redo->add_undo_method(Globals::get_singleton(), "set", name, old_val);
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
_show_last_added(ie, name);
}
void ProjectSettings::_press_a_key_confirm() {
if (last_wait_for_key.type != InputEvent::KEY)
return;
InputEvent ie;
ie.type = InputEvent::KEY;
ie.key.scancode = last_wait_for_key.key.scancode;
ie.key.mod = last_wait_for_key.key.mod;
String name = add_at;
Variant old_val = Globals::get_singleton()->get(name);
Array arr = old_val;
for (int i = 0; i < arr.size(); i++) {
InputEvent aie = arr[i];
if (aie.type == InputEvent::KEY && aie.key.scancode == ie.key.scancode && aie.key.mod == ie.key.mod) {
return;
}
}
arr.push_back(ie);
undo_redo->create_action(TTR("Add Input Action Event"));
undo_redo->add_do_method(Globals::get_singleton(), "set", name, arr);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", name, true);
undo_redo->add_undo_method(Globals::get_singleton(), "set", name, old_val);
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
_show_last_added(ie, name);
}
void ProjectSettings::_show_last_added(const InputEvent &p_event, const String &p_name) {
TreeItem *r = input_editor->get_root();
String name = p_name;
name.erase(0, 6);
if (!r)
return;
r = r->get_children();
if (!r)
return;
bool found = false;
while (r) {
if (r->get_text(0) != name) {
r = r->get_next();
continue;
}
TreeItem *child = r->get_children();
while (child) {
Variant input = child->get_meta("__input");
if (p_event == input) {
child->select(0);
found = true;
break;
}
child = child->get_next();
}
if (found) break;
r = r->get_next();
}
if (found) input_editor->ensure_cursor_is_visible();
}
void ProjectSettings::_wait_for_key(const InputEvent &p_event) {
if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode != 0) {
last_wait_for_key = p_event;
String str = keycode_get_string(p_event.key.scancode).capitalize();
if (p_event.key.mod.meta)
str = TTR("Meta+") + str;
if (p_event.key.mod.shift)
str = TTR("Shift+") + str;
if (p_event.key.mod.alt)
str = TTR("Alt+") + str;
if (p_event.key.mod.control)
str = TTR("Control+") + str;
press_a_key_label->set_text(str);
press_a_key->accept_event();
}
}
void ProjectSettings::_add_item(int p_item) {
add_type = InputEvent::Type(p_item);
switch (add_type) {
case InputEvent::KEY: {
press_a_key_label->set_text(TTR("Press a Key.."));
last_wait_for_key = InputEvent();
press_a_key->popup_centered(Size2(250, 80) * EDSCALE);
press_a_key->grab_focus();
} break;
case InputEvent::MOUSE_BUTTON: {
device_id->set_val(0);
device_index_label->set_text(TTR("Mouse Button Index:"));
device_index->clear();
device_index->add_item(TTR("Left Button"));
device_index->add_item(TTR("Right Button"));
device_index->add_item(TTR("Middle Button"));
device_index->add_item(TTR("Wheel Up Button"));
device_index->add_item(TTR("Wheel Down Button"));
device_index->add_item(TTR("Button 6"));
device_index->add_item(TTR("Button 7"));
device_index->add_item(TTR("Button 8"));
device_index->add_item(TTR("Button 9"));
device_input->popup_centered_minsize(Size2(350, 95));
} break;
case InputEvent::JOYSTICK_MOTION: {
device_id->set_val(0);
device_index_label->set_text(TTR("Joystick Axis Index:"));
device_index->clear();
for (int i = 0; i < JOY_AXIS_MAX * 2; i++) {
String desc = _axis_names[i];
device_index->add_item(TTR("Axis") + " " + itos(i / 2) + " " + (i & 1 ? "+" : "-") + desc);
}
device_input->popup_centered_minsize(Size2(350, 95));
} break;
case InputEvent::JOYSTICK_BUTTON: {
device_id->set_val(0);
device_index_label->set_text(TTR("Joystick Button Index:"));
device_index->clear();
for (int i = 0; i < JOY_BUTTON_MAX; i++) {
device_index->add_item(itos(i) + ": " + String(_button_names[i]));
}
device_input->popup_centered_minsize(Size2(350, 95));
} break;
default: {
}
}
}
void ProjectSettings::_action_button_pressed(Object *p_obj, int p_column, int p_id) {
TreeItem *ti = p_obj->cast_to<TreeItem>();
ERR_FAIL_COND(!ti);
if (p_id == 1) {
Point2 ofs = input_editor->get_global_pos();
Rect2 ir = input_editor->get_item_rect(ti);
ir.pos.y -= input_editor->get_scroll().y;
ofs += ir.pos + ir.size;
ofs.x -= 100;
popup_add->set_pos(ofs);
popup_add->popup();
add_at = "input/" + ti->get_text(0);
} else if (p_id == 2) {
//remove
if (ti->get_parent() == input_editor->get_root()) {
//remove main thing
String name = "input/" + ti->get_text(0);
Variant old_val = Globals::get_singleton()->get(name);
int order = Globals::get_singleton()->get_order(name);
undo_redo->create_action(TTR("Add Input Action"));
undo_redo->add_do_method(Globals::get_singleton(), "clear", name);
undo_redo->add_undo_method(Globals::get_singleton(), "set", name, old_val);
undo_redo->add_undo_method(Globals::get_singleton(), "set_order", name, order);
undo_redo->add_undo_method(Globals::get_singleton(), "set_persisting", name, Globals::get_singleton()->is_persisting(name));
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
} else {
//remove action
String name = "input/" + ti->get_parent()->get_text(0);
Variant old_val = Globals::get_singleton()->get(name);
int idx = ti->get_metadata(0);
Array va = old_val;
ERR_FAIL_INDEX(idx, va.size());
for (int i = idx; i < va.size() - 1; i++) {
va[i] = va[i + 1];
}
va.resize(va.size() - 1);
undo_redo->create_action(TTR("Erase Input Action Event"));
undo_redo->add_do_method(Globals::get_singleton(), "set", name, va);
undo_redo->add_undo_method(Globals::get_singleton(), "set", name, old_val);
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
}
}
void ProjectSettings::_update_actions() {
if (setting)
return;
input_editor->clear();
TreeItem *root = input_editor->create_item();
input_editor->set_hide_root(true);
List<PropertyInfo> props;
Globals::get_singleton()->get_property_list(&props);
for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
const PropertyInfo &pi = E->get();
if (!pi.name.begins_with("input/"))
continue;
String name = pi.name.get_slice("/", 1);
if (name == "")
continue;
TreeItem *item = input_editor->create_item(root);
//item->set_cell_mode(0,TreeItem::CELL_MODE_CHECK);
item->set_text(0, name);
item->add_button(0, get_icon("Add", "EditorIcons"), 1, false, TTR("Add Event"));
if (!Globals::get_singleton()->get_input_presets().find(pi.name)) {
item->add_button(0, get_icon("Remove", "EditorIcons"), 2, false, TTR("Remove"));
item->set_editable(0, true);
}
item->set_custom_bg_color(0, get_color("prop_subsection", "Editor"));
//item->set_checked(0,pi.usage&PROPERTY_USAGE_CHECKED);
Array actions = Globals::get_singleton()->get(pi.name);
for (int i = 0; i < actions.size(); i++) {
if (actions[i].get_type() != Variant::INPUT_EVENT)
continue;
InputEvent ie = actions[i];
TreeItem *action = input_editor->create_item(item);
switch (ie.type) {
case InputEvent::KEY: {
String str = keycode_get_string(ie.key.scancode).capitalize();
if (ie.key.mod.meta)
str = TTR("Meta+") + str;
if (ie.key.mod.shift)
str = TTR("Shift+") + str;
if (ie.key.mod.alt)
str = TTR("Alt+") + str;
if (ie.key.mod.control)
str = TTR("Control+") + str;
action->set_text(0, str);
action->set_icon(0, get_icon("Keyboard", "EditorIcons"));
} break;
case InputEvent::JOYSTICK_BUTTON: {
String str = TTR("Device") + " " + itos(ie.device) + ", " + TTR("Button") + " " + itos(ie.joy_button.button_index);
if (ie.joy_button.button_index >= 0 && ie.joy_button.button_index < JOY_BUTTON_MAX)
str += String() + " (" + _button_names[ie.joy_button.button_index] + ").";
else
str += ".";
action->set_text(0, str);
action->set_icon(0, get_icon("JoyButton", "EditorIcons"));
} break;
case InputEvent::MOUSE_BUTTON: {
String str = TTR("Device") + " " + itos(ie.device) + ", ";
switch (ie.mouse_button.button_index) {
case BUTTON_LEFT: str += TTR("Left Button."); break;
case BUTTON_RIGHT: str += TTR("Right Button."); break;
case BUTTON_MIDDLE: str += TTR("Middle Button."); break;
case BUTTON_WHEEL_UP: str += TTR("Wheel Up."); break;
case BUTTON_WHEEL_DOWN: str += TTR("Wheel Down."); break;
default: str += TTR("Button") + " " + itos(ie.mouse_button.button_index) + ".";
}
action->set_text(0, str);
action->set_icon(0, get_icon("Mouse", "EditorIcons"));
} break;
case InputEvent::JOYSTICK_MOTION: {
int ax = ie.joy_motion.axis;
int n = 2 * ax + (ie.joy_motion.axis_value < 0 ? 0 : 1);
String desc = _axis_names[n];
String str = TTR("Device") + " " + itos(ie.device) + ", " + TTR("Axis") + " " + itos(ax) + " " + (ie.joy_motion.axis_value < 0 ? "-" : "+") + desc + ".";
action->set_text(0, str);
action->set_icon(0, get_icon("JoyAxis", "EditorIcons"));
} break;
}
action->add_button(0, get_icon("Remove", "EditorIcons"), 2, false, TTR("Remove"));
action->set_metadata(0, i);
action->set_meta("__input", ie);
}
}
}
void ProjectSettings::popup_project_settings() {
//popup_centered(Size2(500,400));
popup_centered_ratio();
globals_editor->update_category_list();
_update_translations();
autoload_settings->update_autoload();
plugin_settings->update_plugins();
}
void ProjectSettings::_item_selected() {
TreeItem *ti = globals_editor->get_property_editor()->get_scene_tree()->get_selected();
if (!ti)
return;
if (!ti->get_parent())
return;
category->set_text(globals_editor->get_current_section());
property->set_text(ti->get_text(0));
popup_platform->set_disabled(false);
}
void ProjectSettings::_item_adds(String) {
_item_add();
}
void ProjectSettings::_item_add() {
Variant value;
switch (type->get_selected()) {
case 0: value = false; break;
case 1: value = 0; break;
case 2: value = 0.0; break;
case 3: value = ""; break;
}
String catname = category->get_text().strip_edges();
/*if (!catname.is_valid_identifier()) {
message->set_text("Invalid Category.\nValid characters: a-z,A-Z,0-9 or _");
message->popup_centered(Size2(300,100));
return;
}*/
String propname = property->get_text().strip_edges();
/*if (!propname.is_valid_identifier()) {
message->set_text("Invalid Property.\nValid characters: a-z,A-Z,0-9 or _");
message->popup_centered(Size2(300,100));
return;
}*/
String name = catname != "" ? catname + "/" + propname : propname;
undo_redo->create_action("Add Global Property");
undo_redo->add_do_property(Globals::get_singleton(), name, value);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", name, true);
if (Globals::get_singleton()->has(name)) {
undo_redo->add_undo_property(Globals::get_singleton(), name, Globals::get_singleton()->get(name));
} else {
undo_redo->add_undo_property(Globals::get_singleton(), name, Variant());
}
undo_redo->add_do_method(globals_editor, "update_category_list");
undo_redo->add_undo_method(globals_editor, "update_category_list");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
globals_editor->set_current_section(catname);
_settings_changed();
}
void ProjectSettings::_item_del() {
String catname = category->get_text().strip_edges();
//ERR_FAIL_COND(!catname.is_valid_identifier());
String propname = property->get_text().strip_edges();
//ERR_FAIL_COND(!propname.is_valid_identifier());
String name = catname != "" ? catname + "/" + propname : propname;
undo_redo->create_action("Delete Global Property");
undo_redo->add_do_property(Globals::get_singleton(), name, Variant());
undo_redo->add_undo_property(Globals::get_singleton(), name, Globals::get_singleton()->get(name));
undo_redo->add_undo_method(Globals::get_singleton(), "set_persisting", name, Globals::get_singleton()->is_persisting(name));
undo_redo->add_do_method(globals_editor, "update_category_list");
undo_redo->add_undo_method(globals_editor, "update_category_list");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
_settings_changed();
}
void ProjectSettings::_action_adds(String) {
_action_add();
}
void ProjectSettings::_action_add() {
String action = action_name->get_text();
if (action.find("/") != -1 || action.find(":") != -1 || action == "") {
message->set_text(TTR("Invalid action (anything goes but '/' or ':')."));
message->popup_centered(Size2(300, 100));
return;
}
if (Globals::get_singleton()->has("input/" + action)) {
message->set_text(vformat(TTR("Action '%s' already exists!"), action));
message->popup_centered(Size2(300, 100));
return;
}
Array va;
String name = "input/" + action;
undo_redo->create_action(TTR("Add Input Action Event"));
undo_redo->add_do_method(Globals::get_singleton(), "set", name, va);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", name, true);
undo_redo->add_undo_method(Globals::get_singleton(), "clear", name);
undo_redo->add_do_method(this, "_update_actions");
undo_redo->add_undo_method(this, "_update_actions");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
TreeItem *r = input_editor->get_root();
if (!r)
return;
r = r->get_children();
if (!r)
return;
while (r->get_next())
r = r->get_next();
if (!r)
return;
r->select(0);
input_editor->ensure_cursor_is_visible();
}
void ProjectSettings::_item_checked(const String &p_item, bool p_check) {
undo_redo->create_action(TTR("Toggle Persisting"));
String full_item = globals_editor->get_full_item_path(p_item);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", full_item, p_check);
undo_redo->add_undo_method(Globals::get_singleton(), "set_persisting", full_item, !p_check);
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->add_do_method(globals_editor->get_property_editor(), "update_tree");
undo_redo->add_undo_method(globals_editor->get_property_editor(), "update_tree");
undo_redo->commit_action();
}
void ProjectSettings::_save() {
Error err = Globals::get_singleton()->save();
message->set_text(err != OK ? TTR("Error saving settings.") : TTR("Settings saved OK."));
message->popup_centered(Size2(300, 100));
}
void ProjectSettings::_settings_prop_edited(const String &p_name) {
String full_item = globals_editor->get_full_item_path(p_name);
if (!Globals::get_singleton()->is_persisting(full_item)) {
Globals::get_singleton()->set_persisting(full_item, true);
{
//small usability workaround, if anything related to resolution scaling or size is modified, change all of them together
if (full_item == "display/width" || full_item == "display/height" || full_item == "display/stretch_mode") {
Globals::get_singleton()->set_persisting("display/height", true);
Globals::get_singleton()->set_persisting("display/width", true);
}
}
// globals_editor->update_property(p_name);
globals_editor->get_property_editor()->update_tree();
}
_settings_changed();
}
void ProjectSettings::_settings_changed() {
timer->start();
}
void ProjectSettings::queue_save() {
_settings_changed();
}
void ProjectSettings::_copy_to_platform(int p_which) {
String catname = category->get_text();
if (!catname.is_valid_identifier()) {
message->set_text("Invalid Category.\nValid characters: a-z,A-Z,0-9 or _");
message->popup_centered(Size2(300, 100));
return;
}
String propname = property->get_text();
if (!propname.is_valid_identifier()) {
message->set_text("Invalid Property.\nValid characters: a-z,A-Z,0-9 or _");
message->popup_centered(Size2(300, 100));
return;
}
String name = catname + "/" + propname;
Variant value = Globals::get_singleton()->get(name);
catname += "." + popup_platform->get_popup()->get_item_text(p_which);
name = catname + "/" + propname;
Globals::get_singleton()->set(name, value);
globals_editor->get_property_editor()->update_tree();
}
void ProjectSettings::add_translation(const String &p_translation) {
_translation_add(p_translation);
}
void ProjectSettings::_translation_add(const String &p_path) {
StringArray translations = Globals::get_singleton()->get("locale/translations");
for (int i = 0; i < translations.size(); i++) {
if (translations[i] == p_path)
return; //exists
}
translations.push_back(p_path);
undo_redo->create_action(TTR("Add Translation"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translations", translations);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translations", Globals::get_singleton()->get("locale/translations"));
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translations", true);
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_translation_file_open() {
translation_file_open->popup_centered_ratio();
}
void ProjectSettings::_translation_delete(Object *p_item, int p_column, int p_button) {
TreeItem *ti = p_item->cast_to<TreeItem>();
ERR_FAIL_COND(!ti);
int idx = ti->get_metadata(0);
StringArray translations = Globals::get_singleton()->get("locale/translations");
ERR_FAIL_INDEX(idx, translations.size());
translations.remove(idx);
undo_redo->create_action(TTR("Remove Translation"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translations", translations);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translations", Globals::get_singleton()->get("locale/translations"));
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_translation_res_file_open() {
translation_res_file_open->popup_centered_ratio();
}
void ProjectSettings::_translation_res_add(const String &p_path) {
Variant prev;
Dictionary remaps;
if (Globals::get_singleton()->has("locale/translation_remaps")) {
remaps = Globals::get_singleton()->get("locale/translation_remaps");
prev = remaps;
}
if (remaps.has(p_path))
return; //pointless already has it
remaps[p_path] = StringArray();
undo_redo->create_action(TTR("Add Remapped Path"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translation_remaps", remaps);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translation_remaps", true);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translation_remaps", prev);
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_translation_res_option_file_open() {
translation_res_option_file_open->popup_centered_ratio();
}
void ProjectSettings::_translation_res_option_add(const String &p_path) {
ERR_FAIL_COND(!Globals::get_singleton()->has("locale/translation_remaps"));
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
TreeItem *k = translation_remap->get_selected();
ERR_FAIL_COND(!k);
String key = k->get_metadata(0);
ERR_FAIL_COND(!remaps.has(key));
StringArray r = remaps[key];
r.push_back(p_path + ":" + "en");
remaps[key] = r;
undo_redo->create_action(TTR("Resource Remap Add Remap"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translation_remaps", remaps);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translation_remaps", true);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translation_remaps", Globals::get_singleton()->get("locale/translation_remaps"));
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_translation_res_select() {
if (updating_translations)
return;
call_deferred("_update_translations");
}
void ProjectSettings::_translation_res_option_changed() {
if (updating_translations)
return;
if (!Globals::get_singleton()->has("locale/translation_remaps"))
return;
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
TreeItem *k = translation_remap->get_selected();
ERR_FAIL_COND(!k);
TreeItem *ed = translation_remap_options->get_edited();
ERR_FAIL_COND(!ed);
String key = k->get_metadata(0);
int idx = ed->get_metadata(0);
String path = ed->get_metadata(1);
int which = ed->get_range(1);
Vector<String> langs = TranslationServer::get_all_locales();
ERR_FAIL_INDEX(which, langs.size());
ERR_FAIL_COND(!remaps.has(key));
StringArray r = remaps[key];
ERR_FAIL_INDEX(idx, r.size());
r.set(idx, path + ":" + langs[which]);
remaps[key] = r;
updating_translations = true;
undo_redo->create_action(TTR("Change Resource Remap Language"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translation_remaps", remaps);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translation_remaps", true);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translation_remaps", Globals::get_singleton()->get("locale/translation_remaps"));
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
updating_translations = false;
}
void ProjectSettings::_translation_res_delete(Object *p_item, int p_column, int p_button) {
if (updating_translations)
return;
if (!Globals::get_singleton()->has("locale/translation_remaps"))
return;
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
TreeItem *k = p_item->cast_to<TreeItem>();
String key = k->get_metadata(0);
ERR_FAIL_COND(!remaps.has(key));
remaps.erase(key);
undo_redo->create_action(TTR("Remove Resource Remap"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translation_remaps", remaps);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translation_remaps", true);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translation_remaps", Globals::get_singleton()->get("locale/translation_remaps"));
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_translation_res_option_delete(Object *p_item, int p_column, int p_button) {
if (updating_translations)
return;
if (!Globals::get_singleton()->has("locale/translation_remaps"))
return;
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
TreeItem *k = translation_remap->get_selected();
ERR_FAIL_COND(!k);
TreeItem *ed = p_item->cast_to<TreeItem>();
ERR_FAIL_COND(!ed);
String key = k->get_metadata(0);
int idx = ed->get_metadata(0);
ERR_FAIL_COND(!remaps.has(key));
StringArray r = remaps[key];
ERR_FAIL_INDEX(idx, remaps.size());
r.remove(idx);
remaps[key] = r;
undo_redo->create_action(TTR("Remove Resource Remap Option"));
undo_redo->add_do_property(Globals::get_singleton(), "locale/translation_remaps", remaps);
undo_redo->add_do_method(Globals::get_singleton(), "set_persisting", "locale/translation_remaps", true);
undo_redo->add_undo_property(Globals::get_singleton(), "locale/translation_remaps", Globals::get_singleton()->get("locale/translation_remaps"));
undo_redo->add_do_method(this, "_update_translations");
undo_redo->add_undo_method(this, "_update_translations");
undo_redo->add_do_method(this, "_settings_changed");
undo_redo->add_undo_method(this, "_settings_changed");
undo_redo->commit_action();
}
void ProjectSettings::_update_translations() {
//update translations
if (updating_translations)
return;
updating_translations = true;
translation_list->clear();
TreeItem *root = translation_list->create_item(NULL);
translation_list->set_hide_root(true);
if (Globals::get_singleton()->has("locale/translations")) {
StringArray translations = Globals::get_singleton()->get("locale/translations");
for (int i = 0; i < translations.size(); i++) {
TreeItem *t = translation_list->create_item(root);
t->set_editable(0, false);
t->set_text(0, translations[i].replace_first("res://", ""));
t->set_tooltip(0, translations[i]);
t->set_metadata(0, i);
t->add_button(0, get_icon("Del", "EditorIcons"), 0, false, TTR("Remove"));
}
}
//update translation remaps
String remap_selected;
if (translation_remap->get_selected()) {
remap_selected = translation_remap->get_selected()->get_metadata(0);
}
translation_remap->clear();
translation_remap_options->clear();
root = translation_remap->create_item(NULL);
TreeItem *root2 = translation_remap_options->create_item(NULL);
translation_remap->set_hide_root(true);
translation_remap_options->set_hide_root(true);
translation_res_option_add_button->set_disabled(true);
Vector<String> langs = TranslationServer::get_all_locales();
Vector<String> names = TranslationServer::get_all_locale_names();
String langnames;
for (int i = 0; i < names.size(); i++) {
if (i > 0)
langnames += ",";
langnames += names[i];
}
if (Globals::get_singleton()->has("locale/translation_remaps")) {
Dictionary remaps = Globals::get_singleton()->get("locale/translation_remaps");
List<Variant> rk;
remaps.get_key_list(&rk);
Vector<String> keys;
for (List<Variant>::Element *E = rk.front(); E; E = E->next()) {
keys.push_back(E->get());
}
keys.sort();
for (int i = 0; i < keys.size(); i++) {
TreeItem *t = translation_remap->create_item(root);
t->set_editable(0, false);
t->set_text(0, keys[i].replace_first("res://", ""));
t->set_tooltip(0, keys[i]);
t->set_metadata(0, keys[i]);
t->add_button(0, get_icon("Del", "EditorIcons"), 0, false, TTR("Remove"));
if (keys[i] == remap_selected) {
t->select(0);
translation_res_option_add_button->set_disabled(false);
StringArray selected = remaps[keys[i]];
for (int j = 0; j < selected.size(); j++) {
String s = selected[j];
int qp = s.find_last(":");
String path = s.substr(0, qp);
String locale = s.substr(qp + 1, s.length());
TreeItem *t2 = translation_remap_options->create_item(root2);
t2->set_editable(0, false);
t2->set_text(0, path.replace_first("res://", ""));
t2->set_tooltip(0, path);
t2->set_metadata(0, j);
t2->add_button(0, get_icon("Del", "EditorIcons"), 0, false, TTR("Remove"));
t2->set_cell_mode(1, TreeItem::CELL_MODE_RANGE);
t2->set_text(1, langnames);
t2->set_editable(1, true);
t2->set_metadata(1, path);
int idx = langs.find(locale);
print_line("find " + locale + " at " + itos(idx));
if (idx < 0)
idx = 0;
t2->set_range(1, idx);
}
}
}
}
updating_translations = false;
}
void ProjectSettings::_toggle_search_bar(bool p_pressed) {
globals_editor->get_property_editor()->set_use_filter(p_pressed);
if (p_pressed) {
search_bar->show();
add_prop_bar->hide();
search_box->grab_focus();
search_box->select_all();
} else {
search_bar->hide();
add_prop_bar->show();
}
}
void ProjectSettings::_clear_search_box() {
if (search_box->get_text() == "")
return;
search_box->clear();
globals_editor->get_property_editor()->update_tree();
}
void ProjectSettings::set_plugins_page() {
tab_container->set_current_tab(plugin_settings->get_index());
}
void ProjectSettings::_bind_methods() {
ObjectTypeDB::bind_method(_MD("_item_selected"), &ProjectSettings::_item_selected);
ObjectTypeDB::bind_method(_MD("_item_add"), &ProjectSettings::_item_add);
ObjectTypeDB::bind_method(_MD("_item_adds"), &ProjectSettings::_item_adds);
ObjectTypeDB::bind_method(_MD("_item_del"), &ProjectSettings::_item_del);
ObjectTypeDB::bind_method(_MD("_item_checked"), &ProjectSettings::_item_checked);
ObjectTypeDB::bind_method(_MD("_save"), &ProjectSettings::_save);
ObjectTypeDB::bind_method(_MD("_action_add"), &ProjectSettings::_action_add);
ObjectTypeDB::bind_method(_MD("_action_adds"), &ProjectSettings::_action_adds);
ObjectTypeDB::bind_method(_MD("_action_selected"), &ProjectSettings::_action_selected);
ObjectTypeDB::bind_method(_MD("_action_edited"), &ProjectSettings::_action_edited);
ObjectTypeDB::bind_method(_MD("_action_button_pressed"), &ProjectSettings::_action_button_pressed);
ObjectTypeDB::bind_method(_MD("_update_actions"), &ProjectSettings::_update_actions);
ObjectTypeDB::bind_method(_MD("_wait_for_key"), &ProjectSettings::_wait_for_key);
ObjectTypeDB::bind_method(_MD("_add_item"), &ProjectSettings::_add_item);
ObjectTypeDB::bind_method(_MD("_device_input_add"), &ProjectSettings::_device_input_add);
ObjectTypeDB::bind_method(_MD("_press_a_key_confirm"), &ProjectSettings::_press_a_key_confirm);
ObjectTypeDB::bind_method(_MD("_settings_prop_edited"), &ProjectSettings::_settings_prop_edited);
ObjectTypeDB::bind_method(_MD("_copy_to_platform"), &ProjectSettings::_copy_to_platform);
ObjectTypeDB::bind_method(_MD("_update_translations"), &ProjectSettings::_update_translations);
ObjectTypeDB::bind_method(_MD("_translation_delete"), &ProjectSettings::_translation_delete);
ObjectTypeDB::bind_method(_MD("_settings_changed"), &ProjectSettings::_settings_changed);
ObjectTypeDB::bind_method(_MD("_translation_add"), &ProjectSettings::_translation_add);
ObjectTypeDB::bind_method(_MD("_translation_file_open"), &ProjectSettings::_translation_file_open);
ObjectTypeDB::bind_method(_MD("_translation_res_add"), &ProjectSettings::_translation_res_add);
ObjectTypeDB::bind_method(_MD("_translation_res_file_open"), &ProjectSettings::_translation_res_file_open);
ObjectTypeDB::bind_method(_MD("_translation_res_option_add"), &ProjectSettings::_translation_res_option_add);
ObjectTypeDB::bind_method(_MD("_translation_res_option_file_open"), &ProjectSettings::_translation_res_option_file_open);
ObjectTypeDB::bind_method(_MD("_translation_res_select"), &ProjectSettings::_translation_res_select);
ObjectTypeDB::bind_method(_MD("_translation_res_option_changed"), &ProjectSettings::_translation_res_option_changed);
ObjectTypeDB::bind_method(_MD("_translation_res_delete"), &ProjectSettings::_translation_res_delete);
ObjectTypeDB::bind_method(_MD("_translation_res_option_delete"), &ProjectSettings::_translation_res_option_delete);
ObjectTypeDB::bind_method(_MD("_clear_search_box"), &ProjectSettings::_clear_search_box);
ObjectTypeDB::bind_method(_MD("_toggle_search_bar"), &ProjectSettings::_toggle_search_bar);
}
ProjectSettings::ProjectSettings(EditorData *p_data) {
singleton = this;
set_title(TTR("Project Settings (engine.cfg)"));
undo_redo = &p_data->get_undo_redo();
data = p_data;
tab_container = memnew(TabContainer);
add_child(tab_container);
set_child_rect(tab_container);
//tab_container->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN, 15 );
//tab_container->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END, 15 );
//tab_container->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN, 15 );
//tab_container->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
VBoxContainer *props_base = memnew(VBoxContainer);
props_base->set_alignment(BoxContainer::ALIGN_BEGIN);
props_base->set_v_size_flags(Control::SIZE_EXPAND_FILL);
tab_container->add_child(props_base);
props_base->set_name(TTR("General"));
HBoxContainer *hbc = memnew(HBoxContainer);
hbc->set_h_size_flags(Control::SIZE_EXPAND_FILL);
props_base->add_child(hbc);
search_button = memnew(ToolButton);
search_button->set_toggle_mode(true);
search_button->set_pressed(false);
search_button->set_text(TTR("Search"));
hbc->add_child(search_button);
search_button->connect("toggled", this, "_toggle_search_bar");
hbc->add_child(memnew(VSeparator));
add_prop_bar = memnew(HBoxContainer);
add_prop_bar->set_h_size_flags(Control::SIZE_EXPAND_FILL);
hbc->add_child(add_prop_bar);
Label *l = memnew(Label);
add_prop_bar->add_child(l);
l->set_text(TTR("Category:"));
category = memnew(LineEdit);
category->set_h_size_flags(Control::SIZE_EXPAND_FILL);
add_prop_bar->add_child(category);
category->connect("text_entered", this, "_item_adds");
l = memnew(Label);
add_prop_bar->add_child(l);
l->set_text(TTR("Property:"));
property = memnew(LineEdit);
property->set_h_size_flags(Control::SIZE_EXPAND_FILL);
add_prop_bar->add_child(property);
property->connect("text_entered", this, "_item_adds");
l = memnew(Label);
add_prop_bar->add_child(l);
l->set_text(TTR("Type:"));
type = memnew(OptionButton);
type->set_h_size_flags(Control::SIZE_EXPAND_FILL);
add_prop_bar->add_child(type);
type->add_item("bool");
type->add_item("int");
type->add_item("float");
type->add_item("string");
Button *add = memnew(Button);
add_prop_bar->add_child(add);
add->set_text(TTR("Add"));
add->connect("pressed", this, "_item_add");
Button *del = memnew(Button);
add_prop_bar->add_child(del);
del->set_text(TTR("Del"));
del->connect("pressed", this, "_item_del");
search_bar = memnew(HBoxContainer);
search_bar->set_h_size_flags(Control::SIZE_EXPAND_FILL);
hbc->add_child(search_bar);
search_bar->hide();
search_box = memnew(LineEdit);
search_box->set_h_size_flags(Control::SIZE_EXPAND_FILL);
search_bar->add_child(search_box);
clear_button = memnew(ToolButton);
search_bar->add_child(clear_button);
clear_button->connect("pressed", this, "_clear_search_box");
globals_editor = memnew(SectionedPropertyEditor);
props_base->add_child(globals_editor);
//globals_editor->hide_top_label();
globals_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
globals_editor->get_property_editor()->register_text_enter(search_box);
globals_editor->get_property_editor()->get_scene_tree()->connect("cell_selected", this, "_item_selected");
globals_editor->get_property_editor()->connect("property_toggled", this, "_item_checked", varray(), CONNECT_DEFERRED);
globals_editor->get_property_editor()->connect("property_edited", this, "_settings_prop_edited");
/*
Button *save = memnew( Button );
props_base->add_child(save);
save->set_anchor(MARGIN_LEFT,ANCHOR_END);
save->set_anchor(MARGIN_RIGHT,ANCHOR_END);
save->set_anchor(MARGIN_TOP,ANCHOR_END);
save->set_anchor(MARGIN_BOTTOM,ANCHOR_END);
save->set_begin( Point2(80,28) );
save->set_end( Point2(10,20) );
save->set_text("Save");
save->connect("pressed",this,"_save");
*/
hbc = memnew(HBoxContainer);
props_base->add_child(hbc);
popup_platform = memnew(MenuButton);
popup_platform->set_text(TTR("Copy To Platform.."));
popup_platform->set_disabled(true);
hbc->add_child(popup_platform);
hbc->add_spacer();
List<StringName> ep;
EditorImportExport::get_singleton()->get_export_platforms(&ep);
ep.sort_custom<StringName::AlphCompare>();
for (List<StringName>::Element *E = ep.front(); E; E = E->next()) {
popup_platform->get_popup()->add_item(E->get());
}
popup_platform->get_popup()->connect("item_pressed", this, "_copy_to_platform");
get_ok()->set_text(TTR("Close"));
set_hide_on_ok(true);
message = memnew(ConfirmationDialog);
add_child(message);
// message->get_cancel()->hide();
message->set_hide_on_ok(true);
Control *input_base = memnew(Control);
input_base->set_name(TTR("Input Map"));
input_base->set_area_as_parent_rect();
tab_container->add_child(input_base);
VBoxContainer *vbc = memnew(VBoxContainer);
input_base->add_child(vbc);
vbc->set_anchor_and_margin(MARGIN_TOP, ANCHOR_BEGIN, 5);
vbc->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_END, 5);
vbc->set_anchor_and_margin(MARGIN_LEFT, ANCHOR_BEGIN, 5);
vbc->set_anchor_and_margin(MARGIN_RIGHT, ANCHOR_END, 5);
l = memnew(Label);
vbc->add_child(l);
l->set_pos(Point2(6, 5));
l->set_text(TTR("Action:"));
hbc = memnew(HBoxContainer);
vbc->add_child(hbc);
action_name = memnew(LineEdit);
action_name->set_h_size_flags(SIZE_EXPAND_FILL);
hbc->add_child(action_name);
action_name->connect("text_entered", this, "_action_adds");
add = memnew(Button);
hbc->add_child(add);
add->set_custom_minimum_size(Size2(150, 0));
add->set_text(TTR("Add"));
add->connect("pressed", this, "_action_add");
input_editor = memnew(Tree);
vbc->add_child(input_editor);
input_editor->set_v_size_flags(SIZE_EXPAND_FILL);
input_editor->connect("item_edited", this, "_action_edited");
input_editor->connect("cell_selected", this, "_action_selected");
input_editor->connect("button_pressed", this, "_action_button_pressed");
popup_add = memnew(PopupMenu);
add_child(popup_add);
popup_add->connect("item_pressed", this, "_add_item");
press_a_key = memnew(ConfirmationDialog);
press_a_key->set_focus_mode(FOCUS_ALL);
add_child(press_a_key);
l = memnew(Label);
l->set_text(TTR("Press a Key.."));
l->set_area_as_parent_rect();
l->set_align(Label::ALIGN_CENTER);
l->set_margin(MARGIN_TOP, 20);
l->set_anchor_and_margin(MARGIN_BOTTOM, ANCHOR_BEGIN, 30);
press_a_key_label = l;
press_a_key->add_child(l);
press_a_key->connect("input_event", this, "_wait_for_key");
press_a_key->connect("confirmed", this, "_press_a_key_confirm");
device_input = memnew(ConfirmationDialog);
add_child(device_input);
device_input->get_ok()->set_text(TTR("Add"));
device_input->connect("confirmed", this, "_device_input_add");
hbc = memnew(HBoxContainer);
device_input->add_child(hbc);
device_input->set_child_rect(hbc);
VBoxContainer *vbc_left = memnew(VBoxContainer);
hbc->add_child(vbc_left);
l = memnew(Label);
l->set_text(TTR("Device:"));
vbc_left->add_child(l);
device_id = memnew(SpinBox);
device_id->set_val(0);
vbc_left->add_child(device_id);
VBoxContainer *vbc_right = memnew(VBoxContainer);
hbc->add_child(vbc_right);
vbc_right->set_h_size_flags(SIZE_EXPAND_FILL);
l = memnew(Label);
l->set_text(TTR("Index:"));
vbc_right->add_child(l);
device_index_label = l;
device_index = memnew(OptionButton);
vbc_right->add_child(device_index);
/*
save = memnew( Button );
input_base->add_child(save);
save->set_anchor(MARGIN_LEFT,ANCHOR_END);
save->set_anchor(MARGIN_RIGHT,ANCHOR_END);
save->set_anchor(MARGIN_TOP,ANCHOR_END);
save->set_anchor(MARGIN_BOTTOM,ANCHOR_END);
save->set_begin( Point2(80,28) );
save->set_end( Point2(10,20) );
save->set_text("Save");
save->connect("pressed",this,"_save");
*/
setting = false;
//translations
TabContainer *translations = memnew(TabContainer);
translations->set_name(TTR("Localization"));
tab_container->add_child(translations);
{
VBoxContainer *tvb = memnew(VBoxContainer);
translations->add_child(tvb);
tvb->set_name(TTR("Translations"));
HBoxContainer *thb = memnew(HBoxContainer);
tvb->add_child(thb);
thb->add_child(memnew(Label(TTR("Translations:"))));
thb->add_spacer();
Button *addtr = memnew(Button(TTR("Add..")));
addtr->connect("pressed", this, "_translation_file_open");
thb->add_child(addtr);
MarginContainer *tmc = memnew(MarginContainer);
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_list = memnew(Tree);
translation_list->set_v_size_flags(SIZE_EXPAND_FILL);
tmc->add_child(translation_list);
translation_file_open = memnew(EditorFileDialog);
add_child(translation_file_open);
translation_file_open->set_mode(EditorFileDialog::MODE_OPEN_FILE);
translation_file_open->connect("file_selected", this, "_translation_add");
}
{
VBoxContainer *tvb = memnew(VBoxContainer);
translations->add_child(tvb);
tvb->set_name(TTR("Remaps"));
HBoxContainer *thb = memnew(HBoxContainer);
tvb->add_child(thb);
thb->add_child(memnew(Label(TTR("Resources:"))));
thb->add_spacer();
Button *addtr = memnew(Button(TTR("Add..")));
addtr->connect("pressed", this, "_translation_res_file_open");
thb->add_child(addtr);
MarginContainer *tmc = memnew(MarginContainer);
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap = memnew(Tree);
translation_remap->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap->connect("cell_selected", this, "_translation_res_select");
tmc->add_child(translation_remap);
translation_remap->connect("button_pressed", this, "_translation_res_delete");
translation_res_file_open = memnew(EditorFileDialog);
add_child(translation_res_file_open);
translation_res_file_open->set_mode(EditorFileDialog::MODE_OPEN_FILE);
translation_res_file_open->connect("file_selected", this, "_translation_res_add");
thb = memnew(HBoxContainer);
tvb->add_child(thb);
thb->add_child(memnew(Label(TTR("Remaps by Locale:"))));
thb->add_spacer();
addtr = memnew(Button(TTR("Add..")));
addtr->connect("pressed", this, "_translation_res_option_file_open");
translation_res_option_add_button = addtr;
thb->add_child(addtr);
tmc = memnew(MarginContainer);
tvb->add_child(tmc);
tmc->set_v_size_flags(SIZE_EXPAND_FILL);
translation_remap_options = memnew(Tree);
translation_remap_options->set_v_size_flags(SIZE_EXPAND_FILL);
tmc->add_child(translation_remap_options);
translation_remap_options->set_columns(2);
translation_remap_options->set_column_title(0, TTR("Path"));
translation_remap_options->set_column_title(1, TTR("Locale"));
translation_remap_options->set_column_titles_visible(true);
translation_remap_options->set_column_expand(0, true);
translation_remap_options->set_column_expand(1, false);
translation_remap_options->set_column_min_width(1, 200);
translation_remap_options->connect("item_edited", this, "_translation_res_option_changed");
translation_remap_options->connect("button_pressed", this, "_translation_res_option_delete");
translation_res_option_file_open = memnew(EditorFileDialog);
add_child(translation_res_option_file_open);
translation_res_option_file_open->set_mode(EditorFileDialog::MODE_OPEN_FILE);
translation_res_option_file_open->connect("file_selected", this, "_translation_res_option_add");
}
{
autoload_settings = memnew(EditorAutoloadSettings);
autoload_settings->set_name(TTR("AutoLoad"));
tab_container->add_child(autoload_settings);
autoload_settings->connect("autoload_changed", this, "_settings_changed");
}
{
plugin_settings = memnew(EditorPluginSettings);
plugin_settings->set_name(TTR("Plugins"));
tab_container->add_child(plugin_settings);
}
timer = memnew(Timer);
timer->set_wait_time(1.5);
timer->connect("timeout", Globals::get_singleton(), "save");
timer->set_one_shot(true);
add_child(timer);
updating_translations = false;
/*
Control * es = memnew( Control );
es->set_name("Export");
tab_container->add_child(es);
export_settings = memnew( ProjectExportSettings );
es->add_child(export_settings);
export_settings->set_area_as_parent_rect();
export_settings->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END, 35 );
*/
}
Reference in New Issue View Git Blame Copy Permalink