diff options
Diffstat (limited to 'editor/input_map_editor.cpp')
| -rw-r--r-- | editor/input_map_editor.cpp | 1048 |
1 files changed, 1048 insertions, 0 deletions
diff --git a/editor/input_map_editor.cpp b/editor/input_map_editor.cpp new file mode 100644 index 0000000000..70c354e55a --- /dev/null +++ b/editor/input_map_editor.cpp @@ -0,0 +1,1048 @@ +/*************************************************************************/ +/* input_map_editor.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 "input_map_editor.h" + +#include "core/input/input_map.h" +#include "core/os/keyboard.h" +#include "editor/editor_node.h" +#include "editor/editor_scale.h" + +static const char *_button_descriptions[JOY_SDL_BUTTONS] = { + "Face Bottom, DualShock Cross, Xbox A, Nintendo B", + "Face Right, DualShock Circle, Xbox B, Nintendo A", + "Face Left, DualShock Square, Xbox X, Nintendo Y", + "Face Top, DualShock Triangle, Xbox Y, Nintendo X", + "DualShock Select, Xbox Back, Nintendo -", + "Home, DualShock PS, Guide", + "Start, Nintendo +", + "Left Stick, DualShock L3, Xbox L/LS", + "Right Stick, DualShock R3, Xbox R/RS", + "Left Shoulder, DualShock L1, Xbox LB", + "Right Shoulder, DualShock R1, Xbox RB", + "D-Pad Up", + "D-Pad Down", + "D-Pad Left", + "D-Pad Right" +}; + +static const char *_axis_descriptions[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", + "Joystick 2 Left", + "Joystick 2 Right, Left Trigger, L2, LT", + "Joystick 2 Up", + "Joystick 2 Down, Right Trigger, R2, RT", + "Joystick 3 Left", + "Joystick 3 Right", + "Joystick 3 Up", + "Joystick 3 Down", + "Joystick 4 Left", + "Joystick 4 Right", + "Joystick 4 Up", + "Joystick 4 Down", +}; + +void InputMapEditor::_notification(int p_what) { + switch (p_what) { + case NOTIFICATION_ENTER_TREE: { + action_add_error->add_theme_color_override("font_color", input_editor->get_theme_color("error_color", "Editor")); + popup_add->add_icon_item(input_editor->get_theme_icon("Keyboard", "EditorIcons"), TTR("Key"), INPUT_KEY); + popup_add->add_icon_item(input_editor->get_theme_icon("KeyboardPhysical", "EditorIcons"), TTR("Physical Key"), INPUT_KEY_PHYSICAL); + popup_add->add_icon_item(input_editor->get_theme_icon("JoyButton", "EditorIcons"), TTR("Joy Button"), INPUT_JOY_BUTTON); + popup_add->add_icon_item(input_editor->get_theme_icon("JoyAxis", "EditorIcons"), TTR("Joy Axis"), INPUT_JOY_MOTION); + popup_add->add_icon_item(input_editor->get_theme_icon("Mouse", "EditorIcons"), TTR("Mouse Button"), INPUT_MOUSE_BUTTON); + _update_actions(); + } break; + case EditorSettings::NOTIFICATION_EDITOR_SETTINGS_CHANGED: { + action_add_error->add_theme_color_override("font_color", input_editor->get_theme_color("error_color", "Editor")); + popup_add->set_item_icon(popup_add->get_item_index(INPUT_KEY), input_editor->get_theme_icon("Keyboard", "EditorIcons")); + popup_add->set_item_icon(popup_add->get_item_index(INPUT_KEY_PHYSICAL), input_editor->get_theme_icon("KeyboardPhysical", "EditorIcons")); + popup_add->set_item_icon(popup_add->get_item_index(INPUT_JOY_BUTTON), input_editor->get_theme_icon("JoyButton", "EditorIcons")); + popup_add->set_item_icon(popup_add->get_item_index(INPUT_JOY_MOTION), input_editor->get_theme_icon("JoyAxis", "EditorIcons")); + popup_add->set_item_icon(popup_add->get_item_index(INPUT_MOUSE_BUTTON), input_editor->get_theme_icon("Mouse", "EditorIcons")); + _update_actions(); + } break; + } +} + +static bool _validate_action_name(const String &p_name) { + const CharType *cstr = p_name.c_str(); + for (int i = 0; cstr[i]; i++) { + if (cstr[i] == '/' || cstr[i] == ':' || cstr[i] == '"' || + cstr[i] == '=' || cstr[i] == '\\' || cstr[i] < 32) { + return false; + } + } + return true; +} + +void InputMapEditor::_action_selected() { + TreeItem *ti = input_editor->get_selected(); + if (!ti || !ti->is_editable(0)) { + return; + } + + add_at = "input/" + ti->get_text(0); + edit_idx = -1; +} + +void InputMapEditor::_action_edited() { + TreeItem *ti = input_editor->get_selected(); + if (!ti) { + return; + } + + if (input_editor->get_selected_column() == 0) { + 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 == "" || !_validate_action_name(new_name)) { + ti->set_text(0, old_name); + add_at = "input/" + old_name; + + message->set_text(TTR("Invalid action name. it cannot be empty nor contain '/', ':', '=', '\\' or '\"'")); + message->popup_centered(Size2(300, 100) * EDSCALE); + return; + } + + String action_prop = "input/" + new_name; + + if (ProjectSettings::get_singleton()->has_setting(action_prop)) { + ti->set_text(0, old_name); + add_at = "input/" + old_name; + + message->set_text(vformat(TTR("An action with the name '%s' already exists."), new_name)); + message->popup_centered(Size2(300, 100) * EDSCALE); + return; + } + + int order = ProjectSettings::get_singleton()->get_order(add_at); + Dictionary action = ProjectSettings::get_singleton()->get(add_at); + + setting = true; + undo_redo->create_action(TTR("Rename Input Action Event")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "clear", add_at); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", action_prop, action); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", action_prop, order); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "clear", action_prop); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set", add_at, action); + undo_redo->add_undo_method(ProjectSettings::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, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + setting = false; + + add_at = action_prop; + } else if (input_editor->get_selected_column() == 1) { + String name = "input/" + ti->get_text(0); + Dictionary old_action = ProjectSettings::get_singleton()->get(name); + Dictionary new_action = old_action.duplicate(); + new_action["deadzone"] = ti->get_range(1); + + undo_redo->create_action(TTR("Change Action deadzone")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", name, new_action); + undo_redo->add_do_method(this, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set", name, old_action); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + } +} + +void InputMapEditor::_device_input_add() { + Ref<InputEvent> ie; + String name = add_at; + int idx = edit_idx; + Dictionary old_val = ProjectSettings::get_singleton()->get(name); + Dictionary action = old_val.duplicate(); + Array events = action["events"]; + + switch (add_type) { + case INPUT_MOUSE_BUTTON: { + Ref<InputEventMouseButton> mb; + mb.instance(); + mb->set_button_index(device_index->get_selected() + 1); + mb->set_device(_get_current_device()); + + for (int i = 0; i < events.size(); i++) { + Ref<InputEventMouseButton> aie = events[i]; + if (aie.is_null()) { + continue; + } + if (aie->get_device() == mb->get_device() && aie->get_button_index() == mb->get_button_index()) { + return; + } + } + + ie = mb; + + } break; + case INPUT_JOY_MOTION: { + Ref<InputEventJoypadMotion> jm; + jm.instance(); + jm->set_axis(device_index->get_selected() >> 1); + jm->set_axis_value((device_index->get_selected() & 1) ? 1 : -1); + jm->set_device(_get_current_device()); + + for (int i = 0; i < events.size(); i++) { + Ref<InputEventJoypadMotion> aie = events[i]; + if (aie.is_null()) { + continue; + } + + if (aie->get_device() == jm->get_device() && aie->get_axis() == jm->get_axis() && aie->get_axis_value() == jm->get_axis_value()) { + return; + } + } + + ie = jm; + + } break; + case INPUT_JOY_BUTTON: { + Ref<InputEventJoypadButton> jb; + jb.instance(); + + jb->set_button_index(device_index->get_selected()); + jb->set_device(_get_current_device()); + + for (int i = 0; i < events.size(); i++) { + Ref<InputEventJoypadButton> aie = events[i]; + if (aie.is_null()) { + continue; + } + if (aie->get_device() == jb->get_device() && aie->get_button_index() == jb->get_button_index()) { + return; + } + } + ie = jb; + + } break; + default: { + } + } + + if (idx < 0 || idx >= events.size()) { + events.push_back(ie); + } else { + events[idx] = ie; + } + action["events"] = events; + + undo_redo->create_action(TTR("Add Input Action Event")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", name, action); + undo_redo->add_undo_method(ProjectSettings::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, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + + _show_last_added(ie, name); +} + +void InputMapEditor::_set_current_device(int i_device) { + device_id->select(i_device + 1); +} + +int InputMapEditor::_get_current_device() { + return device_id->get_selected() - 1; +} + +String InputMapEditor::_get_device_string(int i_device) { + if (i_device == InputMap::ALL_DEVICES) { + return TTR("All Devices"); + } + return TTR("Device") + " " + itos(i_device); +} + +void InputMapEditor::_press_a_key_confirm() { + if (last_wait_for_key.is_null()) { + return; + } + + Ref<InputEventKey> ie; + ie.instance(); + if (press_a_key_physical) { + ie->set_physical_keycode(last_wait_for_key->get_physical_keycode()); + ie->set_keycode(0); + } else { + ie->set_physical_keycode(0); + ie->set_keycode(last_wait_for_key->get_keycode()); + } + ie->set_shift(last_wait_for_key->get_shift()); + ie->set_alt(last_wait_for_key->get_alt()); + ie->set_control(last_wait_for_key->get_control()); + ie->set_metakey(last_wait_for_key->get_metakey()); + + String name = add_at; + int idx = edit_idx; + + Dictionary old_val = ProjectSettings::get_singleton()->get(name); + Dictionary action = old_val.duplicate(); + Array events = action["events"]; + + for (int i = 0; i < events.size(); i++) { + Ref<InputEventKey> aie = events[i]; + if (aie.is_null()) { + continue; + } + if (!press_a_key_physical) { + if (aie->get_keycode_with_modifiers() == ie->get_keycode_with_modifiers()) { + return; + } + } else { + if (aie->get_physical_keycode_with_modifiers() == ie->get_physical_keycode_with_modifiers()) { + return; + } + } + } + + if (idx < 0 || idx >= events.size()) { + events.push_back(ie); + } else { + events[idx] = ie; + } + action["events"] = events; + + undo_redo->create_action(TTR("Add Input Action Event")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", name, action); + undo_redo->add_undo_method(ProjectSettings::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, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + + _show_last_added(ie, name); +} + +void InputMapEditor::_show_last_added(const Ref<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) { + r->set_collapsed(false); + 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 InputMapEditor::_wait_for_key(const Ref<InputEvent> &p_event) { + Ref<InputEventKey> k = p_event; + + if (k.is_valid() && k->is_pressed() && k->get_keycode() != 0) { + last_wait_for_key = p_event; + const String str = (press_a_key_physical) ? keycode_get_string(k->get_physical_keycode_with_modifiers()) + TTR(" (Physical)") : keycode_get_string(k->get_keycode_with_modifiers()); + + press_a_key_label->set_text(str); + press_a_key->get_ok()->set_disabled(false); + press_a_key->set_input_as_handled(); + } +} + +void InputMapEditor::_edit_item(Ref<InputEvent> p_exiting_event) { + InputType ie_type; + + if ((Ref<InputEventKey>(p_exiting_event)).is_valid()) { + if ((Ref<InputEventKey>(p_exiting_event))->get_keycode() != 0) { + ie_type = INPUT_KEY; + } else { + ie_type = INPUT_KEY_PHYSICAL; + } + } else if ((Ref<InputEventJoypadButton>(p_exiting_event)).is_valid()) { + ie_type = INPUT_JOY_BUTTON; + } else if ((Ref<InputEventMouseButton>(p_exiting_event)).is_valid()) { + ie_type = INPUT_MOUSE_BUTTON; + } else if ((Ref<InputEventJoypadMotion>(p_exiting_event)).is_valid()) { + ie_type = INPUT_JOY_MOTION; + } else { + return; + } + + _add_item(ie_type, p_exiting_event); +} + +void InputMapEditor::_add_item(int p_item, Ref<InputEvent> p_exiting_event) { + add_type = InputType(p_item); + + switch (add_type) { + case INPUT_KEY: { + press_a_key_physical = false; + press_a_key_label->set_text(TTR("Press a Key...")); + press_a_key->get_ok()->set_disabled(true); + last_wait_for_key = Ref<InputEvent>(); + press_a_key->popup_centered(Size2(250, 80) * EDSCALE); + //press_a_key->grab_focus(); + + } break; + case INPUT_KEY_PHYSICAL: { + press_a_key_physical = true; + press_a_key_label->set_text(TTR("Press a Key...")); + + last_wait_for_key = Ref<InputEvent>(); + press_a_key->popup_centered(Size2(250, 80) * EDSCALE); + press_a_key->grab_focus(); + + } break; + case INPUT_MOUSE_BUTTON: { + 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("Wheel Left Button")); + device_index->add_item(TTR("Wheel Right Button")); + device_index->add_item(TTR("X Button 1")); + device_index->add_item(TTR("X Button 2")); + device_input->popup_centered(Size2(350, 95) * EDSCALE); + + Ref<InputEventMouseButton> mb = p_exiting_event; + if (mb.is_valid()) { + device_index->select(mb->get_button_index() - 1); + _set_current_device(mb->get_device()); + device_input->get_ok()->set_text(TTR("Change")); + } else { + _set_current_device(0); + device_input->get_ok()->set_text(TTR("Add")); + } + + } break; + case INPUT_JOY_MOTION: { + device_index_label->set_text(TTR("Joypad Axis Index:")); + device_index->clear(); + for (int i = 0; i < JOY_AXIS_MAX * 2; i++) { + String desc = TTR("Axis") + " " + itos(i / 2) + " " + ((i & 1) ? "+" : "-") + + " (" + TTR(_axis_descriptions[i]) + ")"; + device_index->add_item(desc); + } + device_input->popup_centered(Size2(350, 95) * EDSCALE); + + Ref<InputEventJoypadMotion> jm = p_exiting_event; + if (jm.is_valid()) { + device_index->select(jm->get_axis() * 2 + (jm->get_axis_value() > 0 ? 1 : 0)); + _set_current_device(jm->get_device()); + device_input->get_ok()->set_text(TTR("Change")); + } else { + _set_current_device(0); + device_input->get_ok()->set_text(TTR("Add")); + } + + } break; + case INPUT_JOY_BUTTON: { + device_index_label->set_text(TTR("Joypad Button Index:")); + device_index->clear(); + for (int i = 0; i < JOY_BUTTON_MAX; i++) { + String desc = TTR("Button") + " " + itos(i); + if (i < JOY_SDL_BUTTONS) { + desc += " (" + TTR(_button_descriptions[i]) + ")"; + } + device_index->add_item(desc); + } + device_input->popup_centered(Size2(350, 95) * EDSCALE); + + Ref<InputEventJoypadButton> jb = p_exiting_event; + if (jb.is_valid()) { + device_index->select(jb->get_button_index()); + _set_current_device(jb->get_device()); + device_input->get_ok()->set_text(TTR("Change")); + } else { + _set_current_device(0); + device_input->get_ok()->set_text(TTR("Add")); + } + + } break; + default: { + } + } +} + +void InputMapEditor::_action_activated() { + TreeItem *ti = input_editor->get_selected(); + + if (!ti || ti->get_parent() == input_editor->get_root()) { + return; + } + + String name = "input/" + ti->get_parent()->get_text(0); + Dictionary action = ProjectSettings::get_singleton()->get(name); + Array events = action["events"]; + int idx = ti->get_metadata(0); + + ERR_FAIL_INDEX(idx, events.size()); + Ref<InputEvent> event = events[idx]; + if (event.is_null()) { + return; + } + + add_at = name; + edit_idx = idx; + _edit_item(event); +} + +void InputMapEditor::_action_button_pressed(Object *p_obj, int p_column, int p_id) { + TreeItem *ti = Object::cast_to<TreeItem>(p_obj); + + ERR_FAIL_COND(!ti); + + if (p_id == 1) { + // Add action event + Point2 ofs = input_editor->get_global_position(); + Rect2 ir = input_editor->get_item_rect(ti); + ir.position.y -= input_editor->get_scroll().y; + ofs += ir.position + ir.size; + ofs.x -= 100; + popup_add->set_position(ofs); + popup_add->popup(); + add_at = "input/" + ti->get_text(0); + edit_idx = -1; + + } else if (p_id == 2) { + // Remove + + if (ti->get_parent() == input_editor->get_root()) { + // Remove action + String name = "input/" + ti->get_text(0); + Dictionary old_val = ProjectSettings::get_singleton()->get(name); + int order = ProjectSettings::get_singleton()->get_order(name); + + undo_redo->create_action(TTR("Erase Input Action")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "clear", name); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set", name, old_val); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", name, order); + undo_redo->add_do_method(this, "_update_actions"); + undo_redo->add_undo_method(this, "_update_actions"); + undo_redo->add_do_method(this, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + + } else { + // Remove action event + String name = "input/" + ti->get_parent()->get_text(0); + Dictionary old_val = ProjectSettings::get_singleton()->get(name); + Dictionary action = old_val.duplicate(); + int idx = ti->get_metadata(0); + + Array events = action["events"]; + ERR_FAIL_INDEX(idx, events.size()); + events.remove(idx); + action["events"] = events; + + undo_redo->create_action(TTR("Erase Input Action Event")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", name, action); + undo_redo->add_undo_method(ProjectSettings::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, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); + } + } else if (p_id == 3) { + // Edit + + if (ti->get_parent() == input_editor->get_root()) { + // Edit action name + ti->set_as_cursor(0); + input_editor->edit_selected(); + + } else { + // Edit action event + String name = "input/" + ti->get_parent()->get_text(0); + int idx = ti->get_metadata(0); + Dictionary action = ProjectSettings::get_singleton()->get(name); + + Array events = action["events"]; + ERR_FAIL_INDEX(idx, events.size()); + + Ref<InputEvent> event = events[idx]; + + if (event.is_null()) { + return; + } + + ti->set_as_cursor(0); + add_at = name; + edit_idx = idx; + _edit_item(event); + } + } +} + +void InputMapEditor::_update_actions() { + if (setting) { + return; + } + + Map<String, bool> collapsed; + + if (input_editor->get_root() && input_editor->get_root()->get_children()) { + for (TreeItem *item = input_editor->get_root()->get_children(); item; item = item->get_next()) { + collapsed[item->get_text(0)] = item->is_collapsed(); + } + } + + input_editor->clear(); + TreeItem *root = input_editor->create_item(); + input_editor->set_hide_root(true); + + List<PropertyInfo> props; + ProjectSettings::get_singleton()->get_property_list(&props); + for (List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) { + const String property_name = E->get().name; + + if (!property_name.begins_with("input/")) { + continue; + } + + const String name = property_name.get_slice("/", 1); + + TreeItem *item = input_editor->create_item(root); + item->set_text(0, name); + item->set_custom_bg_color(0, input_editor->get_theme_color("prop_subsection", "Editor")); + if (collapsed.has(name)) { + item->set_collapsed(collapsed[name]); + } + + item->set_editable(1, true); + item->set_cell_mode(1, TreeItem::CELL_MODE_RANGE); + item->set_range_config(1, 0.0, 1.0, 0.01); + + item->set_custom_bg_color(1, input_editor->get_theme_color("prop_subsection", "Editor")); + + const bool is_builtin_input = ProjectSettings::get_singleton()->get_input_presets().find(property_name) != nullptr; + const String tooltip_remove = is_builtin_input ? TTR("Built-in actions can't be removed as they're used for UI navigation.") : TTR("Remove"); + item->add_button(2, input_editor->get_theme_icon("Add", "EditorIcons"), 1, false, TTR("Add Event")); + item->add_button(2, input_editor->get_theme_icon("Remove", "EditorIcons"), 2, false, tooltip_remove); + + if (is_builtin_input) { + item->set_button_disabled(2, 1, true); + } else { + item->set_editable(0, true); + } + + Dictionary action = ProjectSettings::get_singleton()->get(property_name); + Array events = action["events"]; + item->set_range(1, action["deadzone"]); + + for (int i = 0; i < events.size(); i++) { + Ref<InputEvent> event = events[i]; + if (event.is_null()) { + continue; + } + + TreeItem *action2 = input_editor->create_item(item); + + Ref<InputEventKey> k = event; + if (k.is_valid()) { + if (k->get_keycode() != 0) { + action2->set_text(0, keycode_get_string(k->get_keycode_with_modifiers())); + action2->set_icon(0, input_editor->get_theme_icon("Keyboard", "EditorIcons")); + } else { + action2->set_text(0, keycode_get_string(k->get_physical_keycode_with_modifiers()) + TTR(" (Physical)")); + action2->set_icon(0, input_editor->get_theme_icon("KeyboardPhysical", "EditorIcons")); + } + } + + Ref<InputEventJoypadButton> jb = event; + if (jb.is_valid()) { + const int idx = jb->get_button_index(); + String str = _get_device_string(jb->get_device()) + ", " + + TTR("Button") + " " + itos(idx); + if (idx >= 0 && idx < JOY_SDL_BUTTONS) { + str += String() + " (" + TTR(_button_descriptions[jb->get_button_index()]) + ")"; + } + + action2->set_text(0, str); + action2->set_icon(0, input_editor->get_theme_icon("JoyButton", "EditorIcons")); + } + + Ref<InputEventMouseButton> mb = event; + if (mb.is_valid()) { + String str = _get_device_string(mb->get_device()) + ", "; + switch (mb->get_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 += vformat(TTR("%d Button"), mb->get_button_index()); + } + + action2->set_text(0, str); + action2->set_icon(0, input_editor->get_theme_icon("Mouse", "EditorIcons")); + } + + Ref<InputEventJoypadMotion> jm = event; + if (jm.is_valid()) { + int ax = jm->get_axis(); + int n = 2 * ax + (jm->get_axis_value() < 0 ? 0 : 1); + String str = _get_device_string(jm->get_device()) + ", " + + TTR("Axis") + " " + itos(ax) + " " + (jm->get_axis_value() < 0 ? "-" : "+") + + " (" + _axis_descriptions[n] + ")"; + action2->set_text(0, str); + action2->set_icon(0, input_editor->get_theme_icon("JoyAxis", "EditorIcons")); + } + action2->set_metadata(0, i); + action2->set_meta("__input", event); + + action2->add_button(2, input_editor->get_theme_icon("Edit", "EditorIcons"), 3, false, TTR("Edit")); + action2->add_button(2, input_editor->get_theme_icon("Remove", "EditorIcons"), 2, false, TTR("Remove")); + // Fade out the individual event buttons slightly to make the + // Add/Remove buttons stand out more. + action2->set_button_color(2, 0, Color(1, 1, 1, 0.75)); + action2->set_button_color(2, 1, Color(1, 1, 1, 0.75)); + } + } + + _action_check(action_name->get_text()); +} + +void InputMapEditor::_action_check(String p_action) { + if (p_action == "") { + action_add->set_disabled(true); + } else { + if (!_validate_action_name(p_action)) { + action_add_error->set_text(TTR("Invalid action name. It cannot be empty nor contain '/', ':', '=', '\\' or '\"'.")); + action_add_error->show(); + action_add->set_disabled(true); + return; + } + if (ProjectSettings::get_singleton()->has_setting("input/" + p_action)) { + action_add_error->set_text(vformat(TTR("An action with the name '%s' already exists."), p_action)); + action_add_error->show(); + action_add->set_disabled(true); + return; + } + + action_add->set_disabled(false); + } + + action_add_error->hide(); +} + +void InputMapEditor::_action_adds(String) { + if (!action_add->is_disabled()) { + _action_add(); + } +} + +void InputMapEditor::_action_add() { + Dictionary action; + action["events"] = Array(); + action["deadzone"] = 0.5f; + String name = "input/" + action_name->get_text(); + undo_redo->create_action(TTR("Add Input Action")); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set", name, action); + undo_redo->add_undo_method(ProjectSettings::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, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_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(); + } + + r->select(0); + input_editor->ensure_cursor_is_visible(); + action_add_error->hide(); + action_name->clear(); +} + +Variant InputMapEditor::get_drag_data_fw(const Point2 &p_point, Control *p_from) { + TreeItem *selected = input_editor->get_selected(); + if (!selected || selected->get_parent() != input_editor->get_root()) { + return Variant(); + } + + String name = selected->get_text(0); + VBoxContainer *vb = memnew(VBoxContainer); + HBoxContainer *hb = memnew(HBoxContainer); + Label *label = memnew(Label(name)); + hb->set_modulate(Color(1, 1, 1, 1.0f)); + hb->add_child(label); + vb->add_child(hb); + input_editor->set_drag_preview(vb); + + Dictionary drag_data; + drag_data["type"] = "nodes"; + + input_editor->set_drop_mode_flags(Tree::DROP_MODE_INBETWEEN); + + return drag_data; +} + +bool InputMapEditor::can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const { + Dictionary d = p_data; + if (!d.has("type") || d["type"] != "nodes") { + return false; + } + + TreeItem *selected = input_editor->get_selected(); + TreeItem *item = input_editor->get_item_at_position(p_point); + if (!selected || !item || item == selected || item->get_parent() == selected) { + return false; + } + + return true; +} + +void InputMapEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) { + if (!can_drop_data_fw(p_point, p_data, p_from)) { + return; + } + + TreeItem *selected = input_editor->get_selected(); + TreeItem *item = input_editor->get_item_at_position(p_point); + if (!item) { + return; + } + TreeItem *target = item->get_parent() == input_editor->get_root() ? item : item->get_parent(); + + String selected_name = "input/" + selected->get_text(0); + int old_order = ProjectSettings::get_singleton()->get_order(selected_name); + String target_name = "input/" + target->get_text(0); + int target_order = ProjectSettings::get_singleton()->get_order(target_name); + + int order = old_order; + bool is_below = target_order > old_order; + TreeItem *iterator = is_below ? selected->get_next() : selected->get_prev(); + + undo_redo->create_action(TTR("Moved Input Action Event")); + while (iterator != target) { + String iterator_name = "input/" + iterator->get_text(0); + int iterator_order = ProjectSettings::get_singleton()->get_order(iterator_name); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", iterator_name, order); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", iterator_name, iterator_order); + order = iterator_order; + iterator = is_below ? iterator->get_next() : iterator->get_prev(); + } + + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", target_name, order); + undo_redo->add_do_method(ProjectSettings::get_singleton(), "set_order", selected_name, target_order); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", target_name, target_order); + undo_redo->add_undo_method(ProjectSettings::get_singleton(), "set_order", selected_name, old_order); + + undo_redo->add_do_method(this, "_update_actions"); + undo_redo->add_undo_method(this, "_update_actions"); + undo_redo->add_do_method(this, "emit_signal", inputmap_changed); + undo_redo->add_undo_method(this, "emit_signal", inputmap_changed); + undo_redo->commit_action(); +} + +void InputMapEditor::_bind_methods() { + ClassDB::bind_method(D_METHOD("_update_actions"), &InputMapEditor::_update_actions); + + ClassDB::bind_method(D_METHOD("get_drag_data_fw"), &InputMapEditor::get_drag_data_fw); + ClassDB::bind_method(D_METHOD("can_drop_data_fw"), &InputMapEditor::can_drop_data_fw); + ClassDB::bind_method(D_METHOD("drop_data_fw"), &InputMapEditor::drop_data_fw); + + ADD_SIGNAL(MethodInfo("inputmap_changed")); +} + +InputMapEditor::InputMapEditor() { + undo_redo = EditorNode::get_undo_redo(); + press_a_key_physical = false; + inputmap_changed = "inputmap_changed"; + + VBoxContainer *vbc = memnew(VBoxContainer); + vbc->set_anchor_and_margin(MARGIN_TOP, Control::ANCHOR_BEGIN, 0); + vbc->set_anchor_and_margin(MARGIN_BOTTOM, Control::ANCHOR_END, 0); + vbc->set_anchor_and_margin(MARGIN_LEFT, Control::ANCHOR_BEGIN, 0); + vbc->set_anchor_and_margin(MARGIN_RIGHT, Control::ANCHOR_END, 0); + add_child(vbc); + + HBoxContainer *hbc = memnew(HBoxContainer); + vbc->add_child(hbc); + + Label *l = memnew(Label); + l->set_text(TTR("Action:")); + hbc->add_child(l); + + action_name = memnew(LineEdit); + action_name->set_h_size_flags(Control::SIZE_EXPAND_FILL); + action_name->connect("text_entered", callable_mp(this, &InputMapEditor::_action_adds)); + action_name->connect("text_changed", callable_mp(this, &InputMapEditor::_action_check)); + hbc->add_child(action_name); + + action_add_error = memnew(Label); + action_add_error->hide(); + hbc->add_child(action_add_error); + + Button *add = memnew(Button); + add->set_text(TTR("Add")); + add->set_disabled(true); + add->connect("pressed", callable_mp(this, &InputMapEditor::_action_add)); + hbc->add_child(add); + action_add = add; + + input_editor = memnew(Tree); + input_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL); + input_editor->set_columns(3); + input_editor->set_column_titles_visible(true); + input_editor->set_column_title(0, TTR("Action")); + input_editor->set_column_title(1, TTR("Deadzone")); + input_editor->set_column_expand(1, false); + input_editor->set_column_min_width(1, 80 * EDSCALE); + input_editor->set_column_expand(2, false); + input_editor->set_column_min_width(2, 50 * EDSCALE); + input_editor->connect("item_edited", callable_mp(this, &InputMapEditor::_action_edited)); + input_editor->connect("item_activated", callable_mp(this, &InputMapEditor::_action_activated)); + input_editor->connect("cell_selected", callable_mp(this, &InputMapEditor::_action_selected)); + input_editor->connect("button_pressed", callable_mp(this, &InputMapEditor::_action_button_pressed)); +#ifndef _MSC_VER +#warning need to make drag data forwarding to non controls happen +#endif + //input_editor->set_drag_forwarding(this); + vbc->add_child(input_editor); + + // Popups + + popup_add = memnew(PopupMenu); + popup_add->connect("id_pressed", callable_mp(this, &InputMapEditor::_add_item), make_binds(Ref<InputEvent>())); + add_child(popup_add); + + press_a_key = memnew(ConfirmationDialog); + press_a_key->get_ok()->set_disabled(true); + //press_a_key->set_focus_mode(Control::FOCUS_ALL); + press_a_key->connect("window_input", callable_mp(this, &InputMapEditor::_wait_for_key)); + press_a_key->connect("confirmed", callable_mp(this, &InputMapEditor::_press_a_key_confirm)); + add_child(press_a_key); + + l = memnew(Label); + l->set_text(TTR("Press a Key...")); + l->set_anchors_and_margins_preset(Control::PRESET_WIDE); + l->set_align(Label::ALIGN_CENTER); + l->set_margin(MARGIN_TOP, 20); + l->set_anchor_and_margin(MARGIN_BOTTOM, Control::ANCHOR_BEGIN, 30); + press_a_key->add_child(l); + press_a_key_label = l; + + device_input = memnew(ConfirmationDialog); + device_input->get_ok()->set_text(TTR("Add")); + device_input->connect("confirmed", callable_mp(this, &InputMapEditor::_device_input_add)); + add_child(device_input); + + hbc = memnew(HBoxContainer); + device_input->add_child(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(OptionButton); + for (int i = -1; i < 8; i++) { + device_id->add_item(_get_device_string(i)); + } + _set_current_device(0); + vbc_left->add_child(device_id); + + VBoxContainer *vbc_right = memnew(VBoxContainer); + vbc_right->set_h_size_flags(Control::SIZE_EXPAND_FILL); + hbc->add_child(vbc_right); + + l = memnew(Label); + l->set_text(TTR("Index:")); + vbc_right->add_child(l); + + device_index_label = l; + device_index = memnew(OptionButton); + device_index->set_clip_text(true); + vbc_right->add_child(device_index); + + message = memnew(AcceptDialog); + add_child(message); +} |