diff options
206 files changed, 8543 insertions, 9163 deletions
diff --git a/core/global_config.cpp b/core/global_config.cpp index 81b923f01e..896384d9c8 100644 --- a/core/global_config.cpp +++ b/core/global_config.cpp @@ -846,10 +846,8 @@ GlobalConfig::GlobalConfig() { registering_order = true; Array va; - InputEvent key; - key.type = InputEvent::KEY; - InputEvent joyb; - joyb.type = InputEvent::JOYPAD_BUTTON; + Ref<InputEventKey> key; + Ref<InputEventJoypadButton> joyb; GLOBAL_DEF("application/name", ""); GLOBAL_DEF("application/main_scene", ""); @@ -858,87 +856,106 @@ GlobalConfig::GlobalConfig() { GLOBAL_DEF("application/disable_stderr", false); GLOBAL_DEF("application/use_shared_user_dir", true); - key.key.scancode = KEY_RETURN; + key.instance(); + key->set_scancode(KEY_RETURN); va.push_back(key); - key.key.scancode = KEY_ENTER; + key.instance(); + key->set_scancode(KEY_ENTER); va.push_back(key); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_0; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_0); va.push_back(joyb); GLOBAL_DEF("input/ui_accept", va); input_presets.push_back("input/ui_accept"); va = Array(); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_3; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_3); va.push_back(joyb); GLOBAL_DEF("input/ui_select", va); input_presets.push_back("input/ui_select"); va = Array(); - key.key.scancode = KEY_ESCAPE; + key.instance(); + key->set_scancode(KEY_ESCAPE); va.push_back(key); - joyb.joy_button.button_index = JOY_BUTTON_1; + joyb.instance(); + joyb->set_button_index(JOY_BUTTON_1); va.push_back(joyb); GLOBAL_DEF("input/ui_cancel", va); input_presets.push_back("input/ui_cancel"); va = Array(); - key.key.scancode = KEY_TAB; + key.instance(); + key->set_scancode(KEY_TAB); va.push_back(key); GLOBAL_DEF("input/ui_focus_next", va); input_presets.push_back("input/ui_focus_next"); va = Array(); - key.key.scancode = KEY_TAB; - key.key.mod.shift = true; + key.instance(); + key->set_scancode(KEY_TAB); + key->set_shift(true); va.push_back(key); GLOBAL_DEF("input/ui_focus_prev", va); input_presets.push_back("input/ui_focus_prev"); - key.key.mod.shift = false; va = Array(); - key.key.scancode = KEY_LEFT; + key.instance(); + key->set_scancode(KEY_LEFT); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_LEFT; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_LEFT); va.push_back(joyb); GLOBAL_DEF("input/ui_left", va); input_presets.push_back("input/ui_left"); va = Array(); - key.key.scancode = KEY_RIGHT; + key.instance(); + key->set_scancode(KEY_RIGHT); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_RIGHT; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_RIGHT); va.push_back(joyb); GLOBAL_DEF("input/ui_right", va); input_presets.push_back("input/ui_right"); va = Array(); - key.key.scancode = KEY_UP; + key.instance(); + key->set_scancode(KEY_UP); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_UP; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_UP); va.push_back(joyb); GLOBAL_DEF("input/ui_up", va); input_presets.push_back("input/ui_up"); va = Array(); - key.key.scancode = KEY_DOWN; + key.instance(); + key->set_scancode(KEY_DOWN); va.push_back(key); - joyb.joy_button.button_index = JOY_DPAD_DOWN; + joyb.instance(); + joyb->set_button_index(JOY_DPAD_DOWN); va.push_back(joyb); GLOBAL_DEF("input/ui_down", va); input_presets.push_back("input/ui_down"); va = Array(); - key.key.scancode = KEY_PAGEUP; + key.instance(); + key->set_scancode(KEY_PAGEUP); va.push_back(key); GLOBAL_DEF("input/ui_page_up", va); input_presets.push_back("input/ui_page_up"); va = Array(); - key.key.scancode = KEY_PAGEDOWN; + key.instance(); + key->set_scancode(KEY_PAGEDOWN); va.push_back(key); GLOBAL_DEF("input/ui_page_down", va); input_presets.push_back("input/ui_page_down"); diff --git a/core/global_constants.cpp b/core/global_constants.cpp index 18f34b5d37..4f535fb05e 100644 --- a/core/global_constants.cpp +++ b/core/global_constants.cpp @@ -30,6 +30,7 @@ #include "global_constants.h" #include "object.h" +#include "os/input_event.h" #include "os/keyboard.h" #include "variant.h" @@ -513,9 +514,8 @@ static _GlobalConstant _global_constants[] = { { "TYPE_NODE_PATH", Variant::NODE_PATH }, // 15 { "TYPE_RID", Variant::_RID }, { "TYPE_OBJECT", Variant::OBJECT }, - { "TYPE_INPUT_EVENT", Variant::INPUT_EVENT }, - { "TYPE_DICTIONARY", Variant::DICTIONARY }, - { "TYPE_ARRAY", Variant::ARRAY }, // 20 + { "TYPE_DICTIONARY", Variant::DICTIONARY }, // 20 + { "TYPE_ARRAY", Variant::ARRAY }, { "TYPE_RAW_ARRAY", Variant::POOL_BYTE_ARRAY }, { "TYPE_INT_ARRAY", Variant::POOL_INT_ARRAY }, { "TYPE_REAL_ARRAY", Variant::POOL_REAL_ARRAY }, diff --git a/core/input_map.cpp b/core/input_map.cpp index 9f9eba01c7..1307c467e6 100644 --- a/core/input_map.cpp +++ b/core/input_map.cpp @@ -37,8 +37,6 @@ InputMap *InputMap::singleton = NULL; void InputMap::_bind_methods() { ClassDB::bind_method(D_METHOD("has_action", "action"), &InputMap::has_action); - ClassDB::bind_method(D_METHOD("get_action_id", "action"), &InputMap::get_action_id); - ClassDB::bind_method(D_METHOD("get_action_from_id", "id"), &InputMap::get_action_from_id); ClassDB::bind_method(D_METHOD("get_actions"), &InputMap::_get_actions); ClassDB::bind_method(D_METHOD("add_action", "action"), &InputMap::add_action); ClassDB::bind_method(D_METHOD("erase_action", "action"), &InputMap::erase_action); @@ -57,23 +55,15 @@ void InputMap::add_action(const StringName &p_action) { input_map[p_action] = Action(); static int last_id = 1; input_map[p_action].id = last_id; - input_id_map[last_id] = p_action; last_id++; } void InputMap::erase_action(const StringName &p_action) { ERR_FAIL_COND(!input_map.has(p_action)); - input_id_map.erase(input_map[p_action].id); input_map.erase(p_action); } -StringName InputMap::get_action_from_id(int p_id) const { - - ERR_FAIL_COND_V(!input_id_map.has(p_id), StringName()); - return input_id_map[p_id]; -} - Array InputMap::_get_actions() { Array ret; @@ -103,49 +93,18 @@ List<StringName> InputMap::get_actions() const { return actions; } -List<InputEvent>::Element *InputMap::_find_event(List<InputEvent> &p_list, const InputEvent &p_event, bool p_action_test) const { - - for (List<InputEvent>::Element *E = p_list.front(); E; E = E->next()) { - - const InputEvent &e = E->get(); - if (e.type != p_event.type) - continue; - if (e.type != InputEvent::KEY && e.device != p_event.device) - continue; - - bool same = false; - - switch (p_event.type) { - - case InputEvent::KEY: { - - if (p_action_test) { - uint32_t code = e.key.get_scancode_with_modifiers(); - uint32_t event_code = p_event.key.get_scancode_with_modifiers(); - same = (e.key.scancode == p_event.key.scancode && (!p_event.key.pressed || ((code & event_code) == code))); - } else { - same = (e.key.scancode == p_event.key.scancode && e.key.mod == p_event.key.mod); - } - - } break; - case InputEvent::JOYPAD_BUTTON: { +List<Ref<InputEvent> >::Element *InputMap::_find_event(List<Ref<InputEvent> > &p_list, const Ref<InputEvent> &p_event, bool p_action_test) const { - same = (e.joy_button.button_index == p_event.joy_button.button_index); + for (List<Ref<InputEvent> >::Element *E = p_list.front(); E; E = E->next()) { - } break; - case InputEvent::MOUSE_BUTTON: { + const Ref<InputEvent> e = E->get(); - same = (e.mouse_button.button_index == p_event.mouse_button.button_index); + //if (e.type != Ref<InputEvent>::KEY && e.device != p_event.device) -- unsure about the KEY comparison, why is this here? + // continue; - } break; - case InputEvent::JOYPAD_MOTION: { - - same = (e.joy_motion.axis == p_event.joy_motion.axis && (e.joy_motion.axis_value < 0) == (p_event.joy_motion.axis_value < 0)); - - } break; - } - - if (same) + if (e->get_device() != p_event->get_device()) + continue; + if (e->action_match(p_event)) return E; } @@ -157,9 +116,9 @@ bool InputMap::has_action(const StringName &p_action) const { return input_map.has(p_action); } -void InputMap::action_add_event(const StringName &p_action, const InputEvent &p_event) { +void InputMap::action_add_event(const StringName &p_action, const Ref<InputEvent> &p_event) { - ERR_FAIL_COND(p_event.type == InputEvent::ACTION); + ERR_FAIL_COND(p_event.is_null()); ERR_FAIL_COND(!input_map.has(p_action)); if (_find_event(input_map[p_action].inputs, p_event)) return; //already gots @@ -167,23 +126,17 @@ void InputMap::action_add_event(const StringName &p_action, const InputEvent &p_ input_map[p_action].inputs.push_back(p_event); } -int InputMap::get_action_id(const StringName &p_action) const { - - ERR_FAIL_COND_V(!input_map.has(p_action), -1); - return input_map[p_action].id; -} - -bool InputMap::action_has_event(const StringName &p_action, const InputEvent &p_event) { +bool InputMap::action_has_event(const StringName &p_action, const Ref<InputEvent> &p_event) { ERR_FAIL_COND_V(!input_map.has(p_action), false); return (_find_event(input_map[p_action].inputs, p_event) != NULL); } -void InputMap::action_erase_event(const StringName &p_action, const InputEvent &p_event) { +void InputMap::action_erase_event(const StringName &p_action, const Ref<InputEvent> &p_event) { ERR_FAIL_COND(!input_map.has(p_action)); - List<InputEvent>::Element *E = _find_event(input_map[p_action].inputs, p_event); + List<Ref<InputEvent> >::Element *E = _find_event(input_map[p_action].inputs, p_event); if (E) input_map[p_action].inputs.erase(E); } @@ -191,9 +144,9 @@ void InputMap::action_erase_event(const StringName &p_action, const InputEvent & Array InputMap::_get_action_list(const StringName &p_action) { Array ret; - const List<InputEvent> *al = get_action_list(p_action); + const List<Ref<InputEvent> > *al = get_action_list(p_action); if (al) { - for (const List<InputEvent>::Element *E = al->front(); E; E = E->next()) { + for (const List<Ref<InputEvent> >::Element *E = al->front(); E; E = E->next()) { ret.push_back(E->get()); } @@ -202,7 +155,7 @@ Array InputMap::_get_action_list(const StringName &p_action) { return ret; } -const List<InputEvent> *InputMap::get_action_list(const StringName &p_action) { +const List<Ref<InputEvent> > *InputMap::get_action_list(const StringName &p_action) { const Map<StringName, Action>::Element *E = input_map.find(p_action); if (!E) @@ -211,7 +164,7 @@ const List<InputEvent> *InputMap::get_action_list(const StringName &p_action) { return &E->get().inputs; } -bool InputMap::event_is_action(const InputEvent &p_event, const StringName &p_action) const { +bool InputMap::event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action) const { Map<StringName, Action>::Element *E = input_map.find(p_action); if (!E) { @@ -219,9 +172,9 @@ bool InputMap::event_is_action(const InputEvent &p_event, const StringName &p_ac ERR_FAIL_COND_V(!E, false); } - if (p_event.type == InputEvent::ACTION) { - - return p_event.action.action == E->get().id; + Ref<InputEventAction> iea = p_event; + if (iea.is_valid()) { + return iea->get_action() == p_action; } return _find_event(E->get().inputs, p_event, true) != NULL; @@ -252,8 +205,8 @@ void InputMap::load_from_globals() { for (int i = 0; i < va.size(); i++) { - InputEvent ie = va[i]; - if (ie.type == InputEvent::NONE) + Ref<InputEvent> ie = va[i]; + if (ie.is_null()) continue; action_add_event(name, ie); } @@ -262,57 +215,70 @@ void InputMap::load_from_globals() { void InputMap::load_default() { - InputEvent key; - key.type = InputEvent::KEY; + Ref<InputEventKey> key; add_action("ui_accept"); - key.key.scancode = KEY_RETURN; + key.instance(); + key->set_scancode(KEY_RETURN); action_add_event("ui_accept", key); - key.key.scancode = KEY_ENTER; + + key.instance(); + key->set_scancode(KEY_ENTER); action_add_event("ui_accept", key); - key.key.scancode = KEY_SPACE; + + key.instance(); + key->set_scancode(KEY_SPACE); action_add_event("ui_accept", key); add_action("ui_select"); - key.key.scancode = KEY_SPACE; + key.instance(); + key->set_scancode(KEY_SPACE); action_add_event("ui_select", key); add_action("ui_cancel"); - key.key.scancode = KEY_ESCAPE; + key.instance(); + key->set_scancode(KEY_ESCAPE); action_add_event("ui_cancel", key); add_action("ui_focus_next"); - key.key.scancode = KEY_TAB; + key.instance(); + key->set_scancode(KEY_TAB); action_add_event("ui_focus_next", key); add_action("ui_focus_prev"); - key.key.scancode = KEY_TAB; - key.key.mod.shift = true; + key.instance(); + key->set_scancode(KEY_TAB); + key->set_shift(true); action_add_event("ui_focus_prev", key); - key.key.mod.shift = false; add_action("ui_left"); - key.key.scancode = KEY_LEFT; + key.instance(); + key->set_scancode(KEY_LEFT); action_add_event("ui_left", key); add_action("ui_right"); - key.key.scancode = KEY_RIGHT; + key.instance(); + key->set_scancode(KEY_RIGHT); action_add_event("ui_right", key); add_action("ui_up"); - key.key.scancode = KEY_UP; + key.instance(); + key->set_scancode(KEY_UP); action_add_event("ui_up", key); add_action("ui_down"); - key.key.scancode = KEY_DOWN; + key.instance(); + key->set_scancode(KEY_DOWN); action_add_event("ui_down", key); add_action("ui_page_up"); - key.key.scancode = KEY_PAGEUP; + key.instance(); + key->set_scancode(KEY_PAGEUP); action_add_event("ui_page_up", key); add_action("ui_page_down"); - key.key.scancode = KEY_PAGEDOWN; + key.instance(); + key->set_scancode(KEY_PAGEDOWN); action_add_event("ui_page_down", key); //set("display/handheld/orientation", "landscape"); diff --git a/core/input_map.h b/core/input_map.h index a25255da2d..ba93e61f5f 100644 --- a/core/input_map.h +++ b/core/input_map.h @@ -31,6 +31,7 @@ #define INPUT_MAP_H #include "object.h" +#include "os/input_event.h" class InputMap : public Object { @@ -39,16 +40,15 @@ class InputMap : public Object { public: struct Action { int id; - List<InputEvent> inputs; + List<Ref<InputEvent> > inputs; }; private: static InputMap *singleton; mutable Map<StringName, Action> input_map; - mutable Map<int, StringName> input_id_map; - List<InputEvent>::Element *_find_event(List<InputEvent> &p_list, const InputEvent &p_event, bool p_action_test = false) const; + List<Ref<InputEvent> >::Element *_find_event(List<Ref<InputEvent> > &p_list, const Ref<InputEvent> &p_event, bool p_action_test = false) const; Array _get_action_list(const StringName &p_action); Array _get_actions(); @@ -60,18 +60,16 @@ public: static _FORCE_INLINE_ InputMap *get_singleton() { return singleton; } bool has_action(const StringName &p_action) const; - int get_action_id(const StringName &p_action) const; - StringName get_action_from_id(int p_id) const; List<StringName> get_actions() const; void add_action(const StringName &p_action); void erase_action(const StringName &p_action); - void action_add_event(const StringName &p_action, const InputEvent &p_event); - bool action_has_event(const StringName &p_action, const InputEvent &p_event); - void action_erase_event(const StringName &p_action, const InputEvent &p_event); + void action_add_event(const StringName &p_action, const Ref<InputEvent> &p_event); + bool action_has_event(const StringName &p_action, const Ref<InputEvent> &p_event); + void action_erase_event(const StringName &p_action, const Ref<InputEvent> &p_event); - const List<InputEvent> *get_action_list(const StringName &p_action); - bool event_is_action(const InputEvent &p_event, const StringName &p_action) const; + const List<Ref<InputEvent> > *get_action_list(const StringName &p_action); + bool event_is_action(const Ref<InputEvent> &p_event, const StringName &p_action) const; const Map<StringName, Action> &get_action_map() const; void load_from_globals(); diff --git a/core/io/marshalls.cpp b/core/io/marshalls.cpp index fd14011a81..dccf70ad7a 100644 --- a/core/io/marshalls.cpp +++ b/core/io/marshalls.cpp @@ -365,66 +365,6 @@ Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int r_variant = (Object *)NULL; } break; - case Variant::INPUT_EVENT: { - - InputEvent ie; - - ie.type = decode_uint32(&buf[0]); - ie.device = decode_uint32(&buf[4]); - - if (r_len) - (*r_len) += 12; - - switch (ie.type) { - - case InputEvent::KEY: { - - uint32_t mods = decode_uint32(&buf[12]); - if (mods & KEY_MASK_SHIFT) - ie.key.mod.shift = true; - if (mods & KEY_MASK_CTRL) - ie.key.mod.control = true; - if (mods & KEY_MASK_ALT) - ie.key.mod.alt = true; - if (mods & KEY_MASK_META) - ie.key.mod.meta = true; - ie.key.scancode = decode_uint32(&buf[16]); - - if (r_len) - (*r_len) += 8; - - } break; - case InputEvent::MOUSE_BUTTON: { - - ie.mouse_button.button_index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - - } break; - case InputEvent::JOYPAD_BUTTON: { - - ie.joy_button.button_index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - } break; - case InputEvent::SCREEN_TOUCH: { - - ie.screen_touch.index = decode_uint32(&buf[12]); - if (r_len) - (*r_len) += 4; - } break; - case InputEvent::JOYPAD_MOTION: { - - ie.joy_motion.axis = decode_uint32(&buf[12]); - ie.joy_motion.axis_value = decode_float(&buf[16]); - if (r_len) - (*r_len) += 8; - } break; - } - - r_variant = ie; - - } break; case Variant::DICTIONARY: { ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA); @@ -1055,83 +995,6 @@ Error encode_variant(const Variant &p_variant, uint8_t *r_buffer, int &r_len) { case Variant::OBJECT: { } break; - case Variant::INPUT_EVENT: { - - InputEvent ie = p_variant; - - if (buf) { - - encode_uint32(ie.type, &buf[0]); - encode_uint32(ie.device, &buf[4]); - encode_uint32(0, &buf[8]); - } - - int llen = 12; - - switch (ie.type) { - - case InputEvent::KEY: { - - if (buf) { - - uint32_t mods = 0; - if (ie.key.mod.shift) - mods |= KEY_MASK_SHIFT; - if (ie.key.mod.control) - mods |= KEY_MASK_CTRL; - if (ie.key.mod.alt) - mods |= KEY_MASK_ALT; - if (ie.key.mod.meta) - mods |= KEY_MASK_META; - - encode_uint32(mods, &buf[llen]); - encode_uint32(ie.key.scancode, &buf[llen + 4]); - } - llen += 8; - - } break; - case InputEvent::MOUSE_BUTTON: { - - if (buf) { - - encode_uint32(ie.mouse_button.button_index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::JOYPAD_BUTTON: { - - if (buf) { - - encode_uint32(ie.joy_button.button_index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::SCREEN_TOUCH: { - - if (buf) { - - encode_uint32(ie.screen_touch.index, &buf[llen]); - } - llen += 4; - } break; - case InputEvent::JOYPAD_MOTION: { - - if (buf) { - - int axis = ie.joy_motion.axis; - encode_uint32(axis, &buf[llen]); - encode_float(ie.joy_motion.axis_value, &buf[llen + 4]); - } - llen += 8; - } break; - } - - if (buf) - encode_uint32(llen, &buf[8]); - r_len += llen; - - // not supported - } break; case Variant::DICTIONARY: { Dictionary d = p_variant; diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp index 4ad3d261b2..26b53c2a31 100644 --- a/core/io/resource_format_binary.cpp +++ b/core/io/resource_format_binary.cpp @@ -359,13 +359,6 @@ Error ResourceInteractiveLoaderBinary::parse_variant(Variant &r_v) { } } break; - case VARIANT_INPUT_EVENT: { - - InputEvent ev; - ev.type = f->get_32(); //will only work for null though. - r_v = ev; - - } break; case VARIANT_DICTIONARY: { uint32_t len = f->get_32(); @@ -1446,13 +1439,6 @@ void ResourceFormatSaverBinaryInstance::write_variant(const Variant &p_property, } } break; - case Variant::INPUT_EVENT: { - - f->store_32(VARIANT_INPUT_EVENT); - InputEvent event = p_property; - f->store_32(0); //event type none, nothing else suported for now. - - } break; case Variant::DICTIONARY: { f->store_32(VARIANT_DICTIONARY); diff --git a/core/method_bind.h b/core/method_bind.h index 5b8a458736..8d72c8573a 100644 --- a/core/method_bind.h +++ b/core/method_bind.h @@ -154,7 +154,6 @@ VARIANT_ENUM_CAST(Orientation); VARIANT_ENUM_CAST(HAlign); VARIANT_ENUM_CAST(Variant::Type); VARIANT_ENUM_CAST(Variant::Operator); -VARIANT_ENUM_CAST(InputEvent::Type); class MethodBind { diff --git a/core/method_ptrcall.h b/core/method_ptrcall.h index d3f6143638..bcbf2e4531 100644 --- a/core/method_ptrcall.h +++ b/core/method_ptrcall.h @@ -105,7 +105,6 @@ MAKE_PTRARG(Transform); MAKE_PTRARG(Color); MAKE_PTRARG(NodePath); MAKE_PTRARG(RID); -MAKE_PTRARG(InputEvent); MAKE_PTRARG(Dictionary); MAKE_PTRARG(Array); MAKE_PTRARG(PoolByteArray); diff --git a/core/os/input.h b/core/os/input.h index 4f26f097c2..6759c624e3 100644 --- a/core/os/input.h +++ b/core/os/input.h @@ -82,7 +82,7 @@ public: virtual int get_mouse_button_mask() const = 0; virtual void warp_mouse_pos(const Vector2 &p_to) = 0; - virtual Point2i warp_mouse_motion(const InputEventMouseMotion &p_motion, const Rect2 &p_rect) = 0; + virtual Point2i warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) = 0; virtual Vector3 get_gravity() const = 0; virtual Vector3 get_accelerometer() const = 0; @@ -104,7 +104,7 @@ public: virtual int get_joy_button_index_from_string(String p_button) = 0; virtual int get_joy_axis_index_from_string(String p_axis) = 0; - virtual void parse_input_event(const InputEvent &p_event) = 0; + virtual void parse_input_event(const Ref<InputEvent> &p_event) = 0; Input(); }; diff --git a/core/os/input_event.cpp b/core/os/input_event.cpp index 474bc33b41..2538e8dad2 100644 --- a/core/os/input_event.cpp +++ b/core/os/input_event.cpp @@ -34,275 +34,794 @@ * */ -bool InputEvent::operator==(const InputEvent &p_event) const { - if (type != p_event.type) { - return false; - } +void InputEvent::set_id(uint32_t p_id) { + id = p_id; +} - switch (type) { - /** Current clang-format style doesn't play well with the aligned return values of that switch. */ - /* clang-format off */ - case NONE: - return true; - case KEY: - return key.unicode == p_event.key.unicode - && key.scancode == p_event.key.scancode - && key.echo == p_event.key.echo - && key.pressed == p_event.key.pressed - && key.mod == p_event.key.mod; - case MOUSE_MOTION: - return mouse_motion.x == p_event.mouse_motion.x - && mouse_motion.y == p_event.mouse_motion.y - && mouse_motion.relative_x == p_event.mouse_motion.relative_x - && mouse_motion.relative_y == p_event.mouse_motion.relative_y - && mouse_motion.button_mask == p_event.mouse_motion.button_mask - && key.mod == p_event.key.mod; - case MOUSE_BUTTON: - return mouse_button.pressed == p_event.mouse_button.pressed - && mouse_button.x == p_event.mouse_button.x - && mouse_button.y == p_event.mouse_button.y - && mouse_button.button_index == p_event.mouse_button.button_index - && mouse_button.button_mask == p_event.mouse_button.button_mask - && key.mod == p_event.key.mod; - case JOYPAD_MOTION: - return joy_motion.axis == p_event.joy_motion.axis - && joy_motion.axis_value == p_event.joy_motion.axis_value; - case JOYPAD_BUTTON: - return joy_button.pressed == p_event.joy_button.pressed - && joy_button.button_index == p_event.joy_button.button_index - && joy_button.pressure == p_event.joy_button.pressure; - case SCREEN_TOUCH: - return screen_touch.pressed == p_event.screen_touch.pressed - && screen_touch.index == p_event.screen_touch.index - && screen_touch.x == p_event.screen_touch.x - && screen_touch.y == p_event.screen_touch.y; - case SCREEN_DRAG: - return screen_drag.index == p_event.screen_drag.index - && screen_drag.x == p_event.screen_drag.x - && screen_drag.y == p_event.screen_drag.y; - case ACTION: - return action.action == p_event.action.action - && action.pressed == p_event.action.pressed; - /* clang-format on */ - default: - ERR_PRINT("No logic to compare InputEvents of this type, this shouldn't happen."); - } +uint32_t InputEvent::get_id() const { + return id; +} - return false; +void InputEvent::set_device(int p_device) { + device = p_device; } -InputEvent::operator String() const { - - String str = "Device " + itos(device) + " ID " + itos(ID) + " "; - - switch (type) { - - case NONE: { - - return "Event: None"; - } break; - case KEY: { - - str += "Event: Key "; - str = str + "Unicode: " + String::chr(key.unicode) + " Scan: " + itos(key.scancode) + " Echo: " + String(key.echo ? "True" : "False") + " Pressed" + String(key.pressed ? "True" : "False") + " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_MOTION: { - - str += "Event: Motion "; - str = str + " Pos: " + itos(mouse_motion.x) + "," + itos(mouse_motion.y) + " Rel: " + itos(mouse_motion.relative_x) + "," + itos(mouse_motion.relative_y) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_motion.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - return str; - } break; - case MOUSE_BUTTON: { - str += "Event: Button "; - str = str + "Pressed: " + itos(mouse_button.pressed) + " Pos: " + itos(mouse_button.x) + "," + itos(mouse_button.y) + " Button: " + itos(mouse_button.button_index) + " Mask: "; - for (int i = 0; i < 8; i++) { - - if ((1 << i) & mouse_button.button_mask) - str += itos(i + 1); - } - str += " Mod: "; - if (key.mod.shift) - str += "S"; - if (key.mod.control) - str += "C"; - if (key.mod.alt) - str += "A"; - if (key.mod.meta) - str += "M"; - - str += String(" DoubleClick: ") + (mouse_button.doubleclick ? "Yes" : "No"); - - return str; - - } break; - case JOYPAD_MOTION: { - str += "Event: JoypadMotion "; - str = str + "Axis: " + itos(joy_motion.axis) + " Value: " + rtos(joy_motion.axis_value); - return str; - - } break; - case JOYPAD_BUTTON: { - str += "Event: JoypadButton "; - str = str + "Pressed: " + itos(joy_button.pressed) + " Index: " + itos(joy_button.button_index) + " pressure " + rtos(joy_button.pressure); - return str; - - } break; - case SCREEN_TOUCH: { - str += "Event: ScreenTouch "; - str = str + "Pressed: " + itos(screen_touch.pressed) + " Index: " + itos(screen_touch.index) + " pos " + rtos(screen_touch.x) + "," + rtos(screen_touch.y); - return str; - - } break; - case SCREEN_DRAG: { - str += "Event: ScreenDrag "; - str = str + " Index: " + itos(screen_drag.index) + " pos " + rtos(screen_drag.x) + "," + rtos(screen_drag.y); - return str; - - } break; - case ACTION: { - str += "Event: Action: " + InputMap::get_singleton()->get_action_from_id(action.action) + " Pressed: " + itos(action.pressed); - return str; - - } break; - } - return ""; +int InputEvent::get_device() const { + return device; } -void InputEvent::set_as_action(const String &p_action, bool p_pressed) { +bool InputEvent::is_pressed() const { - type = ACTION; - action.action = InputMap::get_singleton()->get_action_id(p_action); - action.pressed = p_pressed; + return false; } -bool InputEvent::is_pressed() const { +bool InputEvent::is_action(const StringName &p_action) const { - switch (type) { + return InputMap::get_singleton()->event_is_action(Ref<InputEvent>(this), p_action); +} - case KEY: return key.pressed; - case MOUSE_BUTTON: return mouse_button.pressed; - case JOYPAD_BUTTON: return joy_button.pressed; - case SCREEN_TOUCH: return screen_touch.pressed; - case JOYPAD_MOTION: return ABS(joy_motion.axis_value) > 0.5; - case ACTION: return action.pressed; - default: {} - } +bool InputEvent::is_action_pressed(const StringName &p_action) const { + + return false; // InputMap::get_singleton()->event_is_action(Ref<InputEvent>(this),p_action); +} +bool InputEvent::is_action_released(const StringName &p_action) const { return false; } bool InputEvent::is_echo() const { - return (type == KEY && key.echo); + return false; +} + +Ref<InputEvent> InputEvent::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + return Ref<InputEvent>((InputEvent *)this); +} + +String InputEvent::as_text() const { + + return String(); +} + +bool InputEvent::action_match(const Ref<InputEvent> &p_event) const { + + return false; +} + +bool InputEvent::is_action_type() const { + + return false; +} + +#if 0 +if (String(p_method) == "is_action" && p_argidx == 0) { + + List<PropertyInfo> pinfo; + GlobalConfig::get_singleton()->get_property_list(&pinfo); + + for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { + const PropertyInfo &pi = E->get(); + + if (!pi.name.begins_with("input/")) + continue; + + String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); + result.insert("\"" + name + "\""); + } + +} else +#endif + +void InputEvent::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_id", "id"), &InputEvent::set_id); + ClassDB::bind_method(D_METHOD("get_id"), &InputEvent::get_id); + + ClassDB::bind_method(D_METHOD("set_device", "device"), &InputEvent::set_device); + ClassDB::bind_method(D_METHOD("get_device"), &InputEvent::get_device); + + ClassDB::bind_method(D_METHOD("is_pressed"), &InputEvent::is_pressed); + ClassDB::bind_method(D_METHOD("is_action", "action"), &InputEvent::is_action); + ClassDB::bind_method(D_METHOD("is_action_pressed", "action"), &InputEvent::is_action_pressed); + ClassDB::bind_method(D_METHOD("is_action_released", "action"), &InputEvent::is_action_released); + ClassDB::bind_method(D_METHOD("is_echo"), &InputEvent::is_echo); + + ClassDB::bind_method(D_METHOD("as_text"), &InputEvent::as_text); + + ClassDB::bind_method(D_METHOD("action_match", "event:InputEvent"), &InputEvent::action_match); + + ClassDB::bind_method(D_METHOD("is_action_type"), &InputEvent::is_action_type); + + ClassDB::bind_method(D_METHOD("xformed_by:InputEvent", "xform", "local_ofs"), &InputEvent::xformed_by, DEFVAL(Vector2())); +} + +InputEvent::InputEvent() { + + id = 0; + device = 0; +} + +////////////////// + +void InputEventWithModifiers::set_shift(bool p_enabled) { + + shift = p_enabled; +} + +bool InputEventWithModifiers::get_shift() const { + + return shift; +} + +void InputEventWithModifiers::set_alt(bool p_enabled) { + + alt = p_enabled; +} +bool InputEventWithModifiers::get_alt() const { + + return alt; +} + +void InputEventWithModifiers::set_control(bool p_enabled) { + + control = p_enabled; +} +bool InputEventWithModifiers::get_control() const { + + return control; +} + +void InputEventWithModifiers::set_metakey(bool p_enabled) { + + meta = p_enabled; +} +bool InputEventWithModifiers::get_metakey() const { + + return meta; +} + +void InputEventWithModifiers::set_command(bool p_enabled) { + + command = p_enabled; +} +bool InputEventWithModifiers::get_command() const { + + return command; +} + +void InputEventWithModifiers::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_alt", "enable"), &InputEventWithModifiers::set_alt); + ClassDB::bind_method(D_METHOD("get_alt"), &InputEventWithModifiers::get_alt); + + ClassDB::bind_method(D_METHOD("set_shift", "enable"), &InputEventWithModifiers::set_shift); + ClassDB::bind_method(D_METHOD("get_shift"), &InputEventWithModifiers::get_shift); + + ClassDB::bind_method(D_METHOD("set_control", "enable"), &InputEventWithModifiers::set_control); + ClassDB::bind_method(D_METHOD("get_control"), &InputEventWithModifiers::get_control); + + ClassDB::bind_method(D_METHOD("set_metakey", "enable"), &InputEventWithModifiers::set_metakey); + ClassDB::bind_method(D_METHOD("get_metakey"), &InputEventWithModifiers::get_metakey); + + ClassDB::bind_method(D_METHOD("set_command", "enable"), &InputEventWithModifiers::set_command); + ClassDB::bind_method(D_METHOD("get_command"), &InputEventWithModifiers::get_command); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "alt"), "set_alt", "get_alt"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "shift"), "set_shift", "get_shift"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "control"), "set_control", "get_control"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "meta"), "set_metakey", "get_metakey"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "command"), "set_command", "get_command"); +} + +InputEventWithModifiers::InputEventWithModifiers() { + + alt = false; + shift = false; + control = false; + meta = false; +} + +////////////////////////////////// + +void InputEventKey::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} + +bool InputEventKey::is_pressed() { + + return pressed; } -bool InputEvent::is_action(const String &p_action) const { +void InputEventKey::set_scancode(uint32_t p_scancode) { + + scancode = p_scancode; +} +uint32_t InputEventKey::get_scancode() const { - return InputMap::get_singleton()->event_is_action(*this, p_action); + return scancode; } -bool InputEvent::is_action_pressed(const String &p_action) const { +void InputEventKey::set_unicode(uint32_t p_unicode) { - return is_action(p_action) && is_pressed() && !is_echo(); + unicode = p_unicode; } +uint32_t InputEventKey::get_unicode() const { -bool InputEvent::is_action_released(const String &p_action) const { + return unicode; +} + +void InputEventKey::set_echo(bool p_enable) { + + echo = p_enable; +} +bool InputEventKey::is_echo() const { - return is_action(p_action) && !is_pressed(); + return echo; } uint32_t InputEventKey::get_scancode_with_modifiers() const { uint32_t sc = scancode; - if (mod.control) + if (get_control()) sc |= KEY_MASK_CTRL; - if (mod.alt) + if (get_alt()) sc |= KEY_MASK_ALT; - if (mod.shift) + if (get_shift()) sc |= KEY_MASK_SHIFT; - if (mod.meta) + if (get_metakey()) sc |= KEY_MASK_META; return sc; } -InputEvent InputEvent::xform_by(const Transform2D &p_xform) const { - - InputEvent ev = *this; - - switch (ev.type) { - - case InputEvent::MOUSE_BUTTON: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_button.x, ev.mouse_button.y)); - ev.mouse_button.x = l.x; - ev.mouse_button.y = l.y; - ev.mouse_button.global_x = g.x; - ev.mouse_button.global_y = g.y; - - } break; - case InputEvent::MOUSE_MOTION: { - - Vector2 g = p_xform.xform(Vector2(ev.mouse_motion.global_x, ev.mouse_motion.global_y)); - Vector2 l = p_xform.xform(Vector2(ev.mouse_motion.x, ev.mouse_motion.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.mouse_motion.relative_x, ev.mouse_motion.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.mouse_motion.speed_x, ev.mouse_motion.speed_y)); - ev.mouse_motion.x = l.x; - ev.mouse_motion.y = l.y; - ev.mouse_motion.global_x = g.x; - ev.mouse_motion.global_y = g.y; - ev.mouse_motion.relative_x = r.x; - ev.mouse_motion.relative_y = r.y; - ev.mouse_motion.speed_x = s.x; - ev.mouse_motion.speed_y = s.y; - - } break; - case InputEvent::SCREEN_TOUCH: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_touch.x, ev.screen_touch.y)); - ev.screen_touch.x = t.x; - ev.screen_touch.y = t.y; - - } break; - case InputEvent::SCREEN_DRAG: { - - Vector2 t = p_xform.xform(Vector2(ev.screen_drag.x, ev.screen_drag.y)); - Vector2 r = p_xform.basis_xform(Vector2(ev.screen_drag.relative_x, ev.screen_drag.relative_y)); - Vector2 s = p_xform.basis_xform(Vector2(ev.screen_drag.speed_x, ev.screen_drag.speed_y)); - ev.screen_drag.x = t.x; - ev.screen_drag.y = t.y; - ev.screen_drag.relative_x = r.x; - ev.screen_drag.relative_y = r.y; - ev.screen_drag.speed_x = s.x; - ev.screen_drag.speed_y = s.y; - } break; - } +bool InputEventKey::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventKey> key = p_event; + if (key.is_null()) + return false; + + return get_scancode_with_modifiers() == key->get_scancode_with_modifiers(); +} + +void InputEventKey::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventKey::set_pressed); + + ClassDB::bind_method(D_METHOD("set_scancode", "scancode"), &InputEventKey::set_scancode); + ClassDB::bind_method(D_METHOD("get_scancode"), &InputEventKey::get_scancode); + + ClassDB::bind_method(D_METHOD("set_unicode", "unicode"), &InputEventKey::set_unicode); + ClassDB::bind_method(D_METHOD("get_unicode"), &InputEventKey::get_unicode); + + ClassDB::bind_method(D_METHOD("set_echo", "echo"), &InputEventKey::set_echo); + + ClassDB::bind_method(D_METHOD("get_scancode_with_modifiers"), &InputEventKey::get_scancode_with_modifiers); + + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "scancode"), "set_scancode", "get_scancode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "unicode"), "set_unicode", "get_unicode"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "echo"), "set_echo", "is_echo"); +} + +InputEventKey::InputEventKey() { + + pressed = false; + scancode = 0; + unicode = 0; ///unicode + echo = false; +} + +//////////////////////////////////////// + +void InputEventMouse::set_button_mask(int p_mask) { + + button_mask = p_mask; +} +int InputEventMouse::get_button_mask() const { + + return button_mask; +} + +void InputEventMouse::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventMouse::get_pos() const { + + return pos; +} + +void InputEventMouse::set_global_pos(const Vector2 &p_global_pos) { + + global_pos = p_global_pos; +} +Vector2 InputEventMouse::get_global_pos() const { + + return global_pos; +} + +void InputEventMouse::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_mask", "button_mask"), &InputEventMouse::set_button_mask); + ClassDB::bind_method(D_METHOD("get_button_mask"), &InputEventMouse::get_button_mask); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventMouse::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventMouse::get_pos); + + ClassDB::bind_method(D_METHOD("set_global_pos", "global_pos"), &InputEventMouse::set_global_pos); + ClassDB::bind_method(D_METHOD("get_global_pos"), &InputEventMouse::get_global_pos); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_mask"), "set_button_mask", "get_button_mask"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "global_pos"), "set_global_pos", "get_global_pos"); +} + +InputEventMouse::InputEventMouse() { + + button_mask = 0; +} + +/////////////////////////////////////// + +void InputEventMouseButton::set_factor(float p_factor) { + + factor = p_factor; +} + +float InputEventMouseButton::get_factor() { + + return factor; +} + +void InputEventMouseButton::set_button_index(int p_index) { + + button_index = p_index; +} +int InputEventMouseButton::get_button_index() const { + + return button_index; +} + +void InputEventMouseButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventMouseButton::is_pressed() const { + + return pressed; +} + +void InputEventMouseButton::set_doubleclick(bool p_doubleclick) { + + doubleclick = p_doubleclick; +} +bool InputEventMouseButton::is_doubleclick() const { + + return doubleclick; +} + +Ref<InputEvent> InputEventMouseButton::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_pos()); + Vector2 l = p_xform.xform(get_pos() + p_local_ofs); + + Ref<InputEventMouseButton> mb; + mb.instance(); + + mb->set_id(get_id()); + mb->set_device(get_device()); + + mb->set_alt(get_alt()); + mb->set_shift(get_shift()); + mb->set_control(get_control()); + mb->set_metakey(get_metakey()); + + mb->set_pos(l); + mb->set_global_pos(g); + + mb->set_button_mask(get_button_mask()); + mb->set_pressed(pressed); + mb->set_doubleclick(doubleclick); + mb->set_factor(factor); + mb->set_button_index(button_index); + + return mb; +} + +bool InputEventMouseButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_null()) + return false; + + return mb->button_index == button_index; +} + +void InputEventMouseButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_factor", "factor"), &InputEventMouseButton::set_factor); + ClassDB::bind_method(D_METHOD("get_factor"), &InputEventMouseButton::get_factor); + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventMouseButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventMouseButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventMouseButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventMouseButton::is_pressed); + + ClassDB::bind_method(D_METHOD("set_doubleclick", "doubleclick"), &InputEventMouseButton::set_doubleclick); + ClassDB::bind_method(D_METHOD("is_doubleclick"), &InputEventMouseButton::is_doubleclick); + + ADD_PROPERTY(PropertyInfo(Variant::REAL, "factor"), "set_factor", "get_factor"); + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "doubleclick"), "set_doubleclick", "is_doubleclick"); +} + +InputEventMouseButton::InputEventMouseButton() { + + factor = 0; + button_index = 0; + pressed = false; + doubleclick = false; +} + +//////////////////////////////////////////// + +void InputEventMouseMotion::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventMouseMotion::get_relative() const { + + return relative; +} + +void InputEventMouseMotion::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventMouseMotion::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventMouseMotion::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Vector2 g = p_xform.xform(get_global_pos()); + Vector2 l = p_xform.xform(get_pos() + p_local_ofs); + Vector2 r = p_xform.basis_xform(get_relative()); + Vector2 s = p_xform.basis_xform(get_speed()); + + Ref<InputEventMouseMotion> mm; + mm.instance(); + + mm->set_id(get_id()); + mm->set_device(get_device()); + + mm->set_alt(get_alt()); + mm->set_shift(get_shift()); + mm->set_control(get_control()); + mm->set_metakey(get_metakey()); + + mm->set_pos(l); + mm->set_global_pos(g); + + mm->set_button_mask(get_button_mask()); + mm->set_relative(r); + mm->set_speed(s); + + return mm; +} + +void InputEventMouseMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventMouseMotion::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventMouseMotion::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventMouseMotion::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventMouseMotion::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventMouseMotion::InputEventMouseMotion() { +} + +//////////////////////////////////////// + +void InputEventJoypadMotion::set_axis(int p_axis) { + + axis = p_axis; +} + +int InputEventJoypadMotion::get_axis() const { + + return axis; +} + +void InputEventJoypadMotion::set_axis_value(float p_value) { + + axis_value = p_value; +} +float InputEventJoypadMotion::get_axis_value() const { + + return axis_value; +} + +bool InputEventJoypadMotion::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadMotion> jm = p_event; + if (jm.is_null()) + return false; + + return (axis == jm->axis && (axis_value < 0) == (jm->axis_value < 0)); +} + +void InputEventJoypadMotion::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_axis", "axis"), &InputEventJoypadMotion::set_axis); + ClassDB::bind_method(D_METHOD("get_axis"), &InputEventJoypadMotion::get_axis); + + ClassDB::bind_method(D_METHOD("set_axis_value", "axis_value"), &InputEventJoypadMotion::set_axis_value); + ClassDB::bind_method(D_METHOD("get_axis_value"), &InputEventJoypadMotion::get_axis_value); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "axis"), "set_axis", "get_axis"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "axis_value"), "set_axis_value", "get_axis_value"); +} + +InputEventJoypadMotion::InputEventJoypadMotion() { + + axis = 0; + axis_value = 0; +} +///////////////////////////////// + +void InputEventJoypadButton::set_button_index(int p_index) { + + button_index = p_index; +} + +int InputEventJoypadButton::get_button_index() const { + + return button_index; +} + +void InputEventJoypadButton::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventJoypadButton::is_pressed() const { + + return pressed; +} + +void InputEventJoypadButton::set_pressure(float p_pressure) { + + pressure = p_pressure; +} +float InputEventJoypadButton::get_pressure() const { + + return pressure; +} + +bool InputEventJoypadButton::action_match(const Ref<InputEvent> &p_event) const { + + Ref<InputEventJoypadButton> jb = p_event; + if (jb.is_null()) + return false; + + return button_index == jb->button_index; +} + +void InputEventJoypadButton::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_button_index", "button_index"), &InputEventJoypadButton::set_button_index); + ClassDB::bind_method(D_METHOD("get_button_index"), &InputEventJoypadButton::get_button_index); + + ClassDB::bind_method(D_METHOD("set_pressure", "pressure"), &InputEventJoypadButton::set_pressure); + ClassDB::bind_method(D_METHOD("get_pressure"), &InputEventJoypadButton::get_pressure); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventJoypadButton::set_pressed); + // ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventJoypadButton::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "button_index"), "set_button_index", "get_button_index"); + ADD_PROPERTY(PropertyInfo(Variant::REAL, "pressure"), "set_pressure", "get_pressure"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventJoypadButton::InputEventJoypadButton() { + + button_index = 0; + pressure = 0; + pressed = false; +} + +////////////////////////////////////////////// + +void InputEventScreenTouch::set_index(int p_index) { + + index = p_index; +} +int InputEventScreenTouch::get_index() const { + + return index; +} + +void InputEventScreenTouch::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenTouch::get_pos() const { + + return pos; +} + +void InputEventScreenTouch::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventScreenTouch::is_pressed() const { + + return pressed; +} + +Ref<InputEvent> InputEventScreenTouch::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenTouch> st; + st.instance(); + st->set_id(get_id()); + st->set_device(get_device()); + st->set_index(index); + st->set_pos(p_xform.xform(pos + p_local_ofs)); + st->set_pressed(pressed); + + return st; +} + +void InputEventScreenTouch::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenTouch::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenTouch::get_index); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventScreenTouch::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventScreenTouch::get_pos); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventScreenTouch::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"),&InputEventScreenTouch::is_pressed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} + +InputEventScreenTouch::InputEventScreenTouch() { + + index = 0; + pressed = false; +} + +///////////////////////////// + +void InputEventScreenDrag::set_index(int p_index) { + + index = p_index; +} + +int InputEventScreenDrag::get_index() const { + + return index; +} + +void InputEventScreenDrag::set_pos(const Vector2 &p_pos) { + + pos = p_pos; +} +Vector2 InputEventScreenDrag::get_pos() const { + + return pos; +} + +void InputEventScreenDrag::set_relative(const Vector2 &p_relative) { + + relative = p_relative; +} +Vector2 InputEventScreenDrag::get_relative() const { + + return relative; +} + +void InputEventScreenDrag::set_speed(const Vector2 &p_speed) { + + speed = p_speed; +} +Vector2 InputEventScreenDrag::get_speed() const { + + return speed; +} + +Ref<InputEvent> InputEventScreenDrag::xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs) const { + + Ref<InputEventScreenDrag> sd; + + sd.instance(); + + sd->set_id(get_id()); + sd->set_device(get_device()); + + sd->set_index(index); + sd->set_pos(p_xform.xform(pos + p_local_ofs)); + sd->set_relative(p_xform.basis_xform(relative)); + sd->set_speed(p_xform.basis_xform(speed)); + + return sd; +} + +void InputEventScreenDrag::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_index", "index"), &InputEventScreenDrag::set_index); + ClassDB::bind_method(D_METHOD("get_index"), &InputEventScreenDrag::get_index); + + ClassDB::bind_method(D_METHOD("set_pos", "pos"), &InputEventScreenDrag::set_pos); + ClassDB::bind_method(D_METHOD("get_pos"), &InputEventScreenDrag::get_pos); + + ClassDB::bind_method(D_METHOD("set_relative", "relative"), &InputEventScreenDrag::set_relative); + ClassDB::bind_method(D_METHOD("get_relative"), &InputEventScreenDrag::get_relative); + + ClassDB::bind_method(D_METHOD("set_speed", "speed"), &InputEventScreenDrag::set_speed); + ClassDB::bind_method(D_METHOD("get_speed"), &InputEventScreenDrag::get_speed); + + ADD_PROPERTY(PropertyInfo(Variant::INT, "index"), "set_index", "get_index"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "pos"), "set_pos", "get_pos"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "relative"), "set_relative", "get_relative"); + ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "speed"), "set_speed", "get_speed"); +} + +InputEventScreenDrag::InputEventScreenDrag() { + + index = 0; +} +///////////////////////////// + +void InputEventAction::set_action(const StringName &p_action) { + + action = p_action; +} +StringName InputEventAction::get_action() const { + + return action; +} + +void InputEventAction::set_pressed(bool p_pressed) { + + pressed = p_pressed; +} +bool InputEventAction::is_pressed() const { + + return pressed; +} + +bool InputEventAction::is_action(const StringName &p_action) const { + + return action == p_action; +} + +void InputEventAction::_bind_methods() { + + ClassDB::bind_method(D_METHOD("set_action", "action"), &InputEventAction::set_action); + ClassDB::bind_method(D_METHOD("get_action"), &InputEventAction::get_action); + + ClassDB::bind_method(D_METHOD("set_pressed", "pressed"), &InputEventAction::set_pressed); + //ClassDB::bind_method(D_METHOD("is_pressed"), &InputEventAction::is_pressed); + + ClassDB::bind_method(D_METHOD("is_action", "name"), &InputEventAction::is_action); + + ADD_PROPERTY(PropertyInfo(Variant::STRING, "action"), "set_action", "get_action"); + ADD_PROPERTY(PropertyInfo(Variant::BOOL, "pressed"), "set_pressed", "is_pressed"); +} - return ev; +InputEventAction::InputEventAction() { + pressed = false; } diff --git a/core/os/input_event.h b/core/os/input_event.h index 93cceac27c..b94f0ef46a 100644 --- a/core/os/input_event.h +++ b/core/os/input_event.h @@ -32,6 +32,7 @@ #include "math_2d.h" #include "os/copymem.h" +#include "resource.h" #include "typedefs.h" #include "ustring.h" /** @@ -137,7 +138,40 @@ enum { * Input Modifier Status * for keyboard/mouse events. */ -struct InputModifierState { + +class InputEvent : public Resource { + GDCLASS(InputEvent, Resource) + + uint32_t id; + int device; + +protected: + static void _bind_methods(); + +public: + void set_id(uint32_t p_id); + uint32_t get_id() const; + + void set_device(int p_device); + int get_device() const; + + virtual bool is_pressed() const; + virtual bool is_action(const StringName &p_action) const; + virtual bool is_action_pressed(const StringName &p_action) const; + virtual bool is_action_released(const StringName &p_action) const; + virtual bool is_echo() const; + virtual String as_text() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const; + + InputEvent(); +}; + +class InputEventWithModifiers : public InputEvent { + GDCLASS(InputEventWithModifiers, InputEvent) bool shift; bool alt; @@ -157,126 +191,267 @@ struct InputModifierState { #endif - bool operator==(const InputModifierState &rvalue) const { +protected: + static void _bind_methods(); + +public: + void set_shift(bool p_enabled); + bool get_shift() const; + + void set_alt(bool p_enabled); + bool get_alt() const; + + void set_control(bool p_enabled); + bool get_control() const; + + void set_metakey(bool p_enabled); + bool get_metakey() const; + + void set_command(bool p_enabled); + bool get_command() const; - return ((shift == rvalue.shift) && (alt == rvalue.alt) && (control == rvalue.control) && (meta == rvalue.meta)); - } + InputEventWithModifiers(); }; -struct InputEventKey { +class InputEventKey : public InputEventWithModifiers { - InputModifierState mod; + GDCLASS(InputEventKey, InputEventWithModifiers) bool pressed; /// otherwise release uint32_t scancode; ///< check keyboard.h , KeyCode enum, without modifier masks uint32_t unicode; ///unicode + bool echo; /// true if this is an echo key + +protected: + static void _bind_methods(); + +public: + void set_pressed(bool p_pressed); + bool is_pressed(); + + void set_scancode(uint32_t p_scancode); + uint32_t get_scancode() const; + + void set_unicode(uint32_t p_unicode); + uint32_t get_unicode() const; + + void set_echo(bool p_enable); + bool is_echo() const; + uint32_t get_scancode_with_modifiers() const; - bool echo; /// true if this is an echo key + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventKey(); }; -struct InputEventMouse { +class InputEventMouse : public InputEventWithModifiers { + + GDCLASS(InputEventMouse, InputEventWithModifiers) - InputModifierState mod; int button_mask; - float x, y; - float global_x, global_y; - int pointer_index; + + Vector2 pos; + Vector2 global_pos; + +protected: + static void _bind_methods(); + +public: + void set_button_mask(int p_mask); + int get_button_mask() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_global_pos(const Vector2 &p_global_pos); + Vector2 get_global_pos() const; + + InputEventMouse(); }; -struct InputEventMouseButton : public InputEventMouse { +class InputEventMouseButton : public InputEventMouse { + + GDCLASS(InputEventMouseButton, InputEventMouse) - double factor; + float factor; int button_index; bool pressed; //otherwise released bool doubleclick; //last even less than doubleclick time + +protected: + static void _bind_methods(); + +public: + void set_factor(float p_factor); + float get_factor(); + + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_doubleclick(bool p_doubleclick); + bool is_doubleclick() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventMouseButton(); }; -struct InputEventMouseMotion : public InputEventMouse { +class InputEventMouseMotion : public InputEventMouse { + + GDCLASS(InputEventMouseMotion, InputEventMouse) + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; - float relative_x, relative_y; - float speed_x, speed_y; + InputEventMouseMotion(); }; -struct InputEventJoypadMotion { +class InputEventJoypadMotion : public InputEvent { + GDCLASS(InputEventJoypadMotion, InputEvent) int axis; ///< Joypad axis float axis_value; ///< -1 to 1 + +protected: + static void _bind_methods(); + +public: + void set_axis(int p_axis); + int get_axis() const; + + void set_axis_value(float p_value); + float get_axis_value() const; + + virtual bool action_match(const Ref<InputEvent> &p_event) const; + + virtual bool is_action_type() const { return true; } + + InputEventJoypadMotion(); }; -struct InputEventJoypadButton { +class InputEventJoypadButton : public InputEvent { + GDCLASS(InputEventJoypadButton, InputEvent) int button_index; bool pressed; float pressure; //0 to 1 -}; +protected: + static void _bind_methods(); + +public: + void set_button_index(int p_index); + int get_button_index() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + void set_pressure(float p_pressure); + float get_pressure() const; -struct InputEventScreenTouch { + virtual bool action_match(const Ref<InputEvent> &p_event) const; + virtual bool is_action_type() const { return true; } + + InputEventJoypadButton(); +}; + +struct InputEventScreenTouch : public InputEvent { + GDCLASS(InputEventScreenTouch, InputEvent) int index; - float x, y; + Vector2 pos; bool pressed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenTouch(); }; -struct InputEventScreenDrag { +class InputEventScreenDrag : public InputEvent { + + GDCLASS(InputEventScreenDrag, InputEvent) int index; - float x, y; - float relative_x, relative_y; - float speed_x, speed_y; + Vector2 pos; + Vector2 relative; + Vector2 speed; + +protected: + static void _bind_methods(); + +public: + void set_index(int p_index); + int get_index() const; + + void set_pos(const Vector2 &p_pos); + Vector2 get_pos() const; + + void set_relative(const Vector2 &p_relative); + Vector2 get_relative() const; + + void set_speed(const Vector2 &p_speed); + Vector2 get_speed() const; + + virtual Ref<InputEvent> xformed_by(const Transform2D &p_xform, const Vector2 &p_local_ofs = Vector2()) const; + + InputEventScreenDrag(); }; -struct InputEventAction { +class InputEventAction : public InputEvent { + + GDCLASS(InputEventAction, InputEvent) - int action; + StringName action; bool pressed; -}; -struct InputEvent { - - enum Type { - NONE, - KEY, - MOUSE_MOTION, - MOUSE_BUTTON, - JOYPAD_MOTION, - JOYPAD_BUTTON, - SCREEN_TOUCH, - SCREEN_DRAG, - ACTION, - TYPE_MAX - }; +protected: + static void _bind_methods(); - uint32_t ID; - int type; - int device; +public: + void set_action(const StringName &p_action); + StringName get_action() const; - union { - InputEventMouseMotion mouse_motion; - InputEventMouseButton mouse_button; - InputEventJoypadMotion joy_motion; - InputEventJoypadButton joy_button; - InputEventKey key; - InputEventScreenTouch screen_touch; - InputEventScreenDrag screen_drag; - InputEventAction action; - }; + void set_pressed(bool p_pressed); + virtual bool is_pressed() const; - bool is_pressed() const; - bool is_action(const String &p_action) const; - bool is_action_pressed(const String &p_action) const; - bool is_action_released(const String &p_action) const; - bool is_echo() const; - void set_as_action(const String &p_action, bool p_pressed); - - InputEvent xform_by(const Transform2D &p_xform) const; - bool operator==(const InputEvent &p_event) const; - operator String() const; - InputEvent() { - zeromem(this, sizeof(InputEvent)); - mouse_button.factor = 1; - } + virtual bool is_action(const StringName &p_action) const; + + virtual bool is_action_type() const { return true; } + + InputEventAction(); }; #endif diff --git a/core/os/main_loop.cpp b/core/os/main_loop.cpp index 9f8fcccd82..248f5537c6 100644 --- a/core/os/main_loop.cpp +++ b/core/os/main_loop.cpp @@ -39,7 +39,7 @@ void MainLoop::_bind_methods() { ClassDB::bind_method(D_METHOD("idle", "delta"), &MainLoop::idle); ClassDB::bind_method(D_METHOD("finish"), &MainLoop::finish); - BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::INPUT_EVENT, "ev"))); + BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "ev", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); BIND_VMETHOD(MethodInfo("_input_text", PropertyInfo(Variant::STRING, "text"))); BIND_VMETHOD(MethodInfo("_initialize")); BIND_VMETHOD(MethodInfo("_iteration", PropertyInfo(Variant::REAL, "delta"))); @@ -73,7 +73,7 @@ void MainLoop::input_text(const String &p_text) { get_script_instance()->call("_input_text", p_text); } -void MainLoop::input_event(const InputEvent &p_event) { +void MainLoop::input_event(const Ref<InputEvent> &p_event) { if (get_script_instance()) get_script_instance()->call("_input_event", p_event); diff --git a/core/os/main_loop.h b/core/os/main_loop.h index a53137afa4..23b352468e 100644 --- a/core/os/main_loop.h +++ b/core/os/main_loop.h @@ -59,7 +59,7 @@ public: NOTIFICATION_TRANSLATION_CHANGED = 10, }; - virtual void input_event(const InputEvent &p_event); + virtual void input_event(const Ref<InputEvent> &p_event); virtual void input_text(const String &p_text); virtual void init(); diff --git a/core/packed_data_container.cpp b/core/packed_data_container.cpp index 836bcb7287..0565d0d3f5 100644 --- a/core/packed_data_container.cpp +++ b/core/packed_data_container.cpp @@ -237,7 +237,6 @@ uint32_t PackedDataContainer::_pack(const Variant &p_data, Vector<uint8_t> &tmpd case Variant::RECT3: case Variant::BASIS: case Variant::TRANSFORM: - case Variant::INPUT_EVENT: case Variant::POOL_BYTE_ARRAY: case Variant::POOL_INT_ARRAY: case Variant::POOL_REAL_ARRAY: diff --git a/core/register_core_types.cpp b/core/register_core_types.cpp index 634751b0bb..b089ba9129 100644 --- a/core/register_core_types.cpp +++ b/core/register_core_types.cpp @@ -110,6 +110,18 @@ void register_core_types() { ClassDB::register_class<Resource>(); ClassDB::register_class<Image>(); + ClassDB::register_virtual_class<InputEvent>(); + ClassDB::register_virtual_class<InputEventWithModifiers>(); + ClassDB::register_class<InputEventKey>(); + ClassDB::register_virtual_class<InputEventMouse>(); + ClassDB::register_class<InputEventMouseButton>(); + ClassDB::register_class<InputEventMouseMotion>(); + ClassDB::register_class<InputEventJoypadButton>(); + ClassDB::register_class<InputEventJoypadMotion>(); + ClassDB::register_class<InputEventScreenDrag>(); + ClassDB::register_class<InputEventScreenTouch>(); + ClassDB::register_class<InputEventAction>(); + ClassDB::register_class<FuncRef>(); ClassDB::register_virtual_class<StreamPeer>(); ClassDB::register_class<StreamPeerBuffer>(); diff --git a/core/variant.cpp b/core/variant.cpp index 9c05dbaca0..ae5141b8bf 100644 --- a/core/variant.cpp +++ b/core/variant.cpp @@ -133,11 +133,6 @@ String Variant::get_type_name(Variant::Type p_type) { return "NodePath"; } break; - case INPUT_EVENT: { - - return "InputEvent"; - - } break; case DICTIONARY: { return "Dictionary"; @@ -798,11 +793,6 @@ bool Variant::is_zero() const { return reinterpret_cast<const NodePath *>(_data._mem)->is_empty(); } break; - case INPUT_EVENT: { - - return _data._input_event->type == InputEvent::NONE; - - } break; case DICTIONARY: { return reinterpret_cast<const Dictionary *>(_data._mem)->empty(); @@ -1018,11 +1008,6 @@ void Variant::reference(const Variant &p_variant) { memnew_placement(_data._mem, NodePath(*reinterpret_cast<const NodePath *>(p_variant._data._mem))); } break; - case INPUT_EVENT: { - - _data._input_event = memnew(InputEvent(*p_variant._data._input_event)); - - } break; case DICTIONARY: { memnew_placement(_data._mem, Dictionary(*reinterpret_cast<const Dictionary *>(p_variant._data._mem))); @@ -1149,12 +1134,6 @@ void Variant::clear() { reinterpret_cast<Array *>(_data._mem)->~Array(); } break; - case INPUT_EVENT: { - - memdelete(_data._input_event); - - } break; - // arrays case POOL_BYTE_ARRAY: { @@ -1503,7 +1482,6 @@ Variant::operator String() const { } break; case TRANSFORM: return operator Transform(); case NODE_PATH: return operator NodePath(); - case INPUT_EVENT: return operator InputEvent(); case COLOR: return String::num(operator Color().r) + "," + String::num(operator Color().g) + "," + String::num(operator Color().b) + "," + String::num(operator Color().a); case DICTIONARY: { @@ -1798,14 +1776,6 @@ Variant::operator Control *() const { return NULL; } -Variant::operator InputEvent() const { - - if (type == INPUT_EVENT) - return *reinterpret_cast<const InputEvent *>(_data._input_event); - else - return InputEvent(); -} - Variant::operator Dictionary() const { if (type == DICTIONARY) @@ -2285,12 +2255,6 @@ Variant::Variant(const NodePath &p_node_path) { memnew_placement(_data._mem, NodePath(p_node_path)); } -Variant::Variant(const InputEvent &p_input_event) { - - type = INPUT_EVENT; - _data._input_event = memnew(InputEvent(p_input_event)); -} - Variant::Variant(const RefPtr &p_resource) { type = OBJECT; @@ -2690,11 +2654,6 @@ uint32_t Variant::hash() const { return reinterpret_cast<const NodePath *>(_data._mem)->hash(); } break; - case INPUT_EVENT: { - - return hash_djb2_buffer((uint8_t *)_data._input_event, sizeof(InputEvent)); - - } break; case DICTIONARY: { return reinterpret_cast<const Dictionary *>(_data._mem)->hash(); diff --git a/core/variant.h b/core/variant.h index 76097dfbdd..661d31cf16 100644 --- a/core/variant.h +++ b/core/variant.h @@ -42,7 +42,6 @@ #include "io/ip_address.h" #include "math_2d.h" #include "matrix3.h" -#include "os/input_event.h" #include "os/power.h" #include "path_db.h" #include "plane.h" @@ -100,7 +99,6 @@ public: NODE_PATH, // 15 _RID, OBJECT, - INPUT_EVENT, DICTIONARY, ARRAY, // 20 @@ -143,7 +141,6 @@ private: Basis *_basis; Transform *_transform; RefPtr *_resource; - InputEvent *_input_event; void *_ptr; //generic pointer uint8_t _mem[sizeof(ObjData) > (sizeof(real_t) * 4) ? sizeof(ObjData) : (sizeof(real_t) * 4)]; } _data; @@ -207,7 +204,7 @@ public: operator NodePath() const; operator RefPtr() const; operator RID() const; - operator InputEvent() const; + operator Object *() const; operator Node *() const; operator Control *() const; @@ -276,7 +273,6 @@ public: Variant(const RefPtr &p_resource); Variant(const RID &p_rid); Variant(const Object *p_object); - Variant(const InputEvent &p_input_event); Variant(const Dictionary &p_dictionary); Variant(const Array &p_array); diff --git a/core/variant_call.cpp b/core/variant_call.cpp index df81d2111e..6568dc877e 100644 --- a/core/variant_call.cpp +++ b/core/variant_call.cpp @@ -737,13 +737,6 @@ struct _VariantCall { VCALL_PTR1( Transform, translate ); VCALL_PTR0( Transform, orthonormalize ); */ - VCALL_PTR0R(InputEvent, is_pressed); - VCALL_PTR1R(InputEvent, is_action); - VCALL_PTR1R(InputEvent, is_action_pressed); - VCALL_PTR1R(InputEvent, is_action_released); - VCALL_PTR0R(InputEvent, is_echo); - VCALL_PTR2(InputEvent, set_as_action); - struct ConstructData { int arg_count; @@ -1036,7 +1029,6 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i return NodePath(); // 15 case _RID: return RID(); case OBJECT: return (Object *)NULL; - case INPUT_EVENT: return InputEvent(); case DICTIONARY: return Dictionary(); case ARRAY: return Array(); // 20 @@ -1117,7 +1109,6 @@ Variant Variant::construct(const Variant::Type p_type, const Variant **p_args, i return (NodePath(p_args[0]->operator NodePath())); // 15 case _RID: return (RID(*p_args[0])); case OBJECT: return ((Object *)(p_args[0]->operator Object *())); - case INPUT_EVENT: return (InputEvent(*p_args[0])); case DICTIONARY: return p_args[0]->operator Dictionary(); case ARRAY: return p_args[0]->operator Array(); // 20 @@ -1690,13 +1681,6 @@ void register_variant_methods() { _VariantCall::type_funcs[Variant::TRANSFORM].functions["xform_inv"].returns = true; #endif - ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_pressed, varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action, STRING, "action", varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_pressed, STRING, "action", varray()); - ADDFUNC1(INPUT_EVENT, BOOL, InputEvent, is_action_released, STRING, "action", varray()); - ADDFUNC0(INPUT_EVENT, BOOL, InputEvent, is_echo, varray()); - ADDFUNC2(INPUT_EVENT, NIL, InputEvent, set_as_action, STRING, "action", BOOL, "pressed", varray()); - /* REGISTER CONSTRUCTORS */ _VariantCall::add_constructor(_VariantCall::Vector2_init1, Variant::VECTOR2, "x", Variant::REAL, "y", Variant::REAL); @@ -1733,16 +1717,6 @@ void register_variant_methods() { _VariantCall::add_constant(Variant::VECTOR3, "AXIS_X", Vector3::AXIS_X); _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Y", Vector3::AXIS_Y); _VariantCall::add_constant(Variant::VECTOR3, "AXIS_Z", Vector3::AXIS_Z); - - _VariantCall::add_constant(Variant::INPUT_EVENT, "NONE", InputEvent::NONE); - _VariantCall::add_constant(Variant::INPUT_EVENT, "KEY", InputEvent::KEY); - _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_MOTION", InputEvent::MOUSE_MOTION); - _VariantCall::add_constant(Variant::INPUT_EVENT, "MOUSE_BUTTON", InputEvent::MOUSE_BUTTON); - _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYPAD_MOTION", InputEvent::JOYPAD_MOTION); - _VariantCall::add_constant(Variant::INPUT_EVENT, "JOYPAD_BUTTON", InputEvent::JOYPAD_BUTTON); - _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_TOUCH", InputEvent::SCREEN_TOUCH); - _VariantCall::add_constant(Variant::INPUT_EVENT, "SCREEN_DRAG", InputEvent::SCREEN_DRAG); - _VariantCall::add_constant(Variant::INPUT_EVENT, "ACTION", InputEvent::ACTION); } void unregister_variant_methods() { diff --git a/core/variant_op.cpp b/core/variant_op.cpp index 8bae6a168b..7b9b7abd9e 100644 --- a/core/variant_op.cpp +++ b/core/variant_op.cpp @@ -61,7 +61,6 @@ bool Variant::booleanize(bool &r_valid) const { case _RID: return (*reinterpret_cast<const RID *>(_data._mem)).is_valid(); case OBJECT: return _get_obj().obj; case NODE_PATH: return (*reinterpret_cast<const NodePath *>(_data._mem)) != NodePath(); - case INPUT_EVENT: case DICTIONARY: case ARRAY: case POOL_BYTE_ARRAY: @@ -291,7 +290,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == NIL) _RETURN(!p_a._get_obj().obj); } break; - DEFAULT_OP_PTRREF(==, INPUT_EVENT, _input_event); case DICTIONARY: { @@ -378,7 +376,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == OBJECT) _RETURN((p_a._get_obj().obj < p_b._get_obj().obj)); } break; - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); case ARRAY: { @@ -443,7 +440,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & if (p_b.type == OBJECT) _RETURN((p_a._get_obj().obj <= p_b._get_obj().obj)); } break; - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -502,7 +498,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); case ARRAY: { @@ -559,7 +554,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -656,7 +650,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -729,7 +722,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -771,7 +763,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -811,7 +802,6 @@ void Variant::evaluate(const Operator &p_op, const Variant &p_a, const Variant & DEFAULT_OP_FAIL(NODE_PATH); DEFAULT_OP_FAIL(_RID); DEFAULT_OP_FAIL(OBJECT); - DEFAULT_OP_FAIL(INPUT_EVENT); DEFAULT_OP_FAIL(DICTIONARY); DEFAULT_OP_FAIL(ARRAY); DEFAULT_OP_FAIL(POOL_BYTE_ARRAY); @@ -1507,389 +1497,6 @@ void Variant::set(const Variant &p_index, const Variant &p_value, bool *r_valid) return obj->set(p_index, p_value, r_valid); } } break; - case INPUT_EVENT: { - - InputEvent &ie = *_data._input_event; - - if (p_index.get_type() != Variant::STRING) - return; - - const String &str = *reinterpret_cast<const String *>(p_index._data._mem); - - if (str == "type") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - int type = p_value; - if (type < 0 || type >= InputEvent::TYPE_MAX) - return; //fail - valid = true; - ie.type = InputEvent::Type(type); - return; - } else if (str == "device") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.device = p_value; - return; - } else if (str == "ID") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.ID = p_value; - return; - } - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "shift") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.shift = p_value; - return; - } - if (str == "alt") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.alt = p_value; - return; - } - if (str == "control") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.control = p_value; - return; - } - if (str == "meta") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.mod.meta = p_value; - return; - } - } - - if (ie.type == InputEvent::KEY) { - - if (str == "pressed") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.pressed = p_value; - return; - } else if (str == "scancode") { - - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - - valid = true; - ie.key.scancode = p_value; - return; - } else if (str == "unicode") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.key.unicode = p_value; - return; - } else if (str == "echo") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.key.echo = p_value; - return; - } - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_mask") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.button_mask = p_value; - return; - } else if (str == "x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.x = p_value; - return; - } else if (str == "y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.y = p_value; - return; - } else if (str == "pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_button.x = value.x; - ie.mouse_button.y = value.y; - return; - } else if (str == "global_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.global_x = p_value; - return; - } else if (str == "global_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.global_y = p_value; - return; - } else if (str == "global_pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_button.global_x = value.x; - ie.mouse_button.global_y = value.y; - return; - } /*else if (str=="pointer_index") { - valid=true; - return ie.mouse_button.pointer_index; - }*/ - - if (ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "relative_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.relative_x = p_value; - return; - } else if (str == "relative_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.relative_y = p_value; - return; - } else if (str == "relative_pos") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_motion.relative_x = value.x; - ie.mouse_motion.relative_y = value.y; - return; - } - - if (str == "speed_x") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.speed_x = p_value; - return; - } else if (str == "speed_y") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_motion.speed_y = p_value; - return; - } else if (str == "speed") { - if (p_value.type != Variant::VECTOR2) - return; - valid = true; - Point2 value = p_value; - ie.mouse_motion.speed_x = value.x; - ie.mouse_motion.speed_y = value.y; - return; - } - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_index") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL) - return; - valid = true; - ie.mouse_button.button_index = p_value; - return; - } else if (str == "pressed") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - valid = true; - ie.mouse_button.pressed = p_value; - return; - } else if (str == "doubleclick") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - valid = true; - ie.mouse_button.doubleclick = p_value; - return; - } - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - if (str == "button_index") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_button.button_index = p_value; - return; - } - if (str == "pressed") { - if (p_value.type != Variant::INT && p_value.type != Variant::REAL && p_value.type != Variant::BOOL) - return; - - valid = true; - ie.joy_button.pressed = p_value; - return; - } - if (str == "pressure") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_button.pressure = p_value; - return; - } - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - if (str == "axis") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_motion.axis = p_value; - return; - } - if (str == "value") { - if (p_value.type != Variant::REAL && p_value.type != Variant::INT) - return; - valid = true; - ie.joy_motion.axis_value = p_value; - return; - } - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - if (str == "index") { - valid = true; - ie.screen_touch.index = p_value; - return; - } - if (str == "x") { - valid = true; - ie.screen_touch.x = p_value; - return; - } - if (str == "y") { - valid = true; - ie.screen_touch.y = p_value; - return; - } - if (str == "pos") { - valid = true; - Vector2 v = p_value; - ie.screen_touch.x = v.x; - ie.screen_touch.y = v.y; - return; - } - if (str == "pressed") { - valid = true; - ie.screen_touch.pressed = p_value; - return; - } - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - if (str == "index") { - valid = true; - ie.screen_drag.index = p_value; - return; - } - if (str == "x") { - valid = true; - ie.screen_drag.x = p_value; - return; - } - if (str == "y") { - valid = true; - ie.screen_drag.y = p_value; - return; - } - if (str == "pos") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.x = v.x; - ie.screen_drag.y = v.y; - return; - } - if (str == "relative_x") { - valid = true; - ie.screen_drag.relative_x = p_value; - return; - } - if (str == "relative_y") { - valid = true; - ie.screen_drag.relative_y = p_value; - return; - } - if (str == "relative_pos") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.relative_x = v.x; - ie.screen_drag.relative_y = v.y; - return; - } - if (str == "speed_x") { - valid = true; - ie.screen_drag.speed_x = p_value; - return; - } - if (str == "speed_y") { - valid = true; - ie.screen_drag.speed_y = p_value; - return; - } - if (str == "speed") { - valid = true; - Vector2 v = p_value; - ie.screen_drag.speed_x = v.x; - ie.screen_drag.speed_y = v.y; - return; - } - } - if (ie.type == InputEvent::ACTION) { - - if (str == "action") { - valid = true; - ie.action.action = p_value; - return; - } else if (str == "pressed") { - valid = true; - ie.action.pressed = p_value; - return; - } - } - - } break; case DICTIONARY: { Dictionary *dic = reinterpret_cast<Dictionary *>(_data._mem); @@ -2261,235 +1868,6 @@ Variant Variant::get(const Variant &p_index, bool *r_valid) const { } } break; - case INPUT_EVENT: { - - InputEvent ie = operator InputEvent(); - - if (p_index.get_type() != Variant::STRING) - break; - - const String &str = *reinterpret_cast<const String *>(p_index._data._mem); - - if (str == "type") { - valid = true; - return ie.type; - } else if (str == "device") { - valid = true; - return ie.device; - } else if (str == "ID") { - valid = true; - return ie.ID; - } - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "shift") { - valid = true; - return ie.key.mod.shift; - } - if (str == "alt") { - valid = true; - return ie.key.mod.alt; - } - if (str == "control") { - valid = true; - return ie.key.mod.control; - } - if (str == "meta") { - valid = true; - return ie.key.mod.meta; - } - } - - if (ie.type == InputEvent::KEY) { - - if (str == "pressed") { - valid = true; - return ie.key.pressed; - } else if (str == "scancode") { - valid = true; - return ie.key.scancode; - } else if (str == "unicode") { - valid = true; - return ie.key.unicode; - } else if (str == "echo") { - valid = true; - return ie.key.echo; - } - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_mask") { - valid = true; - return ie.mouse_button.button_mask; - } else if (str == "x") { - valid = true; - return ie.mouse_button.x; - } else if (str == "y") { - valid = true; - return ie.mouse_button.y; - } else if (str == "pos") { - valid = true; - return Point2(ie.mouse_button.x, ie.mouse_button.y); - } else if (str == "global_x") { - valid = true; - return ie.mouse_button.global_x; - } else if (str == "global_y") { - valid = true; - return ie.mouse_button.global_y; - } else if (str == "global_pos") { - valid = true; - return Point2(ie.mouse_button.global_x, ie.mouse_button.global_y); - } /*else if (str=="pointer_index") { - valid=true; - return ie.mouse_button.pointer_index; - }*/ - - if (ie.type == InputEvent::MOUSE_MOTION) { - - if (str == "relative_x") { - valid = true; - return ie.mouse_motion.relative_x; - } else if (str == "relative_y") { - valid = true; - return ie.mouse_motion.relative_y; - } else if (str == "relative_pos") { - valid = true; - return Point2(ie.mouse_motion.relative_x, ie.mouse_motion.relative_y); - } else if (str == "speed_x") { - valid = true; - return ie.mouse_motion.speed_x; - } else if (str == "speed_y") { - valid = true; - return ie.mouse_motion.speed_y; - } else if (str == "speed") { - valid = true; - return Point2(ie.mouse_motion.speed_x, ie.mouse_motion.speed_y); - } - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - if (str == "button_index") { - valid = true; - return ie.mouse_button.button_index; - } else if (str == "pressed") { - valid = true; - return ie.mouse_button.pressed; - } else if (str == "doubleclick") { - valid = true; - return ie.mouse_button.doubleclick; - } - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - if (str == "button_index") { - valid = true; - return ie.joy_button.button_index; - } - if (str == "pressed") { - valid = true; - return ie.joy_button.pressed; - } - if (str == "pressure") { - valid = true; - return ie.joy_button.pressure; - } - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - if (str == "axis") { - valid = true; - return ie.joy_motion.axis; - } - if (str == "value") { - valid = true; - return ie.joy_motion.axis_value; - } - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - if (str == "index") { - valid = true; - return ie.screen_touch.index; - } - if (str == "x") { - valid = true; - return ie.screen_touch.x; - } - if (str == "y") { - valid = true; - return ie.screen_touch.y; - } - if (str == "pos") { - valid = true; - return Vector2(ie.screen_touch.x, ie.screen_touch.y); - } - if (str == "pressed") { - valid = true; - return ie.screen_touch.pressed; - } - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - if (str == "index") { - valid = true; - return ie.screen_drag.index; - } - if (str == "x") { - valid = true; - return ie.screen_drag.x; - } - if (str == "y") { - valid = true; - return ie.screen_drag.y; - } - if (str == "pos") { - valid = true; - return Vector2(ie.screen_drag.x, ie.screen_drag.y); - } - if (str == "relative_x") { - valid = true; - return ie.screen_drag.relative_x; - } - if (str == "relative_y") { - valid = true; - return ie.screen_drag.relative_y; - } - if (str == "relative_pos") { - valid = true; - return Vector2(ie.screen_drag.relative_x, ie.screen_drag.relative_y); - } - if (str == "speed_x") { - valid = true; - return ie.screen_drag.speed_x; - } - if (str == "speed_y") { - valid = true; - return ie.screen_drag.speed_y; - } - if (str == "speed") { - valid = true; - return Vector2(ie.screen_drag.speed_x, ie.screen_drag.speed_y); - } - } - if (ie.type == InputEvent::ACTION) { - - if (str == "action") { - valid = true; - return ie.action.action; - } else if (str == "pressed") { - valid = true; - return ie.action.pressed; - } - } - - } break; case DICTIONARY: { const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); @@ -2823,94 +2201,6 @@ void Variant::get_property_list(List<PropertyInfo> *p_list) const { } } break; - case INPUT_EVENT: { - - InputEvent ie = operator InputEvent(); - - p_list->push_back(PropertyInfo(Variant::INT, "type")); - p_list->push_back(PropertyInfo(Variant::INT, "device")); - p_list->push_back(PropertyInfo(Variant::INT, "ID")); - - if (ie.type == InputEvent::KEY || ie.type == InputEvent::MOUSE_BUTTON || ie.type == InputEvent::MOUSE_MOTION) { - - p_list->push_back(PropertyInfo(Variant::BOOL, "shift")); - p_list->push_back(PropertyInfo(Variant::BOOL, "alt")); - p_list->push_back(PropertyInfo(Variant::BOOL, "control")); - p_list->push_back(PropertyInfo(Variant::BOOL, "meta")); - } - - if (ie.type == InputEvent::KEY) { - - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::BOOL, "echo")); - p_list->push_back(PropertyInfo(Variant::INT, "scancode")); - p_list->push_back(PropertyInfo(Variant::INT, "unicode")); - } - - if (ie.type == InputEvent::MOUSE_MOTION || ie.type == InputEvent::MOUSE_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_mask")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "global_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "global_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "global_pos")); - - if (ie.type == InputEvent::MOUSE_MOTION) { - - p_list->push_back(PropertyInfo(Variant::REAL, "relative_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "relative_pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "speed")); - - } else if (ie.type == InputEvent::MOUSE_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_index")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::BOOL, "doubleclick")); - } - } - - if (ie.type == InputEvent::JOYPAD_BUTTON) { - - p_list->push_back(PropertyInfo(Variant::INT, "button_index")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - p_list->push_back(PropertyInfo(Variant::REAL, "pressure")); - } - - if (ie.type == InputEvent::JOYPAD_MOTION) { - - p_list->push_back(PropertyInfo(Variant::INT, "axis")); - p_list->push_back(PropertyInfo(Variant::REAL, "value")); - } - - if (ie.type == InputEvent::SCREEN_TOUCH) { - - p_list->push_back(PropertyInfo(Variant::INT, "index")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::BOOL, "pressed")); - } - - if (ie.type == InputEvent::SCREEN_DRAG) { - - p_list->push_back(PropertyInfo(Variant::INT, "index")); - p_list->push_back(PropertyInfo(Variant::REAL, "x")); - p_list->push_back(PropertyInfo(Variant::REAL, "y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "relative_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "relative_pos")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_x")); - p_list->push_back(PropertyInfo(Variant::REAL, "speed_y")); - p_list->push_back(PropertyInfo(Variant::VECTOR2, "speed")); - } - - } break; case DICTIONARY: { const Dictionary *dic = reinterpret_cast<const Dictionary *>(_data._mem); @@ -3636,10 +2926,6 @@ void Variant::interpolate(const Variant &a, const Variant &b, float c, Variant & r_dst = a; } return; - case INPUT_EVENT: { - r_dst = a; - } - return; case DICTIONARY: { } return; diff --git a/core/variant_parser.cpp b/core/variant_parser.cpp index 798a830dd0..0d4d0429e7 100644 --- a/core/variant_parser.cpp +++ b/core/variant_parser.cpp @@ -30,6 +30,7 @@ #include "variant_parser.h" #include "io/resource_loader.h" +#include "os/input_event.h" #include "os/keyboard.h" CharType VariantParser::StreamFile::get_char() { @@ -760,7 +761,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } return OK; - +#ifndef DISABLE_DEPRECATED } else if (id == "InputEvent") { get_token(p_stream, token, line, r_err_str); @@ -778,12 +779,10 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, String id = token.value; - InputEvent ie; + Ref<InputEvent> ie; if (id == "NONE") { - ie.type = InputEvent::NONE; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -793,21 +792,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "KEY") { + Ref<InputEventKey> key; + key.instance(); + ie = key; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::KEY; - get_token(p_stream, token, line, r_err_str); if (token.type == TK_IDENTIFIER) { String name = token.value; - ie.key.scancode = find_keycode(name); + key->set_scancode(find_keycode(name)); } else if (token.type == TK_NUMBER) { - ie.key.scancode = token.value; + key->set_scancode(token.value); } else { r_err_str = "Expected string or integer for keycode"; @@ -828,13 +829,13 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, String mods = token.value; if (mods.findn("C") != -1) - ie.key.mod.control = true; + key->set_control(true); if (mods.findn("A") != -1) - ie.key.mod.alt = true; + key->set_alt(true); if (mods.findn("S") != -1) - ie.key.mod.shift = true; + key->set_shift(true); if (mods.findn("M") != -1) - ie.key.mod.meta = true; + key->set_metakey(true); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -850,21 +851,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "MBUTTON") { + Ref<InputEventMouseButton> mb; + mb.instance(); + ie = mb; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::MOUSE_BUTTON; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected button index"; return ERR_PARSE_ERROR; } - ie.mouse_button.button_index = token.value; + mb->set_button_index(token.value); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -874,21 +877,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "JBUTTON") { + Ref<InputEventJoypadButton> jb; + jb.instance(); + ie = jb; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::JOYPAD_BUTTON; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected button index"; return ERR_PARSE_ERROR; } - ie.joy_button.button_index = token.value; + jb->set_button_index(token.value); get_token(p_stream, token, line, r_err_str); if (token.type != TK_PARENTHESIS_CLOSE) { @@ -898,21 +903,23 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, } else if (id == "JAXIS") { + Ref<InputEventJoypadMotion> jm; + jm.instance(); + ie = jm; + get_token(p_stream, token, line, r_err_str); if (token.type != TK_COMMA) { r_err_str = "Expected ','"; return ERR_PARSE_ERROR; } - ie.type = InputEvent::JOYPAD_MOTION; - get_token(p_stream, token, line, r_err_str); if (token.type != TK_NUMBER) { r_err_str = "Expected axis index"; return ERR_PARSE_ERROR; } - ie.joy_motion.axis = token.value; + jm->set_axis(token.value); get_token(p_stream, token, line, r_err_str); @@ -927,7 +934,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, return ERR_PARSE_ERROR; } - ie.joy_motion.axis_value = token.value; + jm->set_axis_value(token.value); get_token(p_stream, token, line, r_err_str); @@ -945,7 +952,7 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, value = ie; return OK; - +#endif } else if (id == "PoolByteArray" || id == "ByteArray") { Vector<uint8_t> args; @@ -1121,91 +1128,6 @@ Error VariantParser::parse_value(Token &token, Variant &value, Stream *p_stream, value = arr; return OK; - } else if (id == "key") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 1 && params.size() != 2, ERR_PARSE_ERROR); - - int scode = 0; - - if (params[0].is_numeric()) { - scode = params[0].to_int(); - if (scode < 10) { - scode = KEY_0 + scode; - } - } else - scode = find_keycode(params[0]); - - InputEvent ie; - ie.type = InputEvent::KEY; - ie.key.scancode = scode; - - if (params.size() == 2) { - String mods = params[1]; - if (mods.findn("C") != -1) - ie.key.mod.control = true; - if (mods.findn("A") != -1) - ie.key.mod.alt = true; - if (mods.findn("S") != -1) - ie.key.mod.shift = true; - if (mods.findn("M") != -1) - ie.key.mod.meta = true; - } - value = ie; - return OK; - - } else if (id == "mbutton") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - - InputEvent ie; - ie.type = InputEvent::MOUSE_BUTTON; - ie.device = params[0].to_int(); - ie.mouse_button.button_index = params[1].to_int(); - - value = ie; - return OK; - } else if (id == "jbutton") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - InputEvent ie; - ie.type = InputEvent::JOYPAD_BUTTON; - ie.device = params[0].to_int(); - ie.joy_button.button_index = params[1].to_int(); - - value = ie; - - return OK; - } else if (id == "jaxis") { // compatibility with project.godot - - Vector<String> params; - Error err = _parse_enginecfg(p_stream, params, line, r_err_str); - if (err) - return err; - ERR_FAIL_COND_V(params.size() != 2, ERR_PARSE_ERROR); - - InputEvent ie; - ie.type = InputEvent::JOYPAD_MOTION; - ie.device = params[0].to_int(); - int axis = params[1].to_int(); - ie.joy_motion.axis = axis >> 1; - ie.joy_motion.axis_value = axis & 1 ? 1 : -1; - - value = ie; - - return OK; - } else { r_err_str = "Unexpected identifier: '" + id + "'."; return ERR_PARSE_ERROR; @@ -1715,50 +1637,7 @@ Error VariantWriter::write(const Variant &p_variant, StoreStringFunc p_store_str p_store_string_func(p_store_string_ud, res_text); } break; - case Variant::INPUT_EVENT: { - - String str = "InputEvent("; - - InputEvent ev = p_variant; - switch (ev.type) { - case InputEvent::KEY: { - - str += "KEY," + itos(ev.key.scancode); - String mod; - if (ev.key.mod.alt) - mod += "A"; - if (ev.key.mod.shift) - mod += "S"; - if (ev.key.mod.control) - mod += "C"; - if (ev.key.mod.meta) - mod += "M"; - - if (mod != String()) - str += "," + mod; - } break; - case InputEvent::MOUSE_BUTTON: { - - str += "MBUTTON," + itos(ev.mouse_button.button_index); - } break; - case InputEvent::JOYPAD_BUTTON: { - str += "JBUTTON," + itos(ev.joy_button.button_index); - - } break; - case InputEvent::JOYPAD_MOTION: { - str += "JAXIS," + itos(ev.joy_motion.axis) + "," + itos(ev.joy_motion.axis_value); - } break; - case InputEvent::NONE: { - str += "NONE"; - } break; - default: {} - } - str += ")"; - - p_store_string_func(p_store_string_ud, str); //will be added later - - } break; case Variant::DICTIONARY: { Dictionary dict = p_variant; diff --git a/doc/base/classes.xml b/doc/base/classes.xml index af0a494a84..a04890d4fd 100644 --- a/doc/base/classes.xml +++ b/doc/base/classes.xml @@ -20360,7 +20360,7 @@ Singleton that manages actions. </brief_description> <description> - Singleton that manages actions. InputMap has a list of the actions used in InputEvent, which can be modified. + Singleton that manages actions. InputMap has a list of the actions used in Ref<InputEvent>, which can be modified. </description> <methods> <method name="action_add_event"> diff --git a/editor/animation_editor.cpp b/editor/animation_editor.cpp index e4ae1993ab..7c29162e67 100644 --- a/editor/animation_editor.cpp +++ b/editor/animation_editor.cpp @@ -154,13 +154,15 @@ private: } } - void _gui_input(const InputEvent &p_ev) { - if (p_ev.type == InputEvent::MOUSE_MOTION && p_ev.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + void _gui_input(const Ref<InputEvent> &p_ev) { + + Ref<InputEventMouseMotion> mm = p_ev; + if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT) { if (mode == MODE_DISABLED) return; - float rel = p_ev.mouse_motion.relative_x; + float rel = mm->get_relative().x; if (rel == 0) return; @@ -1746,7 +1748,7 @@ void AnimationKeyEditor::_anim_delete_keys() { } } -void AnimationKeyEditor::_track_editor_gui_input(const InputEvent &p_input) { +void AnimationKeyEditor::_track_editor_gui_input(const Ref<InputEvent> &p_input) { Control *te = track_editor; Ref<StyleBox> style = get_stylebox("normal", "TextEdit"); @@ -1804,1087 +1806,1083 @@ void AnimationKeyEditor::_track_editor_gui_input(const InputEvent &p_input) { int settings_limit = size.width - right_separator_ofs; int name_limit = settings_limit * name_column_ratio; - switch (p_input.type) { + Ref<InputEventKey> key = p_input; + if (key.is_valid()) { - case InputEvent::KEY: { + if (key->get_scancode() == KEY_D && key->is_pressed() && key->get_command()) { - if (p_input.key.scancode == KEY_D && p_input.key.pressed && p_input.key.mod.command) { + if (key->get_shift()) + _menu_track(TRACK_MENU_DUPLICATE_TRANSPOSE); + else + _menu_track(TRACK_MENU_DUPLICATE); - if (p_input.key.mod.shift) - _menu_track(TRACK_MENU_DUPLICATE_TRANSPOSE); - else - _menu_track(TRACK_MENU_DUPLICATE); + accept_event(); - accept_event(); + } else if (key->get_scancode() == KEY_DELETE && key->is_pressed() && click.click == ClickOver::CLICK_NONE) { - } else if (p_input.key.scancode == KEY_DELETE && p_input.key.pressed && click.click == ClickOver::CLICK_NONE) { + _anim_delete_keys(); + } else if (animation.is_valid() && animation->get_track_count() > 0) { - _anim_delete_keys(); - } else if (animation.is_valid() && animation->get_track_count() > 0) { - - if (p_input.is_pressed() && (p_input.is_action("ui_up") || p_input.is_action("ui_page_up"))) { + if (key->is_pressed() && (key->is_action("ui_up") || key->is_action("ui_page_up"))) { - if (p_input.is_action("ui_up")) - selected_track--; - if (v_scroll->is_visible_in_tree() && p_input.is_action("ui_page_up")) - selected_track--; + if (key->is_action("ui_up")) + selected_track--; + if (v_scroll->is_visible_in_tree() && key->is_action("ui_page_up")) + selected_track--; - if (selected_track < 0) - selected_track = 0; + if (selected_track < 0) + selected_track = 0; - if (v_scroll->is_visible_in_tree()) { - if (v_scroll->get_value() > selected_track) - v_scroll->set_value(selected_track); - } - - track_editor->update(); - accept_event(); + if (v_scroll->is_visible_in_tree()) { + if (v_scroll->get_value() > selected_track) + v_scroll->set_value(selected_track); } - if (p_input.is_pressed() && (p_input.is_action("ui_down") || p_input.is_action("ui_page_down"))) { + track_editor->update(); + accept_event(); + } - if (p_input.is_action("ui_down")) - selected_track++; - else if (v_scroll->is_visible_in_tree() && p_input.is_action("ui_page_down")) - selected_track += v_scroll->get_page(); + if (key->is_pressed() && (key->is_action("ui_down") || key->is_action("ui_page_down"))) { - if (selected_track >= animation->get_track_count()) - selected_track = animation->get_track_count() - 1; + if (key->is_action("ui_down")) + selected_track++; + else if (v_scroll->is_visible_in_tree() && key->is_action("ui_page_down")) + selected_track += v_scroll->get_page(); - if (v_scroll->is_visible_in_tree() && v_scroll->get_page() + v_scroll->get_value() < selected_track + 1) { - v_scroll->set_value(selected_track - v_scroll->get_page() + 1); - } + if (selected_track >= animation->get_track_count()) + selected_track = animation->get_track_count() - 1; - track_editor->update(); - accept_event(); + if (v_scroll->is_visible_in_tree() && v_scroll->get_page() + v_scroll->get_value() < selected_track + 1) { + v_scroll->set_value(selected_track - v_scroll->get_page() + 1); } + + track_editor->update(); + accept_event(); } + } + } - } break; - case InputEvent::MOUSE_BUTTON: { + Ref<InputEventMouseButton> mb = p_input; - const InputEventMouseButton &mb = p_input.mouse_button; + if (mb.is_valid()) { - if (mb.button_index == BUTTON_WHEEL_UP && mb.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) { - if (mb.mod.command) { + if (mb->get_command()) { - zoom->set_value(zoom->get_value() + zoom->get_step()); - } else { + zoom->set_value(zoom->get_value() + zoom->get_step()); + } else { - v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * mb.factor / 8); - } + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * mb->get_factor() / 8); } + } - if (mb.button_index == BUTTON_WHEEL_DOWN && mb.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) { - if (mb.mod.command) { + if (mb->get_command()) { - zoom->set_value(zoom->get_value() - zoom->get_step()); - } else { + zoom->set_value(zoom->get_value() - zoom->get_step()); + } else { - v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb.factor / 8); - } + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb->get_factor() / 8); } + } - if (mb.button_index == BUTTON_WHEEL_RIGHT && mb.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_RIGHT && mb->is_pressed()) { - h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * mb.factor / 8); - } + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * mb->get_factor() / 8); + } - if (mb.button_index == BUTTON_WHEEL_LEFT && mb.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_LEFT && mb->is_pressed()) { - v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb.factor / 8); - } + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * mb->get_factor() / 8); + } - if (mb.button_index == BUTTON_RIGHT && mb.pressed) { + if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed()) { - Point2 mpos = Point2(mb.x, mb.y) - ofs; + Point2 mpos = mb->get_pos() - ofs; - if (selection.size() == 0) { - // Auto-select on right-click if nothing is selected - // Note: This code is pretty much duplicated from the left click code, - // both codes could be moved into a function to avoid the duplicated code. - Point2 mpos = Point2(mb.x, mb.y) - ofs; + if (selection.size() == 0) { + // Auto-select on right-click if nothing is selected + // Note: This code is pretty much duplicated from the left click code, + // both codes could be moved into a function to avoid the duplicated code. + Point2 mpos = mb->get_pos() - ofs; - if (mpos.y < h) { - return; - } + if (mpos.y < h) { + return; + } - mpos.y -= h; + mpos.y -= h; - int idx = mpos.y / h; - idx += v_scroll->get_value(); - if (idx < 0 || idx >= animation->get_track_count()) - break; + int idx = mpos.y / h; + idx += v_scroll->get_value(); + if (idx < 0 || idx >= animation->get_track_count()) + return; - if (mpos.x < name_limit) { - } else if (mpos.x < settings_limit) { - float pos = mpos.x - name_limit; - pos /= _get_zoom_scale(); - pos += h_scroll->get_value(); - float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; + if (mpos.x < name_limit) { + } else if (mpos.x < settings_limit) { + float pos = mpos.x - name_limit; + pos /= _get_zoom_scale(); + pos += h_scroll->get_value(); + float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; - int kidx = animation->track_find_key(idx, pos); - int kidx_n = kidx + 1; - int key = -1; + int kidx = animation->track_find_key(idx, pos); + int kidx_n = kidx + 1; + int key = -1; - if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { + if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { - float kpos = animation->track_get_key_time(idx, kidx); - if (ABS(pos - kpos) <= w_time) { + float kpos = animation->track_get_key_time(idx, kidx); + if (ABS(pos - kpos) <= w_time) { - key = kidx; - } + key = kidx; } + } - if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { + if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { - float kpos = animation->track_get_key_time(idx, kidx_n); - if (ABS(pos - kpos) <= w_time) { + float kpos = animation->track_get_key_time(idx, kidx_n); + if (ABS(pos - kpos) <= w_time) { - key = kidx_n; - } + key = kidx_n; } + } - if (key == -1) { + if (key == -1) { - click.click = ClickOver::CLICK_SELECT_KEYS; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - click.shift = mb.mod.shift; - selected_track = idx; - track_editor->update(); - //drag select region - return; - } + click.click = ClickOver::CLICK_SELECT_KEYS; + click.at = mb->get_pos(); + click.to = click.at; + click.shift = mb->get_shift(); + selected_track = idx; + track_editor->update(); + //drag select region + return; + } - SelectedKey sk; - sk.track = idx; - sk.key = key; - KeyInfo ki; - ki.pos = animation->track_get_key_time(idx, key); - click.shift = mb.mod.shift; - click.selk = sk; + SelectedKey sk; + sk.track = idx; + sk.key = key; + KeyInfo ki; + ki.pos = animation->track_get_key_time(idx, key); + click.shift = mb->get_shift(); + click.selk = sk; - if (!mb.mod.shift && !selection.has(sk)) - _clear_selection(); + if (!mb->get_shift() && !selection.has(sk)) + _clear_selection(); - selection.insert(sk, ki); + selection.insert(sk, ki); - click.click = ClickOver::CLICK_MOVE_KEYS; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - update(); - selected_track = idx; - track_editor->update(); + click.click = ClickOver::CLICK_MOVE_KEYS; + click.at = mb->get_pos(); + click.to = click.at; + update(); + selected_track = idx; + track_editor->update(); - if (_edit_if_single_selection() && mb.mod.command) { - edit_button->set_pressed(true); - key_editor_tab->show(); - } + if (_edit_if_single_selection() && mb->get_command()) { + edit_button->set_pressed(true); + key_editor_tab->show(); } } + } - if (selection.size()) { - // User has right clicked and we have a selection, show a popup menu with options - track_menu->clear(); - track_menu->set_size(Point2(1, 1)); - track_menu->add_item(TTR("Duplicate Selection"), RIGHT_MENU_DUPLICATE); - track_menu->add_item(TTR("Duplicate Transposed"), RIGHT_MENU_DUPLICATE_TRANSPOSE); - track_menu->add_item(TTR("Remove Selection"), RIGHT_MENU_REMOVE); + if (selection.size()) { + // User has right clicked and we have a selection, show a popup menu with options + track_menu->clear(); + track_menu->set_size(Point2(1, 1)); + track_menu->add_item(TTR("Duplicate Selection"), RIGHT_MENU_DUPLICATE); + track_menu->add_item(TTR("Duplicate Transposed"), RIGHT_MENU_DUPLICATE_TRANSPOSE); + track_menu->add_item(TTR("Remove Selection"), RIGHT_MENU_REMOVE); - track_menu->set_position(te->get_global_position() + mpos); + track_menu->set_position(te->get_global_position() + mpos); - interp_editing = -1; - cont_editing = -1; - wrap_editing = -1; + interp_editing = -1; + cont_editing = -1; + wrap_editing = -1; - track_menu->popup(); - } + track_menu->popup(); } + } - if (mb.button_index == BUTTON_LEFT && !(mb.button_mask & ~BUTTON_MASK_LEFT)) { + if (mb->get_button_index() == BUTTON_LEFT && !(mb->get_button_mask() & ~BUTTON_MASK_LEFT)) { - if (mb.pressed) { + if (mb->is_pressed()) { - Point2 mpos = Point2(mb.x, mb.y) - ofs; + Point2 mpos = mb->get_pos() - ofs; - if (mpos.y < h) { + if (mpos.y < h) { - if (mpos.x < name_limit && mpos.x > (name_limit - hsep - hsize_icon->get_width())) { + if (mpos.x < name_limit && mpos.x > (name_limit - hsep - hsize_icon->get_width())) { - click.click = ClickOver::CLICK_RESIZE_NAMES; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - click.at.y = name_limit; - } + click.click = ClickOver::CLICK_RESIZE_NAMES; + click.at = mb->get_pos(); + click.to = click.at; + click.at.y = name_limit; + } - if (mpos.x >= name_limit && mpos.x < settings_limit) { - //seek - //int zoomw = settings_limit-name_limit; - float scale = _get_zoom_scale(); - float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale; - if (animation->get_step()) - pos = Math::stepify(pos, animation->get_step()); - - if (pos < 0) - pos = 0; - if (pos >= animation->get_length()) - pos = animation->get_length(); - timeline_pos = pos; - click.click = ClickOver::CLICK_DRAG_TIMELINE; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - emit_signal("timeline_changed", pos, false); - } + if (mpos.x >= name_limit && mpos.x < settings_limit) { + //seek + //int zoomw = settings_limit-name_limit; + float scale = _get_zoom_scale(); + float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale; + if (animation->get_step()) + pos = Math::stepify(pos, animation->get_step()); - return; + if (pos < 0) + pos = 0; + if (pos >= animation->get_length()) + pos = animation->get_length(); + timeline_pos = pos; + click.click = ClickOver::CLICK_DRAG_TIMELINE; + click.at = mb->get_pos(); + click.to = click.at; + emit_signal("timeline_changed", pos, false); } - mpos.y -= h; + return; + } - int idx = mpos.y / h; - idx += v_scroll->get_value(); - if (idx < 0) - break; + mpos.y -= h; - if (idx >= animation->get_track_count()) { + int idx = mpos.y / h; + idx += v_scroll->get_value(); + if (idx < 0) + return; - if (mpos.x >= name_limit && mpos.x < settings_limit) { + if (idx >= animation->get_track_count()) { - click.click = ClickOver::CLICK_SELECT_KEYS; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - //drag select region - } + if (mpos.x >= name_limit && mpos.x < settings_limit) { - break; + click.click = ClickOver::CLICK_SELECT_KEYS; + click.at = mb->get_pos(); + click.to = click.at; + //drag select region } - if (mpos.x < name_limit) { - //name column - - // area - if (idx != selected_track) { - - selected_track = idx; - track_editor->update(); - break; - } + return; + } - Rect2 area(ofs.x, ofs.y + ((int(mpos.y) / h) + 1) * h, name_limit, h); - track_name->set_text(animation->track_get_path(idx)); - track_name->set_position(te->get_global_position() + area.pos); - track_name->set_size(area.size); - track_name->show_modal(); - track_name->grab_focus(); - track_name->select_all(); - track_name_editing = idx; + if (mpos.x < name_limit) { + //name column - } else if (mpos.x < settings_limit) { + // area + if (idx != selected_track) { - float pos = mpos.x - name_limit; - pos /= _get_zoom_scale(); - pos += h_scroll->get_value(); - float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; + selected_track = idx; + track_editor->update(); + return; + } - int kidx = animation->track_find_key(idx, pos); - int kidx_n = kidx + 1; - int key = -1; + Rect2 area(ofs.x, ofs.y + ((int(mpos.y) / h) + 1) * h, name_limit, h); + track_name->set_text(animation->track_get_path(idx)); + track_name->set_position(te->get_global_position() + area.pos); + track_name->set_size(area.size); + track_name->show_modal(); + track_name->grab_focus(); + track_name->select_all(); + track_name_editing = idx; - if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { + } else if (mpos.x < settings_limit) { - float kpos = animation->track_get_key_time(idx, kidx); - if (ABS(pos - kpos) <= w_time) { + float pos = mpos.x - name_limit; + pos /= _get_zoom_scale(); + pos += h_scroll->get_value(); + float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; - key = kidx; - } - } + int kidx = animation->track_find_key(idx, pos); + int kidx_n = kidx + 1; + int key = -1; - if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { + if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { - float kpos = animation->track_get_key_time(idx, kidx_n); - if (ABS(pos - kpos) <= w_time) { + float kpos = animation->track_get_key_time(idx, kidx); + if (ABS(pos - kpos) <= w_time) { - key = kidx_n; - } + key = kidx; } + } - if (key == -1) { + if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { - click.click = ClickOver::CLICK_SELECT_KEYS; - click.at = Point2(mb.x, mb.y); - click.to = click.at; - click.shift = mb.mod.shift; - selected_track = idx; - track_editor->update(); - //drag select region - return; - } - - SelectedKey sk; - sk.track = idx; - sk.key = key; - KeyInfo ki; - ki.pos = animation->track_get_key_time(idx, key); - click.shift = mb.mod.shift; - click.selk = sk; + float kpos = animation->track_get_key_time(idx, kidx_n); + if (ABS(pos - kpos) <= w_time) { - if (!mb.mod.shift && !selection.has(sk)) - _clear_selection(); + key = kidx_n; + } + } - selection.insert(sk, ki); + if (key == -1) { - click.click = ClickOver::CLICK_MOVE_KEYS; - click.at = Point2(mb.x, mb.y); + click.click = ClickOver::CLICK_SELECT_KEYS; + click.at = mb->get_pos(); click.to = click.at; - update(); + click.shift = mb->get_shift(); selected_track = idx; track_editor->update(); + //drag select region + return; + } - if (_edit_if_single_selection() && mb.mod.command) { - edit_button->set_pressed(true); - key_editor_tab->show(); - } - } else { - //button column - int ofsx = size.width - mpos.x; - if (ofsx < 0) - break; - /* - if (ofsx < remove_icon->get_width()) { - - undo_redo->create_action("Remove Anim Track"); - undo_redo->add_do_method(animation.ptr(),"remove_track",idx); - undo_redo->add_undo_method(animation.ptr(),"add_track",animation->track_get_type(idx),idx); - undo_redo->add_undo_method(animation.ptr(),"track_set_path",idx,animation->track_get_path(idx)); - //todo interpolation - for(int i=0;i<animation->track_get_key_count(idx);i++) { + SelectedKey sk; + sk.track = idx; + sk.key = key; + KeyInfo ki; + ki.pos = animation->track_get_key_time(idx, key); + click.shift = mb->get_shift(); + click.selk = sk; - Variant v = animation->track_get_key_value(idx,i); - float time = animation->track_get_key_time(idx,i); - float trans = animation->track_get_key_transition(idx,i); + if (!mb->get_shift() && !selection.has(sk)) + _clear_selection(); - undo_redo->add_undo_method(animation.ptr(),"track_insert_key",idx,time,v); - undo_redo->add_undo_method(animation.ptr(),"track_set_key_transition",idx,i,trans); + selection.insert(sk, ki); - } + click.click = ClickOver::CLICK_MOVE_KEYS; + click.at = mb->get_pos(); + click.to = click.at; + update(); + selected_track = idx; + track_editor->update(); - undo_redo->add_undo_method(animation.ptr(),"track_set_interpolation_type",idx,animation->track_get_interpolation_type(idx)); - if (animation->track_get_type(idx)==Animation::TYPE_VALUE) { - undo_redo->add_undo_method(animation.ptr(),"value_track_set_continuous",idx,animation->value_track_is_continuous(idx)); + if (_edit_if_single_selection() && mb->get_command()) { + edit_button->set_pressed(true); + key_editor_tab->show(); + } + } else { + //button column + int ofsx = size.width - mpos.x; + if (ofsx < 0) + return; + /* + if (ofsx < remove_icon->get_width()) { - } + undo_redo->create_action("Remove Anim Track"); + undo_redo->add_do_method(animation.ptr(),"remove_track",idx); + undo_redo->add_undo_method(animation.ptr(),"add_track",animation->track_get_type(idx),idx); + undo_redo->add_undo_method(animation.ptr(),"track_set_path",idx,animation->track_get_path(idx)); + //todo interpolation + for(int i=0;i<animation->track_get_key_count(idx);i++) { - undo_redo->commit_action(); + Variant v = animation->track_get_key_value(idx,i); + float time = animation->track_get_key_time(idx,i); + float trans = animation->track_get_key_transition(idx,i); + undo_redo->add_undo_method(animation.ptr(),"track_insert_key",idx,time,v); + undo_redo->add_undo_method(animation.ptr(),"track_set_key_transition",idx,i,trans); - return; } - ofsx-=hsep+remove_icon->get_width(); - - if (ofsx < move_down_icon->get_width()) { + undo_redo->add_undo_method(animation.ptr(),"track_set_interpolation_type",idx,animation->track_get_interpolation_type(idx)); + if (animation->track_get_type(idx)==Animation::TYPE_VALUE) { + undo_redo->add_undo_method(animation.ptr(),"value_track_set_continuous",idx,animation->value_track_is_continuous(idx)); - if (idx < animation->get_track_count() -1) { - undo_redo->create_action("Move Anim Track Down"); - undo_redo->add_do_method(animation.ptr(),"track_move_up",idx); - undo_redo->add_undo_method(animation.ptr(),"track_move_down",idx+1); - undo_redo->commit_action(); - } - return; } - ofsx-=hsep+move_down_icon->get_width(); + undo_redo->commit_action(); - if (ofsx < move_up_icon->get_width()) { - if (idx >0) { - undo_redo->create_action("Move Anim Track Up"); - undo_redo->add_do_method(animation.ptr(),"track_move_down",idx); - undo_redo->add_undo_method(animation.ptr(),"track_move_up",idx-1); - undo_redo->commit_action(); - } - return; - } + return; + } + ofsx-=hsep+remove_icon->get_width(); - ofsx-=hsep*3+move_up_icon->get_width(); - */ + if (ofsx < move_down_icon->get_width()) { - if (ofsx < track_ofs[1]) { + if (idx < animation->get_track_count() -1) { + undo_redo->create_action("Move Anim Track Down"); + undo_redo->add_do_method(animation.ptr(),"track_move_up",idx); + undo_redo->add_undo_method(animation.ptr(),"track_move_down",idx+1); + undo_redo->commit_action(); + } + return; + } - track_menu->clear(); - track_menu->set_size(Point2(1, 1)); - static const char *interp_name[2] = { "Clamp Loop Interp", "Wrap Loop Interp" }; - for (int i = 0; i < 2; i++) { - track_menu->add_icon_item(wrap_icon[i], interp_name[i]); - } + ofsx-=hsep+move_down_icon->get_width(); - int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; - int popup_x = size.width - track_ofs[1]; + if (ofsx < move_up_icon->get_width()) { - track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); + if (idx >0) { + undo_redo->create_action("Move Anim Track Up"); + undo_redo->add_do_method(animation.ptr(),"track_move_down",idx); + undo_redo->add_undo_method(animation.ptr(),"track_move_up",idx-1); + undo_redo->commit_action(); + } + return; + } - wrap_editing = idx; - interp_editing = -1; - cont_editing = -1; - track_menu->popup(); + ofsx-=hsep*3+move_up_icon->get_width(); + */ - return; + if (ofsx < track_ofs[1]) { + + track_menu->clear(); + track_menu->set_size(Point2(1, 1)); + static const char *interp_name[2] = { "Clamp Loop Interp", "Wrap Loop Interp" }; + for (int i = 0; i < 2; i++) { + track_menu->add_icon_item(wrap_icon[i], interp_name[i]); } - if (ofsx < track_ofs[2]) { + int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; + int popup_x = size.width - track_ofs[1]; - track_menu->clear(); - track_menu->set_size(Point2(1, 1)); - static const char *interp_name[3] = { "Nearest", "Linear", "Cubic" }; - for (int i = 0; i < 3; i++) { - track_menu->add_icon_item(interp_icon[i], interp_name[i]); - } + track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); - int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; - int popup_x = size.width - track_ofs[2]; + wrap_editing = idx; + interp_editing = -1; + cont_editing = -1; - track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); + track_menu->popup(); - interp_editing = idx; - cont_editing = -1; - wrap_editing = -1; + return; + } - track_menu->popup(); + if (ofsx < track_ofs[2]) { - return; + track_menu->clear(); + track_menu->set_size(Point2(1, 1)); + static const char *interp_name[3] = { "Nearest", "Linear", "Cubic" }; + for (int i = 0; i < 3; i++) { + track_menu->add_icon_item(interp_icon[i], interp_name[i]); } - if (ofsx < track_ofs[3]) { + int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; + int popup_x = size.width - track_ofs[2]; - track_menu->clear(); - track_menu->set_size(Point2(1, 1)); - String cont_name[3] = { TTR("Continuous"), TTR("Discrete"), TTR("Trigger") }; - for (int i = 0; i < 3; i++) { - track_menu->add_icon_item(cont_icon[i], cont_name[i]); - } + track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); - int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; - int popup_x = size.width - track_ofs[3]; + interp_editing = idx; + cont_editing = -1; + wrap_editing = -1; - track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); + track_menu->popup(); - interp_editing = -1; - wrap_editing = -1; - cont_editing = idx; + return; + } - track_menu->popup(); + if (ofsx < track_ofs[3]) { - return; + track_menu->clear(); + track_menu->set_size(Point2(1, 1)); + String cont_name[3] = { TTR("Continuous"), TTR("Discrete"), TTR("Trigger") }; + for (int i = 0; i < 3; i++) { + track_menu->add_icon_item(cont_icon[i], cont_name[i]); } - if (ofsx < track_ofs[4]) { + int popup_y = ofs.y + ((int(mpos.y) / h) + 2) * h; + int popup_x = size.width - track_ofs[3]; - Animation::TrackType tt = animation->track_get_type(idx); + track_menu->set_position(te->get_global_position() + Point2(popup_x, popup_y)); - float pos = timeline_pos; - int existing = animation->track_find_key(idx, pos, true); + interp_editing = -1; + wrap_editing = -1; + cont_editing = idx; - Variant newval; + track_menu->popup(); - if (tt == Animation::TYPE_TRANSFORM) { - Dictionary d; - d["loc"] = Vector3(); - d["rot"] = Quat(); - d["scale"] = Vector3(); - newval = d; + return; + } - } else if (tt == Animation::TYPE_METHOD) { + if (ofsx < track_ofs[4]) { - Dictionary d; - d["method"] = ""; - d["args"] = Vector<Variant>(); + Animation::TrackType tt = animation->track_get_type(idx); - newval = d; - } else if (tt == Animation::TYPE_VALUE) { + float pos = timeline_pos; + int existing = animation->track_find_key(idx, pos, true); - NodePath np; - PropertyInfo inf = _find_hint_for_track(idx, np); - if (inf.type != Variant::NIL) { + Variant newval; - Variant::CallError err; - newval = Variant::construct(inf.type, NULL, 0, err); - } + if (tt == Animation::TYPE_TRANSFORM) { + Dictionary d; + d["loc"] = Vector3(); + d["rot"] = Quat(); + d["scale"] = Vector3(); + newval = d; - if (newval.get_type() == Variant::NIL) { - //popup a new type - cvi_track = idx; - cvi_pos = pos; + } else if (tt == Animation::TYPE_METHOD) { - type_menu->set_position(get_global_position() + mpos + ofs); - type_menu->popup(); - return; - } - } + Dictionary d; + d["method"] = ""; + d["args"] = Vector<Variant>(); - undo_redo->create_action(TTR("Anim Add Key")); + newval = d; + } else if (tt == Animation::TYPE_VALUE) { - undo_redo->add_do_method(animation.ptr(), "track_insert_key", idx, pos, newval, 1); - undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_pos", idx, pos); + NodePath np; + PropertyInfo inf = _find_hint_for_track(idx, np); + if (inf.type != Variant::NIL) { - if (existing != -1) { - Variant v = animation->track_get_key_value(idx, existing); - float trans = animation->track_get_key_transition(idx, existing); - undo_redo->add_undo_method(animation.ptr(), "track_insert_key", idx, pos, v, trans); + Variant::CallError err; + newval = Variant::construct(inf.type, NULL, 0, err); } - undo_redo->commit_action(); + if (newval.get_type() == Variant::NIL) { + //popup a new type + cvi_track = idx; + cvi_pos = pos; - return; + type_menu->set_position(get_global_position() + mpos + ofs); + type_menu->popup(); + return; + } } - } - } else { + undo_redo->create_action(TTR("Anim Add Key")); - switch (click.click) { - case ClickOver::CLICK_SELECT_KEYS: { + undo_redo->add_do_method(animation.ptr(), "track_insert_key", idx, pos, newval, 1); + undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_pos", idx, pos); - float zoom_scale = _get_zoom_scale(); - float keys_from = h_scroll->get_value(); - float keys_to = keys_from + (settings_limit - name_limit) / zoom_scale; + if (existing != -1) { + Variant v = animation->track_get_key_value(idx, existing); + float trans = animation->track_get_key_transition(idx, existing); + undo_redo->add_undo_method(animation.ptr(), "track_insert_key", idx, pos, v, trans); + } - float from_time = keys_from + (click.at.x - (name_limit + ofs.x)) / zoom_scale; - float to_time = keys_from + (click.to.x - (name_limit + ofs.x)) / zoom_scale; + undo_redo->commit_action(); - if (to_time < from_time) - SWAP(from_time, to_time); + return; + } + } - if (from_time > keys_to || to_time < keys_from) - break; + } else { - if (from_time < keys_from) - from_time = keys_from; + switch (click.click) { + case ClickOver::CLICK_SELECT_KEYS: { - if (to_time >= keys_to) - to_time = keys_to; + float zoom_scale = _get_zoom_scale(); + float keys_from = h_scroll->get_value(); + float keys_to = keys_from + (settings_limit - name_limit) / zoom_scale; - int from_track = int(click.at.y - ofs.y - h - sep) / h + v_scroll->get_value(); - int to_track = int(click.to.y - ofs.y - h - sep) / h + v_scroll->get_value(); - int from_mod = int(click.at.y - ofs.y - sep) % h; - int to_mod = int(click.to.y - ofs.y - sep) % h; + float from_time = keys_from + (click.at.x - (name_limit + ofs.x)) / zoom_scale; + float to_time = keys_from + (click.to.x - (name_limit + ofs.x)) / zoom_scale; - if (to_track < from_track) { + if (to_time < from_time) + SWAP(from_time, to_time); - SWAP(from_track, to_track); - SWAP(from_mod, to_mod); - } + if (from_time > keys_to || to_time < keys_from) + break; - if ((from_mod > (h / 2)) && ((click.at.y - ofs.y) >= (h + sep))) { - from_track++; - } + if (from_time < keys_from) + from_time = keys_from; - if (to_mod < h / 2) { - to_track--; - } + if (to_time >= keys_to) + to_time = keys_to; - if (from_track > to_track) { - if (!click.shift) - _clear_selection(); - _edit_if_single_selection(); - break; - } + int from_track = int(click.at.y - ofs.y - h - sep) / h + v_scroll->get_value(); + int to_track = int(click.to.y - ofs.y - h - sep) / h + v_scroll->get_value(); + int from_mod = int(click.at.y - ofs.y - sep) % h; + int to_mod = int(click.to.y - ofs.y - sep) % h; + + if (to_track < from_track) { - int tracks_from = v_scroll->get_value(); - int tracks_to = v_scroll->get_value() + fit - 1; - if (tracks_to >= animation->get_track_count()) - tracks_to = animation->get_track_count() - 1; + SWAP(from_track, to_track); + SWAP(from_mod, to_mod); + } + + if ((from_mod > (h / 2)) && ((click.at.y - ofs.y) >= (h + sep))) { + from_track++; + } - tracks_from = 0; + if (to_mod < h / 2) { + to_track--; + } + + if (from_track > to_track) { + if (!click.shift) + _clear_selection(); + _edit_if_single_selection(); + break; + } + + int tracks_from = v_scroll->get_value(); + int tracks_to = v_scroll->get_value() + fit - 1; + if (tracks_to >= animation->get_track_count()) tracks_to = animation->get_track_count() - 1; - if (to_track > tracks_to) - to_track = tracks_to; - if (from_track < tracks_from) - from_track = tracks_from; - - if (from_track > tracks_to || to_track < tracks_from) { - if (!click.shift) - _clear_selection(); - _edit_if_single_selection(); - break; - } + tracks_from = 0; + tracks_to = animation->get_track_count() - 1; + if (to_track > tracks_to) + to_track = tracks_to; + if (from_track < tracks_from) + from_track = tracks_from; + + if (from_track > tracks_to || to_track < tracks_from) { if (!click.shift) _clear_selection(); + _edit_if_single_selection(); + break; + } - int higher_track = 0x7FFFFFFF; - for (int i = from_track; i <= to_track; i++) { + if (!click.shift) + _clear_selection(); - int kc = animation->track_get_key_count(i); - for (int j = 0; j < kc; j++) { + int higher_track = 0x7FFFFFFF; + for (int i = from_track; i <= to_track; i++) { - float t = animation->track_get_key_time(i, j); - if (t < from_time) - continue; - if (t > to_time) - break; + int kc = animation->track_get_key_count(i); + for (int j = 0; j < kc; j++) { - if (i < higher_track) - higher_track = i; + float t = animation->track_get_key_time(i, j); + if (t < from_time) + continue; + if (t > to_time) + break; - SelectedKey sk; - sk.track = i; - sk.key = j; - KeyInfo ki; - ki.pos = t; - selection[sk] = ki; - } - } + if (i < higher_track) + higher_track = i; - if (higher_track != 0x7FFFFFFF) { - selected_track = higher_track; - track_editor->update(); + SelectedKey sk; + sk.track = i; + sk.key = j; + KeyInfo ki; + ki.pos = t; + selection[sk] = ki; } + } - _edit_if_single_selection(); + if (higher_track != 0x7FFFFFFF) { + selected_track = higher_track; + track_editor->update(); + } - } break; - case ClickOver::CLICK_MOVE_KEYS: { + _edit_if_single_selection(); - if (selection.empty()) - break; - if (click.at == click.to) { + } break; + case ClickOver::CLICK_MOVE_KEYS: { - if (!click.shift) { + if (selection.empty()) + break; + if (click.at == click.to) { - KeyInfo ki = selection[click.selk]; - _clear_selection(); - selection[click.selk] = ki; - _edit_if_single_selection(); - } + if (!click.shift) { - break; + KeyInfo ki = selection[click.selk]; + _clear_selection(); + selection[click.selk] = ki; + _edit_if_single_selection(); } - float from_t = 1e20; + break; + } - for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) { - float t = animation->track_get_key_time(E->key().track, E->key().key); - if (t < from_t) - from_t = t; - } + float from_t = 1e20; - float motion = from_t + (click.to.x - click.at.x) / _get_zoom_scale(); - if (step->get_value()) - motion = Math::stepify(motion, step->get_value()); + for (Map<SelectedKey, KeyInfo>::Element *E = selection.front(); E; E = E->next()) { + float t = animation->track_get_key_time(E->key().track, E->key().key); + if (t < from_t) + from_t = t; + } - undo_redo->create_action(TTR("Anim Move Keys")); + float motion = from_t + (click.to.x - click.at.x) / _get_zoom_scale(); + if (step->get_value()) + motion = Math::stepify(motion, step->get_value()); - List<_AnimMoveRestore> to_restore; + undo_redo->create_action(TTR("Anim Move Keys")); - // 1-remove the keys - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + List<_AnimMoveRestore> to_restore; - undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key); - } - // 2- remove overlapped keys - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + // 1-remove the keys + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { - float newtime = E->get().pos - from_t + motion; - int idx = animation->track_find_key(E->key().track, newtime, true); - if (idx == -1) - continue; - SelectedKey sk; - sk.key = idx; - sk.track = E->key().track; - if (selection.has(sk)) - continue; //already in selection, don't save + undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key); + } + // 2- remove overlapped keys + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + + float newtime = E->get().pos - from_t + motion; + int idx = animation->track_find_key(E->key().track, newtime, true); + if (idx == -1) + continue; + SelectedKey sk; + sk.key = idx; + sk.track = E->key().track; + if (selection.has(sk)) + continue; //already in selection, don't save + + undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newtime); + _AnimMoveRestore amr; + + amr.key = animation->track_get_key_value(E->key().track, idx); + amr.track = E->key().track; + amr.time = newtime; + amr.transition = animation->track_get_key_transition(E->key().track, idx); + + to_restore.push_back(amr); + } - undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newtime); - _AnimMoveRestore amr; + // 3-move the keys (re insert them) + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { - amr.key = animation->track_get_key_value(E->key().track, idx); - amr.track = E->key().track; - amr.time = newtime; - amr.transition = animation->track_get_key_transition(E->key().track, idx); + float newpos = E->get().pos - from_t + motion; + /* + if (newpos<0) + continue; //no add at the beginning + */ + undo_redo->add_do_method(animation.ptr(), "track_insert_key", E->key().track, newpos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key)); + } - to_restore.push_back(amr); - } + // 4-(undo) remove inserted keys + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { - // 3-move the keys (re insert them) - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + float newpos = E->get().pos + -from_t + motion; + /* + if (newpos<0) + continue; //no remove what no inserted + */ + undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newpos); + } - float newpos = E->get().pos - from_t + motion; - /* - if (newpos<0) - continue; //no add at the beginning - */ - undo_redo->add_do_method(animation.ptr(), "track_insert_key", E->key().track, newpos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key)); - } + // 5-(undo) reinsert keys + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { - // 4-(undo) remove inserted keys - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key)); + } - float newpos = E->get().pos + -from_t + motion; - /* - if (newpos<0) - continue; //no remove what no inserted - */ - undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newpos); - } + // 6-(undo) reinsert overlapped keys + for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) { - // 5-(undo) reinsert keys - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + _AnimMoveRestore &amr = E->get(); + undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition); + } - undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key)); - } + // 6-(undo) reinsert overlapped keys + for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) { - // 6-(undo) reinsert overlapped keys - for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) { + _AnimMoveRestore &amr = E->get(); + undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition); + } - _AnimMoveRestore &amr = E->get(); - undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition); - } + undo_redo->add_do_method(this, "_clear_selection_for_anim", animation); + undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation); - // 6-(undo) reinsert overlapped keys - for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) { + // 7-reselect - _AnimMoveRestore &amr = E->get(); - undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition); - } + for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { - undo_redo->add_do_method(this, "_clear_selection_for_anim", animation); - undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation); + float oldpos = E->get().pos; + float newpos = oldpos - from_t + motion; + //if (newpos>=0) + undo_redo->add_do_method(this, "_select_at_anim", animation, E->key().track, newpos); + undo_redo->add_undo_method(this, "_select_at_anim", animation, E->key().track, oldpos); + } - // 7-reselect + undo_redo->commit_action(); + _edit_if_single_selection(); - for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) { + } break; + default: {} + } - float oldpos = E->get().pos; - float newpos = oldpos - from_t + motion; - //if (newpos>=0) - undo_redo->add_do_method(this, "_select_at_anim", animation, E->key().track, newpos); - undo_redo->add_undo_method(this, "_select_at_anim", animation, E->key().track, oldpos); - } + //button released + click.click = ClickOver::CLICK_NONE; + track_editor->update(); + } + } + } - undo_redo->commit_action(); - _edit_if_single_selection(); + Ref<InputEventMouseMotion> mm = p_input; - } break; - default: {} - } + if (mm.is_valid()) { - //button released - click.click = ClickOver::CLICK_NONE; - track_editor->update(); - } - } + mouse_over.over = MouseOver::OVER_NONE; + mouse_over.track = -1; + te->update(); + track_editor->set_tooltip(""); - } break; + if (!track_editor->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field())) + track_editor->call_deferred("grab_focus"); - case InputEvent::MOUSE_MOTION: { + if (click.click != ClickOver::CLICK_NONE) { - const InputEventMouseMotion &mb = p_input.mouse_motion; + switch (click.click) { + case ClickOver::CLICK_RESIZE_NAMES: { - mouse_over.over = MouseOver::OVER_NONE; - mouse_over.track = -1; - te->update(); - track_editor->set_tooltip(""); + float base = click.at.y; + float clickp = click.at.x - ofs.x; + float dif = base - clickp; - if (!track_editor->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field())) - track_editor->call_deferred("grab_focus"); + float target = mb->get_pos().x + dif - ofs.x; - if (click.click != ClickOver::CLICK_NONE) { + float ratio = target / settings_limit; - switch (click.click) { - case ClickOver::CLICK_RESIZE_NAMES: { + if (ratio > 0.9) + ratio = 0.9; + else if (ratio < 0.2) + ratio = 0.2; - float base = click.at.y; - float clickp = click.at.x - ofs.x; - float dif = base - clickp; + name_column_ratio = ratio; - float target = mb.x + dif - ofs.x; + } break; + case ClickOver::CLICK_DRAG_TIMELINE: { - float ratio = target / settings_limit; + Point2 mpos = mb->get_pos() - ofs; + /* + if (mpos.x<name_limit) + mpos.x=name_limit; + if (mpos.x>settings_limit) + mpos.x=settings_limit; + */ - if (ratio > 0.9) - ratio = 0.9; - else if (ratio < 0.2) - ratio = 0.2; + //int zoomw = settings_limit-name_limit; + float scale = _get_zoom_scale(); + float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale; + if (animation->get_step()) { + pos = Math::stepify(pos, animation->get_step()); + } + if (pos < 0) + pos = 0; + if (pos >= animation->get_length()) + pos = animation->get_length(); + + if (pos < h_scroll->get_value()) { + h_scroll->set_value(pos); + } else if (pos > h_scroll->get_value() + (settings_limit - name_limit) / scale) { + h_scroll->set_value(pos - (settings_limit - name_limit) / scale); + } - name_column_ratio = ratio; + timeline_pos = pos; + emit_signal("timeline_changed", pos, true); - } break; - case ClickOver::CLICK_DRAG_TIMELINE: { - - Point2 mpos = Point2(mb.x, mb.y) - ofs; - /* - if (mpos.x<name_limit) - mpos.x=name_limit; - if (mpos.x>settings_limit) - mpos.x=settings_limit; - */ + } break; + case ClickOver::CLICK_SELECT_KEYS: { - //int zoomw = settings_limit-name_limit; - float scale = _get_zoom_scale(); - float pos = h_scroll->get_value() + (mpos.x - name_limit) / scale; - if (animation->get_step()) { - pos = Math::stepify(pos, animation->get_step()); - } - if (pos < 0) - pos = 0; - if (pos >= animation->get_length()) - pos = animation->get_length(); + click.to = mb->get_pos(); + if (click.to.y < h && click.at.y > h && mm->get_relative().y < 0) { - if (pos < h_scroll->get_value()) { - h_scroll->set_value(pos); - } else if (pos > h_scroll->get_value() + (settings_limit - name_limit) / scale) { - h_scroll->set_value(pos - (settings_limit - name_limit) / scale); - } + float prev = v_scroll->get_value(); + v_scroll->set_value(v_scroll->get_value() - 1); + if (prev != v_scroll->get_value()) + click.at.y += h; + } + if (click.to.y > size.height && click.at.y < size.height && mm->get_relative().y > 0) { - timeline_pos = pos; - emit_signal("timeline_changed", pos, true); + float prev = v_scroll->get_value(); + v_scroll->set_value(v_scroll->get_value() + 1); + if (prev != v_scroll->get_value()) + click.at.y -= h; + } - } break; - case ClickOver::CLICK_SELECT_KEYS: { + } break; + case ClickOver::CLICK_MOVE_KEYS: { - click.to = Point2(mb.x, mb.y); - if (click.to.y < h && click.at.y > h && mb.relative_y < 0) { + click.to = mb->get_pos(); + } break; + default: {} + } - float prev = v_scroll->get_value(); - v_scroll->set_value(v_scroll->get_value() - 1); - if (prev != v_scroll->get_value()) - click.at.y += h; - } - if (click.to.y > size.height && click.at.y < size.height && mb.relative_y > 0) { + return; + } else if (mb->get_button_mask() & BUTTON_MASK_MIDDLE) { - float prev = v_scroll->get_value(); - v_scroll->set_value(v_scroll->get_value() + 1); - if (prev != v_scroll->get_value()) - click.at.y -= h; - } + int rel = mm->get_relative().x; + float relf = rel / _get_zoom_scale(); + h_scroll->set_value(h_scroll->get_value() - relf); + } - } break; - case ClickOver::CLICK_MOVE_KEYS: { + if (mb->get_button_mask() == 0) { - click.to = Point2(mb.x, mb.y); - } break; - default: {} - } + Point2 mpos = mb->get_pos() - ofs; + if (mpos.y < h) { +#if 0 + //seek + //int zoomw = settings_limit-name_limit; + float scale = _get_zoom_scale(); + float pos = h_scroll->get_val() + (mpos.y-name_limit) / scale; + if (pos<0 ) + pos=0; + if (pos>=animation->get_length()) + pos=animation->get_length(); + timeline->set_val(pos); +#endif return; - } else if (mb.button_mask & BUTTON_MASK_MIDDLE) { - - int rel = mb.relative_x; - float relf = rel / _get_zoom_scale(); - h_scroll->set_value(h_scroll->get_value() - relf); } - if (mb.button_mask == 0) { + mpos.y -= h; - Point2 mpos = Point2(mb.x, mb.y) - ofs; + int idx = mpos.y / h; + idx += v_scroll->get_value(); + if (idx < 0 || idx >= animation->get_track_count()) + return; - if (mpos.y < h) { -#if 0 - //seek - //int zoomw = settings_limit-name_limit; - float scale = _get_zoom_scale(); - float pos = h_scroll->get_val() + (mpos.y-name_limit) / scale; - if (pos<0 ) - pos=0; - if (pos>=animation->get_length()) - pos=animation->get_length(); - timeline->set_val(pos); -#endif - return; - } + mouse_over.track = idx; - mpos.y -= h; + if (mpos.x < name_limit) { + //name column - int idx = mpos.y / h; - idx += v_scroll->get_value(); - if (idx < 0 || idx >= animation->get_track_count()) - break; + mouse_over.over = MouseOver::OVER_NAME; - mouse_over.track = idx; + } else if (mpos.x < settings_limit) { - if (mpos.x < name_limit) { - //name column + float pos = mpos.x - name_limit; + pos /= _get_zoom_scale(); + pos += h_scroll->get_value(); + float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; - mouse_over.over = MouseOver::OVER_NAME; + int kidx = animation->track_find_key(idx, pos); + int kidx_n = kidx + 1; - } else if (mpos.x < settings_limit) { + bool found = false; - float pos = mpos.x - name_limit; - pos /= _get_zoom_scale(); - pos += h_scroll->get_value(); - float w_time = (type_icon[0]->get_width() / _get_zoom_scale()) / 2.0; + if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { - int kidx = animation->track_find_key(idx, pos); - int kidx_n = kidx + 1; + float kpos = animation->track_get_key_time(idx, kidx); + if (ABS(pos - kpos) <= w_time) { - bool found = false; + mouse_over.over = MouseOver::OVER_KEY; + mouse_over.track = idx; + mouse_over.over_key = kidx; + found = true; + } + } - if (kidx >= 0 && kidx < animation->track_get_key_count(idx)) { + if (!found && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { - float kpos = animation->track_get_key_time(idx, kidx); - if (ABS(pos - kpos) <= w_time) { + float kpos = animation->track_get_key_time(idx, kidx_n); + if (ABS(pos - kpos) <= w_time) { - mouse_over.over = MouseOver::OVER_KEY; - mouse_over.track = idx; - mouse_over.over_key = kidx; - found = true; - } + mouse_over.over = MouseOver::OVER_KEY; + mouse_over.track = idx; + mouse_over.over_key = kidx_n; + found = true; } + } - if (!found && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) { + if (found) { - float kpos = animation->track_get_key_time(idx, kidx_n); - if (ABS(pos - kpos) <= w_time) { + String text; + text = "time: " + rtos(animation->track_get_key_time(idx, mouse_over.over_key)) + "\n"; - mouse_over.over = MouseOver::OVER_KEY; - mouse_over.track = idx; - mouse_over.over_key = kidx_n; - found = true; - } - } + switch (animation->track_get_type(idx)) { - if (found) { - - String text; - text = "time: " + rtos(animation->track_get_key_time(idx, mouse_over.over_key)) + "\n"; - - switch (animation->track_get_type(idx)) { - - case Animation::TYPE_TRANSFORM: { - - Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key); - if (d.has("loc")) - text += "loc: " + String(d["loc"]) + "\n"; - if (d.has("rot")) - text += "rot: " + String(d["rot"]) + "\n"; - if (d.has("scale")) - text += "scale: " + String(d["scale"]) + "\n"; - } break; - case Animation::TYPE_VALUE: { - - Variant v = animation->track_get_key_value(idx, mouse_over.over_key); - //text+="value: "+String(v)+"\n"; - - bool prop_exists = false; - Variant::Type valid_type = Variant::NIL; - Object *obj = NULL; - - RES res; - Node *node = root->get_node_and_resource(animation->track_get_path(idx), res); - - if (res.is_valid()) { - obj = res.ptr(); - } else if (node) { - obj = node; - } - - if (obj) { - valid_type = obj->get_static_property_type(animation->track_get_path(idx).get_property(), &prop_exists); - } - - text += "type: " + Variant::get_type_name(v.get_type()) + "\n"; - if (prop_exists && !Variant::can_convert(v.get_type(), valid_type)) { - text += "value: " + String(v) + " (Invalid, expected type: " + Variant::get_type_name(valid_type) + ")\n"; - } else { - text += "value: " + String(v) + "\n"; - } - - } break; - case Animation::TYPE_METHOD: { - - Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key); - if (d.has("method")) - text += String(d["method"]); - text += "("; - Vector<Variant> args; - if (d.has("args")) - args = d["args"]; - for (int i = 0; i < args.size(); i++) { - - if (i > 0) - text += ", "; - text += String(args[i]); - } - text += ")\n"; - - } break; - } - text += "easing: " + rtos(animation->track_get_key_transition(idx, mouse_over.over_key)); + case Animation::TYPE_TRANSFORM: { - track_editor->set_tooltip(text); - return; - } + Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key); + if (d.has("loc")) + text += "loc: " + String(d["loc"]) + "\n"; + if (d.has("rot")) + text += "rot: " + String(d["rot"]) + "\n"; + if (d.has("scale")) + text += "scale: " + String(d["scale"]) + "\n"; + } break; + case Animation::TYPE_VALUE: { - } else { - //button column - int ofsx = size.width - mpos.x; - if (ofsx < 0) - break; - /* - if (ofsx < remove_icon->get_width()) { + Variant v = animation->track_get_key_value(idx, mouse_over.over_key); + //text+="value: "+String(v)+"\n"; - mouse_over.over=MouseOver::OVER_REMOVE; + bool prop_exists = false; + Variant::Type valid_type = Variant::NIL; + Object *obj = NULL; - return; - } + RES res; + Node *node = root->get_node_and_resource(animation->track_get_path(idx), res); - ofsx-=hsep+remove_icon->get_width(); + if (res.is_valid()) { + obj = res.ptr(); + } else if (node) { + obj = node; + } - if (ofsx < move_down_icon->get_width()) { + if (obj) { + valid_type = obj->get_static_property_type(animation->track_get_path(idx).get_property(), &prop_exists); + } - mouse_over.over=MouseOver::OVER_DOWN; - return; + text += "type: " + Variant::get_type_name(v.get_type()) + "\n"; + if (prop_exists && !Variant::can_convert(v.get_type(), valid_type)) { + text += "value: " + String(v) + " (Invalid, expected type: " + Variant::get_type_name(valid_type) + ")\n"; + } else { + text += "value: " + String(v) + "\n"; + } + + } break; + case Animation::TYPE_METHOD: { + + Dictionary d = animation->track_get_key_value(idx, mouse_over.over_key); + if (d.has("method")) + text += String(d["method"]); + text += "("; + Vector<Variant> args; + if (d.has("args")) + args = d["args"]; + for (int i = 0; i < args.size(); i++) { + + if (i > 0) + text += ", "; + text += String(args[i]); + } + text += ")\n"; + + } break; } + text += "easing: " + rtos(animation->track_get_key_transition(idx, mouse_over.over_key)); - ofsx-=hsep+move_down_icon->get_width(); + track_editor->set_tooltip(text); + return; + } - if (ofsx < move_up_icon->get_width()) { + } else { + //button column + int ofsx = size.width - mpos.x; + if (ofsx < 0) + return; + /* + if (ofsx < remove_icon->get_width()) { - mouse_over.over=MouseOver::OVER_UP; - return; - } + mouse_over.over=MouseOver::OVER_REMOVE; - ofsx-=hsep*3+move_up_icon->get_width(); + return; + } - */ + ofsx-=hsep+remove_icon->get_width(); - if (ofsx < down_icon->get_width() + wrap_icon[0]->get_width() + hsep * 3) { + if (ofsx < move_down_icon->get_width()) { - mouse_over.over = MouseOver::OVER_WRAP; - return; - } + mouse_over.over=MouseOver::OVER_DOWN; + return; + } - ofsx -= hsep * 3 + wrap_icon[0]->get_width() + down_icon->get_width(); + ofsx-=hsep+move_down_icon->get_width(); - if (ofsx < down_icon->get_width() + interp_icon[0]->get_width() + hsep * 3) { + if (ofsx < move_up_icon->get_width()) { - mouse_over.over = MouseOver::OVER_INTERP; - return; - } + mouse_over.over=MouseOver::OVER_UP; + return; + } - ofsx -= hsep * 2 + interp_icon[0]->get_width() + down_icon->get_width(); + ofsx-=hsep*3+move_up_icon->get_width(); - if (ofsx < down_icon->get_width() + cont_icon[0]->get_width() + hsep * 3) { +*/ - mouse_over.over = MouseOver::OVER_VALUE; - return; - } + if (ofsx < down_icon->get_width() + wrap_icon[0]->get_width() + hsep * 3) { - ofsx -= hsep * 3 + cont_icon[0]->get_width() + down_icon->get_width(); + mouse_over.over = MouseOver::OVER_WRAP; + return; + } - if (ofsx < add_key_icon->get_width()) { + ofsx -= hsep * 3 + wrap_icon[0]->get_width() + down_icon->get_width(); - mouse_over.over = MouseOver::OVER_ADD_KEY; - return; - } + if (ofsx < down_icon->get_width() + interp_icon[0]->get_width() + hsep * 3) { + + mouse_over.over = MouseOver::OVER_INTERP; + return; } - } - } break; + ofsx -= hsep * 2 + interp_icon[0]->get_width() + down_icon->get_width(); + + if (ofsx < down_icon->get_width() + cont_icon[0]->get_width() + hsep * 3) { + + mouse_over.over = MouseOver::OVER_VALUE; + return; + } + + ofsx -= hsep * 3 + cont_icon[0]->get_width() + down_icon->get_width(); + + if (ofsx < add_key_icon->get_width()) { + + mouse_over.over = MouseOver::OVER_ADD_KEY; + return; + } + } + } } } diff --git a/editor/animation_editor.h b/editor/animation_editor.h index 0f6cc95634..128481c837 100644 --- a/editor/animation_editor.h +++ b/editor/animation_editor.h @@ -273,7 +273,7 @@ class AnimationKeyEditor : public VBoxContainer { float _get_zoom_scale() const; void _track_editor_draw(); - void _track_editor_gui_input(const InputEvent &p_input); + void _track_editor_gui_input(const Ref<InputEvent> &p_input); void _track_pos_draw(); void _track_name_changed(const String &p_name); diff --git a/editor/code_editor.cpp b/editor/code_editor.cpp index a84d65de0e..2e406fb23d 100644 --- a/editor/code_editor.cpp +++ b/editor/code_editor.cpp @@ -94,17 +94,16 @@ void FindReplaceBar::_notification(int p_what) { } } -void FindReplaceBar::_unhandled_input(const InputEvent &p_event) { +void FindReplaceBar::_unhandled_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_event; + if (k.is_valid()) { - const InputEventKey &k = p_event.key; - - if (k.pressed && (text_edit->has_focus() || text_vbc->is_a_parent_of(get_focus_owner()))) { + if (k->is_pressed() && (text_edit->has_focus() || text_vbc->is_a_parent_of(get_focus_owner()))) { bool accepted = true; - switch (k.scancode) { + switch (k->get_scancode()) { case KEY_ESCAPE: { @@ -957,23 +956,27 @@ FindReplaceDialog::FindReplaceDialog() { /*** CODE EDITOR ****/ -void CodeTextEditor::_text_editor_gui_input(const InputEvent &p_event) { +void CodeTextEditor::_text_editor_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_event; - const InputEventMouseButton &mb = p_event.mouse_button; + if (mb.is_valid()) { - if (mb.pressed && mb.mod.command) { + if (mb->is_pressed() && mb->get_command()) { - if (mb.button_index == BUTTON_WHEEL_UP) { + if (mb->get_button_index() == BUTTON_WHEEL_UP) { _zoom_in(); - } else if (mb.button_index == BUTTON_WHEEL_DOWN) { + } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN) { _zoom_out(); } } - } else if (p_event.type == InputEvent::KEY) { + } + + Ref<InputEventKey> k = p_event; + + if (k.is_valid()) { - if (p_event.key.pressed) { + if (k->is_pressed()) { if (ED_IS_SHORTCUT("script_editor/zoom_in", p_event)) { _zoom_in(); } diff --git a/editor/code_editor.h b/editor/code_editor.h index 44d526fda9..8d48c56503 100644 --- a/editor/code_editor.h +++ b/editor/code_editor.h @@ -100,7 +100,7 @@ class FindReplaceBar : public HBoxContainer { protected: void _notification(int p_what); - void _unhandled_input(const InputEvent &p_event); + void _unhandled_input(const Ref<InputEvent> &p_event); bool _search(uint32_t p_flags, int p_from_line, int p_from_col); @@ -213,7 +213,7 @@ class CodeTextEditor : public VBoxContainer { void _complete_request(); void _font_resize_timeout(); - void _text_editor_gui_input(const InputEvent &p_event); + void _text_editor_gui_input(const Ref<InputEvent> &p_event); void _zoom_in(); void _zoom_out(); void _reset_zoom(); diff --git a/editor/create_dialog.cpp b/editor/create_dialog.cpp index dc28fc9020..c5cfea0b95 100644 --- a/editor/create_dialog.cpp +++ b/editor/create_dialog.cpp @@ -109,14 +109,15 @@ void CreateDialog::_text_changed(const String &p_newtext) { _update_search(); } -void CreateDialog::_sbox_input(const InputEvent &p_ie) { +void CreateDialog::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY && (p_ie.key.scancode == KEY_UP || - p_ie.key.scancode == KEY_DOWN || - p_ie.key.scancode == KEY_PAGEUP || - p_ie.key.scancode == KEY_PAGEDOWN)) { + Ref<InputEventKey> k = p_ie; + if (k.is_valid() && (k->get_scancode() == KEY_UP || + k->get_scancode() == KEY_DOWN || + k->get_scancode() == KEY_PAGEUP || + k->get_scancode() == KEY_PAGEDOWN)) { - search_options->call("_gui_input", p_ie); + search_options->call("_gui_input", k); search_box->accept_event(); } } diff --git a/editor/create_dialog.h b/editor/create_dialog.h index 6170149c6b..02ce762726 100644 --- a/editor/create_dialog.h +++ b/editor/create_dialog.h @@ -69,7 +69,7 @@ class CreateDialog : public ConfirmationDialog { void _history_activated(); void _favorite_activated(); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _confirmed(); void _text_changed(const String &p_newtext); diff --git a/editor/doc/doc_data.cpp b/editor/doc/doc_data.cpp index 75d8721756..6a79f99354 100644 --- a/editor/doc/doc_data.cpp +++ b/editor/doc/doc_data.cpp @@ -331,8 +331,7 @@ void DocData::generate(bool p_basic_types) { default_arg_text = "NULL"; break; } - case Variant::INPUT_EVENT: - case Variant::DICTIONARY: + case Variant::DICTIONARY: // 20 case Variant::ARRAY: case Variant::_RID: @@ -477,97 +476,78 @@ void DocData::generate(bool p_basic_types) { if (i == Variant::OBJECT) continue; //use the core type instead - int loops = 1; + String cname = Variant::get_type_name(Variant::Type(i)); - if (i == Variant::INPUT_EVENT) - loops = InputEvent::TYPE_MAX; - - for (int j = 0; j < loops; j++) { - - String cname = Variant::get_type_name(Variant::Type(i)); - - if (i == Variant::INPUT_EVENT) { - static const char *ie_type[InputEvent::TYPE_MAX] = { - "", "Key", "MouseMotion", "MouseButton", "JoypadMotion", "JoypadButton", "ScreenTouch", "ScreenDrag", "Action" - }; - cname += ie_type[j]; - } - - class_list[cname] = ClassDoc(); - ClassDoc &c = class_list[cname]; - c.name = cname; - c.category = "Built-In Types"; - - Variant::CallError cerror; - Variant v = Variant::construct(Variant::Type(i), NULL, 0, cerror); + class_list[cname] = ClassDoc(); + ClassDoc &c = class_list[cname]; + c.name = cname; + c.category = "Built-In Types"; - if (i == Variant::INPUT_EVENT) { - v.set("type", j); - } + Variant::CallError cerror; + Variant v = Variant::construct(Variant::Type(i), NULL, 0, cerror); - List<MethodInfo> method_list; - v.get_method_list(&method_list); - method_list.sort(); - Variant::get_constructor_list(Variant::Type(i), &method_list); + List<MethodInfo> method_list; + v.get_method_list(&method_list); + method_list.sort(); + Variant::get_constructor_list(Variant::Type(i), &method_list); - for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) { + for (List<MethodInfo>::Element *E = method_list.front(); E; E = E->next()) { - MethodInfo &mi = E->get(); - MethodDoc method; + MethodInfo &mi = E->get(); + MethodDoc method; - method.name = mi.name; + method.name = mi.name; - for (int i = 0; i < mi.arguments.size(); i++) { + for (int i = 0; i < mi.arguments.size(); i++) { - ArgumentDoc arg; - PropertyInfo pi = mi.arguments[i]; + ArgumentDoc arg; + PropertyInfo pi = mi.arguments[i]; - arg.name = pi.name; - //print_line("arg name: "+arg.name); - if (pi.type == Variant::NIL) - arg.type = "var"; - else - arg.type = Variant::get_type_name(pi.type); - int defarg = mi.default_arguments.size() - mi.arguments.size() + i; - if (defarg >= 0) - arg.default_value = mi.default_arguments[defarg]; - - method.arguments.push_back(arg); - } + arg.name = pi.name; + //print_line("arg name: "+arg.name); + if (pi.type == Variant::NIL) + arg.type = "var"; + else + arg.type = Variant::get_type_name(pi.type); + int defarg = mi.default_arguments.size() - mi.arguments.size() + i; + if (defarg >= 0) + arg.default_value = mi.default_arguments[defarg]; - if (mi.return_val.type == Variant::NIL) { - if (mi.return_val.name != "") - method.return_type = "var"; + method.arguments.push_back(arg); + } - } else { - method.return_type = Variant::get_type_name(mi.return_val.type); - } + if (mi.return_val.type == Variant::NIL) { + if (mi.return_val.name != "") + method.return_type = "var"; - c.methods.push_back(method); + } else { + method.return_type = Variant::get_type_name(mi.return_val.type); } - List<PropertyInfo> properties; - v.get_property_list(&properties); - for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) { + c.methods.push_back(method); + } + + List<PropertyInfo> properties; + v.get_property_list(&properties); + for (List<PropertyInfo>::Element *E = properties.front(); E; E = E->next()) { - PropertyInfo pi = E->get(); - PropertyDoc property; - property.name = pi.name; - property.type = Variant::get_type_name(pi.type); + PropertyInfo pi = E->get(); + PropertyDoc property; + property.name = pi.name; + property.type = Variant::get_type_name(pi.type); - c.properties.push_back(property); - } + c.properties.push_back(property); + } - List<StringName> constants; - Variant::get_numeric_constants_for_type(Variant::Type(i), &constants); + List<StringName> constants; + Variant::get_numeric_constants_for_type(Variant::Type(i), &constants); - for (List<StringName>::Element *E = constants.front(); E; E = E->next()) { + for (List<StringName>::Element *E = constants.front(); E; E = E->next()) { - ConstantDoc constant; - constant.name = E->get(); - constant.value = itos(Variant::get_numeric_constant_value(Variant::Type(i), E->get())); - c.constants.push_back(constant); - } + ConstantDoc constant; + constant.name = E->get(); + constant.value = itos(Variant::get_numeric_constant_value(Variant::Type(i), E->get())); + c.constants.push_back(constant); } } diff --git a/editor/doc/doc_dump.cpp b/editor/doc/doc_dump.cpp index 10cd29b814..79a8f79a7c 100644 --- a/editor/doc/doc_dump.cpp +++ b/editor/doc/doc_dump.cpp @@ -194,8 +194,7 @@ void DocDump::dump(const String &p_file) { default_arg_text = Variant::get_type_name(default_arg.get_type()) + "(" + default_arg_text + ")"; break; case Variant::OBJECT: - case Variant::INPUT_EVENT: - case Variant::DICTIONARY: + case Variant::DICTIONARY: // 20 case Variant::ARRAY: case Variant::_RID: diff --git a/editor/editor_audio_buses.cpp b/editor/editor_audio_buses.cpp index 6ef32a6afd..f60186e3b4 100644 --- a/editor/editor_audio_buses.cpp +++ b/editor/editor_audio_buses.cpp @@ -385,15 +385,18 @@ void EditorAudioBus::_effect_add(int p_which) { ur->commit_action(); } -void EditorAudioBus::_gui_input(const InputEvent &p_event) { +void EditorAudioBus::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && !p_event.key.echo) { + Ref<InputEventKey> k = p_event; + if (k.is_valid() && k->is_pressed() && k->get_scancode() == KEY_DELETE && !k->is_echo()) { accept_event(); emit_signal("delete_request"); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 2 && p_event.mouse_button.pressed) { - Vector2 pos = Vector2(p_event.mouse_button.x, p_event.mouse_button.y); + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_valid() && mb->get_button_index() == 2 && mb->is_pressed()) { + + Vector2 pos = Vector2(mb->get_pos().x, mb->get_pos().y); delete_popup->set_position(get_global_position() + pos); delete_popup->popup(); } diff --git a/editor/editor_audio_buses.h b/editor/editor_audio_buses.h index 4a3d784796..f5bf464fd0 100644 --- a/editor/editor_audio_buses.h +++ b/editor/editor_audio_buses.h @@ -75,7 +75,7 @@ class EditorAudioBus : public PanelContainer { bool updating_bus; - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _delete_pressed(int p_option); void _name_changed(const String &p_new_name); diff --git a/editor/editor_file_dialog.cpp b/editor/editor_file_dialog.cpp index c47e3fc0de..25fade46d6 100644 --- a/editor/editor_file_dialog.cpp +++ b/editor/editor_file_dialog.cpp @@ -95,11 +95,13 @@ void EditorFileDialog::_notification(int p_what) { } } -void EditorFileDialog::_unhandled_input(const InputEvent &p_event) { +void EditorFileDialog::_unhandled_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && is_window_modal_on_top()) { + Ref<InputEventKey> k = p_event; - if (p_event.key.pressed) { + if (k.is_valid() && is_window_modal_on_top()) { + + if (k->is_pressed()) { bool handled = false; diff --git a/editor/editor_file_dialog.h b/editor/editor_file_dialog.h index f8c85c4ad1..f44193c70b 100644 --- a/editor/editor_file_dialog.h +++ b/editor/editor_file_dialog.h @@ -169,7 +169,7 @@ private: void _thumbnail_done(const String &p_path, const Ref<Texture> &p_preview, const Variant &p_udata); void _request_single_thumbnail(const String &p_path); - void _unhandled_input(const InputEvent &p_event); + void _unhandled_input(const Ref<InputEvent> &p_event); protected: void _notification(int p_what); diff --git a/editor/editor_help.cpp b/editor/editor_help.cpp index 11fa9396a0..d550ce93d1 100644 --- a/editor/editor_help.cpp +++ b/editor/editor_help.cpp @@ -61,14 +61,16 @@ void EditorHelpSearch::_text_changed(const String &p_newtext) { _update_search(); } -void EditorHelpSearch::_sbox_input(const InputEvent &p_ie) { +void EditorHelpSearch::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY && (p_ie.key.scancode == KEY_UP || - p_ie.key.scancode == KEY_DOWN || - p_ie.key.scancode == KEY_PAGEUP || - p_ie.key.scancode == KEY_PAGEDOWN)) { + Ref<InputEventKey> k = p_ie; - search_options->call("_gui_input", p_ie); + if (k.is_valid() && (k->get_scancode() == KEY_UP || + k->get_scancode() == KEY_DOWN || + k->get_scancode() == KEY_PAGEUP || + k->get_scancode() == KEY_PAGEDOWN)) { + + search_options->call("_gui_input", k); search_box->accept_event(); } } @@ -448,14 +450,16 @@ void EditorHelpIndex::_update_class_list() { } } -void EditorHelpIndex::_sbox_input(const InputEvent &p_ie) { +void EditorHelpIndex::_sbox_input(const Ref<InputEvent> &p_ie) { + + Ref<InputEventKey> k = p_ie; - if (p_ie.type == InputEvent::KEY && (p_ie.key.scancode == KEY_UP || - p_ie.key.scancode == KEY_DOWN || - p_ie.key.scancode == KEY_PAGEUP || - p_ie.key.scancode == KEY_PAGEDOWN)) { + if (k.is_valid() && (k->get_scancode() == KEY_UP || + k->get_scancode() == KEY_DOWN || + k->get_scancode() == KEY_PAGEUP || + k->get_scancode() == KEY_PAGEDOWN)) { - class_list->call("_gui_input", p_ie); + class_list->call("_gui_input", k); search_box->accept_event(); } } @@ -499,11 +503,14 @@ EditorHelpIndex::EditorHelpIndex() { /// ///////////////////////////////// DocData *EditorHelp::doc = NULL; -void EditorHelp::_unhandled_key_input(const InputEvent &p_ev) { +void EditorHelp::_unhandled_key_input(const Ref<InputEvent> &p_ev) { if (!is_visible_in_tree()) return; - if (p_ev.key.mod.control && p_ev.key.scancode == KEY_F) { + + Ref<InputEventKey> k = p_ev; + + if (k.is_valid() && k->get_control() && k->get_scancode() == KEY_F) { search->grab_focus(); search->select_all(); @@ -598,8 +605,11 @@ void EditorHelp::_class_desc_select(const String &p_select) { } } -void EditorHelp::_class_desc_input(const InputEvent &p_input) { - if (p_input.type == InputEvent::MOUSE_BUTTON && p_input.mouse_button.pressed && p_input.mouse_button.button_index == 1) { +void EditorHelp::_class_desc_input(const Ref<InputEvent> &p_input) { + + Ref<InputEventMouseButton> mb = p_input; + + if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == 1) { class_desc->set_selection_enabled(false); class_desc->set_selection_enabled(true); } diff --git a/editor/editor_help.h b/editor/editor_help.h index d22d61b91d..d6fc0e3bf2 100644 --- a/editor/editor_help.h +++ b/editor/editor_help.h @@ -56,7 +56,7 @@ class EditorHelpSearch : public ConfirmationDialog { void _update_search(); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _confirmed(); void _text_changed(const String &p_newtext); @@ -81,7 +81,7 @@ class EditorHelpIndex : public ConfirmationDialog { void _tree_item_selected(); void _text_changed(const String &p_text); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _update_class_list(); @@ -147,7 +147,7 @@ class EditorHelp : public VBoxContainer { void _scroll_changed(double p_scroll); void _class_list_select(const String &p_select); void _class_desc_select(const String &p_select); - void _class_desc_input(const InputEvent &p_input); + void _class_desc_input(const Ref<InputEvent> &p_input); Error _goto_desc(const String &p_class, int p_vscr = -1); //void _update_history_buttons(); @@ -157,7 +157,7 @@ class EditorHelp : public VBoxContainer { void _search(const String &p_str); void _search_cbk(); - void _unhandled_key_input(const InputEvent &p_ev); + void _unhandled_key_input(const Ref<InputEvent> &p_ev); protected: void _notification(int p_what); diff --git a/editor/editor_name_dialog.cpp b/editor/editor_name_dialog.cpp index 29d5dda658..d4c418bfc9 100644 --- a/editor/editor_name_dialog.cpp +++ b/editor/editor_name_dialog.cpp @@ -32,14 +32,16 @@ #include "class_db.h" #include "os/keyboard.h" -void EditorNameDialog::_line_gui_input(const InputEvent &p_event) { +void EditorNameDialog::_line_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_event; - if (!p_event.key.pressed) + if (k.is_valid()) { + + if (!k->is_pressed()) return; - switch (p_event.key.scancode) { + switch (k->get_scancode()) { case KEY_ENTER: case KEY_RETURN: { diff --git a/editor/editor_name_dialog.h b/editor/editor_name_dialog.h index eeeee34d7e..57586951d1 100644 --- a/editor/editor_name_dialog.h +++ b/editor/editor_name_dialog.h @@ -41,7 +41,7 @@ class EditorNameDialog : public ConfirmationDialog { VBoxContainer *makevb; LineEdit *name; - void _line_gui_input(const InputEvent &p_event); + void _line_gui_input(const Ref<InputEvent> &p_event); protected: static void _bind_methods(); diff --git a/editor/editor_node.cpp b/editor/editor_node.cpp index 4a4b720e88..4ecb292027 100644 --- a/editor/editor_node.cpp +++ b/editor/editor_node.cpp @@ -173,12 +173,13 @@ void EditorNode::_update_title() { OS::get_singleton()->set_window_title(title); } -void EditorNode::_unhandled_input(const InputEvent &p_event) { +void EditorNode::_unhandled_input(const Ref<InputEvent> &p_event) { if (Node::get_viewport()->get_modal_stack_top()) return; //ignore because of modal window - if (p_event.type == InputEvent::KEY && p_event.key.pressed && !p_event.key.echo && !gui_base->get_viewport()->gui_has_modal_stack()) { + Ref<InputEventKey> k = p_event; + if (k.is_valid() && k->is_pressed() && !k->is_echo() && !gui_base->get_viewport()->gui_has_modal_stack()) { if (ED_IS_SHORTCUT("editor/next_tab", p_event)) { int next_tab = editor_data.get_edited_scene() + 1; @@ -3710,11 +3711,13 @@ void EditorNode::show_warning(const String &p_text, const String &p_title) { warning->popup_centered_minsize(); } -void EditorNode::_dock_select_input(const InputEvent &p_input) { +void EditorNode::_dock_select_input(const Ref<InputEvent> &p_input) { - if (p_input.type == InputEvent::MOUSE_BUTTON || p_input.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouse> me = p_input; - Vector2 point(p_input.mouse_motion.x, p_input.mouse_motion.y); + if (me.is_valid()) { + + Vector2 point = me->get_pos(); int nrect = -1; for (int i = 0; i < DOCK_SLOT_MAX; i++) { @@ -3732,7 +3735,9 @@ void EditorNode::_dock_select_input(const InputEvent &p_input) { if (nrect == -1) return; - if (p_input.type == InputEvent::MOUSE_BUTTON && p_input.mouse_button.button_index == 1 && p_input.mouse_button.pressed && dock_popup_selected != nrect) { + Ref<InputEventMouseButton> mb = me; + + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed() && dock_popup_selected != nrect) { Control *dock = dock_slot[dock_popup_selected]->get_current_tab_control(); if (dock) { dock_slot[dock_popup_selected]->remove_child(dock); @@ -6190,7 +6195,7 @@ void EditorPluginList::edit(Object *p_object) { } } -bool EditorPluginList::forward_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { +bool EditorPluginList::forward_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { bool discard = false; @@ -6203,7 +6208,7 @@ bool EditorPluginList::forward_gui_input(const Transform2D &p_canvas_xform, cons return discard; } -bool EditorPluginList::forward_spatial_gui_input(Camera *p_camera, const InputEvent &p_event) { +bool EditorPluginList::forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event) { bool discard = false; for (int i = 0; i < plugins_list.size(); i++) { diff --git a/editor/editor_node.h b/editor/editor_node.h index 5215809da3..667f58e6da 100644 --- a/editor/editor_node.h +++ b/editor/editor_node.h @@ -482,7 +482,7 @@ private: bool convert_old; - void _unhandled_input(const InputEvent &p_event); + void _unhandled_input(const Ref<InputEvent> &p_event); static void _load_error_notify(void *p_ud, const String &p_text); @@ -539,7 +539,7 @@ private: bool _find_scene_in_use(Node *p_node, const String &p_path) const; - void _dock_select_input(const InputEvent &p_input); + void _dock_select_input(const Ref<InputEvent> &p_input); void _dock_move_left(); void _dock_move_right(); void _dock_select_draw(); @@ -807,8 +807,8 @@ public: void make_visible(bool p_visible); void edit(Object *p_object); - bool forward_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event); - bool forward_spatial_gui_input(Camera *p_camera, const InputEvent &p_event); + bool forward_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event); + bool forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event); void forward_draw_over_canvas(const Transform2D &p_canvas_xform, Control *p_canvas); void clear(); bool empty(); diff --git a/editor/editor_path.cpp b/editor/editor_path.cpp index 98e0808ba5..8ce4f88590 100644 --- a/editor/editor_path.cpp +++ b/editor/editor_path.cpp @@ -69,9 +69,10 @@ void EditorPath::_add_children_to_popup(Object *p_obj, int p_depth) { } } -void EditorPath::_gui_input(const InputEvent &p_event) { +void EditorPath::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == BUTTON_LEFT && p_event.mouse_button.pressed) { + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { Object *obj = ObjectDB::get_instance(history->get_path_object(history->get_path_size() - 1)); if (!obj) diff --git a/editor/editor_path.h b/editor/editor_path.h index a142cba44c..7b73e7ebb6 100644 --- a/editor/editor_path.h +++ b/editor/editor_path.h @@ -46,7 +46,7 @@ class EditorPath : public Control { EditorPath(); void _popup_select(int p_idx); - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _add_children_to_popup(Object *p_obj, int p_depth = 0); protected: diff --git a/editor/editor_plugin.cpp b/editor/editor_plugin.cpp index 5e5b31aac9..1b8d1b1677 100644 --- a/editor/editor_plugin.cpp +++ b/editor/editor_plugin.cpp @@ -156,7 +156,7 @@ Ref<SpatialEditorGizmo> EditorPlugin::create_spatial_gizmo(Spatial *p_spatial) { return Ref<SpatialEditorGizmo>(); } -bool EditorPlugin::forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { +bool EditorPlugin::forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { if (get_script_instance() && get_script_instance()->has_method("forward_canvas_gui_input")) { return get_script_instance()->call("forward_canvas_gui_input", p_canvas_xform, p_event); @@ -175,7 +175,7 @@ void EditorPlugin::update_canvas() { CanvasItemEditor::get_singleton()->get_viewport_control()->update(); } -bool EditorPlugin::forward_spatial_gui_input(Camera *p_camera, const InputEvent &p_event) { +bool EditorPlugin::forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event) { if (get_script_instance() && get_script_instance()->has_method("forward_spatial_gui_input")) { return get_script_instance()->call("forward_spatial_gui_input", p_camera, p_event); @@ -366,9 +366,9 @@ void EditorPlugin::_bind_methods() { ClassDB::bind_method(D_METHOD("queue_save_layout"), &EditorPlugin::queue_save_layout); ClassDB::bind_method(D_METHOD("edit_resource"), &EditorPlugin::edit_resource); ClassDB::bind_method(D_METHOD("add_import_plugin"), &EditorPlugin::add_import_plugin); - ClassDB::add_virtual_method(get_class_static(), MethodInfo(Variant::BOOL, "forward_canvas_gui_input", PropertyInfo(Variant::TRANSFORM2D, "canvas_xform"), PropertyInfo(Variant::INPUT_EVENT, "event"))); + ClassDB::add_virtual_method(get_class_static(), MethodInfo(Variant::BOOL, "forward_canvas_gui_input", PropertyInfo(Variant::TRANSFORM2D, "canvas_xform"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); ClassDB::add_virtual_method(get_class_static(), MethodInfo("forward_draw_over_canvas", PropertyInfo(Variant::TRANSFORM2D, "canvas_xform"), PropertyInfo(Variant::OBJECT, "canvas:Control"))); - ClassDB::add_virtual_method(get_class_static(), MethodInfo(Variant::BOOL, "forward_spatial_gui_input", PropertyInfo(Variant::OBJECT, "camera", PROPERTY_HINT_RESOURCE_TYPE, "Camera"), PropertyInfo(Variant::INPUT_EVENT, "event"))); + ClassDB::add_virtual_method(get_class_static(), MethodInfo(Variant::BOOL, "forward_spatial_gui_input", PropertyInfo(Variant::OBJECT, "camera", PROPERTY_HINT_RESOURCE_TYPE, "Camera"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); MethodInfo gizmo = MethodInfo(Variant::OBJECT, "create_spatial_gizmo", PropertyInfo(Variant::OBJECT, "for_spatial:Spatial")); gizmo.return_val.hint = PROPERTY_HINT_RESOURCE_TYPE; gizmo.return_val.hint_string = "EditorSpatialGizmo"; diff --git a/editor/editor_plugin.h b/editor/editor_plugin.h index 5f4b47caee..1ef447a6b8 100644 --- a/editor/editor_plugin.h +++ b/editor/editor_plugin.h @@ -107,9 +107,9 @@ public: void remove_tool_menu_item(const String &p_name); virtual Ref<SpatialEditorGizmo> create_spatial_gizmo(Spatial *p_spatial); - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event); + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event); virtual void forward_draw_over_canvas(const Transform2D &p_canvas_xform, Control *p_canvas); - virtual bool forward_spatial_gui_input(Camera *p_camera, const InputEvent &p_event); + virtual bool forward_spatial_gui_input(Camera *p_camera, const Ref<InputEvent> &p_event); virtual String get_name() const; virtual bool has_main_screen() const; virtual void make_visible(bool p_visible); diff --git a/editor/editor_profiler.cpp b/editor/editor_profiler.cpp index 9d12ad687e..d427126734 100644 --- a/editor/editor_profiler.cpp +++ b/editor/editor_profiler.cpp @@ -483,16 +483,20 @@ void EditorProfiler::_cursor_metric_changed(double) { _update_frame(); } -void EditorProfiler::_graph_tex_input(const InputEvent &p_ev) { +void EditorProfiler::_graph_tex_input(const Ref<InputEvent> &p_ev) { if (last_metric < 0) return; + Ref<InputEventMouse> me = p_ev; + Ref<InputEventMouseButton> mb = p_ev; + Ref<InputEventMouseMotion> mm = p_ev; + if ( - (p_ev.type == InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index == BUTTON_LEFT && p_ev.mouse_button.pressed) || - (p_ev.type == InputEvent::MOUSE_MOTION)) { + (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) || + (mm.is_valid())) { - int x = p_ev.mouse_button.x; + int x = me->get_pos().x; x = x * frame_metrics.size() / graph->get_size().width; bool show_hover = x >= 0 && x < frame_metrics.size(); @@ -519,7 +523,7 @@ void EditorProfiler::_graph_tex_input(const InputEvent &p_ev) { hover_metric = -1; } - if (p_ev.type == InputEvent::MOUSE_BUTTON || p_ev.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + if (mb.is_valid() || mb->get_button_mask() & BUTTON_MASK_LEFT) { //cursor_metric=x; updating_frame = true; diff --git a/editor/editor_profiler.h b/editor/editor_profiler.h index 35b5ae366c..4998d45a89 100644 --- a/editor/editor_profiler.h +++ b/editor/editor_profiler.h @@ -143,7 +143,7 @@ private: void _graph_tex_mouse_exit(); void _graph_tex_draw(); - void _graph_tex_input(const InputEvent &p_ev); + void _graph_tex_input(const Ref<InputEvent> &p_ev); int _get_cursor_index() const; diff --git a/editor/editor_settings.cpp b/editor/editor_settings.cpp index cd8e68bc5e..ebd4643537 100644 --- a/editor/editor_settings.cpp +++ b/editor/editor_settings.cpp @@ -65,7 +65,7 @@ bool EditorSettings::_set(const StringName &p_name, const Variant &p_value) { for (int i = 0; i < arr.size(); i += 2) { String name = arr[i]; - InputEvent shortcut = arr[i + 1]; + Ref<InputEvent> shortcut = arr[i + 1]; Ref<ShortCut> sc; sc.instance(); @@ -109,8 +109,8 @@ bool EditorSettings::_get(const StringName &p_name, Variant &r_ret) const { continue; //this came from settings but is not any longer used } - InputEvent original = sc->get_meta("original"); - if (sc->is_shortcut(original) || (original.type == InputEvent::NONE && sc->get_shortcut().type == InputEvent::NONE)) + Ref<InputEvent> original = sc->get_meta("original"); + if (sc->is_shortcut(original) || (original.is_null() && sc->get_shortcut().is_null())) continue; //not changed from default, don't save } @@ -984,7 +984,7 @@ void EditorSettings::add_shortcut(const String &p_name, Ref<ShortCut> &p_shortcu shortcuts[p_name] = p_shortcut; } -bool EditorSettings::is_shortcut(const String &p_name, const InputEvent &p_event) const { +bool EditorSettings::is_shortcut(const String &p_name, const Ref<InputEvent> &p_event) const { const Map<String, Ref<ShortCut> >::Element *E = shortcuts.find(p_name); if (!E) { @@ -1101,15 +1101,16 @@ Ref<ShortCut> ED_GET_SHORTCUT(const String &p_path) { Ref<ShortCut> ED_SHORTCUT(const String &p_path, const String &p_name, uint32_t p_keycode) { - InputEvent ie; + Ref<InputEventKey> ie; if (p_keycode) { - ie.type = InputEvent::KEY; - ie.key.unicode = p_keycode & KEY_CODE_MASK; - ie.key.scancode = p_keycode & KEY_CODE_MASK; - ie.key.mod.shift = bool(p_keycode & KEY_MASK_SHIFT); - ie.key.mod.alt = bool(p_keycode & KEY_MASK_ALT); - ie.key.mod.control = bool(p_keycode & KEY_MASK_CTRL); - ie.key.mod.meta = bool(p_keycode & KEY_MASK_META); + ie.instance(); + + ie->set_unicode(p_keycode & KEY_CODE_MASK); + ie->set_scancode(p_keycode & KEY_CODE_MASK); + ie->set_shift(bool(p_keycode & KEY_MASK_SHIFT)); + ie->set_alt(bool(p_keycode & KEY_MASK_ALT)); + ie->set_control(bool(p_keycode & KEY_MASK_CTRL)); + ie->set_metakey(bool(p_keycode & KEY_MASK_META)); } Ref<ShortCut> sc = EditorSettings::get_singleton()->get_shortcut(p_path); diff --git a/editor/editor_settings.h b/editor/editor_settings.h index a876f23134..7b45e28350 100644 --- a/editor/editor_settings.h +++ b/editor/editor_settings.h @@ -160,7 +160,7 @@ public: bool save_text_editor_theme_as(String p_file); void add_shortcut(const String &p_name, Ref<ShortCut> &p_shortcut); - bool is_shortcut(const String &p_name, const InputEvent &p_event) const; + bool is_shortcut(const String &p_name, const Ref<InputEvent> &p_event) const; Ref<ShortCut> get_shortcut(const String &p_name) const; void get_shortcut_list(List<String> *r_shortcuts); diff --git a/editor/pane_drag.cpp b/editor/pane_drag.cpp index 69a1f07fba..22b306f941 100644 --- a/editor/pane_drag.cpp +++ b/editor/pane_drag.cpp @@ -29,11 +29,12 @@ /*************************************************************************/ #include "pane_drag.h" -void PaneDrag::_gui_input(const InputEvent &p_input) { +void PaneDrag::_gui_input(const Ref<InputEvent> &p_input) { - if (p_input.type == InputEvent::MOUSE_MOTION && p_input.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + Ref<InputEventMouseMotion> mm = p_input; + if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT) { - emit_signal("dragged", Point2(p_input.mouse_motion.relative_x, p_input.mouse_motion.relative_y)); + emit_signal("dragged", Point2(mm->get_relative().x, mm->get_relative().y)); } } diff --git a/editor/pane_drag.h b/editor/pane_drag.h index bd26621c83..7bd9feb63b 100644 --- a/editor/pane_drag.h +++ b/editor/pane_drag.h @@ -39,7 +39,7 @@ class PaneDrag : public Control { bool mouse_over; protected: - void _gui_input(const InputEvent &p_input); + void _gui_input(const Ref<InputEvent> &p_input); void _notification(int p_what); virtual Size2 get_minimum_size() const; static void _bind_methods(); diff --git a/editor/plugins/animation_player_editor_plugin.cpp b/editor/plugins/animation_player_editor_plugin.cpp index 8a1e220fe3..17fb953f3f 100644 --- a/editor/plugins/animation_player_editor_plugin.cpp +++ b/editor/plugins/animation_player_editor_plugin.cpp @@ -51,7 +51,7 @@ void AnimationPlayerEditor::_node_removed(Node *p_node) { } } -void AnimationPlayerEditor::_gui_input(InputEvent p_event) { +void AnimationPlayerEditor::_gui_input(Ref<InputEvent> p_event) { } void AnimationPlayerEditor::_notification(int p_what) { @@ -1160,14 +1160,15 @@ void AnimationPlayerEditor::_animation_save_menu(int p_option) { } } -void AnimationPlayerEditor::_unhandled_key_input(const InputEvent &p_ev) { +void AnimationPlayerEditor::_unhandled_key_input(const Ref<InputEvent> &p_ev) { - if (is_visible_in_tree() && p_ev.type == InputEvent::KEY && p_ev.key.pressed && !p_ev.key.echo && !p_ev.key.mod.alt && !p_ev.key.mod.control && !p_ev.key.mod.meta) { + Ref<InputEventKey> k = p_ev; + if (is_visible_in_tree() && k.is_valid() && k->is_pressed() && !k->is_echo() && !k->get_alt() && !k->get_control() && !k->get_metakey()) { - switch (p_ev.key.scancode) { + switch (k->get_scancode()) { case KEY_A: { - if (!p_ev.key.mod.shift) + if (!k->get_shift()) _play_bw_from_pressed(); else _play_bw_pressed(); @@ -1176,7 +1177,7 @@ void AnimationPlayerEditor::_unhandled_key_input(const InputEvent &p_ev) { _stop_pressed(); } break; case KEY_D: { - if (!p_ev.key.mod.shift) + if (!k->get_shift()) _play_from_pressed(); else _play_pressed(); diff --git a/editor/plugins/animation_player_editor_plugin.h b/editor/plugins/animation_player_editor_plugin.h index ac60090d15..ceaa73569a 100644 --- a/editor/plugins/animation_player_editor_plugin.h +++ b/editor/plugins/animation_player_editor_plugin.h @@ -158,7 +158,7 @@ class AnimationPlayerEditor : public VBoxContainer { void _animation_key_editor_anim_len_changed(float p_new); void _animation_key_editor_anim_step_changed(float p_len); - void _unhandled_key_input(const InputEvent &p_ev); + void _unhandled_key_input(const Ref<InputEvent> &p_ev); void _animation_tool_menu(int p_option); void _animation_save_menu(int p_option); @@ -166,7 +166,7 @@ class AnimationPlayerEditor : public VBoxContainer { protected: void _notification(int p_what); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); void _node_removed(Node *p_node); static void _bind_methods(); diff --git a/editor/plugins/animation_tree_editor_plugin.cpp b/editor/plugins/animation_tree_editor_plugin.cpp index e126cdf40f..fccd527ed6 100644 --- a/editor/plugins/animation_tree_editor_plugin.cpp +++ b/editor/plugins/animation_tree_editor_plugin.cpp @@ -735,139 +735,139 @@ void AnimationTreeEditor::_node_edit_property(const StringName& p_node) { } #endif -void AnimationTreeEditor::_gui_input(InputEvent p_event) { +void AnimationTreeEditor::_gui_input(Ref<InputEvent> p_event) { - switch (p_event.type) { + Ref<InputEventMouseButton> mb = p_event; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - if (p_event.mouse_button.pressed) { + if (mb->is_pressed()) { - if (p_event.mouse_button.button_index == 1) { - click_pos = Point2(p_event.mouse_button.x, p_event.mouse_button.y); - click_motion = click_pos; - click_type = _locate_click(click_pos, &click_node, &click_slot); - if (click_type != CLICK_NONE) { + if (mb->get_button_index() == 1) { + click_pos = Point2(mb->get_pos().x, mb->get_pos().y); + click_motion = click_pos; + click_type = _locate_click(click_pos, &click_node, &click_slot); + if (click_type != CLICK_NONE) { - order.erase(click_node); - order.push_back(click_node); - update(); - } + order.erase(click_node); + order.push_back(click_node); + update(); + } - switch (click_type) { - case CLICK_INPUT_SLOT: { - click_pos = _get_slot_pos(click_node, true, click_slot); - } break; - case CLICK_OUTPUT_SLOT: { - click_pos = _get_slot_pos(click_node, false, click_slot); - } break; - case CLICK_PARAMETER: { - - edited_node = click_node; - renaming_edit = false; - _popup_edit_dialog(); - //open editor - //_node_edit_property(click_node); - } break; - default: {} - } + switch (click_type) { + case CLICK_INPUT_SLOT: { + click_pos = _get_slot_pos(click_node, true, click_slot); + } break; + case CLICK_OUTPUT_SLOT: { + click_pos = _get_slot_pos(click_node, false, click_slot); + } break; + case CLICK_PARAMETER: { + + edited_node = click_node; + renaming_edit = false; + _popup_edit_dialog(); + //open editor + //_node_edit_property(click_node); + } break; + default: {} } - if (p_event.mouse_button.button_index == 2) { - - if (click_type != CLICK_NONE) { - click_type = CLICK_NONE; - update(); - } else { - // try to disconnect/remove - - Point2 rclick_pos = Point2(p_event.mouse_button.x, p_event.mouse_button.y); - rclick_type = _locate_click(rclick_pos, &rclick_node, &rclick_slot); - if (rclick_type == CLICK_INPUT_SLOT || rclick_type == CLICK_OUTPUT_SLOT) { - - node_popup->clear(); - node_popup->add_item(TTR("Disconnect"), NODE_DISCONNECT); - if (anim_tree->node_get_type(rclick_node) == AnimationTreePlayer::NODE_TRANSITION) { - node_popup->add_item(TTR("Add Input"), NODE_ADD_INPUT); - if (rclick_type == CLICK_INPUT_SLOT) { - if (anim_tree->transition_node_has_input_auto_advance(rclick_node, rclick_slot)) - node_popup->add_item(TTR("Clear Auto-Advance"), NODE_CLEAR_AUTOADVANCE); - else - node_popup->add_item(TTR("Set Auto-Advance"), NODE_SET_AUTOADVANCE); - node_popup->add_item(TTR("Delete Input"), NODE_DELETE_INPUT); - } - } + } + if (mb->get_button_index() == 2) { - node_popup->set_position(rclick_pos + get_global_position()); - node_popup->popup(); + if (click_type != CLICK_NONE) { + click_type = CLICK_NONE; + update(); + } else { + // try to disconnect/remove + + Point2 rclick_pos = Point2(mb->get_pos().x, mb->get_pos().y); + rclick_type = _locate_click(rclick_pos, &rclick_node, &rclick_slot); + if (rclick_type == CLICK_INPUT_SLOT || rclick_type == CLICK_OUTPUT_SLOT) { + + node_popup->clear(); + node_popup->add_item(TTR("Disconnect"), NODE_DISCONNECT); + if (anim_tree->node_get_type(rclick_node) == AnimationTreePlayer::NODE_TRANSITION) { + node_popup->add_item(TTR("Add Input"), NODE_ADD_INPUT); + if (rclick_type == CLICK_INPUT_SLOT) { + if (anim_tree->transition_node_has_input_auto_advance(rclick_node, rclick_slot)) + node_popup->add_item(TTR("Clear Auto-Advance"), NODE_CLEAR_AUTOADVANCE); + else + node_popup->add_item(TTR("Set Auto-Advance"), NODE_SET_AUTOADVANCE); + node_popup->add_item(TTR("Delete Input"), NODE_DELETE_INPUT); + } } - if (rclick_type == CLICK_NODE) { - node_popup->clear(); - node_popup->add_item(TTR("Rename"), NODE_RENAME); - node_popup->add_item(TTR("Remove"), NODE_ERASE); - if (anim_tree->node_get_type(rclick_node) == AnimationTreePlayer::NODE_TRANSITION) - node_popup->add_item(TTR("Add Input"), NODE_ADD_INPUT); - node_popup->set_position(rclick_pos + get_global_position()); - node_popup->popup(); - } + node_popup->set_position(rclick_pos + get_global_position()); + node_popup->popup(); } - } - } else { - if (p_event.mouse_button.button_index == 1 && click_type != CLICK_NONE) { + if (rclick_type == CLICK_NODE) { + node_popup->clear(); + node_popup->add_item(TTR("Rename"), NODE_RENAME); + node_popup->add_item(TTR("Remove"), NODE_ERASE); + if (anim_tree->node_get_type(rclick_node) == AnimationTreePlayer::NODE_TRANSITION) + node_popup->add_item(TTR("Add Input"), NODE_ADD_INPUT); + node_popup->set_position(rclick_pos + get_global_position()); + node_popup->popup(); + } + } + } + } else { - switch (click_type) { - case CLICK_INPUT_SLOT: - case CLICK_OUTPUT_SLOT: { + if (mb->get_button_index() == 1 && click_type != CLICK_NONE) { - Point2 dst_click_pos = Point2(p_event.mouse_button.x, p_event.mouse_button.y); - StringName id; - int slot; - ClickType dst_click_type = _locate_click(dst_click_pos, &id, &slot); + switch (click_type) { + case CLICK_INPUT_SLOT: + case CLICK_OUTPUT_SLOT: { - if (dst_click_type == CLICK_INPUT_SLOT && click_type == CLICK_OUTPUT_SLOT) { + Point2 dst_click_pos = Point2(mb->get_pos().x, mb->get_pos().y); + StringName id; + int slot; + ClickType dst_click_type = _locate_click(dst_click_pos, &id, &slot); - anim_tree->connect_nodes(click_node, id, slot); - } - if (click_type == CLICK_INPUT_SLOT && dst_click_type == CLICK_OUTPUT_SLOT) { + if (dst_click_type == CLICK_INPUT_SLOT && click_type == CLICK_OUTPUT_SLOT) { - anim_tree->connect_nodes(id, click_node, click_slot); - } + anim_tree->connect_nodes(click_node, id, slot); + } + if (click_type == CLICK_INPUT_SLOT && dst_click_type == CLICK_OUTPUT_SLOT) { - } break; - case CLICK_NODE: { - Point2 new_pos = anim_tree->node_get_pos(click_node) + (click_motion - click_pos); - if (new_pos.x < 5) - new_pos.x = 5; - if (new_pos.y < 5) - new_pos.y = 5; - anim_tree->node_set_pos(click_node, new_pos); - - } break; - default: {} - } + anim_tree->connect_nodes(id, click_node, click_slot); + } - click_type = CLICK_NONE; - update(); + } break; + case CLICK_NODE: { + Point2 new_pos = anim_tree->node_get_pos(click_node) + (click_motion - click_pos); + if (new_pos.x < 5) + new_pos.x = 5; + if (new_pos.y < 5) + new_pos.y = 5; + anim_tree->node_set_pos(click_node, new_pos); + + } break; + default: {} } + + click_type = CLICK_NONE; + update(); } } + } - case InputEvent::MOUSE_MOTION: { + Ref<InputEventMouseMotion> mm = p_event; - if (p_event.mouse_motion.button_mask & 1 && click_type != CLICK_NONE) { + if (mm.is_valid()) { - click_motion = Point2(p_event.mouse_button.x, p_event.mouse_button.y); - update(); - } - if ((p_event.mouse_motion.button_mask & 4 || Input::get_singleton()->is_key_pressed(KEY_SPACE))) { + if (mm->get_button_mask() & 1 && click_type != CLICK_NONE) { - h_scroll->set_value(h_scroll->get_value() - p_event.mouse_motion.relative_x); - v_scroll->set_value(v_scroll->get_value() - p_event.mouse_motion.relative_y); - update(); - } + click_motion = Point2(mm->get_pos().x, mm->get_pos().y); + update(); + } + if ((mm->get_button_mask() & 4 || Input::get_singleton()->is_key_pressed(KEY_SPACE))) { - } break; + h_scroll->set_value(h_scroll->get_value() - mm->get_relative().x); + v_scroll->set_value(v_scroll->get_value() - mm->get_relative().y); + update(); + } } } diff --git a/editor/plugins/animation_tree_editor_plugin.h b/editor/plugins/animation_tree_editor_plugin.h index 8bbe22387b..785f042dd9 100644 --- a/editor/plugins/animation_tree_editor_plugin.h +++ b/editor/plugins/animation_tree_editor_plugin.h @@ -155,7 +155,7 @@ class AnimationTreeEditor : public Control { protected: void _notification(int p_what); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); static void _bind_methods(); public: diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp index efb431839d..2f1a4ce115 100644 --- a/editor/plugins/canvas_item_editor_plugin.cpp +++ b/editor/plugins/canvas_item_editor_plugin.cpp @@ -204,17 +204,19 @@ void CanvasItemEditor::_edit_set_pivot(const Vector2 &mouse_pos) { undo_redo->commit_action(); } -void CanvasItemEditor::_unhandled_key_input(const InputEvent &p_ev) { +void CanvasItemEditor::_unhandled_key_input(const Ref<InputEvent> &p_ev) { + + Ref<InputEventKey> k = p_ev; if (!is_visible_in_tree() || get_viewport()->gui_has_modal_stack()) return; - if (p_ev.key.mod.control) + if (k->get_control()) return; - if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode == KEY_V && drag == DRAG_NONE && can_move_pivot) { + if (k->is_pressed() && !k->is_echo() && k->get_scancode() == KEY_V && drag == DRAG_NONE && can_move_pivot) { - if (p_ev.key.mod.shift) { + if (k->get_shift()) { //move drag pivot drag = DRAG_PIVOT; } else if (!Input::get_singleton()->is_mouse_button_pressed(0)) { @@ -958,9 +960,9 @@ bool CanvasItemEditor::get_remove_list(List<Node *> *p_list) { return false; //!p_list->empty(); } -void CanvasItemEditor::_list_select(const InputEventMouseButton &b) { +void CanvasItemEditor::_list_select(const Ref<InputEventMouseButton> &b) { - Point2 click = Point2(b.x, b.y); + Point2 click = b->get_pos(); Node *scene = editor->get_edited_scene(); if (!scene) @@ -982,7 +984,7 @@ void CanvasItemEditor::_list_select(const InputEventMouseButton &b) { CanvasItem *item = selection_results[0].item; selection_results.clear(); - additive_selection = b.mod.shift; + additive_selection = b->get_shift(); if (!_select(item, click, additive_selection, false)) return; @@ -1012,9 +1014,9 @@ void CanvasItemEditor::_list_select(const InputEventMouseButton &b) { "\nType: " + item->get_class() + "\nPath: " + node_path); } - additive_selection = b.mod.shift; + additive_selection = b->get_shift(); - selection_menu->set_global_position(Vector2(b.global_x, b.global_y)); + selection_menu->set_global_position(b->get_global_pos()); selection_menu->popup(); selection_menu->call_deferred("grab_click_focus"); selection_menu->set_invalidate_click_until_motion(); @@ -1023,7 +1025,7 @@ void CanvasItemEditor::_list_select(const InputEventMouseButton &b) { } } -void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { +void CanvasItemEditor::_viewport_gui_input(const Ref<InputEvent> &p_event) { { @@ -1039,19 +1041,19 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> b = p_event; - const InputEventMouseButton &b = p_event.mouse_button; + if (b.is_valid()) { - if (b.button_index == BUTTON_WHEEL_DOWN) { + if (b->get_button_index() == BUTTON_WHEEL_DOWN) { if (zoom < MIN_ZOOM) return; float prev_zoom = zoom; - zoom = zoom * (1 - (0.05 * b.factor)); + zoom = zoom * (1 - (0.05 * b->get_factor())); { - Point2 ofs(b.x, b.y); + Point2 ofs = b->get_pos(); ofs = ofs / prev_zoom - ofs / zoom; h_scroll->set_value(h_scroll->get_value() + ofs.x); v_scroll->set_value(v_scroll->get_value() + ofs.y); @@ -1061,15 +1063,15 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { return; } - if (b.button_index == BUTTON_WHEEL_UP) { + if (b->get_button_index() == BUTTON_WHEEL_UP) { if (zoom > MAX_ZOOM) return; float prev_zoom = zoom; - zoom = zoom * ((0.95 + (0.05 * b.factor)) / 0.95); + zoom = zoom * ((0.95 + (0.05 * b->get_factor())) / 0.95); { - Point2 ofs(b.x, b.y); + Point2 ofs = b->get_pos(); ofs = ofs / prev_zoom - ofs / zoom; h_scroll->set_value(h_scroll->get_value() + ofs.x); v_scroll->set_value(v_scroll->get_value() + ofs.y); @@ -1080,9 +1082,9 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { return; } - if (b.button_index == BUTTON_RIGHT) { + if (b->get_button_index() == BUTTON_RIGHT) { - if (b.pressed && (tool == TOOL_SELECT && b.mod.alt)) { + if (b->is_pressed() && (tool == TOOL_SELECT && b->get_alt())) { _list_select(b); return; @@ -1129,7 +1131,7 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { } else if (box_selecting) { box_selecting = false; viewport->update(); - } else if (b.pressed) { + } else if (b->is_pressed()) { #if 0 ref_item = NULL; Node* scene = get_scene()->get_root_node()->cast_to<EditorNode>()->get_edited_scene(); @@ -1145,16 +1147,16 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { return; */ - if (b.button_index == BUTTON_LEFT && tool == TOOL_LIST_SELECT) { - if (b.pressed) + if (b->get_button_index() == BUTTON_LEFT && tool == TOOL_LIST_SELECT) { + if (b->is_pressed()) _list_select(b); return; } - if (b.button_index == BUTTON_LEFT && tool == TOOL_EDIT_PIVOT) { - if (b.pressed) { + if (b->get_button_index() == BUTTON_LEFT && tool == TOOL_EDIT_PIVOT) { + if (b->is_pressed()) { - Point2 mouse_pos(b.x, b.y); + Point2 mouse_pos = b->get_pos(); mouse_pos = transform.affine_inverse().xform(mouse_pos); mouse_pos = snap_point(mouse_pos); _edit_set_pivot(mouse_pos); @@ -1162,10 +1164,10 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { return; } - if (tool == TOOL_PAN || b.button_index != BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE)) + if (tool == TOOL_PAN || b->get_button_index() != BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE)) return; - if (!b.pressed) { + if (!b->is_pressed()) { if (drag != DRAG_NONE) { @@ -1227,7 +1229,7 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { if (box_selecting) { #if 0 - if ( ! b.mod.shift ) _clear_canvas_items(); + if ( ! b->get_shift() ) _clear_canvas_items(); if ( box_selection_end() ) return; #endif @@ -1272,8 +1274,8 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { E->get().to }; - Vector2 p = Geometry::get_closest_point_to_segment_2d(Vector2(b.x, b.y), s); - float d = p.distance_to(Vector2(b.x, b.y)); + Vector2 p = Geometry::get_closest_point_to_segment_2d(b->get_pos(), s); + float d = p.distance_to(b->get_pos()); if (d < bone_width && d < closest_dist) { Cbone = E; closest_dist = d; @@ -1340,9 +1342,9 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item); ERR_FAIL_COND(!se); - Point2 click(b.x, b.y); + Point2 click = b->get_pos(); - if ((b.mod.control && tool == TOOL_SELECT) || tool == TOOL_ROTATE) { + if ((b->get_control() && tool == TOOL_SELECT) || tool == TOOL_ROTATE) { drag = DRAG_ROTATE; drag_from = transform.affine_inverse().xform(click); @@ -1361,7 +1363,7 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { if (tool == TOOL_SELECT) { drag = _find_drag_type(xform, rect, click, drag_point_from); - if (b.doubleclick) { + if (b->is_doubleclick()) { if (canvas_item->get_filename() != "" && canvas_item != editor->get_edited_scene()) { @@ -1386,9 +1388,9 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { //multi canvas_item edit - Point2 click = Point2(b.x, b.y); + Point2 click = b->get_pos(); - if ((b.mod.alt || tool == TOOL_MOVE) && get_item_count()) { + if ((b->get_alt() || tool == TOOL_MOVE) && get_item_count()) { _prepare_drag(click); viewport->update(); return; @@ -1433,37 +1435,36 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { }; c = n->cast_to<CanvasItem>(); #if 0 - if ( b.pressed ) box_selection_start( click ); + if ( b->is_pressed() ) box_selection_start( click ); #endif - additive_selection = b.mod.shift; + additive_selection = b->get_shift(); if (!_select(c, click, additive_selection)) return; } - if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> m = p_event; + if (m.is_valid()) { if (!viewport->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field())) viewport->call_deferred("grab_focus"); - const InputEventMouseMotion &m = p_event.mouse_motion; - if (box_selecting) { - box_selecting_to = transform.affine_inverse().xform(Point2(m.x, m.y)); + box_selecting_to = transform.affine_inverse().xform(m->get_pos()); viewport->update(); return; } if (drag == DRAG_NONE) { - if ((m.button_mask & BUTTON_MASK_LEFT && tool == TOOL_PAN) || m.button_mask & BUTTON_MASK_MIDDLE || (m.button_mask & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) { + if ((m->get_button_mask() & BUTTON_MASK_LEFT && tool == TOOL_PAN) || m->get_button_mask() & BUTTON_MASK_MIDDLE || (m->get_button_mask() & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) { Point2i relative; if (bool(EditorSettings::get_singleton()->get("editors/2d/warped_mouse_panning"))) { relative = Input::get_singleton()->warp_mouse_motion(m, viewport->get_global_rect()); } else { - relative = Point2i(m.relative_x, m.relative_y); + relative = m->get_relative(); } h_scroll->set_value(h_scroll->get_value() - relative.x / zoom); @@ -1496,7 +1497,7 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { } Vector2 dfrom = drag_from; - Vector2 dto = transform.affine_inverse().xform(Point2(m.x, m.y)); + Vector2 dto = transform.affine_inverse().xform(m->get_pos()); if (canvas_item->has_meta("_edit_lock_")) continue; @@ -1530,8 +1531,8 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { continue; } - bool uniform = m.mod.shift; - bool symmetric = m.mod.alt; + bool uniform = b->get_shift(); + bool symmetric = b->get_alt(); dto = dto - (drag == DRAG_ALL || drag == DRAG_NODE_2D ? drag_from - drag_point_from : Vector2(0, 0)); @@ -1765,25 +1766,25 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_event; - const InputEventKey &k = p_event.key; + if (k.is_valid()) { - if (k.pressed && drag == DRAG_NONE) { + if (k->is_pressed() && drag == DRAG_NONE) { KeyMoveMODE move_mode = MOVE_VIEW_BASE; - if (k.mod.alt) move_mode = MOVE_LOCAL_BASE; - if (k.mod.control || k.mod.meta) move_mode = MOVE_LOCAL_WITH_ROT; - - if (k.scancode == KEY_UP) - _key_move(Vector2(0, -1), k.mod.shift, move_mode); - else if (k.scancode == KEY_DOWN) - _key_move(Vector2(0, 1), k.mod.shift, move_mode); - else if (k.scancode == KEY_LEFT) - _key_move(Vector2(-1, 0), k.mod.shift, move_mode); - else if (k.scancode == KEY_RIGHT) - _key_move(Vector2(1, 0), k.mod.shift, move_mode); - else if (k.scancode == KEY_ESCAPE) { + if (k->get_alt()) move_mode = MOVE_LOCAL_BASE; + if (k->get_control() || k->get_metakey()) move_mode = MOVE_LOCAL_WITH_ROT; + + if (k->get_scancode() == KEY_UP) + _key_move(Vector2(0, -1), k->get_shift(), move_mode); + else if (k->get_scancode() == KEY_DOWN) + _key_move(Vector2(0, 1), k->get_shift(), move_mode); + else if (k->get_scancode() == KEY_LEFT) + _key_move(Vector2(-1, 0), k->get_shift(), move_mode); + else if (k->get_scancode() == KEY_RIGHT) + _key_move(Vector2(1, 0), k->get_shift(), move_mode); + else if (k->get_scancode() == KEY_ESCAPE) { editor_selection->clear(); viewport->update(); } else diff --git a/editor/plugins/canvas_item_editor_plugin.h b/editor/plugins/canvas_item_editor_plugin.h index 7f09b92f4c..22fa5b5db8 100644 --- a/editor/plugins/canvas_item_editor_plugin.h +++ b/editor/plugins/canvas_item_editor_plugin.h @@ -322,7 +322,7 @@ class CanvasItemEditor : public VBoxContainer { void _clear_canvas_items(); void _visibility_changed(ObjectID p_canvas_item); void _key_move(const Vector2 &p_dir, bool p_snap, KeyMoveMODE p_move_mode); - void _list_select(const InputEventMouseButton &b); + void _list_select(const Ref<InputEventMouseButton> &b); DragType _find_drag_type(const Transform2D &p_xform, const Rect2 &p_local_rect, const Point2 &p_click, Vector2 &r_point); void _prepare_drag(const Point2 &p_click_pos); @@ -352,9 +352,9 @@ class CanvasItemEditor : public VBoxContainer { int get_item_count(); void _keying_changed(); - void _unhandled_key_input(const InputEvent &p_ev); + void _unhandled_key_input(const Ref<InputEvent> &p_ev); - void _viewport_gui_input(const InputEvent &p_event); + void _viewport_gui_input(const Ref<InputEvent> &p_event); void _viewport_draw(); void _focus_selection(int p_op); diff --git a/editor/plugins/collision_polygon_2d_editor_plugin.cpp b/editor/plugins/collision_polygon_2d_editor_plugin.cpp index ae426ba29e..b7cfcaae02 100644 --- a/editor/plugins/collision_polygon_2d_editor_plugin.cpp +++ b/editor/plugins/collision_polygon_2d_editor_plugin.cpp @@ -94,213 +94,208 @@ void CollisionPolygon2DEditor::_wip_close() { edited_point = -1; } -bool CollisionPolygon2DEditor::forward_gui_input(const InputEvent &p_event) { +bool CollisionPolygon2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) return false; - switch (p_event.type) { + Ref<InputEventMouseButton> mb; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - const InputEventMouseButton &mb = p_event.mouse_button; + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + cpoint = node->get_global_transform().affine_inverse().xform(cpoint); - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Vector<Vector2> poly = node->get_polygon(); - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - cpoint = node->get_global_transform().affine_inverse().xform(cpoint); + //first check if a point is to be added (segment split) + real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); - Vector<Vector2> poly = node->get_polygon(); + switch (mode) { - //first check if a point is to be added (segment split) - real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); + case MODE_CREATE: { - switch (mode) { + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - case MODE_CREATE: { + if (!wip_active) { - if (mb.button_index == BUTTON_LEFT && mb.pressed) { + wip.clear(); + wip.push_back(cpoint); + wip_active = true; + edited_point_pos = cpoint; + canvas_item_editor->get_viewport_control()->update(); + edited_point = 1; + return true; + } else { - if (!wip_active) { + if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { + //wip closed + _wip_close(); - wip.clear(); - wip.push_back(cpoint); - wip_active = true; - edited_point_pos = cpoint; - canvas_item_editor->get_viewport_control()->update(); - edited_point = 1; return true; } else { - if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { - //wip closed - _wip_close(); - - return true; - } else { - - wip.push_back(cpoint); - edited_point = wip.size(); - canvas_item_editor->get_viewport_control()->update(); - return true; + wip.push_back(cpoint); + edited_point = wip.size(); + canvas_item_editor->get_viewport_control()->update(); + return true; - //add wip point - } + //add wip point } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && wip_active) { - _wip_close(); } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && wip_active) { + _wip_close(); + } - } break; - - case MODE_EDIT: { + } break; - if (mb.button_index == BUTTON_LEFT) { - if (mb.pressed) { + case MODE_EDIT: { - if (mb.mod.control) { + if (mb->get_button_index() == BUTTON_LEFT) { + if (mb->is_pressed()) { - if (poly.size() < 3) { + if (mb->get_control()) { - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_undo_method(node, "set_polygon", poly); - poly.push_back(cpoint); - undo_redo->add_do_method(node, "set_polygon", poly); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } - - //search edges - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { - - Vector2 points[2] = { xform.xform(poly[i]), - xform.xform(poly[(i + 1) % poly.size()]) }; - - Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); - if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) - continue; //not valid to reuse point - - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } - } - - if (closest_idx >= 0) { + if (poly.size() < 3) { - pre_move_edit = poly; - poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); - edited_point = closest_idx + 1; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - node->set_polygon(poly); - canvas_item_editor->get_viewport_control()->update(); - return true; - } - } else { + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_undo_method(node, "set_polygon", poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } - //look for points to move + //search edges + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { + Vector2 points[2] = { xform.xform(poly[i]), + xform.xform(poly[(i + 1) % poly.size()]) }; - Vector2 cp = xform.xform(poly[i]); + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); + if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) + continue; //not valid to reuse point - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; } + } - if (closest_idx >= 0) { + if (closest_idx >= 0) { - pre_move_edit = poly; - edited_point = closest_idx; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - canvas_item_editor->get_viewport_control()->update(); - return true; - } + pre_move_edit = poly; + poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); + edited_point = closest_idx + 1; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + node->set_polygon(poly); + canvas_item_editor->get_viewport_control()->update(); + return true; } } else { - if (edited_point != -1) { + //look for points to move - //apply + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - ERR_FAIL_INDEX_V(edited_point, poly.size(), false); - poly[edited_point] = edited_point_pos; - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_do_method(node, "set_polygon", poly); - undo_redo->add_undo_method(node, "set_polygon", pre_move_edit); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + Vector2 cp = xform.xform(poly[i]); - edited_point = -1; - return true; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } } - } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) { - - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { - Vector2 cp = xform.xform(poly[i]); + if (closest_idx >= 0) { - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; + pre_move_edit = poly; + edited_point = closest_idx; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + canvas_item_editor->get_viewport_control()->update(); + return true; } } + } else { + + if (edited_point != -1) { - if (closest_idx >= 0) { + //apply - undo_redo->create_action(TTR("Edit Poly (Remove Point)")); - undo_redo->add_undo_method(node, "set_polygon", poly); - poly.remove(closest_idx); + ERR_FAIL_INDEX_V(edited_point, poly.size(), false); + poly[edited_point] = edited_point_pos; + undo_redo->create_action(TTR("Edit Poly")); undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_undo_method(node, "set_polygon", pre_move_edit); undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->commit_action(); + + edited_point = -1; return true; } } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && edited_point == -1) { - } break; - } + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - } break; - case InputEvent::MOUSE_MOTION: { + Vector2 cp = xform.xform(poly[i]); - const InputEventMouseMotion &mm = p_event.mouse_motion; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } + } - if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) { + if (closest_idx >= 0) { - Vector2 gpoint = Point2(mm.x, mm.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + undo_redo->create_action(TTR("Edit Poly (Remove Point)")); + undo_redo->add_undo_method(node, "set_polygon", poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } + } - canvas_item_editor->get_viewport_control()->update(); - } + } break; + } + } - } break; + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { + + if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) { + + Vector2 gpoint = mm->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + + canvas_item_editor->get_viewport_control()->update(); + } } return false; diff --git a/editor/plugins/collision_polygon_2d_editor_plugin.h b/editor/plugins/collision_polygon_2d_editor_plugin.h index babe653581..382c0d6c37 100644 --- a/editor/plugins/collision_polygon_2d_editor_plugin.h +++ b/editor/plugins/collision_polygon_2d_editor_plugin.h @@ -80,7 +80,7 @@ protected: static void _bind_methods(); public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_collision_polygon); CollisionPolygon2DEditor(EditorNode *p_editor); }; @@ -93,7 +93,7 @@ class CollisionPolygon2DEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } virtual String get_name() const { return "CollisionPolygon2D"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/collision_polygon_editor_plugin.cpp b/editor/plugins/collision_polygon_editor_plugin.cpp index fdb1bf984e..c89e6f59a4 100644 --- a/editor/plugins/collision_polygon_editor_plugin.cpp +++ b/editor/plugins/collision_polygon_editor_plugin.cpp @@ -131,7 +131,7 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In - Vector2 gpoint=Point2(mb.x,mb.y); + Vector2 gpoint=Point2(mb->get_pos().x,mb->get_pos().y); Vector3 ray_from = p_camera->project_ray_origin(gpoint); Vector3 ray_dir = p_camera->project_ray_normal(gpoint); @@ -156,7 +156,7 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In case MODE_CREATE: { - if (mb.button_index==BUTTON_LEFT && mb.pressed) { + if (mb->get_button_index()==BUTTON_LEFT && mb->is_pressed()) { if (!wip_active) { @@ -186,7 +186,7 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In //add wip point } } - } else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) { + } else if (mb->get_button_index()==BUTTON_RIGHT && mb->is_pressed() && wip_active) { _wip_close(); } @@ -196,10 +196,10 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In case MODE_EDIT: { - if (mb.button_index==BUTTON_LEFT) { - if (mb.pressed) { + if (mb->get_button_index()==BUTTON_LEFT) { + if (mb->is_pressed()) { - if (mb.mod.control) { + if (mb->get_control()) { if (poly.size() < 3) { @@ -297,7 +297,7 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In return true; } } - } if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) { + } if (mb->get_button_index()==BUTTON_RIGHT && mb->is_pressed() && edited_point==-1) { @@ -344,7 +344,7 @@ bool CollisionPolygonEditor::forward_spatial_gui_input(Camera* p_camera,const In const InputEventMouseMotion &mm=p_event.mouse_motion; - if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) { + if (edited_point!=-1 && (wip_active || mm->get_button_mask()&BUTTON_MASK_LEFT)) { Vector2 gpoint = Point2(mm.x,mm.y); diff --git a/editor/plugins/collision_shape_2d_editor_plugin.cpp b/editor/plugins/collision_shape_2d_editor_plugin.cpp index 70cc81efb0..e2184c6158 100644 --- a/editor/plugins/collision_shape_2d_editor_plugin.cpp +++ b/editor/plugins/collision_shape_2d_editor_plugin.cpp @@ -302,7 +302,7 @@ void CollisionShape2DEditor::commit_handle(int idx, Variant &p_org) { undo_redo->commit_action(); } -bool CollisionShape2DEditor::forward_gui_input(const InputEvent &p_event) { +bool CollisionShape2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) { return false; @@ -316,68 +316,66 @@ bool CollisionShape2DEditor::forward_gui_input(const InputEvent &p_event) { return false; } - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { - const InputEventMouseButton &mb = p_event.mouse_button; + Ref<InputEventMouseButton> mb = p_event; - Transform2D gt = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + if (mb.is_valid()) { - Point2 gpoint(mb.x, mb.y); + Transform2D gt = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - if (mb.button_index == BUTTON_LEFT) { - if (mb.pressed) { - for (int i = 0; i < handles.size(); i++) { - if (gt.xform(handles[i]).distance_to(gpoint) < 8) { - edit_handle = i; + Point2 gpoint(mb->get_pos().x, mb->get_pos().y); - break; - } + if (mb->get_button_index() == BUTTON_LEFT) { + if (mb->is_pressed()) { + for (int i = 0; i < handles.size(); i++) { + if (gt.xform(handles[i]).distance_to(gpoint) < 8) { + edit_handle = i; + + break; } + } - if (edit_handle == -1) { - pressed = false; + if (edit_handle == -1) { + pressed = false; - return false; - } + return false; + } - original = get_handle_value(edit_handle); - pressed = true; + original = get_handle_value(edit_handle); + pressed = true; - return true; + return true; - } else { - if (pressed) { - commit_handle(edit_handle, original); + } else { + if (pressed) { + commit_handle(edit_handle, original); - edit_handle = -1; - pressed = false; + edit_handle = -1; + pressed = false; - return true; - } + return true; } } + } - return false; - - } break; + return false; + } - case InputEvent::MOUSE_MOTION: { - const InputEventMouseMotion &mm = p_event.mouse_motion; + Ref<InputEventMouseMotion> mm = p_event; - if (edit_handle == -1 || !pressed) { - return false; - } + if (mm.is_valid()) { - Point2 gpoint = Point2(mm.x, mm.y); - Point2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - cpoint = node->get_global_transform().affine_inverse().xform(cpoint); + if (edit_handle == -1 || !pressed) { + return false; + } - set_handle(edit_handle, cpoint); + Point2 gpoint = mm->get_pos(); + Point2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + cpoint = node->get_global_transform().affine_inverse().xform(cpoint); - return true; + set_handle(edit_handle, cpoint); - } break; + return true; } return false; diff --git a/editor/plugins/collision_shape_2d_editor_plugin.h b/editor/plugins/collision_shape_2d_editor_plugin.h index bbd94516a8..09aefc65c0 100644 --- a/editor/plugins/collision_shape_2d_editor_plugin.h +++ b/editor/plugins/collision_shape_2d_editor_plugin.h @@ -74,7 +74,7 @@ protected: static void _bind_methods(); public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_node); CollisionShape2DEditor(EditorNode *p_editor); @@ -87,7 +87,7 @@ class CollisionShape2DEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return collision_shape_2d_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return collision_shape_2d_editor->forward_gui_input(p_event); } virtual String get_name() const { return "CollisionShape2D"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/curve_editor_plugin.cpp b/editor/plugins/curve_editor_plugin.cpp index f3ad5c0fd1..6dd94863a1 100644 --- a/editor/plugins/curve_editor_plugin.cpp +++ b/editor/plugins/curve_editor_plugin.cpp @@ -33,9 +33,10 @@ #include "os/keyboard.h" #include "spatial_editor_plugin.h" -void CurveTextureEdit::_gui_input(const InputEvent &p_event) { +void CurveTextureEdit::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && grabbed != -1) { + Ref<InputEventKey> k = p_event; + if (k.is_valid() && k->is_pressed() && k->get_scancode() == KEY_DELETE && grabbed != -1) { points.remove(grabbed); grabbed = -1; @@ -44,7 +45,9 @@ void CurveTextureEdit::_gui_input(const InputEvent &p_event) { accept_event(); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { update(); Ref<Font> font = get_font("font", "Label"); @@ -54,7 +57,7 @@ void CurveTextureEdit::_gui_input(const InputEvent &p_event) { Vector2 size = get_size(); size.y -= font_h; - Point2 p = Vector2(p_event.mouse_button.x, p_event.mouse_button.y) / size; + Point2 p = Vector2(mb->get_pos().x, mb->get_pos().y) / size; p.y = CLAMP(1.0 - p.y, 0, 1) * (max - min) + min; grabbed = -1; grabbing = true; @@ -90,7 +93,7 @@ void CurveTextureEdit::_gui_input(const InputEvent &p_event) { emit_signal("curve_changed"); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && !p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && !mb->is_pressed()) { if (grabbing) { grabbing = false; @@ -99,14 +102,16 @@ void CurveTextureEdit::_gui_input(const InputEvent &p_event) { update(); } - if (p_event.type == InputEvent::MOUSE_MOTION && grabbing && grabbed != -1) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid() && grabbing && grabbed != -1) { Ref<Font> font = get_font("font", "Label"); int font_h = font->get_height(); Vector2 size = get_size(); size.y -= font_h; - Point2 p = Vector2(p_event.mouse_motion.x, p_event.mouse_motion.y) / size; + Point2 p = mm->get_pos() / size; p.y = CLAMP(1.0 - p.y, 0, 1) * (max - min) + min; p.x = CLAMP(p.x, 0.0, 1.0); diff --git a/editor/plugins/curve_editor_plugin.h b/editor/plugins/curve_editor_plugin.h index ebe05539aa..4e75ba407c 100644 --- a/editor/plugins/curve_editor_plugin.h +++ b/editor/plugins/curve_editor_plugin.h @@ -54,7 +54,7 @@ class CurveTextureEdit : public Control { void _plot_curve(const Vector2 &p_a, const Vector2 &p_b, const Vector2 &p_c, const Vector2 &p_d); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); static void _bind_methods(); diff --git a/editor/plugins/gradient_texture_editor_plugin.cpp b/editor/plugins/gradient_texture_editor_plugin.cpp index 005633a10e..40f7de478d 100644 --- a/editor/plugins/gradient_texture_editor_plugin.cpp +++ b/editor/plugins/gradient_texture_editor_plugin.cpp @@ -77,9 +77,11 @@ void GradientTextureEdit::_show_color_picker() { GradientTextureEdit::~GradientTextureEdit() { } -void GradientTextureEdit::_gui_input(const InputEvent &p_event) { +void GradientTextureEdit::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && grabbed != -1) { + Ref<InputEventKey> k = p_event; + + if (k.is_valid() && k->is_pressed() && k->get_scancode() == KEY_DELETE && grabbed != -1) { points.remove(grabbed); grabbed = -1; @@ -89,16 +91,17 @@ void GradientTextureEdit::_gui_input(const InputEvent &p_event) { accept_event(); } + Ref<InputEventMouseButton> mb = p_event; //Show color picker on double click. - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.doubleclick && p_event.mouse_button.pressed) { - grabbed = _get_point_from_pos(p_event.mouse_button.x); + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_doubleclick() && mb->is_pressed()) { + grabbed = _get_point_from_pos(mb->get_pos().x); _show_color_picker(); accept_event(); } //Delete point on right click - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 2 && p_event.mouse_button.pressed) { - grabbed = _get_point_from_pos(p_event.mouse_button.x); + if (mb.is_valid() && mb->get_button_index() == 2 && mb->is_pressed()) { + grabbed = _get_point_from_pos(mb->get_pos().x); if (grabbed != -1) { points.remove(grabbed); grabbed = -1; @@ -110,9 +113,9 @@ void GradientTextureEdit::_gui_input(const InputEvent &p_event) { } //Hold alt key to duplicate selected color - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed && p_event.key.mod.alt) { + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed() && mb->get_alt()) { - int x = p_event.mouse_button.x; + int x = mb->get_pos().x; grabbed = _get_point_from_pos(x); if (grabbed != -1) { @@ -134,10 +137,10 @@ void GradientTextureEdit::_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { update(); - int x = p_event.mouse_button.x; + int x = mb->get_pos().x; int total_w = get_size().width - get_size().height - 3; //Check if color selector was clicked. @@ -202,7 +205,7 @@ void GradientTextureEdit::_gui_input(const InputEvent &p_event) { emit_signal("ramp_changed"); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && !p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && !mb->is_pressed()) { if (grabbing) { grabbing = false; @@ -211,15 +214,17 @@ void GradientTextureEdit::_gui_input(const InputEvent &p_event) { update(); } - if (p_event.type == InputEvent::MOUSE_MOTION && grabbing) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid() && grabbing) { int total_w = get_size().width - get_size().height - 3; - int x = p_event.mouse_motion.x; + int x = mm->get_pos().x; float newofs = CLAMP(x / float(total_w), 0, 1); //Snap to nearest point if holding shift - if (p_event.key.mod.shift) { + if (mm->get_shift()) { float snap_treshhold = 0.03; float smallest_ofs = snap_treshhold; bool founded = false; diff --git a/editor/plugins/gradient_texture_editor_plugin.h b/editor/plugins/gradient_texture_editor_plugin.h index cb2f6b4061..842d586541 100644 --- a/editor/plugins/gradient_texture_editor_plugin.h +++ b/editor/plugins/gradient_texture_editor_plugin.h @@ -53,7 +53,7 @@ class GradientTextureEdit : public Control { void _show_color_picker(); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); static void _bind_methods(); diff --git a/editor/plugins/light_occluder_2d_editor_plugin.cpp b/editor/plugins/light_occluder_2d_editor_plugin.cpp index 73b615d817..9c9e010b47 100644 --- a/editor/plugins/light_occluder_2d_editor_plugin.cpp +++ b/editor/plugins/light_occluder_2d_editor_plugin.cpp @@ -98,225 +98,223 @@ void LightOccluder2DEditor::_wip_close(bool p_closed) { edited_point = -1; } -bool LightOccluder2DEditor::forward_gui_input(const InputEvent &p_event) { +bool LightOccluder2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) return false; if (node->get_occluder_polygon().is_null()) { - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + Ref<InputEventMouseButton> mb = p_event; + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { create_poly->set_text("No OccluderPolygon2D resource on this node.\nCreate and assign one?"); create_poly->popup_centered_minsize(); } - return (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1); + return (mb.is_valid() && mb->get_button_index() == 1); } - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { + Ref<InputEventMouseButton> mb = p_event; - const InputEventMouseButton &mb = p_event.mouse_button; + if (mb.is_valid()) { - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - cpoint = node->get_global_transform().affine_inverse().xform(cpoint); + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + cpoint = node->get_global_transform().affine_inverse().xform(cpoint); - Vector<Vector2> poly = Variant(node->get_occluder_polygon()->get_polygon()); + Vector<Vector2> poly = Variant(node->get_occluder_polygon()->get_polygon()); - //first check if a point is to be added (segment split) - real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); + //first check if a point is to be added (segment split) + real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); - switch (mode) { + switch (mode) { - case MODE_CREATE: { + case MODE_CREATE: { - if (mb.button_index == BUTTON_LEFT && mb.pressed) { + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - if (!wip_active) { + if (!wip_active) { - wip.clear(); - wip.push_back(cpoint); - wip_active = true; - edited_point_pos = cpoint; - canvas_item_editor->get_viewport_control()->update(); - edited_point = 1; - return true; - } else { + wip.clear(); + wip.push_back(cpoint); + wip_active = true; + edited_point_pos = cpoint; + canvas_item_editor->get_viewport_control()->update(); + edited_point = 1; + return true; + } else { - if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { - //wip closed - _wip_close(true); + if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { + //wip closed + _wip_close(true); - return true; - } else if (wip.size() > 1 && xform.xform(wip[wip.size() - 1]).distance_to(gpoint) < grab_treshold) { - //wip closed - _wip_close(false); - return true; + return true; + } else if (wip.size() > 1 && xform.xform(wip[wip.size() - 1]).distance_to(gpoint) < grab_treshold) { + //wip closed + _wip_close(false); + return true; - } else { + } else { - wip.push_back(cpoint); - edited_point = wip.size(); - canvas_item_editor->get_viewport_control()->update(); - return true; + wip.push_back(cpoint); + edited_point = wip.size(); + canvas_item_editor->get_viewport_control()->update(); + return true; - //add wip point - } + //add wip point } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && wip_active) { - _wip_close(true); } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && wip_active) { + _wip_close(true); + } - } break; - - case MODE_EDIT: { - - if (mb.button_index == BUTTON_LEFT) { - if (mb.pressed) { - - if (mb.mod.control) { + } break; - if (poly.size() < 3) { + case MODE_EDIT: { - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); - poly.push_back(cpoint); - undo_redo->add_do_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } + if (mb->get_button_index() == BUTTON_LEFT) { + if (mb->is_pressed()) { - //search edges - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { - - Vector2 points[2] = { xform.xform(poly[i]), - xform.xform(poly[(i + 1) % poly.size()]) }; - - Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); - if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) - continue; //not valid to reuse point - - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } - } + if (mb->get_control()) { - if (closest_idx >= 0) { + if (poly.size() < 3) { - pre_move_edit = poly; - poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); - edited_point = closest_idx + 1; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - node->get_occluder_polygon()->set_polygon(Variant(poly)); - canvas_item_editor->get_viewport_control()->update(); - return true; - } - } else { + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } - //look for points to move + //search edges + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { + Vector2 points[2] = { xform.xform(poly[i]), + xform.xform(poly[(i + 1) % poly.size()]) }; - Vector2 cp = xform.xform(poly[i]); + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); + if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) + continue; //not valid to reuse point - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; } + } - if (closest_idx >= 0) { + if (closest_idx >= 0) { - pre_move_edit = poly; - edited_point = closest_idx; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - canvas_item_editor->get_viewport_control()->update(); - return true; - } + pre_move_edit = poly; + poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); + edited_point = closest_idx + 1; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + node->get_occluder_polygon()->set_polygon(Variant(poly)); + canvas_item_editor->get_viewport_control()->update(); + return true; } } else { - if (edited_point != -1) { + //look for points to move - //apply + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - ERR_FAIL_INDEX_V(edited_point, poly.size(), false); - poly[edited_point] = edited_point_pos; - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_do_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); - undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", pre_move_edit); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + Vector2 cp = xform.xform(poly[i]); - edited_point = -1; - return true; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } } - } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) { - - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { - Vector2 cp = xform.xform(poly[i]); + if (closest_idx >= 0) { - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; + pre_move_edit = poly; + edited_point = closest_idx; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + canvas_item_editor->get_viewport_control()->update(); + return true; } } + } else { + + if (edited_point != -1) { - if (closest_idx >= 0) { + //apply - undo_redo->create_action(TTR("Edit Poly (Remove Point)")); - undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); - poly.remove(closest_idx); + ERR_FAIL_INDEX_V(edited_point, poly.size(), false); + poly[edited_point] = edited_point_pos; + undo_redo->create_action(TTR("Edit Poly")); undo_redo->add_do_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); + undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", pre_move_edit); undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->commit_action(); + + edited_point = -1; return true; } } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && edited_point == -1) { - } break; - } + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - } break; - case InputEvent::MOUSE_MOTION: { + Vector2 cp = xform.xform(poly[i]); - const InputEventMouseMotion &mm = p_event.mouse_motion; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } + } - if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) { + if (closest_idx >= 0) { - Vector2 gpoint = Point2(mm.x, mm.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + undo_redo->create_action(TTR("Edit Poly (Remove Point)")); + undo_redo->add_undo_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node->get_occluder_polygon().ptr(), "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } + } - canvas_item_editor->get_viewport_control()->update(); - } + } break; + } + } - } break; + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { + + if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) { + + Vector2 gpoint = mm->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + + canvas_item_editor->get_viewport_control()->update(); + } } return false; diff --git a/editor/plugins/light_occluder_2d_editor_plugin.h b/editor/plugins/light_occluder_2d_editor_plugin.h index 8e0817e61e..d6579fc94c 100644 --- a/editor/plugins/light_occluder_2d_editor_plugin.h +++ b/editor/plugins/light_occluder_2d_editor_plugin.h @@ -84,7 +84,7 @@ protected: public: Vector2 snap_point(const Vector2 &p_point) const; - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_collision_polygon); LightOccluder2DEditor(EditorNode *p_editor); }; @@ -97,7 +97,7 @@ class LightOccluder2DEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } virtual String get_name() const { return "LightOccluder2D"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/line_2d_editor_plugin.cpp b/editor/plugins/line_2d_editor_plugin.cpp index 4df0d2605a..3497af3602 100644 --- a/editor/plugins/line_2d_editor_plugin.cpp +++ b/editor/plugins/line_2d_editor_plugin.cpp @@ -75,7 +75,7 @@ int Line2DEditor::get_point_index_at(Vector2 gpos) { return -1; } -bool Line2DEditor::forward_gui_input(const InputEvent &p_event) { +bool Line2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) return false; @@ -83,75 +83,74 @@ bool Line2DEditor::forward_gui_input(const InputEvent &p_event) { if (!node->is_visible()) return false; - switch (p_event.type) { - - case InputEvent::MOUSE_BUTTON: { - - const InputEventMouseButton &mb = p_event.mouse_button; - - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = mouse_to_local_pos(gpoint, mb.mod.alt); - - if (mb.pressed && _dragging == false) { - int i = get_point_index_at(gpoint); - if (i != -1) { - if (mb.button_index == BUTTON_LEFT && !mb.mod.shift && mode == MODE_EDIT) { - _dragging = true; - action_point = i; - moving_from = node->get_point_pos(i); - moving_screen_from = gpoint; - } else if ((mb.button_index == BUTTON_RIGHT && mode == MODE_EDIT) || (mb.button_index == BUTTON_LEFT && mode == MODE_DELETE)) { - undo_redo->create_action(TTR("Remove Point from Line2D")); - undo_redo->add_do_method(node, "remove_point", i); - undo_redo->add_undo_method(node, "add_point", node->get_point_pos(i), i); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - } - return true; + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid()) { + + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = mouse_to_local_pos(gpoint, mb->get_alt()); + + if (mb->is_pressed() && _dragging == false) { + int i = get_point_index_at(gpoint); + if (i != -1) { + if (mb->get_button_index() == BUTTON_LEFT && !mb->get_shift() && mode == MODE_EDIT) { + _dragging = true; + action_point = i; + moving_from = node->get_point_pos(i); + moving_screen_from = gpoint; + } else if ((mb->get_button_index() == BUTTON_RIGHT && mode == MODE_EDIT) || (mb->get_button_index() == BUTTON_LEFT && mode == MODE_DELETE)) { + undo_redo->create_action(TTR("Remove Point from Line2D")); + undo_redo->add_do_method(node, "remove_point", i); + undo_redo->add_undo_method(node, "add_point", node->get_point_pos(i), i); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); } + return true; } + } - if (mb.pressed && mb.button_index == BUTTON_LEFT && ((mb.mod.command && mode == MODE_EDIT) || mode == MODE_CREATE)) { + if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && ((mb->get_command() && mode == MODE_EDIT) || mode == MODE_CREATE)) { - undo_redo->create_action(TTR("Add Point to Line2D")); - undo_redo->add_do_method(node, "add_point", cpoint); - undo_redo->add_undo_method(node, "remove_point", node->get_point_count()); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + undo_redo->create_action(TTR("Add Point to Line2D")); + undo_redo->add_do_method(node, "add_point", cpoint); + undo_redo->add_undo_method(node, "remove_point", node->get_point_count()); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); - _dragging = true; - action_point = node->get_point_count() - 1; - moving_from = node->get_point_pos(action_point); - moving_screen_from = gpoint; + _dragging = true; + action_point = node->get_point_count() - 1; + moving_from = node->get_point_pos(action_point); + moving_screen_from = gpoint; - canvas_item_editor->get_viewport_control()->update(); + canvas_item_editor->get_viewport_control()->update(); - return true; - } + return true; + } - if (!mb.pressed && mb.button_index == BUTTON_LEFT && _dragging) { - undo_redo->create_action(TTR("Move Point in Line2D")); - undo_redo->add_do_method(node, "set_point_pos", action_point, cpoint); - undo_redo->add_undo_method(node, "set_point_pos", action_point, moving_from); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - _dragging = false; - return true; - } - } break; - - case InputEvent::MOUSE_MOTION: { - if (_dragging) { - const InputEventMouseMotion &mm = p_event.mouse_motion; - Vector2 cpoint = mouse_to_local_pos(Vector2(mm.x, mm.y), mm.mod.alt); - node->set_point_pos(action_point, cpoint); - canvas_item_editor->get_viewport_control()->update(); - return true; - } - } break; + if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && _dragging) { + undo_redo->create_action(TTR("Move Point in Line2D")); + undo_redo->add_do_method(node, "set_point_pos", action_point, cpoint); + undo_redo->add_undo_method(node, "set_point_pos", action_point, moving_from); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + _dragging = false; + return true; + } + } + + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { + + if (_dragging) { + Vector2 cpoint = mouse_to_local_pos(mm->get_pos(), mm->get_alt()); + node->set_point_pos(action_point, cpoint); + canvas_item_editor->get_viewport_control()->update(); + return true; + } } return false; diff --git a/editor/plugins/line_2d_editor_plugin.h b/editor/plugins/line_2d_editor_plugin.h index 7477f7eee5..3a1f841556 100644 --- a/editor/plugins/line_2d_editor_plugin.h +++ b/editor/plugins/line_2d_editor_plugin.h @@ -43,7 +43,7 @@ class Line2DEditor : public HBoxContainer { GDCLASS(Line2DEditor, HBoxContainer) public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_line2d); Line2DEditor(EditorNode *p_editor); @@ -95,7 +95,7 @@ class Line2DEditorPlugin : public EditorPlugin { public: virtual bool forward_canvas_gui_input( const Transform2D &p_canvas_xform, - const InputEvent &p_event) { + const Ref<InputEvent> &p_event) { return line2d_editor->forward_gui_input(p_event); } diff --git a/editor/plugins/mesh_editor_plugin.cpp b/editor/plugins/mesh_editor_plugin.cpp index 61da860cab..f377d3a7cc 100644 --- a/editor/plugins/mesh_editor_plugin.cpp +++ b/editor/plugins/mesh_editor_plugin.cpp @@ -33,10 +33,10 @@ void MeshEditor::_gui_input(InputEvent p_event) { - if (p_event.type==InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) { + if (p_event.type==InputEvent::MOUSE_MOTION && p_event->get_button_mask()&BUTTON_MASK_LEFT) { - rot_x-=p_event.mouse_motion.relative_y*0.01; - rot_y-=p_event.mouse_motion.relative_x*0.01; + rot_x-=p_event->get_relative().y*0.01; + rot_y-=p_event->get_relative().x*0.01; if (rot_x<-Math_PI/2) rot_x=-Math_PI/2; else if (rot_x>Math_PI/2) { diff --git a/editor/plugins/navigation_polygon_editor_plugin.cpp b/editor/plugins/navigation_polygon_editor_plugin.cpp index be8c46f379..a7fc1d5adb 100644 --- a/editor/plugins/navigation_polygon_editor_plugin.cpp +++ b/editor/plugins/navigation_polygon_editor_plugin.cpp @@ -112,263 +112,262 @@ void NavigationPolygonEditor::_wip_close() { edited_point = -1; } -bool NavigationPolygonEditor::forward_gui_input(const InputEvent &p_event) { +bool NavigationPolygonEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) return false; if (node->get_navigation_polygon().is_null()) { - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { create_nav->set_text("No NavigationPolygon resource on this node.\nCreate and assign one?"); create_nav->popup_centered_minsize(); } - return (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1); + return (mb.is_valid() && mb->get_button_index() == 1); } - switch (p_event.type) { + Ref<InputEventMouseButton> mb = p_event; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_event.mouse_button; + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + cpoint = node->get_global_transform().affine_inverse().xform(cpoint); - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - cpoint = node->get_global_transform().affine_inverse().xform(cpoint); + //first check if a point is to be added (segment split) + real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); - //first check if a point is to be added (segment split) - real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); + switch (mode) { - switch (mode) { + case MODE_CREATE: { - case MODE_CREATE: { + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - if (mb.button_index == BUTTON_LEFT && mb.pressed) { + if (!wip_active) { - if (!wip_active) { + wip.clear(); + wip.push_back(cpoint); + wip_active = true; + edited_point_pos = cpoint; + edited_outline = -1; + canvas_item_editor->get_viewport_control()->update(); + edited_point = 1; + return true; + } else { + + if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { + //wip closed + _wip_close(); - wip.clear(); - wip.push_back(cpoint); - wip_active = true; - edited_point_pos = cpoint; - edited_outline = -1; - canvas_item_editor->get_viewport_control()->update(); - edited_point = 1; return true; } else { - if (wip.size() > 1 && xform.xform(wip[0]).distance_to(gpoint) < grab_treshold) { - //wip closed - _wip_close(); - - return true; - } else { - - wip.push_back(cpoint); - edited_point = wip.size(); - canvas_item_editor->get_viewport_control()->update(); - return true; + wip.push_back(cpoint); + edited_point = wip.size(); + canvas_item_editor->get_viewport_control()->update(); + return true; - //add wip point - } + //add wip point } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && wip_active) { - _wip_close(); } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && wip_active) { + _wip_close(); + } - } break; + } break; - case MODE_EDIT: { + case MODE_EDIT: { - if (mb.button_index == BUTTON_LEFT) { - if (mb.pressed) { + if (mb->get_button_index() == BUTTON_LEFT) { + if (mb->is_pressed()) { - if (mb.mod.control) { + if (mb->get_control()) { - //search edges - int closest_outline = -1; - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; + //search edges + int closest_outline = -1; + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; - for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { + for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { - PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); + PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); - int pc = points.size(); - PoolVector<Vector2>::Read poly = points.read(); + int pc = points.size(); + PoolVector<Vector2>::Read poly = points.read(); - for (int i = 0; i < pc; i++) { + for (int i = 0; i < pc; i++) { - Vector2 points[2] = { xform.xform(poly[i]), - xform.xform(poly[(i + 1) % pc]) }; + Vector2 points[2] = { xform.xform(poly[i]), + xform.xform(poly[(i + 1) % pc]) }; - Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); - if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) - continue; //not valid to reuse point + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); + if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) + continue; //not valid to reuse point - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_outline = j; - closest_pos = cp; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_outline = j; + closest_pos = cp; + closest_idx = i; } } + } - if (closest_idx >= 0) { - - pre_move_edit = node->get_navigation_polygon()->get_outline(closest_outline); - PoolVector<Point2> poly = pre_move_edit; - poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); - edited_point = closest_idx + 1; - edited_outline = closest_outline; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - node->get_navigation_polygon()->set_outline(closest_outline, poly); - canvas_item_editor->get_viewport_control()->update(); - return true; - } - } else { + if (closest_idx >= 0) { + + pre_move_edit = node->get_navigation_polygon()->get_outline(closest_outline); + PoolVector<Point2> poly = pre_move_edit; + poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos)); + edited_point = closest_idx + 1; + edited_outline = closest_outline; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + node->get_navigation_polygon()->set_outline(closest_outline, poly); + canvas_item_editor->get_viewport_control()->update(); + return true; + } + } else { - //look for points to move - int closest_outline = -1; - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; + //look for points to move + int closest_outline = -1; + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; - for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { + for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { - PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); + PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); - int pc = points.size(); - PoolVector<Vector2>::Read poly = points.read(); + int pc = points.size(); + PoolVector<Vector2>::Read poly = points.read(); - for (int i = 0; i < pc; i++) { + for (int i = 0; i < pc; i++) { - Vector2 cp = xform.xform(poly[i]); + Vector2 cp = xform.xform(poly[i]); - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_outline = j; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_outline = j; + closest_idx = i; } } + } - if (closest_idx >= 0) { + if (closest_idx >= 0) { - pre_move_edit = node->get_navigation_polygon()->get_outline(closest_outline); - edited_point = closest_idx; - edited_outline = closest_outline; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - canvas_item_editor->get_viewport_control()->update(); - return true; - } + pre_move_edit = node->get_navigation_polygon()->get_outline(closest_outline); + edited_point = closest_idx; + edited_outline = closest_outline; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + canvas_item_editor->get_viewport_control()->update(); + return true; } - } else { + } + } else { - if (edited_point != -1) { + if (edited_point != -1) { - //apply + //apply - PoolVector<Vector2> poly = node->get_navigation_polygon()->get_outline(edited_outline); - ERR_FAIL_INDEX_V(edited_point, poly.size(), false); - poly.set(edited_point, edited_point_pos); - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "set_outline", edited_outline, poly); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "set_outline", edited_outline, pre_move_edit); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + PoolVector<Vector2> poly = node->get_navigation_polygon()->get_outline(edited_outline); + ERR_FAIL_INDEX_V(edited_point, poly.size(), false); + poly.set(edited_point, edited_point_pos); + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "set_outline", edited_outline, poly); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "set_outline", edited_outline, pre_move_edit); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); - edited_point = -1; - return true; - } + edited_point = -1; + return true; } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) { + } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && edited_point == -1) { - int closest_outline = -1; - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; + int closest_outline = -1; + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; - for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { + for (int j = 0; j < node->get_navigation_polygon()->get_outline_count(); j++) { - PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); + PoolVector<Vector2> points = node->get_navigation_polygon()->get_outline(j); - int pc = points.size(); - PoolVector<Vector2>::Read poly = points.read(); + int pc = points.size(); + PoolVector<Vector2>::Read poly = points.read(); - for (int i = 0; i < pc; i++) { + for (int i = 0; i < pc; i++) { - Vector2 cp = xform.xform(poly[i]); + Vector2 cp = xform.xform(poly[i]); - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_outline = j; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_outline = j; + closest_idx = i; } } + } - if (closest_idx >= 0) { - - PoolVector<Vector2> poly = node->get_navigation_polygon()->get_outline(closest_outline); - - if (poly.size() > 3) { - undo_redo->create_action(TTR("Edit Poly (Remove Point)")); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "set_outline", closest_outline, poly); - poly.remove(closest_idx); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "set_outline", closest_outline, poly); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - } else { - - undo_redo->create_action(TTR("Remove Poly And Point")); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "add_outline_at_index", poly, closest_outline); - poly.remove(closest_idx); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "remove_outline", closest_outline); - undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - } - return true; + if (closest_idx >= 0) { + + PoolVector<Vector2> poly = node->get_navigation_polygon()->get_outline(closest_outline); + + if (poly.size() > 3) { + undo_redo->create_action(TTR("Edit Poly (Remove Point)")); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "set_outline", closest_outline, poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "set_outline", closest_outline, poly); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + } else { + + undo_redo->create_action(TTR("Remove Poly And Point")); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "add_outline_at_index", poly, closest_outline); + poly.remove(closest_idx); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "remove_outline", closest_outline); + undo_redo->add_do_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_undo_method(node->get_navigation_polygon().ptr(), "make_polygons_from_outlines"); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); } + return true; } + } - } break; - } - - } break; - case InputEvent::MOUSE_MOTION: { + } break; + } + } - const InputEventMouseMotion &mm = p_event.mouse_motion; + Ref<InputEventMouseMotion> mm = p_event; - if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) { + if (mm.is_valid()) { - Vector2 gpoint = Point2(mm.x, mm.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) { - canvas_item_editor->get_viewport_control()->update(); - } + Vector2 gpoint = mm->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); - } break; + canvas_item_editor->get_viewport_control()->update(); + } } return false; diff --git a/editor/plugins/navigation_polygon_editor_plugin.h b/editor/plugins/navigation_polygon_editor_plugin.h index 6de77b5ef3..62a83983fd 100644 --- a/editor/plugins/navigation_polygon_editor_plugin.h +++ b/editor/plugins/navigation_polygon_editor_plugin.h @@ -85,7 +85,7 @@ protected: static void _bind_methods(); public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_collision_polygon); NavigationPolygonEditor(EditorNode *p_editor); }; @@ -98,7 +98,7 @@ class NavigationPolygonEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } virtual String get_name() const { return "NavigationPolygonInstance"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/path_2d_editor_plugin.cpp b/editor/plugins/path_2d_editor_plugin.cpp index 045084d2ec..38a2a0c462 100644 --- a/editor/plugins/path_2d_editor_plugin.cpp +++ b/editor/plugins/path_2d_editor_plugin.cpp @@ -58,7 +58,7 @@ void Path2DEditor::_node_removed(Node *p_node) { } } -bool Path2DEditor::forward_gui_input(const InputEvent &p_event) { +bool Path2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node) return false; @@ -69,279 +69,299 @@ bool Path2DEditor::forward_gui_input(const InputEvent &p_event) { if (!node->get_curve().is_valid()) return false; - switch (p_event.type) { + Ref<InputEventMouseButton> mb = p_event; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_event.mouse_button; + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = !mb.mod.alt ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint))); - - //first check if a point is to be added (segment split) - real_t grab_threshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = !mb->get_alt() ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint))); + //first check if a point is to be added (segment split) + real_t grab_threshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); - // Test move point!! + // Test move point!! - if (mb.pressed && action == ACTION_NONE) { + if (mb->is_pressed() && action == ACTION_NONE) { - Ref<Curve2D> curve = node->get_curve(); + Ref<Curve2D> curve = node->get_curve(); - for (int i = 0; i < curve->get_point_count(); i++) { + for (int i = 0; i < curve->get_point_count(); i++) { - bool pointunder = false; + bool pointunder = false; - real_t dist_to_p = gpoint.distance_to(xform.xform(curve->get_point_pos(i))); - real_t dist_to_p_out = gpoint.distance_to(xform.xform(curve->get_point_pos(i) + curve->get_point_out(i))); - real_t dist_to_p_in = gpoint.distance_to(xform.xform(curve->get_point_pos(i) + curve->get_point_in(i))); + real_t dist_to_p = gpoint.distance_to(xform.xform(curve->get_point_pos(i))); + real_t dist_to_p_out = gpoint.distance_to(xform.xform(curve->get_point_pos(i) + curve->get_point_out(i))); + real_t dist_to_p_in = gpoint.distance_to(xform.xform(curve->get_point_pos(i) + curve->get_point_in(i))); - if (mb.button_index == BUTTON_LEFT && !mb.mod.shift && mode == MODE_EDIT) { - if (dist_to_p < grab_threshold) { + if (mb->get_button_index() == BUTTON_LEFT && !mb->get_shift() && mode == MODE_EDIT) { + if (dist_to_p < grab_threshold) { - action = ACTION_MOVING_POINT; - action_point = i; - moving_from = curve->get_point_pos(i); - moving_screen_from = gpoint; - return true; - } + action = ACTION_MOVING_POINT; + action_point = i; + moving_from = curve->get_point_pos(i); + moving_screen_from = gpoint; + return true; } + } - if ((mb.button_index == BUTTON_RIGHT && mode == MODE_EDIT) || (mb.button_index == BUTTON_LEFT && mode == MODE_DELETE)) { - if (dist_to_p < grab_threshold) { + if ((mb->get_button_index() == BUTTON_RIGHT && mode == MODE_EDIT) || (mb->get_button_index() == BUTTON_LEFT && mode == MODE_DELETE)) { + if (dist_to_p < grab_threshold) { - undo_redo->create_action(TTR("Remove Point from Curve")); - undo_redo->add_do_method(curve.ptr(), "remove_point", i); - undo_redo->add_undo_method(curve.ptr(), "add_point", curve->get_point_pos(i), curve->get_point_in(i), curve->get_point_out(i), i); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } else if (dist_to_p_out < grab_threshold) { + undo_redo->create_action(TTR("Remove Point from Curve")); + undo_redo->add_do_method(curve.ptr(), "remove_point", i); + undo_redo->add_undo_method(curve.ptr(), "add_point", curve->get_point_pos(i), curve->get_point_in(i), curve->get_point_out(i), i); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } else if (dist_to_p_out < grab_threshold) { - undo_redo->create_action(TTR("Remove Out-Control from Curve")); - undo_redo->add_do_method(curve.ptr(), "set_point_out", i, Vector2()); - undo_redo->add_undo_method(curve.ptr(), "set_point_out", i, curve->get_point_out(i)); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } else if (dist_to_p_in < grab_threshold) { + undo_redo->create_action(TTR("Remove Out-Control from Curve")); + undo_redo->add_do_method(curve.ptr(), "set_point_out", i, Vector2()); + undo_redo->add_undo_method(curve.ptr(), "set_point_out", i, curve->get_point_out(i)); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } else if (dist_to_p_in < grab_threshold) { - undo_redo->create_action(TTR("Remove In-Control from Curve")); - undo_redo->add_do_method(curve.ptr(), "set_point_in", i, Vector2()); - undo_redo->add_undo_method(curve.ptr(), "set_point_in", i, curve->get_point_in(i)); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } + undo_redo->create_action(TTR("Remove In-Control from Curve")); + undo_redo->add_do_method(curve.ptr(), "set_point_in", i, Vector2()); + undo_redo->add_undo_method(curve.ptr(), "set_point_in", i, curve->get_point_in(i)); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; } + } - if (dist_to_p < grab_threshold) - pointunder = true; + if (dist_to_p < grab_threshold) + pointunder = true; - if (mb.button_index == BUTTON_LEFT && i < (curve->get_point_count() - 1)) { - if (dist_to_p_out < grab_threshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) { + if (mb->get_button_index() == BUTTON_LEFT && i < (curve->get_point_count() - 1)) { + if (dist_to_p_out < grab_threshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) { - action = ACTION_MOVING_OUT; - action_point = i; - moving_from = curve->get_point_out(i); - moving_screen_from = gpoint; - return true; - } - } - - if (mb.button_index == BUTTON_LEFT && i > 0) { - if (dist_to_p_in < grab_threshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) { - - action = ACTION_MOVING_IN; - action_point = i; - moving_from = curve->get_point_in(i); - moving_screen_from = gpoint; - return true; - } - } + action_point = i; + moving_from = curve->get_point_pos(i); + moving_screen_from = gpoint; + return true; + } else if ((mb->get_button_index() == BUTTON_RIGHT && mode == MODE_EDIT) || (mb->get_button_index() == BUTTON_LEFT && mode == MODE_DELETE)) { - if (pointunder) + undo_redo->create_action(TTR("Remove Point from Curve")); + undo_redo->add_do_method(curve.ptr(), "remove_point", i); + undo_redo->add_undo_method(curve.ptr(), "add_point", curve->get_point_pos(i), curve->get_point_in(i), curve->get_point_out(i), i); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); return true; + } else + pointunder = true; + } + + if (pointunder) + return true; + } +#if 0 +I think i broke this, was this not suposed to go somewhere? + if (mb->get_button_index() == BUTTON_LEFT && i < (curve->get_point_count() - 1)) { + Point2 p = xform.xform(curve->get_point_pos(i) + curve->get_point_out(i)); + if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) { + action = ACTION_MOVING_OUT; + action_point = i; + moving_from = curve->get_point_out(i); + moving_screen_from = gpoint; + return true; } } - // Test add point in empty space! + if (mb->get_button_index() == BUTTON_LEFT && i > 0) { + Point2 p = xform.xform(curve->get_point_pos(i) + curve->get_point_in(i)); + if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode == MODE_EDIT_CURVE)) { - if (mb.pressed && mb.button_index == BUTTON_LEFT && ((mb.mod.command && mode == MODE_EDIT) || mode == MODE_CREATE)) { + action = ACTION_MOVING_IN; + action_point = i; + moving_from = curve->get_point_in(i); + moving_screen_from = gpoint; + return true; + } + } - Ref<Curve2D> curve = node->get_curve(); + if (pointunder) + return true; +#endif + } - undo_redo->create_action(TTR("Add Point to Curve")); - undo_redo->add_do_method(curve.ptr(), "add_point", cpoint); - undo_redo->add_undo_method(curve.ptr(), "remove_point", curve->get_point_count()); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + // Test add point in empty space! - action = ACTION_MOVING_POINT; - action_point = curve->get_point_count() - 1; - moving_from = curve->get_point_pos(action_point); - moving_screen_from = gpoint; + if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && ((mb->get_command() && mode == MODE_EDIT) || mode == MODE_CREATE)) { - canvas_item_editor->get_viewport_control()->update(); + Ref<Curve2D> curve = node->get_curve(); - return true; - } + undo_redo->create_action(TTR("Add Point to Curve")); + undo_redo->add_do_method(curve.ptr(), "add_point", cpoint); + undo_redo->add_undo_method(curve.ptr(), "remove_point", curve->get_point_count()); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); - if (!mb.pressed && mb.button_index == BUTTON_LEFT && action != ACTION_NONE) { + action = ACTION_MOVING_POINT; + action_point = curve->get_point_count() - 1; + moving_from = curve->get_point_pos(action_point); + moving_screen_from = gpoint; - Ref<Curve2D> curve = node->get_curve(); + canvas_item_editor->get_viewport_control()->update(); - Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from); - switch (action) { + return true; + } - case ACTION_MOVING_POINT: { + if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && action != ACTION_NONE) { - undo_redo->create_action(TTR("Move Point in Curve")); - undo_redo->add_do_method(curve.ptr(), "set_point_pos", action_point, cpoint); - undo_redo->add_undo_method(curve.ptr(), "set_point_pos", action_point, moving_from); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + Ref<Curve2D> curve = node->get_curve(); - } break; - case ACTION_MOVING_IN: { + Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from); + switch (action) { - undo_redo->create_action(TTR("Move In-Control in Curve")); - undo_redo->add_do_method(curve.ptr(), "set_point_in", action_point, new_pos); - undo_redo->add_undo_method(curve.ptr(), "set_point_in", action_point, moving_from); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + case ACTION_MOVING_POINT: { - } break; - case ACTION_MOVING_OUT: { + undo_redo->create_action(TTR("Move Point in Curve")); + undo_redo->add_do_method(curve.ptr(), "set_point_pos", action_point, cpoint); + undo_redo->add_undo_method(curve.ptr(), "set_point_pos", action_point, moving_from); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); - undo_redo->create_action(TTR("Move Out-Control in Curve")); - undo_redo->add_do_method(curve.ptr(), "set_point_out", action_point, new_pos); - undo_redo->add_undo_method(curve.ptr(), "set_point_out", action_point, moving_from); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + } break; + case ACTION_MOVING_IN: { - } break; - } + undo_redo->create_action(TTR("Move In-Control in Curve")); + undo_redo->add_do_method(curve.ptr(), "set_point_in", action_point, new_pos); + undo_redo->add_undo_method(curve.ptr(), "set_point_in", action_point, moving_from); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); - action = ACTION_NONE; + } break; + case ACTION_MOVING_OUT: { - return true; + undo_redo->create_action(TTR("Move Out-Control in Curve")); + undo_redo->add_do_method(curve.ptr(), "set_point_out", action_point, new_pos); + undo_redo->add_undo_method(curve.ptr(), "set_point_out", action_point, moving_from); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + + } break; } -#if 0 - switch(mode) { + action = ACTION_NONE; + return true; + } - case MODE_CREATE: { +#if 0 + switch(mode) { - if (mb.button_index==BUTTON_LEFT && mb.pressed) { + case MODE_CREATE: { - if (!wip_active) { + if (mb->get_button_index()==BUTTON_LEFT && mb->is_pressed()) { - wip.clear(); - wip.push_back( canvas_item_editor->snap_point(cpoint) ); - wip_active=true; - edited_point_pos=canvas_item_editor->snap_point(cpoint); - canvas_item_editor->update(); - edited_point=1; - return true; - } else { + if (!wip_active) { + + wip.clear(); + wip.push_back( canvas_item_editor->snap_point(cpoint) ); + wip_active=true; + edited_point_pos=canvas_item_editor->snap_point(cpoint); + canvas_item_editor->update(); + edited_point=1; + return true; + } else { if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_threshold) { //wip closed _wip_close(); + if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) { + //wip closed + _wip_close(); - return true; - } else { - wip.push_back( canvas_item_editor->snap_point(cpoint) ); - edited_point=wip.size(); - canvas_item_editor->update(); - return true; + return true; + } else { - //add wip point - } + wip.push_back( canvas_item_editor->snap_point(cpoint) ); + edited_point=wip.size(); + canvas_item_editor->update(); + return true; + + //add wip point } - } else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) { - _wip_close(); } + } else if (mb->get_button_index()==BUTTON_RIGHT && mb->is_pressed() && wip_active) { + _wip_close(); + } - } break; - - case MODE_EDIT: { + } break; - if (mb.button_index==BUTTON_LEFT) { - if (mb.pressed) { + case MODE_EDIT: { - if (mb.mod.control) { + if (mb->get_button_index()==BUTTON_LEFT) { + if (mb->is_pressed()) { + if (mb->get_control()) { - if (poly.size() < 3) { - - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_undo_method(node,"set_polygon",poly); - poly.push_back(cpoint); - undo_redo->add_do_method(node,"set_polygon",poly); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->commit_action(); - return true; - } - //search edges - int closest_idx=-1; - Vector2 closest_pos; - real_t closest_dist=1e10; - for(int i=0;i<poly.size();i++) { + if (poly.size() < 3) { - Vector2 points[2] ={ xform.xform(poly[i]), - xform.xform(poly[(i+1)%poly.size()]) }; + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->commit_action(); + return true; + } - Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points); - if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2) - continue; //not valid to reuse point + //search edges + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { - real_t d = cp.distance_to(gpoint); if (d<closest_dist && d<grab_threshold) { closest_dist=d; closest_pos=cp; closest_idx=i; } + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points); + if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2) + continue; //not valid to reuse point + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; } - if (closest_idx>=0) { - - pre_move_edit=poly; - poly.insert(closest_idx+1,canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos))); - edited_point=closest_idx+1; - edited_point_pos=canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos)); - node->set_polygon(poly); - canvas_item_editor->update(); - return true; - } - } else { - //look for points to move + } - int closest_idx=-1; - Vector2 closest_pos; - real_t closest_dist=1e10; - for(int i=0;i<poly.size();i++) { + if (closest_idx>=0) { - Vector2 cp =xform.xform(poly[i]); + pre_move_edit=poly; + poly.insert(closest_idx+1,canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos))); + edited_point=closest_idx+1; + edited_point_pos=canvas_item_editor->snap_point(xform.affine_inverse().xform(closest_pos)); + node->set_polygon(poly); + canvas_item_editor->update(); + return true; + } + } else { real_t d = cp.distance_to(gpoint); if (d<closest_dist && d<grab_threshold) { @@ -350,46 +370,51 @@ bool Path2DEditor::forward_gui_input(const InputEvent &p_event) { closest_idx=i; } - } + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { - if (closest_idx>=0) { + Vector2 cp =xform.xform(poly[i]); - pre_move_edit=poly; - edited_point=closest_idx; - edited_point_pos=xform.affine_inverse().xform(closest_pos); - canvas_item_editor->update(); - return true; + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; } - } - } else { - if (edited_point!=-1) { + } - //apply + if (closest_idx>=0) { - ERR_FAIL_INDEX_V(edited_point,poly.size(),false); - poly[edited_point]=edited_point_pos; - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_do_method(node,"set_polygon",poly); - undo_redo->add_undo_method(node,"set_polygon",pre_move_edit); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->commit_action(); - - edited_point=-1; + pre_move_edit=poly; + edited_point=closest_idx; + edited_point_pos=xform.affine_inverse().xform(closest_pos); + canvas_item_editor->update(); return true; } } - } if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) { + } else { + if (edited_point!=-1) { + //apply - int closest_idx=-1; - Vector2 closest_pos; - real_t closest_dist=1e10; - for(int i=0;i<poly.size();i++) { + ERR_FAIL_INDEX_V(edited_point,poly.size(),false); + poly[edited_point]=edited_point_pos; + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_undo_method(node,"set_polygon",pre_move_edit); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->commit_action(); - Vector2 cp =xform.xform(poly[i]); + edited_point=-1; + return true; + } + } + } if (mb->get_button_index()==BUTTON_RIGHT && mb->is_pressed() && edited_point==-1) { real_t d = cp.distance_to(gpoint); if (d<closest_dist && d<grab_threshold) { @@ -398,79 +423,93 @@ bool Path2DEditor::forward_gui_input(const InputEvent &p_event) { closest_idx=i; } + int closest_idx=-1; + Vector2 closest_pos; + real_t closest_dist=1e10; + for(int i=0;i<poly.size();i++) { + + Vector2 cp =xform.xform(poly[i]); + + real_t d = cp.distance_to(gpoint); + if (d<closest_dist && d<grab_treshold) { + closest_dist=d; + closest_pos=cp; + closest_idx=i; } - if (closest_idx>=0) { + } + if (closest_idx>=0) { - undo_redo->create_action(TTR("Edit Poly (Remove Point)")); - undo_redo->add_undo_method(node,"set_polygon",poly); - poly.remove(closest_idx); - undo_redo->add_do_method(node,"set_polygon",poly); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); - undo_redo->commit_action(); - return true; - } + undo_redo->create_action(TTR("Edit Poly (Remove Point)")); + undo_redo->add_undo_method(node,"set_polygon",poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node,"set_polygon",poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update"); + undo_redo->commit_action(); + return true; } + } - } break; - } + + } break; + } #endif - } break; - case InputEvent::MOUSE_MOTION: { + } - const InputEventMouseMotion &mm = p_event.mouse_motion; + Ref<InputEventMouseMotion> mm = p_event; - if (action != ACTION_NONE) { + if (mm.is_valid()) { - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Vector2 gpoint = Point2(mm.x, mm.y); - Vector2 cpoint = !mm.mod.alt ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint))); + if (action != ACTION_NONE) { - Ref<Curve2D> curve = node->get_curve(); + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Vector2 gpoint = mm->get_pos(); + Vector2 cpoint = !mm->get_alt() ? canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)) : node->get_global_transform().affine_inverse().xform(canvas_item_editor->snap_point(canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint))); - Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from); + Ref<Curve2D> curve = node->get_curve(); - switch (action) { + Vector2 new_pos = moving_from + xform.affine_inverse().basis_xform(gpoint - moving_screen_from); - case ACTION_MOVING_POINT: { + switch (action) { - curve->set_point_pos(action_point, cpoint); - } break; - case ACTION_MOVING_IN: { + case ACTION_MOVING_POINT: { - curve->set_point_in(action_point, new_pos); + curve->set_point_pos(action_point, cpoint); + } break; + case ACTION_MOVING_IN: { - } break; - case ACTION_MOVING_OUT: { + curve->set_point_in(action_point, new_pos); - curve->set_point_out(action_point, new_pos); + } break; + case ACTION_MOVING_OUT: { - } break; - } + curve->set_point_out(action_point, new_pos); - canvas_item_editor->get_viewport_control()->update(); - return true; + } break; } + canvas_item_editor->get_viewport_control()->update(); + return true; + } + #if 0 - if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) { + if (edited_point!=-1 && (wip_active || mm->get_button_mask()&BUTTON_MASK_LEFT)) { - Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Vector2 gpoint = Point2(mm.x,mm.y); - edited_point_pos = canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)); - canvas_item_editor->update(); + Vector2 gpoint = Point2(mm.x,mm.y); + edited_point_pos = canvas_item_editor->snap_point(xform.affine_inverse().xform(gpoint)); + canvas_item_editor->update(); - } + } #endif - } break; } return false; diff --git a/editor/plugins/path_2d_editor_plugin.h b/editor/plugins/path_2d_editor_plugin.h index 67c6f3c8cb..70911444ad 100644 --- a/editor/plugins/path_2d_editor_plugin.h +++ b/editor/plugins/path_2d_editor_plugin.h @@ -95,7 +95,7 @@ protected: static void _bind_methods(); public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_path2d); Path2DEditor(EditorNode *p_editor); }; @@ -108,7 +108,7 @@ class Path2DEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return path2d_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return path2d_editor->forward_gui_input(p_event); } virtual String get_name() const { return "Path2D"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/path_editor_plugin.cpp b/editor/plugins/path_editor_plugin.cpp index 9e18a5c4c5..12b6dce798 100644 --- a/editor/plugins/path_editor_plugin.cpp +++ b/editor/plugins/path_editor_plugin.cpp @@ -303,9 +303,9 @@ bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEve if (p_event.type==InputEvent::MOUSE_BUTTON) { const InputEventMouseButton &mb=p_event.mouse_button; - Point2 mbpos(mb.x,mb.y); + Point2 mbpos(mb->get_pos().x,mb->get_pos().y); - if (mb.pressed && mb.button_index==BUTTON_LEFT && (curve_create->is_pressed() || (curve_edit->is_pressed() && mb.mod.control))) { + if (mb->is_pressed() && mb->get_button_index()==BUTTON_LEFT && (curve_create->is_pressed() || (curve_edit->is_pressed() && mb->get_control()))) { //click into curve, break it down Vector3Array v3a = c->tesselate(); int idx=0; @@ -405,7 +405,7 @@ bool PathEditorPlugin::forward_spatial_gui_input(Camera* p_camera,const InputEve //add new at pos } - } else if (mb.pressed && ((mb.button_index==BUTTON_LEFT && curve_del->is_pressed()) || (mb.button_index==BUTTON_RIGHT && curve_edit->is_pressed()))) { + } else if (mb->is_pressed() && ((mb->get_button_index()==BUTTON_LEFT && curve_del->is_pressed()) || (mb->get_button_index()==BUTTON_RIGHT && curve_edit->is_pressed()))) { for(int i=0;i<c->get_point_count();i++) { real_t dist_to_p = p_camera->unproject_position(gt.xform(c->get_point_pos(i))).distance_to(mbpos); diff --git a/editor/plugins/polygon_2d_editor_plugin.cpp b/editor/plugins/polygon_2d_editor_plugin.cpp index 896a26c8e8..c2edc608ab 100644 --- a/editor/plugins/polygon_2d_editor_plugin.cpp +++ b/editor/plugins/polygon_2d_editor_plugin.cpp @@ -201,213 +201,209 @@ void Polygon2DEditor::_wip_close() { edited_point = -1; } -bool Polygon2DEditor::forward_gui_input(const InputEvent &p_event) { +bool Polygon2DEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (node == NULL) return false; - switch (p_event.type) { + Ref<InputEventMouseButton> mb = p_event; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_event.mouse_button; + Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); - Transform2D xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform(); + Vector2 gpoint = mb->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + cpoint = node->get_global_transform().affine_inverse().xform(cpoint); - Vector2 gpoint = Point2(mb.x, mb.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - cpoint = node->get_global_transform().affine_inverse().xform(cpoint); + Vector<Vector2> poly = Variant(node->get_polygon()); - Vector<Vector2> poly = Variant(node->get_polygon()); + //first check if a point is to be added (segment split) + real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); - //first check if a point is to be added (segment split) - real_t grab_treshold = EDITOR_DEF("editors/poly_editor/point_grab_radius", 8); + switch (mode) { - switch (mode) { + case MODE_CREATE: { - case MODE_CREATE: { + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - if (mb.button_index == BUTTON_LEFT && mb.pressed) { + if (!wip_active) { - if (!wip_active) { + wip.clear(); + wip.push_back(cpoint - node->get_offset()); + wip_active = true; + edited_point_pos = cpoint; + canvas_item_editor->get_viewport_control()->update(); + edited_point = 1; + return true; + } else { + + if (wip.size() > 1 && xform.xform(wip[0] + node->get_offset()).distance_to(gpoint) < grab_treshold) { + //wip closed + _wip_close(); - wip.clear(); - wip.push_back(cpoint - node->get_offset()); - wip_active = true; - edited_point_pos = cpoint; - canvas_item_editor->get_viewport_control()->update(); - edited_point = 1; return true; } else { - if (wip.size() > 1 && xform.xform(wip[0] + node->get_offset()).distance_to(gpoint) < grab_treshold) { - //wip closed - _wip_close(); - - return true; - } else { - - wip.push_back(cpoint - node->get_offset()); - edited_point = wip.size(); - canvas_item_editor->get_viewport_control()->update(); - return true; + wip.push_back(cpoint - node->get_offset()); + edited_point = wip.size(); + canvas_item_editor->get_viewport_control()->update(); + return true; - //add wip point - } + //add wip point } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && wip_active) { - _wip_close(); } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && wip_active) { + _wip_close(); + } - } break; - - case MODE_EDIT: { - - if (mb.button_index == BUTTON_LEFT) { - if (mb.pressed) { - - if (mb.mod.control) { + } break; - if (poly.size() < 3) { + case MODE_EDIT: { - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_undo_method(node, "set_polygon", poly); - poly.push_back(cpoint); - undo_redo->add_do_method(node, "set_polygon", poly); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); - return true; - } + if (mb->get_button_index() == BUTTON_LEFT) { + if (mb->is_pressed()) { - //search edges - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { - - Vector2 points[2] = { xform.xform(poly[i] + node->get_offset()), - xform.xform(poly[(i + 1) % poly.size()] + node->get_offset()) }; - - Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); - if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) - continue; //not valid to reuse point - - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } - } + if (mb->get_control()) { - if (closest_idx >= 0) { + if (poly.size() < 3) { - pre_move_edit = poly; - poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos) - node->get_offset()); - edited_point = closest_idx + 1; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - node->set_polygon(Variant(poly)); - canvas_item_editor->get_viewport_control()->update(); - return true; - } - } else { + undo_redo->create_action(TTR("Edit Poly")); + undo_redo->add_undo_method(node, "set_polygon", poly); + poly.push_back(cpoint); + undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } - //look for points to move + //search edges + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { + Vector2 points[2] = { xform.xform(poly[i] + node->get_offset()), + xform.xform(poly[(i + 1) % poly.size()] + node->get_offset()) }; - Vector2 cp = xform.xform(poly[i] + node->get_offset()); + Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint, points); + if (cp.distance_squared_to(points[0]) < CMP_EPSILON2 || cp.distance_squared_to(points[1]) < CMP_EPSILON2) + continue; //not valid to reuse point - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; - } + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; } + } - if (closest_idx >= 0) { + if (closest_idx >= 0) { - pre_move_edit = poly; - edited_point = closest_idx; - edited_point_pos = xform.affine_inverse().xform(closest_pos); - canvas_item_editor->get_viewport_control()->update(); - return true; - } + pre_move_edit = poly; + poly.insert(closest_idx + 1, xform.affine_inverse().xform(closest_pos) - node->get_offset()); + edited_point = closest_idx + 1; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + node->set_polygon(Variant(poly)); + canvas_item_editor->get_viewport_control()->update(); + return true; } } else { - if (edited_point != -1) { + //look for points to move - //apply + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - ERR_FAIL_INDEX_V(edited_point, poly.size(), false); - poly[edited_point] = edited_point_pos - node->get_offset(); - undo_redo->create_action(TTR("Edit Poly")); - undo_redo->add_do_method(node, "set_polygon", poly); - undo_redo->add_undo_method(node, "set_polygon", pre_move_edit); - undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); - undo_redo->commit_action(); + Vector2 cp = xform.xform(poly[i] + node->get_offset()); - edited_point = -1; - return true; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } } - } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) { - int closest_idx = -1; - Vector2 closest_pos; - real_t closest_dist = 1e10; - for (int i = 0; i < poly.size(); i++) { + if (closest_idx >= 0) { - Vector2 cp = xform.xform(poly[i] + node->get_offset()); - - real_t d = cp.distance_to(gpoint); - if (d < closest_dist && d < grab_treshold) { - closest_dist = d; - closest_pos = cp; - closest_idx = i; + pre_move_edit = poly; + edited_point = closest_idx; + edited_point_pos = xform.affine_inverse().xform(closest_pos); + canvas_item_editor->get_viewport_control()->update(); + return true; } } + } else { + + if (edited_point != -1) { - if (closest_idx >= 0) { + //apply - undo_redo->create_action(TTR("Edit Poly (Remove Point)")); - undo_redo->add_undo_method(node, "set_polygon", poly); - poly.remove(closest_idx); + ERR_FAIL_INDEX_V(edited_point, poly.size(), false); + poly[edited_point] = edited_point_pos - node->get_offset(); + undo_redo->create_action(TTR("Edit Poly")); undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_undo_method(node, "set_polygon", pre_move_edit); undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); undo_redo->commit_action(); + + edited_point = -1; return true; } } + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed() && edited_point == -1) { - } break; - } + int closest_idx = -1; + Vector2 closest_pos; + real_t closest_dist = 1e10; + for (int i = 0; i < poly.size(); i++) { - } break; - case InputEvent::MOUSE_MOTION: { + Vector2 cp = xform.xform(poly[i] + node->get_offset()); - const InputEventMouseMotion &mm = p_event.mouse_motion; + real_t d = cp.distance_to(gpoint); + if (d < closest_dist && d < grab_treshold) { + closest_dist = d; + closest_pos = cp; + closest_idx = i; + } + } - if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) { + if (closest_idx >= 0) { - Vector2 gpoint = Point2(mm.x, mm.y); - Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); - cpoint = canvas_item_editor->snap_point(cpoint); - edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + undo_redo->create_action(TTR("Edit Poly (Remove Point)")); + undo_redo->add_undo_method(node, "set_polygon", poly); + poly.remove(closest_idx); + undo_redo->add_do_method(node, "set_polygon", poly); + undo_redo->add_do_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(), "update"); + undo_redo->commit_action(); + return true; + } + } - canvas_item_editor->get_viewport_control()->update(); - } + } break; + } + } - } break; + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { + + if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) { + + Vector2 gpoint = mm->get_pos(); + Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint); + cpoint = canvas_item_editor->snap_point(cpoint); + edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint); + + canvas_item_editor->get_viewport_control()->update(); + } } return false; @@ -455,31 +451,31 @@ void Polygon2DEditor::_uv_mode(int p_mode) { } } -void Polygon2DEditor::_uv_input(const InputEvent &p_input) { +void Polygon2DEditor::_uv_input(const Ref<InputEvent> &p_input) { Transform2D mtx; mtx.elements[2] = -uv_draw_ofs; mtx.scale_basis(Vector2(uv_draw_zoom, uv_draw_zoom)); - if (p_input.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_input; - const InputEventMouseButton &mb = p_input.mouse_button; + if (mb.is_valid()) { - if (mb.button_index == BUTTON_LEFT) { + if (mb->get_button_index() == BUTTON_LEFT) { - if (mb.pressed) { + if (mb->is_pressed()) { - uv_drag_from = Vector2(mb.x, mb.y); + uv_drag_from = Vector2(mb->get_pos().x, mb->get_pos().y); uv_drag = true; uv_prev = node->get_uv(); uv_move_current = uv_mode; if (uv_move_current == UV_MODE_EDIT_POINT) { - if (mb.mod.shift && mb.mod.command) + if (mb->get_shift() && mb->get_command()) uv_move_current = UV_MODE_SCALE; - else if (mb.mod.shift) + else if (mb->get_shift()) uv_move_current = UV_MODE_MOVE; - else if (mb.mod.command) + else if (mb->get_command()) uv_move_current = UV_MODE_ROTATE; } @@ -489,7 +485,7 @@ void Polygon2DEditor::_uv_input(const InputEvent &p_input) { for (int i = 0; i < uv_prev.size(); i++) { Vector2 tuv = mtx.xform(uv_prev[i]); - if (tuv.distance_to(Vector2(mb.x, mb.y)) < 8) { + if (tuv.distance_to(Vector2(mb->get_pos().x, mb->get_pos().y)) < 8) { uv_drag_from = tuv; uv_drag_index = i; } @@ -511,7 +507,7 @@ void Polygon2DEditor::_uv_input(const InputEvent &p_input) { uv_drag = false; } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed) { + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed()) { if (uv_drag) { @@ -520,27 +516,28 @@ void Polygon2DEditor::_uv_input(const InputEvent &p_input) { uv_edit_draw->update(); } - } else if (mb.button_index == BUTTON_WHEEL_UP && mb.pressed) { + } else if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) { - uv_zoom->set_value(uv_zoom->get_value() / (1 - (0.1 * mb.factor))); - } else if (mb.button_index == BUTTON_WHEEL_DOWN && mb.pressed) { + uv_zoom->set_value(uv_zoom->get_value() / (1 - (0.1 * mb->get_factor()))); + } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) { - uv_zoom->set_value(uv_zoom->get_value() * (1 - (0.1 * mb.factor))); + uv_zoom->set_value(uv_zoom->get_value() * (1 - (0.1 * mb->get_factor()))); } + } - } else if (p_input.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_input; - const InputEventMouseMotion &mm = p_input.mouse_motion; + if (mm.is_valid()) { - if (mm.button_mask & BUTTON_MASK_MIDDLE || Input::get_singleton()->is_key_pressed(KEY_SPACE)) { + if (mm->get_button_mask() & BUTTON_MASK_MIDDLE || Input::get_singleton()->is_key_pressed(KEY_SPACE)) { - Vector2 drag(mm.relative_x, mm.relative_y); + Vector2 drag(mm->get_relative().x, mm->get_relative().y); uv_hscroll->set_value(uv_hscroll->get_value() - drag.x); uv_vscroll->set_value(uv_vscroll->get_value() - drag.y); } else if (uv_drag) { - Vector2 uv_drag_to = snap_point(Vector2(mm.x, mm.y)); + Vector2 uv_drag_to = mm->get_pos(); Vector2 drag = mtx.affine_inverse().xform(uv_drag_to) - mtx.affine_inverse().xform(uv_drag_from); switch (uv_move_current) { diff --git a/editor/plugins/polygon_2d_editor_plugin.h b/editor/plugins/polygon_2d_editor_plugin.h index 00926bf2d1..0901cc9082 100644 --- a/editor/plugins/polygon_2d_editor_plugin.h +++ b/editor/plugins/polygon_2d_editor_plugin.h @@ -113,7 +113,7 @@ class Polygon2DEditor : public HBoxContainer { Vector2 snap_step; void _uv_scroll_changed(float); - void _uv_input(const InputEvent &p_input); + void _uv_input(const Ref<InputEvent> &p_input); void _uv_draw(); void _uv_mode(int p_mode); void _wip_close(); @@ -135,7 +135,7 @@ protected: Vector2 snap_point(Vector2 p_target) const; public: - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_collision_polygon); Polygon2DEditor(EditorNode *p_editor); }; @@ -148,7 +148,7 @@ class Polygon2DEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return collision_polygon_editor->forward_gui_input(p_event); } virtual String get_name() const { return "Polygon2D"; } bool has_main_screen() const { return false; } diff --git a/editor/plugins/resource_preloader_editor_plugin.cpp b/editor/plugins/resource_preloader_editor_plugin.cpp index 3b8d655af7..ea7a84d2f4 100644 --- a/editor/plugins/resource_preloader_editor_plugin.cpp +++ b/editor/plugins/resource_preloader_editor_plugin.cpp @@ -33,7 +33,7 @@ #include "global_config.h" #include "io/resource_loader.h" -void ResourcePreloaderEditor::_gui_input(InputEvent p_event) { +void ResourcePreloaderEditor::_gui_input(Ref<InputEvent> p_event) { } void ResourcePreloaderEditor::_notification(int p_what) { diff --git a/editor/plugins/resource_preloader_editor_plugin.h b/editor/plugins/resource_preloader_editor_plugin.h index fad3ba93f1..1f54620ba4 100644 --- a/editor/plugins/resource_preloader_editor_plugin.h +++ b/editor/plugins/resource_preloader_editor_plugin.h @@ -70,7 +70,7 @@ class ResourcePreloaderEditor : public PanelContainer { protected: void _notification(int p_what); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); static void _bind_methods(); public: diff --git a/editor/plugins/script_editor_plugin.cpp b/editor/plugins/script_editor_plugin.cpp index 4582108210..d369064050 100644 --- a/editor/plugins/script_editor_plugin.cpp +++ b/editor/plugins/script_editor_plugin.cpp @@ -164,14 +164,16 @@ void ScriptEditorQuickOpen::_text_changed(const String &p_newtext) { _update_search(); } -void ScriptEditorQuickOpen::_sbox_input(const InputEvent &p_ie) { +void ScriptEditorQuickOpen::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY && (p_ie.key.scancode == KEY_UP || - p_ie.key.scancode == KEY_DOWN || - p_ie.key.scancode == KEY_PAGEUP || - p_ie.key.scancode == KEY_PAGEDOWN)) { + Ref<InputEventKey> k = p_ie; - search_options->call("_gui_input", p_ie); + if (k.is_valid() && (k->get_scancode() == KEY_UP || + k->get_scancode() == KEY_DOWN || + k->get_scancode() == KEY_PAGEUP || + k->get_scancode() == KEY_PAGEDOWN)) { + + search_options->call("_gui_input", k); search_box->accept_event(); } } @@ -1778,8 +1780,8 @@ void ScriptEditor::_script_split_dragged(float) { _save_layout(); } -void ScriptEditor::_unhandled_input(const InputEvent &p_event) { - if (p_event.key.pressed || !is_visible_in_tree()) return; +void ScriptEditor::_unhandled_input(const Ref<InputEvent> &p_event) { + if (p_event->is_pressed() || !is_visible_in_tree()) return; if (ED_IS_SHORTCUT("script_editor/next_script", p_event)) { int next_tab = script_list->get_current() + 1; next_tab %= script_list->get_item_count(); diff --git a/editor/plugins/script_editor_plugin.h b/editor/plugins/script_editor_plugin.h index 983847ddaf..fb2f108277 100644 --- a/editor/plugins/script_editor_plugin.h +++ b/editor/plugins/script_editor_plugin.h @@ -54,7 +54,7 @@ class ScriptEditorQuickOpen : public ConfirmationDialog { void _update_search(); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); Vector<String> functions; void _confirmed(); @@ -288,7 +288,7 @@ class ScriptEditor : public VBoxContainer { void _script_split_dragged(float); - void _unhandled_input(const InputEvent &p_event); + void _unhandled_input(const Ref<InputEvent> &p_event); void _help_search(String p_text); diff --git a/editor/plugins/script_text_editor.cpp b/editor/plugins/script_text_editor.cpp index 3bb1c7852b..2d3a14e525 100644 --- a/editor/plugins/script_text_editor.cpp +++ b/editor/plugins/script_text_editor.cpp @@ -124,7 +124,6 @@ void ScriptTextEditor::_load_theme_settings() { text_edit->add_keyword_color("Transform", basetype_color); text_edit->add_keyword_color("Color", basetype_color); text_edit->add_keyword_color("Image", basetype_color); - text_edit->add_keyword_color("InputEvent", basetype_color); text_edit->add_keyword_color("Rect2", basetype_color); text_edit->add_keyword_color("NodePath", basetype_color); @@ -1227,15 +1226,18 @@ void ScriptTextEditor::drop_data_fw(const Point2 &p_point, const Variant &p_data } } -void ScriptTextEditor::_text_edit_gui_input(const InputEvent &ev) { - if (ev.type == InputEvent::MOUSE_BUTTON) { - InputEventMouseButton mb = ev.mouse_button; - if (mb.button_index == BUTTON_RIGHT && !mb.pressed) { +void ScriptTextEditor::_text_edit_gui_input(const Ref<InputEvent> &ev) { + + Ref<InputEventMouseButton> mb = ev; + + if (mb.is_valid()) { + + if (mb->get_button_index() == BUTTON_RIGHT && !mb->is_pressed()) { int col, row; TextEdit *tx = code_editor->get_text_edit(); - tx->_get_mouse_pos(Point2i(mb.global_x, mb.global_y) - tx->get_global_position(), row, col); - Vector2 mpos = Vector2(mb.global_x, mb.global_y) - tx->get_global_position(); + tx->_get_mouse_pos(mb->get_global_pos() - tx->get_global_position(), row, col); + Vector2 mpos = mb->get_global_pos() - tx->get_global_position(); bool have_selection = (tx->get_selection_text().length() > 0); bool have_color = (tx->get_word_at_pos(mpos) == "Color"); if (have_color) { diff --git a/editor/plugins/script_text_editor.h b/editor/plugins/script_text_editor.h index 77bce59f2e..fdae03949c 100644 --- a/editor/plugins/script_text_editor.h +++ b/editor/plugins/script_text_editor.h @@ -106,7 +106,7 @@ protected: void _edit_option(int p_op); void _make_context_menu(bool p_selection, bool p_color); - void _text_edit_gui_input(const InputEvent &ev); + void _text_edit_gui_input(const Ref<InputEvent> &ev); void _color_changed(const Color &p_color); void _goto_line(int p_line) { goto_line(p_line); } diff --git a/editor/plugins/shader_graph_editor_plugin.cpp b/editor/plugins/shader_graph_editor_plugin.cpp index 0fd28a0b59..9c65ef667a 100644 --- a/editor/plugins/shader_graph_editor_plugin.cpp +++ b/editor/plugins/shader_graph_editor_plugin.cpp @@ -40,7 +40,7 @@ void GraphColorRampEdit::_gui_input(const InputEvent& p_event) { - if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) { + if (p_event.type==InputEvent::KEY && p_event->is_pressed() && p_event->get_scancode()==KEY_DELETE && grabbed!=-1) { points.remove(grabbed); grabbed=-1; @@ -49,10 +49,10 @@ void GraphColorRampEdit::_gui_input(const InputEvent& p_event) { accept_event(); } - if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) { + if (p_event.type==InputEvent::MOUSE_BUTTON && p_event->get_button_index()==1 && p_event->is_pressed()) { update(); - int x = p_event.mouse_button.x; + int x = p_event->get_pos().x; int total_w = get_size().width-get_size().height-3; if (x>total_w+3) { @@ -132,7 +132,7 @@ void GraphColorRampEdit::_gui_input(const InputEvent& p_event) { } - if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) { + if (p_event.type==InputEvent::MOUSE_BUTTON && p_event->get_button_index()==1 && !p_event->is_pressed()) { if (grabbing) { grabbing=false; @@ -319,7 +319,7 @@ GraphColorRampEdit::GraphColorRampEdit(){ void GraphCurveMapEdit::_gui_input(const InputEvent& p_event) { - if (p_event.type==InputEvent::KEY && p_event.key.pressed && p_event.key.scancode==KEY_DELETE && grabbed!=-1) { + if (p_event.type==InputEvent::KEY && p_event->is_pressed() && p_event->get_scancode()==KEY_DELETE && grabbed!=-1) { points.remove(grabbed); grabbed=-1; @@ -328,10 +328,10 @@ void GraphCurveMapEdit::_gui_input(const InputEvent& p_event) { accept_event(); } - if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) { + if (p_event.type==InputEvent::MOUSE_BUTTON && p_event->get_button_index()==1 && p_event->is_pressed()) { update(); - Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size(); + Point2 p = Vector2(p_event->get_pos().x,p_event->get_pos().y)/get_size(); p.y=1.0-p.y; grabbed=-1; grabbing=true; @@ -371,7 +371,7 @@ void GraphCurveMapEdit::_gui_input(const InputEvent& p_event) { } - if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && !p_event.mouse_button.pressed) { + if (p_event.type==InputEvent::MOUSE_BUTTON && p_event->get_button_index()==1 && !p_event->is_pressed()) { if (grabbing) { grabbing=false; @@ -382,7 +382,7 @@ void GraphCurveMapEdit::_gui_input(const InputEvent& p_event) { if (p_event.type==InputEvent::MOUSE_MOTION && grabbing && grabbed != -1) { - Point2 p = Vector2(p_event.mouse_button.x,p_event.mouse_button.y)/get_size(); + Point2 p = Vector2(p_event->get_pos().x,p_event->get_pos().y)/get_size(); p.y=1.0-p.y; p.x = CLAMP(p.x,0.0,1.0); diff --git a/editor/plugins/spatial_editor_plugin.cpp b/editor/plugins/spatial_editor_plugin.cpp index 91900465a5..c4595b477e 100644 --- a/editor/plugins/spatial_editor_plugin.cpp +++ b/editor/plugins/spatial_editor_plugin.cpp @@ -634,9 +634,9 @@ void SpatialEditorViewport::_smouseenter() { surface->grab_focus(); } -void SpatialEditorViewport::_list_select(InputEventMouseButton b) { +void SpatialEditorViewport::_list_select(Ref<InputEventMouseButton> b) { - _find_items_at_pos(Vector2(b.x, b.y), clicked_includes_current, selection_results, b.mod.shift); + _find_items_at_pos(b->get_pos(), clicked_includes_current, selection_results, b->get_shift()); Node *scene = editor->get_edited_scene(); @@ -649,7 +649,7 @@ void SpatialEditorViewport::_list_select(InputEventMouseButton b) { } } - clicked_wants_append = b.mod.shift; + clicked_wants_append = b->get_shift(); if (selection_results.size() == 1) { @@ -684,13 +684,13 @@ void SpatialEditorViewport::_list_select(InputEventMouseButton b) { selection_menu->set_item_tooltip(i, String(spat->get_name()) + "\nType: " + spat->get_class() + "\nPath: " + node_path); } - selection_menu->set_global_position(Vector2(b.global_x, b.global_y)); + selection_menu->set_global_position(b->get_global_pos()); selection_menu->popup(); selection_menu->call_deferred("grab_click_focus"); selection_menu->set_invalidate_click_until_motion(); } } -void SpatialEditorViewport::_sinput(const InputEvent &p_event) { +void SpatialEditorViewport::_sinput(const Ref<InputEvent> &p_event) { if (previewing) return; //do NONE @@ -707,800 +707,802 @@ void SpatialEditorViewport::_sinput(const InputEvent &p_event) { } } - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { + Ref<InputEventMouseButton> b = p_event; - const InputEventMouseButton &b = p_event.mouse_button; + if (b.is_valid()) { - switch (b.button_index) { + switch (b->get_button_index()) { - case BUTTON_WHEEL_UP: { - scale_cursor_distance(is_freelook_active() ? ZOOM_MULTIPLIER : 1.0 / ZOOM_MULTIPLIER); - } break; + case BUTTON_WHEEL_UP: { + scale_cursor_distance(is_freelook_active() ? ZOOM_MULTIPLIER : 1.0 / ZOOM_MULTIPLIER); + } break; - case BUTTON_WHEEL_DOWN: { - scale_cursor_distance(is_freelook_active() ? 1.0 / ZOOM_MULTIPLIER : ZOOM_MULTIPLIER); - } break; + case BUTTON_WHEEL_DOWN: { + scale_cursor_distance(is_freelook_active() ? 1.0 / ZOOM_MULTIPLIER : ZOOM_MULTIPLIER); + } break; - case BUTTON_RIGHT: { + case BUTTON_RIGHT: { - NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); + NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); - if (b.pressed && _edit.gizmo.is_valid()) { - //restore - _edit.gizmo->commit_handle(_edit.gizmo_handle, _edit.gizmo_initial_value, true); - _edit.gizmo = Ref<SpatialEditorGizmo>(); - } + if (b->is_pressed() && _edit.gizmo.is_valid()) { + //restore + _edit.gizmo->commit_handle(_edit.gizmo_handle, _edit.gizmo_initial_value, true); + _edit.gizmo = Ref<SpatialEditorGizmo>(); + } - if (_edit.mode == TRANSFORM_NONE && b.pressed) { + if (_edit.mode == TRANSFORM_NONE && b->is_pressed()) { - if (b.mod.alt) { + if (b->get_alt()) { - if (nav_scheme == NAVIGATION_MAYA) - break; + if (nav_scheme == NAVIGATION_MAYA) + break; - _list_select(b); - return; - } + _list_select(b); + return; } + } - if (_edit.mode != TRANSFORM_NONE && b.pressed) { - //cancel motion - _edit.mode = TRANSFORM_NONE; - //_validate_selection(); + if (_edit.mode != TRANSFORM_NONE && b->is_pressed()) { + //cancel motion + _edit.mode = TRANSFORM_NONE; + //_validate_selection(); - List<Node *> &selection = editor_selection->get_selected_node_list(); + List<Node *> &selection = editor_selection->get_selected_node_list(); - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) - continue; + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; - SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); - if (!se) - continue; + SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; - sp->set_global_transform(se->original); - } - surface->update(); - //VisualServer::get_singleton()->poly_clear(indicators); - set_message(TTR("Transform Aborted."), 3); + sp->set_global_transform(se->original); } + surface->update(); + //VisualServer::get_singleton()->poly_clear(indicators); + set_message(TTR("Transform Aborted."), 3); + } - freelook_active = b.pressed; + freelook_active = b->is_pressed(); - } break; - case BUTTON_MIDDLE: { + } break; + case BUTTON_MIDDLE: { - if (b.pressed && _edit.mode != TRANSFORM_NONE) { + if (b->is_pressed() && _edit.mode != TRANSFORM_NONE) { - switch (_edit.plane) { + switch (_edit.plane) { - case TRANSFORM_VIEW: { + case TRANSFORM_VIEW: { - _edit.plane = TRANSFORM_X_AXIS; - set_message(TTR("X-Axis Transform."), 2); - name = ""; - _update_name(); - } break; - case TRANSFORM_X_AXIS: { + _edit.plane = TRANSFORM_X_AXIS; + set_message(TTR("X-Axis Transform."), 2); + name = ""; + _update_name(); + } break; + case TRANSFORM_X_AXIS: { - _edit.plane = TRANSFORM_Y_AXIS; - set_message(TTR("Y-Axis Transform."), 2); + _edit.plane = TRANSFORM_Y_AXIS; + set_message(TTR("Y-Axis Transform."), 2); - } break; - case TRANSFORM_Y_AXIS: { + } break; + case TRANSFORM_Y_AXIS: { - _edit.plane = TRANSFORM_Z_AXIS; - set_message(TTR("Z-Axis Transform."), 2); + _edit.plane = TRANSFORM_Z_AXIS; + set_message(TTR("Z-Axis Transform."), 2); - } break; - case TRANSFORM_Z_AXIS: { + } break; + case TRANSFORM_Z_AXIS: { - _edit.plane = TRANSFORM_VIEW; - set_message(TTR("View Plane Transform."), 2); + _edit.plane = TRANSFORM_VIEW; + set_message(TTR("View Plane Transform."), 2); - } break; - } + } break; } - } break; - case BUTTON_LEFT: { + } + } break; + case BUTTON_LEFT: { - if (b.pressed) { + if (b->is_pressed()) { - NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); - if ((nav_scheme == NAVIGATION_MAYA || nav_scheme == NAVIGATION_MODO) && b.mod.alt) { - break; - } + NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); + if ((nav_scheme == NAVIGATION_MAYA || nav_scheme == NAVIGATION_MODO) && b->get_alt()) { + break; + } - if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_LIST_SELECT) { - _list_select(b); - break; - } + if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_LIST_SELECT) { + _list_select(b); + break; + } - _edit.mouse_pos = Point2(b.x, b.y); - _edit.snap = false; - _edit.mode = TRANSFORM_NONE; + _edit.mouse_pos = b->get_pos(); + _edit.snap = false; + _edit.mode = TRANSFORM_NONE; - //gizmo has priority over everything + //gizmo has priority over everything - bool can_select_gizmos = true; + bool can_select_gizmos = true; - { - int idx = view_menu->get_popup()->get_item_index(VIEW_GIZMOS); - can_select_gizmos = view_menu->get_popup()->is_item_checked(idx); - } + { + int idx = view_menu->get_popup()->get_item_index(VIEW_GIZMOS); + can_select_gizmos = view_menu->get_popup()->is_item_checked(idx); + } - if (can_select_gizmos && spatial_editor->get_selected()) { + if (can_select_gizmos && spatial_editor->get_selected()) { - Ref<SpatialEditorGizmo> seg = spatial_editor->get_selected()->get_gizmo(); - if (seg.is_valid()) { - int handle = -1; - Vector3 point; - Vector3 normal; - bool inters = seg->intersect_ray(camera, _edit.mouse_pos, point, normal, &handle, b.mod.shift); - if (inters && handle != -1) { + Ref<SpatialEditorGizmo> seg = spatial_editor->get_selected()->get_gizmo(); + if (seg.is_valid()) { + int handle = -1; + Vector3 point; + Vector3 normal; + bool inters = seg->intersect_ray(camera, _edit.mouse_pos, point, normal, &handle, b->get_shift()); + if (inters && handle != -1) { - _edit.gizmo = seg; - _edit.gizmo_handle = handle; - //_edit.gizmo_initial_pos=seg->get_handle_pos(gizmo_handle); - _edit.gizmo_initial_value = seg->get_handle_value(handle); - break; - } + _edit.gizmo = seg; + _edit.gizmo_handle = handle; + //_edit.gizmo_initial_pos=seg->get_handle_pos(gizmo_handle); + _edit.gizmo_initial_value = seg->get_handle_value(handle); + break; } } + } - if (_gizmo_select(_edit.mouse_pos)) - break; + if (_gizmo_select(_edit.mouse_pos)) + break; - clicked = 0; - clicked_includes_current = false; + clicked = 0; + clicked_includes_current = false; - if ((spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_SELECT && b.mod.control) || spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_ROTATE) { + if ((spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_SELECT && b->get_control()) || spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_ROTATE) { - /* HANDLE ROTATION */ - if (get_selected_count() == 0) - break; //bye - //handle rotate - _edit.mode = TRANSFORM_ROTATE; - _compute_edit(Point2(b.x, b.y)); - break; - } + /* HANDLE ROTATION */ + if (get_selected_count() == 0) + break; //bye + //handle rotate + _edit.mode = TRANSFORM_ROTATE; + _compute_edit(b->get_pos()); + break; + } - if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_MOVE) { + if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_MOVE) { - if (get_selected_count() == 0) - break; //bye - //handle rotate - _edit.mode = TRANSFORM_TRANSLATE; - _compute_edit(Point2(b.x, b.y)); - break; - } + if (get_selected_count() == 0) + break; //bye + //handle rotate + _edit.mode = TRANSFORM_TRANSLATE; + _compute_edit(b->get_pos()); + break; + } - if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_SCALE) { + if (spatial_editor->get_tool_mode() == SpatialEditor::TOOL_MODE_SCALE) { - if (get_selected_count() == 0) - break; //bye - //handle rotate - _edit.mode = TRANSFORM_SCALE; - _compute_edit(Point2(b.x, b.y)); - break; - } + if (get_selected_count() == 0) + break; //bye + //handle rotate + _edit.mode = TRANSFORM_SCALE; + _compute_edit(b->get_pos()); + break; + } - // todo scale + // todo scale - int gizmo_handle = -1; + int gizmo_handle = -1; - clicked = _select_ray(Vector2(b.x, b.y), b.mod.shift, clicked_includes_current, &gizmo_handle, b.mod.shift); + clicked = _select_ray(b->get_pos(), b->get_shift(), clicked_includes_current, &gizmo_handle, b->get_shift()); - //clicking is always deferred to either move or release + //clicking is always deferred to either move or release - clicked_wants_append = b.mod.shift; + clicked_wants_append = b->get_shift(); - if (!clicked) { + if (!clicked) { - if (!clicked_wants_append) - _clear_selected(); + if (!clicked_wants_append) + _clear_selected(); - //default to regionselect - cursor.region_select = true; - cursor.region_begin = Point2(b.x, b.y); - cursor.region_end = Point2(b.x, b.y); - } + //default to regionselect + cursor.region_select = true; + cursor.region_begin = b->get_pos(); + cursor.region_end = b->get_pos(); + } - if (clicked && gizmo_handle >= 0) { + if (clicked && gizmo_handle >= 0) { - Object *obj = ObjectDB::get_instance(clicked); - if (obj) { + Object *obj = ObjectDB::get_instance(clicked); + if (obj) { - Spatial *spa = obj->cast_to<Spatial>(); - if (spa) { + Spatial *spa = obj->cast_to<Spatial>(); + if (spa) { - Ref<SpatialEditorGizmo> seg = spa->get_gizmo(); - if (seg.is_valid()) { + Ref<SpatialEditorGizmo> seg = spa->get_gizmo(); + if (seg.is_valid()) { - _edit.gizmo = seg; - _edit.gizmo_handle = gizmo_handle; - //_edit.gizmo_initial_pos=seg->get_handle_pos(gizmo_handle); - _edit.gizmo_initial_value = seg->get_handle_value(gizmo_handle); - //print_line("GIZMO: "+itos(gizmo_handle)+" FROMPOS: "+_edit.orig_gizmo_pos); - break; - } + _edit.gizmo = seg; + _edit.gizmo_handle = gizmo_handle; + //_edit.gizmo_initial_pos=seg->get_handle_pos(gizmo_handle); + _edit.gizmo_initial_value = seg->get_handle_value(gizmo_handle); + //print_line("GIZMO: "+itos(gizmo_handle)+" FROMPOS: "+_edit.orig_gizmo_pos); + break; } } - //_compute_edit(Point2(b.x,b.y)); //in case a motion happens.. } + //_compute_edit(Point2(b.x,b.y)); //in case a motion happens.. + } - surface->update(); - } else { + surface->update(); + } else { - if (_edit.gizmo.is_valid()) { + if (_edit.gizmo.is_valid()) { - _edit.gizmo->commit_handle(_edit.gizmo_handle, _edit.gizmo_initial_value, false); - _edit.gizmo = Ref<SpatialEditorGizmo>(); - break; - } - if (clicked) { - _select_clicked(clicked_wants_append, true); - //clickd processing was deferred - clicked = 0; - } + _edit.gizmo->commit_handle(_edit.gizmo_handle, _edit.gizmo_initial_value, false); + _edit.gizmo = Ref<SpatialEditorGizmo>(); + break; + } + if (clicked) { + _select_clicked(clicked_wants_append, true); + //clickd processing was deferred + clicked = 0; + } - if (cursor.region_select) { - _select_region(); - cursor.region_select = false; - surface->update(); - } + if (cursor.region_select) { + _select_region(); + cursor.region_select = false; + surface->update(); + } - if (_edit.mode != TRANSFORM_NONE) { + if (_edit.mode != TRANSFORM_NONE) { - static const char *_transform_name[4] = { "None", "Rotate", "Translate", "Scale" }; - undo_redo->create_action(_transform_name[_edit.mode]); + static const char *_transform_name[4] = { "None", "Rotate", "Translate", "Scale" }; + undo_redo->create_action(_transform_name[_edit.mode]); - List<Node *> &selection = editor_selection->get_selected_node_list(); + List<Node *> &selection = editor_selection->get_selected_node_list(); - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) - continue; + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; - SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); - if (!se) - continue; + SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; - undo_redo->add_do_method(sp, "set_global_transform", sp->get_global_transform()); - undo_redo->add_undo_method(sp, "set_global_transform", se->original); - } - undo_redo->commit_action(); - _edit.mode = TRANSFORM_NONE; - //VisualServer::get_singleton()->poly_clear(indicators); - set_message(""); + undo_redo->add_do_method(sp, "set_global_transform", sp->get_global_transform()); + undo_redo->add_undo_method(sp, "set_global_transform", se->original); } - - surface->update(); + undo_redo->commit_action(); + _edit.mode = TRANSFORM_NONE; + //VisualServer::get_singleton()->poly_clear(indicators); + set_message(""); } - } break; - } - } break; - case InputEvent::MOUSE_MOTION: { - const InputEventMouseMotion &m = p_event.mouse_motion; - _edit.mouse_pos = Point2(p_event.mouse_motion.x, p_event.mouse_motion.y); + surface->update(); + } - if (spatial_editor->get_selected()) { + } break; + } + } - Ref<SpatialEditorGizmo> seg = spatial_editor->get_selected()->get_gizmo(); - if (seg.is_valid()) { + Ref<InputEventMouseMotion> m = p_event; - int selected_handle = -1; + if (m.is_valid()) { - int handle = -1; - Vector3 point; - Vector3 normal; - bool inters = seg->intersect_ray(camera, _edit.mouse_pos, point, normal, &handle, false); - if (inters && handle != -1) { + _edit.mouse_pos = m->get_pos(); - selected_handle = handle; - } + if (spatial_editor->get_selected()) { - if (selected_handle != spatial_editor->get_over_gizmo_handle()) { - spatial_editor->set_over_gizmo_handle(selected_handle); - spatial_editor->get_selected()->update_gizmo(); - if (selected_handle != -1) - spatial_editor->select_gizmo_highlight_axis(-1); - } - } - } + Ref<SpatialEditorGizmo> seg = spatial_editor->get_selected()->get_gizmo(); + if (seg.is_valid()) { + + int selected_handle = -1; + + int handle = -1; + Vector3 point; + Vector3 normal; + bool inters = seg->intersect_ray(camera, _edit.mouse_pos, point, normal, &handle, false); + if (inters && handle != -1) { - if (spatial_editor->get_over_gizmo_handle() == -1 && !(m.button_mask & 1) && !_edit.gizmo.is_valid()) { + selected_handle = handle; + } - _gizmo_select(_edit.mouse_pos, true); + if (selected_handle != spatial_editor->get_over_gizmo_handle()) { + spatial_editor->set_over_gizmo_handle(selected_handle); + spatial_editor->get_selected()->update_gizmo(); + if (selected_handle != -1) + spatial_editor->select_gizmo_highlight_axis(-1); + } } + } - NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); - NavigationMode nav_mode = NAVIGATION_NONE; + if (spatial_editor->get_over_gizmo_handle() == -1 && !(m->get_button_mask() & 1) && !_edit.gizmo.is_valid()) { - if (_edit.gizmo.is_valid()) { + _gizmo_select(_edit.mouse_pos, true); + } - _edit.gizmo->set_handle(_edit.gizmo_handle, camera, Vector2(m.x, m.y)); - Variant v = _edit.gizmo->get_handle_value(_edit.gizmo_handle); - String n = _edit.gizmo->get_handle_name(_edit.gizmo_handle); - set_message(n + ": " + String(v)); + NavigationScheme nav_scheme = (NavigationScheme)EditorSettings::get_singleton()->get("editors/3d/navigation_scheme").operator int(); + NavigationMode nav_mode = NAVIGATION_NONE; - } else if (m.button_mask & BUTTON_MASK_LEFT) { + if (_edit.gizmo.is_valid()) { - if (nav_scheme == NAVIGATION_MAYA && m.mod.alt) { - nav_mode = NAVIGATION_ORBIT; - } else if (nav_scheme == NAVIGATION_MODO && m.mod.alt && m.mod.shift) { - nav_mode = NAVIGATION_PAN; - } else if (nav_scheme == NAVIGATION_MODO && m.mod.alt && m.mod.control) { - nav_mode = NAVIGATION_ZOOM; - } else if (nav_scheme == NAVIGATION_MODO && m.mod.alt) { - nav_mode = NAVIGATION_ORBIT; - } else { - if (clicked) { + _edit.gizmo->set_handle(_edit.gizmo_handle, camera, m->get_pos()); + Variant v = _edit.gizmo->get_handle_value(_edit.gizmo_handle); + String n = _edit.gizmo->get_handle_name(_edit.gizmo_handle); + set_message(n + ": " + String(v)); - if (!clicked_includes_current) { + } else if (m->get_button_mask() & BUTTON_MASK_LEFT) { - _select_clicked(clicked_wants_append, true); - //clickd processing was deferred - } + if (nav_scheme == NAVIGATION_MAYA && m->get_alt()) { + nav_mode = NAVIGATION_ORBIT; + } else if (nav_scheme == NAVIGATION_MODO && m->get_alt() && m->get_shift()) { + nav_mode = NAVIGATION_PAN; + } else if (nav_scheme == NAVIGATION_MODO && m->get_alt() && m->get_control()) { + nav_mode = NAVIGATION_ZOOM; + } else if (nav_scheme == NAVIGATION_MODO && m->get_alt()) { + nav_mode = NAVIGATION_ORBIT; + } else { + if (clicked) { - _compute_edit(_edit.mouse_pos); - clicked = 0; + if (!clicked_includes_current) { - _edit.mode = TRANSFORM_TRANSLATE; + _select_clicked(clicked_wants_append, true); + //clickd processing was deferred } - if (cursor.region_select && nav_mode == NAVIGATION_NONE) { + _compute_edit(_edit.mouse_pos); + clicked = 0; - cursor.region_end = Point2(m.x, m.y); - surface->update(); - return; - } + _edit.mode = TRANSFORM_TRANSLATE; + } - if (_edit.mode == TRANSFORM_NONE && nav_mode == NAVIGATION_NONE) - break; + if (cursor.region_select && nav_mode == NAVIGATION_NONE) { - Vector3 ray_pos = _get_ray_pos(Vector2(m.x, m.y)); - Vector3 ray = _get_ray(Vector2(m.x, m.y)); + cursor.region_end = m->get_pos(); + surface->update(); + return; + } - switch (_edit.mode) { + if (_edit.mode == TRANSFORM_NONE && nav_mode == NAVIGATION_NONE) + return; - case TRANSFORM_SCALE: { + Vector3 ray_pos = _get_ray_pos(m->get_pos()); + Vector3 ray = _get_ray(m->get_pos()); - Plane plane = Plane(_edit.center, _get_camera_normal()); + switch (_edit.mode) { - Vector3 intersection; - if (!plane.intersects_ray(ray_pos, ray, &intersection)) - break; + case TRANSFORM_SCALE: { - Vector3 click; - if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) - break; + Plane plane = Plane(_edit.center, _get_camera_normal()); - float center_click_dist = click.distance_to(_edit.center); - float center_inters_dist = intersection.distance_to(_edit.center); - if (center_click_dist == 0) - break; + Vector3 intersection; + if (!plane.intersects_ray(ray_pos, ray, &intersection)) + break; - float scale = (center_inters_dist / center_click_dist) * 100.0; + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) + break; - if (_edit.snap || spatial_editor->is_snap_enabled()) { + float center_click_dist = click.distance_to(_edit.center); + float center_inters_dist = intersection.distance_to(_edit.center); + if (center_click_dist == 0) + break; - scale = Math::stepify(scale, spatial_editor->get_scale_snap()); - } + float scale = (center_inters_dist / center_click_dist) * 100.0; - set_message(vformat(TTR("Scaling to %s%%."), String::num(scale, 1))); - scale /= 100.0; + if (_edit.snap || spatial_editor->is_snap_enabled()) { - Transform r; - r.basis.scale(Vector3(scale, scale, scale)); + scale = Math::stepify(scale, spatial_editor->get_scale_snap()); + } - List<Node *> &selection = editor_selection->get_selected_node_list(); + set_message(vformat(TTR("Scaling to %s%%."), String::num(scale, 1))); + scale /= 100.0; - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + Transform r; + r.basis.scale(Vector3(scale, scale, scale)); - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) - continue; + List<Node *> &selection = editor_selection->get_selected_node_list(); - SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); - if (!se) - continue; + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - Transform original = se->original; + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; - Transform base = Transform(Basis(), _edit.center); - Transform t = base * (r * (base.inverse() * original)); + SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; - sp->set_global_transform(t); - } + Transform original = se->original; - surface->update(); + Transform base = Transform(Basis(), _edit.center); + Transform t = base * (r * (base.inverse() * original)); - } break; + sp->set_global_transform(t); + } - case TRANSFORM_TRANSLATE: { + surface->update(); - Vector3 motion_mask; - Plane plane; + } break; - switch (_edit.plane) { - case TRANSFORM_VIEW: - motion_mask = Vector3(0, 0, 0); - plane = Plane(_edit.center, _get_camera_normal()); - break; - case TRANSFORM_X_AXIS: - motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(0); - plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); - break; - case TRANSFORM_Y_AXIS: - motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(1); - plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); - break; - case TRANSFORM_Z_AXIS: - motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(2); - plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); - break; - } + case TRANSFORM_TRANSLATE: { - Vector3 intersection; - if (!plane.intersects_ray(ray_pos, ray, &intersection)) - break; + Vector3 motion_mask; + Plane plane; - Vector3 click; - if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) + switch (_edit.plane) { + case TRANSFORM_VIEW: + motion_mask = Vector3(0, 0, 0); + plane = Plane(_edit.center, _get_camera_normal()); + break; + case TRANSFORM_X_AXIS: + motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(0); + plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); + break; + case TRANSFORM_Y_AXIS: + motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(1); + plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); break; + case TRANSFORM_Z_AXIS: + motion_mask = spatial_editor->get_gizmo_transform().basis.get_axis(2); + plane = Plane(_edit.center, motion_mask.cross(motion_mask.cross(_get_camera_normal())).normalized()); + break; + } - //_validate_selection(); - Vector3 motion = intersection - click; - if (motion_mask != Vector3()) { - motion = motion_mask.dot(motion) * motion_mask; - } + Vector3 intersection; + if (!plane.intersects_ray(ray_pos, ray, &intersection)) + break; - float snap = 0; + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) + break; - if (_edit.snap || spatial_editor->is_snap_enabled()) { + //_validate_selection(); + Vector3 motion = intersection - click; + if (motion_mask != Vector3()) { + motion = motion_mask.dot(motion) * motion_mask; + } - snap = spatial_editor->get_translate_snap(); - motion.snap(snap); - } + float snap = 0; - //set_message("Translating: "+motion); + if (_edit.snap || spatial_editor->is_snap_enabled()) { - List<Node *> &selection = editor_selection->get_selected_node_list(); + snap = spatial_editor->get_translate_snap(); + motion.snap(snap); + } - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + //set_message("Translating: "+motion); - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) { - continue; - } + List<Node *> &selection = editor_selection->get_selected_node_list(); - SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); - if (!se) { - continue; - } + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - Transform t = se->original; - t.origin += motion; - sp->set_global_transform(t); + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) { + continue; } - } break; - case TRANSFORM_ROTATE: { + SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) { + continue; + } - Plane plane; + Transform t = se->original; + t.origin += motion; + sp->set_global_transform(t); + } + } break; - switch (_edit.plane) { - case TRANSFORM_VIEW: - plane = Plane(_edit.center, _get_camera_normal()); - break; - case TRANSFORM_X_AXIS: - plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(0)); - break; - case TRANSFORM_Y_AXIS: - plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(1)); - break; - case TRANSFORM_Z_AXIS: - plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(2)); - break; - } + case TRANSFORM_ROTATE: { - Vector3 intersection; - if (!plane.intersects_ray(ray_pos, ray, &intersection)) - break; + Plane plane; - Vector3 click; - if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) + switch (_edit.plane) { + case TRANSFORM_VIEW: + plane = Plane(_edit.center, _get_camera_normal()); + break; + case TRANSFORM_X_AXIS: + plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(0)); break; + case TRANSFORM_Y_AXIS: + plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(1)); + break; + case TRANSFORM_Z_AXIS: + plane = Plane(_edit.center, spatial_editor->get_gizmo_transform().basis.get_axis(2)); + break; + } + + Vector3 intersection; + if (!plane.intersects_ray(ray_pos, ray, &intersection)) + break; - Vector3 y_axis = (click - _edit.center).normalized(); - Vector3 x_axis = plane.normal.cross(y_axis).normalized(); + Vector3 click; + if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click)) + break; - float angle = Math::atan2(x_axis.dot(intersection - _edit.center), y_axis.dot(intersection - _edit.center)); - if (_edit.snap || spatial_editor->is_snap_enabled()) { + Vector3 y_axis = (click - _edit.center).normalized(); + Vector3 x_axis = plane.normal.cross(y_axis).normalized(); - float snap = spatial_editor->get_rotate_snap(); + float angle = Math::atan2(x_axis.dot(intersection - _edit.center), y_axis.dot(intersection - _edit.center)); + if (_edit.snap || spatial_editor->is_snap_enabled()) { - if (snap) { - angle = Math::rad2deg(angle) + snap * 0.5; //else it wont reach +180 - angle -= Math::fmod(angle, snap); - set_message(vformat(TTR("Rotating %s degrees."), rtos(angle))); - angle = Math::deg2rad(angle); - } else - set_message(vformat(TTR("Rotating %s degrees."), rtos(Math::rad2deg(angle)))); + float snap = spatial_editor->get_rotate_snap(); - } else { + if (snap) { + angle = Math::rad2deg(angle) + snap * 0.5; //else it wont reach +180 + angle -= Math::fmod(angle, snap); + set_message(vformat(TTR("Rotating %s degrees."), rtos(angle))); + angle = Math::deg2rad(angle); + } else set_message(vformat(TTR("Rotating %s degrees."), rtos(Math::rad2deg(angle)))); - } - Transform r; - r.basis.rotate(plane.normal, angle); + } else { + set_message(vformat(TTR("Rotating %s degrees."), rtos(Math::rad2deg(angle)))); + } - List<Node *> &selection = editor_selection->get_selected_node_list(); + Transform r; + r.basis.rotate(plane.normal, angle); + + List<Node *> &selection = editor_selection->get_selected_node_list(); - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) - continue; + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; - SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); - if (!se) - continue; + SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp); + if (!se) + continue; - Transform original = se->original; + Transform original = se->original; - Transform base = Transform(Basis(), _edit.center); - Transform t = base * r * base.inverse() * original; + Transform base = Transform(Basis(), _edit.center); + Transform t = base * r * base.inverse() * original; - sp->set_global_transform(t); - } + sp->set_global_transform(t); + } - surface->update(); - /* - VisualServer::get_singleton()->poly_clear(indicators); - - Vector<Vector3> points; - Vector<Vector3> empty; - Vector<Color> colors; - points.push_back(intersection); - points.push_back(_edit.original.origin); - colors.push_back( Color(255,155,100) ); - colors.push_back( Color(255,155,100) ); - VisualServer::get_singleton()->poly_add_primitive(indicators,points,empty,colors,empty); - */ - } break; - default: {} - } + surface->update(); + /* + VisualServer::get_singleton()->poly_clear(indicators); + + Vector<Vector3> points; + Vector<Vector3> empty; + Vector<Color> colors; + points.push_back(intersection); + points.push_back(_edit.original.origin); + colors.push_back( Color(255,155,100) ); + colors.push_back( Color(255,155,100) ); + VisualServer::get_singleton()->poly_add_primitive(indicators,points,empty,colors,empty); + */ + } break; + default: {} } + } - } else if (m.button_mask & BUTTON_MASK_RIGHT) { + } else if (m->get_button_mask() & BUTTON_MASK_RIGHT) { - if (nav_scheme == NAVIGATION_MAYA && m.mod.alt) { - nav_mode = NAVIGATION_ZOOM; - } else { - nav_mode = NAVIGATION_LOOK; - } + if (nav_scheme == NAVIGATION_MAYA && m->get_alt()) { + nav_mode = NAVIGATION_ZOOM; + } else { + nav_mode = NAVIGATION_LOOK; + } - } else if (m.button_mask & BUTTON_MASK_MIDDLE) { - - if (nav_scheme == NAVIGATION_GODOT) { - - int mod = 0; - if (m.mod.shift) - mod = KEY_SHIFT; - if (m.mod.alt) - mod = KEY_ALT; - if (m.mod.control) - mod = KEY_CONTROL; - if (m.mod.meta) - mod = KEY_META; - - if (mod == _get_key_modifier("editors/3d/pan_modifier")) - nav_mode = NAVIGATION_PAN; - else if (mod == _get_key_modifier("editors/3d/zoom_modifier")) - nav_mode = NAVIGATION_ZOOM; - else if (mod == _get_key_modifier("editors/3d/orbit_modifier")) - nav_mode = NAVIGATION_ORBIT; - - } else if (nav_scheme == NAVIGATION_MAYA) { - if (m.mod.alt) - nav_mode = NAVIGATION_PAN; - } + } else if (m->get_button_mask() & BUTTON_MASK_MIDDLE) { + + if (nav_scheme == NAVIGATION_GODOT) { - } else if (EditorSettings::get_singleton()->get("editors/3d/emulate_3_button_mouse")) { - // Handle trackpad (no external mouse) use case int mod = 0; - if (m.mod.shift) + if (m->get_shift()) mod = KEY_SHIFT; - if (m.mod.alt) + if (m->get_alt()) mod = KEY_ALT; - if (m.mod.control) + if (m->get_control()) mod = KEY_CONTROL; - if (m.mod.meta) + if (m->get_metakey()) mod = KEY_META; - if (mod) { - if (mod == _get_key_modifier("editors/3d/pan_modifier")) - nav_mode = NAVIGATION_PAN; - else if (mod == _get_key_modifier("editors/3d/zoom_modifier")) - nav_mode = NAVIGATION_ZOOM; - else if (mod == _get_key_modifier("editors/3d/orbit_modifier")) - nav_mode = NAVIGATION_ORBIT; - } + if (mod == _get_key_modifier("editors/3d/pan_modifier")) + nav_mode = NAVIGATION_PAN; + else if (mod == _get_key_modifier("editors/3d/zoom_modifier")) + nav_mode = NAVIGATION_ZOOM; + else if (mod == _get_key_modifier("editors/3d/orbit_modifier")) + nav_mode = NAVIGATION_ORBIT; + + } else if (nav_scheme == NAVIGATION_MAYA) { + if (m->get_alt()) + nav_mode = NAVIGATION_PAN; } - switch (nav_mode) { - case NAVIGATION_PAN: { + } else if (EditorSettings::get_singleton()->get("editors/3d/emulate_3_button_mouse")) { + // Handle trackpad (no external mouse) use case + int mod = 0; + if (m->get_shift()) + mod = KEY_SHIFT; + if (m->get_alt()) + mod = KEY_ALT; + if (m->get_control()) + mod = KEY_CONTROL; + if (m->get_metakey()) + mod = KEY_META; + + if (mod) { + if (mod == _get_key_modifier("editors/3d/pan_modifier")) + nav_mode = NAVIGATION_PAN; + else if (mod == _get_key_modifier("editors/3d/zoom_modifier")) + nav_mode = NAVIGATION_ZOOM; + else if (mod == _get_key_modifier("editors/3d/orbit_modifier")) + nav_mode = NAVIGATION_ORBIT; + } + } - real_t pan_speed = 1 / 150.0; - int pan_speed_modifier = 10; - if (nav_scheme == NAVIGATION_MAYA && m.mod.shift) - pan_speed *= pan_speed_modifier; + switch (nav_mode) { + case NAVIGATION_PAN: { - Point2i relative = _get_warped_mouse_motion(m); + real_t pan_speed = 1 / 150.0; + int pan_speed_modifier = 10; + if (nav_scheme == NAVIGATION_MAYA && m->get_shift()) + pan_speed *= pan_speed_modifier; - Transform camera_transform; - - camera_transform.translate(cursor.pos); - camera_transform.basis.rotate(Vector3(1, 0, 0), -cursor.x_rot); - camera_transform.basis.rotate(Vector3(0, 1, 0), -cursor.y_rot); - Vector3 translation(-relative.x * pan_speed, relative.y * pan_speed, 0); - translation *= cursor.distance / DISTANCE_DEFAULT; - camera_transform.translate(translation); - cursor.pos = camera_transform.origin; - - } break; - - case NAVIGATION_ZOOM: { - real_t zoom_speed = 1 / 80.0; - int zoom_speed_modifier = 10; - if (nav_scheme == NAVIGATION_MAYA && m.mod.shift) - zoom_speed *= zoom_speed_modifier; - - NavigationZoomStyle zoom_style = (NavigationZoomStyle)EditorSettings::get_singleton()->get("editors/3d/zoom_style").operator int(); - if (zoom_style == NAVIGATION_ZOOM_HORIZONTAL) { - if (m.relative_x > 0) - scale_cursor_distance(1 - m.relative_x * zoom_speed); - else if (m.relative_x < 0) - scale_cursor_distance(1.0 / (1 + m.relative_x * zoom_speed)); - } else { - if (m.relative_y > 0) - scale_cursor_distance(1 + m.relative_y * zoom_speed); - else if (m.relative_y < 0) - scale_cursor_distance(1.0 / (1 - m.relative_y * zoom_speed)); - } + Point2i relative = _get_warped_mouse_motion(m); + + Transform camera_transform; + + camera_transform.translate(cursor.pos); + camera_transform.basis.rotate(Vector3(1, 0, 0), -cursor.x_rot); + camera_transform.basis.rotate(Vector3(0, 1, 0), -cursor.y_rot); + Vector3 translation(-relative.x * pan_speed, relative.y * pan_speed, 0); + translation *= cursor.distance / DISTANCE_DEFAULT; + camera_transform.translate(translation); + cursor.pos = camera_transform.origin; + + } break; + + case NAVIGATION_ZOOM: { + real_t zoom_speed = 1 / 80.0; + int zoom_speed_modifier = 10; + if (nav_scheme == NAVIGATION_MAYA && m->get_shift()) + zoom_speed *= zoom_speed_modifier; + + NavigationZoomStyle zoom_style = (NavigationZoomStyle)EditorSettings::get_singleton()->get("editors/3d/zoom_style").operator int(); + if (zoom_style == NAVIGATION_ZOOM_HORIZONTAL) { + if (m->get_relative().x > 0) + scale_cursor_distance(1 - m->get_relative().x * zoom_speed); + else if (m->get_relative().x < 0) + scale_cursor_distance(1.0 / (1 + m->get_relative().x * zoom_speed)); + } else { + if (m->get_relative().y > 0) + scale_cursor_distance(1 + m->get_relative().y * zoom_speed); + else if (m->get_relative().y < 0) + scale_cursor_distance(1.0 / (1 - m->get_relative().y * zoom_speed)); + } + + } break; - } break; + case NAVIGATION_ORBIT: { + Point2i relative = _get_warped_mouse_motion(m); + cursor.x_rot += relative.y / 80.0; + cursor.y_rot += relative.x / 80.0; + if (cursor.x_rot > Math_PI / 2.0) + cursor.x_rot = Math_PI / 2.0; + if (cursor.x_rot < -Math_PI / 2.0) + cursor.x_rot = -Math_PI / 2.0; + name = ""; + _update_name(); + } break; - case NAVIGATION_ORBIT: { + case NAVIGATION_LOOK: { + // Freelook only works properly in perspective. + // It technically works too in ortho, but it's awful for a user due to fov being near zero + if (!orthogonal) { Point2i relative = _get_warped_mouse_motion(m); - cursor.x_rot += relative.y / 80.0; - cursor.y_rot += relative.x / 80.0; + cursor.x_rot += relative.y / 120.0; + cursor.y_rot += relative.x / 120.0; if (cursor.x_rot > Math_PI / 2.0) cursor.x_rot = Math_PI / 2.0; if (cursor.x_rot < -Math_PI / 2.0) cursor.x_rot = -Math_PI / 2.0; + + // Look is like Orbit, except the cursor translates, not the camera + Transform camera_transform = to_camera_transform(cursor); + Vector3 pos = camera_transform.xform(Vector3(0, 0, 0)); + Vector3 diff = camera->get_translation() - pos; + cursor.pos += diff; + name = ""; _update_name(); - } break; - - case NAVIGATION_LOOK: { - // Freelook only works properly in perspective. - // It technically works too in ortho, but it's awful for a user due to fov being near zero - if (!orthogonal) { - Point2i relative = _get_warped_mouse_motion(m); - cursor.x_rot += relative.y / 120.0; - cursor.y_rot += relative.x / 120.0; - if (cursor.x_rot > Math_PI / 2.0) - cursor.x_rot = Math_PI / 2.0; - if (cursor.x_rot < -Math_PI / 2.0) - cursor.x_rot = -Math_PI / 2.0; - - // Look is like Orbit, except the cursor translates, not the camera - Transform camera_transform = to_camera_transform(cursor); - Vector3 pos = camera_transform.xform(Vector3(0, 0, 0)); - Vector3 diff = camera->get_translation() - pos; - cursor.pos += diff; - - name = ""; - _update_name(); - } + } - } break; + } break; - default: {} - } - } break; - case InputEvent::KEY: { - const InputEventKey &k = p_event.key; - if (!k.pressed) - break; + default: {} + } + } - if (ED_IS_SHORTCUT("spatial_editor/snap", p_event)) { - if (_edit.mode != TRANSFORM_NONE) { - _edit.snap = true; - } - } - if (ED_IS_SHORTCUT("spatial_editor/bottom_view", p_event)) { - cursor.y_rot = 0; - cursor.x_rot = -Math_PI / 2.0; - set_message(TTR("Bottom View."), 2); - name = TTR("Bottom"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/top_view", p_event)) { - cursor.y_rot = 0; - cursor.x_rot = Math_PI / 2.0; - set_message(TTR("Top View."), 2); - name = TTR("Top"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/rear_view", p_event)) { - cursor.x_rot = 0; - cursor.y_rot = Math_PI; - set_message(TTR("Rear View."), 2); - name = TTR("Rear"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/front_view", p_event)) { - cursor.x_rot = 0; - cursor.y_rot = 0; - set_message(TTR("Front View."), 2); - name = TTR("Front"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/left_view", p_event)) { - cursor.x_rot = 0; - cursor.y_rot = Math_PI / 2.0; - set_message(TTR("Left View."), 2); - name = TTR("Left"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/right_view", p_event)) { - cursor.x_rot = 0; - cursor.y_rot = -Math_PI / 2.0; - set_message(TTR("Right View."), 2); - name = TTR("Right"); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/switch_perspective_orthogonal", p_event)) { - _menu_option(orthogonal ? VIEW_PERSPECTIVE : VIEW_ORTHOGONAL); - _update_name(); - } - if (ED_IS_SHORTCUT("spatial_editor/insert_anim_key", p_event)) { - if (!get_selected_count() || _edit.mode != TRANSFORM_NONE) - break; + Ref<InputEventKey> k = p_event; - if (!AnimationPlayerEditor::singleton->get_key_editor()->has_keying()) { - set_message(TTR("Keying is disabled (no key inserted).")); - break; - } + if (k.is_valid()) { + if (!k->is_pressed()) + return; + + if (ED_IS_SHORTCUT("spatial_editor/snap", p_event)) { + if (_edit.mode != TRANSFORM_NONE) { + _edit.snap = true; + } + } + if (ED_IS_SHORTCUT("spatial_editor/bottom_view", p_event)) { + cursor.y_rot = 0; + cursor.x_rot = -Math_PI / 2.0; + set_message(TTR("Bottom View."), 2); + name = TTR("Bottom"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/top_view", p_event)) { + cursor.y_rot = 0; + cursor.x_rot = Math_PI / 2.0; + set_message(TTR("Top View."), 2); + name = TTR("Top"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/rear_view", p_event)) { + cursor.x_rot = 0; + cursor.y_rot = Math_PI; + set_message(TTR("Rear View."), 2); + name = TTR("Rear"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/front_view", p_event)) { + cursor.x_rot = 0; + cursor.y_rot = 0; + set_message(TTR("Front View."), 2); + name = TTR("Front"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/left_view", p_event)) { + cursor.x_rot = 0; + cursor.y_rot = Math_PI / 2.0; + set_message(TTR("Left View."), 2); + name = TTR("Left"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/right_view", p_event)) { + cursor.x_rot = 0; + cursor.y_rot = -Math_PI / 2.0; + set_message(TTR("Right View."), 2); + name = TTR("Right"); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/switch_perspective_orthogonal", p_event)) { + _menu_option(orthogonal ? VIEW_PERSPECTIVE : VIEW_ORTHOGONAL); + _update_name(); + } + if (ED_IS_SHORTCUT("spatial_editor/insert_anim_key", p_event)) { + if (!get_selected_count() || _edit.mode != TRANSFORM_NONE) + return; - List<Node *> &selection = editor_selection->get_selected_node_list(); + if (!AnimationPlayerEditor::singleton->get_key_editor()->has_keying()) { + set_message(TTR("Keying is disabled (no key inserted).")); + return; + } - for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { + List<Node *> &selection = editor_selection->get_selected_node_list(); - Spatial *sp = E->get()->cast_to<Spatial>(); - if (!sp) - continue; + for (List<Node *>::Element *E = selection.front(); E; E = E->next()) { - emit_signal("transform_key_request", sp, "", sp->get_transform()); - } + Spatial *sp = E->get()->cast_to<Spatial>(); + if (!sp) + continue; - set_message(TTR("Animation Key Inserted.")); + emit_signal("transform_key_request", sp, "", sp->get_transform()); } - if (k.scancode == KEY_SPACE) { - if (!k.pressed) emit_signal("toggle_maximize_view", this); - } + set_message(TTR("Animation Key Inserted.")); + } - } break; + if (k->get_scancode() == KEY_SPACE) { + if (!k->is_pressed()) emit_signal("toggle_maximize_view", this); + } } } @@ -1526,12 +1528,12 @@ void SpatialEditorViewport::scale_cursor_distance(real_t scale) { surface->update(); } -Point2i SpatialEditorViewport::_get_warped_mouse_motion(const InputEventMouseMotion &p_ev_mouse_motion) const { +Point2i SpatialEditorViewport::_get_warped_mouse_motion(const Ref<InputEventMouseMotion> &p_ev_mouse_motion) const { Point2i relative; if (bool(EditorSettings::get_singleton()->get("editors/3d/warped_mouse_panning"))) { relative = Input::get_singleton()->warp_mouse_motion(p_ev_mouse_motion, surface->get_global_rect()); } else { - relative = Point2i(p_ev_mouse_motion.relative_x, p_ev_mouse_motion.relative_y); + relative = p_ev_mouse_motion->get_relative(); } return relative; } @@ -1545,13 +1547,13 @@ void SpatialEditorViewport::_update_freelook(real_t delta) { Vector3 right = camera->get_transform().basis.xform(Vector3(1, 0, 0)); Vector3 up = camera->get_transform().basis.xform(Vector3(0, 1, 0)); - int key_left = ED_SHORTCUT("spatial_editor/freelook_left", TTR("Freelook Left"), KEY_A)->get_shortcut().key.scancode; - int key_right = ED_SHORTCUT("spatial_editor/freelook_right", TTR("Freelook Right"), KEY_D)->get_shortcut().key.scancode; - int key_forward = ED_SHORTCUT("spatial_editor/freelook_forward", TTR("Freelook Forward"), KEY_W)->get_shortcut().key.scancode; - int key_backwards = ED_SHORTCUT("spatial_editor/freelook_backwards", TTR("Freelook Backwards"), KEY_S)->get_shortcut().key.scancode; - int key_up = ED_SHORTCUT("spatial_editor/freelook_up", TTR("Freelook Up"), KEY_Q)->get_shortcut().key.scancode; - int key_down = ED_SHORTCUT("spatial_editor/freelook_down", TTR("Freelook Down"), KEY_E)->get_shortcut().key.scancode; - int key_speed_modifier = ED_SHORTCUT("spatial_editor/freelook_speed_modifier", TTR("Freelook Speed Modifier"), KEY_SHIFT)->get_shortcut().key.scancode; + int key_left = ED_SHORTCUT("spatial_editor/freelook_left", TTR("Freelook Left"), KEY_A)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_right = ED_SHORTCUT("spatial_editor/freelook_right", TTR("Freelook Right"), KEY_D)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_forward = ED_SHORTCUT("spatial_editor/freelook_forward", TTR("Freelook Forward"), KEY_W)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_backwards = ED_SHORTCUT("spatial_editor/freelook_backwards", TTR("Freelook Backwards"), KEY_S)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_up = ED_SHORTCUT("spatial_editor/freelook_up", TTR("Freelook Up"), KEY_Q)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_down = ED_SHORTCUT("spatial_editor/freelook_down", TTR("Freelook Down"), KEY_E)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); + int key_speed_modifier = ED_SHORTCUT("spatial_editor/freelook_speed_modifier", TTR("Freelook Speed Modifier"), KEY_SHIFT)->get_shortcut()->cast_to<InputEventKey>()->get_scancode(); Vector3 velocity; bool pressed = false; @@ -3274,7 +3276,7 @@ bool SpatialEditor::is_any_freelook_active() const { return false; } -void SpatialEditor::_unhandled_key_input(InputEvent p_event) { +void SpatialEditor::_unhandled_key_input(Ref<InputEvent> p_event) { if (!is_visible_in_tree() || get_viewport()->gui_has_modal_stack()) return; @@ -3294,43 +3296,39 @@ void SpatialEditor::_unhandled_key_input(InputEvent p_event) { } #endif - switch (p_event.type) { - - case InputEvent::KEY: { + Ref<InputEventKey> k = p_event; - // Note: need to check is_echo because first person movement keys might still be held - if (!is_any_freelook_active() && !p_event.is_echo()) { + if (k.is_valid()) { - const InputEventKey &k = p_event.key; + // Note: need to check is_echo because first person movement keys might still be held + if (!is_any_freelook_active() && !p_event->is_echo()) { - if (!k.pressed) - break; + if (!k->is_pressed()) + return; - if (ED_IS_SHORTCUT("spatial_editor/tool_select", p_event)) - _menu_item_pressed(MENU_TOOL_SELECT); + if (ED_IS_SHORTCUT("spatial_editor/tool_select", p_event)) + _menu_item_pressed(MENU_TOOL_SELECT); - else if (ED_IS_SHORTCUT("spatial_editor/tool_move", p_event)) - _menu_item_pressed(MENU_TOOL_MOVE); + else if (ED_IS_SHORTCUT("spatial_editor/tool_move", p_event)) + _menu_item_pressed(MENU_TOOL_MOVE); - else if (ED_IS_SHORTCUT("spatial_editor/tool_rotate", p_event)) - _menu_item_pressed(MENU_TOOL_ROTATE); + else if (ED_IS_SHORTCUT("spatial_editor/tool_rotate", p_event)) + _menu_item_pressed(MENU_TOOL_ROTATE); - else if (ED_IS_SHORTCUT("spatial_editor/tool_scale", p_event)) - _menu_item_pressed(MENU_TOOL_SCALE); + else if (ED_IS_SHORTCUT("spatial_editor/tool_scale", p_event)) + _menu_item_pressed(MENU_TOOL_SCALE); - else if (ED_IS_SHORTCUT("spatial_editor/display_wireframe", p_event)) { - if (k.mod.shift || k.mod.control || k.mod.command) - break; + else if (ED_IS_SHORTCUT("spatial_editor/display_wireframe", p_event)) { + if (k->get_shift() || k->get_control() || k->get_command()) + return; - if (view_menu->get_popup()->is_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_WIREFRAME))) { - _menu_item_pressed(MENU_VIEW_DISPLAY_NORMAL); - } else { - _menu_item_pressed(MENU_VIEW_DISPLAY_WIREFRAME); - } + if (view_menu->get_popup()->is_item_checked(view_menu->get_popup()->get_item_index(MENU_VIEW_DISPLAY_WIREFRAME))) { + _menu_item_pressed(MENU_VIEW_DISPLAY_NORMAL); + } else { + _menu_item_pressed(MENU_VIEW_DISPLAY_WIREFRAME); } } - - } break; + } } } void SpatialEditor::_notification(int p_what) { @@ -3547,12 +3545,13 @@ void SpatialEditor::_update_default_light_angle() { } } -void SpatialEditor::_default_light_angle_input(const InputEvent &p_event) { +void SpatialEditor::_default_light_angle_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask & (0x1 | 0x2 | 0x4)) { + Ref<InputEventMouseMotion> mm = p_event; + if (mm.is_valid() && mm->get_button_mask() & (0x1 | 0x2 | 0x4)) { - settings_default_light_rot_y = Math::fposmod(settings_default_light_rot_y - p_event.mouse_motion.relative_x * 0.01, Math_PI * 2.0); - settings_default_light_rot_x = Math::fposmod(settings_default_light_rot_x - p_event.mouse_motion.relative_y * 0.01, Math_PI * 2.0); + settings_default_light_rot_y = Math::fposmod(settings_default_light_rot_y - mm->get_relative().x * 0.01, Math_PI * 2.0); + settings_default_light_rot_x = Math::fposmod(settings_default_light_rot_x - mm->get_relative().y * 0.01, Math_PI * 2.0); _update_default_light_angle(); } } diff --git a/editor/plugins/spatial_editor_plugin.h b/editor/plugins/spatial_editor_plugin.h index 0f07ec4c66..1f76d9bfb8 100644 --- a/editor/plugins/spatial_editor_plugin.h +++ b/editor/plugins/spatial_editor_plugin.h @@ -236,7 +236,7 @@ private: void _draw(); void _smouseenter(); - void _sinput(const InputEvent &p_ie); + void _sinput(const Ref<InputEvent> &p_ie); void _update_freelook(real_t delta); SpatialEditor *spatial_editor; @@ -249,8 +249,8 @@ private: void _finish_gizmo_instances(); void _selection_result_pressed(int); void _selection_menu_hide(); - void _list_select(InputEventMouseButton b); - Point2i _get_warped_mouse_motion(const InputEventMouseMotion &p_ev_mouse_motion) const; + void _list_select(Ref<InputEventMouseButton> b); + Point2i _get_warped_mouse_motion(const Ref<InputEventMouseMotion> &p_ev_mouse_motion) const; protected: void _notification(int p_what); @@ -464,14 +464,14 @@ private: void _update_ambient_light_color(const Color &p_color); void _update_default_light_angle(); - void _default_light_angle_input(const InputEvent &p_event); + void _default_light_angle_input(const Ref<InputEvent> &p_event); bool is_any_freelook_active() const; protected: void _notification(int p_what); //void _gui_input(InputEvent p_event); - void _unhandled_key_input(InputEvent p_event); + void _unhandled_key_input(Ref<InputEvent> p_event); static void _bind_methods(); diff --git a/editor/plugins/sprite_frames_editor_plugin.cpp b/editor/plugins/sprite_frames_editor_plugin.cpp index c7c77fa960..d06c065f4f 100644 --- a/editor/plugins/sprite_frames_editor_plugin.cpp +++ b/editor/plugins/sprite_frames_editor_plugin.cpp @@ -34,7 +34,7 @@ #include "io/resource_loader.h" #include "scene/3d/sprite_3d.h" -void SpriteFramesEditor::_gui_input(InputEvent p_event) { +void SpriteFramesEditor::_gui_input(Ref<InputEvent> p_event) { } void SpriteFramesEditor::_notification(int p_what) { diff --git a/editor/plugins/sprite_frames_editor_plugin.h b/editor/plugins/sprite_frames_editor_plugin.h index 3778e4ca55..c9081c599a 100644 --- a/editor/plugins/sprite_frames_editor_plugin.h +++ b/editor/plugins/sprite_frames_editor_plugin.h @@ -100,7 +100,7 @@ class SpriteFramesEditor : public PanelContainer { protected: void _notification(int p_what); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); static void _bind_methods(); public: diff --git a/editor/plugins/texture_editor_plugin.cpp b/editor/plugins/texture_editor_plugin.cpp index 62977d86ea..3b705aae24 100644 --- a/editor/plugins/texture_editor_plugin.cpp +++ b/editor/plugins/texture_editor_plugin.cpp @@ -33,7 +33,7 @@ #include "global_config.h" #include "io/resource_loader.h" -void TextureEditor::_gui_input(InputEvent p_event) { +void TextureEditor::_gui_input(Ref<InputEvent> p_event) { } void TextureEditor::_notification(int p_what) { diff --git a/editor/plugins/texture_editor_plugin.h b/editor/plugins/texture_editor_plugin.h index 8750ce4d5e..9382983538 100644 --- a/editor/plugins/texture_editor_plugin.h +++ b/editor/plugins/texture_editor_plugin.h @@ -42,7 +42,7 @@ class TextureEditor : public Control { protected: void _notification(int p_what); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); static void _bind_methods(); public: diff --git a/editor/plugins/texture_region_editor_plugin.cpp b/editor/plugins/texture_region_editor_plugin.cpp index 89995edf05..799bfbf358 100644 --- a/editor/plugins/texture_region_editor_plugin.cpp +++ b/editor/plugins/texture_region_editor_plugin.cpp @@ -202,7 +202,7 @@ void TextureRegionEditor::_region_draw() { } } -void TextureRegionEditor::_region_input(const InputEvent &p_input) { +void TextureRegionEditor::_region_input(const Ref<InputEvent> &p_input) { Transform2D mtx; mtx.elements[2] = -draw_ofs; mtx.scale_basis(Vector2(draw_zoom, draw_zoom)); @@ -218,13 +218,12 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { mtx.xform(rect.pos + Vector2(0, rect.size.y / 2)) + Vector2(-4, 0) }; - if (p_input.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb; + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_input.mouse_button; + if (mb->get_button_index() == BUTTON_LEFT) { - if (mb.button_index == BUTTON_LEFT) { - - if (mb.pressed) { + if (mb->is_pressed()) { if (node_patch9 || obj_styleBox.is_valid()) { edited_margin = -1; float margins[4]; @@ -245,26 +244,26 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { mtx.basis_xform(rect.pos + Vector2(margins[2], 0)) - draw_ofs, mtx.basis_xform(rect.pos + rect.size - Vector2(margins[3], 0)) - draw_ofs }; - if (Math::abs(mb.y - pos[0].y) < 8) { + if (Math::abs(mb->get_pos().y - pos[0].y) < 8) { edited_margin = 0; prev_margin = margins[0]; - } else if (Math::abs(mb.y - pos[1].y) < 8) { + } else if (Math::abs(mb->get_pos().y - pos[1].y) < 8) { edited_margin = 1; prev_margin = margins[1]; - } else if (Math::abs(mb.x - pos[2].x) < 8) { + } else if (Math::abs(mb->get_pos().x - pos[2].x) < 8) { edited_margin = 2; prev_margin = margins[2]; - } else if (Math::abs(mb.x - pos[3].x) < 8) { + } else if (Math::abs(mb->get_pos().x - pos[3].x) < 8) { edited_margin = 3; prev_margin = margins[3]; } if (edited_margin >= 0) { - drag_from = Vector2(mb.x, mb.y); + drag_from = Vector2(mb->get_pos().x, mb->get_pos().y); drag = true; } } if (edited_margin < 0 && snap_mode == SNAP_AUTOSLICE) { - Vector2 point = mtx.affine_inverse().xform(Vector2(mb.x, mb.y)); + Vector2 point = mtx.affine_inverse().xform(Vector2(mb->get_pos().x, mb->get_pos().y)); for (List<Rect2>::Element *E = autoslice_cache.front(); E; E = E->next()) { if (E->get().has_point(point)) { rect = E->get(); @@ -302,7 +301,7 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { } } } else if (edited_margin < 0) { - drag_from = mtx.affine_inverse().xform(Vector2(mb.x, mb.y)); + drag_from = mtx.affine_inverse().xform(Vector2(mb->get_pos().x, mb->get_pos().y)); if (snap_mode == SNAP_PIXEL) drag_from = drag_from.snapped(Vector2(1, 1)); else if (snap_mode == SNAP_GRID) @@ -319,7 +318,7 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { for (int i = 0; i < 8; i++) { Vector2 tuv = endpoints[i]; - if (tuv.distance_to(Vector2(mb.x, mb.y)) < 8) { + if (tuv.distance_to(Vector2(mb->get_pos().x, mb->get_pos().y)) < 8) { drag_index = i; } } @@ -369,7 +368,7 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { creating = false; } - } else if (mb.button_index == BUTTON_RIGHT && mb.pressed) { + } else if (mb->get_button_index() == BUTTON_RIGHT && mb->is_pressed()) { if (drag) { drag = false; @@ -387,18 +386,20 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { drag_index = -1; } } - } else if (mb.button_index == BUTTON_WHEEL_UP && mb.pressed) { + } else if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) { _zoom_in(); - } else if (mb.button_index == BUTTON_WHEEL_DOWN && mb.pressed) { + } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) { _zoom_out(); } - } else if (p_input.type == InputEvent::MOUSE_MOTION) { + } + + Ref<InputEventMouseMotion> mm = p_input; - const InputEventMouseMotion &mm = p_input.mouse_motion; + if (mm.is_valid()) { - if (mm.button_mask & BUTTON_MASK_MIDDLE || Input::get_singleton()->is_key_pressed(KEY_SPACE)) { + if (mm->get_button_mask() & BUTTON_MASK_MIDDLE || Input::get_singleton()->is_key_pressed(KEY_SPACE)) { - Vector2 draged(mm.relative_x, mm.relative_y); + Vector2 draged(mm->get_relative().x, mm->get_relative().y); hscroll->set_value(hscroll->get_value() - draged.x); vscroll->set_value(vscroll->get_value() - draged.y); @@ -407,13 +408,13 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { if (edited_margin >= 0) { float new_margin; if (edited_margin == 0) - new_margin = prev_margin + (mm.y - drag_from.y) / draw_zoom; + new_margin = prev_margin + (mm->get_pos().y - drag_from.y) / draw_zoom; else if (edited_margin == 1) - new_margin = prev_margin - (mm.y - drag_from.y) / draw_zoom; + new_margin = prev_margin - (mm->get_pos().y - drag_from.y) / draw_zoom; else if (edited_margin == 2) - new_margin = prev_margin + (mm.x - drag_from.x) / draw_zoom; + new_margin = prev_margin + (mm->get_pos().x - drag_from.x) / draw_zoom; else if (edited_margin == 3) - new_margin = prev_margin - (mm.x - drag_from.x) / draw_zoom; + new_margin = prev_margin - (mm->get_pos().x - drag_from.x) / draw_zoom; if (new_margin < 0) new_margin = 0; static Margin m[4] = { MARGIN_TOP, MARGIN_BOTTOM, MARGIN_LEFT, MARGIN_RIGHT }; @@ -422,7 +423,7 @@ void TextureRegionEditor::_region_input(const InputEvent &p_input) { if (obj_styleBox.is_valid()) obj_styleBox->set_margin_size(m[edited_margin], new_margin); } else { - Vector2 new_pos = mtx.affine_inverse().xform(Vector2(mm.x, mm.y)); + Vector2 new_pos = mtx.affine_inverse().xform(mm->get_pos()); if (snap_mode == SNAP_PIXEL) new_pos = new_pos.snapped(Vector2(1, 1)); else if (snap_mode == SNAP_GRID) diff --git a/editor/plugins/texture_region_editor_plugin.h b/editor/plugins/texture_region_editor_plugin.h index 093e2f7d01..cb0b9fc372 100644 --- a/editor/plugins/texture_region_editor_plugin.h +++ b/editor/plugins/texture_region_editor_plugin.h @@ -122,7 +122,7 @@ protected: public: void _edit_region(); void _region_draw(); - void _region_input(const InputEvent &p_input); + void _region_input(const Ref<InputEvent> &p_input); void _scroll_changed(float); void edit(Object *p_obj); diff --git a/editor/plugins/tile_map_editor_plugin.cpp b/editor/plugins/tile_map_editor_plugin.cpp index 9f99a9b978..9f7a41b8b6 100644 --- a/editor/plugins/tile_map_editor_plugin.cpp +++ b/editor/plugins/tile_map_editor_plugin.cpp @@ -179,14 +179,16 @@ void TileMapEditor::_text_changed(const String &p_text) { _update_palette(); } -void TileMapEditor::_sbox_input(const InputEvent &p_ie) { +void TileMapEditor::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY && (p_ie.key.scancode == KEY_UP || - p_ie.key.scancode == KEY_DOWN || - p_ie.key.scancode == KEY_PAGEUP || - p_ie.key.scancode == KEY_PAGEDOWN)) { + Ref<InputEventKey> k = p_ie; - palette->call("_gui_input", p_ie); + if (k.is_valid() && (k->get_scancode() == KEY_UP || + k->get_scancode() == KEY_DOWN || + k->get_scancode() == KEY_PAGEUP || + k->get_scancode() == KEY_PAGEDOWN)) { + + palette->call("_gui_input", k); search_box->accept_event(); } } @@ -622,7 +624,7 @@ static inline Vector<Point2i> line(int x0, int x1, int y0, int y1) { return points; } -bool TileMapEditor::forward_gui_input(const InputEvent &p_event) { +bool TileMapEditor::forward_gui_input(const Ref<InputEvent> &p_event) { if (!node || !node->get_tileset().is_valid() || !node->is_visible_in_tree()) return false; @@ -630,464 +632,459 @@ bool TileMapEditor::forward_gui_input(const InputEvent &p_event) { Transform2D xform = CanvasItemEditor::get_singleton()->get_canvas_transform() * node->get_global_transform(); Transform2D xform_inv = xform.affine_inverse(); - switch (p_event.type) { - - case InputEvent::MOUSE_BUTTON: { - - const InputEventMouseButton &mb = p_event.mouse_button; - - if (mb.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; - if (mb.pressed) { + if (mb.is_valid()) { + if (mb->get_button_index() == BUTTON_LEFT) { - if (Input::get_singleton()->is_key_pressed(KEY_SPACE)) - return false; //drag + if (mb->is_pressed()) { - if (tool == TOOL_NONE) { + if (Input::get_singleton()->is_key_pressed(KEY_SPACE)) + return false; //drag - if (mb.mod.shift) { + if (tool == TOOL_NONE) { - if (mb.mod.control) - tool = TOOL_RECTANGLE_PAINT; - else - tool = TOOL_LINE_PAINT; + if (mb->get_shift()) { - selection_active = false; - rectangle_begin = over_tile; + if (mb->get_control()) + tool = TOOL_RECTANGLE_PAINT; + else + tool = TOOL_LINE_PAINT; - return true; - } + selection_active = false; + rectangle_begin = over_tile; - if (mb.mod.control) { + return true; + } - tool = TOOL_PICKING; - _pick_tile(over_tile); + if (mb->get_control()) { - return true; - } + tool = TOOL_PICKING; + _pick_tile(over_tile); - tool = TOOL_PAINTING; + return true; } - if (tool == TOOL_PAINTING) { - - int id = get_selected_tile(); + tool = TOOL_PAINTING; + } - if (id != TileMap::INVALID_CELL) { + if (tool == TOOL_PAINTING) { - tool = TOOL_PAINTING; + int id = get_selected_tile(); - paint_undo.clear(); - paint_undo[over_tile] = _get_op_from_cell(over_tile); + if (id != TileMap::INVALID_CELL) { - _set_cell(over_tile, id, flip_h, flip_v, transpose); - } - } else if (tool == TOOL_PICKING) { + tool = TOOL_PAINTING; - _pick_tile(over_tile); - } else if (tool == TOOL_SELECTING) { + paint_undo.clear(); + paint_undo[over_tile] = _get_op_from_cell(over_tile); - selection_active = true; - rectangle_begin = over_tile; + _set_cell(over_tile, id, flip_h, flip_v, transpose); } + } else if (tool == TOOL_PICKING) { - return true; + _pick_tile(over_tile); + } else if (tool == TOOL_SELECTING) { - } else { + selection_active = true; + rectangle_begin = over_tile; + } + + return true; - if (tool != TOOL_NONE) { + } else { - if (tool == TOOL_PAINTING) { + if (tool != TOOL_NONE) { - int id = get_selected_tile(); + if (tool == TOOL_PAINTING) { - if (id != TileMap::INVALID_CELL && paint_undo.size()) { + int id = get_selected_tile(); - undo_redo->create_action(TTR("Paint TileMap")); - for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + if (id != TileMap::INVALID_CELL && paint_undo.size()) { - Point2 p = E->key(); - undo_redo->add_do_method(node, "set_cellv", p, id, flip_h, flip_v, transpose); - undo_redo->add_undo_method(node, "set_cellv", p, E->get().idx, E->get().xf, E->get().yf, E->get().tr); - } - undo_redo->commit_action(); + undo_redo->create_action(TTR("Paint TileMap")); + for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { - paint_undo.clear(); + Point2 p = E->key(); + undo_redo->add_do_method(node, "set_cellv", p, id, flip_h, flip_v, transpose); + undo_redo->add_undo_method(node, "set_cellv", p, E->get().idx, E->get().xf, E->get().yf, E->get().tr); } - } else if (tool == TOOL_LINE_PAINT) { - - int id = get_selected_tile(); + undo_redo->commit_action(); - if (id != TileMap::INVALID_CELL) { + paint_undo.clear(); + } + } else if (tool == TOOL_LINE_PAINT) { - undo_redo->create_action("Line Draw"); - for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + int id = get_selected_tile(); - _set_cell(E->key(), id, flip_h, flip_v, transpose, true); - } - undo_redo->commit_action(); + if (id != TileMap::INVALID_CELL) { - paint_undo.clear(); + undo_redo->create_action("Line Draw"); + for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { - canvas_item_editor->update(); + _set_cell(E->key(), id, flip_h, flip_v, transpose, true); } - } else if (tool == TOOL_RECTANGLE_PAINT) { - - int id = get_selected_tile(); - - if (id != TileMap::INVALID_CELL) { + undo_redo->commit_action(); - undo_redo->create_action("Rectangle Paint"); - for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) { - for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) { + paint_undo.clear(); - _set_cell(Point2i(j, i), id, flip_h, flip_v, transpose, true); - } - } - undo_redo->commit_action(); + canvas_item_editor->update(); + } + } else if (tool == TOOL_RECTANGLE_PAINT) { - canvas_item_editor->update(); - } - } else if (tool == TOOL_DUPLICATING) { + int id = get_selected_tile(); - Point2 ofs = over_tile - rectangle.pos; + if (id != TileMap::INVALID_CELL) { - undo_redo->create_action(TTR("Duplicate")); - for (List<TileData>::Element *E = copydata.front(); E; E = E->next()) { + undo_redo->create_action("Rectangle Paint"); + for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) { + for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) { - _set_cell(E->get().pos + ofs, E->get().cell, E->get().flip_h, E->get().flip_v, E->get().transpose, true); + _set_cell(Point2i(j, i), id, flip_h, flip_v, transpose, true); + } } undo_redo->commit_action(); - copydata.clear(); - canvas_item_editor->update(); + } + } else if (tool == TOOL_DUPLICATING) { - } else if (tool == TOOL_SELECTING) { + Point2 ofs = over_tile - rectangle.pos; - canvas_item_editor->update(); + undo_redo->create_action(TTR("Duplicate")); + for (List<TileData>::Element *E = copydata.front(); E; E = E->next()) { - } else if (tool == TOOL_BUCKET) { + _set_cell(E->get().pos + ofs, E->get().cell, E->get().flip_h, E->get().flip_v, E->get().transpose, true); + } + undo_redo->commit_action(); - Dictionary pop; - pop["id"] = node->get_cell(over_tile.x, over_tile.y); - pop["flip_h"] = node->is_cell_x_flipped(over_tile.x, over_tile.y); - pop["flip_v"] = node->is_cell_y_flipped(over_tile.x, over_tile.y); - pop["transpose"] = node->is_cell_transposed(over_tile.x, over_tile.y); + copydata.clear(); + + canvas_item_editor->update(); - PoolVector<Vector2> points = _bucket_fill(over_tile); + } else if (tool == TOOL_SELECTING) { - if (points.size() == 0) - return false; + canvas_item_editor->update(); - Dictionary op; - op["id"] = get_selected_tile(); - op["flip_h"] = flip_h; - op["flip_v"] = flip_v; - op["transpose"] = transpose; + } else if (tool == TOOL_BUCKET) { - undo_redo->create_action("Bucket Fill"); + Dictionary pop; + pop["id"] = node->get_cell(over_tile.x, over_tile.y); + pop["flip_h"] = node->is_cell_x_flipped(over_tile.x, over_tile.y); + pop["flip_v"] = node->is_cell_y_flipped(over_tile.x, over_tile.y); + pop["transpose"] = node->is_cell_transposed(over_tile.x, over_tile.y); - undo_redo->add_do_method(this, "_fill_points", points, op); - undo_redo->add_undo_method(this, "_fill_points", points, pop); + PoolVector<Vector2> points = _bucket_fill(over_tile); - undo_redo->commit_action(); - } + if (points.size() == 0) + return false; - tool = TOOL_NONE; + Dictionary op; + op["id"] = get_selected_tile(); + op["flip_h"] = flip_h; + op["flip_v"] = flip_v; + op["transpose"] = transpose; - return true; + undo_redo->create_action("Bucket Fill"); + + undo_redo->add_do_method(this, "_fill_points", points, op); + undo_redo->add_undo_method(this, "_fill_points", points, pop); + + undo_redo->commit_action(); } - } - } else if (mb.button_index == BUTTON_RIGHT) { - if (mb.pressed) { + tool = TOOL_NONE; - if (tool == TOOL_SELECTING || selection_active) { + return true; + } + } + } else if (mb->get_button_index() == BUTTON_RIGHT) { - tool = TOOL_NONE; - selection_active = false; + if (mb->is_pressed()) { - canvas_item_editor->update(); + if (tool == TOOL_SELECTING || selection_active) { - return true; - } + tool = TOOL_NONE; + selection_active = false; - if (tool == TOOL_DUPLICATING) { + canvas_item_editor->update(); - tool = TOOL_NONE; - copydata.clear(); + return true; + } - canvas_item_editor->update(); + if (tool == TOOL_DUPLICATING) { - return true; - } + tool = TOOL_NONE; + copydata.clear(); - if (tool == TOOL_NONE) { + canvas_item_editor->update(); - paint_undo.clear(); + return true; + } - Point2 local = node->world_to_map(xform_inv.xform(Point2(mb.x, mb.y))); + if (tool == TOOL_NONE) { - if (mb.mod.shift) { + paint_undo.clear(); - if (mb.mod.control) - tool = TOOL_RECTANGLE_ERASE; - else - tool = TOOL_LINE_ERASE; + Point2 local = node->world_to_map(xform_inv.xform(mb->get_pos())); - selection_active = false; - rectangle_begin = local; - } else { + if (mb->get_shift()) { - tool = TOOL_ERASING; + if (mb->get_control()) + tool = TOOL_RECTANGLE_ERASE; + else + tool = TOOL_LINE_ERASE; - paint_undo[local] = _get_op_from_cell(local); - _set_cell(local, TileMap::INVALID_CELL); - } + selection_active = false; + rectangle_begin = local; + } else { - return true; + tool = TOOL_ERASING; + + paint_undo[local] = _get_op_from_cell(local); + _set_cell(local, TileMap::INVALID_CELL); } - } else { - if (tool == TOOL_ERASING || tool == TOOL_RECTANGLE_ERASE || tool == TOOL_LINE_ERASE) { + return true; + } - if (paint_undo.size()) { - undo_redo->create_action(TTR("Erase TileMap")); - for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + } else { + if (tool == TOOL_ERASING || tool == TOOL_RECTANGLE_ERASE || tool == TOOL_LINE_ERASE) { - Point2 p = E->key(); - undo_redo->add_do_method(node, "set_cellv", p, TileMap::INVALID_CELL, false, false, false); - undo_redo->add_undo_method(node, "set_cellv", p, E->get().idx, E->get().xf, E->get().yf, E->get().tr); - } + if (paint_undo.size()) { + undo_redo->create_action(TTR("Erase TileMap")); + for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { - undo_redo->commit_action(); - paint_undo.clear(); + Point2 p = E->key(); + undo_redo->add_do_method(node, "set_cellv", p, TileMap::INVALID_CELL, false, false, false); + undo_redo->add_undo_method(node, "set_cellv", p, E->get().idx, E->get().xf, E->get().yf, E->get().tr); } - if (tool == TOOL_RECTANGLE_ERASE || tool == TOOL_LINE_ERASE) { - canvas_item_editor->update(); - } + undo_redo->commit_action(); + paint_undo.clear(); + } - tool = TOOL_NONE; + if (tool == TOOL_RECTANGLE_ERASE || tool == TOOL_LINE_ERASE) { + canvas_item_editor->update(); + } - return true; + tool = TOOL_NONE; - } else if (tool == TOOL_BUCKET) { + return true; - Dictionary pop; - pop["id"] = node->get_cell(over_tile.x, over_tile.y); - pop["flip_h"] = node->is_cell_x_flipped(over_tile.x, over_tile.y); - pop["flip_v"] = node->is_cell_y_flipped(over_tile.x, over_tile.y); - pop["transpose"] = node->is_cell_transposed(over_tile.x, over_tile.y); + } else if (tool == TOOL_BUCKET) { - PoolVector<Vector2> points = _bucket_fill(over_tile, true); + Dictionary pop; + pop["id"] = node->get_cell(over_tile.x, over_tile.y); + pop["flip_h"] = node->is_cell_x_flipped(over_tile.x, over_tile.y); + pop["flip_v"] = node->is_cell_y_flipped(over_tile.x, over_tile.y); + pop["transpose"] = node->is_cell_transposed(over_tile.x, over_tile.y); - if (points.size() == 0) - return false; + PoolVector<Vector2> points = _bucket_fill(over_tile, true); - undo_redo->create_action("Bucket Fill"); + if (points.size() == 0) + return false; - undo_redo->add_do_method(this, "_erase_points", points); - undo_redo->add_undo_method(this, "_fill_points", points, pop); + undo_redo->create_action("Bucket Fill"); - undo_redo->commit_action(); - } + undo_redo->add_do_method(this, "_erase_points", points); + undo_redo->add_undo_method(this, "_fill_points", points, pop); + + undo_redo->commit_action(); } } - } break; - case InputEvent::MOUSE_MOTION: { + } + } - const InputEventMouseMotion &mm = p_event.mouse_motion; + Ref<InputEventMouseMotion> mm = p_event; - Point2i new_over_tile = node->world_to_map(xform_inv.xform(Point2(mm.x, mm.y))); + if (mm.is_valid()) { - if (new_over_tile != over_tile) { + Point2i new_over_tile = node->world_to_map(xform_inv.xform(mm->get_pos())); - over_tile = new_over_tile; - canvas_item_editor->update(); - } + if (new_over_tile != over_tile) { - int tile_under = node->get_cell(over_tile.x, over_tile.y); - String tile_name = "none"; + over_tile = new_over_tile; + canvas_item_editor->update(); + } - if (node->get_tileset()->has_tile(tile_under)) - tile_name = node->get_tileset()->tile_get_name(tile_under); - tile_info->set_text(String::num(over_tile.x) + ", " + String::num(over_tile.y) + " [" + tile_name + "]"); + int tile_under = node->get_cell(over_tile.x, over_tile.y); + String tile_name = "none"; - if (tool == TOOL_PAINTING) { + if (node->get_tileset()->has_tile(tile_under)) + tile_name = node->get_tileset()->tile_get_name(tile_under); + tile_info->set_text(String::num(over_tile.x) + ", " + String::num(over_tile.y) + " [" + tile_name + "]"); - int id = get_selected_tile(); - if (id != TileMap::INVALID_CELL) { + if (tool == TOOL_PAINTING) { - if (!paint_undo.has(over_tile)) { - paint_undo[over_tile] = _get_op_from_cell(over_tile); - } - - _set_cell(over_tile, id, flip_h, flip_v, transpose); + int id = get_selected_tile(); + if (id != TileMap::INVALID_CELL) { - return true; + if (!paint_undo.has(over_tile)) { + paint_undo[over_tile] = _get_op_from_cell(over_tile); } - } - if (tool == TOOL_SELECTING) { - - _select(rectangle_begin, over_tile); + _set_cell(over_tile, id, flip_h, flip_v, transpose); return true; } + } - if (tool == TOOL_LINE_PAINT || tool == TOOL_LINE_ERASE) { + if (tool == TOOL_SELECTING) { - int id = get_selected_tile(); - bool erasing = (tool == TOOL_LINE_ERASE); + _select(rectangle_begin, over_tile); - if (erasing && paint_undo.size()) { + return true; + } - for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + if (tool == TOOL_LINE_PAINT || tool == TOOL_LINE_ERASE) { - _set_cell(E->key(), E->get().idx, E->get().xf, E->get().yf, E->get().tr); - } - } + int id = get_selected_tile(); + bool erasing = (tool == TOOL_LINE_ERASE); - paint_undo.clear(); + if (erasing && paint_undo.size()) { + + for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + + _set_cell(E->key(), E->get().idx, E->get().xf, E->get().yf, E->get().tr); + } + } - if (id != TileMap::INVALID_CELL) { + paint_undo.clear(); - Vector<Point2i> points = line(rectangle_begin.x, over_tile.x, rectangle_begin.y, over_tile.y); + if (id != TileMap::INVALID_CELL) { - for (int i = 0; i < points.size(); i++) { + Vector<Point2i> points = line(rectangle_begin.x, over_tile.x, rectangle_begin.y, over_tile.y); - paint_undo[points[i]] = _get_op_from_cell(points[i]); + for (int i = 0; i < points.size(); i++) { - if (erasing) - _set_cell(points[i], TileMap::INVALID_CELL); - } + paint_undo[points[i]] = _get_op_from_cell(points[i]); - canvas_item_editor->update(); + if (erasing) + _set_cell(points[i], TileMap::INVALID_CELL); } - return true; + canvas_item_editor->update(); } - if (tool == TOOL_RECTANGLE_PAINT || tool == TOOL_RECTANGLE_ERASE) { - _select(rectangle_begin, over_tile); + return true; + } + if (tool == TOOL_RECTANGLE_PAINT || tool == TOOL_RECTANGLE_ERASE) { - if (tool == TOOL_RECTANGLE_ERASE) { + _select(rectangle_begin, over_tile); - if (paint_undo.size()) { + if (tool == TOOL_RECTANGLE_ERASE) { - for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + if (paint_undo.size()) { - _set_cell(E->key(), E->get().idx, E->get().xf, E->get().yf, E->get().tr); - } + for (Map<Point2i, CellOp>::Element *E = paint_undo.front(); E; E = E->next()) { + + _set_cell(E->key(), E->get().idx, E->get().xf, E->get().yf, E->get().tr); } + } - paint_undo.clear(); + paint_undo.clear(); - for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) { - for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) { + for (int i = rectangle.pos.y; i <= rectangle.pos.y + rectangle.size.y; i++) { + for (int j = rectangle.pos.x; j <= rectangle.pos.x + rectangle.size.x; j++) { - Point2i tile = Point2i(j, i); - paint_undo[tile] = _get_op_from_cell(tile); + Point2i tile = Point2i(j, i); + paint_undo[tile] = _get_op_from_cell(tile); - _set_cell(tile, TileMap::INVALID_CELL); - } + _set_cell(tile, TileMap::INVALID_CELL); } } - - return true; } - if (tool == TOOL_ERASING) { - - if (!paint_undo.has(over_tile)) { - paint_undo[over_tile] = _get_op_from_cell(over_tile); - } - _set_cell(over_tile, TileMap::INVALID_CELL); + return true; + } + if (tool == TOOL_ERASING) { - return true; + if (!paint_undo.has(over_tile)) { + paint_undo[over_tile] = _get_op_from_cell(over_tile); } - if (tool == TOOL_PICKING && Input::get_singleton()->is_mouse_button_pressed(BUTTON_LEFT)) { - _pick_tile(over_tile); + _set_cell(over_tile, TileMap::INVALID_CELL); - return true; - } - } break; - case InputEvent::KEY: { + return true; + } + if (tool == TOOL_PICKING && Input::get_singleton()->is_mouse_button_pressed(BUTTON_LEFT)) { - const InputEventKey &k = p_event.key; + _pick_tile(over_tile); - if (!k.pressed) - break; + return true; + } + } - if (k.scancode == KEY_ESCAPE) { + Ref<InputEventKey> k = p_event; - if (tool == TOOL_DUPLICATING) - copydata.clear(); - else if (tool == TOOL_SELECTING || selection_active) - selection_active = false; + if (k.is_valid() && k->is_pressed()) { - tool = TOOL_NONE; + if (k->get_scancode() == KEY_ESCAPE) { - canvas_item_editor->update(); + if (tool == TOOL_DUPLICATING) + copydata.clear(); + else if (tool == TOOL_SELECTING || selection_active) + selection_active = false; - return true; - } + tool = TOOL_NONE; - if (tool != TOOL_NONE || !mouse_over) - return false; + canvas_item_editor->update(); - if (ED_IS_SHORTCUT("tile_map_editor/erase_selection", p_event)) { - _menu_option(OPTION_ERASE_SELECTION); + return true; + } - return true; - } - if (ED_IS_SHORTCUT("tile_map_editor/select", p_event)) { - tool = TOOL_SELECTING; - selection_active = false; + if (tool != TOOL_NONE || !mouse_over) + return false; - canvas_item_editor->update(); + if (ED_IS_SHORTCUT("tile_map_editor/erase_selection", p_event)) { + _menu_option(OPTION_ERASE_SELECTION); - return true; - } - if (ED_IS_SHORTCUT("tile_map_editor/duplicate_selection", p_event)) { - _update_copydata(); + return true; + } + if (ED_IS_SHORTCUT("tile_map_editor/select", p_event)) { + tool = TOOL_SELECTING; + selection_active = false; - if (selection_active) { - tool = TOOL_DUPLICATING; + canvas_item_editor->update(); - canvas_item_editor->update(); + return true; + } + if (ED_IS_SHORTCUT("tile_map_editor/duplicate_selection", p_event)) { + _update_copydata(); - return true; - } - } - if (ED_IS_SHORTCUT("tile_map_editor/find_tile", p_event)) { - search_box->select_all(); - search_box->grab_focus(); + if (selection_active) { + tool = TOOL_DUPLICATING; - return true; - } - if (ED_IS_SHORTCUT("tile_map_editor/mirror_x", p_event)) { - flip_h = !flip_h; - mirror_x->set_pressed(flip_h); - canvas_item_editor->update(); - return true; - } - if (ED_IS_SHORTCUT("tile_map_editor/mirror_y", p_event)) { - flip_v = !flip_v; - mirror_y->set_pressed(flip_v); - canvas_item_editor->update(); - return true; - } - if (ED_IS_SHORTCUT("tile_map_editor/transpose", p_event)) { - transpose = !transpose; - transp->set_pressed(transpose); canvas_item_editor->update(); + return true; } - } break; + } + if (ED_IS_SHORTCUT("tile_map_editor/find_tile", p_event)) { + search_box->select_all(); + search_box->grab_focus(); + + return true; + } + if (ED_IS_SHORTCUT("tile_map_editor/mirror_x", p_event)) { + flip_h = !flip_h; + mirror_x->set_pressed(flip_h); + canvas_item_editor->update(); + return true; + } + if (ED_IS_SHORTCUT("tile_map_editor/mirror_y", p_event)) { + flip_v = !flip_v; + mirror_y->set_pressed(flip_v); + canvas_item_editor->update(); + return true; + } + if (ED_IS_SHORTCUT("tile_map_editor/transpose", p_event)) { + transpose = !transpose; + transp->set_pressed(transpose); + canvas_item_editor->update(); + return true; + } } return false; diff --git a/editor/plugins/tile_map_editor_plugin.h b/editor/plugins/tile_map_editor_plugin.h index 3eedb6c941..981d5c66a1 100644 --- a/editor/plugins/tile_map_editor_plugin.h +++ b/editor/plugins/tile_map_editor_plugin.h @@ -158,7 +158,7 @@ class TileMapEditor : public VBoxContainer { void _text_entered(const String &p_text); void _text_changed(const String &p_text); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _update_palette(); void _canvas_draw(); void _menu_option(int p_option); @@ -179,7 +179,7 @@ protected: public: HBoxContainer *get_toolbar() const { return toolbar; } - bool forward_gui_input(const InputEvent &p_event); + bool forward_gui_input(const Ref<InputEvent> &p_event); void edit(Node *p_tile_map); TileMapEditor(EditorNode *p_editor); @@ -193,7 +193,7 @@ class TileMapEditorPlugin : public EditorPlugin { TileMapEditor *tile_map_editor; public: - virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const InputEvent &p_event) { return tile_map_editor->forward_gui_input(p_event); } + virtual bool forward_canvas_gui_input(const Transform2D &p_canvas_xform, const Ref<InputEvent> &p_event) { return tile_map_editor->forward_gui_input(p_event); } virtual String get_name() const { return "TileMap"; } bool has_main_screen() const { return false; } diff --git a/editor/project_manager.cpp b/editor/project_manager.cpp index 2d3b3a2200..50b518afba 100644 --- a/editor/project_manager.cpp +++ b/editor/project_manager.cpp @@ -503,14 +503,16 @@ void ProjectManager::_update_project_buttons() { run_btn->set_disabled(!has_runnable_scene); } -void ProjectManager::_panel_input(const InputEvent &p_ev, Node *p_hb) { +void ProjectManager::_panel_input(const Ref<InputEvent> &p_ev, Node *p_hb) { - if (p_ev.type == InputEvent::MOUSE_BUTTON && p_ev.mouse_button.pressed && p_ev.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_ev; + + if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { String clicked = p_hb->get_meta("name"); String clicked_main_scene = p_hb->get_meta("main_scene"); - if (p_ev.key.mod.shift && selected_list.size() > 0 && last_clicked != "" && clicked != last_clicked) { + if (mb->get_shift() && selected_list.size() > 0 && last_clicked != "" && clicked != last_clicked) { int clicked_id = -1; int last_clicked_id = -1; @@ -527,7 +529,7 @@ void ProjectManager::_panel_input(const InputEvent &p_ev, Node *p_hb) { for (int i = 0; i < scroll_childs->get_child_count(); ++i) { HBoxContainer *hb = scroll_childs->get_child(i)->cast_to<HBoxContainer>(); if (!hb) continue; - if (i != clicked_id && (i < min || i > max) && !p_ev.key.mod.control) { + if (i != clicked_id && (i < min || i > max) && !mb->get_control()) { selected_list.erase(hb->get_meta("name")); } else if (i >= min && i <= max) { selected_list.insert(hb->get_meta("name"), hb->get_meta("main_scene")); @@ -535,14 +537,14 @@ void ProjectManager::_panel_input(const InputEvent &p_ev, Node *p_hb) { } } - } else if (selected_list.has(clicked) && p_ev.key.mod.control) { + } else if (selected_list.has(clicked) && mb->get_control()) { selected_list.erase(clicked); } else { last_clicked = clicked; - if (p_ev.key.mod.control || selected_list.size() == 0) { + if (mb->get_control() || selected_list.size() == 0) { selected_list.insert(clicked, clicked_main_scene); } else { selected_list.clear(); @@ -552,23 +554,23 @@ void ProjectManager::_panel_input(const InputEvent &p_ev, Node *p_hb) { _update_project_buttons(); - if (p_ev.mouse_button.doubleclick) + if (mb->is_doubleclick()) _open_project(); //open if doubleclicked } } -void ProjectManager::_unhandled_input(const InputEvent &p_ev) { +void ProjectManager::_unhandled_input(const Ref<InputEvent> &p_ev) { - if (p_ev.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_ev; - const InputEventKey &k = p_ev.key; + if (k.is_valid()) { - if (!k.pressed) + if (!k->is_pressed()) return; bool scancode_handled = true; - switch (k.scancode) { + switch (k->get_scancode()) { case KEY_RETURN: { @@ -606,7 +608,7 @@ void ProjectManager::_unhandled_input(const InputEvent &p_ev) { } break; case KEY_UP: { - if (k.mod.shift) + if (k->get_shift()) break; if (selected_list.size()) { @@ -645,7 +647,7 @@ void ProjectManager::_unhandled_input(const InputEvent &p_ev) { } case KEY_DOWN: { - if (k.mod.shift) + if (k->get_shift()) break; bool found = selected_list.empty(); @@ -679,7 +681,7 @@ void ProjectManager::_unhandled_input(const InputEvent &p_ev) { } break; case KEY_F: { - if (k.mod.command) + if (k->get_command()) this->project_filter->search_box->grab_focus(); else scancode_handled = false; diff --git a/editor/project_manager.h b/editor/project_manager.h index 5be28ce2f0..27886132c5 100644 --- a/editor/project_manager.h +++ b/editor/project_manager.h @@ -91,8 +91,8 @@ class ProjectManager : public Control { void _install_project(const String &p_zip_path, const String &p_title); void _panel_draw(Node *p_hb); - void _panel_input(const InputEvent &p_ev, Node *p_hb); - void _unhandled_input(const InputEvent &p_ev); + void _panel_input(const Ref<InputEvent> &p_ev, Node *p_hb); + void _unhandled_input(const Ref<InputEvent> &p_ev); void _favorite_pressed(Node *p_hb); void _files_dropped(PoolStringArray p_files, int p_screen); void _scan_multiple_folders(PoolStringArray p_files); diff --git a/editor/project_settings.cpp b/editor/project_settings.cpp index c9a6d4df66..1c4ca3cb58 100644 --- a/editor/project_settings.cpp +++ b/editor/project_settings.cpp @@ -83,10 +83,10 @@ void ProjectSettings::_notification(int p_what) { 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::JOYPAD_BUTTON); - popup_add->add_icon_item(get_icon("JoyAxis", "EditorIcons"), TTR("Joy Axis"), InputEvent::JOYPAD_MOTION); - popup_add->add_icon_item(get_icon("Mouse", "EditorIcons"), TTR("Mouse Button"), InputEvent::MOUSE_BUTTON); + popup_add->add_icon_item(get_icon("Keyboard", "EditorIcons"), TTR("Key "), INPUT_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"), INPUT_JOY_BUTTON); + popup_add->add_icon_item(get_icon("JoyAxis", "EditorIcons"), TTR("Joy Axis"), INPUT_JOY_MOTION); + popup_add->add_icon_item(get_icon("Mouse", "EditorIcons"), TTR("Mouse Button"), INPUT_MOUSE_BUTTON); List<String> tfn; ResourceLoader::get_recognized_extensions_for_type("Translation", &tfn); @@ -178,54 +178,74 @@ void ProjectSettings::_action_edited() { void ProjectSettings::_device_input_add() { - InputEvent ie; + Ref<InputEvent> ie; String name = add_at; Variant old_val = GlobalConfig::get_singleton()->get(name); Array arr = old_val; - ie.device = device_id->get_value(); - - ie.type = add_type; + // ie.device = device_id->get_value(); + // ie.type = add_type; switch (add_type) { - case InputEvent::MOUSE_BUTTON: { + case INPUT_MOUSE_BUTTON: { - ie.mouse_button.button_index = device_index->get_selected() + 1; + Ref<InputEventMouseButton> mb; + mb.instance(); + mb->set_button_index(device_index->get_selected() + 1); + mb->set_device(device_id->get_value()); 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) { + Ref<InputEventMouseButton> aie = arr[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 InputEvent::JOYPAD_MOTION: { + case INPUT_JOY_MOTION: { - ie.joy_motion.axis = device_index->get_selected() >> 1; - ie.joy_motion.axis_value = device_index->get_selected() & 1 ? 1 : -1; + 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(device_id->get_value()); for (int i = 0; i < arr.size(); i++) { - InputEvent aie = arr[i]; - if (aie.device == ie.device && aie.type == InputEvent::JOYPAD_MOTION && aie.joy_motion.axis == ie.joy_motion.axis && aie.joy_motion.axis_value == ie.joy_motion.axis_value) { + Ref<InputEventJoypadMotion> aie = arr[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 InputEvent::JOYPAD_BUTTON: { + case INPUT_JOY_BUTTON: { - ie.joy_button.button_index = device_index->get_selected(); + Ref<InputEventJoypadButton> jb; + jb.instance(); + + jb->set_button_index(device_index->get_selected()); + jb->set_device(device_id->get_value()); for (int i = 0; i < arr.size(); i++) { - InputEvent aie = arr[i]; - if (aie.device == ie.device && aie.type == InputEvent::JOYPAD_BUTTON && aie.joy_button.button_index == ie.joy_button.button_index) { + Ref<InputEventJoypadButton> aie = arr[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: {} @@ -247,13 +267,17 @@ void ProjectSettings::_device_input_add() { void ProjectSettings::_press_a_key_confirm() { - if (last_wait_for_key.type != InputEvent::KEY) + if (last_wait_for_key.is_null()) 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; + Ref<InputEventKey> ie; + ie.instance(); + ie->set_scancode(last_wait_for_key->get_scancode()); + 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; Variant old_val = GlobalConfig::get_singleton()->get(name); @@ -261,8 +285,10 @@ void ProjectSettings::_press_a_key_confirm() { 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) { + Ref<InputEventKey> aie = arr[i]; + if (aie.is_null()) + continue; + if (aie->get_scancode_with_modifiers() == ie->get_scancode_with_modifiers()) { return; } } @@ -281,7 +307,7 @@ void ProjectSettings::_press_a_key_confirm() { _show_last_added(ie, name); } -void ProjectSettings::_show_last_added(const InputEvent &p_event, const String &p_name) { +void ProjectSettings::_show_last_added(const Ref<InputEvent> &p_event, const String &p_name) { TreeItem *r = input_editor->get_root(); String name = p_name; @@ -314,19 +340,21 @@ void ProjectSettings::_show_last_added(const InputEvent &p_event, const String & if (found) input_editor->ensure_cursor_is_visible(); } -void ProjectSettings::_wait_for_key(const InputEvent &p_event) { +void ProjectSettings::_wait_for_key(const Ref<InputEvent> &p_event) { + + Ref<InputEventKey> k = p_event; - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode != 0) { + if (k.is_valid() && k->is_pressed() && k->get_scancode() != 0) { last_wait_for_key = p_event; - String str = keycode_get_string(p_event.key.scancode).capitalize(); - if (p_event.key.mod.meta) + String str = keycode_get_string(k->get_scancode()).capitalize(); + if (k->get_metakey()) str = TTR("Meta+") + str; - if (p_event.key.mod.shift) + if (k->get_shift()) str = TTR("Shift+") + str; - if (p_event.key.mod.alt) + if (k->get_alt()) str = TTR("Alt+") + str; - if (p_event.key.mod.control) + if (k->get_control()) str = TTR("Control+") + str; press_a_key_label->set_text(str); @@ -336,18 +364,18 @@ void ProjectSettings::_wait_for_key(const InputEvent &p_event) { void ProjectSettings::_add_item(int p_item) { - add_type = InputEvent::Type(p_item); + add_type = InputType(p_item); switch (add_type) { - case InputEvent::KEY: { + case INPUT_KEY: { press_a_key_label->set_text(TTR("Press a Key..")); - last_wait_for_key = InputEvent(); + last_wait_for_key = Ref<InputEvent>(); press_a_key->popup_centered(Size2(250, 80) * EDSCALE); press_a_key->grab_focus(); } break; - case InputEvent::MOUSE_BUTTON: { + case INPUT_MOUSE_BUTTON: { device_id->set_value(0); device_index_label->set_text(TTR("Mouse Button Index:")); @@ -363,7 +391,7 @@ void ProjectSettings::_add_item(int p_item) { device_index->add_item(TTR("Button 9")); device_input->popup_centered_minsize(Size2(350, 95)); } break; - case InputEvent::JOYPAD_MOTION: { + case INPUT_JOY_MOTION: { device_id->set_value(0); device_index_label->set_text(TTR("Joypad Axis Index:")); @@ -376,7 +404,7 @@ void ProjectSettings::_add_item(int p_item) { device_input->popup_centered_minsize(Size2(350, 95)); } break; - case InputEvent::JOYPAD_BUTTON: { + case INPUT_JOY_BUTTON: { device_id->set_value(0); device_index_label->set_text(TTR("Joypad Button Index:")); @@ -496,65 +524,70 @@ void ProjectSettings::_update_actions() { for (int i = 0; i < actions.size(); i++) { - if (actions[i].get_type() != Variant::INPUT_EVENT) + Ref<InputEvent> ie = actions[i]; + if (ie.is_null()) 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::JOYPAD_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::JOYPAD_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; + Ref<InputEventKey> k = ie; + if (k.is_valid()) { + + String str = keycode_get_string(k->get_scancode()).capitalize(); + if (k->get_metakey()) + str = TTR("Meta+") + str; + if (k->get_shift()) + str = TTR("Shift+") + str; + if (k->get_alt()) + str = TTR("Alt+") + str; + if (k->get_control()) + str = TTR("Control+") + str; + + action->set_text(0, str); + action->set_icon(0, get_icon("Keyboard", "EditorIcons")); + } + + Ref<InputEventJoypadButton> jb = ie; + + if (jb.is_valid()) { + + String str = TTR("Device") + " " + itos(jb->get_device()) + ", " + TTR("Button") + " " + itos(jb->get_button_index()); + if (jb->get_button_index() >= 0 && jb->get_button_index() < JOY_BUTTON_MAX) + str += String() + " (" + _button_names[jb->get_button_index()] + ")."; + else + str += "."; + + action->set_text(0, str); + action->set_icon(0, get_icon("JoyButton", "EditorIcons")); + } + + Ref<InputEventMouseButton> mb = ie; + + if (mb.is_valid()) { + String str = TTR("Device") + " " + itos(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 += TTR("Button") + " " + itos(mb->get_button_index()) + "."; + } + + action->set_text(0, str); + action->set_icon(0, get_icon("Mouse", "EditorIcons")); + } + + Ref<InputEventJoypadMotion> jm = ie; + + if (jm.is_valid()) { + + int ax = jm->get_axis(); + int n = 2 * ax + (jm->get_axis_value() < 0 ? 0 : 1); + String desc = _axis_names[n]; + String str = TTR("Device") + " " + itos(jm->get_device()) + ", " + TTR("Axis") + " " + itos(ax) + " " + (jm->get_axis_value() < 0 ? "-" : "+") + desc + "."; + action->set_text(0, str); + action->set_icon(0, get_icon("JoyAxis", "EditorIcons")); } action->add_button(0, get_icon("Remove", "EditorIcons"), 2, false, TTR("Remove")); action->set_metadata(0, i); diff --git a/editor/project_settings.h b/editor/project_settings.h index a5a9e04250..47fb45cf8e 100644 --- a/editor/project_settings.h +++ b/editor/project_settings.h @@ -43,10 +43,17 @@ class ProjectSettings : public AcceptDialog { GDCLASS(ProjectSettings, AcceptDialog); + enum InputType { + INPUT_KEY, + INPUT_JOY_BUTTON, + INPUT_JOY_MOTION, + INPUT_MOUSE_BUTTON + }; + TabContainer *tab_container; Timer *timer; - InputEvent::Type add_type; + InputType add_type; String add_at; EditorData *data; @@ -77,7 +84,7 @@ class ProjectSettings : public AcceptDialog { bool setting; bool updating_translations; - InputEvent last_wait_for_key; + Ref<InputEventKey> last_wait_for_key; EditorFileDialog *translation_file_open; Tree *translation_list; @@ -108,9 +115,9 @@ class ProjectSettings : public AcceptDialog { void _action_selected(); void _action_edited(); void _action_button_pressed(Object *p_obj, int p_column, int p_id); - void _wait_for_key(const InputEvent &p_event); + void _wait_for_key(const Ref<InputEvent> &p_event); void _press_a_key_confirm(); - void _show_last_added(const InputEvent &p_event, const String &p_name); + void _show_last_added(const Ref<InputEvent> &p_event, const String &p_name); void _settings_prop_edited(const String &p_name); void _settings_changed(); diff --git a/editor/property_editor.cpp b/editor/property_editor.cpp index 2cc7acd260..1c8a1c0ee0 100644 --- a/editor/property_editor.cpp +++ b/editor/property_editor.cpp @@ -609,12 +609,9 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant:: type = Variant::Type(Variant::Type(i)); } } - InputEvent::Type iet = InputEvent::NONE; - if (hint_text.find(".") != -1) { - iet = InputEvent::Type(int(hint_text.get_slice(".", 1).to_int())); - } + if (type) - property_select->select_property_from_basic_type(type, iet, v); + property_select->select_property_from_basic_type(type, v); updating = false; return false; @@ -979,9 +976,6 @@ bool CustomPropertyEditor::edit(Object *p_owner, const String &p_name, Variant:: return false; } break; - case Variant::INPUT_EVENT: { - - } break; case Variant::DICTIONARY: { } break; @@ -1401,11 +1395,13 @@ void CustomPropertyEditor::_scroll_modified(double p_value) { */ } -void CustomPropertyEditor::_drag_easing(const InputEvent &p_ev) { +void CustomPropertyEditor::_drag_easing(const Ref<InputEvent> &p_ev) { + + Ref<InputEventMouseMotion> mm = p_ev; - if (p_ev.type == InputEvent::MOUSE_MOTION && p_ev.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT) { - float rel = p_ev.mouse_motion.relative_x; + float rel = mm->get_relative().x; if (rel == 0) return; @@ -1434,8 +1430,8 @@ void CustomPropertyEditor::_drag_easing(const InputEvent &p_ev) { //emit_signal("variant_changed"); emit_signal("variant_changed"); } - if (p_ev.type == InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index == BUTTON_LEFT) { - } + // if (p_ev.type == Ref<InputEvent>::MOUSE_BUTTON && p_ev->get_button_index() == BUTTON_LEFT) { + // } } void CustomPropertyEditor::_draw_easing() { @@ -1715,9 +1711,6 @@ void CustomPropertyEditor::_modified(String p_string) { v = NodePath(value_editor[0]->get_text()); emit_signal("variant_changed"); } break; - case Variant::INPUT_EVENT: { - - } break; case Variant::DICTIONARY: { } break; @@ -3862,9 +3855,6 @@ void PropertyEditor::_item_edited() { } break; - case Variant::INPUT_EVENT: { - - } break; case Variant::DICTIONARY: { } break; diff --git a/editor/property_editor.h b/editor/property_editor.h index b88ba38e19..c02c301acf 100644 --- a/editor/property_editor.h +++ b/editor/property_editor.h @@ -134,7 +134,7 @@ class CustomPropertyEditor : public Popup { void _draw_easing(); void _menu_option(int p_which); - void _drag_easing(const InputEvent &p_ev); + void _drag_easing(const Ref<InputEvent> &p_ev); void _node_path_selected(NodePath p_path); void show_value_editors(int p_amount); diff --git a/editor/property_selector.cpp b/editor/property_selector.cpp index 752965c806..47e5994e3f 100644 --- a/editor/property_selector.cpp +++ b/editor/property_selector.cpp @@ -37,17 +37,19 @@ void PropertySelector::_text_changed(const String &p_newtext) { _update_search(); } -void PropertySelector::_sbox_input(const InputEvent &p_ie) { +void PropertySelector::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_ie; - switch (p_ie.key.scancode) { + if (k.is_valid()) { + + switch (k->get_scancode()) { case KEY_UP: case KEY_DOWN: case KEY_PAGEUP: case KEY_PAGEDOWN: { - search_options->call("_gui_input", p_ie); + search_options->call("_gui_input", k); search_box->accept_event(); TreeItem *root = search_options->get_root(); @@ -89,14 +91,8 @@ void PropertySelector::_update_search() { instance->get_property_list(&props, true); } else if (type != Variant::NIL) { Variant v; - if (type == Variant::INPUT_EVENT) { - InputEvent ie; - ie.type = event_type; - v = ie; - } else { - Variant::CallError ce; - v = Variant::construct(type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(type, NULL, 0, ce); v.get_property_list(&props); } else { @@ -139,7 +135,6 @@ void PropertySelector::_update_search() { Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), - Control::get_icon("MiniInput", "EditorIcons"), Control::get_icon("MiniDictionary", "EditorIcons"), Control::get_icon("MiniArray", "EditorIcons"), Control::get_icon("MiniRawArray", "EditorIcons"), @@ -325,22 +320,7 @@ void PropertySelector::_item_selected() { String name = item->get_metadata(0); String class_type; - if (properties && type == Variant::INPUT_EVENT) { - - switch (event_type) { - case InputEvent::NONE: class_type = "InputEvent"; break; - case InputEvent::KEY: class_type = "InputEventKey"; break; - case InputEvent::MOUSE_MOTION: class_type = "InputEventMouseMotion"; break; - case InputEvent::MOUSE_BUTTON: class_type = "InputEventMouseButton"; break; - case InputEvent::JOYPAD_MOTION: class_type = "InputEventJoypadMotion"; break; - case InputEvent::JOYPAD_BUTTON: class_type = "InputEventJoypadButton"; break; - case InputEvent::SCREEN_TOUCH: class_type = "InputEventScreenTouch"; break; - case InputEvent::SCREEN_DRAG: class_type = "InputEventScreenDrag"; break; - case InputEvent::ACTION: class_type = "InputEventAction"; break; - default: {} - } - - } else if (type) { + if (type) { class_type = Variant::get_type_name(type); } else { @@ -514,13 +494,12 @@ void PropertySelector::select_property_from_script(const Ref<Script> &p_script, search_box->grab_focus(); _update_search(); } -void PropertySelector::select_property_from_basic_type(Variant::Type p_type, InputEvent::Type p_event_type, const String &p_current) { +void PropertySelector::select_property_from_basic_type(Variant::Type p_type, const String &p_current) { ERR_FAIL_COND(p_type == Variant::NIL); base_type = ""; selected = p_current; type = p_type; - event_type = p_event_type; script = 0; properties = true; instance = NULL; diff --git a/editor/property_selector.h b/editor/property_selector.h index 6dc2592176..def791a3fd 100644 --- a/editor/property_selector.h +++ b/editor/property_selector.h @@ -42,7 +42,7 @@ class PropertySelector : public ConfirmationDialog { void _update_search(); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _confirmed(); void _text_changed(const String &p_newtext); @@ -52,7 +52,6 @@ class PropertySelector : public ConfirmationDialog { bool properties; String selected; Variant::Type type; - InputEvent::Type event_type; String base_type; ObjectID script; Object *instance; @@ -71,7 +70,7 @@ public: void select_property_from_base_type(const String &p_base, const String &p_current = ""); void select_property_from_script(const Ref<Script> &p_script, const String &p_current = ""); - void select_property_from_basic_type(Variant::Type p_type, InputEvent::Type p_event_type, const String &p_current = ""); + void select_property_from_basic_type(Variant::Type p_type, const String &p_current = ""); void select_property_from_instance(Object *p_instance, const String &p_current = ""); PropertySelector(); diff --git a/editor/quick_open.cpp b/editor/quick_open.cpp index 7fce485f3a..7fb9666afb 100644 --- a/editor/quick_open.cpp +++ b/editor/quick_open.cpp @@ -77,17 +77,18 @@ void EditorQuickOpen::_text_changed(const String &p_newtext) { _update_search(); } -void EditorQuickOpen::_sbox_input(const InputEvent &p_ie) { +void EditorQuickOpen::_sbox_input(const Ref<InputEvent> &p_ie) { - if (p_ie.type == InputEvent::KEY) { + Ref<InputEventKey> k = p_ie; + if (k.is_valid()) { - switch (p_ie.key.scancode) { + switch (k->get_scancode()) { case KEY_UP: case KEY_DOWN: case KEY_PAGEUP: case KEY_PAGEDOWN: { - search_options->call("_gui_input", p_ie); + search_options->call("_gui_input", k); search_box->accept_event(); TreeItem *root = search_options->get_root(); diff --git a/editor/quick_open.h b/editor/quick_open.h index 0e5766033f..44f8c025e6 100644 --- a/editor/quick_open.h +++ b/editor/quick_open.h @@ -47,7 +47,7 @@ class EditorQuickOpen : public ConfirmationDialog { void _update_search(); - void _sbox_input(const InputEvent &p_ie); + void _sbox_input(const Ref<InputEvent> &p_ie); void _parse_fs(EditorFileSystemDirectory *efsd, Vector<Pair<String, Ref<Texture> > > &list); float _path_cmp(String search, String path) const; diff --git a/editor/scene_tree_dock.cpp b/editor/scene_tree_dock.cpp index 7916b6b63c..0f05cc79ff 100644 --- a/editor/scene_tree_dock.cpp +++ b/editor/scene_tree_dock.cpp @@ -52,19 +52,21 @@ void SceneTreeDock::_nodes_drag_begin() { } } -void SceneTreeDock::_input(InputEvent p_event) { +void SceneTreeDock::_input(Ref<InputEvent> p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { restore_script_editor_on_drag = false; //lost chance } } -void SceneTreeDock::_unhandled_key_input(InputEvent p_event) { +void SceneTreeDock::_unhandled_key_input(Ref<InputEvent> p_event) { if (get_viewport()->get_modal_stack_top()) return; //ignore because of modal window - if (!p_event.key.pressed || p_event.key.echo) + if (!p_event->is_pressed() || p_event->is_echo()) return; if (ED_IS_SHORTCUT("scene_tree/add_child_node", p_event)) { diff --git a/editor/scene_tree_dock.h b/editor/scene_tree_dock.h index de6b81d44a..f190025dd6 100644 --- a/editor/scene_tree_dock.h +++ b/editor/scene_tree_dock.h @@ -133,8 +133,8 @@ class SceneTreeDock : public VBoxContainer { void _node_prerenamed(Node *p_node, const String &p_new_name); void _nodes_drag_begin(); - void _input(InputEvent p_event); - void _unhandled_key_input(InputEvent p_event); + void _input(Ref<InputEvent> p_event); + void _unhandled_key_input(Ref<InputEvent> p_event); void _import_subscene(); diff --git a/editor/settings_config_dialog.cpp b/editor/settings_config_dialog.cpp index 16ab431321..563de78415 100644 --- a/editor/settings_config_dialog.cpp +++ b/editor/settings_config_dialog.cpp @@ -148,7 +148,7 @@ void EditorSettingsDialog::_update_shortcuts() { if (!sc->has_meta("original")) continue; - InputEvent original = sc->get_meta("original"); + Ref<InputEvent> original = sc->get_meta("original"); String section_name = E->get().get_slice("/", 0); @@ -170,7 +170,7 @@ void EditorSettingsDialog::_update_shortcuts() { item->set_text(0, sc->get_name()); item->set_text(1, sc->get_as_text()); - if (!sc->is_shortcut(original) && !(sc->get_shortcut().type == InputEvent::NONE && original.type == InputEvent::NONE)) { + if (!sc->is_shortcut(original) && !(sc->get_shortcut().is_null() && original.is_null())) { item->add_button(1, get_icon("Reload", "EditorIcons"), 2); } item->add_button(1, get_icon("Edit", "EditorIcons"), 0); @@ -199,7 +199,7 @@ void EditorSettingsDialog::_shortcut_button_pressed(Object *p_item, int p_column if (p_idx == 0) { press_a_key_label->set_text(TTR("Press a Key..")); - last_wait_for_key = InputEvent(); + last_wait_for_key = Ref<InputEventKey>(); press_a_key->popup_centered(Size2(250, 80) * EDSCALE); press_a_key->grab_focus(); press_a_key->get_ok()->set_focus_mode(FOCUS_NONE); @@ -212,7 +212,7 @@ void EditorSettingsDialog::_shortcut_button_pressed(Object *p_item, int p_column UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); ur->create_action("Erase Shortcut"); - ur->add_do_method(sc.ptr(), "set_shortcut", InputEvent()); + ur->add_do_method(sc.ptr(), "set_shortcut", Ref<InputEvent>()); ur->add_undo_method(sc.ptr(), "set_shortcut", sc->get_shortcut()); ur->add_do_method(this, "_update_shortcuts"); ur->add_undo_method(this, "_update_shortcuts"); @@ -223,7 +223,7 @@ void EditorSettingsDialog::_shortcut_button_pressed(Object *p_item, int p_column if (!sc.is_valid()) return; //pointless, there is nothing - InputEvent original = sc->get_meta("original"); + Ref<InputEvent> original = sc->get_meta("original"); UndoRedo *ur = EditorNode::get_singleton()->get_undo_redo(); ur->create_action("Restore Shortcut"); @@ -237,19 +237,21 @@ void EditorSettingsDialog::_shortcut_button_pressed(Object *p_item, int p_column } } -void EditorSettingsDialog::_wait_for_key(const InputEvent &p_event) { +void EditorSettingsDialog::_wait_for_key(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode != 0) { + Ref<InputEventKey> k = p_event; - last_wait_for_key = p_event; - String str = keycode_get_string(p_event.key.scancode).capitalize(); - if (p_event.key.mod.meta) + if (k.is_valid() && k->is_pressed() && k->get_scancode() != 0) { + + last_wait_for_key = k; + String str = keycode_get_string(k->get_scancode()).capitalize(); + if (k->get_metakey()) str = TTR("Meta+") + str; - if (p_event.key.mod.shift) + if (k->get_shift()) str = TTR("Shift+") + str; - if (p_event.key.mod.alt) + if (k->get_alt()) str = TTR("Alt+") + str; - if (p_event.key.mod.control) + if (k->get_control()) str = TTR("Control+") + str; press_a_key_label->set_text(str); @@ -259,13 +261,16 @@ void EditorSettingsDialog::_wait_for_key(const InputEvent &p_event) { void EditorSettingsDialog::_press_a_key_confirm() { - if (last_wait_for_key.type != InputEvent::KEY) + if (last_wait_for_key.is_null()) 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; + Ref<InputEventKey> ie; + ie.instance(); + ie->set_scancode(last_wait_for_key->get_scancode()); + ie->set_shift(last_wait_for_key->get_shift()); + ie->set_control(last_wait_for_key->get_control()); + ie->set_alt(last_wait_for_key->get_alt()); + ie->set_metakey(last_wait_for_key->get_metakey()); Ref<ShortCut> sc = EditorSettings::get_singleton()->get_shortcut(shortcut_configured); diff --git a/editor/settings_config_dialog.h b/editor/settings_config_dialog.h index 7b6e8862dc..cda191ac36 100644 --- a/editor/settings_config_dialog.h +++ b/editor/settings_config_dialog.h @@ -54,7 +54,7 @@ class EditorSettingsDialog : public AcceptDialog { ConfirmationDialog *press_a_key; Label *press_a_key_label; - InputEvent last_wait_for_key; + Ref<InputEventKey> last_wait_for_key; String shortcut_configured; String shortcut_filter; @@ -68,7 +68,7 @@ class EditorSettingsDialog : public AcceptDialog { void _notification(int p_what); void _press_a_key_confirm(); - void _wait_for_key(const InputEvent &p_event); + void _wait_for_key(const Ref<InputEvent> &p_event); void _clear_shortcut_search_box(); void _clear_search_box(); diff --git a/main/input_default.cpp b/main/input_default.cpp index 8f0b8464eb..2cce62ab51 100644 --- a/main/input_default.cpp +++ b/main/input_default.cpp @@ -115,19 +115,19 @@ bool InputDefault::is_action_pressed(const StringName &p_action) const { case InputEvent::KEY: { const InputEventKey &iek=E->get().key; - if ((keys_pressed.has(iek.scancode))) + if ((keys_pressed.has(iek->get_scancode()))) return true; } break; case InputEvent::MOUSE_BUTTON: { const InputEventMouseButton &iemb=E->get().mouse_button; - if(mouse_button_mask&(1<<iemb.button_index)) + if(mouse_button_mask&(1<<iemb->get_button_index())) return true; } break; case InputEvent::JOYPAD_BUTTON: { const InputEventJoypadButton &iejb=E->get().joy_button; - int c = _combine_device(iejb.button_index,device); + int c = _combine_device(iejb->get_button_index(),device); if (joy_buttons_pressed.has(c)) return true; } break; @@ -297,94 +297,86 @@ Vector3 InputDefault::get_gyroscope() const { return gyroscope; } -void InputDefault::parse_input_event(const InputEvent &p_event) { +void InputDefault::parse_input_event(const Ref<InputEvent> &p_event) { _THREAD_SAFE_METHOD_ - switch (p_event.type) { - - case InputEvent::KEY: { - - if (p_event.key.echo) - break; - if (p_event.key.scancode == 0) - break; - - //print_line(p_event); - - if (p_event.key.pressed) - keys_pressed.insert(p_event.key.scancode); - else - keys_pressed.erase(p_event.key.scancode); - } break; - case InputEvent::MOUSE_BUTTON: { - - if (p_event.mouse_button.doubleclick) - break; - - if (p_event.mouse_button.pressed) - mouse_button_mask |= (1 << p_event.mouse_button.button_index); - else - mouse_button_mask &= ~(1 << p_event.mouse_button.button_index); - - if (main_loop && emulate_touch && p_event.mouse_button.button_index == 1) { - InputEventScreenTouch touch_event; - touch_event.index = 0; - touch_event.pressed = p_event.mouse_button.pressed; - touch_event.x = p_event.mouse_button.x; - touch_event.y = p_event.mouse_button.y; - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch = touch_event; - main_loop->input_event(ev); - } - Point2 pos = Point2(p_event.mouse_button.global_x, p_event.mouse_button.global_y); - if (mouse_pos != pos) { - set_mouse_position(pos); - } - } break; - case InputEvent::MOUSE_MOTION: { - - if (main_loop && emulate_touch && p_event.mouse_motion.button_mask & 1) { - InputEventScreenDrag drag_event; - drag_event.index = 0; - drag_event.x = p_event.mouse_motion.x; - drag_event.y = p_event.mouse_motion.y; - drag_event.relative_x = p_event.mouse_motion.relative_x; - drag_event.relative_y = p_event.mouse_motion.relative_y; - drag_event.speed_x = p_event.mouse_motion.speed_x; - drag_event.speed_y = p_event.mouse_motion.speed_y; - - InputEvent ev; - ev.type = InputEvent::SCREEN_DRAG; - ev.screen_drag = drag_event; - - main_loop->input_event(ev); - } + Ref<InputEventKey> k = p_event; + if (k.is_valid() && k->is_echo() && k->get_scancode() != 0) { + + //print_line(p_event); + + if (k->is_pressed()) + keys_pressed.insert(k->get_scancode()); + else + keys_pressed.erase(k->get_scancode()); + } + + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && !mb->is_doubleclick()) { + + if (mb->is_pressed()) + mouse_button_mask |= (1 << mb->get_button_index()); + else + mouse_button_mask &= ~(1 << mb->get_button_index()); + + if (main_loop && emulate_touch && mb->get_button_index() == 1) { + Ref<InputEventScreenTouch> touch_event; + touch_event.instance(); + touch_event->set_pressed(mb->is_pressed()); + touch_event->set_pos(mb->get_pos()); + main_loop->input_event(touch_event); + } + + Point2 pos = mb->get_global_pos(); + if (mouse_pos != pos) { + set_mouse_position(pos); + } + } + + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { + + if (main_loop && emulate_touch && mm->get_button_mask() & 1) { + Ref<InputEventScreenDrag> drag_event; + drag_event.instance(); - } break; - case InputEvent::JOYPAD_BUTTON: { + drag_event->set_pos(mm->get_pos()); + drag_event->set_relative(mm->get_relative()); + drag_event->set_speed(mm->get_speed()); + + main_loop->input_event(drag_event); + } + } + + Ref<InputEventJoypadButton> jb = p_event; + + if (jb.is_valid()) { + + int c = _combine_device(jb->get_button_index(), jb->get_device()); + + if (jb->is_pressed()) + joy_buttons_pressed.insert(c); + else + joy_buttons_pressed.erase(c); + } - int c = _combine_device(p_event.joy_button.button_index, p_event.device); + Ref<InputEventJoypadMotion> jm = p_event; - if (p_event.joy_button.pressed) - joy_buttons_pressed.insert(c); - else - joy_buttons_pressed.erase(c); - } break; - case InputEvent::JOYPAD_MOTION: { - set_joy_axis(p_event.device, p_event.joy_motion.axis, p_event.joy_motion.axis_value); - } break; + if (jm.is_valid()) { + set_joy_axis(jm->get_device(), jm->get_axis(), jm->get_axis_value()); } - if (!p_event.is_echo()) { + if (p_event->is_echo()) { for (const Map<StringName, InputMap::Action>::Element *E = InputMap::get_singleton()->get_action_map().front(); E; E = E->next()) { - if (InputMap::get_singleton()->event_is_action(p_event, E->key()) && is_action_pressed(E->key()) != p_event.is_pressed()) { + if (InputMap::get_singleton()->event_is_action(p_event, E->key()) && is_action_pressed(E->key()) != p_event->is_pressed()) { Action action; action.fixed_frame = Engine::get_singleton()->get_fixed_frames(); action.idle_frame = Engine::get_singleton()->get_idle_frames(); - action.pressed = p_event.is_pressed(); + action.pressed = p_event->is_pressed(); action_state[E->key()] = action; } } @@ -484,7 +476,7 @@ void InputDefault::warp_mouse_pos(const Vector2 &p_to) { OS::get_singleton()->warp_mouse_pos(p_to); } -Point2i InputDefault::warp_mouse_motion(const InputEventMouseMotion &p_motion, const Rect2 &p_rect) { +Point2i InputDefault::warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect) { // The relative distance reported for the next event after a warp is in the boundaries of the // size of the rect on that axis, but it may be greater, in which case there's not problem as fmod() @@ -495,13 +487,13 @@ Point2i InputDefault::warp_mouse_motion(const InputEventMouseMotion &p_motion, c // detect the warp: if the relative distance is greater than the half of the size of the relevant rect // (checked per each axis), it will be considered as the consequence of a former pointer warp. - const Point2i rel_sgn(p_motion.relative_x >= 0.0f ? 1 : -1, p_motion.relative_y >= 0.0 ? 1 : -1); + const Point2i rel_sgn(p_motion->get_relative().x >= 0.0f ? 1 : -1, p_motion->get_relative().y >= 0.0 ? 1 : -1); const Size2i warp_margin = p_rect.size * 0.5f; const Point2i rel_warped( - Math::fmod(p_motion.relative_x + rel_sgn.x * warp_margin.x, p_rect.size.x) - rel_sgn.x * warp_margin.x, - Math::fmod(p_motion.relative_y + rel_sgn.y * warp_margin.y, p_rect.size.y) - rel_sgn.y * warp_margin.y); + Math::fmod(p_motion->get_relative().x + rel_sgn.x * warp_margin.x, p_rect.size.x) - rel_sgn.x * warp_margin.x, + Math::fmod(p_motion->get_relative().y + rel_sgn.y * warp_margin.y, p_rect.size.y) - rel_sgn.y * warp_margin.y); - const Point2i pos_local = Point2i(p_motion.global_x, p_motion.global_y) - p_rect.pos; + const Point2i pos_local = p_motion->get_global_pos() - p_rect.pos; const Point2i pos_warped(Math::fposmod(pos_local.x, p_rect.size.x), Math::fposmod(pos_local.y, p_rect.size.y)); if (pos_warped != pos_local) { OS::get_singleton()->warp_mouse_pos(pos_warped + p_rect.pos); @@ -1020,22 +1012,22 @@ void InputDefault::joy_hat(int p_device, int p_val) { void InputDefault::_button_event(int p_device, int p_index, bool p_pressed) { - InputEvent ievent; - ievent.type = InputEvent::JOYPAD_BUTTON; - ievent.device = p_device; - ievent.joy_button.button_index = p_index; - ievent.joy_button.pressed = p_pressed; + Ref<InputEventJoypadButton> ievent; + ievent.instance(); + ievent->set_device(p_device); + ievent->set_button_index(p_index); + ievent->set_pressed(p_pressed); parse_input_event(ievent); }; void InputDefault::_axis_event(int p_device, int p_axis, float p_value) { - InputEvent ievent; - ievent.type = InputEvent::JOYPAD_MOTION; - ievent.device = p_device; - ievent.joy_motion.axis = p_axis; - ievent.joy_motion.axis_value = p_value; + Ref<InputEventJoypadMotion> ievent; + ievent.instance(); + ievent->set_device(p_device); + ievent->set_axis(p_axis); + ievent->set_axis_value(p_value); parse_input_event(ievent); }; diff --git a/main/input_default.h b/main/input_default.h index 55b7555ef9..35e841a488 100644 --- a/main/input_default.h +++ b/main/input_default.h @@ -201,9 +201,9 @@ public: virtual int get_mouse_button_mask() const; virtual void warp_mouse_pos(const Vector2 &p_to); - virtual Point2i warp_mouse_motion(const InputEventMouseMotion &p_motion, const Rect2 &p_rect); + virtual Point2i warp_mouse_motion(const Ref<InputEventMouseMotion> &p_motion, const Rect2 &p_rect); - virtual void parse_input_event(const InputEvent &p_event); + virtual void parse_input_event(const Ref<InputEvent> &p_event); void set_gravity(const Vector3 &p_gravity); void set_accelerometer(const Vector3 &p_accel); diff --git a/main/tests/test_image.cpp b/main/tests/test_image.cpp index c2c742e75d..0b120f87d5 100644 --- a/main/tests/test_image.cpp +++ b/main/tests/test_image.cpp @@ -41,7 +41,7 @@ class TestMainLoop : public MainLoop { bool quit; public: - virtual void input_event(const InputEvent &p_event) { + virtual void input_event(const Ref<InputEvent> &p_event) { } virtual void init() { diff --git a/main/tests/test_physics.cpp b/main/tests/test_physics.cpp index d32756937a..5a233e818e 100644 --- a/main/tests/test_physics.cpp +++ b/main/tests/test_physics.cpp @@ -263,18 +263,19 @@ protected: } public: - virtual void input_event(const InputEvent &p_event) { + virtual void input_event(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask & 4) { + Ref<InputEventMouseMotion> mm = p_event; + if (mm.is_valid() && mm->get_button_mask() & 4) { - ofs_y -= p_event.mouse_motion.relative_y / 200.0; - ofs_x += p_event.mouse_motion.relative_x / 200.0; + ofs_y -= mm->get_relative().y / 200.0; + ofs_x += mm->get_relative().x / 200.0; } - if (p_event.type == InputEvent::MOUSE_MOTION && p_event.mouse_motion.button_mask & 1) { + if (mm.is_valid() && mm->get_button_mask() & 1) { - float y = -p_event.mouse_motion.relative_y / 20.0; - float x = p_event.mouse_motion.relative_x / 20.0; + float y = -mm->get_relative().y / 20.0; + float x = mm->get_relative().x / 20.0; if (mover.is_valid()) { @@ -285,19 +286,6 @@ public: ps->body_set_state(mover, PhysicsServer::BODY_STATE_TRANSFORM, t); } } - - if (p_event.type == InputEvent::JOYPAD_MOTION) { - - if (p_event.joy_motion.axis == 0) { - - joy_direction.x = p_event.joy_motion.axis_value; - }; - - if (p_event.joy_motion.axis == 1) { - - joy_direction.y = p_event.joy_motion.axis_value; - }; - }; } virtual void request_quit() { diff --git a/main/tests/test_physics_2d.cpp b/main/tests/test_physics_2d.cpp index d8a00a589a..5f57275503 100644 --- a/main/tests/test_physics_2d.cpp +++ b/main/tests/test_physics_2d.cpp @@ -208,35 +208,36 @@ class TestPhysics2DMainLoop : public MainLoop { } protected: - void input_event(const InputEvent &p_event) { + void input_event(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_event; - const InputEventMouseButton &mb = p_event.mouse_button; + if (mb.is_valid()) { - if (mb.pressed) { + if (mb->is_pressed()) { - Point2 p(mb.x, mb.y); + Point2 p(mb->get_pos().x, mb->get_pos().y); - if (mb.button_index == 1) { + if (mb->get_button_index() == 1) { ray_to = p; _do_ray_query(); - } else if (mb.button_index == 2) { + } else if (mb->get_button_index() == 2) { ray_from = p; _do_ray_query(); } } } - if (p_event.type == InputEvent::MOUSE_MOTION) { - const InputEventMouseMotion &mm = p_event.mouse_motion; + Ref<InputEventMouseMotion> mm = p_event; - Point2 p(mm.x, mm.y); + if (mm.is_valid()) { - if (mm.button_mask & BUTTON_MASK_LEFT) { + Point2 p = mm->get_pos(); + + if (mm->get_button_mask() & BUTTON_MASK_LEFT) { ray_to = p; _do_ray_query(); - } else if (mm.button_mask & BUTTON_MASK_RIGHT) { + } else if (mm->get_button_mask() & BUTTON_MASK_RIGHT) { ray_from = p; _do_ray_query(); } diff --git a/main/tests/test_render.cpp b/main/tests/test_render.cpp index 89bd5db60f..74f7453d1b 100644 --- a/main/tests/test_render.cpp +++ b/main/tests/test_render.cpp @@ -64,9 +64,9 @@ class TestMainLoop : public MainLoop { protected: public: - virtual void input_event(const InputEvent &p_event) { + virtual void input_event(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed) + if (p_event->is_pressed()) quit = true; } diff --git a/modules/gdscript/gd_editor.cpp b/modules/gdscript/gd_editor.cpp index 7d5ba08d6c..eea5b15236 100644 --- a/modules/gdscript/gd_editor.cpp +++ b/modules/gdscript/gd_editor.cpp @@ -1321,7 +1321,7 @@ static void _find_identifiers(GDCompletionContext &context, int p_line, bool p_o static const char *_type_names[Variant::VARIANT_MAX] = { "null", "bool", "int", "float", "String", "Vector2", "Rect2", "Vector3", "Transform2D", "Plane", "Quat", "AABB", "Basis", "Transform", - "Color", "NodePath", "RID", "Object", "InputEvent", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", + "Color", "NodePath", "RID", "Object", "Dictionary", "Array", "RawArray", "IntArray", "FloatArray", "StringArray", "Vector2Array", "Vector3Array", "ColorArray" }; @@ -1425,22 +1425,7 @@ void get_directory_contents(EditorFileSystemDirectory *p_dir, Set<String> &r_lis static void _find_type_arguments(GDCompletionContext &context, const GDParser::Node *p_node, int p_line, const StringName &p_method, const GDCompletionIdentifier &id, int p_argidx, Set<String> &result, String &arghint) { //print_line("find type arguments?"); - if (id.type == Variant::INPUT_EVENT && String(p_method) == "is_action" && p_argidx == 0) { - - List<PropertyInfo> pinfo; - GlobalConfig::get_singleton()->get_property_list(&pinfo); - - for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) { - const PropertyInfo &pi = E->get(); - - if (!pi.name.begins_with("input/")) - continue; - - String name = pi.name.substr(pi.name.find("/") + 1, pi.name.length()); - result.insert("\"" + name + "\""); - } - - } else if (id.type == Variant::OBJECT && id.obj_type != StringName()) { + if (id.type == Variant::OBJECT && id.obj_type != StringName()) { MethodBind *m = ClassDB::get_method(id.obj_type, p_method); if (!m) { @@ -2266,54 +2251,8 @@ Error GDScriptLanguage::complete_code(const String &p_code, const String &p_base } } else { - if (t.type == Variant::INPUT_EVENT) { - - //this is hardcoded otherwise it's not obvious - Set<String> exclude; - - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - - InputEvent ie; - ie.type = InputEvent::Type(i); - static const char *evnames[] = { - "# Common", - "# Key", - "# MouseMotion", - "# MouseButton", - "# JoypadMotion", - "# JoypadButton", - "# ScreenTouch", - "# ScreenDrag", - "# Action" - }; - - r_options->push_back(evnames[i]); - - Variant v = ie; - - if (i == 0) { - List<MethodInfo> mi; - v.get_method_list(&mi); - for (List<MethodInfo>::Element *E = mi.front(); E; E = E->next()) { - r_options->push_back(E->get().name + "("); - } - } - - List<PropertyInfo> pi; - v.get_property_list(&pi); - - for (List<PropertyInfo>::Element *E = pi.front(); E; E = E->next()) { - - if (i == 0) - exclude.insert(E->get().name); - else if (exclude.has(E->get().name)) - continue; - - r_options->push_back(E->get().name); - } - } - return OK; - } else { + //check InputEvent hint + { if (t.value.get_type() == Variant::NIL) { Variant::CallError ce; t.value = Variant::construct(t.type, NULL, 0, ce); diff --git a/modules/gdscript/gd_tokenizer.cpp b/modules/gdscript/gd_tokenizer.cpp index c26ba03a64..5e1a48ae86 100644 --- a/modules/gdscript/gd_tokenizer.cpp +++ b/modules/gdscript/gd_tokenizer.cpp @@ -802,7 +802,6 @@ void GDTokenizerText::_advance() { { Variant::COLOR, "Color" }, { Variant::_RID, "RID" }, { Variant::OBJECT, "Object" }, - { Variant::INPUT_EVENT, "InputEvent" }, { Variant::NODE_PATH, "NodePath" }, { Variant::DICTIONARY, "Dictionary" }, { Variant::ARRAY, "Array" }, diff --git a/modules/gridmap/grid_map_editor_plugin.cpp b/modules/gridmap/grid_map_editor_plugin.cpp index d8993710a4..e567e08c79 100644 --- a/modules/gridmap/grid_map_editor_plugin.cpp +++ b/modules/gridmap/grid_map_editor_plugin.cpp @@ -508,146 +508,150 @@ void GridMapEditor::_duplicate_paste() { } } -bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) { +bool GridMapEditor::forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event) { if (!node) { return false; } if (edit_mode->get_selected() == 0) { // regular click - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { - if (p_event.mouse_button.button_index == BUTTON_WHEEL_UP && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { - if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() + p_event.mouse_button.factor); + Ref<InputEventMouseButton> mb = p_event; - return true; //eaten - } else if (p_event.mouse_button.button_index == BUTTON_WHEEL_DOWN && (p_event.mouse_button.mod.command || p_event.mouse_button.mod.shift)) { - if (p_event.mouse_button.pressed) - floor->set_value(floor->get_value() - p_event.mouse_button.factor); - return true; - } + if (mb.is_valid()) { - if (p_event.mouse_button.pressed) { + if (mb->get_button_index() == BUTTON_WHEEL_UP && (mb->get_command() || mb->get_shift())) { + if (mb->is_pressed()) + floor->set_value(floor->get_value() + mb->get_factor()); - if (p_event.mouse_button.button_index == BUTTON_LEFT) { + return true; //eaten + } else if (mb->get_button_index() == BUTTON_WHEEL_DOWN && (mb->get_command() || mb->get_shift())) { + if (mb->is_pressed()) + floor->set_value(floor->get_value() - mb->get_factor()); + return true; + } - if (input_action == INPUT_DUPLICATE) { + if (mb->is_pressed()) { - //paste - _duplicate_paste(); - input_action = INPUT_NONE; - _update_duplicate_indicator(); - } else if (p_event.mouse_button.mod.shift) { - input_action = INPUT_SELECT; - } else if (p_event.mouse_button.mod.command) - input_action = INPUT_COPY; - else { - input_action = INPUT_PAINT; - set_items.clear(); - } - } else if (p_event.mouse_button.button_index == BUTTON_RIGHT) - if (input_action == INPUT_DUPLICATE) { - - input_action = INPUT_NONE; - _update_duplicate_indicator(); - } else { - input_action = INPUT_ERASE; - set_items.clear(); - } - else - return false; + if (mb->get_button_index() == BUTTON_LEFT) { - return do_input_action(p_camera, Point2(p_event.mouse_button.x, p_event.mouse_button.y), true); - } else { + if (input_action == INPUT_DUPLICATE) { - if ( - (p_event.mouse_button.button_index == BUTTON_RIGHT && input_action == INPUT_ERASE) || - (p_event.mouse_button.button_index == BUTTON_LEFT && input_action == INPUT_PAINT)) { + //paste + _duplicate_paste(); + input_action = INPUT_NONE; + _update_duplicate_indicator(); + } else if (mb->get_shift()) { + input_action = INPUT_SELECT; + } else if (mb->get_command()) + input_action = INPUT_COPY; + else { + input_action = INPUT_PAINT; + set_items.clear(); + } + } else if (mb->get_button_index() == BUTTON_RIGHT) + if (input_action == INPUT_DUPLICATE) { - if (set_items.size()) { - undo_redo->create_action("GridMap Paint"); - for (List<SetItem>::Element *E = set_items.front(); E; E = E->next()) { + input_action = INPUT_NONE; + _update_duplicate_indicator(); + } else { + input_action = INPUT_ERASE; + set_items.clear(); + } + else + return false; + + return do_input_action(p_camera, Point2(mb->get_pos().x, mb->get_pos().y), true); + } else { - const SetItem &si = E->get(); - undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation); - } - for (List<SetItem>::Element *E = set_items.back(); E; E = E->prev()) { + if ( + (mb->get_button_index() == BUTTON_RIGHT && input_action == INPUT_ERASE) || + (mb->get_button_index() == BUTTON_LEFT && input_action == INPUT_PAINT)) { - const SetItem &si = E->get(); - undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation); - } + if (set_items.size()) { + undo_redo->create_action("GridMap Paint"); + for (List<SetItem>::Element *E = set_items.front(); E; E = E->next()) { - undo_redo->commit_action(); + const SetItem &si = E->get(); + undo_redo->add_do_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.new_value, si.new_orientation); } - set_items.clear(); - input_action = INPUT_NONE; - return true; - } + for (List<SetItem>::Element *E = set_items.back(); E; E = E->prev()) { - if (p_event.mouse_button.button_index == BUTTON_LEFT && input_action != INPUT_NONE) { + const SetItem &si = E->get(); + undo_redo->add_undo_method(node, "set_cell_item", si.pos.x, si.pos.y, si.pos.z, si.old_value, si.old_orientation); + } - set_items.clear(); - input_action = INPUT_NONE; - return true; - } - if (p_event.mouse_button.button_index == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_DUPLICATE)) { - input_action = INPUT_NONE; - return true; + undo_redo->commit_action(); } + set_items.clear(); + input_action = INPUT_NONE; + return true; + } + + if (mb->get_button_index() == BUTTON_LEFT && input_action != INPUT_NONE) { + + set_items.clear(); + input_action = INPUT_NONE; + return true; + } + if (mb->get_button_index() == BUTTON_RIGHT && (input_action == INPUT_ERASE || input_action == INPUT_DUPLICATE)) { + input_action = INPUT_NONE; + return true; } - } break; - case InputEvent::MOUSE_MOTION: { + } + } + + Ref<InputEventMouseMotion> mm = p_event; - return do_input_action(p_camera, Point2(p_event.mouse_motion.x, p_event.mouse_motion.y), false); - } break; + if (mm.is_valid()) { + + return do_input_action(p_camera, mm->get_pos(), false); } } else if (edit_mode->get_selected() == 1) { //area mode, select an area - switch (p_event.type) { - case InputEvent::MOUSE_BUTTON: { + Ref<InputEventMouseButton> mb = p_event; - if (p_event.mouse_button.button_index == BUTTON_LEFT && p_event.mouse_button.pressed) { + if (mb.is_valid()) { - Point2 point = Point2(p_event.mouse_motion.x, p_event.mouse_motion.y); + if (mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { - Camera *camera = p_camera; - Vector3 from = camera->project_ray_origin(point); - Vector3 normal = camera->project_ray_normal(point); - Transform local_xform = node->get_global_transform().affine_inverse(); - from = local_xform.xform(from); - normal = local_xform.basis.xform(normal).normalized(); + Point2 point = mb->get_pos(); - List<int> areas; - node->get_area_list(&areas); + Camera *camera = p_camera; + Vector3 from = camera->project_ray_origin(point); + Vector3 normal = camera->project_ray_normal(point); + Transform local_xform = node->get_global_transform().affine_inverse(); + from = local_xform.xform(from); + normal = local_xform.basis.xform(normal).normalized(); - float min_d = 1e10; - int min_area = -1; + List<int> areas; + node->get_area_list(&areas); - for (List<int>::Element *E = areas.front(); E; E = E->next()) { + float min_d = 1e10; + int min_area = -1; - int area = E->get(); - Rect3 aabb = node->area_get_bounds(area); - aabb.pos *= node->get_cell_size(); - aabb.size *= node->get_cell_size(); + for (List<int>::Element *E = areas.front(); E; E = E->next()) { - Vector3 rclip, rnormal; - if (!aabb.intersects_segment(from, from + normal * 10000, &rclip, &rnormal)) - continue; + int area = E->get(); + Rect3 aabb = node->area_get_bounds(area); + aabb.pos *= node->get_cell_size(); + aabb.size *= node->get_cell_size(); - float d = normal.dot(rclip); - if (d < min_d) { - min_d = d; - min_area = area; - } - } + Vector3 rclip, rnormal; + if (!aabb.intersects_segment(from, from + normal * 10000, &rclip, &rnormal)) + continue; - selected_area = min_area; - update_areas(); + float d = normal.dot(rclip); + if (d < min_d) { + min_d = d; + min_area = area; + } } - } break; + + selected_area = min_area; + update_areas(); + } } } diff --git a/modules/gridmap/grid_map_editor_plugin.h b/modules/gridmap/grid_map_editor_plugin.h index d928e6afac..1572f4fbe5 100644 --- a/modules/gridmap/grid_map_editor_plugin.h +++ b/modules/gridmap/grid_map_editor_plugin.h @@ -220,7 +220,7 @@ protected: static void _bind_methods(); public: - bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event); + bool forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event); void edit(GridMap *p_gridmap); GridMapEditor() {} @@ -236,7 +236,7 @@ class GridMapEditorPlugin : public EditorPlugin { EditorNode *editor; public: - virtual bool forward_spatial_input_event(Camera *p_camera, const InputEvent &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); } + virtual bool forward_spatial_input_event(Camera *p_camera, const Ref<InputEvent> &p_event) { return gridmap_editor->forward_spatial_input_event(p_camera, p_event); } virtual String get_name() const { return "GridMap"; } bool has_main_screen() const { return false; } virtual void edit(Object *p_node); diff --git a/modules/visual_script/register_types.cpp b/modules/visual_script/register_types.cpp index 4006ad3428..c0467a901b 100644 --- a/modules/visual_script/register_types.cpp +++ b/modules/visual_script/register_types.cpp @@ -88,7 +88,7 @@ void register_visual_script_types() { ClassDB::register_class<VisualScriptWhile>(); ClassDB::register_class<VisualScriptIterator>(); ClassDB::register_class<VisualScriptSequence>(); - ClassDB::register_class<VisualScriptInputFilter>(); + //ClassDB::register_class<VisualScriptInputFilter>(); ClassDB::register_class<VisualScriptSwitch>(); ClassDB::register_class<VisualScriptYield>(); diff --git a/modules/visual_script/visual_script.h b/modules/visual_script/visual_script.h index 273a819611..72843099c7 100644 --- a/modules/visual_script/visual_script.h +++ b/modules/visual_script/visual_script.h @@ -89,13 +89,11 @@ public: struct TypeGuess { Variant::Type type; - InputEvent::Type ev_type; StringName GDCLASS; Ref<Script> script; TypeGuess() { type = Variant::NIL; - ev_type = InputEvent::NONE; } }; diff --git a/modules/visual_script/visual_script_editor.cpp b/modules/visual_script/visual_script_editor.cpp index 9c77a2ce5e..5839bc9243 100644 --- a/modules/visual_script/visual_script_editor.cpp +++ b/modules/visual_script/visual_script_editor.cpp @@ -349,7 +349,6 @@ static Color _color_from_type(Variant::Type p_type) { case Variant::NODE_PATH: color = Color::html("6993ec"); break; case Variant::_RID: color = Color::html("69ec9a"); break; case Variant::OBJECT: color = Color::html("79f3e8"); break; - case Variant::INPUT_EVENT: color = Color::html("adf18f"); break; case Variant::DICTIONARY: color = Color::html("77edb1"); break; case Variant::ARRAY: color = Color::html("e0e0e0"); break; @@ -453,7 +452,6 @@ void VisualScriptEditor::_update_graph(int p_only_id) { Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), - Control::get_icon("MiniInput", "EditorIcons"), Control::get_icon("MiniDictionary", "EditorIcons"), Control::get_icon("MiniArray", "EditorIcons"), Control::get_icon("MiniRawArray", "EditorIcons"), @@ -736,7 +734,6 @@ void VisualScriptEditor::_update_members() { Control::get_icon("MiniPath", "EditorIcons"), Control::get_icon("MiniRid", "EditorIcons"), Control::get_icon("MiniObject", "EditorIcons"), - Control::get_icon("MiniInput", "EditorIcons"), Control::get_icon("MiniDictionary", "EditorIcons"), Control::get_icon("MiniArray", "EditorIcons"), Control::get_icon("MiniRawArray", "EditorIcons"), @@ -1419,9 +1416,11 @@ void VisualScriptEditor::_on_nodes_duplicate() { } } -void VisualScriptEditor::_input(const InputEvent &p_event) { +void VisualScriptEditor::_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; + + if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { revert_on_drag = String(); //so we can still drag functions } } @@ -2640,7 +2639,7 @@ void VisualScriptEditor::_port_action_menu(int p_option) { } else { n->set_call_mode(VisualScriptPropertySet::CALL_MODE_BASIC_TYPE); n->set_basic_type(tg.type); - new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type); + new_connect_node_select->select_property_from_basic_type(tg.type); } } break; case CREATE_GET: { @@ -2670,7 +2669,7 @@ void VisualScriptEditor::_port_action_menu(int p_option) { } else { n->set_call_mode(VisualScriptPropertyGet::CALL_MODE_BASIC_TYPE); n->set_basic_type(tg.type); - new_connect_node_select->select_property_from_basic_type(tg.type, tg.ev_type); + new_connect_node_select->select_property_from_basic_type(tg.type); } } break; diff --git a/modules/visual_script/visual_script_editor.h b/modules/visual_script/visual_script_editor.h index 1fd97cc1bc..bb832431a0 100644 --- a/modules/visual_script/visual_script_editor.h +++ b/modules/visual_script/visual_script_editor.h @@ -196,7 +196,7 @@ class VisualScriptEditor : public ScriptEditorBase { String revert_on_drag; - void _input(const InputEvent &p_event); + void _input(const Ref<InputEvent> &p_event); void _on_nodes_delete(); void _on_nodes_duplicate(); diff --git a/modules/visual_script/visual_script_flow_control.cpp b/modules/visual_script/visual_script_flow_control.cpp index 2deb6064d3..07d69db207 100644 --- a/modules/visual_script/visual_script_flow_control.cpp +++ b/modules/visual_script/visual_script_flow_control.cpp @@ -734,6 +734,7 @@ VisualScriptSwitch::VisualScriptSwitch() { ////////////////EVENT ACTION FILTER/////////// ////////////////////////////////////////// +#if 0 int VisualScriptInputFilter::get_output_sequence_port_count() const { return filters.size(); @@ -758,86 +759,86 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const String text; switch (filters[p_port].type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { text = "None"; } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { InputEventKey k = filters[p_port].key; - if (k.scancode == 0 && k.unicode == 0) { + if (k->get_scancode() == 0 && k.unicode == 0) { text = "No Key"; } else { - if (k.scancode != 0) { - text = "KeyCode: " + keycode_get_string(k.scancode); + if (k->get_scancode() != 0) { + text = "KeyCode: " + keycode_get_string(k->get_scancode()); } else if (k.unicode != 0) { text = "Uniode: " + String::chr(k.unicode); } - if (k.pressed) + if (k->is_pressed()) text += ", Pressed"; else text += ", Released"; if (k.echo) text += ", Echo"; - if (k.mod.alt) + if (k->get_alt()) text = "Alt+" + text; - if (k.mod.shift) + if (k->get_shift()) text = "Shift+" + text; - if (k.mod.control) + if (k->get_control()) text = "Ctrl+" + text; - if (k.mod.meta) + if (k->get_metakey()) text = "Meta+" + text; } } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { InputEventMouseMotion mm = filters[p_port].mouse_motion; text = "Mouse Motion"; String b = "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"; for (int i = 0; i < 7; i++) { - if (mm.button_mask & (1 << i)) { + if (mm->get_button_mask() & (1 << i)) { text = b.get_slice(",", i) + "+" + text; } } - if (mm.mod.alt) + if (mm->get_alt()) text = "Alt+" + text; - if (mm.mod.shift) + if (mm->get_shift()) text = "Shift+" + text; - if (mm.mod.control) + if (mm->get_control()) text = "Ctrl+" + text; - if (mm.mod.meta) + if (mm->get_metakey()) text = "Meta+" + text; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { InputEventMouseButton mb = filters[p_port].mouse_button; String b = "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight"; - text = b.get_slice(",", mb.button_index) + " Mouse Button"; + text = b.get_slice(",", mb->get_button_index()) + " Mouse Button"; - if (mb.pressed) + if (mb->is_pressed()) text += ", Pressed"; else text += ", Released"; if (mb.doubleclick) text += ", DblClick"; - if (mb.mod.alt) + if (mb->get_alt()) text = "Alt+" + text; - if (mb.mod.shift) + if (mb->get_shift()) text = "Shift+" + text; - if (mb.mod.control) + if (mb->get_control()) text = "Ctrl+" + text; - if (mb.mod.meta) + if (mb->get_metakey()) text = "Meta+" + text; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { InputEventJoypadMotion jm = filters[p_port].joy_motion; @@ -848,29 +849,29 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const text += " < " + rtos(-jm.axis_value); } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { InputEventJoypadButton jb = filters[p_port].joy_button; - text = "JoyButton " + itos(jb.button_index); - if (jb.pressed) + text = "JoyButton " + itos(jb->get_button_index()); + if (jb->is_pressed()) text += ", Pressed"; else text += ", Released"; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { InputEventScreenTouch sd = filters[p_port].screen_touch; text = "Touch Finger " + itos(sd.index); - if (sd.pressed) + if (sd->is_pressed()) text += ", Pressed"; else text += ", Released"; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { InputEventScreenDrag sd = filters[p_port].screen_drag; text = "Drag Finger " + itos(sd.index); } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { List<PropertyInfo> pinfo; GlobalConfig::get_singleton()->get_property_list(&pinfo); @@ -890,7 +891,7 @@ String VisualScriptInputFilter::get_output_sequence_port_text(int p_port) const index++; } - if (filters[p_port].action.pressed) + if (filters[p_port].action->is_pressed()) text += ", Pressed"; else text += ", Released"; @@ -939,20 +940,20 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va String what = String(p_name).get_slice("/", 1); if (what == "type") { - filters[idx] = InputEvent(); - filters[idx].type = InputEvent::Type(int(p_value)); - if (filters[idx].type == InputEvent::JOYPAD_MOTION) { + filters[idx] = Ref<InputEvent>(); + filters[idx].type = Ref<InputEvent>::Type(int(p_value)); + if (filters[idx].type == Ref<InputEvent>::JOYPAD_MOTION) { filters[idx].joy_motion.axis_value = 0.5; //for treshold - } else if (filters[idx].type == InputEvent::KEY) { - filters[idx].key.pressed = true; //put these as true to make it more user friendly - } else if (filters[idx].type == InputEvent::MOUSE_BUTTON) { - filters[idx].mouse_button.pressed = true; - } else if (filters[idx].type == InputEvent::JOYPAD_BUTTON) { - filters[idx].joy_button.pressed = true; - } else if (filters[idx].type == InputEvent::SCREEN_TOUCH) { - filters[idx].screen_touch.pressed = true; - } else if (filters[idx].type == InputEvent::ACTION) { - filters[idx].action.pressed = true; + } else if (filters[idx].type == Ref<InputEvent>::KEY) { + filters[idx]->is_pressed() = true; //put these as true to make it more user friendly + } else if (filters[idx].type == Ref<InputEvent>::MOUSE_BUTTON) { + filters[idx]->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::JOYPAD_BUTTON) { + filters[idx].joy_button->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::SCREEN_TOUCH) { + filters[idx].screen_touch->is_pressed() = true; + } else if (filters[idx].type == Ref<InputEvent>::ACTION) { + filters[idx].action->is_pressed() = true; } _change_notify(); ports_changed_notify(); @@ -967,14 +968,14 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va switch (filters[idx].type) { - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (what == "scancode") { String sc = p_value; if (sc == String()) { - filters[idx].key.scancode = 0; + filters[idx]->get_scancode() = 0; } else { - filters[idx].key.scancode = find_keycode(p_value); + filters[idx]->get_scancode() = find_keycode(p_value); } } else if (what == "unicode") { @@ -989,22 +990,22 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va } else if (what == "pressed") { - filters[idx].key.pressed = p_value; + filters[idx]->is_pressed() = p_value; } else if (what == "echo") { - filters[idx].key.echo = p_value; + filters[idx]->is_echo() = p_value; } else if (what == "mod_alt") { - filters[idx].key.mod.alt = p_value; + filters[idx]->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].key.mod.shift = p_value; + filters[idx]->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].key.mod.control = p_value; + filters[idx]->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].key.mod.meta = p_value; + filters[idx]->get_metakey() = p_value; } else { return false; } @@ -1012,22 +1013,22 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { if (what == "button_mask") { - filters[idx].mouse_motion.button_mask = p_value; + filters[idx]->get_button_mask() = p_value; } else if (what == "mod_alt") { - filters[idx].mouse_motion.mod.alt = p_value; + filters[idx].mouse_motion->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].mouse_motion.mod.shift = p_value; + filters[idx].mouse_motion->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].mouse_motion.mod.control = p_value; + filters[idx].mouse_motion->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].mouse_motion.mod.meta = p_value; + filters[idx].mouse_motion->get_metakey() = p_value; } else { return false; } @@ -1036,26 +1037,26 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { if (what == "button_index") { - filters[idx].mouse_button.button_index = p_value; + filters[idx]->get_button_index() = p_value; } else if (what == "pressed") { - filters[idx].mouse_button.pressed = p_value; + filters[idx]->is_pressed() = p_value; } else if (what == "doubleclicked") { filters[idx].mouse_button.doubleclick = p_value; } else if (what == "mod_alt") { - filters[idx].mouse_button.mod.alt = p_value; + filters[idx].mouse_button->get_alt() = p_value; } else if (what == "mod_shift") { - filters[idx].mouse_button.mod.shift = p_value; + filters[idx].mouse_button->get_shift() = p_value; } else if (what == "mod_ctrl") { - filters[idx].mouse_button.mod.control = p_value; + filters[idx].mouse_button->get_control() = p_value; } else if (what == "mod_meta") { - filters[idx].mouse_button.mod.meta = p_value; + filters[idx].mouse_button->get_metakey() = p_value; } else { return false; } @@ -1063,7 +1064,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { if (what == "axis") { filters[idx].joy_motion.axis = int(p_value) << 1 | filters[idx].joy_motion.axis; @@ -1078,12 +1079,12 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { if (what == "button_index") { - filters[idx].joy_button.button_index = p_value; + filters[idx].joy_button->get_button_index() = p_value; } else if (what == "pressed") { - filters[idx].joy_button.pressed = p_value; + filters[idx].joy_button->is_pressed() = p_value; } else { return false; } @@ -1091,19 +1092,19 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va return true; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { if (what == "finger_index") { filters[idx].screen_touch.index = p_value; } else if (what == "pressed") { - filters[idx].screen_touch.pressed = p_value; + filters[idx].screen_touch->is_pressed() = p_value; } else { return false; } ports_changed_notify(); return true; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { if (what == "finger_index") { filters[idx].screen_drag.index = p_value; } else { @@ -1112,7 +1113,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va ports_changed_notify(); return true; } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (what == "action_name") { @@ -1144,7 +1145,7 @@ bool VisualScriptInputFilter::_set(const StringName &p_name, const Variant &p_va } else if (what == "pressed") { - filters[idx].action.pressed = p_value; + filters[idx].action->is_pressed() = p_value; ports_changed_notify(); return true; } @@ -1181,14 +1182,14 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con switch (filters[idx].type) { - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (what == "scancode") { - if (filters[idx].key.scancode == 0) + if (filters[idx]->get_scancode() == 0) r_ret = String(); else { - r_ret = keycode_get_string(filters[idx].key.scancode); + r_ret = keycode_get_string(filters[idx]->get_scancode()); } } else if (what == "unicode") { @@ -1202,44 +1203,44 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } else if (what == "pressed") { - r_ret = filters[idx].key.pressed; + r_ret = filters[idx]->is_pressed(); } else if (what == "echo") { - r_ret = filters[idx].key.echo; + r_ret = filters[idx]->is_echo(); } else if (what == "mod_alt") { - r_ret = filters[idx].key.mod.alt; + r_ret = filters[idx]->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].key.mod.shift; + r_ret = filters[idx]->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].key.mod.control; + r_ret = filters[idx]->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].key.mod.meta; + r_ret = filters[idx]->get_metakey(); } else { return false; } return true; } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { if (what == "button_mask") { - r_ret = filters[idx].mouse_motion.button_mask; + r_ret = filters[idx]->get_button_mask(); } else if (what == "mod_alt") { - r_ret = filters[idx].mouse_motion.mod.alt; + r_ret = filters[idx].mouse_motion->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].mouse_motion.mod.shift; + r_ret = filters[idx].mouse_motion->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].mouse_motion.mod.control; + r_ret = filters[idx].mouse_motion->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].mouse_motion.mod.meta; + r_ret = filters[idx].mouse_motion->get_metakey(); } else { return false; } @@ -1247,33 +1248,33 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return true; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { if (what == "button_index") { - r_ret = filters[idx].mouse_button.button_index; + r_ret = filters[idx]->get_button_index(); } else if (what == "pressed") { - r_ret = filters[idx].mouse_button.pressed; + r_ret = filters[idx]->is_pressed(); } else if (what == "doubleclicked") { r_ret = filters[idx].mouse_button.doubleclick; } else if (what == "mod_alt") { - r_ret = filters[idx].mouse_button.mod.alt; + r_ret = filters[idx].mouse_button->get_alt(); } else if (what == "mod_shift") { - r_ret = filters[idx].mouse_button.mod.shift; + r_ret = filters[idx].mouse_button->get_shift(); } else if (what == "mod_ctrl") { - r_ret = filters[idx].mouse_button.mod.control; + r_ret = filters[idx].mouse_button->get_control(); } else if (what == "mod_meta") { - r_ret = filters[idx].mouse_button.mod.meta; + r_ret = filters[idx].mouse_button->get_metakey(); } else { return false; } return true; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { if (what == "axis_index") { r_ret = filters[idx].joy_motion.axis >> 1; @@ -1287,30 +1288,30 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return true; } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { if (what == "button_index") { - r_ret = filters[idx].joy_button.button_index; + r_ret = filters[idx].joy_button->get_button_index(); } else if (what == "pressed") { - r_ret = filters[idx].joy_button.pressed; + r_ret = filters[idx].joy_button->is_pressed(); } else { return false; } return true; } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { if (what == "finger_index") { r_ret = filters[idx].screen_touch.index; } else if (what == "pressed") { - r_ret = filters[idx].screen_touch.pressed; + r_ret = filters[idx].screen_touch->is_pressed(); } else { return false; } return true; } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { if (what == "finger_index") { r_ret = filters[idx].screen_drag.index; } else { @@ -1318,7 +1319,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } return true; } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (what == "action_name") { @@ -1344,7 +1345,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con } else if (what == "pressed") { - r_ret = filters[idx].action.pressed; + r_ret = filters[idx].action->is_pressed(); return true; } @@ -1354,7 +1355,7 @@ bool VisualScriptInputFilter::_get(const StringName &p_name, Variant &r_ret) con return false; } -static const char *event_type_names[InputEvent::TYPE_MAX] = { +static const char *event_type_names[Ref<InputEvent>::TYPE_MAX] = { "None", "Key", "MouseMotion", @@ -1371,7 +1372,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::INT, "filter_count", PROPERTY_HINT_RANGE, "0,64")); String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { + for (int i = 0; i < Ref<InputEvent>::TYPE_MAX; i++) { if (i > 0) et += ","; @@ -1388,10 +1389,10 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::INT, base + "device")); switch (filters[i].type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { if (kc == String()) { int kcc = keycode_get_count(); kc = "None"; @@ -1410,7 +1411,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_mask", PROPERTY_HINT_FLAGS, "Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_alt")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_shift")); @@ -1418,7 +1419,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_index", PROPERTY_HINT_ENUM, "Any,Left,Right,Middle,WheelUp,WheelDown,WheelLeft,WheelRight")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "doubleclicked")); @@ -1428,26 +1429,26 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con p_list->push_back(PropertyInfo(Variant::BOOL, base + "mod_meta")); } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { p_list->push_back(PropertyInfo(Variant::INT, base + "axis_index")); p_list->push_back(PropertyInfo(Variant::INT, base + "mode", PROPERTY_HINT_ENUM, "Min,Max")); p_list->push_back(PropertyInfo(Variant::REAL, base + "treshold", PROPERTY_HINT_RANGE, "0,1,0.01")); } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { p_list->push_back(PropertyInfo(Variant::INT, base + "button_index")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index")); p_list->push_back(PropertyInfo(Variant::BOOL, base + "pressed")); } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { p_list->push_back(PropertyInfo(Variant::INT, base + "finger_index")); } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { if (actions == String()) { @@ -1485,7 +1486,7 @@ void VisualScriptInputFilter::_get_property_list(List<PropertyInfo> *p_list) con class VisualScriptNodeInstanceInputFilter : public VisualScriptNodeInstance { public: VisualScriptInstance *instance; - Vector<InputEvent> filters; + Vector<Ref<InputEvent>> filters; //virtual int get_working_memory_size() const { return 0; } //virtual bool is_output_port_unsequenced(int p_idx) const { return false; } @@ -1499,11 +1500,11 @@ public: return 0; } - InputEvent event = *p_inputs[0]; + Ref<InputEvent> event = *p_inputs[0]; for (int i = 0; i < filters.size(); i++) { - const InputEvent &ie = filters[i]; + const Ref<InputEvent> &ie = filters[i]; if (ie.type != event.type) continue; @@ -1511,25 +1512,25 @@ public: switch (ie.type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { match = true; } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { InputEventKey k = ie.key; InputEventKey k2 = event.key; - if (k.scancode == 0 && k.unicode == 0 && k2.scancode == 0 && k2.unicode == 0) { + if (k->get_scancode() == 0 && k.unicode == 0 && k2->get_scancode() == 0 && k2.unicode == 0) { match = true; } else { - if ((k.scancode != 0 && k.scancode == k2.scancode) || (k.unicode != 0 && k.unicode == k2.unicode)) { + if ((k->get_scancode() != 0 && k->get_scancode() == k2->get_scancode()) || (k.unicode != 0 && k.unicode == k2.unicode)) { //key valid if ( - k.pressed == k2.pressed && + k->is_pressed() == k2->is_pressed() && k.echo == k2.echo && k.mod == k2.mod) { match = true; @@ -1538,30 +1539,30 @@ public: } } break; - case InputEvent::MOUSE_MOTION: { + case Ref<InputEvent>::MOUSE_MOTION: { InputEventMouseMotion mm = ie.mouse_motion; InputEventMouseMotion mm2 = event.mouse_motion; - if (mm.button_mask == mm2.button_mask && + if (mm->get_button_mask() == mm2->get_button_mask() && mm.mod == mm2.mod) { match = true; } } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { InputEventMouseButton mb = ie.mouse_button; InputEventMouseButton mb2 = event.mouse_button; - if (mb.button_index == mb2.button_index && - mb.pressed == mb2.pressed && + if (mb->get_button_index() == mb2->get_button_index() && + mb->is_pressed() == mb2->is_pressed() && mb.doubleclick == mb2.doubleclick && mb.mod == mb2.mod) { match = true; } } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { InputEventJoypadMotion jm = ie.joy_motion; InputEventJoypadMotion jm2 = event.joy_motion; @@ -1584,26 +1585,26 @@ public: } } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { InputEventJoypadButton jb = ie.joy_button; InputEventJoypadButton jb2 = event.joy_button; - if (jb.button_index == jb2.button_index && - jb.pressed == jb2.pressed) { + if (jb->get_button_index() == jb2->get_button_index() && + jb->is_pressed() == jb2->is_pressed()) { match = true; } } break; - case InputEvent::SCREEN_TOUCH: { + case Ref<InputEvent>::SCREEN_TOUCH: { InputEventScreenTouch st = ie.screen_touch; InputEventScreenTouch st2 = event.screen_touch; if (st.index == st2.index && - st.pressed == st2.pressed) { + st->is_pressed() == st2->is_pressed()) { match = true; } } break; - case InputEvent::SCREEN_DRAG: { + case Ref<InputEvent>::SCREEN_DRAG: { InputEventScreenDrag sd = ie.screen_drag; InputEventScreenDrag sd2 = event.screen_drag; @@ -1611,13 +1612,13 @@ public: match = true; } } break; - case InputEvent::ACTION: { + case Ref<InputEvent>::ACTION: { InputEventAction ia = ie.action; InputEventAction ia2 = event.action; if (ia.action == ia2.action && - ia.pressed == ia2.pressed) { + ia->is_pressed() == ia2->is_pressed()) { match = true; } } break; @@ -1643,7 +1644,7 @@ VisualScriptNodeInstance *VisualScriptInputFilter::instance(VisualScriptInstance VisualScriptInputFilter::VisualScriptInputFilter() { } - +#endif ////////////////////////////////////////// ////////////////TYPE CAST/////////// ////////////////////////////////////////// @@ -1832,6 +1833,6 @@ void register_visual_script_flow_control_nodes() { VisualScriptLanguage::singleton->add_register_func("flow_control/iterator", create_node_generic<VisualScriptIterator>); VisualScriptLanguage::singleton->add_register_func("flow_control/sequence", create_node_generic<VisualScriptSequence>); VisualScriptLanguage::singleton->add_register_func("flow_control/switch", create_node_generic<VisualScriptSwitch>); - VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter", create_node_generic<VisualScriptInputFilter>); + //VisualScriptLanguage::singleton->add_register_func("flow_control/input_filter", create_node_generic<VisualScriptInputFilter>); VisualScriptLanguage::singleton->add_register_func("flow_control/type_cast", create_node_generic<VisualScriptTypeCast>); } diff --git a/modules/visual_script/visual_script_flow_control.h b/modules/visual_script/visual_script_flow_control.h index e3936da9e5..314804602e 100644 --- a/modules/visual_script/visual_script_flow_control.h +++ b/modules/visual_script/visual_script_flow_control.h @@ -228,11 +228,12 @@ public: VisualScriptSwitch(); }; +#if 0 class VisualScriptInputFilter : public VisualScriptNode { GDCLASS(VisualScriptInputFilter, VisualScriptNode) - Vector<InputEvent> filters; + Vector<Ref<InputEvent>> filters; protected: bool _set(const StringName &p_name, const Variant &p_value); @@ -259,7 +260,7 @@ public: VisualScriptInputFilter(); }; - +#endif class VisualScriptTypeCast : public VisualScriptNode { GDCLASS(VisualScriptTypeCast, VisualScriptNode) diff --git a/modules/visual_script/visual_script_func_nodes.cpp b/modules/visual_script/visual_script_func_nodes.cpp index 84224dfcbe..b466e64aec 100644 --- a/modules/visual_script/visual_script_func_nodes.cpp +++ b/modules/visual_script/visual_script_func_nodes.cpp @@ -943,18 +943,6 @@ static Ref<VisualScriptNode> create_function_call_node(const String &p_name) { ////////////////SET////////////////////// ////////////////////////////////////////// -static const char *event_type_names[InputEvent::TYPE_MAX] = { - "None", - "Key", - "MouseMotion", - "MouseButton", - "JoypadMotion", - "JoypadButton", - "ScreenTouch", - "ScreenDrag", - "Action" -}; - int VisualScriptPropertySet::get_output_sequence_port_count() const { return call_mode != CALL_MODE_BASIC_TYPE ? 1 : 0; @@ -1119,24 +1107,6 @@ Variant::Type VisualScriptPropertySet::get_basic_type() const { return basic_type; } -void VisualScriptPropertySet::set_event_type(InputEvent::Type p_type) { - - if (event_type == p_type) - return; - event_type = p_type; - if (call_mode == CALL_MODE_BASIC_TYPE) { - _update_cache(); - } - _change_notify(); - _update_base_type(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptPropertySet::get_event_type() const { - - return event_type; -} - void VisualScriptPropertySet::set_base_type(const StringName &p_type) { if (base_type == p_type) @@ -1182,14 +1152,8 @@ void VisualScriptPropertySet::_update_cache() { //not super efficient.. Variant v; - if (basic_type == Variant::INPUT_EVENT) { - InputEvent ev; - ev.type = event_type; - v = ev; - } else { - Variant::CallError ce; - v = Variant::construct(basic_type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(basic_type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -1341,12 +1305,6 @@ void VisualScriptPropertySet::_validate_property(PropertyInfo &property) const { } } - if (property.name == "property/event_type") { - if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } - if (property.name == "property/node_path") { if (call_mode != CALL_MODE_NODE_PATH) { property.usage = 0; @@ -1418,9 +1376,6 @@ void VisualScriptPropertySet::_bind_methods() { ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertySet::_set_type_cache); ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertySet::_get_type_cache); - ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertySet::set_event_type); - ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertySet::get_event_type); - ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertySet::set_property); ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertySet::get_property); @@ -1438,14 +1393,6 @@ void VisualScriptPropertySet::_bind_methods() { bt += Variant::get_type_name(Variant::Type(i)); } - String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - if (i > 0) - et += ","; - - et += event_type_names[i]; - } - List<String> script_extensions; for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions); @@ -1463,7 +1410,6 @@ void VisualScriptPropertySet::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type"); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property"); @@ -1574,7 +1520,6 @@ VisualScriptPropertySet::VisualScriptPropertySet() { call_mode = CALL_MODE_SELF; base_type = "Object"; basic_type = Variant::NIL; - event_type = InputEvent::NONE; } template <VisualScriptPropertySet::CallMode cmode> @@ -1764,14 +1709,8 @@ void VisualScriptPropertyGet::_update_cache() { //not super efficient.. Variant v; - if (basic_type == Variant::INPUT_EVENT) { - InputEvent ev; - ev.type = event_type; - v = ev; - } else { - Variant::CallError ce; - v = Variant::construct(basic_type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(basic_type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -1919,24 +1858,6 @@ Variant::Type VisualScriptPropertyGet::get_basic_type() const { return basic_type; } -void VisualScriptPropertyGet::set_event_type(InputEvent::Type p_type) { - - if (event_type == p_type) - return; - event_type = p_type; - if (call_mode == CALL_MODE_BASIC_TYPE) { - _update_cache(); - } - _change_notify(); - _update_base_type(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptPropertyGet::get_event_type() const { - - return event_type; -} - void VisualScriptPropertyGet::_set_type_cache(Variant::Type p_type) { type_cache = p_type; } @@ -1965,11 +1886,6 @@ void VisualScriptPropertyGet::_validate_property(PropertyInfo &property) const { property.usage = 0; } } - if (property.name == "property/event_type") { - if (call_mode != CALL_MODE_BASIC_TYPE || basic_type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } if (property.name == "property/node_path") { if (call_mode != CALL_MODE_NODE_PATH) { @@ -2041,9 +1957,6 @@ void VisualScriptPropertyGet::_bind_methods() { ClassDB::bind_method(D_METHOD("_set_type_cache", "type_cache"), &VisualScriptPropertyGet::_set_type_cache); ClassDB::bind_method(D_METHOD("_get_type_cache"), &VisualScriptPropertyGet::_get_type_cache); - ClassDB::bind_method(D_METHOD("set_event_type", "event_type"), &VisualScriptPropertyGet::set_event_type); - ClassDB::bind_method(D_METHOD("get_event_type"), &VisualScriptPropertyGet::get_event_type); - ClassDB::bind_method(D_METHOD("set_property", "property"), &VisualScriptPropertyGet::set_property); ClassDB::bind_method(D_METHOD("get_property"), &VisualScriptPropertyGet::get_property); @@ -2061,14 +1974,6 @@ void VisualScriptPropertyGet::_bind_methods() { bt += Variant::get_type_name(Variant::Type(i)); } - String et; - for (int i = 0; i < InputEvent::TYPE_MAX; i++) { - if (i > 0) - et += ","; - - et += event_type_names[i]; - } - List<String> script_extensions; for (int i = 0; i < ScriptServer::get_language_count(); i++) { ScriptServer::get_language(i)->get_recognized_extensions(&script_extensions); @@ -2086,7 +1991,6 @@ void VisualScriptPropertyGet::_bind_methods() { ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/base_script", PROPERTY_HINT_FILE, script_ext_hint), "set_base_script", "get_base_script"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/type_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_type_cache", "_get_type_cache"); ADD_PROPERTY(PropertyInfo(Variant::INT, "property/basic_type", PROPERTY_HINT_ENUM, bt), "set_basic_type", "get_basic_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "property/event_type", PROPERTY_HINT_ENUM, et), "set_event_type", "get_event_type"); ADD_PROPERTY(PropertyInfo(Variant::NODE_PATH, "property/node_path", PROPERTY_HINT_NODE_PATH_TO_EDITED_NODE), "set_base_path", "get_base_path"); ADD_PROPERTY(PropertyInfo(Variant::STRING, "property/property"), "set_property", "get_property"); @@ -2184,7 +2088,6 @@ VisualScriptPropertyGet::VisualScriptPropertyGet() { call_mode = CALL_MODE_SELF; base_type = "Object"; basic_type = Variant::NIL; - event_type = InputEvent::NONE; type_cache = Variant::NIL; } diff --git a/modules/visual_script/visual_script_func_nodes.h b/modules/visual_script/visual_script_func_nodes.h index b56a3c2bcc..3b284952c5 100644 --- a/modules/visual_script/visual_script_func_nodes.h +++ b/modules/visual_script/visual_script_func_nodes.h @@ -155,7 +155,6 @@ private: String base_script; NodePath base_path; StringName property; - InputEvent::Type event_type; Node *_get_base_node() const; StringName _get_base_type() const; @@ -197,9 +196,6 @@ public: void set_basic_type(Variant::Type p_type); Variant::Type get_basic_type() const; - void set_event_type(InputEvent::Type p_type); - InputEvent::Type get_event_type() const; - void set_property(const StringName &p_type); StringName get_property() const; @@ -238,7 +234,6 @@ private: String base_script; NodePath base_path; StringName property; - InputEvent::Type event_type; void _update_base_type(); Node *_get_base_node() const; @@ -279,9 +274,6 @@ public: void set_basic_type(Variant::Type p_type); Variant::Type get_basic_type() const; - void set_event_type(InputEvent::Type p_type); - InputEvent::Type get_event_type() const; - void set_property(const StringName &p_type); StringName get_property() const; diff --git a/modules/visual_script/visual_script_nodes.cpp b/modules/visual_script/visual_script_nodes.cpp index 08f4191d3d..8ea3b8098d 100644 --- a/modules/visual_script/visual_script_nodes.cpp +++ b/modules/visual_script/visual_script_nodes.cpp @@ -3460,14 +3460,8 @@ void VisualScriptDeconstruct::_update_elements() { elements.clear(); Variant v; - if (type == Variant::INPUT_EVENT) { - InputEvent ie; - ie.type = input_type; - v = ie; - } else { - Variant::CallError ce; - v = Variant::construct(type, NULL, 0, ce); - } + Variant::CallError ce; + v = Variant::construct(type, NULL, 0, ce); List<PropertyInfo> pinfo; v.get_property_list(&pinfo); @@ -3497,21 +3491,6 @@ Variant::Type VisualScriptDeconstruct::get_deconstruct_type() const { return type; } -void VisualScriptDeconstruct::set_deconstruct_input_type(InputEvent::Type p_input_type) { - - if (input_type == p_input_type) - return; - - input_type = p_input_type; - _update_elements(); - ports_changed_notify(); -} - -InputEvent::Type VisualScriptDeconstruct::get_deconstruct_input_type() const { - - return input_type; -} - void VisualScriptDeconstruct::_set_elem_cache(const Array &p_elements) { ERR_FAIL_COND(p_elements.size() % 2 == 1); @@ -3570,12 +3549,6 @@ VisualScriptNodeInstance *VisualScriptDeconstruct::instance(VisualScriptInstance } void VisualScriptDeconstruct::_validate_property(PropertyInfo &property) const { - - if (property.name == "input_type") { - if (type != Variant::INPUT_EVENT) { - property.usage = 0; - } - } } void VisualScriptDeconstruct::_bind_methods() { @@ -3583,9 +3556,6 @@ void VisualScriptDeconstruct::_bind_methods() { ClassDB::bind_method(D_METHOD("set_deconstruct_type", "type"), &VisualScriptDeconstruct::set_deconstruct_type); ClassDB::bind_method(D_METHOD("get_deconstruct_type"), &VisualScriptDeconstruct::get_deconstruct_type); - ClassDB::bind_method(D_METHOD("set_deconstruct_input_type", "input_type"), &VisualScriptDeconstruct::set_deconstruct_input_type); - ClassDB::bind_method(D_METHOD("get_deconstruct_input_type"), &VisualScriptDeconstruct::get_deconstruct_input_type); - ClassDB::bind_method(D_METHOD("_set_elem_cache", "_cache"), &VisualScriptDeconstruct::_set_elem_cache); ClassDB::bind_method(D_METHOD("_get_elem_cache"), &VisualScriptDeconstruct::_get_elem_cache); @@ -3594,17 +3564,13 @@ void VisualScriptDeconstruct::_bind_methods() { argt += "," + Variant::get_type_name(Variant::Type(i)); } - String iet = "None,Key,MouseMotion,MouseButton,JoypadMotion,JoypadButton,ScreenTouch,ScreenDrag,Action"; - ADD_PROPERTY(PropertyInfo(Variant::INT, "type", PROPERTY_HINT_ENUM, argt), "set_deconstruct_type", "get_deconstruct_type"); - ADD_PROPERTY(PropertyInfo(Variant::INT, "input_type", PROPERTY_HINT_ENUM, iet), "set_deconstruct_input_type", "get_deconstruct_input_type"); ADD_PROPERTY(PropertyInfo(Variant::ARRAY, "elem_cache", PROPERTY_HINT_NONE, "", PROPERTY_USAGE_NOEDITOR), "_set_elem_cache", "_get_elem_cache"); } VisualScriptDeconstruct::VisualScriptDeconstruct() { type = Variant::NIL; - input_type = InputEvent::NONE; } void register_visual_script_nodes() { diff --git a/modules/visual_script/visual_script_nodes.h b/modules/visual_script/visual_script_nodes.h index c0933d1a78..402093fa80 100644 --- a/modules/visual_script/visual_script_nodes.h +++ b/modules/visual_script/visual_script_nodes.h @@ -923,7 +923,6 @@ class VisualScriptDeconstruct : public VisualScriptNode { void _update_elements(); Variant::Type type; - InputEvent::Type input_type; void _set_elem_cache(const Array &p_elements); Array _get_elem_cache() const; @@ -952,9 +951,6 @@ public: void set_deconstruct_type(Variant::Type p_type); Variant::Type get_deconstruct_type() const; - void set_deconstruct_input_type(InputEvent::Type p_input_type); - InputEvent::Type get_deconstruct_input_type() const; - virtual VisualScriptNodeInstance *instance(VisualScriptInstance *p_instance); VisualScriptDeconstruct(); diff --git a/platform/android/java_glue.cpp b/platform/android/java_glue.cpp index 6882dad4f0..37f53a2478 100644 --- a/platform/android/java_glue.cpp +++ b/platform/android/java_glue.cpp @@ -610,7 +610,7 @@ struct JAndroidPointerEvent { }; static List<JAndroidPointerEvent> pointer_events; -static List<InputEvent> key_events; +static List<Ref<InputEvent> > key_events; static List<OS_Android::JoypadEvent> joy_events; static bool initialized = false; static Mutex *input_mutex = NULL; @@ -1036,7 +1036,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_step(JNIEnv *env, job while (key_events.size()) { - InputEvent event = key_events.front()->get(); + Ref<InputEvent> event = key_events.front()->get(); os_android->process_event(event); key_events.pop_front(); @@ -1367,7 +1367,7 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joybutton(JNIEnv *env jevent.device = p_device; jevent.type = OS_Android::JOY_EVENT_BUTTON; jevent.index = p_button; - jevent.pressed = p_pressed; + jevent->is_pressed() = p_pressed; input_mutex->lock(); joy_events.push_back(jevent); @@ -1419,30 +1419,23 @@ JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_joyconnectionchanged( JNIEXPORT void JNICALL Java_org_godotengine_godot_GodotLib_key(JNIEnv *env, jobject obj, jint p_scancode, jint p_unicode_char, jboolean p_pressed) { - InputEvent ievent; - ievent.type = InputEvent::KEY; - ievent.device = 0; + Ref<InputEventKey> ievent; int val = p_unicode_char; int scancode = android_get_keysym(p_scancode); - ievent.key.scancode = scancode; - ievent.key.unicode = val; - ievent.key.pressed = p_pressed; + ievent->set_scancode(scancode); + ievent->set_unicode(val); + ievent->set_pressed(p_pressed); - print_line("Scancode: " + String::num(p_scancode) + ":" + String::num(ievent.key.scancode) + " Unicode: " + String::num(val)); - - ievent.key.mod.shift = false; - ievent.key.mod.alt = false; - ievent.key.mod.control = false; - ievent.key.echo = false; + print_line("Scancode: " + String::num(p_scancode) + ":" + String::num(ievent->get_scancode()) + " Unicode: " + String::num(val)); if (val == '\n') { - ievent.key.scancode = KEY_ENTER; + ievent->set_scancode(KEY_ENTER); } else if (val == 61448) { - ievent.key.scancode = KEY_BACKSPACE; - ievent.key.unicode = KEY_BACKSPACE; + ievent->set_scancode(KEY_BACKSPACE); + ievent->set_unicode(KEY_BACKSPACE); } else if (val == 61453) { - ievent.key.scancode = KEY_ENTER; - ievent.key.unicode = KEY_ENTER; + ievent->set_scancode(KEY_ENTER); + ievent->set_unicode(KEY_ENTER); } else if (p_scancode == 4) { go_back_request = true; diff --git a/platform/android/os_android.cpp b/platform/android/os_android.cpp index 6772964c2f..1c721c645c 100644 --- a/platform/android/os_android.cpp +++ b/platform/android/os_android.cpp @@ -344,7 +344,7 @@ void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) { switch (p_event.type) { case JOY_EVENT_BUTTON: - input->joy_button(p_event.device, p_event.index, p_event.pressed); + input->joy_button(p_event.device, p_event.index, p_event->is_pressed()); break; case JOY_EVENT_AXIS: InputDefault::JoyAxis value; @@ -360,7 +360,7 @@ void OS_Android::process_joy_event(OS_Android::JoypadEvent p_event) { } } -void OS_Android::process_event(InputEvent p_event) { +void OS_Android::process_event(Ref<InputEvent> p_event) { input->parse_input_event(p_event); } @@ -374,25 +374,24 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> if (touch.size()) { //end all if exist - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.button_mask = BUTTON_MASK_LEFT; - ev.mouse_button.pressed = false; - ev.mouse_button.x = touch[0].pos.x; - ev.mouse_button.y = touch[0].pos.y; - ev.mouse_button.global_x = touch[0].pos.x; - ev.mouse_button.global_y = touch[0].pos.y; - input->parse_input_event(ev); + { + Ref<InputEventMouseButton> ev; + ev.instance(); + ev->set_button_index(BUTTON_LEFT); + ev->set_button_mask(BUTTON_MASK_LEFT); + ev->set_pressed(false); + ev->set_pos(touch[0].pos); + ev->set_global_pos(touch[0].pos); + input->parse_input_event(ev); + } for (int i = 0; i < touch.size(); i++) { - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = touch[i].id; - ev.screen_touch.pressed = false; - ev.screen_touch.x = touch[i].pos.x; - ev.screen_touch.y = touch[i].pos.y; + Ref<InputEventScreenTouch> ev; + ev.instance(); + ev->set_index(touch[i].id); + ev->set_pressed(false); + ev->set_pos(touch[i].pos); input->parse_input_event(ev); } } @@ -405,15 +404,14 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> { //send mouse - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.button_mask = BUTTON_MASK_LEFT; - ev.mouse_button.pressed = true; - ev.mouse_button.x = touch[0].pos.x; - ev.mouse_button.y = touch[0].pos.y; - ev.mouse_button.global_x = touch[0].pos.x; - ev.mouse_button.global_y = touch[0].pos.y; + Ref<InputEventMouseButton> ev; + ev.instance(); + ev.type = Ref<InputEvent>::MOUSE_BUTTON; + ev->set_button_index(BUTTON_LEFT); + ev->set_button_mask(BUTTON_MASK_LEFT); + ev->set_pressed(true); + ev->set_pos(touch[0].pos); + ev->set_global_pos(touch[0].pos); input->set_mouse_position(Point2(touch[0].pos.x, touch[0].pos.y)); last_mouse = touch[0].pos; input->parse_input_event(ev); @@ -422,12 +420,11 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> //send touch for (int i = 0; i < touch.size(); i++) { - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = touch[i].id; - ev.screen_touch.pressed = true; - ev.screen_touch.x = touch[i].pos.x; - ev.screen_touch.y = touch[i].pos.y; + Ref<InputEventScreenTouch> ev; + ev.instance(); + ev->set_index(touch[i].id); + ev->set_pressed(true); + ev->set_pos(touch[i].pos.x); input->parse_input_event(ev); } @@ -436,16 +433,13 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> if (p_points.size()) { //send mouse, should look for point 0? - InputEvent ev; - ev.type = InputEvent::MOUSE_MOTION; - ev.mouse_motion.button_mask = BUTTON_MASK_LEFT; - ev.mouse_motion.x = p_points[0].pos.x; - ev.mouse_motion.y = p_points[0].pos.y; + Ref<InputEventMouseMotion> ev; + ev.instance(); + ev->set_button_mask(BUTTON_MASK_LEFT); + ev->set_pos(p_points[0].pos.x); input->set_mouse_position(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); - ev.mouse_motion.speed_x = input->get_last_mouse_speed().x; - ev.mouse_motion.speed_y = input->get_last_mouse_speed().y; - ev.mouse_motion.relative_x = p_points[0].pos.x - last_mouse.x; - ev.mouse_motion.relative_y = p_points[0].pos.y - last_mouse.y; + ev->set_speed(input->get_last_mouse_speed()); + ev->set_relative(p_points[0].pos - last_mouse); last_mouse = p_points[0].pos; input->parse_input_event(ev); } @@ -468,13 +462,11 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> if (touch[i].pos == p_points[idx].pos) continue; //no move unncesearily - InputEvent ev; - ev.type = InputEvent::SCREEN_DRAG; - ev.screen_drag.index = touch[i].id; - ev.screen_drag.x = p_points[idx].pos.x; - ev.screen_drag.y = p_points[idx].pos.y; - ev.screen_drag.relative_x = p_points[idx].pos.x - touch[i].pos.x; - ev.screen_drag.relative_y = p_points[idx].pos.y - touch[i].pos.y; + Ref<InputEventScreenDrag> ev; + ev.instance(); + ev->set_index(touch[i].id); + ev->set_pos(p_points[idx].pos.x); + ev->set_relative(p_points[idx].pos - touch[i].pos); input->parse_input_event(ev); touch[i].pos = p_points[idx].pos; } @@ -484,26 +476,23 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> if (touch.size()) { //end all if exist - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.button_mask = BUTTON_MASK_LEFT; - ev.mouse_button.pressed = false; - ev.mouse_button.x = touch[0].pos.x; - ev.mouse_button.y = touch[0].pos.y; - ev.mouse_button.global_x = touch[0].pos.x; - ev.mouse_button.global_y = touch[0].pos.y; + Ref<InputEventMouseButton> ev; + ev.instance(); + ev->set_button_index(BUTTON_LEFT); + ev->set_button_mask(BUTTON_MASK_LEFT); + ev->set_pressed(false); + ev->set_pos(touch[0].pos.x); + ev->set_global_pos(touch[0].pos.x); input->set_mouse_position(Point2(touch[0].pos.x, touch[0].pos.y)); input->parse_input_event(ev); for (int i = 0; i < touch.size(); i++) { - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = touch[i].id; - ev.screen_touch.pressed = false; - ev.screen_touch.x = touch[i].pos.x; - ev.screen_touch.y = touch[i].pos.y; + Ref<InputEventScreenTouch> ev; + ev.instance(); + ev->set_index(touch[i].id); + ev->set_pressed(false); + ev->set_pos(touch[i].pos); input->parse_input_event(ev); } touch.clear(); @@ -517,12 +506,12 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> TouchPos tp = p_points[p_pointer]; touch.push_back(tp); - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = tp.id; - ev.screen_touch.pressed = true; - ev.screen_touch.x = tp.pos.x; - ev.screen_touch.y = tp.pos.y; + Ref<InputEventScreenTouch> ev; + ev.instance(); + + ev->set_index(tp.id); + ev->set_pressed(true); + ev->set_pos(tp.pos); input->parse_input_event(ev); } break; @@ -531,12 +520,11 @@ void OS_Android::process_touch(int p_what, int p_pointer, const Vector<TouchPos> for (int i = 0; i < touch.size(); i++) { if (touch[i].id == p_pointer) { - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = touch[i].id; - ev.screen_touch.pressed = false; - ev.screen_touch.x = touch[i].pos.x; - ev.screen_touch.y = touch[i].pos.y; + Ref<InputEventScreenTouch> ev; + ev.instance(); + ev->set_index(touch[i].id); + ev->set_pressed(false); + ev->set_pos(touch[i].pos); input->parse_input_event(ev); touch.remove(i); i--; diff --git a/platform/android/os_android.h b/platform/android/os_android.h index f1da2867f0..897c71a7df 100644 --- a/platform/android/os_android.h +++ b/platform/android/os_android.h @@ -231,7 +231,7 @@ public: void process_gyroscope(const Vector3 &p_gyroscope); void process_touch(int p_what, int p_pointer, const Vector<TouchPos> &p_points); void process_joy_event(JoypadEvent p_event); - void process_event(InputEvent p_event); + void process_event(Ref<InputEvent> p_event); void init_video_mode(int p_video_width, int p_video_height); virtual Error native_video_play(String p_path, float p_volume); diff --git a/platform/haiku/haiku_direct_window.cpp b/platform/haiku/haiku_direct_window.cpp index fb6d9afd85..4a9f8c780d 100644 --- a/platform/haiku/haiku_direct_window.cpp +++ b/platform/haiku/haiku_direct_window.cpp @@ -151,35 +151,35 @@ void HaikuDirectWindow::HandleMouseButton(BMessage *message) { } */ - InputEvent mouse_event; - mouse_event.type = InputEvent::MOUSE_BUTTON; + Ref<InputEvent> mouse_event; + mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON; mouse_event.device = 0; mouse_event.mouse_button.mod = GetKeyModifierState(modifiers); - mouse_event.mouse_button.button_mask = GetMouseButtonState(buttons); - mouse_event.mouse_button.x = where.x; - mouse_event.mouse_button.y = where.y; + mouse_event->get_button_mask() = GetMouseButtonState(buttons); + mouse_event->get_pos().x = where.x; + mouse_event->get_pos().y = where.y; mouse_event.mouse_button.global_x = where.x; mouse_event.mouse_button.global_y = where.y; switch (button) { default: case B_PRIMARY_MOUSE_BUTTON: - mouse_event.mouse_button.button_index = 1; + mouse_event->get_button_index() = 1; break; case B_SECONDARY_MOUSE_BUTTON: - mouse_event.mouse_button.button_index = 2; + mouse_event->get_button_index() = 2; break; case B_TERTIARY_MOUSE_BUTTON: - mouse_event.mouse_button.button_index = 3; + mouse_event->get_button_index() = 3; break; } - mouse_event.mouse_button.pressed = (message->what == B_MOUSE_DOWN); + mouse_event->is_pressed() = (message->what == B_MOUSE_DOWN); - if (message->what == B_MOUSE_DOWN && mouse_event.mouse_button.button_index == 1) { + if (message->what == B_MOUSE_DOWN && mouse_event->get_button_index() == 1) { int32 clicks = message->FindInt32("clicks"); if (clicks > 1) { @@ -207,12 +207,12 @@ void HaikuDirectWindow::HandleMouseMoved(BMessage *message) { Point2i rel = pos - last_mouse_position; - InputEvent motion_event; - motion_event.type = InputEvent::MOUSE_MOTION; + Ref<InputEvent> motion_event; + motion_event.type = Ref<InputEvent>::MOUSE_MOTION; motion_event.device = 0; motion_event.mouse_motion.mod = GetKeyModifierState(modifiers); - motion_event.mouse_motion.button_mask = GetMouseButtonState(buttons); + motion_event->get_button_mask() = GetMouseButtonState(buttons); motion_event.mouse_motion.x = pos.x; motion_event.mouse_motion.y = pos.y; input->set_mouse_position(pos); @@ -221,8 +221,8 @@ void HaikuDirectWindow::HandleMouseMoved(BMessage *message) { motion_event.mouse_motion.speed_x = input->get_last_mouse_speed().x; motion_event.mouse_motion.speed_y = input->get_last_mouse_speed().y; - motion_event.mouse_motion.relative_x = rel.x; - motion_event.mouse_motion.relative_y = rel.y; + motion_event->get_relative().x = rel.x; + motion_event->get_relative().y = rel.y; last_mouse_position = pos; @@ -235,22 +235,22 @@ void HaikuDirectWindow::HandleMouseWheelChanged(BMessage *message) { return; } - InputEvent mouse_event; - mouse_event.type = InputEvent::MOUSE_BUTTON; + Ref<InputEvent> mouse_event; + mouse_event.type = Ref<InputEvent>::MOUSE_BUTTON; mouse_event.device = 0; - mouse_event.mouse_button.button_index = wheel_delta_y < 0 ? 4 : 5; + mouse_event->get_button_index() = wheel_delta_y < 0 ? 4 : 5; mouse_event.mouse_button.mod = GetKeyModifierState(last_key_modifier_state); - mouse_event.mouse_button.button_mask = last_button_mask; - mouse_event.mouse_button.x = last_mouse_position.x; - mouse_event.mouse_button.y = last_mouse_position.y; + mouse_event->get_button_mask() = last_button_mask; + mouse_event->get_pos().x = last_mouse_position.x; + mouse_event->get_pos().y = last_mouse_position.y; mouse_event.mouse_button.global_x = last_mouse_position.x; mouse_event.mouse_button.global_y = last_mouse_position.y; - mouse_event.mouse_button.pressed = true; + mouse_event->is_pressed() = true; input->parse_input_event(mouse_event); - mouse_event.mouse_button.pressed = false; + mouse_event->is_pressed() = false; input->parse_input_event(mouse_event); } @@ -271,13 +271,13 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) { return; } - InputEvent event; - event.type = InputEvent::KEY; + Ref<InputEvent> event; + event.type = Ref<InputEvent>::KEY; event.device = 0; event.key.mod = GetKeyModifierState(modifiers); - event.key.pressed = (message->what == B_KEY_DOWN); - event.key.scancode = KeyMappingHaiku::get_keysym(raw_char, key); - event.key.echo = message->HasInt32("be:key_repeat"); + event->is_pressed() = (message->what == B_KEY_DOWN); + event->get_scancode() = KeyMappingHaiku::get_keysym(raw_char, key); + event->is_echo() = message->HasInt32("be:key_repeat"); event.key.unicode = 0; const char *bytes = NULL; @@ -286,9 +286,9 @@ void HaikuDirectWindow::HandleKeyboardEvent(BMessage *message) { } //make it consistent across platforms. - if (event.key.scancode == KEY_BACKTAB) { - event.key.scancode = KEY_TAB; - event.key.mod.shift = true; + if (event->get_scancode() == KEY_BACKTAB) { + event->get_scancode() = KEY_TAB; + event->get_shift() = true; } input->parse_input_event(event); @@ -308,13 +308,13 @@ void HaikuDirectWindow::HandleKeyboardModifierEvent(BMessage *message) { int32 key = old_modifiers ^ modifiers; - InputEvent event; - event.type = InputEvent::KEY; + Ref<InputEvent> event; + event.type = Ref<InputEvent>::KEY; event.device = 0; event.key.mod = GetKeyModifierState(modifiers); - event.key.pressed = ((modifiers & key) != 0); - event.key.scancode = KeyMappingHaiku::get_modifier_keysym(key); - event.key.echo = false; + event->is_pressed() = ((modifiers & key) != 0); + event->get_scancode() = KeyMappingHaiku::get_modifier_keysym(key); + event->is_echo() = false; event.key.unicode = 0; input->parse_input_event(event); diff --git a/platform/iphone/os_iphone.cpp b/platform/iphone/os_iphone.cpp index 0a9d776421..3e95d1a706 100644 --- a/platform/iphone/os_iphone.cpp +++ b/platform/iphone/os_iphone.cpp @@ -195,48 +195,45 @@ bool OSIPhone::iterate() { void OSIPhone::key(uint32_t p_key, bool p_pressed) { - InputEvent ev; - ev.type = InputEvent::KEY; - ev.key.echo = false; - ev.key.pressed = p_pressed; - ev.key.scancode = p_key; - ev.key.unicode = p_key; + Ref<InputEventKey> ev; + ev.instance() + ev->set_echo(false); + ev->set_pressed(p_pressed); + ev->set_scancode(p_key); + ev->set_unicode(p_key); queue_event(ev); }; void OSIPhone::mouse_button(int p_idx, int p_x, int p_y, bool p_pressed, bool p_doubleclick, bool p_use_as_mouse) { if (!GLOBAL_DEF("debug/disable_touch", false)) { - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; - ev.screen_touch.index = p_idx; - ev.screen_touch.pressed = p_pressed; - ev.screen_touch.x = p_x; - ev.screen_touch.y = p_y; + Ref<InputEventSreenTouch> ev; + ev.instance(); + + ev->set_index(p_idx); + ev->set_pressed(p_pressed); + ev->set_pos(Vector2(p_x, p_y)); queue_event(ev); }; - mouse_list.pressed[p_idx] = p_pressed; + mouse_list->is_pressed()[p_idx] = p_pressed; if (p_use_as_mouse) { - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.device = 0; - ev.mouse_button.pointer_index = p_idx; - + Ref<InputEventMouseButton> ev; + ev.instance(); // swaped it for tilted screen - //ev.mouse_button.x = ev.mouse_button.global_x = video_mode.height - p_y; - //ev.mouse_button.y = ev.mouse_button.global_y = p_x; - ev.mouse_button.x = ev.mouse_button.global_x = p_x; - ev.mouse_button.y = ev.mouse_button.global_y = p_y; + //ev->get_pos().x = ev.mouse_button.global_x = video_mode.height - p_y; + //ev->get_pos().y = ev.mouse_button.global_y = p_x; + ev->set_pos(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); + ev->set_global_pos(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); - //mouse_list.pressed[p_idx] = p_pressed; + //mouse_list->is_pressed()[p_idx] = p_pressed; - input->set_mouse_position(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.doubleclick = p_doubleclick; - ev.mouse_button.pressed = p_pressed; + input->set_mouse_position(ev->get_pos()); + ev->set_button_index(BUTTON_LEFT); + ev->set_doubleclick(p_doubleclick); + ev->set_pressed(p_pressed); queue_event(ev); }; @@ -246,46 +243,31 @@ void OSIPhone::mouse_move(int p_idx, int p_prev_x, int p_prev_y, int p_x, int p_ if (!GLOBAL_DEF("debug/disable_touch", false)) { - InputEvent ev; - ev.type = InputEvent::SCREEN_DRAG; - ev.screen_drag.index = p_idx; - ev.screen_drag.x = p_x; - ev.screen_drag.y = p_y; - ev.screen_drag.relative_x = p_x - p_prev_x; - ev.screen_drag.relative_y = p_y - p_prev_y; + Ref<InputEventScreenDrag> ev; + ev.instance(); + ev->set_index(p_idx); + ev->set_pos(Vector2(p_x, p_y)); + ev->set_relative(Vector2(p_x - p_prev_x, p_y - p_prev_y)); queue_event(ev); }; if (p_use_as_mouse) { - InputEvent ev; - ev.type = InputEvent::MOUSE_MOTION; - ev.device = 0; - ev.mouse_motion.pointer_index = p_idx; - - if (true) { // vertical + Ref<InputEventMouseMotion> ev; + ev.instance(); - ev.mouse_motion.x = ev.mouse_button.global_x = p_x; - ev.mouse_motion.y = ev.mouse_button.global_y = p_y; - ev.mouse_motion.relative_x = ev.mouse_motion.x - p_prev_x; - ev.mouse_motion.relative_y = ev.mouse_motion.y - p_prev_y; - - } else { // horizontal? - ev.mouse_motion.x = ev.mouse_button.global_x = video_mode.height - p_y; - ev.mouse_motion.y = ev.mouse_button.global_y = p_x; - ev.mouse_motion.relative_x = ev.mouse_motion.x - (video_mode.height - p_prev_x); - ev.mouse_motion.relative_y = ev.mouse_motion.y - p_prev_x; - }; + ev->set_pos(Vector2(p_x, p_y)); + ev->set_global_pos(Vector2(p_x, p_y)); + ev->set_relative(Vector2(p_x - p_prev_x, p_y - p_prev_y)); - input->set_mouse_position(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); - ev.mouse_motion.speed_x = input->get_last_mouse_speed().x; - ev.mouse_motion.speed_y = input->get_last_mouse_speed().y; - ev.mouse_motion.button_mask = 1; // pressed + input->set_mouse_position(ev->get_pos()); + ev->set_speed(input->get_last_mouse_speed()); + ev->set_button_mask(BUTTON_LEFT); // pressed queue_event(ev); }; }; -void OSIPhone::queue_event(const InputEvent &p_event) { +void OSIPhone::queue_event(const Ref<InputEvent> &p_event) { ERR_FAIL_INDEX(event_count, MAX_EVENTS); @@ -296,7 +278,7 @@ void OSIPhone::touches_cancelled() { for (int i = 0; i < MAX_MOUSE_COUNT; i++) { - if (mouse_list.pressed[i]) { + if (mouse_list->is_pressed()[i]) { // send a mouse_up outside the screen mouse_button(i, -1, -1, false, false, false); @@ -416,7 +398,7 @@ Point2 OSIPhone::get_mouse_position() const { int OSIPhone::get_mouse_button_state() const { - return mouse_list.pressed[0]; + return mouse_list->is_pressed()[0]; }; void OSIPhone::set_window_title(const String &p_title){}; diff --git a/platform/iphone/os_iphone.h b/platform/iphone/os_iphone.h index 209bf00788..0da7e6d081 100644 --- a/platform/iphone/os_iphone.h +++ b/platform/iphone/os_iphone.h @@ -118,9 +118,9 @@ private: Vector3 last_accel; - InputEvent event_queue[MAX_EVENTS]; + Ref<InputEvent> event_queue[MAX_EVENTS]; int event_count; - void queue_event(const InputEvent &p_event); + void queue_event(const Ref<InputEvent> &p_event); String data_dir; String unique_ID; diff --git a/platform/javascript/os_javascript.cpp b/platform/javascript/os_javascript.cpp index dda619a54d..ae00fb429e 100644 --- a/platform/javascript/os_javascript.cpp +++ b/platform/javascript/os_javascript.cpp @@ -151,26 +151,26 @@ static EM_BOOL _mousebutton_callback(int event_type, const EmscriptenMouseEvent ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_MOUSEDOWN && event_type != EMSCRIPTEN_EVENT_MOUSEUP, false); - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.pressed = event_type == EMSCRIPTEN_EVENT_MOUSEDOWN; - ev.mouse_button.global_x = ev.mouse_button.x = mouse_event->canvasX; - ev.mouse_button.global_y = ev.mouse_button.y = mouse_event->canvasY; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::MOUSE_BUTTON; + ev->is_pressed() = event_type == EMSCRIPTEN_EVENT_MOUSEDOWN; + ev.mouse_button.global_x = ev->get_pos().x = mouse_event->canvasX; + ev.mouse_button.global_y = ev->get_pos().y = mouse_event->canvasY; ev.mouse_button.mod = dom2godot_mod(mouse_event); switch (mouse_event->button) { - case DOM_BUTTON_LEFT: ev.mouse_button.button_index = BUTTON_LEFT; break; - case DOM_BUTTON_MIDDLE: ev.mouse_button.button_index = BUTTON_MIDDLE; break; - case DOM_BUTTON_RIGHT: ev.mouse_button.button_index = BUTTON_RIGHT; break; + case DOM_BUTTON_LEFT: ev->get_button_index() = BUTTON_LEFT; break; + case DOM_BUTTON_MIDDLE: ev->get_button_index() = BUTTON_MIDDLE; break; + case DOM_BUTTON_RIGHT: ev->get_button_index() = BUTTON_RIGHT; break; default: return false; } - ev.mouse_button.button_mask = _input->get_mouse_button_mask(); - if (ev.mouse_button.pressed) - ev.mouse_button.button_mask |= 1 << ev.mouse_button.button_index; + ev->get_button_mask() = _input->get_mouse_button_mask(); + if (ev->is_pressed()) + ev->get_button_mask() |= 1 << ev->get_button_index(); else - ev.mouse_button.button_mask &= ~(1 << ev.mouse_button.button_index); - ev.mouse_button.button_mask >>= 1; + ev->get_button_mask() &= ~(1 << ev->get_button_index()); + ev->get_button_mask() >>= 1; _input->parse_input_event(ev); return true; @@ -180,16 +180,16 @@ static EM_BOOL _mousemove_callback(int event_type, const EmscriptenMouseEvent *m ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_MOUSEMOVE, false); - InputEvent ev; - ev.type = InputEvent::MOUSE_MOTION; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::MOUSE_MOTION; ev.mouse_motion.mod = dom2godot_mod(mouse_event); - ev.mouse_motion.button_mask = _input->get_mouse_button_mask() >> 1; + ev->get_button_mask() = _input->get_mouse_button_mask() >> 1; ev.mouse_motion.global_x = ev.mouse_motion.x = mouse_event->canvasX; ev.mouse_motion.global_y = ev.mouse_motion.y = mouse_event->canvasY; - ev.mouse_motion.relative_x = _input->get_mouse_position().x - ev.mouse_motion.x; - ev.mouse_motion.relative_y = _input->get_mouse_position().y - ev.mouse_motion.y; + ev->get_relative().x = _input->get_mouse_position().x - ev.mouse_motion.x; + ev->get_relative().y = _input->get_mouse_position().y - ev.mouse_motion.y; _input->set_mouse_position(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); ev.mouse_motion.speed_x = _input->get_last_mouse_speed().x; @@ -203,31 +203,31 @@ static EM_BOOL _wheel_callback(int event_type, const EmscriptenWheelEvent *wheel ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_WHEEL, false); - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_mask = _input->get_mouse_button_mask() >> 1; - ev.mouse_button.global_x = ev.mouse_button.x = _input->get_mouse_position().x; - ev.mouse_button.global_y = ev.mouse_button.y = _input->get_mouse_position().y; - ev.mouse_button.mod.shift = _input->is_key_pressed(KEY_SHIFT); - ev.mouse_button.mod.alt = _input->is_key_pressed(KEY_ALT); - ev.mouse_button.mod.control = _input->is_key_pressed(KEY_CONTROL); - ev.mouse_button.mod.meta = _input->is_key_pressed(KEY_META); + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::MOUSE_BUTTON; + ev->get_button_mask() = _input->get_mouse_button_mask() >> 1; + ev.mouse_button.global_x = ev->get_pos().x = _input->get_mouse_position().x; + ev.mouse_button.global_y = ev->get_pos().y = _input->get_mouse_position().y; + ev.mouse_button->get_shift() = _input->is_key_pressed(KEY_SHIFT); + ev.mouse_button->get_alt() = _input->is_key_pressed(KEY_ALT); + ev.mouse_button->get_control() = _input->is_key_pressed(KEY_CONTROL); + ev.mouse_button->get_metakey() = _input->is_key_pressed(KEY_META); if (wheel_event->deltaY < 0) - ev.mouse_button.button_index = BUTTON_WHEEL_UP; + ev->get_button_index() = BUTTON_WHEEL_UP; else if (wheel_event->deltaY > 0) - ev.mouse_button.button_index = BUTTON_WHEEL_DOWN; + ev->get_button_index() = BUTTON_WHEEL_DOWN; else if (wheel_event->deltaX > 0) - ev.mouse_button.button_index = BUTTON_WHEEL_LEFT; + ev->get_button_index() = BUTTON_WHEEL_LEFT; else if (wheel_event->deltaX < 0) - ev.mouse_button.button_index = BUTTON_WHEEL_RIGHT; + ev->get_button_index() = BUTTON_WHEEL_RIGHT; else return false; - ev.mouse_button.pressed = true; + ev->is_pressed() = true; _input->parse_input_event(ev); - ev.mouse_button.pressed = false; + ev->is_pressed() = false; _input->parse_input_event(ev); return true; @@ -243,8 +243,8 @@ static EM_BOOL _touchpress_callback(int event_type, const EmscriptenTouchEvent * event_type != EMSCRIPTEN_EVENT_TOUCHCANCEL, false); - InputEvent ev; - ev.type = InputEvent::SCREEN_TOUCH; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::SCREEN_TOUCH; int lowest_id_index = -1; for (int i = 0; i < touch_event->numTouches; ++i) { @@ -256,20 +256,20 @@ static EM_BOOL _touchpress_callback(int event_type, const EmscriptenTouchEvent * ev.screen_touch.index = touch.identifier; _prev_touches[i].x = ev.screen_touch.x = touch.canvasX; _prev_touches[i].y = ev.screen_touch.y = touch.canvasY; - ev.screen_touch.pressed = event_type == EMSCRIPTEN_EVENT_TOUCHSTART; + ev.screen_touch->is_pressed() = event_type == EMSCRIPTEN_EVENT_TOUCHSTART; _input->parse_input_event(ev); } if (touch_event->touches[lowest_id_index].isChanged) { - ev.type = InputEvent::MOUSE_BUTTON; + ev.type = Ref<InputEvent>::MOUSE_BUTTON; ev.mouse_button.mod = dom2godot_mod(touch_event); - ev.mouse_button.button_mask = _input->get_mouse_button_mask() >> 1; - ev.mouse_button.global_x = ev.mouse_button.x = touch_event->touches[lowest_id_index].canvasX; - ev.mouse_button.global_y = ev.mouse_button.y = touch_event->touches[lowest_id_index].canvasY; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.pressed = event_type == EMSCRIPTEN_EVENT_TOUCHSTART; + ev->get_button_mask() = _input->get_mouse_button_mask() >> 1; + ev.mouse_button.global_x = ev->get_pos().x = touch_event->touches[lowest_id_index].canvasX; + ev.mouse_button.global_y = ev->get_pos().y = touch_event->touches[lowest_id_index].canvasY; + ev->get_button_index() = BUTTON_LEFT; + ev->is_pressed() = event_type == EMSCRIPTEN_EVENT_TOUCHSTART; _input->parse_input_event(ev); } @@ -280,8 +280,8 @@ static EM_BOOL _touchmove_callback(int event_type, const EmscriptenTouchEvent *t ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_TOUCHMOVE, false); - InputEvent ev; - ev.type = InputEvent::SCREEN_DRAG; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::SCREEN_DRAG; int lowest_id_index = -1; for (int i = 0; i < touch_event->numTouches; ++i) { @@ -304,13 +304,13 @@ static EM_BOOL _touchmove_callback(int event_type, const EmscriptenTouchEvent *t if (touch_event->touches[lowest_id_index].isChanged) { - ev.type = InputEvent::MOUSE_MOTION; + ev.type = Ref<InputEvent>::MOUSE_MOTION; ev.mouse_motion.mod = dom2godot_mod(touch_event); - ev.mouse_motion.button_mask = _input->get_mouse_button_mask() >> 1; + ev->get_button_mask() = _input->get_mouse_button_mask() >> 1; ev.mouse_motion.global_x = ev.mouse_motion.x = touch_event->touches[lowest_id_index].canvasX; ev.mouse_motion.global_y = ev.mouse_motion.y = touch_event->touches[lowest_id_index].canvasY; - ev.mouse_motion.relative_x = _input->get_mouse_position().x - ev.mouse_motion.x; - ev.mouse_motion.relative_y = _input->get_mouse_position().y - ev.mouse_motion.y; + ev->get_relative().x = _input->get_mouse_position().x - ev.mouse_motion.x; + ev->get_relative().y = _input->get_mouse_position().y - ev.mouse_motion.y; _input->set_mouse_position(Point2(ev.mouse_motion.x, ev.mouse_motion.y)); ev.mouse_motion.speed_x = _input->get_last_mouse_speed().x; @@ -321,13 +321,13 @@ static EM_BOOL _touchmove_callback(int event_type, const EmscriptenTouchEvent *t return true; } -static InputEvent _setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) { +static Ref<InputEvent> _setup_key_event(const EmscriptenKeyboardEvent *emscripten_event) { - InputEvent ev; - ev.type = InputEvent::KEY; - ev.key.echo = emscripten_event->repeat; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::KEY; + ev->is_echo() = emscripten_event->repeat; ev.key.mod = dom2godot_mod(emscripten_event); - ev.key.scancode = dom2godot_scancode(emscripten_event->keyCode); + ev->get_scancode() = dom2godot_scancode(emscripten_event->keyCode); String unicode = String::utf8(emscripten_event->key); // check if empty or multi-character (e.g. `CapsLock`) @@ -342,15 +342,15 @@ static InputEvent _setup_key_event(const EmscriptenKeyboardEvent *emscripten_eve return ev; } -static InputEvent deferred_key_event; +static Ref<InputEvent> deferred_key_event; static EM_BOOL _keydown_callback(int event_type, const EmscriptenKeyboardEvent *key_event, void *user_data) { ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_KEYDOWN, false); - InputEvent ev = _setup_key_event(key_event); - ev.key.pressed = true; - if (ev.key.unicode == 0 && keycode_has_unicode(ev.key.scancode)) { + Ref<InputEvent> ev = _setup_key_event(key_event); + ev->is_pressed() = true; + if (ev.key.unicode == 0 && keycode_has_unicode(ev->get_scancode())) { // defer to keypress event for legacy unicode retrieval deferred_key_event = ev; return false; // do not suppress keypress event @@ -372,10 +372,10 @@ static EM_BOOL _keyup_callback(int event_type, const EmscriptenKeyboardEvent *ke ERR_FAIL_COND_V(event_type != EMSCRIPTEN_EVENT_KEYUP, false); - InputEvent ev = _setup_key_event(key_event); - ev.key.pressed = false; + Ref<InputEvent> ev = _setup_key_event(key_event); + ev->is_pressed() = false; _input->parse_input_event(ev); - return ev.key.scancode != KEY_UNKNOWN && ev.key.scancode != 0; + return ev->get_scancode() != KEY_UNKNOWN && ev->get_scancode() != 0; } static EM_BOOL joy_callback_func(int p_type, const EmscriptenGamepadEvent *p_event, void *p_user) { diff --git a/platform/javascript/os_javascript.h b/platform/javascript/os_javascript.h index 2bc603d8d9..65269148ec 100644 --- a/platform/javascript/os_javascript.h +++ b/platform/javascript/os_javascript.h @@ -154,7 +154,7 @@ public: virtual String get_resource_dir() const; void process_accelerometer(const Vector3 &p_accelerometer); - void push_input(const InputEvent &p_ev); + void push_input(const Ref<InputEvent> &p_ev); virtual bool is_joy_known(int p_device); virtual String get_joy_guid(int p_device) const; diff --git a/platform/osx/os_osx.h b/platform/osx/os_osx.h index ff02bf0794..3a37d663ad 100644 --- a/platform/osx/os_osx.h +++ b/platform/osx/os_osx.h @@ -165,7 +165,7 @@ public: virtual void swap_buffers(); Error shell_open(String p_uri); - void push_input(const InputEvent &p_event); + void push_input(const Ref<InputEvent> &p_event); String get_locale() const; diff --git a/platform/osx/os_osx.mm b/platform/osx/os_osx.mm index d6647fc1d2..462a926674 100644 --- a/platform/osx/os_osx.mm +++ b/platform/osx/os_osx.mm @@ -288,15 +288,15 @@ static int button_mask = 0; //print_line("mouse down:"); button_mask |= BUTTON_MASK_LEFT; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.pressed = true; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_LEFT; + ev->is_pressed() = true; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.doubleclick = [event clickCount] == 2; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); @@ -309,24 +309,24 @@ static int button_mask = 0; - (void)mouseUp:(NSEvent *)event { button_mask &= ~BUTTON_MASK_LEFT; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_LEFT; - ev.mouse_button.pressed = false; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_LEFT; + ev->is_pressed() = false; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); } - (void)mouseMoved:(NSEvent *)event { - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_MOTION; - ev.mouse_motion.button_mask = button_mask; + ev->get_button_mask() = button_mask; prev_mouse_x = mouse_x; prev_mouse_y = mouse_y; const NSRect contentRect = [OS_OSX::singleton->window_view frame]; @@ -337,8 +337,8 @@ static int button_mask = 0; ev.mouse_motion.y = mouse_y; ev.mouse_motion.global_x = mouse_x; ev.mouse_motion.global_y = mouse_y; - ev.mouse_motion.relative_x = [event deltaX] * OS_OSX::singleton->_mouse_scale([[event window] backingScaleFactor]); - ev.mouse_motion.relative_y = [event deltaY] * OS_OSX::singleton->_mouse_scale([[event window] backingScaleFactor]); + ev->get_relative().x = [event deltaX] * OS_OSX::singleton->_mouse_scale([[event window] backingScaleFactor]); + ev->get_relative().y = [event deltaY] * OS_OSX::singleton->_mouse_scale([[event window] backingScaleFactor]); ev.mouse_motion.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->input->set_mouse_position(Point2(mouse_x, mouse_y)); @@ -348,15 +348,15 @@ static int button_mask = 0; - (void)rightMouseDown:(NSEvent *)event { button_mask |= BUTTON_MASK_RIGHT; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_RIGHT; - ev.mouse_button.pressed = true; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_RIGHT; + ev->is_pressed() = true; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); } @@ -368,15 +368,15 @@ static int button_mask = 0; - (void)rightMouseUp:(NSEvent *)event { button_mask &= ~BUTTON_MASK_RIGHT; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_RIGHT; - ev.mouse_button.pressed = false; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_RIGHT; + ev->is_pressed() = false; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); } @@ -387,15 +387,15 @@ static int button_mask = 0; return; button_mask |= BUTTON_MASK_MIDDLE; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_MIDDLE; - ev.mouse_button.pressed = true; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_MIDDLE; + ev->is_pressed() = true; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); } @@ -410,15 +410,15 @@ static int button_mask = 0; return; button_mask &= ~BUTTON_MASK_MIDDLE; - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = BUTTON_MIDDLE; - ev.mouse_button.pressed = false; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + ev->get_button_index() = BUTTON_MIDDLE; + ev->is_pressed() = false; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; ev.mouse_button.mod = translateFlags([event modifierFlags]); OS_OSX::singleton->push_input(ev); } @@ -610,21 +610,21 @@ static int translateKey(unsigned int key) { } - (void)keyDown:(NSEvent *)event { - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::KEY; - ev.key.pressed = true; + ev->is_pressed() = true; ev.key.mod = translateFlags([event modifierFlags]); - ev.key.scancode = latin_keyboard_keycode_convert(translateKey([event keyCode])); - ev.key.echo = [event isARepeat]; + ev->get_scancode() = latin_keyboard_keycode_convert(translateKey([event keyCode])); + ev->is_echo() = [event isARepeat]; NSString *characters = [event characters]; NSUInteger i, length = [characters length]; - if (length > 0 && keycode_has_unicode(ev.key.scancode)) { + if (length > 0 && keycode_has_unicode(ev->get_scancode())) { for (i = 0; i < length; i++) { ev.key.unicode = [characters characterAtIndex:i]; OS_OSX::singleton->push_input(ev); - ev.key.scancode = 0; + ev->get_scancode() = 0; } } else { OS_OSX::singleton->push_input(ev); @@ -632,7 +632,7 @@ static int translateKey(unsigned int key) { } - (void)flagsChanged:(NSEvent *)event { - InputEvent ev; + Ref<InputEvent> ev; int key = [event keyCode]; int mod = [event modifierFlags]; @@ -641,64 +641,64 @@ static int translateKey(unsigned int key) { if (key == 0x36 || key == 0x37) { if (mod & NSCommandKeyMask) { mod &= ~NSCommandKeyMask; - ev.key.pressed = true; + ev->is_pressed() = true; } else { - ev.key.pressed = false; + ev->is_pressed() = false; } } else if (key == 0x38 || key == 0x3c) { if (mod & NSShiftKeyMask) { mod &= ~NSShiftKeyMask; - ev.key.pressed = true; + ev->is_pressed() = true; } else { - ev.key.pressed = false; + ev->is_pressed() = false; } } else if (key == 0x3a || key == 0x3d) { if (mod & NSAlternateKeyMask) { mod &= ~NSAlternateKeyMask; - ev.key.pressed = true; + ev->is_pressed() = true; } else { - ev.key.pressed = false; + ev->is_pressed() = false; } } else if (key == 0x3b || key == 0x3e) { if (mod & NSControlKeyMask) { mod &= ~NSControlKeyMask; - ev.key.pressed = true; + ev->is_pressed() = true; } else { - ev.key.pressed = false; + ev->is_pressed() = false; } } else { return; } ev.key.mod = translateFlags(mod); - ev.key.scancode = latin_keyboard_keycode_convert(translateKey(key)); + ev->get_scancode() = latin_keyboard_keycode_convert(translateKey(key)); OS_OSX::singleton->push_input(ev); } - (void)keyUp:(NSEvent *)event { - InputEvent ev; + Ref<InputEvent> ev; ev.type = InputEvent::KEY; - ev.key.pressed = false; + ev->is_pressed() = false; ev.key.mod = translateFlags([event modifierFlags]); - ev.key.scancode = latin_keyboard_keycode_convert(translateKey([event keyCode])); + ev->get_scancode() = latin_keyboard_keycode_convert(translateKey([event keyCode])); OS_OSX::singleton->push_input(ev); } inline void sendScrollEvent(int button, double factor) { - InputEvent ev; - ev.type = InputEvent::MOUSE_BUTTON; - ev.mouse_button.button_index = button; - ev.mouse_button.factor = factor; - ev.mouse_button.pressed = true; - ev.mouse_button.x = mouse_x; - ev.mouse_button.y = mouse_y; + Ref<InputEvent> ev; + ev.type = Ref<InputEvent>::MOUSE_BUTTON; + ev->get_button_index() = button; + ev.mouse_button->get_factor() = factor; + ev->is_pressed() = true; + ev->get_pos().x = mouse_x; + ev->get_pos().y = mouse_y; ev.mouse_button.global_x = mouse_x; ev.mouse_button.global_y = mouse_y; - ev.mouse_button.button_mask = button_mask; + ev->get_button_mask() = button_mask; OS_OSX::singleton->push_input(ev); - ev.mouse_button.pressed = false; + ev->is_pressed() = false; OS_OSX::singleton->push_input(ev); } @@ -1515,9 +1515,9 @@ void OS_OSX::process_events() { autoreleasePool = [[NSAutoreleasePool alloc] init]; } -void OS_OSX::push_input(const InputEvent &p_event) { +void OS_OSX::push_input(const Ref<InputEvent> &p_event) { - InputEvent ev = p_event; + Ref<InputEvent> ev = p_event; input->parse_input_event(ev); } diff --git a/platform/uwp/app.cpp b/platform/uwp/app.cpp index 2946aa1eae..7c8f09b27b 100644 --- a/platform/uwp/app.cpp +++ b/platform/uwp/app.cpp @@ -259,10 +259,10 @@ void App::pointer_event(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Cor int but = _get_button(point); if (_is_touch(point)) { - InputEvent event; + Ref<InputEvent> event; event.type = InputEvent::SCREEN_TOUCH; event.device = 0; - event.screen_touch.pressed = p_pressed; + event.screen_touch->is_pressed() = p_pressed; event.screen_touch.x = pos.X; event.screen_touch.y = pos.Y; event.screen_touch.index = _get_finger(point->PointerId); @@ -276,21 +276,21 @@ void App::pointer_event(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Cor }; // fallthrought of sorts - InputEvent event; + Ref<InputEvent> event; event.type = InputEvent::MOUSE_BUTTON; event.device = 0; - event.mouse_button.pressed = p_pressed; - event.mouse_button.button_index = but; - event.mouse_button.x = pos.X; - event.mouse_button.y = pos.Y; + event->is_pressed() = p_pressed; + event->get_button_index() = but; + event->get_pos().x = pos.X; + event->get_pos().y = pos.Y; event.mouse_button.global_x = pos.X; event.mouse_button.global_y = pos.Y; if (p_is_wheel) { if (point->Properties->MouseWheelDelta > 0) { - event.mouse_button.button_index = point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_RIGHT : BUTTON_WHEEL_UP; + event->get_button_index() = point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_RIGHT : BUTTON_WHEEL_UP; } else if (point->Properties->MouseWheelDelta < 0) { - event.mouse_button.button_index = point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_LEFT : BUTTON_WHEEL_DOWN; + event->get_button_index() = point->Properties->IsHorizontalMouseWheel ? BUTTON_WHEEL_LEFT : BUTTON_WHEEL_DOWN; } } @@ -350,7 +350,7 @@ void App::OnPointerMoved(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Co if (point->IsInContact && _is_touch(point)) { InputEvent event; - event.type = InputEvent::SCREEN_DRAG; + event.type = Ref<InputEvent>::SCREEN_DRAG; event.device = 0; event.screen_drag.x = pos.X; event.screen_drag.y = pos.Y; @@ -369,14 +369,14 @@ void App::OnPointerMoved(Windows::UI::Core::CoreWindow ^ sender, Windows::UI::Co return; InputEvent event; - event.type = InputEvent::MOUSE_MOTION; + event.type = Ref<InputEvent>::MOUSE_MOTION; event.device = 0; event.mouse_motion.x = pos.X; event.mouse_motion.y = pos.Y; event.mouse_motion.global_x = pos.X; event.mouse_motion.global_y = pos.Y; - event.mouse_motion.relative_x = pos.X - last_touch_x[31]; - event.mouse_motion.relative_y = pos.Y - last_touch_y[31]; + event->get_relative().x = pos.X - last_touch_x[31]; + event->get_relative().y = pos.Y - last_touch_y[31]; last_mouse_pos = pos; @@ -394,14 +394,14 @@ void App::OnMouseMoved(MouseDevice ^ mouse_device, MouseEventArgs ^ args) { pos.Y = last_mouse_pos.Y + args->MouseDelta.Y; InputEvent event; - event.type = InputEvent::MOUSE_MOTION; + event.type = Ref<InputEvent>::MOUSE_MOTION; event.device = 0; event.mouse_motion.x = pos.X; event.mouse_motion.y = pos.Y; event.mouse_motion.global_x = pos.X; event.mouse_motion.global_y = pos.Y; - event.mouse_motion.relative_x = args->MouseDelta.X; - event.mouse_motion.relative_y = args->MouseDelta.Y; + event->get_relative().x = args->MouseDelta.X; + event->get_relative().y = args->MouseDelta.Y; last_mouse_pos = pos; @@ -420,20 +420,20 @@ void App::key_event(Windows::UI::Core::CoreWindow ^ sender, bool p_pressed, Wind mod.shift = sender->GetAsyncKeyState(VirtualKey::Shift) == CoreVirtualKeyStates::Down; ke.mod_state = mod; - ke.pressed = p_pressed; + ke->is_pressed() = p_pressed; if (key_args != nullptr) { ke.type = OSUWP::KeyEvent::MessageType::KEY_EVENT_MESSAGE; ke.unicode = 0; - ke.scancode = KeyMappingWindows::get_keysym((unsigned int)key_args->VirtualKey); + ke->get_scancode() = KeyMappingWindows::get_keysym((unsigned int)key_args->VirtualKey); ke.echo = (!p_pressed && !key_args->KeyStatus.IsKeyReleased) || (p_pressed && key_args->KeyStatus.WasKeyDown); } else { ke.type = OSUWP::KeyEvent::MessageType::CHAR_EVENT_MESSAGE; ke.unicode = char_args->KeyCode; - ke.scancode = 0; + ke->get_scancode() = 0; ke.echo = (!p_pressed && !char_args->KeyStatus.IsKeyReleased) || (p_pressed && char_args->KeyStatus.WasKeyDown); } diff --git a/platform/uwp/os_uwp.cpp b/platform/uwp/os_uwp.cpp index c68b2ffa33..47f4b3f3c8 100644 --- a/platform/uwp/os_uwp.cpp +++ b/platform/uwp/os_uwp.cpp @@ -330,14 +330,14 @@ String OSUWP::get_clipboard() const { return ""; }; -void OSUWP::input_event(InputEvent &p_event) { +void OSUWP::input_event(Ref<InputEvent> &p_event) { input->parse_input_event(p_event); - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index > 3) { + if (p_event.type == Ref<InputEvent>::MOUSE_BUTTON && p_event->is_pressed() && p_event->get_button_index() > 3) { //send release for mouse wheel - p_event.mouse_button.pressed = false; + p_event->is_pressed() = false; input->parse_input_event(p_event); } }; @@ -663,14 +663,14 @@ void OSUWP::process_key_events() { for (int i = 0; i < key_event_pos; i++) { KeyEvent &kev = key_event_buffer[i]; - InputEvent iev; + Ref<InputEvent> iev; - iev.type = InputEvent::KEY; + iev.type = Ref<InputEvent>::KEY; iev.key.mod = kev.mod_state; - iev.key.echo = kev.echo; - iev.key.scancode = kev.scancode; + iev->is_echo() = kev.echo; + iev->get_scancode() = kev->get_scancode(); iev.key.unicode = kev.unicode; - iev.key.pressed = kev.pressed; + iev->is_pressed() = kev->is_pressed(); input_event(iev); } diff --git a/platform/uwp/os_uwp.h b/platform/uwp/os_uwp.h index 22602e4564..d2a51aad4c 100644 --- a/platform/uwp/os_uwp.h +++ b/platform/uwp/os_uwp.h @@ -257,7 +257,7 @@ public: virtual bool get_swap_ok_cancel() { return true; } - void input_event(InputEvent &p_event); + void input_event(Ref<InputEvent> &p_event); virtual PowerState get_power_state(); virtual int get_power_seconds_left(); diff --git a/platform/windows/os_windows.cpp b/platform/windows/os_windows.cpp index 42597f79c8..ba5db05dab 100644 --- a/platform/windows/os_windows.cpp +++ b/platform/windows/os_windows.cpp @@ -215,14 +215,11 @@ bool OS_Windows::can_draw() const { void OS_Windows::_touch_event(bool p_pressed, int p_x, int p_y, int idx) { - InputEvent event; - event.type = InputEvent::SCREEN_TOUCH; - event.screen_touch.index = idx; - - event.screen_touch.pressed = p_pressed; - - event.screen_touch.x = p_x; - event.screen_touch.y = p_y; + Ref<InputEventScreenTouch> event; + event.instance(); + event->set_index(idx); + event->set_pressed(p_pressed); + event->set_pos(Vector2(p_x, p_y)); if (main_loop) { input->parse_input_event(event); @@ -231,12 +228,10 @@ void OS_Windows::_touch_event(bool p_pressed, int p_x, int p_y, int idx) { void OS_Windows::_drag_event(int p_x, int p_y, int idx) { - InputEvent event; - event.type = InputEvent::SCREEN_DRAG; - event.screen_drag.index = idx; - - event.screen_drag.x = p_x; - event.screen_drag.y = p_y; + Ref<InputEventScreenDrag> event; + event.instance(); + event->set_index(idx); + event->set_pos(Vector2(p_x, p_y)); if (main_loop) input->parse_input_event(event); @@ -367,22 +362,23 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) }; */ - InputEvent event; - event.type = InputEvent::MOUSE_MOTION; - InputEventMouseMotion &mm = event.mouse_motion; + Ref<InputEventMouseMotion> mm; + mm.instance(); + + mm->set_control((wParam & MK_CONTROL) != 0); + mm->set_shift((wParam & MK_SHIFT) != 0); + mm->set_alt(alt_mem); - mm.mod.control = (wParam & MK_CONTROL) != 0; - mm.mod.shift = (wParam & MK_SHIFT) != 0; - mm.mod.alt = alt_mem; + int bmask = 0; + bmask |= (wParam & MK_LBUTTON) ? (1 << 0) : 0; + bmask |= (wParam & MK_RBUTTON) ? (1 << 1) : 0; + bmask |= (wParam & MK_MBUTTON) ? (1 << 2) : 0; + mm->set_button_mask(bmask); - mm.button_mask |= (wParam & MK_LBUTTON) ? (1 << 0) : 0; - mm.button_mask |= (wParam & MK_RBUTTON) ? (1 << 1) : 0; - mm.button_mask |= (wParam & MK_MBUTTON) ? (1 << 2) : 0; - last_button_state = mm.button_mask; - /*mm.button_mask|=(wParam&MK_XBUTTON1)?(1<<5):0; - mm.button_mask|=(wParam&MK_XBUTTON2)?(1<<6):0;*/ - mm.x = GET_X_LPARAM(lParam); - mm.y = GET_Y_LPARAM(lParam); + last_button_state = mm->get_button_mask(); + /*mm->get_button_mask()|=(wParam&MK_XBUTTON1)?(1<<5):0; + mm->get_button_mask()|=(wParam&MK_XBUTTON2)?(1<<6):0;*/ + mm->set_pos(Vector2(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))); if (mouse_mode == MOUSE_MODE_CAPTURED) { @@ -390,35 +386,33 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) old_x = c.x; old_y = c.y; - if (Point2i(mm.x, mm.y) == c) { + if (mm->get_pos() == c) { center = c; return 0; } - Point2i ncenter(mm.x, mm.y); + Point2i ncenter = mm->get_pos(); center = ncenter; POINT pos = { (int)c.x, (int)c.y }; ClientToScreen(hWnd, &pos); SetCursorPos(pos.x, pos.y); } - input->set_mouse_position(Point2(mm.x, mm.y)); - mm.speed_x = input->get_last_mouse_speed().x; - mm.speed_y = input->get_last_mouse_speed().y; + input->set_mouse_position(mm->get_pos()); + mm->set_speed(input->get_last_mouse_speed()); if (old_invalid) { - old_x = mm.x; - old_y = mm.y; + old_x = mm->get_pos().x; + old_y = mm->get_pos().y; old_invalid = false; } - mm.relative_x = mm.x - old_x; - mm.relative_y = mm.y - old_y; - old_x = mm.x; - old_y = mm.y; + mm->set_relative(Vector2(mm->get_pos() - Vector2(old_x, old_y))); + old_x = mm->get_pos().x; + old_y = mm->get_pos().y; if (window_has_focus && main_loop) - input->parse_input_event(event); + input->parse_input_event(mm); } break; case WM_LBUTTONDOWN: @@ -447,114 +441,112 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) }; */ - InputEvent event; - event.type = InputEvent::MOUSE_BUTTON; - InputEventMouseButton &mb = event.mouse_button; + Ref<InputEventMouseButton> mb; + mb.instance(); switch (uMsg) { case WM_LBUTTONDOWN: { - mb.pressed = true; - mb.button_index = 1; + mb->set_pressed(true); + mb->set_button_index(1); } break; case WM_LBUTTONUP: { - mb.pressed = false; - mb.button_index = 1; + mb->set_pressed(false); + mb->set_button_index(1); } break; case WM_MBUTTONDOWN: { - mb.pressed = true; - mb.button_index = 3; + mb->set_pressed(true); + mb->set_button_index(3); } break; case WM_MBUTTONUP: { - mb.pressed = false; - mb.button_index = 3; + mb->set_pressed(false); + mb->set_button_index(3); } break; case WM_RBUTTONDOWN: { - mb.pressed = true; - mb.button_index = 2; + mb->set_pressed(true); + mb->set_button_index(2); } break; case WM_RBUTTONUP: { - mb.pressed = false; - mb.button_index = 2; + mb->set_pressed(false); + mb->set_button_index(2); } break; case WM_LBUTTONDBLCLK: { - mb.pressed = true; - mb.button_index = 1; - mb.doubleclick = true; + mb->set_pressed(true); + mb->set_button_index(1); + mb->set_doubleclick(true); } break; case WM_RBUTTONDBLCLK: { - mb.pressed = true; - mb.button_index = 2; - mb.doubleclick = true; + mb->set_pressed(true); + mb->set_button_index(2); + mb->set_doubleclick(true); } break; case WM_MOUSEWHEEL: { - mb.pressed = true; + mb->set_pressed(true); int motion = (short)HIWORD(wParam); if (!motion) return 0; if (motion > 0) - mb.button_index = BUTTON_WHEEL_UP; + mb->set_button_index(BUTTON_WHEEL_UP); else - mb.button_index = BUTTON_WHEEL_DOWN; + mb->set_button_index(BUTTON_WHEEL_DOWN); } break; case WM_MOUSEHWHEEL: { - mb.pressed = true; + mb->set_pressed(true); int motion = (short)HIWORD(wParam); if (!motion) return 0; if (motion < 0) { - mb.button_index = BUTTON_WHEEL_LEFT; - mb.factor = fabs((double)motion / (double)WHEEL_DELTA); + mb->set_button_index(BUTTON_WHEEL_LEFT); + mb->set_factor(fabs((double)motion / (double)WHEEL_DELTA)); } else { - mb.button_index = BUTTON_WHEEL_RIGHT; - mb.factor = fabs((double)motion / (double)WHEEL_DELTA); + mb->set_button_index(BUTTON_WHEEL_RIGHT); + mb->set_factor(fabs((double)motion / (double)WHEEL_DELTA)); } } break; /* case WM_XBUTTONDOWN: { - mb.pressed=true; - mb.button_index=(HIWORD(wParam)==XBUTTON1)?6:7; + mb->is_pressed()=true; + mb->get_button_index()=(HIWORD(wParam)==XBUTTON1)?6:7; } break; case WM_XBUTTONUP: - mb.pressed=true; - mb.button_index=(HIWORD(wParam)==XBUTTON1)?6:7; + mb->is_pressed()=true; + mb->get_button_index()=(HIWORD(wParam)==XBUTTON1)?6:7; } break;*/ default: { return 0; } } - mb.mod.control = (wParam & MK_CONTROL) != 0; - mb.mod.shift = (wParam & MK_SHIFT) != 0; - mb.mod.alt = alt_mem; - //mb.mod.alt=(wParam&MK_MENU)!=0; - mb.button_mask |= (wParam & MK_LBUTTON) ? (1 << 0) : 0; - mb.button_mask |= (wParam & MK_RBUTTON) ? (1 << 1) : 0; - mb.button_mask |= (wParam & MK_MBUTTON) ? (1 << 2) : 0; - - last_button_state = mb.button_mask; + mb->set_control((wParam & MK_CONTROL) != 0); + mb->set_shift((wParam & MK_SHIFT) != 0); + mb->set_alt(alt_mem); + //mb->get_alt()=(wParam&MK_MENU)!=0; + int bmask = 0; + bmask |= (wParam & MK_LBUTTON) ? (1 << 0) : 0; + bmask |= (wParam & MK_RBUTTON) ? (1 << 1) : 0; + bmask |= (wParam & MK_MBUTTON) ? (1 << 2) : 0; + mb->set_button_mask(bmask); + + last_button_state = mb->get_button_mask(); /* - mb.button_mask|=(wParam&MK_XBUTTON1)?(1<<5):0; - mb.button_mask|=(wParam&MK_XBUTTON2)?(1<<6):0;*/ - mb.x = GET_X_LPARAM(lParam); - mb.y = GET_Y_LPARAM(lParam); + mb->get_button_mask()|=(wParam&MK_XBUTTON1)?(1<<5):0; + mb->get_button_mask()|=(wParam&MK_XBUTTON2)?(1<<6):0;*/ + mb->set_pos(Vector2(GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam))); if (mouse_mode == MOUSE_MODE_CAPTURED) { - mb.x = old_x; - mb.y = old_y; + mb->set_pos(Vector2(old_x, old_y)); } - mb.global_x = mb.x; - mb.global_y = mb.y; + mb->set_global_pos(mb->get_pos()); if (uMsg != WM_MOUSEWHEEL) { - if (mb.pressed) { + if (mb->is_pressed()) { if (++pressrc > 0) SetCapture(hWnd); @@ -568,21 +560,21 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) } else if (mouse_mode != MOUSE_MODE_CAPTURED) { // for reasons unknown to mankind, wheel comes in screen cordinates POINT coords; - coords.x = mb.x; - coords.y = mb.y; + coords.x = mb->get_pos().x; + coords.y = mb->get_pos().y; ScreenToClient(hWnd, &coords); - mb.x = coords.x; - mb.y = coords.y; + mb->set_pos(coords); } if (main_loop) { - input->parse_input_event(event); - if (mb.pressed && mb.button_index > 3) { + input->parse_input_event(mb); + if (mb->is_pressed() && mb->get_button_index() > 3) { //send release for mouse wheel - mb.pressed = false; - input->parse_input_event(event); + Ref<InputEventMouseButton> mbd = mb->duplicate(); + mbd->set_pressed(false); + input->parse_input_event(mbd); } } } @@ -638,10 +630,10 @@ LRESULT OS_Windows::WndProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) // Make sure we don't include modifiers for the modifier key itself. KeyEvent ke; - ke.mod_state.shift = (wParam != VK_SHIFT) ? shift_mem : false; - ke.mod_state.alt = (!(wParam == VK_MENU && (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN))) ? alt_mem : false; - ke.mod_state.control = (wParam != VK_CONTROL) ? control_mem : false; - ke.mod_state.meta = meta_mem; + ke.shift = (wParam != VK_SHIFT) ? shift_mem : false; + ke.alt = (!(wParam == VK_MENU && (uMsg == WM_KEYDOWN || uMsg == WM_SYSKEYDOWN))) ? alt_mem : false; + ke.control = (wParam != VK_CONTROL) ? control_mem : false; + ke.meta = meta_mem; ke.uMsg = uMsg; if (ke.uMsg == WM_SYSKEYDOWN) @@ -777,23 +769,25 @@ void OS_Windows::process_key_events() { case WM_CHAR: { if ((i == 0 && ke.uMsg == WM_CHAR) || (i > 0 && key_event_buffer[i - 1].uMsg == WM_CHAR)) { - InputEvent event; - event.type = InputEvent::KEY; - InputEventKey &k = event.key; - - k.mod = ke.mod_state; - k.pressed = true; - k.scancode = KeyMappingWindows::get_keysym(ke.wParam); - k.unicode = ke.wParam; - if (k.unicode && gr_mem) { - k.mod.alt = false; - k.mod.control = false; + Ref<InputEventKey> k; + k.instance(); + + k->set_shift(ke.shift); + k->set_alt(ke.alt); + k->set_control(ke.control); + k->set_metakey(ke.meta); + k->set_pressed(true); + k->set_scancode(KeyMappingWindows::get_keysym(ke.wParam)); + k->set_unicode(ke.wParam); + if (k->get_unicode() && gr_mem) { + k->set_alt(false); + k->set_control(false); } - if (k.unicode < 32) - k.unicode = 0; + if (k->get_unicode() < 32) + k->set_unicode(0); - input->parse_input_event(event); + input->parse_input_event(k); } //do nothing @@ -801,27 +795,32 @@ void OS_Windows::process_key_events() { case WM_KEYUP: case WM_KEYDOWN: { - InputEvent event; - event.type = InputEvent::KEY; - InputEventKey &k = event.key; + Ref<InputEventKey> k; + k.instance(); + + k->set_shift(ke.shift); + k->set_alt(ke.alt); + k->set_control(ke.control); + k->set_metakey(ke.meta); - k.mod = ke.mod_state; - k.pressed = (ke.uMsg == WM_KEYDOWN); + k->set_pressed(ke.uMsg == WM_KEYDOWN); - k.scancode = KeyMappingWindows::get_keysym(ke.wParam); - if (i + 1 < key_event_pos && key_event_buffer[i + 1].uMsg == WM_CHAR) - k.unicode = key_event_buffer[i + 1].wParam; - if (k.unicode && gr_mem) { - k.mod.alt = false; - k.mod.control = false; + k->set_scancode(KeyMappingWindows::get_keysym(ke.wParam)); + + if (i + 1 < key_event_pos && key_event_buffer[i + 1].uMsg == WM_CHAR) { + k->set_unicode(key_event_buffer[i + 1].wParam); + } + if (k->get_unicode() && gr_mem) { + k->set_alt(false); + k->set_control(false); } - if (k.unicode < 32) - k.unicode = 0; + if (k->get_unicode() < 32) + k->set_unicode(0); - k.echo = (ke.uMsg == WM_KEYDOWN && (ke.lParam & (1 << 30))); + k->set_echo((ke.uMsg == WM_KEYDOWN && (ke.lParam & (1 << 30)))); - input->parse_input_event(event); + input->parse_input_event(k); } break; } diff --git a/platform/windows/os_windows.h b/platform/windows/os_windows.h index 4dd05928df..bd5acde417 100644 --- a/platform/windows/os_windows.h +++ b/platform/windows/os_windows.h @@ -69,6 +69,7 @@ class OS_Windows : public OS { struct KeyEvent { InputModifierState mod_state; + bool alt, shift, ctrl, meta; UINT uMsg; WPARAM wParam; LPARAM lParam; diff --git a/platform/x11/os_x11.cpp b/platform/x11/os_x11.cpp index 59ac1fed96..8534185389 100644 --- a/platform/x11/os_x11.cpp +++ b/platform/x11/os_x11.cpp @@ -958,16 +958,12 @@ void OS_X11::request_attention() { XSendEvent(x11_display, DefaultRootWindow(x11_display), False, SubstructureRedirectMask | SubstructureNotifyMask, &xev); } -InputModifierState OS_X11::get_key_modifier_state(unsigned int p_x11_state) { +void OS_X11::get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state) { - InputModifierState state; - - state.shift = (p_x11_state & ShiftMask); - state.control = (p_x11_state & ControlMask); - state.alt = (p_x11_state & Mod1Mask /*|| p_x11_state&Mod5Mask*/); //altgr should not count as alt - state.meta = (p_x11_state & Mod4Mask); - - return state; + state->set_shift((p_x11_state & ShiftMask)); + state->set_control((p_x11_state & ControlMask)); + state->set_alt((p_x11_state & Mod1Mask /*|| p_x11_state&Mod5Mask*/)); //altgr should not count as alt + state->set_metakey((p_x11_state & Mod4Mask)); } unsigned int OS_X11::get_mouse_button_state(unsigned int p_x11_state) { @@ -1099,7 +1095,10 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { //print_line("mod1: "+itos(xkeyevent->state&Mod1Mask)+" mod 5: "+itos(xkeyevent->state&Mod5Mask)); - InputModifierState state = get_key_modifier_state(xkeyevent->state); + Ref<InputEventKey> k; + k.instance(); + + get_key_modifier_state(xkeyevent->state, k); /* Phase 6, determine echo character */ @@ -1142,40 +1141,36 @@ void OS_X11::handle_key_event(XKeyEvent *p_event, bool p_echo) { /* Phase 7, send event to Window */ - InputEvent event; - event.type = InputEvent::KEY; - event.device = 0; - event.key.mod = state; - event.key.pressed = keypress; + k->set_pressed(keypress); if (keycode >= 'a' && keycode <= 'z') keycode -= 'a' - 'A'; - event.key.scancode = keycode; - event.key.unicode = unicode; - event.key.echo = p_echo; + k->set_scancode(keycode); + k->set_unicode(unicode); + k->set_echo(p_echo); - if (event.key.scancode == KEY_BACKTAB) { + if (k->get_scancode() == KEY_BACKTAB) { //make it consistent across platforms. - event.key.scancode = KEY_TAB; - event.key.mod.shift = true; + k->set_scancode(KEY_TAB); + k->set_shift(true); } //don't set mod state if modifier keys are released by themselves //else event.is_action() will not work correctly here - if (!event.key.pressed) { - if (event.key.scancode == KEY_SHIFT) - event.key.mod.shift = false; - else if (event.key.scancode == KEY_CONTROL) - event.key.mod.control = false; - else if (event.key.scancode == KEY_ALT) - event.key.mod.alt = false; - else if (event.key.scancode == KEY_META) - event.key.mod.meta = false; + if (!k->is_pressed()) { + if (k->get_scancode() == KEY_SHIFT) + k->set_shift(false); + else if (k->get_scancode() == KEY_CONTROL) + k->set_control(false); + else if (k->get_scancode() == KEY_ALT) + k->set_alt(false); + else if (k->get_scancode() == KEY_META) + k->set_metakey(false); } - //printf("key: %x\n",event.key.scancode); - input->parse_input_event(event); + //printf("key: %x\n",k->get_scancode()); + input->parse_input_event(k); } struct Property { @@ -1332,22 +1327,20 @@ void OS_X11::process_xevents() { event.xbutton.y = last_mouse_pos.y; } - InputEvent mouse_event; - mouse_event.type = InputEvent::MOUSE_BUTTON; - mouse_event.device = 0; - mouse_event.mouse_button.mod = get_key_modifier_state(event.xbutton.state); - mouse_event.mouse_button.button_mask = get_mouse_button_state(event.xbutton.state); - mouse_event.mouse_button.x = event.xbutton.x; - mouse_event.mouse_button.y = event.xbutton.y; - mouse_event.mouse_button.global_x = event.xbutton.x; - mouse_event.mouse_button.global_y = event.xbutton.y; - mouse_event.mouse_button.button_index = event.xbutton.button; - if (mouse_event.mouse_button.button_index == 2) - mouse_event.mouse_button.button_index = 3; - else if (mouse_event.mouse_button.button_index == 3) - mouse_event.mouse_button.button_index = 2; - - mouse_event.mouse_button.pressed = (event.type == ButtonPress); + Ref<InputEventMouseButton> mb; + mb.instance(); + + get_key_modifier_state(event.xbutton.state, mb); + mb->set_button_mask(get_mouse_button_state(event.xbutton.state)); + mb->set_pos(Vector2(event.xbutton.x, event.xbutton.y)); + mb->set_global_pos(mb->get_pos()); + mb->set_button_index(event.xbutton.button); + if (mb->get_button_index() == 2) + mb->set_button_index(3); + else if (mb->get_button_index() == 3) + mb->set_button_index(2); + + mb->set_pressed((event.type == ButtonPress)); if (event.type == ButtonPress && event.xbutton.button == 1) { @@ -1357,7 +1350,7 @@ void OS_X11::process_xevents() { last_click_ms = 0; last_click_pos = Point2(-100, -100); - mouse_event.mouse_button.doubleclick = true; + mb->set_doubleclick(true); } else { last_click_ms += diff; @@ -1365,7 +1358,7 @@ void OS_X11::process_xevents() { } } - input->parse_input_event(mouse_event); + input->parse_input_event(mb); } break; case MotionNotify: { @@ -1443,22 +1436,16 @@ void OS_X11::process_xevents() { Point2i rel = pos - last_mouse_pos; - InputEvent motion_event; - motion_event.type = InputEvent::MOUSE_MOTION; - motion_event.device = 0; + Ref<InputEventMouseMotion> mm; + mm.instance(); - motion_event.mouse_motion.mod = get_key_modifier_state(event.xmotion.state); - motion_event.mouse_motion.button_mask = get_mouse_button_state(event.xmotion.state); - motion_event.mouse_motion.x = pos.x; - motion_event.mouse_motion.y = pos.y; + get_key_modifier_state(event.xmotion.state, mm); + mm->set_button_mask(get_mouse_button_state(event.xmotion.state)); + mm->set_pos(pos); + mm->set_global_pos(pos); input->set_mouse_position(pos); - motion_event.mouse_motion.global_x = pos.x; - motion_event.mouse_motion.global_y = pos.y; - motion_event.mouse_motion.speed_x = input->get_last_mouse_speed().x; - motion_event.mouse_motion.speed_y = input->get_last_mouse_speed().y; - - motion_event.mouse_motion.relative_x = rel.x; - motion_event.mouse_motion.relative_y = rel.y; + mm->set_speed(input->get_last_mouse_speed()); + mm->set_relative(rel); last_mouse_pos = pos; @@ -1467,7 +1454,7 @@ void OS_X11::process_xevents() { // this is so that the relative motion doesn't get messed up // after we regain focus. if (window_has_focus || !mouse_mode_grab) - input->parse_input_event(motion_event); + input->parse_input_event(mm); } break; case KeyPress: diff --git a/platform/x11/os_x11.h b/platform/x11/os_x11.h index 7f01f9c617..d62186e5bd 100644 --- a/platform/x11/os_x11.h +++ b/platform/x11/os_x11.h @@ -121,7 +121,7 @@ class OS_X11 : public OS_Unix { PhysicsServer *physics_server; unsigned int get_mouse_button_state(unsigned int p_x11_state); - InputModifierState get_key_modifier_state(unsigned int p_x11_state); + void get_key_modifier_state(unsigned int p_x11_state, Ref<InputEventWithModifiers> state); Physics2DServer *physics_2d_server; MouseMode mouse_mode; diff --git a/scene/2d/canvas_item.cpp b/scene/2d/canvas_item.cpp index f699c8f0e8..b2258ec94b 100644 --- a/scene/2d/canvas_item.cpp +++ b/scene/2d/canvas_item.cpp @@ -688,11 +688,11 @@ Vector2 CanvasItem::make_canvas_pos_local(const Vector2 &screen_point) const { return local_matrix.xform(screen_point); } -InputEvent CanvasItem::make_input_local(const InputEvent &p_event) const { +Ref<InputEvent> CanvasItem::make_input_local(const Ref<InputEvent> &p_event) const { ERR_FAIL_COND_V(!is_inside_tree(), p_event); - return p_event.xform_by((get_canvas_transform() * get_global_transform()).affine_inverse()); + return p_event->xformed_by((get_canvas_transform() * get_global_transform()).affine_inverse()); } Vector2 CanvasItem::get_global_mouse_position() const { diff --git a/scene/2d/canvas_item.h b/scene/2d/canvas_item.h index 72fe5b93da..bea4301326 100644 --- a/scene/2d/canvas_item.h +++ b/scene/2d/canvas_item.h @@ -209,7 +209,7 @@ public: void set_use_parent_material(bool p_use_parent_material); bool get_use_parent_material() const; - InputEvent make_input_local(const InputEvent &pevent) const; + Ref<InputEvent> make_input_local(const Ref<InputEvent> &pevent) const; Vector2 make_canvas_pos_local(const Vector2 &screen_point) const; Vector2 get_global_mouse_position() const; diff --git a/scene/2d/collision_object_2d.cpp b/scene/2d/collision_object_2d.cpp index afbdfec45e..caf9cf201a 100644 --- a/scene/2d/collision_object_2d.cpp +++ b/scene/2d/collision_object_2d.cpp @@ -180,7 +180,7 @@ bool CollisionObject2D::is_pickable() const { return pickable; } -void CollisionObject2D::_input_event(Node *p_viewport, const InputEvent &p_input_event, int p_shape) { +void CollisionObject2D::_input_event(Node *p_viewport, const Ref<InputEvent> &p_input_event, int p_shape) { if (get_script_instance()) { get_script_instance()->call(SceneStringNames::get_singleton()->_input_event, p_viewport, p_input_event, p_shape); @@ -231,9 +231,9 @@ void CollisionObject2D::_bind_methods() { ClassDB::bind_method(D_METHOD("set_pickable", "enabled"), &CollisionObject2D::set_pickable); ClassDB::bind_method(D_METHOD("is_pickable"), &CollisionObject2D::is_pickable); - BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "viewport"), PropertyInfo(Variant::INPUT_EVENT, "event"), PropertyInfo(Variant::INT, "shape_idx"))); + BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "viewport"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), PropertyInfo(Variant::INT, "shape_idx"))); - ADD_SIGNAL(MethodInfo("input_event", PropertyInfo(Variant::OBJECT, "viewport"), PropertyInfo(Variant::INPUT_EVENT, "event"), PropertyInfo(Variant::INT, "shape_idx"))); + ADD_SIGNAL(MethodInfo("input_event", PropertyInfo(Variant::OBJECT, "viewport"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), PropertyInfo(Variant::INT, "shape_idx"))); ADD_SIGNAL(MethodInfo("mouse_entered")); ADD_SIGNAL(MethodInfo("mouse_exited")); diff --git a/scene/2d/collision_object_2d.h b/scene/2d/collision_object_2d.h index e3dc39feae..4d4611afd1 100644 --- a/scene/2d/collision_object_2d.h +++ b/scene/2d/collision_object_2d.h @@ -70,7 +70,7 @@ protected: void _update_pickable(); friend class Viewport; - void _input_event(Node *p_viewport, const InputEvent &p_input_event, int p_shape); + void _input_event(Node *p_viewport, const Ref<InputEvent> &p_input_event, int p_shape); void _mouse_enter(); void _mouse_exit(); diff --git a/scene/2d/screen_button.cpp b/scene/2d/screen_button.cpp index 7712108488..f503a66208 100644 --- a/scene/2d/screen_button.cpp +++ b/scene/2d/screen_button.cpp @@ -148,11 +148,6 @@ void TouchScreenButton::_notification(int p_what) { if (!get_tree()->is_editor_hint()) set_process_input(is_visible_in_tree()); - if (action.operator String() != "" && InputMap::get_singleton()->has_action(action)) { - action_id = InputMap::get_singleton()->get_action_id(action); - } else { - action_id = -1; - } } break; case NOTIFICATION_EXIT_TREE: { if (is_pressed()) @@ -184,11 +179,6 @@ bool TouchScreenButton::is_pressed() const { void TouchScreenButton::set_action(const String &p_action) { action = p_action; - if (action.operator String() != "" && InputMap::get_singleton()->has_action(action)) { - action_id = InputMap::get_singleton()->get_action_id(action); - } else { - action_id = -1; - } } String TouchScreenButton::get_action() const { @@ -196,26 +186,32 @@ String TouchScreenButton::get_action() const { return action; } -void TouchScreenButton::_input(const InputEvent &p_event) { +void TouchScreenButton::_input(const Ref<InputEvent> &p_event) { if (!get_tree()) return; - if (p_event.device != 0) + if (p_event->get_device() != 0) return; if (passby_press) { - if (p_event.type == InputEvent::SCREEN_TOUCH && !p_event.screen_touch.pressed && finger_pressed == p_event.screen_touch.index) { + Ref<InputEventScreenTouch> st = p_event; + Ref<InputEventScreenTouch> sd = p_event; + + if (st.is_valid() && !st->is_pressed() && finger_pressed == st->get_index()) { _release(); } - if ((p_event.type == InputEvent::SCREEN_TOUCH && p_event.screen_touch.pressed) || p_event.type == InputEvent::SCREEN_DRAG) { + if ((st.is_valid() && st->is_pressed()) || sd.is_valid()) { + + int index = st.is_valid() ? st->get_index() : sd->get_index(); + Vector2 coord = st.is_valid() ? st->get_pos() : sd->get_pos(); - if (finger_pressed == -1 || p_event.screen_touch.index == finger_pressed) { + if (finger_pressed == -1 || index == finger_pressed) { - Point2 coord = (get_global_transform_with_canvas()).affine_inverse().xform(Point2(p_event.screen_touch.x, p_event.screen_touch.y)); + coord = (get_global_transform_with_canvas()).affine_inverse().xform(coord); bool touched = false; if (bitmask.is_valid()) { @@ -233,7 +229,7 @@ void TouchScreenButton::_input(const InputEvent &p_event) { if (touched) { if (finger_pressed == -1) { - _press(p_event.screen_touch.index); + _press(index); } } else { if (finger_pressed != -1) { @@ -245,9 +241,11 @@ void TouchScreenButton::_input(const InputEvent &p_event) { } else { - if (p_event.type == InputEvent::SCREEN_TOUCH) { + Ref<InputEventScreenTouch> st = p_event; - if (p_event.screen_touch.pressed) { + if (st.is_valid()) { + + if (st->is_pressed()) { if (!is_visible_in_tree()) return; @@ -256,7 +254,7 @@ void TouchScreenButton::_input(const InputEvent &p_event) { if (!can_press) return; //already fingering - Point2 coord = (get_global_transform_with_canvas()).affine_inverse().xform(Point2(p_event.screen_touch.x, p_event.screen_touch.y)); + Point2 coord = (get_global_transform_with_canvas()).affine_inverse().xform(st->get_pos()); Rect2 item_rect = get_item_rect(); bool touched = false; @@ -284,10 +282,10 @@ void TouchScreenButton::_input(const InputEvent &p_event) { } if (touched) { - _press(p_event.screen_touch.index); + _press(st->get_index()); } } else { - if (p_event.screen_touch.index == finger_pressed) { + if (st->get_index() == finger_pressed) { _release(); } } @@ -299,15 +297,14 @@ void TouchScreenButton::_press(int p_finger_pressed) { finger_pressed = p_finger_pressed; - if (action_id != -1) { + if (action != StringName()) { Input::get_singleton()->action_press(action); - InputEvent ie; - ie.type = InputEvent::ACTION; - ie.ID = 0; - ie.action.action = action_id; - ie.action.pressed = true; - get_tree()->input_event(ie); + Ref<InputEventAction> iea; + iea.instance(); + iea->set_action(action); + iea->set_pressed(true); + get_tree()->input_event(iea); } emit_signal("pressed"); @@ -318,16 +315,16 @@ void TouchScreenButton::_release(bool p_exiting_tree) { finger_pressed = -1; - if (action_id != -1) { + if (action != StringName()) { Input::get_singleton()->action_release(action); if (!p_exiting_tree) { - InputEvent ie; - ie.type = InputEvent::ACTION; - ie.ID = 0; - ie.action.action = action_id; - ie.action.pressed = false; - get_tree()->input_event(ie); + + Ref<InputEventAction> iea; + iea.instance(); + iea->set_action(action); + iea->set_pressed(false); + get_tree()->input_event(iea); } } @@ -419,7 +416,6 @@ void TouchScreenButton::_bind_methods() { TouchScreenButton::TouchScreenButton() { finger_pressed = -1; - action_id = -1; passby_press = false; visibility = VISIBILITY_ALWAYS; shape_centered = true; diff --git a/scene/2d/screen_button.h b/scene/2d/screen_button.h index 0cfaf681dd..e44f556c31 100644 --- a/scene/2d/screen_button.h +++ b/scene/2d/screen_button.h @@ -58,11 +58,10 @@ private: StringName action; bool passby_press; int finger_pressed; - int action_id; VisibilityMode visibility; - void _input(const InputEvent &p_Event); + void _input(const Ref<InputEvent> &p_Event); void _press(int p_finger_pressed); void _release(bool p_exiting_tree = false); diff --git a/scene/3d/collision_object.cpp b/scene/3d/collision_object.cpp index 4dc01975b8..1b27313d3b 100644 --- a/scene/3d/collision_object.cpp +++ b/scene/3d/collision_object.cpp @@ -172,7 +172,7 @@ void CollisionObject::_get_property_list(List<PropertyInfo> *p_list) const { } } -void CollisionObject::_input_event(Node *p_camera, const InputEvent &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape) { +void CollisionObject::_input_event(Node *p_camera, const Ref<InputEvent> &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape) { if (get_script_instance()) { get_script_instance()->call(SceneStringNames::get_singleton()->_input_event, p_camera, p_input_event, p_pos, p_normal, p_shape); @@ -235,9 +235,9 @@ void CollisionObject::_bind_methods() { ClassDB::bind_method(D_METHOD("set_capture_input_on_drag", "enable"), &CollisionObject::set_capture_input_on_drag); ClassDB::bind_method(D_METHOD("get_capture_input_on_drag"), &CollisionObject::get_capture_input_on_drag); ClassDB::bind_method(D_METHOD("get_rid"), &CollisionObject::get_rid); - BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "camera"), PropertyInfo(Variant::INPUT_EVENT, "event"), PropertyInfo(Variant::VECTOR3, "click_pos"), PropertyInfo(Variant::VECTOR3, "click_normal"), PropertyInfo(Variant::INT, "shape_idx"))); + BIND_VMETHOD(MethodInfo("_input_event", PropertyInfo(Variant::OBJECT, "camera"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), PropertyInfo(Variant::VECTOR3, "click_pos"), PropertyInfo(Variant::VECTOR3, "click_normal"), PropertyInfo(Variant::INT, "shape_idx"))); - ADD_SIGNAL(MethodInfo("input_event", PropertyInfo(Variant::OBJECT, "camera"), PropertyInfo(Variant::INPUT_EVENT, "event"), PropertyInfo(Variant::VECTOR3, "click_pos"), PropertyInfo(Variant::VECTOR3, "click_normal"), PropertyInfo(Variant::INT, "shape_idx"))); + ADD_SIGNAL(MethodInfo("input_event", PropertyInfo(Variant::OBJECT, "camera"), PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), PropertyInfo(Variant::VECTOR3, "click_pos"), PropertyInfo(Variant::VECTOR3, "click_normal"), PropertyInfo(Variant::INT, "shape_idx"))); ADD_SIGNAL(MethodInfo("mouse_entered")); ADD_SIGNAL(MethodInfo("mouse_exited")); diff --git a/scene/3d/collision_object.h b/scene/3d/collision_object.h index abe0b804bf..3822fb0d5a 100644 --- a/scene/3d/collision_object.h +++ b/scene/3d/collision_object.h @@ -70,7 +70,7 @@ protected: void _get_property_list(List<PropertyInfo> *p_list) const; static void _bind_methods(); friend class Viewport; - virtual void _input_event(Node *p_camera, const InputEvent &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape); + virtual void _input_event(Node *p_camera, const Ref<InputEvent> &p_input_event, const Vector3 &p_pos, const Vector3 &p_normal, int p_shape); virtual void _mouse_enter(); virtual void _mouse_exit(); diff --git a/scene/gui/base_button.cpp b/scene/gui/base_button.cpp index 839dcc3678..318db8458b 100644 --- a/scene/gui/base_button.cpp +++ b/scene/gui/base_button.cpp @@ -48,188 +48,185 @@ void BaseButton::_unpress_group() { } } -void BaseButton::_gui_input(InputEvent p_event) { +void BaseButton::_gui_input(Ref<InputEvent> p_event) { if (status.disabled) // no interaction with disabled button return; - switch (p_event.type) { + Ref<InputEventMouseButton> b = p_event; - case InputEvent::MOUSE_BUTTON: { + if (b.is_valid()) { + if (status.disabled || b->get_button_index() != 1) + return; - const InputEventMouseButton &b = p_event.mouse_button; + if (status.pressing_button) + return; - if (status.disabled || b.button_index != 1) - return; + if (action_mode == ACTION_MODE_BUTTON_PRESS) { - if (status.pressing_button) - break; + if (b->is_pressed()) { - if (action_mode == ACTION_MODE_BUTTON_PRESS) { - - if (b.pressed) { - - emit_signal("button_down"); - - if (!toggle_mode) { //mouse press attempt + emit_signal("button_down"); - status.press_attempt = true; - status.pressing_inside = true; + if (!toggle_mode) { //mouse press attempt - pressed(); - if (get_script_instance()) { - Variant::CallError ce; - get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); - } + status.press_attempt = true; + status.pressing_inside = true; - emit_signal("pressed"); - _unpress_group(); + pressed(); + if (get_script_instance()) { + Variant::CallError ce; + get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); + } - } else { + emit_signal("pressed"); + _unpress_group(); - status.pressed = !status.pressed; - pressed(); - if (get_script_instance()) { - Variant::CallError ce; - get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); - } - emit_signal("pressed"); - _unpress_group(); + } else { - toggled(status.pressed); - emit_signal("toggled", status.pressed); + status.pressed = !status.pressed; + pressed(); + if (get_script_instance()) { + Variant::CallError ce; + get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); } + emit_signal("pressed"); + _unpress_group(); - } else { + toggled(status.pressed); + emit_signal("toggled", status.pressed); + } + + } else { - emit_signal("button_up"); + emit_signal("button_up"); - /* this is pointless if (status.press_attempt && status.pressing_inside) { - //released(); - emit_signal("released"); - } -*/ - status.press_attempt = false; + /* this is pointless if (status.press_attempt && status.pressing_inside) { + //released(); + emit_signal("released"); } - update(); - break; +*/ + status.press_attempt = false; } + update(); + return; + } - if (b.pressed) { + if (b->is_pressed()) { - status.press_attempt = true; - status.pressing_inside = true; - emit_signal("button_down"); + status.press_attempt = true; + status.pressing_inside = true; + emit_signal("button_down"); - } else { + } else { - emit_signal("button_up"); + emit_signal("button_up"); - if (status.press_attempt && status.pressing_inside) { + if (status.press_attempt && status.pressing_inside) { - if (!toggle_mode) { //mouse press attempt + if (!toggle_mode) { //mouse press attempt - pressed(); - if (get_script_instance()) { - Variant::CallError ce; - get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); - } + pressed(); + if (get_script_instance()) { + Variant::CallError ce; + get_script_instance()->call(SceneStringNames::get_singleton()->_pressed, NULL, 0, ce); + } - emit_signal("pressed"); + emit_signal("pressed"); - } else { + } else { - status.pressed = !status.pressed; + status.pressed = !status.pressed; - pressed(); - emit_signal("pressed"); + pressed(); + emit_signal("pressed"); - toggled(status.pressed); - emit_signal("toggled", status.pressed); - if (get_script_instance()) { - get_script_instance()->call(SceneStringNames::get_singleton()->_toggled, status.pressed); - } + toggled(status.pressed); + emit_signal("toggled", status.pressed); + if (get_script_instance()) { + get_script_instance()->call(SceneStringNames::get_singleton()->_toggled, status.pressed); } - - _unpress_group(); } - status.press_attempt = false; + _unpress_group(); } - update(); - } break; - case InputEvent::MOUSE_MOTION: { - - if (status.press_attempt && status.pressing_button == 0) { - bool last_press_inside = status.pressing_inside; - status.pressing_inside = has_point(Point2(p_event.mouse_motion.x, p_event.mouse_motion.y)); - if (last_press_inside != status.pressing_inside) - update(); - } - } break; - case InputEvent::ACTION: - case InputEvent::JOYPAD_BUTTON: - case InputEvent::KEY: { + status.press_attempt = false; + } - if (p_event.is_echo()) { - break; - } + update(); + } - if (status.disabled) { - break; - } + Ref<InputEventMouseMotion> mm = p_event; - if (status.press_attempt && status.pressing_button == 0) { - break; - } + if (mm.is_valid()) { + if (status.press_attempt && status.pressing_button == 0) { + bool last_press_inside = status.pressing_inside; + status.pressing_inside = has_point(mm->get_pos()); + if (last_press_inside != status.pressing_inside) + update(); + } + } - if (p_event.is_action("ui_accept")) { + if (!mm.is_valid() && !b.is_valid()) { - if (p_event.is_pressed()) { + if (p_event->is_echo()) { + return; + } - status.pressing_button++; - status.press_attempt = true; - status.pressing_inside = true; - emit_signal("button_down"); + if (status.disabled) { + return; + } - } else if (status.press_attempt) { + if (status.press_attempt && status.pressing_button == 0) { + return; + } - if (status.pressing_button) - status.pressing_button--; + if (p_event->is_action("ui_accept")) { - if (status.pressing_button) - break; + if (p_event->is_pressed()) { - status.press_attempt = false; - status.pressing_inside = false; + status.pressing_button++; + status.press_attempt = true; + status.pressing_inside = true; + emit_signal("button_down"); - emit_signal("button_up"); + } else if (status.press_attempt) { - if (!toggle_mode) { //mouse press attempt + if (status.pressing_button) + status.pressing_button--; - pressed(); - emit_signal("pressed"); - } else { + if (status.pressing_button) + return; - status.pressed = !status.pressed; + status.press_attempt = false; + status.pressing_inside = false; - pressed(); - emit_signal("pressed"); + emit_signal("button_up"); - toggled(status.pressed); - if (get_script_instance()) { - get_script_instance()->call(SceneStringNames::get_singleton()->_toggled, status.pressed); - } - emit_signal("toggled", status.pressed); - } + if (!toggle_mode) { //mouse press attempt - _unpress_group(); + pressed(); + emit_signal("pressed"); + } else { + + status.pressed = !status.pressed; + + pressed(); + emit_signal("pressed"); + + toggled(status.pressed); + if (get_script_instance()) { + get_script_instance()->call(SceneStringNames::get_singleton()->_toggled, status.pressed); + } + emit_signal("toggled", status.pressed); } - accept_event(); - update(); + _unpress_group(); } + + accept_event(); + update(); } } } @@ -430,9 +427,9 @@ Ref<ShortCut> BaseButton::get_shortcut() const { return shortcut; } -void BaseButton::_unhandled_input(InputEvent p_event) { +void BaseButton::_unhandled_input(Ref<InputEvent> p_event) { - if (!is_disabled() && is_visible_in_tree() && p_event.is_pressed() && !p_event.is_echo() && shortcut.is_valid() && shortcut->is_shortcut(p_event)) { + if (!is_disabled() && is_visible_in_tree() && p_event->is_pressed() && !p_event->is_echo() && shortcut.is_valid() && shortcut->is_shortcut(p_event)) { if (get_viewport()->get_modal_stack_top() && !get_viewport()->get_modal_stack_top()->is_a_parent_of(this)) return; //ignore because of modal window diff --git a/scene/gui/base_button.h b/scene/gui/base_button.h index 62b6633bfc..dfcf3b0f8a 100644 --- a/scene/gui/base_button.h +++ b/scene/gui/base_button.h @@ -73,8 +73,8 @@ protected: virtual void pressed(); virtual void toggled(bool p_pressed); static void _bind_methods(); - virtual void _gui_input(InputEvent p_event); - virtual void _unhandled_input(InputEvent p_event); + virtual void _gui_input(Ref<InputEvent> p_event); + virtual void _unhandled_input(Ref<InputEvent> p_event); void _notification(int p_what); public: diff --git a/scene/gui/button_array.cpp b/scene/gui/button_array.cpp index eccf3ea64a..0d518059c8 100644 --- a/scene/gui/button_array.cpp +++ b/scene/gui/button_array.cpp @@ -287,12 +287,12 @@ void ButtonArray::_notification(int p_what) { } } -void ButtonArray::_gui_input(const InputEvent &p_event) { +void ButtonArray::_gui_input(const Ref<InputEvent> &p_event) { if ( - ((orientation == HORIZONTAL && p_event.is_action("ui_left")) || - (orientation == VERTICAL && p_event.is_action("ui_up"))) && - p_event.is_pressed() && selected > 0) { + ((orientation == HORIZONTAL && p_event->is_action("ui_left")) || + (orientation == VERTICAL && p_event->is_action("ui_up"))) && + p_event->is_pressed() && selected > 0) { set_selected(selected - 1); accept_event(); emit_signal("button_selected", selected); @@ -300,18 +300,20 @@ void ButtonArray::_gui_input(const InputEvent &p_event) { } if ( - ((orientation == HORIZONTAL && p_event.is_action("ui_right")) || - (orientation == VERTICAL && p_event.is_action("ui_down"))) && - p_event.is_pressed() && selected < (buttons.size() - 1)) { + ((orientation == HORIZONTAL && p_event->is_action("ui_right")) || + (orientation == VERTICAL && p_event->is_action("ui_down"))) && + p_event->is_pressed() && selected < (buttons.size() - 1)) { set_selected(selected + 1); accept_event(); emit_signal("button_selected", selected); return; } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; - int ofs = orientation == HORIZONTAL ? p_event.mouse_button.x : p_event.mouse_button.y; + if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { + + int ofs = orientation == HORIZONTAL ? mb->get_pos().x : mb->get_pos().y; for (int i = 0; i < buttons.size(); i++) { @@ -324,9 +326,11 @@ void ButtonArray::_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { - int ofs = orientation == HORIZONTAL ? p_event.mouse_motion.x : p_event.mouse_motion.y; + int ofs = orientation == HORIZONTAL ? mm->get_pos().x : mm->get_pos().y; int new_hover = -1; for (int i = 0; i < buttons.size(); i++) { diff --git a/scene/gui/button_array.h b/scene/gui/button_array.h index f2f7bea9c6..0ebf681cb6 100644 --- a/scene/gui/button_array.h +++ b/scene/gui/button_array.h @@ -76,7 +76,7 @@ protected: static void _bind_methods(); public: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void set_align(Align p_align); Align get_align() const; diff --git a/scene/gui/color_picker.cpp b/scene/gui/color_picker.cpp index 264ee6297e..67d440ca67 100644 --- a/scene/gui/color_picker.cpp +++ b/scene/gui/color_picker.cpp @@ -297,13 +297,15 @@ void ColorPicker::_hsv_draw(int p_wich, Control *c) { } } -void ColorPicker::_uv_input(const InputEvent &ev) { - if (ev.type == InputEvent::MOUSE_BUTTON) { - const InputEventMouseButton &bev = ev.mouse_button; - if (bev.pressed && bev.button_index == BUTTON_LEFT) { +void ColorPicker::_uv_input(const Ref<InputEvent> &ev) { + + Ref<InputEventMouseButton> bev = ev; + + if (bev.is_valid()) { + if (bev->is_pressed() && bev->get_button_index() == BUTTON_LEFT) { changing_color = true; - float x = CLAMP((float)bev.x, 0, 256); - float y = CLAMP((float)bev.y, 0, 256); + float x = CLAMP((float)bev->get_pos().x, 0, 256); + float y = CLAMP((float)bev->get_pos().y, 0, 256); s = x / 256; v = 1.0 - y / 256.0; color.set_hsv(h, s, v, color.a); @@ -314,12 +316,15 @@ void ColorPicker::_uv_input(const InputEvent &ev) { } else { changing_color = false; } - } else if (ev.type == InputEvent::MOUSE_MOTION) { - const InputEventMouse &bev = ev.mouse_motion; + } + + Ref<InputEventMouseMotion> mev = ev; + + if (mev.is_valid()) { if (!changing_color) return; - float x = CLAMP((float)bev.x, 0, 256); - float y = CLAMP((float)bev.y, 0, 256); + float x = CLAMP((float)mev->get_pos().x, 0, 256); + float y = CLAMP((float)mev->get_pos().y, 0, 256); s = x / 256; v = 1.0 - y / 256.0; color.set_hsv(h, s, v, color.a); @@ -330,12 +335,15 @@ void ColorPicker::_uv_input(const InputEvent &ev) { } } -void ColorPicker::_w_input(const InputEvent &ev) { - if (ev.type == InputEvent::MOUSE_BUTTON) { - const InputEventMouseButton &bev = ev.mouse_button; - if (bev.pressed && bev.button_index == BUTTON_LEFT) { +void ColorPicker::_w_input(const Ref<InputEvent> &ev) { + + Ref<InputEventMouseButton> bev = ev; + + if (bev.is_valid()) { + + if (bev->is_pressed() && bev->get_button_index() == BUTTON_LEFT) { changing_color = true; - h = 1 - ((float)bev.y) / 256.0; + h = 1 - ((float)bev->get_pos().y) / 256.0; } else { changing_color = false; @@ -345,11 +353,15 @@ void ColorPicker::_w_input(const InputEvent &ev) { set_pick_color(color); _update_color(); emit_signal("color_changed", color); - } else if (ev.type == InputEvent::MOUSE_MOTION) { - const InputEventMouse &bev = ev.mouse_motion; + } + + Ref<InputEventMouseMotion> mev = ev; + + if (mev.is_valid()) { + if (!changing_color) return; - float y = CLAMP((float)bev.y, 0, 256); + float y = CLAMP((float)bev->get_pos().y, 0, 256); h = 1.0 - y / 256.0; color.set_hsv(h, s, v, color.a); last_hsv = color; @@ -359,23 +371,30 @@ void ColorPicker::_w_input(const InputEvent &ev) { } } -void ColorPicker::_preset_input(const InputEvent &ev) { - if (ev.type == InputEvent::MOUSE_BUTTON) { - const InputEventMouseButton &bev = ev.mouse_button; - if (bev.pressed && bev.button_index == BUTTON_LEFT) { - int index = bev.x / (preset->get_size().x / presets.size()); +void ColorPicker::_preset_input(const Ref<InputEvent> &ev) { + + Ref<InputEventMouseButton> bev = ev; + + if (bev.is_valid()) { + + if (bev->is_pressed() && bev->get_button_index() == BUTTON_LEFT) { + int index = bev->get_pos().x / (preset->get_size().x / presets.size()); set_pick_color(presets[index]); - } else if (bev.pressed && bev.button_index == BUTTON_RIGHT) { - int index = bev.x / (preset->get_size().x / presets.size()); + } else if (bev->is_pressed() && bev->get_button_index() == BUTTON_RIGHT) { + int index = bev->get_pos().x / (preset->get_size().x / presets.size()); presets.erase(presets[index]); _update_presets(); bt_add_preset->show(); } _update_color(); emit_signal("color_changed", color); - } else if (ev.type == InputEvent::MOUSE_MOTION) { - const InputEventMouse &mev = ev.mouse_motion; - int index = mev.x * presets.size(); + } + + Ref<InputEventMouseMotion> mev = ev; + + if (mev.is_valid()) { + + int index = mev->get_pos().x * presets.size(); if (preset->get_size().x != 0) { index /= preset->get_size().x; } @@ -387,17 +406,23 @@ void ColorPicker::_preset_input(const InputEvent &ev) { } } -void ColorPicker::_screen_input(const InputEvent &ev) { - if (ev.type == InputEvent::MOUSE_BUTTON) { - const InputEventMouseButton &bev = ev.mouse_button; - if (bev.button_index == BUTTON_LEFT && !bev.pressed) { +void ColorPicker::_screen_input(const Ref<InputEvent> &ev) { + + Ref<InputEventMouseButton> bev = ev; + + if (bev.is_valid()) { + + if (bev->get_button_index() == BUTTON_LEFT && !bev->is_pressed()) { emit_signal("color_changed", color); screen->hide(); } - } else if (ev.type == InputEvent::MOUSE_MOTION) { - const InputEventMouse &mev = ev.mouse_motion; + } + + Ref<InputEventMouseMotion> mev = ev; + + if (mev.is_valid()) { Viewport *r = get_tree()->get_root(); - if (!r->get_visible_rect().has_point(Point2(mev.global_x, mev.global_y))) + if (!r->get_visible_rect().has_point(Point2(mev->get_global_pos().x, mev->get_global_pos().y))) return; Ref<Image> img = r->get_screen_capture(); if (!img.is_null()) { @@ -406,7 +431,7 @@ void ColorPicker::_screen_input(const InputEvent &ev) { } if (last_capture.is_valid() && !last_capture->empty()) { int pw = last_capture->get_format() == Image::FORMAT_RGBA8 ? 4 : 3; - int ofs = (mev.global_y * last_capture->get_width() + mev.global_x) * pw; + int ofs = (mev->get_global_pos().y * last_capture->get_width() + mev->get_global_pos().x) * pw; PoolVector<uint8_t>::Read r = last_capture->get_data().read(); diff --git a/scene/gui/color_picker.h b/scene/gui/color_picker.h index 437a491b54..ca47c3a5f4 100644 --- a/scene/gui/color_picker.h +++ b/scene/gui/color_picker.h @@ -82,10 +82,10 @@ private: void _sample_draw(); void _hsv_draw(int p_wich, Control *c); - void _uv_input(const InputEvent &p_input); - void _w_input(const InputEvent &p_input); - void _preset_input(const InputEvent &p_input); - void _screen_input(const InputEvent &p_input); + void _uv_input(const Ref<InputEvent> &p_input); + void _w_input(const Ref<InputEvent> &p_input); + void _preset_input(const Ref<InputEvent> &p_input); + void _screen_input(const Ref<InputEvent> &p_input); void _add_preset_pressed(); void _screen_pick_pressed(); diff --git a/scene/gui/color_ramp_edit.cpp b/scene/gui/color_ramp_edit.cpp index a0fd2dd33c..9270b97e02 100644 --- a/scene/gui/color_ramp_edit.cpp +++ b/scene/gui/color_ramp_edit.cpp @@ -71,9 +71,11 @@ void ColorRampEdit::_show_color_picker() { ColorRampEdit::~ColorRampEdit() { } -void ColorRampEdit::_gui_input(const InputEvent &p_event) { +void ColorRampEdit::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && p_event.key.pressed && p_event.key.scancode == KEY_DELETE && grabbed != -1) { + Ref<InputEventKey> k = p_event; + + if (k.is_valid() && k->is_pressed() && k->get_scancode() == KEY_DELETE && grabbed != -1) { points.remove(grabbed); grabbed = -1; @@ -83,16 +85,17 @@ void ColorRampEdit::_gui_input(const InputEvent &p_event) { accept_event(); } + Ref<InputEventMouseButton> mb = p_event; //Show color picker on double click. - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.doubleclick && p_event.mouse_button.pressed) { - grabbed = _get_point_from_pos(p_event.mouse_button.x); + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_doubleclick() && mb->is_pressed()) { + grabbed = _get_point_from_pos(mb->get_pos().x); _show_color_picker(); accept_event(); } //Delete point on right click - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 2 && p_event.mouse_button.pressed) { - grabbed = _get_point_from_pos(p_event.mouse_button.x); + if (mb.is_valid() && mb->get_button_index() == 2 && mb->is_pressed()) { + grabbed = _get_point_from_pos(mb->get_pos().x); if (grabbed != -1) { points.remove(grabbed); grabbed = -1; @@ -104,9 +107,9 @@ void ColorRampEdit::_gui_input(const InputEvent &p_event) { } //Hold alt key to duplicate selected color - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed && p_event.key.mod.alt) { + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed() && mb->get_alt()) { - int x = p_event.mouse_button.x; + int x = mb->get_pos().x; grabbed = _get_point_from_pos(x); if (grabbed != -1) { @@ -128,10 +131,10 @@ void ColorRampEdit::_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { update(); - int x = p_event.mouse_button.x; + int x = mb->get_pos().x; int total_w = get_size().width - get_size().height - 3; //Check if color selector was clicked. @@ -196,7 +199,7 @@ void ColorRampEdit::_gui_input(const InputEvent &p_event) { emit_signal("ramp_changed"); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == 1 && !p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && !mb->is_pressed()) { if (grabbing) { grabbing = false; @@ -205,15 +208,18 @@ void ColorRampEdit::_gui_input(const InputEvent &p_event) { update(); } - if (p_event.type == InputEvent::MOUSE_MOTION && grabbing) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid() && grabbing) { int total_w = get_size().width - get_size().height - 3; - int x = p_event.mouse_motion.x; + int x = mm->get_pos().x; + float newofs = CLAMP(x / float(total_w), 0, 1); //Snap to nearest point if holding shift - if (p_event.key.mod.shift) { + if (mm->get_shift()) { float snap_treshhold = 0.03; float smallest_ofs = snap_treshhold; bool founded = false; diff --git a/scene/gui/color_ramp_edit.h b/scene/gui/color_ramp_edit.h index 38176d2e77..ede8954040 100644 --- a/scene/gui/color_ramp_edit.h +++ b/scene/gui/color_ramp_edit.h @@ -56,7 +56,7 @@ class ColorRampEdit : public Control { void _show_color_picker(); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); static void _bind_methods(); diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp index e62a993651..1263dc91be 100644 --- a/scene/gui/control.cpp +++ b/scene/gui/control.cpp @@ -2419,7 +2419,7 @@ void Control::_bind_methods() { ClassDB::bind_method(D_METHOD("_font_changed"), &Control::_font_changed); - BIND_VMETHOD(MethodInfo("_gui_input", PropertyInfo(Variant::INPUT_EVENT, "event"))); + BIND_VMETHOD(MethodInfo("_gui_input", PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); BIND_VMETHOD(MethodInfo(Variant::VECTOR2, "_get_minimum_size")); BIND_VMETHOD(MethodInfo(Variant::OBJECT, "get_drag_data", PropertyInfo(Variant::VECTOR2, "pos"))); BIND_VMETHOD(MethodInfo(Variant::BOOL, "can_drop_data", PropertyInfo(Variant::VECTOR2, "pos"), PropertyInfo(Variant::NIL, "data"))); @@ -2507,7 +2507,7 @@ void Control::_bind_methods() { BIND_CONSTANT(MOUSE_FILTER_IGNORE); ADD_SIGNAL(MethodInfo("resized")); - ADD_SIGNAL(MethodInfo("gui_input", PropertyInfo(Variant::INPUT_EVENT, "ev"))); + ADD_SIGNAL(MethodInfo("gui_input", PropertyInfo(Variant::OBJECT, "ev", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); ADD_SIGNAL(MethodInfo("mouse_entered")); ADD_SIGNAL(MethodInfo("mouse_exited")); ADD_SIGNAL(MethodInfo("focus_entered")); diff --git a/scene/gui/dialogs.cpp b/scene/gui/dialogs.cpp index 053be515ac..627bc96fb1 100644 --- a/scene/gui/dialogs.cpp +++ b/scene/gui/dialogs.cpp @@ -105,29 +105,33 @@ bool WindowDialog::has_point(const Point2 &p_point) const { return r.has_point(p_point); } -void WindowDialog::_gui_input(const InputEvent &p_event) { +void WindowDialog::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; - if (p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT) { + + if (mb->is_pressed()) { // Begin a possible dragging operation. - drag_type = _drag_hit_test(Point2(p_event.mouse_button.x, p_event.mouse_button.y)); + drag_type = _drag_hit_test(Point2(mb->get_pos().x, mb->get_pos().y)); if (drag_type != DRAG_NONE) drag_offset = get_global_mouse_position() - get_position(); drag_offset_far = get_position() + get_size() - get_global_mouse_position(); - } else if (drag_type != DRAG_NONE && !p_event.mouse_button.pressed) { + } else if (drag_type != DRAG_NONE && !mb->is_pressed()) { // End a dragging operation. drag_type = DRAG_NONE; } } - if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid()) { if (drag_type == DRAG_NONE) { // Update the cursor while moving along the borders. CursorShape cursor = CURSOR_ARROW; if (resizable) { - int preview_drag_type = _drag_hit_test(Point2(p_event.mouse_button.x, p_event.mouse_button.y)); + int preview_drag_type = _drag_hit_test(Point2(mm->get_pos().x, mm->get_pos().y)); switch (preview_drag_type) { case DRAG_RESIZE_TOP: case DRAG_RESIZE_BOTTOM: diff --git a/scene/gui/dialogs.h b/scene/gui/dialogs.h index 2365df3d79..9d8f113caa 100644 --- a/scene/gui/dialogs.h +++ b/scene/gui/dialogs.h @@ -60,7 +60,7 @@ class WindowDialog : public Popup { Point2 drag_offset_far; bool resizable; - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _closed(); int _drag_hit_test(const Point2 &pos) const; diff --git a/scene/gui/file_dialog.cpp b/scene/gui/file_dialog.cpp index 391b39443d..3527b834c7 100644 --- a/scene/gui/file_dialog.cpp +++ b/scene/gui/file_dialog.cpp @@ -61,21 +61,20 @@ void FileDialog::_notification(int p_what) { } } -void FileDialog::_unhandled_input(const InputEvent &p_event) { +void FileDialog::_unhandled_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::KEY && is_window_modal_on_top()) { + Ref<InputEventKey> k = p_event; + if (k.is_valid() && is_window_modal_on_top()) { - const InputEventKey &k = p_event.key; - - if (k.pressed) { + if (k->is_pressed()) { bool handled = true; - switch (k.scancode) { + switch (k->get_scancode()) { case KEY_H: { - if (k.mod.command) { + if (k->get_command()) { set_show_hidden_files(!show_hidden_files); } else { handled = false; diff --git a/scene/gui/file_dialog.h b/scene/gui/file_dialog.h index 2afd0227c6..9873a677b2 100644 --- a/scene/gui/file_dialog.h +++ b/scene/gui/file_dialog.h @@ -115,7 +115,7 @@ private: void _update_drives(); - void _unhandled_input(const InputEvent &p_event); + void _unhandled_input(const Ref<InputEvent> &p_event); virtual void _post_popup(); diff --git a/scene/gui/graph_edit.cpp b/scene/gui/graph_edit.cpp index cfa09f538d..c52cdd9325 100644 --- a/scene/gui/graph_edit.cpp +++ b/scene/gui/graph_edit.cpp @@ -367,13 +367,14 @@ bool GraphEdit::_filter_input(const Point2 &p_point) { return false; } -void GraphEdit::_top_layer_input(const InputEvent &p_ev) { +void GraphEdit::_top_layer_input(const Ref<InputEvent> &p_ev) { float grab_r_extend = 2.0; - if (p_ev.type == InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index == BUTTON_LEFT && p_ev.mouse_button.pressed) { + Ref<InputEventMouseButton> mb = p_ev; + if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && mb->is_pressed()) { Ref<Texture> port = get_icon("port", "GraphNode"); - Vector2 mpos(p_ev.mouse_button.x, p_ev.mouse_button.y); + Vector2 mpos(mb->get_pos().x, mb->get_pos().y); float grab_r = port->get_width() * 0.5 * grab_r_extend; for (int i = get_child_count() - 1; i >= 0; i--) { @@ -479,14 +480,15 @@ void GraphEdit::_top_layer_input(const InputEvent &p_ev) { } } - if (p_ev.type == InputEvent::MOUSE_MOTION && connecting) { + Ref<InputEventMouseMotion> mm = p_ev; + if (mm.is_valid() && connecting) { - connecting_to = Vector2(p_ev.mouse_motion.x, p_ev.mouse_motion.y); + connecting_to = mm->get_pos(); connecting_target = false; top_layer->update(); Ref<Texture> port = get_icon("port", "GraphNode"); - Vector2 mpos(p_ev.mouse_button.x, p_ev.mouse_button.y); + Vector2 mpos = mm->get_pos(); float grab_r = port->get_width() * 0.5 * grab_r_extend; for (int i = get_child_count() - 1; i >= 0; i--) { @@ -526,7 +528,7 @@ void GraphEdit::_top_layer_input(const InputEvent &p_ev) { } } - if (p_ev.type == InputEvent::MOUSE_BUTTON && p_ev.mouse_button.button_index == BUTTON_LEFT && !p_ev.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && !mb->is_pressed()) { if (connecting && connecting_target) { @@ -544,7 +546,7 @@ void GraphEdit::_top_layer_input(const InputEvent &p_ev) { } else if (!just_disconected) { String from = connecting_from; int from_slot = connecting_index; - Vector2 ofs = Vector2(p_ev.mouse_button.x, p_ev.mouse_button.y); + Vector2 ofs = Vector2(mb->get_pos().x, mb->get_pos().y); emit_signal("connection_to_empty", from, from_slot, ofs); } connecting = false; @@ -739,18 +741,19 @@ void GraphEdit::set_selected(Node *p_child) { } } -void GraphEdit::_gui_input(const InputEvent &p_ev) { +void GraphEdit::_gui_input(const Ref<InputEvent> &p_ev) { - if (p_ev.type == InputEvent::MOUSE_MOTION && (p_ev.mouse_motion.button_mask & BUTTON_MASK_MIDDLE || (p_ev.mouse_motion.button_mask & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE)))) { - h_scroll->set_value(h_scroll->get_value() - p_ev.mouse_motion.relative_x); - v_scroll->set_value(v_scroll->get_value() - p_ev.mouse_motion.relative_y); + Ref<InputEventMouseMotion> mm = p_ev; + if (mm.is_valid() && (mm->get_button_mask() & BUTTON_MASK_MIDDLE || (mm->get_button_mask() & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE)))) { + h_scroll->set_value(h_scroll->get_value() - mm->get_relative().x); + v_scroll->set_value(v_scroll->get_value() - mm->get_relative().y); } - if (p_ev.type == InputEvent::MOUSE_MOTION && dragging) { + if (mm.is_valid() && dragging) { just_selected = true; // TODO: Remove local mouse pos hack if/when InputEventMouseMotion is fixed to support floats - //drag_accum+=Vector2(p_ev.mouse_motion.relative_x,p_ev.mouse_motion.relative_y); + //drag_accum+=Vector2(mm->get_relative().x,mm->get_relative().y); drag_accum = get_local_mouse_pos() - drag_origin; for (int i = get_child_count() - 1; i >= 0; i--) { GraphNode *gn = get_child(i)->cast_to<GraphNode>(); @@ -767,7 +770,7 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { } } - if (p_ev.type == InputEvent::MOUSE_MOTION && box_selecting) { + if (mm.is_valid() && box_selecting) { box_selecting_to = get_local_mouse_pos(); box_selecting_rect = Rect2(MIN(box_selecting_from.x, box_selecting_to.x), @@ -794,11 +797,10 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { top_layer->update(); } - if (p_ev.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> b = p_ev; + if (b.is_valid()) { - const InputEventMouseButton &b = p_ev.mouse_button; - - if (b.button_index == BUTTON_RIGHT && b.pressed) { + if (b->get_button_index() == BUTTON_RIGHT && b->is_pressed()) { if (box_selecting) { box_selecting = false; for (int i = get_child_count() - 1; i >= 0; i--) { @@ -815,12 +817,12 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { connecting = false; top_layer->update(); } else { - emit_signal("popup_request", Vector2(b.global_x, b.global_y)); + emit_signal("popup_request", b->get_global_pos()); } } } - if (b.button_index == BUTTON_LEFT && !b.pressed && dragging) { + if (b->get_button_index() == BUTTON_LEFT && !b->is_pressed() && dragging) { if (!just_selected && drag_accum == Vector2() && Input::get_singleton()->is_key_pressed(KEY_CONTROL)) { //deselect current node for (int i = get_child_count() - 1; i >= 0; i--) { @@ -855,7 +857,7 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { connections_layer->update(); } - if (b.button_index == BUTTON_LEFT && b.pressed) { + if (b->get_button_index() == BUTTON_LEFT && b->is_pressed()) { GraphNode *gn = NULL; GraphNode *gn_selected = NULL; @@ -878,7 +880,7 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { if (gn) { - if (_filter_input(Vector2(b.x, b.y))) + if (_filter_input(b->get_pos())) return; dragging = true; @@ -903,14 +905,14 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { } } else { - if (_filter_input(Vector2(b.x, b.y))) + if (_filter_input(b->get_pos())) return; if (Input::get_singleton()->is_key_pressed(KEY_SPACE)) return; box_selecting = true; box_selecting_from = get_local_mouse_pos(); - if (b.mod.control) { + if (b->get_control()) { box_selection_mode_aditive = true; previus_selected.clear(); for (int i = get_child_count() - 1; i >= 0; i--) { @@ -921,7 +923,7 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { previus_selected.push_back(gn); } - } else if (b.mod.shift) { + } else if (b->get_shift()) { box_selection_mode_aditive = false; previus_selected.clear(); for (int i = get_child_count() - 1; i >= 0; i--) { @@ -947,41 +949,42 @@ void GraphEdit::_gui_input(const InputEvent &p_ev) { } } - if (b.button_index == BUTTON_LEFT && !b.pressed && box_selecting) { + if (b->get_button_index() == BUTTON_LEFT && !b->is_pressed() && box_selecting) { box_selecting = false; previus_selected.clear(); top_layer->update(); } - if (b.button_index == BUTTON_WHEEL_UP && b.pressed) { + if (b->get_button_index() == BUTTON_WHEEL_UP && b->is_pressed()) { //too difficult to get right //set_zoom(zoom*ZOOM_SCALE); } - if (b.button_index == BUTTON_WHEEL_DOWN && b.pressed) { + if (b->get_button_index() == BUTTON_WHEEL_DOWN && b->is_pressed()) { //too difficult to get right //set_zoom(zoom/ZOOM_SCALE); } - if (b.button_index == BUTTON_WHEEL_UP) { - h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * b.factor / 8); + if (b->get_button_index() == BUTTON_WHEEL_UP) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * b->get_factor() / 8); } - if (b.button_index == BUTTON_WHEEL_DOWN) { - h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * b.factor / 8); + if (b->get_button_index() == BUTTON_WHEEL_DOWN) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * b->get_factor() / 8); } - if (b.button_index == BUTTON_WHEEL_RIGHT) { - v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * b.factor / 8); + if (b->get_button_index() == BUTTON_WHEEL_RIGHT) { + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * b->get_factor() / 8); } - if (b.button_index == BUTTON_WHEEL_LEFT) { - v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * b.factor / 8); + if (b->get_button_index() == BUTTON_WHEEL_LEFT) { + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * b->get_factor() / 8); } } - if (p_ev.type == InputEvent::KEY && p_ev.key.scancode == KEY_D && p_ev.key.pressed && p_ev.key.mod.command) { + Ref<InputEventKey> k = p_ev; + if (k.is_valid() && k->get_scancode() == KEY_D && k->is_pressed() && k->get_command()) { emit_signal("duplicate_nodes_request"); accept_event(); } - if (p_ev.type == InputEvent::KEY && p_ev.key.scancode == KEY_DELETE && p_ev.key.pressed) { + if (k.is_valid() && k->get_scancode() == KEY_DELETE && k->is_pressed()) { emit_signal("delete_nodes_request"); accept_event(); } diff --git a/scene/gui/graph_edit.h b/scene/gui/graph_edit.h index ff3867a059..22d053d312 100644 --- a/scene/gui/graph_edit.h +++ b/scene/gui/graph_edit.h @@ -119,11 +119,11 @@ private: void _update_scroll(); void _scroll_moved(double); - void _gui_input(const InputEvent &p_ev); + void _gui_input(const Ref<InputEvent> &p_ev); Control *connections_layer; GraphEditFilter *top_layer; - void _top_layer_input(const InputEvent &p_ev); + void _top_layer_input(const Ref<InputEvent> &p_ev); void _top_layer_draw(); void _connections_layer_draw(); void _update_scroll_offset(); diff --git a/scene/gui/graph_node.cpp b/scene/gui/graph_node.cpp index f7bb866f6f..fb0ff4f320 100644 --- a/scene/gui/graph_node.cpp +++ b/scene/gui/graph_node.cpp @@ -574,18 +574,19 @@ Color GraphNode::get_connection_output_color(int p_idx) { return conn_output_cache[p_idx].color; } -void GraphNode::_gui_input(const InputEvent &p_ev) { +void GraphNode::_gui_input(const Ref<InputEvent> &p_ev) { - if (p_ev.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_ev; + if (mb.is_valid()) { ERR_EXPLAIN("GraphNode must be the child of a GraphEdit node."); ERR_FAIL_COND(get_parent_control() == NULL); print_line("INPUT EVENT BUTTON"); - if (p_ev.mouse_button.pressed && p_ev.mouse_button.button_index == BUTTON_LEFT) { + if (mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { - Vector2 mpos = Vector2(p_ev.mouse_button.x, p_ev.mouse_button.y); + Vector2 mpos = Vector2(mb->get_pos().x, mb->get_pos().y); if (close_rect.size != Size2() && close_rect.has_point(mpos)) { emit_signal("close_request"); accept_event(); @@ -608,13 +609,14 @@ void GraphNode::_gui_input(const InputEvent &p_ev) { get_parent_control()->grab_focus(); } - if (!p_ev.mouse_button.pressed && p_ev.mouse_button.button_index == BUTTON_LEFT) { + if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { resizing = false; } } - if (resizing && p_ev.type == InputEvent::MOUSE_MOTION) { - Vector2 mpos = Vector2(p_ev.mouse_motion.x, p_ev.mouse_motion.y); + Ref<InputEventMouseMotion> mm = p_ev; + if (resizing && mm.is_valid()) { + Vector2 mpos = mm->get_pos(); Vector2 diff = mpos - resizing_from; diff --git a/scene/gui/graph_node.h b/scene/gui/graph_node.h index e98d0b3d07..056b699aa6 100644 --- a/scene/gui/graph_node.h +++ b/scene/gui/graph_node.h @@ -102,7 +102,7 @@ private: bool has_point(const Point2 &p_point) const; protected: - void _gui_input(const InputEvent &p_ev); + void _gui_input(const Ref<InputEvent> &p_ev); void _notification(int p_what); static void _bind_methods(); diff --git a/scene/gui/input_action.cpp b/scene/gui/input_action.cpp index 5b03338286..311cb4ab13 100644 --- a/scene/gui/input_action.cpp +++ b/scene/gui/input_action.cpp @@ -30,95 +30,73 @@ #include "input_action.h" #include "os/keyboard.h" -void ShortCut::set_shortcut(const InputEvent &p_shortcut) { +void ShortCut::set_shortcut(const Ref<InputEvent> &p_shortcut) { shortcut = p_shortcut; emit_changed(); } -InputEvent ShortCut::get_shortcut() const { +Ref<InputEvent> ShortCut::get_shortcut() const { return shortcut; } -bool ShortCut::is_shortcut(const InputEvent &p_event) const { +bool ShortCut::is_shortcut(const Ref<InputEvent> &p_event) const { - bool same = false; - - switch (p_event.type) { - - case InputEvent::KEY: { - - same = (shortcut.key.scancode == p_event.key.scancode && shortcut.key.mod == p_event.key.mod); - - } break; - case InputEvent::JOYPAD_BUTTON: { - - same = (shortcut.joy_button.button_index == p_event.joy_button.button_index); - - } break; - case InputEvent::MOUSE_BUTTON: { - - same = (shortcut.mouse_button.button_index == p_event.mouse_button.button_index); - - } break; - case InputEvent::JOYPAD_MOTION: { - - same = (shortcut.joy_motion.axis == p_event.joy_motion.axis && (shortcut.joy_motion.axis_value < 0) == (p_event.joy_motion.axis_value < 0)); - - } break; - default: {}; - } - - return same; + return shortcut.is_valid() && shortcut->action_match(p_event); } String ShortCut::get_as_text() const { + if (shortcut.is_valid()) + return shortcut->as_text(); + else + return "None"; +#if 0 switch (shortcut.type) { - case InputEvent::NONE: { + case Ref<InputEvent>::NONE: { return "None"; } break; - case InputEvent::KEY: { + case Ref<InputEvent>::KEY: { String str; - if (shortcut.key.mod.shift) + if (shortcut->get_shift()) str += RTR("Shift+"); - if (shortcut.key.mod.alt) + if (shortcut->get_alt()) str += RTR("Alt+"); - if (shortcut.key.mod.control) + if (shortcut->get_control()) str += RTR("Ctrl+"); - if (shortcut.key.mod.meta) + if (shortcut->get_metakey()) str += RTR("Meta+"); - str += keycode_get_string(shortcut.key.scancode).capitalize(); + str += keycode_get_string(shortcut->get_scancode()).capitalize(); return str; } break; - case InputEvent::JOYPAD_BUTTON: { + case Ref<InputEvent>::JOYPAD_BUTTON: { - String str = RTR("Device") + " " + itos(shortcut.device) + ", " + RTR("Button") + " " + itos(shortcut.joy_button.button_index); + String str = RTR("Device") + " " + itos(shortcut.device) + ", " + RTR("Button") + " " + itos(shortcut.joy_button->get_button_index()); str += "."; return str; } break; - case InputEvent::MOUSE_BUTTON: { + case Ref<InputEvent>::MOUSE_BUTTON: { String str = RTR("Device") + " " + itos(shortcut.device) + ", "; - switch (shortcut.mouse_button.button_index) { + switch (shortcut->get_button_index()) { case BUTTON_LEFT: str += RTR("Left Button."); break; case BUTTON_RIGHT: str += RTR("Right Button."); break; case BUTTON_MIDDLE: str += RTR("Middle Button."); break; case BUTTON_WHEEL_UP: str += RTR("Wheel Up."); break; case BUTTON_WHEEL_DOWN: str += RTR("Wheel Down."); break; - default: str += RTR("Button") + " " + itos(shortcut.mouse_button.button_index) + "."; + default: str += RTR("Button") + " " + itos(shortcut->get_button_index()) + "."; } return str; } break; - case InputEvent::JOYPAD_MOTION: { + case Ref<InputEvent>::JOYPAD_MOTION: { int ax = shortcut.joy_motion.axis; String str = RTR("Device") + " " + itos(shortcut.device) + ", " + RTR("Axis") + " " + itos(ax) + "."; @@ -128,24 +106,25 @@ String ShortCut::get_as_text() const { } return ""; +#endif } bool ShortCut::is_valid() const { - return shortcut.type != InputEvent::NONE; + return shortcut.is_valid(); } void ShortCut::_bind_methods() { - ClassDB::bind_method(D_METHOD("set_shortcut", "event"), &ShortCut::set_shortcut); - ClassDB::bind_method(D_METHOD("get_shortcut"), &ShortCut::get_shortcut); + ClassDB::bind_method(D_METHOD("set_shortcut", "event:InputEvent"), &ShortCut::set_shortcut); + ClassDB::bind_method(D_METHOD("get_shortcut:InputEvent"), &ShortCut::get_shortcut); ClassDB::bind_method(D_METHOD("is_valid"), &ShortCut::is_valid); - ClassDB::bind_method(D_METHOD("is_shortcut", "event"), &ShortCut::is_shortcut); + ClassDB::bind_method(D_METHOD("is_shortcut", "event:InputEvent"), &ShortCut::is_shortcut); ClassDB::bind_method(D_METHOD("get_as_text"), &ShortCut::get_as_text); - ADD_PROPERTY(PropertyInfo(Variant::INPUT_EVENT, "shortcut"), "set_shortcut", "get_shortcut"); + ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "shortcut", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"), "set_shortcut", "get_shortcut"); } ShortCut::ShortCut() { diff --git a/scene/gui/input_action.h b/scene/gui/input_action.h index c33490ae1d..6d13d8bd40 100644 --- a/scene/gui/input_action.h +++ b/scene/gui/input_action.h @@ -30,21 +30,22 @@ #ifndef INPUTACTION_H #define INPUTACTION_H +#include "os/input_event.h" #include "resource.h" class ShortCut : public Resource { GDCLASS(ShortCut, Resource); - InputEvent shortcut; + Ref<InputEvent> shortcut; protected: static void _bind_methods(); public: - void set_shortcut(const InputEvent &p_shortcut); - InputEvent get_shortcut() const; - bool is_shortcut(const InputEvent &p_Event) const; + void set_shortcut(const Ref<InputEvent> &p_shortcut); + Ref<InputEvent> get_shortcut() const; + bool is_shortcut(const Ref<InputEvent> &p_Event) const; bool is_valid() const; String get_as_text() const; diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp index bbfe1b61bb..494dde0e20 100644 --- a/scene/gui/item_list.cpp +++ b/scene/gui/item_list.cpp @@ -409,14 +409,17 @@ Size2 ItemList::Item::get_icon_size() const { return icon_region.size; } -void ItemList::_gui_input(const InputEvent &p_event) { +void ItemList::_gui_input(const Ref<InputEvent> &p_event) { - if (defer_select_single >= 0 && p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; + if (defer_select_single >= 0 && mm.is_valid()) { defer_select_single = -1; return; } - if (defer_select_single >= 0 && p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == BUTTON_LEFT && !p_event.mouse_button.pressed) { + Ref<InputEventMouseButton> mb = p_event; + + if (defer_select_single >= 0 && mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && !mb->is_pressed()) { select(defer_select_single, true); @@ -425,12 +428,10 @@ void ItemList::_gui_input(const InputEvent &p_event) { return; } - if (p_event.type == InputEvent::MOUSE_BUTTON && (p_event.mouse_button.button_index == BUTTON_LEFT || (allow_rmb_select && p_event.mouse_button.button_index == BUTTON_RIGHT)) && p_event.mouse_button.pressed) { - - const InputEventMouseButton &mb = p_event.mouse_button; + if (mb.is_valid() && (mb->get_button_index() == BUTTON_LEFT || (allow_rmb_select && mb->get_button_index() == BUTTON_RIGHT)) && mb->is_pressed()) { search_string = ""; //any mousepress cancels - Vector2 pos(mb.x, mb.y); + Vector2 pos(mb->get_pos().x, mb->get_pos().y); Ref<StyleBox> bg = get_stylebox("bg"); pos -= bg->get_offset(); pos.y += scroll_bar->get_value(); @@ -454,11 +455,11 @@ void ItemList::_gui_input(const InputEvent &p_event) { int i = closest; - if (select_mode == SELECT_MULTI && items[i].selected && mb.mod.command) { + if (select_mode == SELECT_MULTI && items[i].selected && mb->get_command()) { unselect(i); emit_signal("multi_selected", i, false); - } else if (select_mode == SELECT_MULTI && mb.mod.shift && current >= 0 && current < items.size() && current != i) { + } else if (select_mode == SELECT_MULTI && mb->get_shift() && current >= 0 && current < items.size() && current != i) { int from = current; int to = i; @@ -472,24 +473,24 @@ void ItemList::_gui_input(const InputEvent &p_event) { emit_signal("multi_selected", i, true); } - if (p_event.mouse_button.button_index == BUTTON_RIGHT) { + if (mb->get_button_index() == BUTTON_RIGHT) { - emit_signal("item_rmb_selected", i, Vector2(mb.x, mb.y)); + emit_signal("item_rmb_selected", i, Vector2(mb->get_pos().x, mb->get_pos().y)); } } else { - if (!mb.doubleclick && !mb.mod.command && select_mode == SELECT_MULTI && items[i].selectable && !items[i].disabled && items[i].selected && p_event.mouse_button.button_index == BUTTON_LEFT) { + if (!mb->is_doubleclick() && !mb->get_command() && select_mode == SELECT_MULTI && items[i].selectable && !items[i].disabled && items[i].selected && mb->get_button_index() == BUTTON_LEFT) { defer_select_single = i; return; } - if (items[i].selected && p_event.mouse_button.button_index == BUTTON_RIGHT) { + if (items[i].selected && mb->get_button_index() == BUTTON_RIGHT) { - emit_signal("item_rmb_selected", i, Vector2(mb.x, mb.y)); + emit_signal("item_rmb_selected", i, Vector2(mb->get_pos().x, mb->get_pos().y)); } else { bool selected = !items[i].selected; - select(i, select_mode == SELECT_SINGLE || !mb.mod.command); + select(i, select_mode == SELECT_SINGLE || !mb->get_command()); if (selected) { if (select_mode == SELECT_SINGLE) { @@ -498,10 +499,10 @@ void ItemList::_gui_input(const InputEvent &p_event) { emit_signal("multi_selected", i, true); } - if (p_event.mouse_button.button_index == BUTTON_RIGHT) { + if (mb->get_button_index() == BUTTON_RIGHT) { - emit_signal("item_rmb_selected", i, Vector2(mb.x, mb.y)); - } else if (/*select_mode==SELECT_SINGLE &&*/ mb.doubleclick) { + emit_signal("item_rmb_selected", i, Vector2(mb->get_pos().x, mb->get_pos().y)); + } else if (/*select_mode==SELECT_SINGLE &&*/ mb->is_doubleclick()) { emit_signal("item_activated", i); } @@ -516,21 +517,21 @@ void ItemList::_gui_input(const InputEvent &p_event) { } } } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == BUTTON_WHEEL_UP && p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) { - scroll_bar->set_value(scroll_bar->get_value() - scroll_bar->get_page() * p_event.mouse_button.factor / 8); + scroll_bar->set_value(scroll_bar->get_value() - scroll_bar->get_page() * mb->get_factor() / 8); scroll_bar->set_value(scroll_bar->get_value() - scroll_bar->get_page() / 8); } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index == BUTTON_WHEEL_DOWN && p_event.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) { - scroll_bar->set_value(scroll_bar->get_value() + scroll_bar->get_page() * p_event.mouse_button.factor / 8); + scroll_bar->set_value(scroll_bar->get_value() + scroll_bar->get_page() * mb->get_factor() / 8); scroll_bar->set_value(scroll_bar->get_value() + scroll_bar->get_page() / 8); } - if (p_event.is_pressed() && items.size() > 0) { - if (p_event.is_action("ui_up")) { + if (p_event->is_pressed() && items.size() > 0) { + if (p_event->is_action("ui_up")) { if (search_string != "") { @@ -565,7 +566,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { } accept_event(); } - } else if (p_event.is_action("ui_down")) { + } else if (p_event->is_action("ui_down")) { if (search_string != "") { @@ -599,7 +600,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { } accept_event(); } - } else if (p_event.is_action("ui_page_up")) { + } else if (p_event->is_action("ui_page_up")) { search_string = ""; //any mousepress cancels @@ -614,7 +615,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { break; } } - } else if (p_event.is_action("ui_page_down")) { + } else if (p_event->is_action("ui_page_down")) { search_string = ""; //any mousepress cancels @@ -630,7 +631,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { break; } } - } else if (p_event.is_action("ui_left")) { + } else if (p_event->is_action("ui_left")) { search_string = ""; //any mousepress cancels @@ -642,7 +643,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { } accept_event(); } - } else if (p_event.is_action("ui_right")) { + } else if (p_event->is_action("ui_right")) { search_string = ""; //any mousepress cancels @@ -654,9 +655,9 @@ void ItemList::_gui_input(const InputEvent &p_event) { } accept_event(); } - } else if (p_event.is_action("ui_cancel")) { + } else if (p_event->is_action("ui_cancel")) { search_string = ""; - } else if (p_event.is_action("ui_select")) { + } else if (p_event->is_action("ui_select")) { if (select_mode == SELECT_MULTI && current >= 0 && current < items.size()) { if (items[current].selectable && !items[current].disabled && !items[current].selected) { @@ -667,15 +668,17 @@ void ItemList::_gui_input(const InputEvent &p_event) { emit_signal("multi_selected", current, false); } } - } else if (p_event.is_action("ui_accept")) { + } else if (p_event->is_action("ui_accept")) { search_string = ""; //any mousepress cance if (current >= 0 && current < items.size()) { emit_signal("item_activated", current); } - } else if (p_event.type == InputEvent::KEY) { + } else { + + Ref<InputEventKey> k = p_event; - if (p_event.key.unicode) { + if (k.is_valid() && k->get_unicode()) { uint64_t now = OS::get_singleton()->get_ticks_msec(); uint64_t diff = now - search_time_msec; @@ -686,7 +689,7 @@ void ItemList::_gui_input(const InputEvent &p_event) { search_string = ""; } - search_string += String::chr(p_event.key.unicode); + search_string += String::chr(k->get_unicode()); for (int i = 0; i < items.size(); i++) { if (items[i].text.begins_with(search_string)) { set_current(i); diff --git a/scene/gui/item_list.h b/scene/gui/item_list.h index 4b896de77c..c7abc2990f 100644 --- a/scene/gui/item_list.h +++ b/scene/gui/item_list.h @@ -104,7 +104,7 @@ private: real_t icon_scale; void _scroll_changed(double); - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); protected: void _notification(int p_what); diff --git a/scene/gui/line_edit.cpp b/scene/gui/line_edit.cpp index 4ceaeeba04..38debe8a77 100644 --- a/scene/gui/line_edit.cpp +++ b/scene/gui/line_edit.cpp @@ -42,445 +42,442 @@ static bool _is_text_char(CharType c) { return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || c == '_'; } -void LineEdit::_gui_input(InputEvent p_event) { +void LineEdit::_gui_input(Ref<InputEvent> p_event) { - switch (p_event.type) { + Ref<InputEventMouseButton> b = p_event; - case InputEvent::MOUSE_BUTTON: { + if (b.is_valid()) { - const InputEventMouseButton &b = p_event.mouse_button; - - if (b.pressed && b.button_index == BUTTON_RIGHT) { - menu->set_position(get_global_transform().xform(get_local_mouse_pos())); - menu->set_size(Vector2(1, 1)); - menu->popup(); - grab_focus(); - return; - } + if (b->is_pressed() && b->get_button_index() == BUTTON_RIGHT) { + menu->set_position(get_global_transform().xform(get_local_mouse_pos())); + menu->set_size(Vector2(1, 1)); + menu->popup(); + grab_focus(); + return; + } - if (b.button_index != BUTTON_LEFT) - break; + if (b->get_button_index() != BUTTON_LEFT) + return; - _reset_caret_blink_timer(); - if (b.pressed) { + _reset_caret_blink_timer(); + if (b->is_pressed()) { - shift_selection_check_pre(b.mod.shift); + shift_selection_check_pre(b->get_shift()); - set_cursor_at_pixel_pos(b.x); + set_cursor_at_pixel_pos(b->get_pos().x); - if (b.mod.shift) { + if (b->get_shift()) { - selection_fill_at_cursor(); - selection.creating = true; + selection_fill_at_cursor(); + selection.creating = true; - } else { + } else { - if (b.doubleclick) { + if (b->is_doubleclick()) { - selection.enabled = true; - selection.begin = 0; - selection.end = text.length(); - selection.doubleclick = true; - } + selection.enabled = true; + selection.begin = 0; + selection.end = text.length(); + selection.doubleclick = true; + } - selection.drag_attempt = false; + selection.drag_attempt = false; - if ((cursor_pos < selection.begin) || (cursor_pos > selection.end) || !selection.enabled) { + if ((cursor_pos < selection.begin) || (cursor_pos > selection.end) || !selection.enabled) { - selection_clear(); - selection.cursor_start = cursor_pos; - selection.creating = true; - } else if (selection.enabled) { + selection_clear(); + selection.cursor_start = cursor_pos; + selection.creating = true; + } else if (selection.enabled) { - selection.drag_attempt = true; - } + selection.drag_attempt = true; } + } - update(); - - } else { + update(); - if ((!selection.creating) && (!selection.doubleclick)) { - selection_clear(); - } - selection.creating = false; - selection.doubleclick = false; + } else { - if (OS::get_singleton()->has_virtual_keyboard()) - OS::get_singleton()->show_virtual_keyboard(text, get_global_rect()); + if ((!selection.creating) && (!selection.doubleclick)) { + selection_clear(); } + selection.creating = false; + selection.doubleclick = false; - update(); - } break; - case InputEvent::MOUSE_MOTION: { + if (OS::get_singleton()->has_virtual_keyboard()) + OS::get_singleton()->show_virtual_keyboard(text, get_global_rect()); + } - const InputEventMouseMotion &m = p_event.mouse_motion; + update(); + } - if (m.button_mask & BUTTON_LEFT) { + Ref<InputEventMouseMotion> m = p_event; - if (selection.creating) { - set_cursor_at_pixel_pos(m.x); - selection_fill_at_cursor(); - } - } + if (m.is_valid()) { - } break; - case InputEvent::KEY: { + if (m->get_button_mask() & BUTTON_LEFT) { - const InputEventKey &k = p_event.key; + if (selection.creating) { + set_cursor_at_pixel_pos(m->get_pos().x); + selection_fill_at_cursor(); + } + } + } - if (!k.pressed) - return; - unsigned int code = k.scancode; + Ref<InputEventKey> k = p_event; - if (k.mod.command) { + if (k.is_valid()) { - bool handled = true; + if (!k->is_pressed()) + return; + unsigned int code = k->get_scancode(); - switch (code) { + if (k->get_command()) { - case (KEY_X): { // CUT + bool handled = true; - if (editable) { - cut_text(); - } + switch (code) { - } break; + case (KEY_X): { // CUT - case (KEY_C): { // COPY + if (editable) { + cut_text(); + } - copy_text(); + } break; - } break; + case (KEY_C): { // COPY - case (KEY_V): { // PASTE + copy_text(); - if (editable) { + } break; - paste_text(); - } + case (KEY_V): { // PASTE - } break; + if (editable) { - case (KEY_Z): { // Simple One level undo + paste_text(); + } - if (editable) { + } break; - undo(); - } + case (KEY_Z): { // Simple One level undo - } break; + if (editable) { + + undo(); + } - case (KEY_U): { // Delete from start to cursor + } break; - if (editable) { + case (KEY_U): { // Delete from start to cursor - selection_clear(); - undo_text = text; - text = text.substr(cursor_pos, text.length() - cursor_pos); + if (editable) { - Ref<Font> font = get_font("font"); + selection_clear(); + undo_text = text; + text = text.substr(cursor_pos, text.length() - cursor_pos); - cached_width = 0; - if (font != NULL) { - for (int i = 0; i < text.length(); i++) - cached_width += font->get_char_size(text[i]).width; - } + Ref<Font> font = get_font("font"); - set_cursor_pos(0); - _text_changed(); + cached_width = 0; + if (font != NULL) { + for (int i = 0; i < text.length(); i++) + cached_width += font->get_char_size(text[i]).width; } - } break; + set_cursor_pos(0); + _text_changed(); + } - case (KEY_Y): { // PASTE (Yank for unix users) + } break; - if (editable) { + case (KEY_Y): { // PASTE (Yank for unix users) - paste_text(); - } + if (editable) { - } break; - case (KEY_K): { // Delete from cursor_pos to end + paste_text(); + } - if (editable) { + } break; + case (KEY_K): { // Delete from cursor_pos to end - selection_clear(); - undo_text = text; - text = text.substr(0, cursor_pos); - _text_changed(); - } + if (editable) { - } break; - case (KEY_A): { //Select All - select(); - } break; - default: { handled = false; } - } + selection_clear(); + undo_text = text; + text = text.substr(0, cursor_pos); + _text_changed(); + } - if (handled) { - accept_event(); - return; - } + } break; + case (KEY_A): { //Select All + select(); + } break; + default: { handled = false; } } - _reset_caret_blink_timer(); - if (!k.mod.meta) { + if (handled) { + accept_event(); + return; + } + } - bool handled = true; - switch (code) { + _reset_caret_blink_timer(); + if (!k->get_metakey()) { - case KEY_ENTER: - case KEY_RETURN: { + bool handled = true; + switch (code) { - emit_signal("text_entered", text); - if (OS::get_singleton()->has_virtual_keyboard()) - OS::get_singleton()->hide_virtual_keyboard(); + case KEY_ENTER: + case KEY_RETURN: { - return; - } break; + emit_signal("text_entered", text); + if (OS::get_singleton()->has_virtual_keyboard()) + OS::get_singleton()->hide_virtual_keyboard(); - case KEY_BACKSPACE: { + return; + } break; - if (!editable) - break; + case KEY_BACKSPACE: { - if (selection.enabled) { - undo_text = text; - selection_delete(); - break; - } + if (!editable) + break; + + if (selection.enabled) { + undo_text = text; + selection_delete(); + break; + } #ifdef APPLE_STYLE_KEYS - if (k.mod.alt) { + if (k->get_alt()) { #else - if (k.mod.alt) { - handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + handled = false; + break; + } else if (k->get_command()) { #endif - int cc = cursor_pos; - bool prev_char = false; + int cc = cursor_pos; + bool prev_char = false; - while (cc > 0) { - bool ischar = _is_text_char(text[cc - 1]); + while (cc > 0) { + bool ischar = _is_text_char(text[cc - 1]); - if (prev_char && !ischar) - break; + if (prev_char && !ischar) + break; - prev_char = ischar; - cc--; - } + prev_char = ischar; + cc--; + } - delete_text(cc, cursor_pos); + delete_text(cc, cursor_pos); - set_cursor_pos(cc); + set_cursor_pos(cc); - } else { - undo_text = text; - delete_char(); - } + } else { + undo_text = text; + delete_char(); + } - } break; - case KEY_KP_4: { - if (k.unicode != 0) { - handled = false; - break; - } - // numlock disabled. fallthrough to key_left + } break; + case KEY_KP_4: { + if (k->get_unicode() != 0) { + handled = false; + break; } - case KEY_LEFT: { + // numlock disabled. fallthrough to key_left + } + case KEY_LEFT: { #ifndef APPLE_STYLE_KEYS - if (!k.mod.alt) + if (!k->get_alt()) #endif - shift_selection_check_pre(k.mod.shift); + shift_selection_check_pre(k->get_shift()); #ifdef APPLE_STYLE_KEYS - if (k.mod.command) { - set_cursor_pos(0); - } else if (k.mod.alt) { + if (k->get_command()) { + set_cursor_pos(0); + } else if (k->get_alt()) { #else - if (k.mod.alt) { - handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + handled = false; + break; + } else if (k->get_command()) { #endif - bool prev_char = false; - int cc = cursor_pos; + bool prev_char = false; + int cc = cursor_pos; - while (cc > 0) { - bool ischar = _is_text_char(text[cc - 1]); + while (cc > 0) { + bool ischar = _is_text_char(text[cc - 1]); - if (prev_char && !ischar) - break; + if (prev_char && !ischar) + break; - prev_char = ischar; - cc--; - } + prev_char = ischar; + cc--; + } - set_cursor_pos(cc); + set_cursor_pos(cc); - } else { - set_cursor_pos(get_cursor_pos() - 1); - } + } else { + set_cursor_pos(get_cursor_pos() - 1); + } - shift_selection_check_post(k.mod.shift); + shift_selection_check_post(k->get_shift()); - } break; - case KEY_KP_6: { - if (k.unicode != 0) { - handled = false; - break; - } - // numlock disabled. fallthrough to key_right + } break; + case KEY_KP_6: { + if (k->get_unicode() != 0) { + handled = false; + break; } - case KEY_RIGHT: { + // numlock disabled. fallthrough to key_right + } + case KEY_RIGHT: { - shift_selection_check_pre(k.mod.shift); + shift_selection_check_pre(k->get_shift()); #ifdef APPLE_STYLE_KEYS - if (k.mod.command) { - set_cursor_pos(text.length()); - } else if (k.mod.alt) { + if (k->get_command()) { + set_cursor_pos(text.length()); + } else if (k->get_alt()) { #else - if (k.mod.alt) { - handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + handled = false; + break; + } else if (k->get_command()) { #endif - bool prev_char = false; - int cc = cursor_pos; + bool prev_char = false; + int cc = cursor_pos; - while (cc < text.length()) { - bool ischar = _is_text_char(text[cc]); + while (cc < text.length()) { + bool ischar = _is_text_char(text[cc]); - if (prev_char && !ischar) - break; + if (prev_char && !ischar) + break; - prev_char = ischar; - cc++; - } + prev_char = ischar; + cc++; + } - set_cursor_pos(cc); + set_cursor_pos(cc); - } else { - set_cursor_pos(get_cursor_pos() + 1); - } + } else { + set_cursor_pos(get_cursor_pos() + 1); + } - shift_selection_check_post(k.mod.shift); + shift_selection_check_post(k->get_shift()); - } break; - case KEY_DELETE: { + } break; + case KEY_DELETE: { - if (!editable) - break; + if (!editable) + break; - if (k.mod.shift && !k.mod.command && !k.mod.alt) { - cut_text(); - break; - } + if (k->get_shift() && !k->get_command() && !k->get_alt()) { + cut_text(); + break; + } - if (selection.enabled) { - undo_text = text; - selection_delete(); - break; - } + if (selection.enabled) { + undo_text = text; + selection_delete(); + break; + } - int text_len = text.length(); + int text_len = text.length(); - if (cursor_pos == text_len) - break; // nothing to do + if (cursor_pos == text_len) + break; // nothing to do #ifdef APPLE_STYLE_KEYS - if (k.mod.alt) { + if (k->get_alt()) { #else - if (k.mod.alt) { - handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + handled = false; + break; + } else if (k->get_command()) { #endif - int cc = cursor_pos; - - bool prev_char = false; + int cc = cursor_pos; - while (cc < text.length()) { + bool prev_char = false; - bool ischar = _is_text_char(text[cc]); + while (cc < text.length()) { - if (prev_char && !ischar) - break; - prev_char = ischar; - cc++; - } + bool ischar = _is_text_char(text[cc]); - delete_text(cursor_pos, cc); - - } else { - undo_text = text; - set_cursor_pos(cursor_pos + 1); - delete_char(); + if (prev_char && !ischar) + break; + prev_char = ischar; + cc++; } - } break; - case KEY_KP_7: { - if (k.unicode != 0) { - handled = false; - break; - } - // numlock disabled. fallthrough to key_home - } - case KEY_HOME: { + delete_text(cursor_pos, cc); - shift_selection_check_pre(k.mod.shift); - set_cursor_pos(0); - shift_selection_check_post(k.mod.shift); - } break; - case KEY_KP_1: { - if (k.unicode != 0) { - handled = false; - break; - } - // numlock disabled. fallthrough to key_end + } else { + undo_text = text; + set_cursor_pos(cursor_pos + 1); + delete_char(); } - case KEY_END: { - shift_selection_check_pre(k.mod.shift); - set_cursor_pos(text.length()); - shift_selection_check_post(k.mod.shift); - } break; - - default: { + } break; + case KEY_KP_7: { + if (k->get_unicode() != 0) { + handled = false; + break; + } + // numlock disabled. fallthrough to key_home + } + case KEY_HOME: { + shift_selection_check_pre(k->get_shift()); + set_cursor_pos(0); + shift_selection_check_post(k->get_shift()); + } break; + case KEY_KP_1: { + if (k->get_unicode() != 0) { handled = false; - } break; + break; + } + // numlock disabled. fallthrough to key_end } + case KEY_END: { - if (handled) { - accept_event(); - } else if (!k.mod.alt && !k.mod.command) { - if (k.unicode >= 32 && k.scancode != KEY_DELETE) { - - if (editable) { - selection_delete(); - CharType ucodestr[2] = { (CharType)k.unicode, 0 }; - append_at_cursor(ucodestr); - _text_changed(); - accept_event(); - } + shift_selection_check_pre(k->get_shift()); + set_cursor_pos(text.length()); + shift_selection_check_post(k->get_shift()); + } break; - } else { - return; + default: { + + handled = false; + } break; + } + + if (handled) { + accept_event(); + } else if (!k->get_alt() && !k->get_command()) { + if (k->get_unicode() >= 32 && k->get_scancode() != KEY_DELETE) { + + if (editable) { + selection_delete(); + CharType ucodestr[2] = { (CharType)k->get_unicode(), 0 }; + append_at_cursor(ucodestr); + _text_changed(); + accept_event(); } - } - update(); + } else { + return; + } } - return; + update(); + } - } break; + return; } } diff --git a/scene/gui/line_edit.h b/scene/gui/line_edit.h index a969095947..1167cfb6d0 100644 --- a/scene/gui/line_edit.h +++ b/scene/gui/line_edit.h @@ -119,7 +119,7 @@ private: void _editor_settings_changed(); #endif - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); void _notification(int p_what); protected: diff --git a/scene/gui/menu_button.cpp b/scene/gui/menu_button.cpp index cf468f2257..fe76b16460 100644 --- a/scene/gui/menu_button.cpp +++ b/scene/gui/menu_button.cpp @@ -31,9 +31,9 @@ #include "os/keyboard.h" #include "scene/main/viewport.h" -void MenuButton::_unhandled_key_input(InputEvent p_event) { +void MenuButton::_unhandled_key_input(Ref<InputEvent> p_event) { - if (p_event.is_pressed() && !p_event.is_echo() && (p_event.type == InputEvent::KEY || p_event.type == InputEvent::ACTION || p_event.type == InputEvent::JOYPAD_BUTTON)) { + if (p_event->is_pressed() && !p_event->is_echo() && (p_event->cast_to<InputEventKey>() || p_event->cast_to<InputEventJoypadButton>() || p_event->cast_to<InputEventAction>())) { if (!get_parent() || !is_visible_in_tree() || is_disabled()) return; @@ -59,10 +59,10 @@ void MenuButton::pressed() { popup->set_invalidate_click_until_motion(); } -void MenuButton::_gui_input(InputEvent p_event) { +void MenuButton::_gui_input(Ref<InputEvent> p_event) { - /*if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==BUTTON_LEFT) { - clicked=p_event.mouse_button.pressed; + /*if (p_event.type==InputEvent::MOUSE_BUTTON && p_event->get_button_index()==BUTTON_LEFT) { + clicked=p_event->is_pressed(); } if (clicked && p_event.type==InputEvent::MOUSE_MOTION && popup->is_visible_in_tree()) { diff --git a/scene/gui/menu_button.h b/scene/gui/menu_button.h index e07627c07c..6bb23452dd 100644 --- a/scene/gui/menu_button.h +++ b/scene/gui/menu_button.h @@ -43,11 +43,11 @@ class MenuButton : public Button { PopupMenu *popup; virtual void pressed(); - void _unhandled_key_input(InputEvent p_event); + void _unhandled_key_input(Ref<InputEvent> p_event); Array _get_items() const; void _set_items(const Array &p_items); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); protected: static void _bind_methods(); diff --git a/scene/gui/popup.cpp b/scene/gui/popup.cpp index 7d0b91a366..655d8ed6f6 100644 --- a/scene/gui/popup.cpp +++ b/scene/gui/popup.cpp @@ -30,7 +30,7 @@ #include "popup.h" #include "os/keyboard.h" -void Popup::_gui_input(InputEvent p_event) { +void Popup::_gui_input(Ref<InputEvent> p_event) { } void Popup::_notification(int p_what) { diff --git a/scene/gui/popup.h b/scene/gui/popup.h index 950aa65fa4..0543ae1937 100644 --- a/scene/gui/popup.h +++ b/scene/gui/popup.h @@ -45,7 +45,7 @@ class Popup : public Control { protected: virtual void _post_popup() {} - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); void _notification(int p_what); virtual void _fix_size(); static void _bind_methods(); diff --git a/scene/gui/popup_menu.cpp b/scene/gui/popup_menu.cpp index e3f26e0f0b..985d9addc9 100644 --- a/scene/gui/popup_menu.cpp +++ b/scene/gui/popup_menu.cpp @@ -208,171 +208,170 @@ void PopupMenu::_submenu_timeout() { } } -void PopupMenu::_gui_input(const InputEvent &p_event) { +void PopupMenu::_gui_input(const Ref<InputEvent> &p_event) { - switch (p_event.type) { + Ref<InputEventKey> k = p_event; - case InputEvent::KEY: { + if (k.is_valid()) { - if (!p_event.key.pressed) - break; + if (!k->is_pressed()) + return; - switch (p_event.key.scancode) { + switch (k->get_scancode()) { - case KEY_DOWN: { + case KEY_DOWN: { - for (int i = mouse_over + 1; i < items.size(); i++) { + for (int i = mouse_over + 1; i < items.size(); i++) { - if (i < 0 || i >= items.size()) - continue; + if (i < 0 || i >= items.size()) + continue; - if (!items[i].separator && !items[i].disabled) { + if (!items[i].separator && !items[i].disabled) { - mouse_over = i; - update(); - break; - } + mouse_over = i; + update(); + break; } - } break; - case KEY_UP: { + } + } break; + case KEY_UP: { - for (int i = mouse_over - 1; i >= 0; i--) { + for (int i = mouse_over - 1; i >= 0; i--) { - if (i < 0 || i >= items.size()) - continue; + if (i < 0 || i >= items.size()) + continue; - if (!items[i].separator && !items[i].disabled) { + if (!items[i].separator && !items[i].disabled) { - mouse_over = i; - update(); - break; - } + mouse_over = i; + update(); + break; } - } break; - case KEY_RETURN: - case KEY_ENTER: { + } + } break; + case KEY_RETURN: + case KEY_ENTER: { - if (mouse_over >= 0 && mouse_over < items.size() && !items[mouse_over].separator) { + if (mouse_over >= 0 && mouse_over < items.size() && !items[mouse_over].separator) { - activate_item(mouse_over); - } - } break; - } + activate_item(mouse_over); + } + } break; + } + } - } break; + Ref<InputEventMouseButton> b = p_event; - case InputEvent::MOUSE_BUTTON: { + if (b.is_valid()) { - const InputEventMouseButton &b = p_event.mouse_button; - if (b.pressed) - break; + if (b->is_pressed()) + return; - switch (b.button_index) { + switch (b->get_button_index()) { - case BUTTON_WHEEL_DOWN: { + case BUTTON_WHEEL_DOWN: { - if (get_global_position().y + get_size().y > get_viewport_rect().size.y) { + if (get_global_position().y + get_size().y > get_viewport_rect().size.y) { - int vseparation = get_constant("vseparation"); - Ref<Font> font = get_font("font"); + int vseparation = get_constant("vseparation"); + Ref<Font> font = get_font("font"); - Point2 pos = get_position(); - int s = (vseparation + font->get_height()) * 3; - pos.y -= (s * b.factor); - set_position(pos); + Point2 pos = get_position(); + int s = (vseparation + font->get_height()) * 3; + pos.y -= (s * b->get_factor()); + set_position(pos); - //update hover - InputEvent ie; - ie.type = InputEvent::MOUSE_MOTION; - ie.mouse_motion.x = b.x; - ie.mouse_motion.y = b.y + s; - _gui_input(ie); - } - } break; - case BUTTON_WHEEL_UP: { + //update hover + Ref<InputEventMouseMotion> ie; + ie.instance(); + ie->set_pos(b->get_pos() + Vector2(0, s)); + _gui_input(ie); + } + } break; + case BUTTON_WHEEL_UP: { - if (get_global_position().y < 0) { + if (get_global_position().y < 0) { - int vseparation = get_constant("vseparation"); - Ref<Font> font = get_font("font"); + int vseparation = get_constant("vseparation"); + Ref<Font> font = get_font("font"); - Point2 pos = get_position(); - int s = (vseparation + font->get_height()) * 3; - pos.y += (s * b.factor); - set_position(pos); + Point2 pos = get_position(); + int s = (vseparation + font->get_height()) * 3; + pos.y += (s * b->get_factor()); + set_position(pos); - //update hover - InputEvent ie; - ie.type = InputEvent::MOUSE_MOTION; - ie.mouse_motion.x = b.x; - ie.mouse_motion.y = b.y - s; - _gui_input(ie); - } - } break; - case BUTTON_LEFT: { + //update hover + Ref<InputEventMouseMotion> ie; + ie.instance(); + ie->set_pos(b->get_pos() - Vector2(0, s)); + _gui_input(ie); + } + } break; + case BUTTON_LEFT: { - int over = _get_mouse_over(Point2(b.x, b.y)); + int over = _get_mouse_over(b->get_pos()); - if (invalidated_click) { - invalidated_click = false; - break; - } - if (over < 0) { - hide(); - break; //non-activable - } + if (invalidated_click) { + invalidated_click = false; + break; + } + if (over < 0) { + hide(); + break; //non-activable + } - if (items[over].separator || items[over].disabled) - break; + if (items[over].separator || items[over].disabled) + break; - if (items[over].submenu != "") { + if (items[over].submenu != "") { - _activate_submenu(over); - return; - } - activate_item(over); + _activate_submenu(over); + return; + } + activate_item(over); - } break; - } + } break; + } - //update(); - } break; - case InputEvent::MOUSE_MOTION: { + //update(); + } - if (invalidated_click) { - moved += Vector2(p_event.mouse_motion.relative_x, p_event.mouse_motion.relative_y); - if (moved.length() > 4) - invalidated_click = false; - } + Ref<InputEventMouseMotion> m = p_event; - const InputEventMouseMotion &m = p_event.mouse_motion; - for (List<Rect2>::Element *E = autohide_areas.front(); E; E = E->next()) { + if (m.is_valid()) { - if (!Rect2(Point2(), get_size()).has_point(Point2(m.x, m.y)) && E->get().has_point(Point2(m.x, m.y))) { - call_deferred("hide"); - return; - } - } + if (invalidated_click) { + moved += m->get_relative(); + if (moved.length() > 4) + invalidated_click = false; + } - int over = _get_mouse_over(Point2(m.x, m.y)); - int id = (over < 0 || items[over].separator || items[over].disabled) ? -1 : (items[over].ID >= 0 ? items[over].ID : over); + for (List<Rect2>::Element *E = autohide_areas.front(); E; E = E->next()) { - if (id < 0) { - mouse_over = -1; - update(); - break; + if (!Rect2(Point2(), get_size()).has_point(m->get_pos()) && E->get().has_point(m->get_pos())) { + call_deferred("hide"); + return; } + } - if (items[over].submenu != "" && submenu_over != over) { - submenu_over = over; - submenu_timer->start(); - } + int over = _get_mouse_over(m->get_pos()); + int id = (over < 0 || items[over].separator || items[over].disabled) ? -1 : (items[over].ID >= 0 ? items[over].ID : over); - if (over != mouse_over) { - mouse_over = over; - update(); - } - } break; + if (id < 0) { + mouse_over = -1; + update(); + return; + } + + if (items[over].submenu != "" && submenu_over != over) { + submenu_over = over; + submenu_timer->start(); + } + + if (over != mouse_over) { + mouse_over = over; + update(); + } } } @@ -820,20 +819,22 @@ int PopupMenu::get_item_count() const { return items.size(); } -bool PopupMenu::activate_item_by_event(const InputEvent &p_event, bool p_for_global_only) { +bool PopupMenu::activate_item_by_event(const Ref<InputEvent> &p_event, bool p_for_global_only) { uint32_t code = 0; - if (p_event.type == InputEvent::KEY) { - code = p_event.key.scancode; + Ref<InputEventKey> k = p_event; + + if (k.is_valid()) { + code = k->get_scancode(); if (code == 0) - code = p_event.key.unicode; - if (p_event.key.mod.control) + code = k->get_unicode(); + if (k->get_control()) code |= KEY_MASK_CTRL; - if (p_event.key.mod.alt) + if (k->get_alt()) code |= KEY_MASK_ALT; - if (p_event.key.mod.meta) + if (k->get_metakey()) code |= KEY_MASK_META; - if (p_event.key.mod.shift) + if (k->get_shift()) code |= KEY_MASK_SHIFT; } diff --git a/scene/gui/popup_menu.h b/scene/gui/popup_menu.h index de809f29d3..7ef532453d 100644 --- a/scene/gui/popup_menu.h +++ b/scene/gui/popup_menu.h @@ -79,7 +79,7 @@ class PopupMenu : public Popup { String _get_accel_text(int p_item) const; int _get_mouse_over(const Point2 &p_over) const; virtual Size2 get_minimum_size() const; - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _activate_submenu(int over); void _submenu_timeout(); @@ -146,7 +146,7 @@ public: int get_item_count() const; - bool activate_item_by_event(const InputEvent &p_event, bool p_for_global_only = false); + bool activate_item_by_event(const Ref<InputEvent> &p_event, bool p_for_global_only = false); void activate_item(int p_item); void remove_item(int p_idx); diff --git a/scene/gui/rich_text_label.cpp b/scene/gui/rich_text_label.cpp index 6e5f218a66..a142bf5981 100644 --- a/scene/gui/rich_text_label.cpp +++ b/scene/gui/rich_text_label.cpp @@ -734,160 +734,155 @@ Control::CursorShape RichTextLabel::get_cursor_shape(const Point2 &p_pos) const return CURSOR_ARROW; } -void RichTextLabel::_gui_input(InputEvent p_event) { +void RichTextLabel::_gui_input(Ref<InputEvent> p_event) { - switch (p_event.type) { + Ref<InputEventMouseButton> b = p_event; - case InputEvent::MOUSE_BUTTON: { - - if (main->first_invalid_line < main->lines.size()) - return; - - const InputEventMouseButton &b = p_event.mouse_button; + if (b.is_valid()) { + if (main->first_invalid_line < main->lines.size()) + return; - if (b.button_index == BUTTON_LEFT) { + if (b->get_button_index() == BUTTON_LEFT) { - if (true) { + if (true) { - if (b.pressed && !b.doubleclick) { - int line = 0; - Item *item = NULL; + if (b->is_pressed() && !b->is_doubleclick()) { + int line = 0; + Item *item = NULL; - bool outside; - _find_click(main, Point2i(b.x, b.y), &item, &line, &outside); + bool outside; + _find_click(main, b->get_pos(), &item, &line, &outside); - if (item) { + if (item) { - Variant meta; - if (!outside && _find_meta(item, &meta)) { - //meta clicked + Variant meta; + if (!outside && _find_meta(item, &meta)) { + //meta clicked - emit_signal("meta_clicked", meta); - } else if (selection.enabled) { + emit_signal("meta_clicked", meta); + } else if (selection.enabled) { - selection.click = item; - selection.click_char = line; - } + selection.click = item; + selection.click_char = line; } + } - } else if (!b.pressed) { + } else if (!b->is_pressed()) { - selection.click = NULL; - } + selection.click = NULL; } } + } - if (b.button_index == BUTTON_WHEEL_UP) { + if (b->get_button_index() == BUTTON_WHEEL_UP) { - if (scroll_active) + if (scroll_active) - vscroll->set_value(vscroll->get_value() - vscroll->get_page() * b.factor * 0.5 / 8); - } - if (b.button_index == BUTTON_WHEEL_DOWN) { + vscroll->set_value(vscroll->get_value() - vscroll->get_page() * b->get_factor() * 0.5 / 8); + } + if (b->get_button_index() == BUTTON_WHEEL_DOWN) { - if (scroll_active) + if (scroll_active) - vscroll->set_value(vscroll->get_value() + vscroll->get_page() * b.factor * 0.5 / 8); - } - } break; - case InputEvent::KEY: { - - const InputEventKey &k = p_event.key; - if (k.pressed && !k.mod.alt && !k.mod.shift && !k.mod.meta) { - bool handled = true; - switch (k.scancode) { - case KEY_PAGEUP: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(vscroll->get_value() - vscroll->get_page()); - } break; - case KEY_PAGEDOWN: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(vscroll->get_value() + vscroll->get_page()); - } break; - case KEY_UP: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(vscroll->get_value() - get_font("normal_font")->get_height()); - } break; - case KEY_DOWN: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(vscroll->get_value() + get_font("normal_font")->get_height()); - } break; - case KEY_HOME: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(0); - } break; - case KEY_END: { - - if (vscroll->is_visible_in_tree()) - vscroll->set_value(vscroll->get_max()); - } break; - case KEY_INSERT: - case KEY_C: { - - if (k.mod.command) { - selection_copy(); - } else { - handled = false; - } + vscroll->set_value(vscroll->get_value() + vscroll->get_page() * b->get_factor() * 0.5 / 8); + } + } - } break; - default: handled = false; - } + Ref<InputEventKey> k = p_event; + + if (k.is_valid()) { + if (k->is_pressed() && !k->get_alt() && !k->get_shift() && !k->get_metakey()) { + bool handled = true; + switch (k->get_scancode()) { + case KEY_PAGEUP: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(vscroll->get_value() - vscroll->get_page()); + } break; + case KEY_PAGEDOWN: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(vscroll->get_value() + vscroll->get_page()); + } break; + case KEY_UP: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(vscroll->get_value() - get_font("normal_font")->get_height()); + } break; + case KEY_DOWN: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(vscroll->get_value() + get_font("normal_font")->get_height()); + } break; + case KEY_HOME: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(0); + } break; + case KEY_END: { + + if (vscroll->is_visible_in_tree()) + vscroll->set_value(vscroll->get_max()); + } break; + case KEY_INSERT: + case KEY_C: { + + if (k->get_command()) { + selection_copy(); + } else { + handled = false; + } - if (handled) - accept_event(); + } break; + default: handled = false; } - } break; - case InputEvent::MOUSE_MOTION: { + if (handled) + accept_event(); + } + } - if (main->first_invalid_line < main->lines.size()) - return; + Ref<InputEventMouseMotion> m = p_event; - const InputEventMouseMotion &m = p_event.mouse_motion; + if (m.is_valid()) { + if (main->first_invalid_line < main->lines.size()) + return; - if (selection.click) { + if (selection.click) { - int line = 0; - Item *item = NULL; - _find_click(main, Point2i(m.x, m.y), &item, &line); - if (!item) - return; // do not update + int line = 0; + Item *item = NULL; + _find_click(main, m->get_pos(), &item, &line); + if (!item) + return; // do not update - selection.from = selection.click; - selection.from_char = selection.click_char; + selection.from = selection.click; + selection.from_char = selection.click_char; - selection.to = item; - selection.to_char = line; + selection.to = item; + selection.to_char = line; - bool swap = false; - if (selection.from->index > selection.to->index) + bool swap = false; + if (selection.from->index > selection.to->index) + swap = true; + else if (selection.from->index == selection.to->index) { + if (selection.from_char > selection.to_char) swap = true; - else if (selection.from->index == selection.to->index) { - if (selection.from_char > selection.to_char) - swap = true; - else if (selection.from_char == selection.to_char) { + else if (selection.from_char == selection.to_char) { - selection.active = false; - return; - } - } - - if (swap) { - SWAP(selection.from, selection.to); - SWAP(selection.from_char, selection.to_char); + selection.active = false; + return; } + } - selection.active = true; - update(); + if (swap) { + SWAP(selection.from, selection.to); + SWAP(selection.from_char, selection.to_char); } - } break; + selection.active = true; + update(); + } } } diff --git a/scene/gui/rich_text_label.h b/scene/gui/rich_text_label.h index 05d98b3ee8..eedb7e54db 100644 --- a/scene/gui/rich_text_label.h +++ b/scene/gui/rich_text_label.h @@ -272,7 +272,7 @@ private: void _update_scroll(); void _scroll_changed(double); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); Item *_get_next_item(Item *p_item, bool p_free = false); bool use_bbcode; diff --git a/scene/gui/scroll_bar.cpp b/scene/gui/scroll_bar.cpp index bf44493b51..27a16ccc33 100644 --- a/scene/gui/scroll_bar.cpp +++ b/scene/gui/scroll_bar.cpp @@ -38,191 +38,188 @@ void ScrollBar::set_can_focus_by_default(bool p_can_focus) { focus_by_default = p_can_focus; } -void ScrollBar::_gui_input(InputEvent p_event) { +void ScrollBar::_gui_input(Ref<InputEvent> p_event) { - switch (p_event.type) { + Ref<InputEventMouseButton> b = p_event; - case InputEvent::MOUSE_BUTTON: { + if (b.is_valid()) { + accept_event(); - const InputEventMouseButton &b = p_event.mouse_button; - accept_event(); - - if (b.button_index == 5 && b.pressed) { - - /* - if (orientation==VERTICAL) - set_val( get_val() + get_page() / 4.0 ); - else - */ - set_value(get_value() + get_page() / 4.0); - accept_event(); - } - - if (b.button_index == 4 && b.pressed) { + if (b->get_button_index() == 5 && b->is_pressed()) { - /* - if (orientation==HORIZONTAL) - set_val( get_val() - get_page() / 4.0 ); - else - */ - set_value(get_value() - get_page() / 4.0); - accept_event(); - } + /* + if (orientation==VERTICAL) + set_val( get_val() + get_page() / 4.0 ); + else + */ + set_value(get_value() + get_page() / 4.0); + accept_event(); + } - if (b.button_index != 1) - return; + if (b->get_button_index() == 4 && b->is_pressed()) { - if (b.pressed) { + /* + if (orientation==HORIZONTAL) + set_val( get_val() - get_page() / 4.0 ); + else + */ + set_value(get_value() - get_page() / 4.0); + accept_event(); + } - double ofs = orientation == VERTICAL ? b.y : b.x; - Ref<Texture> decr = get_icon("decrement"); - Ref<Texture> incr = get_icon("increment"); + if (b->get_button_index() != 1) + return; - double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); - double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width(); - double grabber_ofs = get_grabber_offset(); - double grabber_size = get_grabber_size(); - double total = orientation == VERTICAL ? get_size().height : get_size().width; + if (b->is_pressed()) { - if (ofs < decr_size) { + double ofs = orientation == VERTICAL ? b->get_pos().y : b->get_pos().x; + Ref<Texture> decr = get_icon("decrement"); + Ref<Texture> incr = get_icon("increment"); - set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); - break; - } + double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); + double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width(); + double grabber_ofs = get_grabber_offset(); + double grabber_size = get_grabber_size(); + double total = orientation == VERTICAL ? get_size().height : get_size().width; - if (ofs > total - incr_size) { + if (ofs < decr_size) { - set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); - break; - } + set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); + return; + } - ofs -= decr_size; + if (ofs > total - incr_size) { - if (ofs < grabber_ofs) { + set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); + return; + } - set_value(get_value() - get_page()); - break; - } + ofs -= decr_size; - ofs -= grabber_ofs; + if (ofs < grabber_ofs) { - if (ofs < grabber_size) { + set_value(get_value() - get_page()); + return; + } - drag.active = true; - drag.pos_at_click = grabber_ofs + ofs; - drag.value_at_click = get_as_ratio(); - update(); - } else { + ofs -= grabber_ofs; - set_value(get_value() + get_page()); - } + if (ofs < grabber_size) { + drag.active = true; + drag.pos_at_click = grabber_ofs + ofs; + drag.value_at_click = get_as_ratio(); + update(); } else { - drag.active = false; - update(); + set_value(get_value() + get_page()); } - } break; - case InputEvent::MOUSE_MOTION: { + } else { - const InputEventMouseMotion &m = p_event.mouse_motion; + drag.active = false; + update(); + } + } - accept_event(); + Ref<InputEventMouseMotion> m = p_event; - if (drag.active) { + if (m.is_valid()) { - double ofs = orientation == VERTICAL ? m.y : m.x; - Ref<Texture> decr = get_icon("decrement"); + accept_event(); - double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); - ofs -= decr_size; + if (drag.active) { - double diff = (ofs - drag.pos_at_click) / get_area_size(); + double ofs = orientation == VERTICAL ? m->get_pos().y : m->get_pos().x; + Ref<Texture> decr = get_icon("decrement"); - set_as_ratio(drag.value_at_click + diff); - } else { + double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); + ofs -= decr_size; - double ofs = orientation == VERTICAL ? m.y : m.x; - Ref<Texture> decr = get_icon("decrement"); - Ref<Texture> incr = get_icon("increment"); + double diff = (ofs - drag.pos_at_click) / get_area_size(); - double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); - double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width(); - double total = orientation == VERTICAL ? get_size().height : get_size().width; + set_as_ratio(drag.value_at_click + diff); + } else { - HighlightStatus new_highlight; + double ofs = orientation == VERTICAL ? m->get_pos().y : m->get_pos().x; + Ref<Texture> decr = get_icon("decrement"); + Ref<Texture> incr = get_icon("increment"); - if (ofs < decr_size) { + double decr_size = orientation == VERTICAL ? decr->get_height() : decr->get_width(); + double incr_size = orientation == VERTICAL ? incr->get_height() : incr->get_width(); + double total = orientation == VERTICAL ? get_size().height : get_size().width; - new_highlight = HIGHLIGHT_DECR; + HighlightStatus new_hilite; - } else if (ofs > total - incr_size) { + if (ofs < decr_size) { - new_highlight = HIGHLIGHT_INCR; + new_hilite = HIGHLIGHT_DECR; - } else { + } else if (ofs > total - incr_size) { - new_highlight = HIGHLIGHT_RANGE; - } + new_hilite = HIGHLIGHT_INCR; - if (new_highlight != highlight) { + } else { - highlight = new_highlight; - update(); - } + new_hilite = HIGHLIGHT_RANGE; } - } break; - case InputEvent::KEY: { - const InputEventKey &k = p_event.key; + if (new_hilite != highlight) { - if (!k.pressed) - return; + highlight = new_hilite; + update(); + } + } + } - switch (k.scancode) { + Ref<InputEventKey> k = p_event; - case KEY_LEFT: { + if (k.is_valid()) { - if (orientation != HORIZONTAL) - return; - set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); + if (!k->is_pressed()) + return; - } break; - case KEY_RIGHT: { + switch (k->get_scancode()) { - if (orientation != HORIZONTAL) - return; - set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); + case KEY_LEFT: { - } break; - case KEY_UP: { + if (orientation != HORIZONTAL) + return; + set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); - if (orientation != VERTICAL) - return; + } break; + case KEY_RIGHT: { - set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); + if (orientation != HORIZONTAL) + return; + set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); - } break; - case KEY_DOWN: { + } break; + case KEY_UP: { - if (orientation != VERTICAL) - return; - set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); + if (orientation != VERTICAL) + return; - } break; - case KEY_HOME: { + set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); - set_value(get_min()); + } break; + case KEY_DOWN: { - } break; - case KEY_END: { + if (orientation != VERTICAL) + return; + set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); - set_value(get_max()); + } break; + case KEY_HOME: { - } break; - } - break; + set_value(get_min()); + + } break; + case KEY_END: { + + set_value(get_max()); + + } break; } } } @@ -522,87 +519,84 @@ void ScrollBar::_drag_slave_exit() { drag_slave = NULL; } -void ScrollBar::_drag_slave_input(const InputEvent &p_input) { +void ScrollBar::_drag_slave_input(const Ref<InputEvent> &p_input) { - switch (p_input.type) { + Ref<InputEventMouseButton> mb = p_input; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_input.mouse_button; + if (mb->get_button_index() != 1) + return; - if (mb.button_index != 1) - break; + if (mb->is_pressed()) { + + if (drag_slave_touching) { + set_fixed_process(false); + drag_slave_touching_deaccel = false; + drag_slave_touching = false; + drag_slave_speed = Vector2(); + drag_slave_accum = Vector2(); + last_drag_slave_accum = Vector2(); + drag_slave_from = Vector2(); + } - if (mb.pressed) { + if (true) { + drag_slave_speed = Vector2(); + drag_slave_accum = Vector2(); + last_drag_slave_accum = Vector2(); + //drag_slave_from=Vector2(h_scroll->get_val(),v_scroll->get_val()); + drag_slave_from = Vector2(orientation == HORIZONTAL ? get_value() : 0, orientation == VERTICAL ? get_value() : 0); + drag_slave_touching = OS::get_singleton()->has_touchscreen_ui_hint(); + drag_slave_touching_deaccel = false; + time_since_motion = 0; if (drag_slave_touching) { - set_fixed_process(false); - drag_slave_touching_deaccel = false; - drag_slave_touching = false; - drag_slave_speed = Vector2(); - drag_slave_accum = Vector2(); - last_drag_slave_accum = Vector2(); - drag_slave_from = Vector2(); + set_fixed_process(true); + time_since_motion = 0; } + } + + } else { - if (true) { - drag_slave_speed = Vector2(); - drag_slave_accum = Vector2(); - last_drag_slave_accum = Vector2(); - //drag_slave_from=Vector2(h_scroll->get_val(),v_scroll->get_val()); - drag_slave_from = Vector2(orientation == HORIZONTAL ? get_value() : 0, orientation == VERTICAL ? get_value() : 0); + if (drag_slave_touching) { - drag_slave_touching = OS::get_singleton()->has_touchscreen_ui_hint(); + if (drag_slave_speed == Vector2()) { drag_slave_touching_deaccel = false; - time_since_motion = 0; - if (drag_slave_touching) { - set_fixed_process(true); - time_since_motion = 0; - } + drag_slave_touching = false; + set_fixed_process(false); + } else { + + drag_slave_touching_deaccel = true; } + } + } + } - } else { + Ref<InputEventMouseMotion> mm = p_input; - if (drag_slave_touching) { + if (mm.is_valid()) { - if (drag_slave_speed == Vector2()) { - drag_slave_touching_deaccel = false; - drag_slave_touching = false; - set_fixed_process(false); - } else { + if (drag_slave_touching && !drag_slave_touching_deaccel) { - drag_slave_touching_deaccel = true; - } - } - } - } break; - case InputEvent::MOUSE_MOTION: { - - const InputEventMouseMotion &mm = p_input.mouse_motion; - - if (drag_slave_touching && !drag_slave_touching_deaccel) { - - Vector2 motion = Vector2(mm.relative_x, mm.relative_y); - - drag_slave_accum -= motion; - Vector2 diff = drag_slave_from + drag_slave_accum; - - if (orientation == HORIZONTAL) - set_value(diff.x); - /* - else - drag_slave_accum.x=0; - */ - if (orientation == VERTICAL) - set_value(diff.y); - /* - else - drag_slave_accum.y=0; - */ - time_since_motion = 0; - } + Vector2 motion = Vector2(mm->get_relative().x, mm->get_relative().y); - } break; + drag_slave_accum -= motion; + Vector2 diff = drag_slave_from + drag_slave_accum; + + if (orientation == HORIZONTAL) + set_value(diff.x); + /* + else + drag_slave_accum.x=0; + */ + if (orientation == VERTICAL) + set_value(diff.y); + /* + else + drag_slave_accum.y=0; + */ + time_since_motion = 0; + } } } @@ -640,11 +634,11 @@ NodePath ScrollBar::get_drag_slave() const { #if 0 -void ScrollBar::mouse_button(const Point2& p_pos, int b.button_index,bool b.pressed,int p_modifier_mask) { +void ScrollBar::mouse_button(const Point2& p_pos, int b->get_button_index(),bool b->is_pressed(),int p_modifier_mask) { // wheel! - if (b.button_index==BUTTON_WHEEL_UP && b.pressed) { + if (b->get_button_index()==BUTTON_WHEEL_UP && b->is_pressed()) { if (orientation==VERTICAL) set_val( get_val() - get_page() / 4.0 ); @@ -652,7 +646,7 @@ void ScrollBar::mouse_button(const Point2& p_pos, int b.button_index,bool b.pres set_val( get_val() + get_page() / 4.0 ); } - if (b.button_index==BUTTON_WHEEL_DOWN && b.pressed) { + if (b->get_button_index()==BUTTON_WHEEL_DOWN && b->is_pressed()) { if (orientation==HORIZONTAL) set_val( get_val() - get_page() / 4.0 ); @@ -660,10 +654,10 @@ void ScrollBar::mouse_button(const Point2& p_pos, int b.button_index,bool b.pres set_val( get_val() + get_page() / 4.0 ); } - if (b.button_index!=BUTTON_LEFT) + if (b->get_button_index()!=BUTTON_LEFT) return; - if (b.pressed) { + if (b->is_pressed()) { int ofs = orientation==VERTICAL ? p_pos.y : p_pos.x ; int grabber_ofs = get_grabber_offset(); @@ -692,7 +686,7 @@ void ScrollBar::mouse_button(const Point2& p_pos, int b.button_index,bool b.pres } } -void ScrollBar::mouse_motion(const Point2& p_pos, const Point2& p_rel, int b.button_index_mask) { +void ScrollBar::mouse_motion(const Point2& p_pos, const Point2& p_rel, int b->get_button_index()_mask) { if (!drag.active) return; @@ -712,9 +706,9 @@ void ScrollBar::mouse_motion(const Point2& p_pos, const Point2& p_rel, int b.but } -bool ScrollBar::key(unsigned long p_unicode, unsigned long p_scan_code,bool b.pressed,bool p_repeat,int p_modifier_mask) { +bool ScrollBar::key(unsigned long p_unicode, unsigned long p_scan_code,bool b->is_pressed(),bool p_repeat,int p_modifier_mask) { - if (!b.pressed) + if (!b->is_pressed()) return false; switch (p_scan_code) { diff --git a/scene/gui/scroll_bar.h b/scene/gui/scroll_bar.h index cb6bf227a0..8310e12590 100644 --- a/scene/gui/scroll_bar.h +++ b/scene/gui/scroll_bar.h @@ -84,9 +84,9 @@ class ScrollBar : public Range { bool click_handled; void _drag_slave_exit(); - void _drag_slave_input(const InputEvent &p_input); + void _drag_slave_input(const Ref<InputEvent> &p_input); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); protected: void _notification(int p_what); diff --git a/scene/gui/scroll_container.cpp b/scene/gui/scroll_container.cpp index a89c2b27c9..70b4ac47f8 100644 --- a/scene/gui/scroll_container.cpp +++ b/scene/gui/scroll_container.cpp @@ -76,113 +76,109 @@ void ScrollContainer::_cancel_drag() { drag_from = Vector2(); } -void ScrollContainer::_gui_input(const InputEvent &p_gui_input) { +void ScrollContainer::_gui_input(const Ref<InputEvent> &p_gui_input) { - switch (p_gui_input.type) { + Ref<InputEventMouseButton> mb = p_gui_input; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - const InputEventMouseButton &mb = p_gui_input.mouse_button; - - if (mb.button_index == BUTTON_WHEEL_UP && mb.pressed) { - // only horizontal is enabled, scroll horizontally - if (h_scroll->is_visible() && !v_scroll->is_visible()) { - h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() / 8 * mb.factor); - } else if (v_scroll->is_visible_in_tree()) { - v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() / 8 * mb.factor); - } + if (mb->get_button_index() == BUTTON_WHEEL_UP && mb->is_pressed()) { + // only horizontal is enabled, scroll horizontally + if (h_scroll->is_visible() && !v_scroll->is_visible()) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() / 8 * mb->get_factor()); + } else if (v_scroll->is_visible_in_tree()) { + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() / 8 * mb->get_factor()); } + } - if (mb.button_index == BUTTON_WHEEL_DOWN && mb.pressed) { - // only horizontal is enabled, scroll horizontally - if (h_scroll->is_visible() && !v_scroll->is_visible()) { - h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() / 8 * mb.factor); - } else if (v_scroll->is_visible()) { - v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() / 8 * mb.factor); - } + if (mb->get_button_index() == BUTTON_WHEEL_DOWN && mb->is_pressed()) { + // only horizontal is enabled, scroll horizontally + if (h_scroll->is_visible() && !v_scroll->is_visible()) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() / 8 * mb->get_factor()); + } else if (v_scroll->is_visible()) { + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() / 8 * mb->get_factor()); } + } - if (mb.button_index == BUTTON_WHEEL_LEFT && mb.pressed) { - if (h_scroll->is_visible_in_tree()) { - h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * mb.factor / 8); - } + if (mb->get_button_index() == BUTTON_WHEEL_LEFT && mb->is_pressed()) { + if (h_scroll->is_visible_in_tree()) { + h_scroll->set_value(h_scroll->get_value() - h_scroll->get_page() * mb->get_factor() / 8); } + } - if (mb.button_index == BUTTON_WHEEL_RIGHT && mb.pressed) { - if (h_scroll->is_visible_in_tree()) { - h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * mb.factor / 8); - } + if (mb->get_button_index() == BUTTON_WHEEL_RIGHT && mb->is_pressed()) { + if (h_scroll->is_visible_in_tree()) { + h_scroll->set_value(h_scroll->get_value() + h_scroll->get_page() * mb->get_factor() / 8); } + } - if (!OS::get_singleton()->has_touchscreen_ui_hint()) - return; + if (!OS::get_singleton()->has_touchscreen_ui_hint()) + return; - if (mb.button_index != BUTTON_LEFT) - break; + if (mb->get_button_index() != BUTTON_LEFT) + return; - if (mb.pressed) { + if (mb->is_pressed()) { - if (drag_touching) { - set_fixed_process(false); - drag_touching_deaccel = false; - drag_touching = false; - drag_speed = Vector2(); - drag_accum = Vector2(); - last_drag_accum = Vector2(); - drag_from = Vector2(); - } + if (drag_touching) { + set_fixed_process(false); + drag_touching_deaccel = false; + drag_touching = false; + drag_speed = Vector2(); + drag_accum = Vector2(); + last_drag_accum = Vector2(); + drag_from = Vector2(); + } - if (true) { - drag_speed = Vector2(); - drag_accum = Vector2(); - last_drag_accum = Vector2(); - drag_from = Vector2(h_scroll->get_value(), v_scroll->get_value()); - drag_touching = OS::get_singleton()->has_touchscreen_ui_hint(); - drag_touching_deaccel = false; + if (true) { + drag_speed = Vector2(); + drag_accum = Vector2(); + last_drag_accum = Vector2(); + drag_from = Vector2(h_scroll->get_value(), v_scroll->get_value()); + drag_touching = OS::get_singleton()->has_touchscreen_ui_hint(); + drag_touching_deaccel = false; + time_since_motion = 0; + if (drag_touching) { + set_fixed_process(true); time_since_motion = 0; - if (drag_touching) { - set_fixed_process(true); - time_since_motion = 0; - } } + } - } else { - if (drag_touching) { + } else { + if (drag_touching) { - if (drag_speed == Vector2()) { - drag_touching_deaccel = false; - drag_touching = false; - set_fixed_process(false); - } else { + if (drag_speed == Vector2()) { + drag_touching_deaccel = false; + drag_touching = false; + set_fixed_process(false); + } else { - drag_touching_deaccel = true; - } + drag_touching_deaccel = true; } } + } + } - } break; - case InputEvent::MOUSE_MOTION: { - - const InputEventMouseMotion &mm = p_gui_input.mouse_motion; + Ref<InputEventMouseMotion> mm = p_gui_input; - if (drag_touching && !drag_touching_deaccel) { + if (mm.is_valid()) { - Vector2 motion = Vector2(mm.relative_x, mm.relative_y); - drag_accum -= motion; - Vector2 diff = drag_from + drag_accum; + if (drag_touching && !drag_touching_deaccel) { - if (scroll_h) - h_scroll->set_value(diff.x); - else - drag_accum.x = 0; - if (scroll_v) - v_scroll->set_value(diff.y); - else - drag_accum.y = 0; - time_since_motion = 0; - } + Vector2 motion = Vector2(mm->get_relative().x, mm->get_relative().y); + drag_accum -= motion; + Vector2 diff = drag_from + drag_accum; - } break; + if (scroll_h) + h_scroll->set_value(diff.x); + else + drag_accum.x = 0; + if (scroll_v) + v_scroll->set_value(diff.y); + else + drag_accum.y = 0; + time_since_motion = 0; + } } } diff --git a/scene/gui/scroll_container.h b/scene/gui/scroll_container.h index bbc6d829ef..e5df3e5e1c 100644 --- a/scene/gui/scroll_container.h +++ b/scene/gui/scroll_container.h @@ -64,7 +64,7 @@ class ScrollContainer : public Container { protected: Size2 get_minimum_size() const; - void _gui_input(const InputEvent &p_gui_input); + void _gui_input(const Ref<InputEvent> &p_gui_input); void _notification(int p_what); void _scroll_moved(float); diff --git a/scene/gui/slider.cpp b/scene/gui/slider.cpp index ae52d6d452..ae2bf0999e 100644 --- a/scene/gui/slider.cpp +++ b/scene/gui/slider.cpp @@ -37,16 +37,17 @@ Size2 Slider::get_minimum_size() const { return ms; } -void Slider::_gui_input(InputEvent p_event) { +void Slider::_gui_input(Ref<InputEvent> p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_event; - InputEventMouseButton &mb = p_event.mouse_button; - if (mb.button_index == BUTTON_LEFT) { + if (mb.is_valid()) { + if (mb->get_button_index() == BUTTON_LEFT) { - if (mb.pressed) { + if (mb->is_pressed()) { Ref<Texture> grabber = get_icon(mouse_inside || has_focus() ? "grabber_highlight" : "grabber"); - grab.pos = orientation == VERTICAL ? mb.y : mb.x; + grab.pos = orientation == VERTICAL ? mb->get_pos().y : mb->get_pos().x; + double grab_width = (double)grabber->get_size().width; double grab_height = (double)grabber->get_size().height; double max = orientation == VERTICAL ? get_size().height - grab_height : get_size().width - grab_width; @@ -59,20 +60,22 @@ void Slider::_gui_input(InputEvent p_event) { } else { grab.active = false; } - } else if (mb.pressed && mb.button_index == BUTTON_WHEEL_UP) { + } else if (mb->is_pressed() && mb->get_button_index() == BUTTON_WHEEL_UP) { set_value(get_value() + get_step()); - } else if (mb.pressed && mb.button_index == BUTTON_WHEEL_DOWN) { + } else if (mb->is_pressed() && mb->get_button_index() == BUTTON_WHEEL_DOWN) { set_value(get_value() - get_step()); } + } - } else if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; + if (mm.is_valid()) { if (grab.active) { Size2i size = get_size(); Ref<Texture> grabber = get_icon("grabber"); - float motion = (orientation == VERTICAL ? p_event.mouse_motion.y : p_event.mouse_motion.x) - grab.pos; + float motion = (orientation == VERTICAL ? mm->get_pos().y : mm->get_pos().x) - grab.pos; if (orientation == VERTICAL) motion = -motion; float areasize = orientation == VERTICAL ? size.height - grabber->get_size().height : size.width - grabber->get_size().width; @@ -81,42 +84,44 @@ void Slider::_gui_input(InputEvent p_event) { float umotion = motion / float(areasize); set_as_ratio(grab.uvalue + umotion); } - } else { + } - if (p_event.is_action("ui_left") && p_event.is_pressed()) { + if (!mm.is_valid() && !mb.is_valid()) { + + if (p_event->is_action("ui_left") && p_event->is_pressed()) { if (orientation != HORIZONTAL) return; set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); accept_event(); - } else if (p_event.is_action("ui_right") && p_event.is_pressed()) { + } else if (p_event->is_action("ui_right") && p_event->is_pressed()) { if (orientation != HORIZONTAL) return; set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); accept_event(); - } else if (p_event.is_action("ui_up") && p_event.is_pressed()) { + } else if (p_event->is_action("ui_up") && p_event->is_pressed()) { if (orientation != VERTICAL) return; set_value(get_value() + (custom_step >= 0 ? custom_step : get_step())); accept_event(); - } else if (p_event.is_action("ui_down") && p_event.is_pressed()) { + } else if (p_event->is_action("ui_down") && p_event->is_pressed()) { if (orientation != VERTICAL) return; set_value(get_value() - (custom_step >= 0 ? custom_step : get_step())); accept_event(); - } else if (p_event.type == InputEvent::KEY) { + } else { - const InputEventKey &k = p_event.key; + Ref<InputEventKey> k = p_event; - if (!k.pressed) + if (!k.is_valid() || !k->is_pressed()) return; - switch (k.scancode) { + switch (k->get_scancode()) { case KEY_HOME: { @@ -129,7 +134,7 @@ void Slider::_gui_input(InputEvent p_event) { accept_event(); } break; - }; + } } } } diff --git a/scene/gui/slider.h b/scene/gui/slider.h index 61ad76e31e..7194484058 100644 --- a/scene/gui/slider.h +++ b/scene/gui/slider.h @@ -48,7 +48,7 @@ class Slider : public Range { float custom_step; protected: - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); void _notification(int p_what); static void _bind_methods(); bool ticks_on_borders; diff --git a/scene/gui/spin_box.cpp b/scene/gui/spin_box.cpp index 77bfd3edf7..2eb2028391 100644 --- a/scene/gui/spin_box.cpp +++ b/scene/gui/spin_box.cpp @@ -65,7 +65,7 @@ LineEdit *SpinBox::get_line_edit() { return line_edit; } -void SpinBox::_line_edit_input(const InputEvent &p_event) { +void SpinBox::_line_edit_input(const Ref<InputEvent> &p_event) { } void SpinBox::_range_click_timeout() { @@ -86,17 +86,19 @@ void SpinBox::_range_click_timeout() { } } -void SpinBox::_gui_input(const InputEvent &p_event) { +void SpinBox::_gui_input(const Ref<InputEvent> &p_event) { if (!is_editable()) { return; } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed) { - const InputEventMouseButton &mb = p_event.mouse_button; - bool up = mb.y < (get_size().height / 2); + Ref<InputEventMouseButton> mb = p_event; - switch (mb.button_index) { + if (mb.is_valid() && mb->is_pressed()) { + + bool up = mb->get_pos().y < (get_size().height / 2); + + switch (mb->get_button_index()) { case BUTTON_LEFT: { @@ -116,28 +118,28 @@ void SpinBox::_gui_input(const InputEvent &p_event) { case BUTTON_WHEEL_UP: { if (line_edit->has_focus()) { - set_value(get_value() + get_step() * mb.factor); + set_value(get_value() + get_step() * mb->get_factor()); accept_event(); } } break; case BUTTON_WHEEL_DOWN: { if (line_edit->has_focus()) { - set_value(get_value() - get_step() * mb.factor); + set_value(get_value() - get_step() * mb->get_factor()); accept_event(); } } break; } } - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index == 1) { + if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == 1) { //set_default_cursor_shape(CURSOR_VSIZE); - Vector2 cpos = Vector2(p_event.mouse_button.x, p_event.mouse_button.y); + Vector2 cpos = Vector2(mb->get_pos().x, mb->get_pos().y); drag.mouse_pos = cpos; } - if (p_event.type == InputEvent::MOUSE_BUTTON && !p_event.mouse_button.pressed && p_event.mouse_button.button_index == 1) { + if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == 1) { //set_default_cursor_shape(CURSOR_ARROW); range_click_timer->stop(); @@ -149,9 +151,12 @@ void SpinBox::_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_MOTION && p_event.mouse_button.button_mask & 1) { + Ref<InputEventMouseMotion> mm = p_event; + + if (mm.is_valid() && mm->get_button_mask() & 1) { + + Vector2 cpos = mm->get_pos(); - Vector2 cpos = Vector2(p_event.mouse_motion.x, p_event.mouse_motion.y); if (drag.enabled) { float diff_y = drag.mouse_pos.y - cpos.y; diff --git a/scene/gui/spin_box.h b/scene/gui/spin_box.h index 338ae875f0..683ed0c344 100644 --- a/scene/gui/spin_box.h +++ b/scene/gui/spin_box.h @@ -49,7 +49,7 @@ class SpinBox : public Range { String prefix; String suffix; - void _line_edit_input(const InputEvent &p_event); + void _line_edit_input(const Ref<InputEvent> &p_event); struct Drag { float base_val; @@ -62,7 +62,7 @@ class SpinBox : public Range { void _line_edit_focus_exit(); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); diff --git a/scene/gui/split_container.cpp b/scene/gui/split_container.cpp index df24fa84d8..91fd18e2ed 100644 --- a/scene/gui/split_container.cpp +++ b/scene/gui/split_container.cpp @@ -270,32 +270,32 @@ void SplitContainer::_notification(int p_what) { } } -void SplitContainer::_gui_input(const InputEvent &p_event) { +void SplitContainer::_gui_input(const Ref<InputEvent> &p_event) { if (collapsed || !_getch(0) || !_getch(1) || dragger_visibility != DRAGGER_VISIBLE) return; - if (p_event.type == InputEvent::MOUSE_BUTTON) { + Ref<InputEventMouseButton> mb = p_event; - const InputEventMouseButton &mb = p_event.mouse_button; + if (mb.is_valid()) { - if (mb.button_index == BUTTON_LEFT) { + if (mb->get_button_index() == BUTTON_LEFT) { - if (mb.pressed) { + if (mb->is_pressed()) { int sep = get_constant("separation"); if (vertical) { - if (mb.y > middle_sep && mb.y < middle_sep + sep) { + if (mb->get_pos().y > middle_sep && mb->get_pos().y < middle_sep + sep) { dragging = true; - drag_from = mb.y; + drag_from = mb->get_pos().y; drag_ofs = expand_ofs; } } else { - if (mb.x > middle_sep && mb.x < middle_sep + sep) { + if (mb->get_pos().x > middle_sep && mb->get_pos().x < middle_sep + sep) { dragging = true; - drag_from = mb.x; + drag_from = mb->get_pos().x; drag_ofs = expand_ofs; } } @@ -306,13 +306,13 @@ void SplitContainer::_gui_input(const InputEvent &p_event) { } } - if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; - const InputEventMouseMotion &mm = p_event.mouse_motion; + if (mm.is_valid()) { if (dragging) { - expand_ofs = drag_ofs + ((vertical ? mm.y : mm.x) - drag_from); + expand_ofs = drag_ofs + ((vertical ? mm->get_pos().y : mm->get_pos().x) - drag_from); queue_sort(); emit_signal("dragged", get_split_offset()); } diff --git a/scene/gui/split_container.h b/scene/gui/split_container.h index 12722c9f95..94b80cf279 100644 --- a/scene/gui/split_container.h +++ b/scene/gui/split_container.h @@ -59,7 +59,7 @@ private: void _resort(); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); static void _bind_methods(); diff --git a/scene/gui/tab_container.cpp b/scene/gui/tab_container.cpp index 0c7a58dc16..6bbfa1aeb0 100644 --- a/scene/gui/tab_container.cpp +++ b/scene/gui/tab_container.cpp @@ -63,11 +63,13 @@ int TabContainer::_get_top_margin() const { return tab_height + content_height; } -void TabContainer::_gui_input(const InputEvent &p_event) { +void TabContainer::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_BUTTON && p_event.mouse_button.pressed && p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; - Point2 pos(p_event.mouse_button.x, p_event.mouse_button.y); + if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) { + + Point2 pos(mb->get_pos().x, mb->get_pos().y); Size2 size = get_size(); // Click must be on tabs in the tab header area. @@ -662,4 +664,4 @@ TabContainer::TabContainer() { align = ALIGN_CENTER; tabs_visible = true; popup = NULL; -}
\ No newline at end of file +} diff --git a/scene/gui/tab_container.h b/scene/gui/tab_container.h index 87a99c82b8..1105c6b298 100644 --- a/scene/gui/tab_container.h +++ b/scene/gui/tab_container.h @@ -63,7 +63,7 @@ private: protected: void _child_renamed_callback(); - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); virtual void add_child_notify(Node *p_child); virtual void remove_child_notify(Node *p_child); diff --git a/scene/gui/tabs.cpp b/scene/gui/tabs.cpp index 797082f17c..d94c33e408 100644 --- a/scene/gui/tabs.cpp +++ b/scene/gui/tabs.cpp @@ -79,11 +79,13 @@ Size2 Tabs::get_minimum_size() const { return ms; } -void Tabs::_gui_input(const InputEvent &p_event) { +void Tabs::_gui_input(const Ref<InputEvent> &p_event) { - if (p_event.type == InputEvent::MOUSE_MOTION) { + Ref<InputEventMouseMotion> mm = p_event; - Point2 pos(p_event.mouse_motion.x, p_event.mouse_motion.y); + if (mm.is_valid()) { + + Point2 pos = mm->get_pos(); highlight_arrow = -1; if (buttons_visible) { @@ -130,9 +132,11 @@ void Tabs::_gui_input(const InputEvent &p_event) { return; } - if (rb_pressing && p_event.type == InputEvent::MOUSE_BUTTON && - !p_event.mouse_button.pressed && - p_event.mouse_button.button_index == BUTTON_LEFT) { + Ref<InputEventMouseButton> mb = p_event; + + if (rb_pressing && mb.is_valid() && + !mb->is_pressed() && + mb->get_button_index() == BUTTON_LEFT) { if (rb_hover != -1) { //pressed @@ -143,9 +147,9 @@ void Tabs::_gui_input(const InputEvent &p_event) { update(); } - if (cb_pressing && p_event.type == InputEvent::MOUSE_BUTTON && - !p_event.mouse_button.pressed && - p_event.mouse_button.button_index == BUTTON_LEFT) { + if (cb_pressing && mb.is_valid() && + !mb->is_pressed() && + mb->get_button_index() == BUTTON_LEFT) { if (cb_hover != -1) { //pressed @@ -156,12 +160,12 @@ void Tabs::_gui_input(const InputEvent &p_event) { update(); } - if (p_event.type == InputEvent::MOUSE_BUTTON && - p_event.mouse_button.pressed && - p_event.mouse_button.button_index == BUTTON_LEFT) { + if (mb.is_valid() && + mb->is_pressed() && + mb->get_button_index() == BUTTON_LEFT) { // clicks - Point2 pos(p_event.mouse_button.x, p_event.mouse_button.y); + Point2 pos(mb->get_pos().x, mb->get_pos().y); if (buttons_visible) { diff --git a/scene/gui/tabs.h b/scene/gui/tabs.h index 131526f298..61b97d2dff 100644 --- a/scene/gui/tabs.h +++ b/scene/gui/tabs.h @@ -90,7 +90,7 @@ private: void _ensure_no_over_offset(); protected: - void _gui_input(const InputEvent &p_event); + void _gui_input(const Ref<InputEvent> &p_event); void _notification(int p_what); static void _bind_methods(); diff --git a/scene/gui/text_edit.cpp b/scene/gui/text_edit.cpp index fb986cfb97..4989a3d863 100644 --- a/scene/gui/text_edit.cpp +++ b/scene/gui/text_edit.cpp @@ -1440,1271 +1440,1266 @@ void TextEdit::_get_mouse_pos(const Point2i &p_mouse, int &r_row, int &r_col) co r_col = col; } -void TextEdit::_gui_input(const InputEvent &p_gui_input) { +void TextEdit::_gui_input(const Ref<InputEvent> &p_gui_input) { - switch (p_gui_input.type) { + Ref<InputEventMouseButton> mb = p_gui_input; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { + if (completion_active && completion_rect.has_point(mb->get_pos())) { - const InputEventMouseButton &mb = p_gui_input.mouse_button; - - if (completion_active && completion_rect.has_point(Point2(mb.x, mb.y))) { - - if (!mb.pressed) - return; + if (!mb->is_pressed()) + return; - if (mb.button_index == BUTTON_WHEEL_UP) { - if (completion_index > 0) { - completion_index--; - completion_current = completion_options[completion_index]; - update(); - } + if (mb->get_button_index() == BUTTON_WHEEL_UP) { + if (completion_index > 0) { + completion_index--; + completion_current = completion_options[completion_index]; + update(); } - if (mb.button_index == BUTTON_WHEEL_DOWN) { + } + if (mb->get_button_index() == BUTTON_WHEEL_DOWN) { - if (completion_index < completion_options.size() - 1) { - completion_index++; - completion_current = completion_options[completion_index]; - update(); - } + if (completion_index < completion_options.size() - 1) { + completion_index++; + completion_current = completion_options[completion_index]; + update(); } + } - if (mb.button_index == BUTTON_LEFT) { + if (mb->get_button_index() == BUTTON_LEFT) { - completion_index = CLAMP(completion_line_ofs + (mb.y - completion_rect.pos.y) / get_row_height(), 0, completion_options.size() - 1); + completion_index = CLAMP(completion_line_ofs + (mb->get_pos().y - completion_rect.pos.y) / get_row_height(), 0, completion_options.size() - 1); - completion_current = completion_options[completion_index]; - update(); - if (mb.doubleclick) - _confirm_completion(); - } - return; - } else { - _cancel_completion(); - _cancel_code_hint(); + completion_current = completion_options[completion_index]; + update(); + if (mb->is_doubleclick()) + _confirm_completion(); } + return; + } else { + _cancel_completion(); + _cancel_code_hint(); + } - if (mb.pressed) { + if (mb->is_pressed()) { - if (mb.button_index == BUTTON_WHEEL_UP && !mb.mod.command) { - v_scroll->set_value(v_scroll->get_value() - (3 * mb.factor)); - } - if (mb.button_index == BUTTON_WHEEL_DOWN && !mb.mod.command) { - v_scroll->set_value(v_scroll->get_value() + (3 * mb.factor)); - } - if (mb.button_index == BUTTON_WHEEL_LEFT) { - h_scroll->set_value(h_scroll->get_value() - (100 * mb.factor)); - } - if (mb.button_index == BUTTON_WHEEL_RIGHT) { - h_scroll->set_value(h_scroll->get_value() + (100 * mb.factor)); - } - if (mb.button_index == BUTTON_LEFT) { + if (mb->get_button_index() == BUTTON_WHEEL_UP && !mb->get_command()) { + v_scroll->set_value(v_scroll->get_value() - (3 * mb->get_factor())); + } + if (mb->get_button_index() == BUTTON_WHEEL_DOWN && !mb->get_command()) { + v_scroll->set_value(v_scroll->get_value() + (3 * mb->get_factor())); + } + if (mb->get_button_index() == BUTTON_WHEEL_LEFT) { + h_scroll->set_value(h_scroll->get_value() - (100 * mb->get_factor())); + } + if (mb->get_button_index() == BUTTON_WHEEL_RIGHT) { + h_scroll->set_value(h_scroll->get_value() + (100 * mb->get_factor())); + } + if (mb->get_button_index() == BUTTON_LEFT) { - _reset_caret_blink_timer(); + _reset_caret_blink_timer(); - int row, col; - _get_mouse_pos(Point2i(mb.x, mb.y), row, col); + int row, col; + _get_mouse_pos(Point2i(mb->get_pos().x, mb->get_pos().y), row, col); - if (mb.mod.command && highlighted_word != String()) { + if (mb->get_command() && highlighted_word != String()) { - emit_signal("symbol_lookup", highlighted_word, row, col); + emit_signal("symbol_lookup", highlighted_word, row, col); + return; + } + + // toggle breakpoint on gutter click + if (draw_breakpoint_gutter) { + int gutter = cache.style_normal->get_margin(MARGIN_LEFT); + if (mb->get_pos().x > gutter && mb->get_pos().x <= gutter + cache.breakpoint_gutter_width + 3) { + set_line_as_breakpoint(row, !is_line_set_as_breakpoint(row)); + emit_signal("breakpoint_toggled", row); return; } + } - // toggle breakpoint on gutter click - if (draw_breakpoint_gutter) { - int gutter = cache.style_normal->get_margin(MARGIN_LEFT); - if (mb.x > gutter && mb.x <= gutter + cache.breakpoint_gutter_width + 3) { - set_line_as_breakpoint(row, !is_line_set_as_breakpoint(row)); - emit_signal("breakpoint_toggled", row); - return; - } - } + int prev_col = cursor.column; + int prev_line = cursor.line; - int prev_col = cursor.column; - int prev_line = cursor.line; + cursor_set_line(row); + cursor_set_column(col); - cursor_set_line(row); - cursor_set_column(col); + if (mb->get_shift() && (cursor.column != prev_col || cursor.line != prev_line)) { - if (mb.mod.shift && (cursor.column != prev_col || cursor.line != prev_line)) { + if (!selection.active) { + selection.active = true; + selection.selecting_mode = Selection::MODE_POINTER; + selection.from_column = prev_col; + selection.from_line = prev_line; + selection.to_column = cursor.column; + selection.to_line = cursor.line; + + if (selection.from_line > selection.to_line || (selection.from_line == selection.to_line && selection.from_column > selection.to_column)) { + SWAP(selection.from_column, selection.to_column); + SWAP(selection.from_line, selection.to_line); + selection.shiftclick_left = false; + } else { + selection.shiftclick_left = true; + } + selection.selecting_line = prev_line; + selection.selecting_column = prev_col; + update(); + } else { - if (!selection.active) { - selection.active = true; - selection.selecting_mode = Selection::MODE_POINTER; - selection.from_column = prev_col; - selection.from_line = prev_line; - selection.to_column = cursor.column; - selection.to_line = cursor.line; + if (cursor.line < selection.selecting_line || (cursor.line == selection.selecting_line && cursor.column < selection.selecting_column)) { - if (selection.from_line > selection.to_line || (selection.from_line == selection.to_line && selection.from_column > selection.to_column)) { + if (selection.shiftclick_left) { SWAP(selection.from_column, selection.to_column); SWAP(selection.from_line, selection.to_line); - selection.shiftclick_left = false; - } else { - selection.shiftclick_left = true; + selection.shiftclick_left = !selection.shiftclick_left; } - selection.selecting_line = prev_line; - selection.selecting_column = prev_col; - update(); - } else { + selection.from_column = cursor.column; + selection.from_line = cursor.line; - if (cursor.line < selection.selecting_line || (cursor.line == selection.selecting_line && cursor.column < selection.selecting_column)) { - - if (selection.shiftclick_left) { - SWAP(selection.from_column, selection.to_column); - SWAP(selection.from_line, selection.to_line); - selection.shiftclick_left = !selection.shiftclick_left; - } - selection.from_column = cursor.column; - selection.from_line = cursor.line; - - } else if (cursor.line > selection.selecting_line || (cursor.line == selection.selecting_line && cursor.column > selection.selecting_column)) { - - if (!selection.shiftclick_left) { - SWAP(selection.from_column, selection.to_column); - SWAP(selection.from_line, selection.to_line); - selection.shiftclick_left = !selection.shiftclick_left; - } - selection.to_column = cursor.column; - selection.to_line = cursor.line; + } else if (cursor.line > selection.selecting_line || (cursor.line == selection.selecting_line && cursor.column > selection.selecting_column)) { - } else { - selection.active = false; + if (!selection.shiftclick_left) { + SWAP(selection.from_column, selection.to_column); + SWAP(selection.from_line, selection.to_line); + selection.shiftclick_left = !selection.shiftclick_left; } + selection.to_column = cursor.column; + selection.to_line = cursor.line; - update(); + } else { + selection.active = false; } - } else { - - //if sel active and dblick last time < something - - //else - selection.active = false; - selection.selecting_mode = Selection::MODE_POINTER; - selection.selecting_line = row; - selection.selecting_column = col; + update(); } - if (!mb.doubleclick && (OS::get_singleton()->get_ticks_msec() - last_dblclk) < 600 && cursor.line == prev_line) { - //tripleclick select line - select(cursor.line, 0, cursor.line, text[cursor.line].length()); - selection.selecting_column = 0; - last_dblclk = 0; + } else { - } else if (mb.doubleclick && text[cursor.line].length()) { + //if sel active and dblick last time < something - //doubleclick select world - String s = text[cursor.line]; - int beg = CLAMP(cursor.column, 0, s.length()); - int end = beg; + //else + selection.active = false; + selection.selecting_mode = Selection::MODE_POINTER; + selection.selecting_line = row; + selection.selecting_column = col; + } - if (s[beg] > 32 || beg == s.length()) { + if (!mb->is_doubleclick() && (OS::get_singleton()->get_ticks_msec() - last_dblclk) < 600 && cursor.line == prev_line) { + //tripleclick select line + select(cursor.line, 0, cursor.line, text[cursor.line].length()); + selection.selecting_column = 0; + last_dblclk = 0; - bool symbol = beg < s.length() && _is_symbol(s[beg]); //not sure if right but most editors behave like this + } else if (mb->is_doubleclick() && text[cursor.line].length()) { - while (beg > 0 && s[beg - 1] > 32 && (symbol == _is_symbol(s[beg - 1]))) { - beg--; - } - while (end < s.length() && s[end + 1] > 32 && (symbol == _is_symbol(s[end + 1]))) { - end++; - } + //doubleclick select world + String s = text[cursor.line]; + int beg = CLAMP(cursor.column, 0, s.length()); + int end = beg; - if (end < s.length()) - end += 1; + if (s[beg] > 32 || beg == s.length()) { - select(cursor.line, beg, cursor.line, end); + bool symbol = beg < s.length() && _is_symbol(s[beg]); //not sure if right but most editors behave like this - selection.selecting_column = beg; + while (beg > 0 && s[beg - 1] > 32 && (symbol == _is_symbol(s[beg - 1]))) { + beg--; + } + while (end < s.length() && s[end + 1] > 32 && (symbol == _is_symbol(s[end + 1]))) { + end++; } - last_dblclk = OS::get_singleton()->get_ticks_msec(); - } + if (end < s.length()) + end += 1; - update(); - } + select(cursor.line, beg, cursor.line, end); - if (mb.button_index == BUTTON_RIGHT && context_menu_enabled) { + selection.selecting_column = beg; + } - menu->set_position(get_global_transform().xform(get_local_mouse_pos())); - menu->set_size(Vector2(1, 1)); - menu->popup(); - grab_focus(); + last_dblclk = OS::get_singleton()->get_ticks_msec(); } - } else { - if (mb.button_index == BUTTON_LEFT) - click_select_held->stop(); + update(); + } + + if (mb->get_button_index() == BUTTON_RIGHT && context_menu_enabled) { - // notify to show soft keyboard - notification(NOTIFICATION_FOCUS_ENTER); + menu->set_position(get_global_transform().xform(get_local_mouse_pos())); + menu->set_size(Vector2(1, 1)); + menu->popup(); + grab_focus(); } + } else { - } break; - case InputEvent::MOUSE_MOTION: { + if (mb->get_button_index() == BUTTON_LEFT) + click_select_held->stop(); + + // notify to show soft keyboard + notification(NOTIFICATION_FOCUS_ENTER); + } + } - const InputEventMouseMotion &mm = p_gui_input.mouse_motion; + Ref<InputEventMouseMotion> mm = p_gui_input; - if (select_identifiers_enabled) { - if (mm.mod.command && mm.button_mask == 0) { + if (mm.is_valid()) { - String new_word = get_word_at_pos(Vector2(mm.x, mm.y)); - if (new_word != highlighted_word) { - highlighted_word = new_word; - update(); - } - } else { - if (highlighted_word != String()) { - highlighted_word = String(); - update(); - } + if (select_identifiers_enabled) { + if (mm->get_command() && mm->get_button_mask() == 0) { + + String new_word = get_word_at_pos(mm->get_pos()); + if (new_word != highlighted_word) { + highlighted_word = new_word; + update(); + } + } else { + if (highlighted_word != String()) { + highlighted_word = String(); + update(); } } + } - if (mm.button_mask & BUTTON_MASK_LEFT && get_viewport()->gui_get_drag_data() == Variant()) { //ignore if dragging + if (mm->get_button_mask() & BUTTON_MASK_LEFT && get_viewport()->gui_get_drag_data() == Variant()) { //ignore if dragging - if (selection.selecting_mode != Selection::MODE_NONE) { + if (selection.selecting_mode != Selection::MODE_NONE) { - _reset_caret_blink_timer(); + _reset_caret_blink_timer(); - int row, col; - _get_mouse_pos(Point2i(mm.x, mm.y), row, col); + int row, col; + _get_mouse_pos(mm->get_pos(), row, col); - select(selection.selecting_line, selection.selecting_column, row, col); + select(selection.selecting_line, selection.selecting_column, row, col); - cursor_set_line(row); - cursor_set_column(col); - update(); + cursor_set_line(row); + cursor_set_column(col); + update(); - click_select_held->start(); - } + click_select_held->start(); } + } + } - } break; + Ref<InputEventKey> k = p_gui_input; - case InputEvent::KEY: { + if (k.is_valid()) { - InputEventKey k = p_gui_input.key; + k = k->duplicate(); //it will be modified later on #ifdef OSX_ENABLED - if (k.scancode == KEY_META) { + if (k->get_scancode() == KEY_META) { #else - if (k.scancode == KEY_CONTROL) { + if (k->get_scancode() == KEY_CONTROL) { #endif - if (select_identifiers_enabled) { + if (select_identifiers_enabled) { - if (k.pressed) { + if (k->is_pressed()) { - highlighted_word = get_word_at_pos(get_local_mouse_pos()); - update(); + highlighted_word = get_word_at_pos(get_local_mouse_pos()); + update(); - } else { - highlighted_word = String(); - update(); - } + } else { + highlighted_word = String(); + update(); } } + } - if (!k.pressed) - return; - - if (completion_active) { - if (readonly) - break; - - bool valid = true; - if (k.mod.command || k.mod.meta) - valid = false; - - if (valid) { - - if (!k.mod.alt) { - if (k.scancode == KEY_UP) { + if (!k->is_pressed()) + return; - if (completion_index > 0) { - completion_index--; - completion_current = completion_options[completion_index]; - update(); - } - accept_event(); - return; - } + if (completion_active) { + if (readonly) + return; - if (k.scancode == KEY_DOWN) { + bool valid = true; + if (k->get_command() || k->get_metakey()) + valid = false; - if (completion_index < completion_options.size() - 1) { - completion_index++; - completion_current = completion_options[completion_index]; - update(); - } - accept_event(); - return; - } + if (valid) { - if (k.scancode == KEY_PAGEUP) { + if (!k->get_alt()) { + if (k->get_scancode() == KEY_UP) { - completion_index -= get_constant("completion_lines"); - if (completion_index < 0) - completion_index = 0; + if (completion_index > 0) { + completion_index--; completion_current = completion_options[completion_index]; update(); - accept_event(); - return; } + accept_event(); + return; + } - if (k.scancode == KEY_PAGEDOWN) { + if (k->get_scancode() == KEY_DOWN) { - completion_index += get_constant("completion_lines"); - if (completion_index >= completion_options.size()) - completion_index = completion_options.size() - 1; + if (completion_index < completion_options.size() - 1) { + completion_index++; completion_current = completion_options[completion_index]; update(); - accept_event(); - return; } + accept_event(); + return; + } - if (k.scancode == KEY_HOME && completion_index > 0) { + if (k->get_scancode() == KEY_PAGEUP) { + completion_index -= get_constant("completion_lines"); + if (completion_index < 0) completion_index = 0; - completion_current = completion_options[completion_index]; - update(); - accept_event(); - return; - } + completion_current = completion_options[completion_index]; + update(); + accept_event(); + return; + } - if (k.scancode == KEY_END && completion_index < completion_options.size() - 1) { + if (k->get_scancode() == KEY_PAGEDOWN) { + completion_index += get_constant("completion_lines"); + if (completion_index >= completion_options.size()) completion_index = completion_options.size() - 1; - completion_current = completion_options[completion_index]; - update(); - accept_event(); - return; - } - - if (k.scancode == KEY_DOWN) { + completion_current = completion_options[completion_index]; + update(); + accept_event(); + return; + } - if (completion_index < completion_options.size() - 1) { - completion_index++; - completion_current = completion_options[completion_index]; - update(); - } - accept_event(); - return; - } + if (k->get_scancode() == KEY_HOME && completion_index > 0) { - if (k.scancode == KEY_ENTER || k.scancode == KEY_RETURN || k.scancode == KEY_TAB) { + completion_index = 0; + completion_current = completion_options[completion_index]; + update(); + accept_event(); + return; + } - _confirm_completion(); - accept_event(); - return; - } + if (k->get_scancode() == KEY_END && completion_index < completion_options.size() - 1) { - if (k.scancode == KEY_BACKSPACE) { + completion_index = completion_options.size() - 1; + completion_current = completion_options[completion_index]; + update(); + accept_event(); + return; + } - _reset_caret_blink_timer(); + if (k->get_scancode() == KEY_DOWN) { - backspace_at_cursor(); - _update_completion_candidates(); - accept_event(); - return; + if (completion_index < completion_options.size() - 1) { + completion_index++; + completion_current = completion_options[completion_index]; + update(); } + accept_event(); + return; + } - if (k.scancode == KEY_SHIFT) { - accept_event(); - return; - } + if (k->get_scancode() == KEY_ENTER || k->get_scancode() == KEY_RETURN || k->get_scancode() == KEY_TAB) { + + _confirm_completion(); + accept_event(); + return; } - if (k.unicode > 32) { + if (k->get_scancode() == KEY_BACKSPACE) { _reset_caret_blink_timer(); - const CharType chr[2] = { (CharType)k.unicode, 0 }; - if (auto_brace_completion_enabled && _is_pair_symbol(chr[0])) { - _consume_pair_symbol(chr[0]); - } else { + backspace_at_cursor(); + _update_completion_candidates(); + accept_event(); + return; + } - // remove the old character if in insert mode - if (insert_mode) { - begin_complex_operation(); + if (k->get_scancode() == KEY_SHIFT) { + accept_event(); + return; + } + } - // make sure we don't try and remove empty space - if (cursor.column < get_line(cursor.line).length()) { - _remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1); - } - } + if (k->get_unicode() > 32) { - _insert_text_at_cursor(chr); + _reset_caret_blink_timer(); - if (insert_mode) { - end_complex_operation(); + const CharType chr[2] = { (CharType)k->get_unicode(), 0 }; + if (auto_brace_completion_enabled && _is_pair_symbol(chr[0])) { + _consume_pair_symbol(chr[0]); + } else { + + // remove the old character if in insert mode + if (insert_mode) { + begin_complex_operation(); + + // make sure we don't try and remove empty space + if (cursor.column < get_line(cursor.line).length()) { + _remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1); } } - _update_completion_candidates(); - accept_event(); - return; + _insert_text_at_cursor(chr); + + if (insert_mode) { + end_complex_operation(); + } } - } + _update_completion_candidates(); + accept_event(); - _cancel_completion(); + return; + } } - /* TEST CONTROL FIRST!! */ + _cancel_completion(); + } - // some remaps for duplicate functions.. - if (k.mod.command && !k.mod.shift && !k.mod.alt && !k.mod.meta && k.scancode == KEY_INSERT) { + /* TEST CONTROL FIRST!! */ - k.scancode = KEY_C; - } - if (!k.mod.command && k.mod.shift && !k.mod.alt && !k.mod.meta && k.scancode == KEY_INSERT) { + // some remaps for duplicate functions.. + if (k->get_command() && !k->get_shift() && !k->get_alt() && !k->get_metakey() && k->get_scancode() == KEY_INSERT) { - k.scancode = KEY_V; - k.mod.command = true; - k.mod.shift = false; - } + k->set_scancode(KEY_C); + } + if (!k->get_command() && k->get_shift() && !k->get_alt() && !k->get_metakey() && k->get_scancode() == KEY_INSERT) { - if (!k.mod.command) { - _reset_caret_blink_timer(); - } + k->set_scancode(KEY_V); + k->set_command(true); + k->set_shift(false); + } - // save here for insert mode, just in case it is cleared in the following section - bool had_selection = selection.active; + if (!k->get_command()) { + _reset_caret_blink_timer(); + } - // stuff to do when selection is active.. - if (selection.active) { + // save here for insert mode, just in case it is cleared in the following section + bool had_selection = selection.active; - if (readonly) - break; + // stuff to do when selection is active.. + if (selection.active) { - bool clear = false; - bool unselect = false; - bool dobreak = false; + if (readonly) + return; - switch (k.scancode) { + bool clear = false; + bool unselect = false; + bool dobreak = false; - case KEY_TAB: { - if (k.mod.shift) { - indent_selection_left(); - } else { - indent_selection_right(); - } - dobreak = true; - accept_event(); - } break; - case KEY_X: - case KEY_C: - //special keys often used with control, wait... - clear = (!k.mod.command || k.mod.shift || k.mod.alt); - break; - case KEY_DELETE: - if (!k.mod.shift) { - accept_event(); - clear = true; - dobreak = true; - } else if (k.mod.command || k.mod.alt) { - dobreak = true; - } - break; - case KEY_BACKSPACE: + switch (k->get_scancode()) { + + case KEY_TAB: { + if (k->get_shift()) { + indent_selection_left(); + } else { + indent_selection_right(); + } + dobreak = true; + accept_event(); + } break; + case KEY_X: + case KEY_C: + //special keys often used with control, wait... + clear = (!k->get_command() || k->get_shift() || k->get_alt()); + break; + case KEY_DELETE: + if (!k->get_shift()) { accept_event(); clear = true; dobreak = true; + } else if (k->get_command() || k->get_alt()) { + dobreak = true; + } + break; + case KEY_BACKSPACE: + accept_event(); + clear = true; + dobreak = true; + break; + case KEY_LEFT: + case KEY_RIGHT: + case KEY_UP: + case KEY_DOWN: + case KEY_PAGEUP: + case KEY_PAGEDOWN: + case KEY_HOME: + case KEY_END: + // ignore arrows if any modifiers are held (shift = selecting, others may be used for editor hotkeys) + if (k->get_command() || k->get_shift() || k->get_alt()) break; - case KEY_LEFT: - case KEY_RIGHT: - case KEY_UP: - case KEY_DOWN: - case KEY_PAGEUP: - case KEY_PAGEDOWN: - case KEY_HOME: - case KEY_END: - // ignore arrows if any modifiers are held (shift = selecting, others may be used for editor hotkeys) - if (k.mod.command || k.mod.shift || k.mod.alt) - break; - unselect = true; - break; + unselect = true; + break; - default: - if (k.unicode >= 32 && !k.mod.command && !k.mod.alt && !k.mod.meta) - clear = true; - if (auto_brace_completion_enabled && _is_pair_left_symbol(k.unicode)) - clear = false; - } + default: + if (k->get_unicode() >= 32 && !k->get_command() && !k->get_alt() && !k->get_metakey()) + clear = true; + if (auto_brace_completion_enabled && _is_pair_left_symbol(k->get_unicode())) + clear = false; + } - if (unselect) { - selection.active = false; - selection.selecting_mode = Selection::MODE_NONE; - update(); - } - if (clear) { + if (unselect) { + selection.active = false; + selection.selecting_mode = Selection::MODE_NONE; + update(); + } + if (clear) { - if (!dobreak) { - begin_complex_operation(); - } - selection.active = false; - update(); - _remove_text(selection.from_line, selection.from_column, selection.to_line, selection.to_column); - cursor_set_line(selection.from_line); - cursor_set_column(selection.from_column); - update(); + if (!dobreak) { + begin_complex_operation(); } - if (dobreak) - break; + selection.active = false; + update(); + _remove_text(selection.from_line, selection.from_column, selection.to_line, selection.to_column); + cursor_set_line(selection.from_line); + cursor_set_column(selection.from_column); + update(); } + if (dobreak) + return; + } - selection.selecting_text = false; + selection.selecting_text = false; - bool scancode_handled = true; + bool scancode_handled = true; - // special scancode test... + // special scancode test... - switch (k.scancode) { + switch (k->get_scancode()) { - case KEY_ENTER: - case KEY_RETURN: { + case KEY_ENTER: + case KEY_RETURN: { - if (readonly) - break; + if (readonly) + break; - String ins = "\n"; + String ins = "\n"; - //keep indentation - int space_count = 0; - for (int i = 0; i < text[cursor.line].length(); i++) { - if (text[cursor.line][i] == '\t') { + //keep indentation + int space_count = 0; + for (int i = 0; i < text[cursor.line].length(); i++) { + if (text[cursor.line][i] == '\t') { + if (indent_using_spaces) { + ins += space_indent; + } else { + ins += "\t"; + } + space_count = 0; + } else if (text[cursor.line][i] == ' ') { + space_count++; + + if (space_count == indent_size) { if (indent_using_spaces) { ins += space_indent; } else { ins += "\t"; } space_count = 0; - } else if (text[cursor.line][i] == ' ') { - space_count++; - - if (space_count == indent_size) { - if (indent_using_spaces) { - ins += space_indent; - } else { - ins += "\t"; - } - space_count = 0; - } - } else { - break; } + } else { + break; } - if (auto_indent) { - // indent once again if previous line will end with ':' - // (i.e. colon precedes current cursor position) - if (cursor.column > 0 && text[cursor.line][cursor.column - 1] == ':') { - if (indent_using_spaces) { - ins += space_indent; - } else { - ins += "\t"; - } + } + if (auto_indent) { + // indent once again if previous line will end with ':' + // (i.e. colon precedes current cursor position) + if (cursor.column > 0 && text[cursor.line][cursor.column - 1] == ':') { + if (indent_using_spaces) { + ins += space_indent; + } else { + ins += "\t"; } } + } - bool first_line = false; - if (k.mod.command) { - if (k.mod.shift) { - if (cursor.line > 0) { - cursor_set_line(cursor.line - 1); - cursor_set_column(text[cursor.line].length()); - } else { - cursor_set_column(0); - first_line = true; - } - } else { + bool first_line = false; + if (k->get_command()) { + if (k->get_shift()) { + if (cursor.line > 0) { + cursor_set_line(cursor.line - 1); cursor_set_column(text[cursor.line].length()); + } else { + cursor_set_column(0); + first_line = true; } + } else { + cursor_set_column(text[cursor.line].length()); } + } - _insert_text_at_cursor(ins); - _push_current_op(); + _insert_text_at_cursor(ins); + _push_current_op(); - if (first_line) { - cursor_set_line(0); - } + if (first_line) { + cursor_set_line(0); + } - } break; - case KEY_ESCAPE: { - if (completion_hint != "") { - completion_hint = ""; - update(); - } else { - scancode_handled = false; - } - } break; - case KEY_TAB: { - if (k.mod.command) break; // avoid tab when command + } break; + case KEY_ESCAPE: { + if (completion_hint != "") { + completion_hint = ""; + update(); + } else { + scancode_handled = false; + } + } break; + case KEY_TAB: { + if (k->get_command()) break; // avoid tab when command - if (readonly) - break; + if (readonly) + break; - if (selection.active) { + if (selection.active) { - } else { - if (k.mod.shift) { - - //simple unindent - int cc = cursor.column; - if (cc > 0 && cc <= text[cursor.line].length()) { - if (text[cursor.line][cursor.column - 1] == '\t') { - backspace_at_cursor(); - } else { - if (cursor.column - indent_size >= 0) { - - bool unindent = true; - for (int i = 1; i <= indent_size; i++) { - if (text[cursor.line][cursor.column - i] != ' ') { - unindent = false; - break; - } - } + } else { + if (k->get_shift()) { - if (unindent) { - _remove_text(cursor.line, cursor.column - indent_size, cursor.line, cursor.column); - cursor_set_column(cursor.column - indent_size); + //simple unindent + int cc = cursor.column; + if (cc > 0 && cc <= text[cursor.line].length()) { + if (text[cursor.line][cursor.column - 1] == '\t') { + backspace_at_cursor(); + } else { + if (cursor.column - indent_size >= 0) { + + bool unindent = true; + for (int i = 1; i <= indent_size; i++) { + if (text[cursor.line][cursor.column - i] != ' ') { + unindent = false; + break; } } + + if (unindent) { + _remove_text(cursor.line, cursor.column - indent_size, cursor.line, cursor.column); + cursor_set_column(cursor.column - indent_size); + } } } + } + } else { + //simple indent + if (indent_using_spaces) { + _insert_text_at_cursor(space_indent); } else { - //simple indent - if (indent_using_spaces) { - _insert_text_at_cursor(space_indent); - } else { - _insert_text_at_cursor("\t"); - } + _insert_text_at_cursor("\t"); } } + } - } break; - case KEY_BACKSPACE: { - if (readonly) - break; + } break; + case KEY_BACKSPACE: { + if (readonly) + break; #ifdef APPLE_STYLE_KEYS - if (k.mod.alt) { + if (k->get_alt()) { #else - if (k.mod.alt) { - scancode_handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + scancode_handled = false; + break; + } else if (k->get_command()) { #endif - int line = cursor.line; - int column = cursor.column; - - bool prev_char = false; - bool only_whitespace = true; - - while (only_whitespace && line > 0) { - - while (column > 0) { - CharType c = text[line][column - 1]; - - if (c != '\t' && c != ' ') { - only_whitespace = false; - break; - } + int line = cursor.line; + int column = cursor.column; - column--; - } + bool prev_char = false; + bool only_whitespace = true; - if (only_whitespace) { - line--; - column = text[line].length(); - } - } + while (only_whitespace && line > 0) { while (column > 0) { - bool ischar = _is_text_char(text[line][column - 1]); + CharType c = text[line][column - 1]; - if (prev_char && !ischar) + if (c != '\t' && c != ' ') { + only_whitespace = false; break; + } - prev_char = ischar; column--; } - _remove_text(line, column, cursor.line, cursor.column); + if (only_whitespace) { + line--; + column = text[line].length(); + } + } - cursor_set_line(line); - cursor_set_column(column); + while (column > 0) { + bool ischar = _is_text_char(text[line][column - 1]); - } else { - backspace_at_cursor(); - } + if (prev_char && !ischar) + break; - } break; - case KEY_KP_4: { - if (k.unicode != 0) { - scancode_handled = false; - break; + prev_char = ischar; + column--; } - // numlock disabled. fallthrough to key_left + + _remove_text(line, column, cursor.line, cursor.column); + + cursor_set_line(line); + cursor_set_column(column); + + } else { + backspace_at_cursor(); } - case KEY_LEFT: { - if (k.mod.shift) - _pre_shift_selection(); + } break; + case KEY_KP_4: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; + } + // numlock disabled. fallthrough to key_left + } + case KEY_LEFT: { + + if (k->get_shift()) + _pre_shift_selection(); #ifdef APPLE_STYLE_KEYS - else + else #else - else if (!k.mod.alt) + else if (!k->get_alt()) #endif - deselect(); + deselect(); #ifdef APPLE_STYLE_KEYS - if (k.mod.command) { - cursor_set_column(0); - } else if (k.mod.alt) { + if (k->get_command()) { + cursor_set_column(0); + } else if (k->get_alt()) { #else - if (k.mod.alt) { - scancode_handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + scancode_handled = false; + break; + } else if (k->get_command()) { #endif - bool prev_char = false; - int cc = cursor.column; - while (cc > 0) { + bool prev_char = false; + int cc = cursor.column; + while (cc > 0) { - bool ischar = _is_text_char(text[cursor.line][cc - 1]); + bool ischar = _is_text_char(text[cursor.line][cc - 1]); - if (prev_char && !ischar) - break; + if (prev_char && !ischar) + break; - prev_char = ischar; - cc--; - } + prev_char = ischar; + cc--; + } - cursor_set_column(cc); + cursor_set_column(cc); - } else if (cursor.column == 0) { + } else if (cursor.column == 0) { - if (cursor.line > 0) { - cursor_set_line(cursor.line - 1); - cursor_set_column(text[cursor.line].length()); - } - } else { - cursor_set_column(cursor_get_column() - 1); + if (cursor.line > 0) { + cursor_set_line(cursor.line - 1); + cursor_set_column(text[cursor.line].length()); } + } else { + cursor_set_column(cursor_get_column() - 1); + } - if (k.mod.shift) - _post_shift_selection(); + if (k->get_shift()) + _post_shift_selection(); - } break; - case KEY_KP_6: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_right + } break; + case KEY_KP_6: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } - case KEY_RIGHT: { + // numlock disabled. fallthrough to key_right + } + case KEY_RIGHT: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); #ifdef APPLE_STYLE_KEYS - else + else #else - else if (!k.mod.alt) + else if (!k->get_alt()) #endif - deselect(); + deselect(); #ifdef APPLE_STYLE_KEYS - if (k.mod.command) { - cursor_set_column(text[cursor.line].length()); - } else if (k.mod.alt) { + if (k->get_command()) { + cursor_set_column(text[cursor.line].length()); + } else if (k->get_alt()) { #else - if (k.mod.alt) { - scancode_handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + scancode_handled = false; + break; + } else if (k->get_command()) { #endif - bool prev_char = false; - int cc = cursor.column; - while (cc < text[cursor.line].length()) { + bool prev_char = false; + int cc = cursor.column; + while (cc < text[cursor.line].length()) { - bool ischar = _is_text_char(text[cursor.line][cc]); + bool ischar = _is_text_char(text[cursor.line][cc]); - if (prev_char && !ischar) - break; - prev_char = ischar; - cc++; - } + if (prev_char && !ischar) + break; + prev_char = ischar; + cc++; + } - cursor_set_column(cc); + cursor_set_column(cc); - } else if (cursor.column == text[cursor.line].length()) { + } else if (cursor.column == text[cursor.line].length()) { - if (cursor.line < text.size() - 1) { - cursor_set_line(cursor.line + 1); - cursor_set_column(0); - } - } else { - cursor_set_column(cursor_get_column() + 1); + if (cursor.line < text.size() - 1) { + cursor_set_line(cursor.line + 1); + cursor_set_column(0); } + } else { + cursor_set_column(cursor_get_column() + 1); + } - if (k.mod.shift) - _post_shift_selection(); + if (k->get_shift()) + _post_shift_selection(); - } break; - case KEY_KP_8: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_up + } break; + case KEY_KP_8: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } - case KEY_UP: { + // numlock disabled. fallthrough to key_up + } + case KEY_UP: { - if (k.mod.shift) - _pre_shift_selection(); - if (k.mod.alt) { - scancode_handled = false; - break; - } + if (k->get_shift()) + _pre_shift_selection(); + if (k->get_alt()) { + scancode_handled = false; + break; + } #ifndef APPLE_STYLE_KEYS - if (k.mod.command) { - _scroll_lines_up(); - break; - } + if (k->get_command()) { + _scroll_lines_up(); + break; + } #else - if (k.mod.command && k.mod.alt) { - _scroll_lines_up(); - break; - } + if (k->get_command() && k->get_alt()) { + _scroll_lines_up(); + break; + } - if (k.mod.command) - cursor_set_line(0); - else + if (k->get_command()) + cursor_set_line(0); + else #endif - cursor_set_line(cursor_get_line() - 1); + cursor_set_line(cursor_get_line() - 1); - if (k.mod.shift) - _post_shift_selection(); - _cancel_code_hint(); + if (k->get_shift()) + _post_shift_selection(); + _cancel_code_hint(); - } break; - case KEY_KP_2: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_down + } break; + case KEY_KP_2: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } - case KEY_DOWN: { + // numlock disabled. fallthrough to key_down + } + case KEY_DOWN: { - if (k.mod.shift) - _pre_shift_selection(); - if (k.mod.alt) { - scancode_handled = false; - break; - } + if (k->get_shift()) + _pre_shift_selection(); + if (k->get_alt()) { + scancode_handled = false; + break; + } #ifndef APPLE_STYLE_KEYS - if (k.mod.command) { - _scroll_lines_down(); - break; - } + if (k->get_command()) { + _scroll_lines_down(); + break; + } #else - if (k.mod.command && k.mod.alt) { - _scroll_lines_down(); - break; - } + if (k->get_command() && k->get_alt()) { + _scroll_lines_down(); + break; + } - if (k.mod.command) - cursor_set_line(text.size() - 1); - else + if (k->get_command()) + cursor_set_line(text.size() - 1); + else #endif - cursor_set_line(cursor_get_line() + 1); + cursor_set_line(cursor_get_line() + 1); - if (k.mod.shift) - _post_shift_selection(); - _cancel_code_hint(); + if (k->get_shift()) + _post_shift_selection(); + _cancel_code_hint(); - } break; + } break; - case KEY_DELETE: { + case KEY_DELETE: { - if (readonly) - break; + if (readonly) + break; - if (k.mod.shift && !k.mod.command && !k.mod.alt) { - cut(); - break; - } + if (k->get_shift() && !k->get_command() && !k->get_alt()) { + cut(); + break; + } - int curline_len = text[cursor.line].length(); + int curline_len = text[cursor.line].length(); - if (cursor.line == text.size() - 1 && cursor.column == curline_len) - break; //nothing to do + if (cursor.line == text.size() - 1 && cursor.column == curline_len) + break; //nothing to do - int next_line = cursor.column < curline_len ? cursor.line : cursor.line + 1; - int next_column; + int next_line = cursor.column < curline_len ? cursor.line : cursor.line + 1; + int next_column; #ifdef APPLE_STYLE_KEYS - if (k.mod.alt) { + if (k->get_alt()) { #else - if (k.mod.alt) { - scancode_handled = false; - break; - } else if (k.mod.command) { + if (k->get_alt()) { + scancode_handled = false; + break; + } else if (k->get_command()) { #endif - int last_line = text.size() - 1; + int last_line = text.size() - 1; - int line = cursor.line; - int column = cursor.column; + int line = cursor.line; + int column = cursor.column; - bool prev_char = false; - bool only_whitespace = true; + bool prev_char = false; + bool only_whitespace = true; - while (only_whitespace && line < last_line) { + while (only_whitespace && line < last_line) { - while (column < text[line].length()) { - CharType c = text[line][column]; - - if (c != '\t' && c != ' ') { - only_whitespace = false; - break; - } + while (column < text[line].length()) { + CharType c = text[line][column]; - column++; + if (c != '\t' && c != ' ') { + only_whitespace = false; + break; } - if (only_whitespace) { - line++; - column = 0; - } + column++; } - while (column < text[line].length()) { + if (only_whitespace) { + line++; + column = 0; + } + } - bool ischar = _is_text_char(text[line][column]); + while (column < text[line].length()) { - if (prev_char && !ischar) - break; - prev_char = ischar; - column++; - } + bool ischar = _is_text_char(text[line][column]); - next_line = line; - next_column = column; - } else { - next_column = cursor.column < curline_len ? (cursor.column + 1) : 0; + if (prev_char && !ischar) + break; + prev_char = ischar; + column++; } - _remove_text(cursor.line, cursor.column, next_line, next_column); - update(); + next_line = line; + next_column = column; + } else { + next_column = cursor.column < curline_len ? (cursor.column + 1) : 0; + } - } break; - case KEY_KP_7: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_home + _remove_text(cursor.line, cursor.column, next_line, next_column); + update(); + + } break; + case KEY_KP_7: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } + // numlock disabled. fallthrough to key_home + } #ifdef APPLE_STYLE_KEYS - case KEY_HOME: { + case KEY_HOME: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); - cursor_set_line(0); + cursor_set_line(0); - if (k.mod.shift) - _post_shift_selection(); - else if (k.mod.command || k.mod.control) - deselect(); + if (k->get_shift()) + _post_shift_selection(); + else if (k->get_command() || k->get_control()) + deselect(); - } break; + } break; #else - case KEY_HOME: { + case KEY_HOME: { - if (k.mod.shift) - _pre_shift_selection(); - - if (k.mod.command) { - cursor_set_line(0); - cursor_set_column(0); - } else { - // compute whitespace symbols seq length - int current_line_whitespace_len = 0; - while (current_line_whitespace_len < text[cursor.line].length()) { - CharType c = text[cursor.line][current_line_whitespace_len]; - if (c != '\t' && c != ' ') - break; - current_line_whitespace_len++; - } + if (k->get_shift()) + _pre_shift_selection(); - if (cursor_get_column() == current_line_whitespace_len) - cursor_set_column(0); - else - cursor_set_column(current_line_whitespace_len); + if (k->get_command()) { + cursor_set_line(0); + cursor_set_column(0); + } else { + // compute whitespace symbols seq length + int current_line_whitespace_len = 0; + while (current_line_whitespace_len < text[cursor.line].length()) { + CharType c = text[cursor.line][current_line_whitespace_len]; + if (c != '\t' && c != ' ') + break; + current_line_whitespace_len++; } - if (k.mod.shift) - _post_shift_selection(); - else if (k.mod.command || k.mod.control) - deselect(); - _cancel_completion(); - completion_hint = ""; + if (cursor_get_column() == current_line_whitespace_len) + cursor_set_column(0); + else + cursor_set_column(current_line_whitespace_len); + } - } break; + if (k->get_shift()) + _post_shift_selection(); + else if (k->get_command() || k->get_control()) + deselect(); + _cancel_completion(); + completion_hint = ""; + + } break; #endif - case KEY_KP_1: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_end + case KEY_KP_1: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } + // numlock disabled. fallthrough to key_end + } #ifdef APPLE_STYLE_KEYS - case KEY_END: { + case KEY_END: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); - cursor_set_line(text.size() - 1); + cursor_set_line(text.size() - 1); - if (k.mod.shift) - _post_shift_selection(); - else if (k.mod.command || k.mod.control) - deselect(); + if (k->get_shift()) + _post_shift_selection(); + else if (k->get_command() || k->get_control()) + deselect(); - } break; + } break; #else - case KEY_END: { + case KEY_END: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); - if (k.mod.command) - cursor_set_line(text.size() - 1); - cursor_set_column(text[cursor.line].length()); + if (k->get_command()) + cursor_set_line(text.size() - 1); + cursor_set_column(text[cursor.line].length()); - if (k.mod.shift) - _post_shift_selection(); - else if (k.mod.command || k.mod.control) - deselect(); + if (k->get_shift()) + _post_shift_selection(); + else if (k->get_command() || k->get_control()) + deselect(); - _cancel_completion(); - completion_hint = ""; + _cancel_completion(); + completion_hint = ""; - } break; + } break; #endif - case KEY_KP_9: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_pageup + case KEY_KP_9: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } - case KEY_PAGEUP: { + // numlock disabled. fallthrough to key_pageup + } + case KEY_PAGEUP: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); - cursor_set_line(cursor_get_line() - get_visible_rows()); + cursor_set_line(cursor_get_line() - get_visible_rows()); - if (k.mod.shift) - _post_shift_selection(); + if (k->get_shift()) + _post_shift_selection(); - _cancel_completion(); - completion_hint = ""; + _cancel_completion(); + completion_hint = ""; - } break; - case KEY_KP_3: { - if (k.unicode != 0) { - scancode_handled = false; - break; - } - // numlock disabled. fallthrough to key_pageup + } break; + case KEY_KP_3: { + if (k->get_unicode() != 0) { + scancode_handled = false; + break; } - case KEY_PAGEDOWN: { + // numlock disabled. fallthrough to key_pageup + } + case KEY_PAGEDOWN: { - if (k.mod.shift) - _pre_shift_selection(); + if (k->get_shift()) + _pre_shift_selection(); - cursor_set_line(cursor_get_line() + get_visible_rows()); + cursor_set_line(cursor_get_line() + get_visible_rows()); - if (k.mod.shift) - _post_shift_selection(); + if (k->get_shift()) + _post_shift_selection(); - _cancel_completion(); - completion_hint = ""; + _cancel_completion(); + completion_hint = ""; - } break; - case KEY_A: { + } break; + case KEY_A: { - if (!k.mod.command || k.mod.shift || k.mod.alt) { - scancode_handled = false; - break; - } + if (!k->get_command() || k->get_shift() || k->get_alt()) { + scancode_handled = false; + break; + } - select_all(); + select_all(); - } break; - case KEY_X: { - if (readonly) { - break; - } - if (!k.mod.command || k.mod.shift || k.mod.alt) { - scancode_handled = false; - break; - } + } break; + case KEY_X: { + if (readonly) { + break; + } + if (!k->get_command() || k->get_shift() || k->get_alt()) { + scancode_handled = false; + break; + } - cut(); + cut(); - } break; - case KEY_C: { + } break; + case KEY_C: { - if (!k.mod.command || k.mod.shift || k.mod.alt) { - scancode_handled = false; - break; - } + if (!k->get_command() || k->get_shift() || k->get_alt()) { + scancode_handled = false; + break; + } - copy(); + copy(); - } break; - case KEY_Z: { + } break; + case KEY_Z: { - if (!k.mod.command) { - scancode_handled = false; - break; - } + if (!k->get_command()) { + scancode_handled = false; + break; + } - if (k.mod.shift) - redo(); - else - undo(); - } break; - case KEY_V: { - if (readonly) { - break; - } - if (!k.mod.command || k.mod.shift || k.mod.alt) { - scancode_handled = false; - break; - } + if (k->get_shift()) + redo(); + else + undo(); + } break; + case KEY_V: { + if (readonly) { + break; + } + if (!k->get_command() || k->get_shift() || k->get_alt()) { + scancode_handled = false; + break; + } - paste(); + paste(); - } break; - case KEY_SPACE: { + } break; + case KEY_SPACE: { #ifdef OSX_ENABLED - if (completion_enabled && k.mod.meta) { //cmd-space is spotlight shortcut in OSX + if (completion_enabled && k->get_metakey()) { //cmd-space is spotlight shortcut in OSX #else - if (completion_enabled && k.mod.command) { + if (completion_enabled && k->get_command()) { #endif - query_code_comple(); - scancode_handled = true; - } else { - scancode_handled = false; - } + query_code_comple(); + scancode_handled = true; + } else { + scancode_handled = false; + } - } break; + } break; - case KEY_U: { - if (!k.mod.command || k.mod.shift) { - scancode_handled = false; - break; - } else { - if (selection.active) { - int ini = selection.from_line; - int end = selection.to_line; - for (int i = ini; i <= end; i++) { - if (text[i][0] == '#') - _remove_text(i, 0, i, 1); - } - } else { - if (text[cursor.line][0] == '#') - _remove_text(cursor.line, 0, cursor.line, 1); + case KEY_U: { + if (!k->get_command() || k->get_shift()) { + scancode_handled = false; + break; + } else { + if (selection.active) { + int ini = selection.from_line; + int end = selection.to_line; + for (int i = ini; i <= end; i++) { + if (text[i][0] == '#') + _remove_text(i, 0, i, 1); } - update(); + } else { + if (text[cursor.line][0] == '#') + _remove_text(cursor.line, 0, cursor.line, 1); } - } break; + update(); + } + } break; - default: { + default: { - scancode_handled = false; - } break; - } + scancode_handled = false; + } break; + } - if (scancode_handled) - accept_event(); - /* - if (!scancode_handled && !k.mod.command && !k.mod.alt) { + if (scancode_handled) + accept_event(); + /* + if (!scancode_handled && !k->get_command() && !k->get_alt()) { - if (k.unicode>=32) { + if (k->get_unicode()>=32) { - if (readonly) - break; + if (readonly) + break; - accept_event(); - } else { + accept_event(); + } else { - break; - } - } + break; + } + } */ - if (k.scancode == KEY_INSERT) { - set_insert_mode(!insert_mode); - accept_event(); - return; - } - - if (!scancode_handled && !k.mod.command) { //for german kbds + if (k->get_scancode() == KEY_INSERT) { + set_insert_mode(!insert_mode); + accept_event(); + return; + } - if (k.unicode >= 32) { + if (!scancode_handled && !k->get_command()) { //for german kbds - if (readonly) - break; + if (k->get_unicode() >= 32) { - // remove the old character if in insert mode and no selection - if (insert_mode && !had_selection) { - begin_complex_operation(); - - // make sure we don't try and remove empty space - if (cursor.column < get_line(cursor.line).length()) { - _remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1); - } - } + if (readonly) + return; - const CharType chr[2] = { (CharType)k.unicode, 0 }; + // remove the old character if in insert mode and no selection + if (insert_mode && !had_selection) { + begin_complex_operation(); - if (completion_hint != "" && k.unicode == ')') { - completion_hint = ""; - } - if (auto_brace_completion_enabled && _is_pair_symbol(chr[0])) { - _consume_pair_symbol(chr[0]); - } else { - _insert_text_at_cursor(chr); + // make sure we don't try and remove empty space + if (cursor.column < get_line(cursor.line).length()) { + _remove_text(cursor.line, cursor.column, cursor.line, cursor.column + 1); } + } - if (insert_mode && !had_selection) { - end_complex_operation(); - } + const CharType chr[2] = { (CharType)k->get_unicode(), 0 }; - if (selection.active != had_selection) { - end_complex_operation(); - } - accept_event(); + if (completion_hint != "" && k->get_unicode() == ')') { + completion_hint = ""; + } + if (auto_brace_completion_enabled && _is_pair_symbol(chr[0])) { + _consume_pair_symbol(chr[0]); } else { + _insert_text_at_cursor(chr); + } - break; + if (insert_mode && !had_selection) { + end_complex_operation(); + } + + if (selection.active != had_selection) { + end_complex_operation(); } + accept_event(); + } else { } + } - return; - } break; + return; } } diff --git a/scene/gui/text_edit.h b/scene/gui/text_edit.h index 905ea46bd7..f8f60d2b03 100644 --- a/scene/gui/text_edit.h +++ b/scene/gui/text_edit.h @@ -337,7 +337,7 @@ protected: void _insert_text(int p_line, int p_column, const String &p_text, int *r_end_line = NULL, int *r_end_char = NULL); void _remove_text(int p_from_line, int p_from_column, int p_to_line, int p_to_column); void _insert_text_at_cursor(const String &p_text); - void _gui_input(const InputEvent &p_input); + void _gui_input(const Ref<InputEvent> &p_input); void _notification(int p_what); void _consume_pair_symbol(CharType ch); diff --git a/scene/gui/tree.cpp b/scene/gui/tree.cpp index f77b160f57..9ada68f5dc 100644 --- a/scene/gui/tree.cpp +++ b/scene/gui/tree.cpp @@ -1410,10 +1410,12 @@ void Tree::_range_click_timeout() { } click_handled = false; - InputModifierState mod = InputModifierState(); // should be irrelevant.. + Ref<InputEventMouseButton> mb; + mb.instance(); + ; blocked++; - propagate_mouse_event(pos + cache.offset, 0, 0, false, root, BUTTON_LEFT, mod); + propagate_mouse_event(pos + cache.offset, 0, 0, false, root, BUTTON_LEFT, mb); blocked--; if (range_click_timer->is_one_shot()) { @@ -1430,7 +1432,7 @@ void Tree::_range_click_timeout() { } } -int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_doubleclick, TreeItem *p_item, int p_button, const InputModifierState &p_mod) { +int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_doubleclick, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod) { int item_h = compute_item_height(p_item) + cache.vseparation; @@ -1522,7 +1524,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool return -1; } - if (select_mode == SELECT_MULTI && p_mod.command && c.selectable) { + if (select_mode == SELECT_MULTI && p_mod->get_command() && c.selectable) { if (!c.selected || p_button == BUTTON_RIGHT) { @@ -1544,7 +1546,7 @@ int Tree::propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool if (c.selectable) { - if (select_mode == SELECT_MULTI && p_mod.shift && selected_item && selected_item != p_item) { + if (select_mode == SELECT_MULTI && p_mod->get_shift() && selected_item && selected_item != p_item) { bool inrange = false; @@ -1839,537 +1841,534 @@ void Tree::popup_select(int p_option) { item_edited(popup_edited_item_col, popup_edited_item); } -void Tree::_gui_input(InputEvent p_event) { +void Tree::_gui_input(Ref<InputEvent> p_event) { - switch (p_event.type) { + Ref<InputEventKey> k = p_event; - case InputEvent::KEY: { + if (k.is_valid()) { - if (!p_event.key.pressed) - break; - if (p_event.key.mod.alt || p_event.key.mod.command || (p_event.key.mod.shift && p_event.key.unicode == 0) || p_event.key.mod.meta) - break; - if (!root) - return; + if (!k->is_pressed()) + return; + if (k->get_alt() || k->get_command() || (k->get_shift() && k->get_unicode() == 0) || k->get_metakey()) + return; + if (!root) + return; - if (hide_root && !root->get_next_visible()) - return; + if (hide_root && !root->get_next_visible()) + return; - switch (p_event.key.scancode) { + switch (k->get_scancode()) { #define EXIT_BREAK \ { \ if (!cursor_can_exit_tree) accept_event(); \ break; \ } - case KEY_RIGHT: { - - //TreeItem *next = NULL; - if (!selected_item) - break; - if (select_mode == SELECT_ROW) - EXIT_BREAK; - if (selected_col >= (columns.size() - 1)) - EXIT_BREAK; - if (select_mode == SELECT_MULTI) { - selected_col++; - emit_signal("cell_selected"); - } else { - - selected_item->select(selected_col + 1); - } + case KEY_RIGHT: { + + //TreeItem *next = NULL; + if (!selected_item) + break; + if (select_mode == SELECT_ROW) + EXIT_BREAK; + if (selected_col >= (columns.size() - 1)) + EXIT_BREAK; + if (select_mode == SELECT_MULTI) { + selected_col++; + emit_signal("cell_selected"); + } else { - update(); - ensure_cursor_is_visible(); - accept_event(); + selected_item->select(selected_col + 1); + } - } break; - case KEY_LEFT: { + update(); + ensure_cursor_is_visible(); + accept_event(); - //TreeItem *next = NULL; - if (!selected_item) - break; - if (select_mode == SELECT_ROW) - EXIT_BREAK; - if (selected_col <= 0) - EXIT_BREAK; - if (select_mode == SELECT_MULTI) { - selected_col--; - emit_signal("cell_selected"); - } else { + } break; + case KEY_LEFT: { + + //TreeItem *next = NULL; + if (!selected_item) + break; + if (select_mode == SELECT_ROW) + EXIT_BREAK; + if (selected_col <= 0) + EXIT_BREAK; + if (select_mode == SELECT_MULTI) { + selected_col--; + emit_signal("cell_selected"); + } else { - selected_item->select(selected_col - 1); - } + selected_item->select(selected_col - 1); + } - update(); - accept_event(); + update(); + accept_event(); - } break; - case KEY_DOWN: { + } break; + case KEY_DOWN: { - TreeItem *next = NULL; - if (!selected_item) { + TreeItem *next = NULL; + if (!selected_item) { - next = hide_root ? root->get_next_visible() : root; - selected_item = 0; - } else { + next = hide_root ? root->get_next_visible() : root; + selected_item = 0; + } else { - next = selected_item->get_next_visible(); + next = selected_item->get_next_visible(); - //if (diff < uint64_t(GLOBAL_DEF("gui/incr_search_max_interval_msec",2000))) { - if (last_keypress != 0) { - //incr search next - int col; - next = _search_item_text(next, incr_search, &col, true); - if (!next) { - accept_event(); - return; - } + //if (diff < uint64_t(GLOBAL_DEF("gui/incr_search_max_interval_msec",2000))) { + if (last_keypress != 0) { + //incr search next + int col; + next = _search_item_text(next, incr_search, &col, true); + if (!next) { + accept_event(); + return; } } + } - if (select_mode == SELECT_MULTI) { + if (select_mode == SELECT_MULTI) { - if (!next) - EXIT_BREAK; + if (!next) + EXIT_BREAK; - selected_item = next; - emit_signal("cell_selected"); - update(); - } else { + selected_item = next; + emit_signal("cell_selected"); + update(); + } else { - int col = selected_col < 0 ? 0 : selected_col; + int col = selected_col < 0 ? 0 : selected_col; - while (next && !next->cells[col].selectable) - next = next->get_next_visible(); - if (!next) - EXIT_BREAK; // do nothing.. - next->select(col); - } + while (next && !next->cells[col].selectable) + next = next->get_next_visible(); + if (!next) + EXIT_BREAK; // do nothing.. + next->select(col); + } - ensure_cursor_is_visible(); - accept_event(); + ensure_cursor_is_visible(); + accept_event(); - } break; - case KEY_UP: { + } break; + case KEY_UP: { - TreeItem *prev = NULL; - if (!selected_item) { - prev = get_last_item(); - selected_col = 0; - } else { + TreeItem *prev = NULL; + if (!selected_item) { + prev = get_last_item(); + selected_col = 0; + } else { - prev = selected_item->get_prev_visible(); - if (last_keypress != 0) { - //incr search next - int col; - prev = _search_item_text(prev, incr_search, &col, true, true); - if (!prev) { - accept_event(); - return; - } + prev = selected_item->get_prev_visible(); + if (last_keypress != 0) { + //incr search next + int col; + prev = _search_item_text(prev, incr_search, &col, true, true); + if (!prev) { + accept_event(); + return; } } + } - if (select_mode == SELECT_MULTI) { + if (select_mode == SELECT_MULTI) { - if (!prev) - break; - selected_item = prev; - emit_signal("cell_selected"); - update(); - } else { + if (!prev) + break; + selected_item = prev; + emit_signal("cell_selected"); + update(); + } else { - int col = selected_col < 0 ? 0 : selected_col; - while (prev && !prev->cells[col].selectable) - prev = prev->get_prev_visible(); - if (!prev) - break; // do nothing.. - prev->select(col); - } + int col = selected_col < 0 ? 0 : selected_col; + while (prev && !prev->cells[col].selectable) + prev = prev->get_prev_visible(); + if (!prev) + break; // do nothing.. + prev->select(col); + } - ensure_cursor_is_visible(); - accept_event(); + ensure_cursor_is_visible(); + accept_event(); - } break; - case KEY_PAGEDOWN: { + } break; + case KEY_PAGEDOWN: { - TreeItem *next = NULL; - if (!selected_item) - break; - next = selected_item; + TreeItem *next = NULL; + if (!selected_item) + break; + next = selected_item; - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 10; i++) { - TreeItem *_n = next->get_next_visible(); - if (_n) { - next = _n; - } else { + TreeItem *_n = next->get_next_visible(); + if (_n) { + next = _n; + } else { - break; - } - } - if (next == selected_item) break; + } + } + if (next == selected_item) + break; - if (select_mode == SELECT_MULTI) { + if (select_mode == SELECT_MULTI) { - selected_item = next; - emit_signal("cell_selected"); - update(); - } else { + selected_item = next; + emit_signal("cell_selected"); + update(); + } else { - while (next && !next->cells[selected_col].selectable) - next = next->get_next_visible(); - if (!next) - EXIT_BREAK; // do nothing.. - next->select(selected_col); - } + while (next && !next->cells[selected_col].selectable) + next = next->get_next_visible(); + if (!next) + EXIT_BREAK; // do nothing.. + next->select(selected_col); + } - ensure_cursor_is_visible(); - } break; - case KEY_PAGEUP: { + ensure_cursor_is_visible(); + } break; + case KEY_PAGEUP: { - TreeItem *prev = NULL; - if (!selected_item) - break; - prev = selected_item; + TreeItem *prev = NULL; + if (!selected_item) + break; + prev = selected_item; - for (int i = 0; i < 10; i++) { + for (int i = 0; i < 10; i++) { - TreeItem *_n = prev->get_prev_visible(); - if (_n) { - prev = _n; - } else { + TreeItem *_n = prev->get_prev_visible(); + if (_n) { + prev = _n; + } else { - break; - } - } - if (prev == selected_item) break; + } + } + if (prev == selected_item) + break; - if (select_mode == SELECT_MULTI) { + if (select_mode == SELECT_MULTI) { - selected_item = prev; - emit_signal("cell_selected"); - update(); - } else { + selected_item = prev; + emit_signal("cell_selected"); + update(); + } else { - while (prev && !prev->cells[selected_col].selectable) - prev = prev->get_prev_visible(); - if (!prev) - EXIT_BREAK; // do nothing.. - prev->select(selected_col); - } + while (prev && !prev->cells[selected_col].selectable) + prev = prev->get_prev_visible(); + if (!prev) + EXIT_BREAK; // do nothing.. + prev->select(selected_col); + } - ensure_cursor_is_visible(); + ensure_cursor_is_visible(); - } break; - case KEY_F2: - case KEY_RETURN: - case KEY_ENTER: { - - if (selected_item) { - //bring up editor if possible - if (!edit_selected()) { - emit_signal("item_activated"); - incr_search.clear(); - } + } break; + case KEY_F2: + case KEY_RETURN: + case KEY_ENTER: { + + if (selected_item) { + //bring up editor if possible + if (!edit_selected()) { + emit_signal("item_activated"); + incr_search.clear(); } - accept_event(); + } + accept_event(); - } break; - case KEY_SPACE: { - if (select_mode == SELECT_MULTI) { - if (!selected_item) - break; - if (selected_item->is_selected(selected_col)) { - selected_item->deselect(selected_col); - emit_signal("multi_selected", selected_item, selected_col, false); - } else if (selected_item->is_selectable(selected_col)) { - selected_item->select(selected_col); - emit_signal("multi_selected", selected_item, selected_col, true); - } + } break; + case KEY_SPACE: { + if (select_mode == SELECT_MULTI) { + if (!selected_item) + break; + if (selected_item->is_selected(selected_col)) { + selected_item->deselect(selected_col); + emit_signal("multi_selected", selected_item, selected_col, false); + } else if (selected_item->is_selectable(selected_col)) { + selected_item->select(selected_col); + emit_signal("multi_selected", selected_item, selected_col, true); } - accept_event(); + } + accept_event(); - } break; - default: { + } break; + default: { - if (p_event.key.unicode > 0) { + if (k->get_unicode() > 0) { - _do_incr_search(String::chr(p_event.key.unicode)); - accept_event(); + _do_incr_search(String::chr(k->get_unicode())); + accept_event(); - return; - } else { - if (p_event.key.scancode != KEY_SHIFT) - last_keypress = 0; - } - } break; + return; + } else { + if (k->get_scancode() != KEY_SHIFT) + last_keypress = 0; + } + } break; - last_keypress = 0; - } + last_keypress = 0; + } + } - } break; + Ref<InputEventMouseMotion> mm = p_event; - case InputEvent::MOUSE_MOTION: { + if (mm.is_valid()) { - if (cache.font.is_null()) // avoid a strange case that may fuckup stuff - update_cache(); - const InputEventMouseMotion &b = p_event.mouse_motion; + if (cache.font.is_null()) // avoid a strange case that may fuckup stuff + update_cache(); - Ref<StyleBox> bg = cache.bg; + Ref<StyleBox> bg = cache.bg; - Point2 pos = Point2(b.x, b.y) - bg->get_offset(); + Point2 pos = mm->get_pos() - bg->get_offset(); - Cache::ClickType old_hover = cache.hover_type; - int old_index = cache.hover_index; + Cache::ClickType old_hover = cache.hover_type; + int old_index = cache.hover_index; - cache.hover_type = Cache::CLICK_NONE; - cache.hover_index = 0; - if (show_column_titles) { - pos.y -= _get_title_button_height(); - if (pos.y < 0) { - pos.x += cache.offset.x; - int len = 0; - for (int i = 0; i < columns.size(); i++) { - - len += get_column_width(i); - if (pos.x < len) { - - cache.hover_type = Cache::CLICK_TITLE; - cache.hover_index = i; - update(); - break; - } + cache.hover_type = Cache::CLICK_NONE; + cache.hover_index = 0; + if (show_column_titles) { + pos.y -= _get_title_button_height(); + if (pos.y < 0) { + pos.x += cache.offset.x; + int len = 0; + for (int i = 0; i < columns.size(); i++) { + + len += get_column_width(i); + if (pos.x < len) { + + cache.hover_type = Cache::CLICK_TITLE; + cache.hover_index = i; + update(); + break; } } } + } - if (drop_mode_flags && root) { + if (drop_mode_flags && root) { - Point2 mpos = Point2(b.x, b.y); - mpos -= cache.bg->get_offset(); - mpos.y -= _get_title_button_height(); - if (mpos.y >= 0) { + Point2 mpos = mm->get_pos(); + mpos -= cache.bg->get_offset(); + mpos.y -= _get_title_button_height(); + if (mpos.y >= 0) { - if (h_scroll->is_visible_in_tree()) - mpos.x += h_scroll->get_value(); - if (v_scroll->is_visible_in_tree()) - mpos.y += v_scroll->get_value(); + if (h_scroll->is_visible_in_tree()) + mpos.x += h_scroll->get_value(); + if (v_scroll->is_visible_in_tree()) + mpos.y += v_scroll->get_value(); - int col, h, section; - TreeItem *it = _find_item_at_pos(root, mpos, col, h, section); + int col, h, section; + TreeItem *it = _find_item_at_pos(root, mpos, col, h, section); - if (it != drop_mode_over || section != drop_mode_section) { - drop_mode_over = it; - drop_mode_section = section; - update(); - } + if (it != drop_mode_over || section != drop_mode_section) { + drop_mode_over = it; + drop_mode_section = section; + update(); } } + } - if (cache.hover_type != old_hover || cache.hover_index != old_index) { - update(); - } + if (cache.hover_type != old_hover || cache.hover_index != old_index) { + update(); + } - if (pressing_for_editor && popup_edited_item && (popup_edited_item->get_cell_mode(popup_edited_item_col) == TreeItem::CELL_MODE_RANGE || popup_edited_item->get_cell_mode(popup_edited_item_col) == TreeItem::CELL_MODE_RANGE_EXPRESSION)) { - //range drag + if (pressing_for_editor && popup_edited_item && (popup_edited_item->get_cell_mode(popup_edited_item_col) == TreeItem::CELL_MODE_RANGE || popup_edited_item->get_cell_mode(popup_edited_item_col) == TreeItem::CELL_MODE_RANGE_EXPRESSION)) { + //range drag - if (!range_drag_enabled) { + if (!range_drag_enabled) { - Vector2 cpos = Vector2(b.x, b.y); - if (cpos.distance_to(pressing_pos) > 2) { - range_drag_enabled = true; - range_drag_capture_pos = cpos; - range_drag_base = popup_edited_item->get_range(popup_edited_item_col); - Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_CAPTURED); - } - } else { - - TreeItem::Cell &c = popup_edited_item->cells[popup_edited_item_col]; - float diff_y = -b.relative_y; - diff_y = Math::pow(ABS(diff_y), 1.8f) * SGN(diff_y); - diff_y *= 0.1; - range_drag_base = CLAMP(range_drag_base + c.step * diff_y, c.min, c.max); - popup_edited_item->set_range(popup_edited_item_col, range_drag_base); - item_edited(popup_edited_item_col, popup_edited_item); + Vector2 cpos = mm->get_pos(); + if (cpos.distance_to(pressing_pos) > 2) { + range_drag_enabled = true; + range_drag_capture_pos = cpos; + range_drag_base = popup_edited_item->get_range(popup_edited_item_col); + Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_CAPTURED); } + } else { + + TreeItem::Cell &c = popup_edited_item->cells[popup_edited_item_col]; + float diff_y = -mm->get_relative().y; + diff_y = Math::pow(ABS(diff_y), 1.8f) * SGN(diff_y); + diff_y *= 0.1; + range_drag_base = CLAMP(range_drag_base + c.step * diff_y, c.min, c.max); + popup_edited_item->set_range(popup_edited_item_col, range_drag_base); + item_edited(popup_edited_item_col, popup_edited_item); } + } - if (drag_touching && !drag_touching_deaccel) { + if (drag_touching && !drag_touching_deaccel) { - drag_accum -= b.relative_y; - v_scroll->set_value(drag_from + drag_accum); - drag_speed = -b.speed_y; - } - } break; - case InputEvent::MOUSE_BUTTON: { + drag_accum -= mm->get_relative().y; + v_scroll->set_value(drag_from + drag_accum); + drag_speed = -mm->get_speed().y; + } + } - if (cache.font.is_null()) // avoid a strange case that may fuckup stuff - update_cache(); - const InputEventMouseButton &b = p_event.mouse_button; + Ref<InputEventMouseButton> b = p_event; - if (!b.pressed) { + if (b.is_valid()) { + if (cache.font.is_null()) // avoid a strange case that may fuckup stuff + update_cache(); - if (b.button_index == BUTTON_LEFT) { + if (!b->is_pressed()) { - Ref<StyleBox> bg = cache.bg; + if (b->get_button_index() == BUTTON_LEFT) { - Point2 pos = Point2(b.x, b.y) - bg->get_offset(); - if (show_column_titles) { - pos.y -= _get_title_button_height(); + Point2 pos = b->get_pos() - cache.bg->get_offset(); + if (show_column_titles) { + pos.y -= _get_title_button_height(); - if (pos.y < 0) { - pos.x += cache.offset.x; - int len = 0; - for (int i = 0; i < columns.size(); i++) { + if (pos.y < 0) { + pos.x += cache.offset.x; + int len = 0; + for (int i = 0; i < columns.size(); i++) { - len += get_column_width(i); - if (pos.x < len) { - emit_signal("column_title_pressed", i); - break; - } + len += get_column_width(i); + if (pos.x < len) { + emit_signal("column_title_pressed", i); + break; } } } + } - if (single_select_defer) { - select_single_item(single_select_defer, root, single_select_defer_column); - single_select_defer = NULL; - } + if (single_select_defer) { + select_single_item(single_select_defer, root, single_select_defer_column); + single_select_defer = NULL; + } - range_click_timer->stop(); + range_click_timer->stop(); - if (pressing_for_editor) { + if (pressing_for_editor) { - if (range_drag_enabled) { + if (range_drag_enabled) { - range_drag_enabled = false; - Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE); - warp_mouse(range_drag_capture_pos); + range_drag_enabled = false; + Input::get_singleton()->set_mouse_mode(Input::MOUSE_MODE_VISIBLE); + warp_mouse(range_drag_capture_pos); + } else { + Rect2 rect = get_selected()->get_meta("__focus_rect"); + if (rect.has_point(Point2(b->get_pos().x, b->get_pos().y))) { + edit_selected(); } else { - Rect2 rect = get_selected()->get_meta("__focus_rect"); - if (rect.has_point(Point2(p_event.mouse_button.x, p_event.mouse_button.y))) { - edit_selected(); - } else { - emit_signal("item_double_clicked"); - } + emit_signal("item_double_clicked"); } - pressing_for_editor = false; } + pressing_for_editor = false; + } - if (cache.click_type == Cache::CLICK_BUTTON) { - // make sure in case of wrong reference after reconstructing whole TreeItems - cache.click_item = get_item_at_pos(cache.click_pos); - emit_signal("button_pressed", cache.click_item, cache.click_column, cache.click_id); - } - cache.click_type = Cache::CLICK_NONE; - cache.click_index = -1; - cache.click_id = -1; - cache.click_item = NULL; - cache.click_column = 0; + if (cache.click_type == Cache::CLICK_BUTTON) { + // make sure in case of wrong reference after reconstructing whole TreeItems + cache.click_item = get_item_at_pos(cache.click_pos); + emit_signal("button_pressed", cache.click_item, cache.click_column, cache.click_id); + } + cache.click_type = Cache::CLICK_NONE; + cache.click_index = -1; + cache.click_id = -1; + cache.click_item = NULL; + cache.click_column = 0; - if (drag_touching) { + if (drag_touching) { - if (drag_speed == 0) { - drag_touching_deaccel = false; - drag_touching = false; - set_fixed_process(false); - } else { + if (drag_speed == 0) { + drag_touching_deaccel = false; + drag_touching = false; + set_fixed_process(false); + } else { - drag_touching_deaccel = true; - } + drag_touching_deaccel = true; } - update(); } - break; + update(); } + return; + } - if (range_drag_enabled) - break; - - switch (b.button_index) { - case BUTTON_RIGHT: - case BUTTON_LEFT: { - Ref<StyleBox> bg = cache.bg; + if (range_drag_enabled) + return; - Point2 pos = Point2(b.x, b.y) - bg->get_offset(); - cache.click_type = Cache::CLICK_NONE; - if (show_column_titles && b.button_index == BUTTON_LEFT) { - pos.y -= _get_title_button_height(); - - if (pos.y < 0) { - pos.x += cache.offset.x; - int len = 0; - for (int i = 0; i < columns.size(); i++) { - - len += get_column_width(i); - if (pos.x < len) { - - cache.click_type = Cache::CLICK_TITLE; - cache.click_index = i; - //cache.click_id=; - update(); - break; - } + switch (b->get_button_index()) { + case BUTTON_RIGHT: + case BUTTON_LEFT: { + Ref<StyleBox> bg = cache.bg; + + Point2 pos = b->get_pos() - bg->get_offset(); + cache.click_type = Cache::CLICK_NONE; + if (show_column_titles && b->get_button_index() == BUTTON_LEFT) { + pos.y -= _get_title_button_height(); + + if (pos.y < 0) { + pos.x += cache.offset.x; + int len = 0; + for (int i = 0; i < columns.size(); i++) { + + len += get_column_width(i); + if (pos.x < len) { + + cache.click_type = Cache::CLICK_TITLE; + cache.click_index = i; + //cache.click_id=; + update(); + break; } - break; - } - } - if (!root || (!root->get_children() && hide_root)) { - if (b.button_index == BUTTON_RIGHT && allow_rmb_select) { - emit_signal("empty_tree_rmb_selected", get_local_mouse_pos()); } break; } + } + if (!root || (!root->get_children() && hide_root)) { + if (b->get_button_index() == BUTTON_RIGHT && allow_rmb_select) { + emit_signal("empty_tree_rmb_selected", get_local_mouse_pos()); + } + break; + } - click_handled = false; - pressing_for_editor = false; + click_handled = false; + pressing_for_editor = false; - blocked++; - bool handled = propagate_mouse_event(pos + cache.offset, 0, 0, b.doubleclick, root, b.button_index, b.mod); - blocked--; + blocked++; + bool handled = propagate_mouse_event(pos + cache.offset, 0, 0, b->is_doubleclick(), root, b->get_button_index(), b); + blocked--; - if (pressing_for_editor) { - pressing_pos = Point2(b.x, b.y); - } + if (pressing_for_editor) { + pressing_pos = b->get_pos(); + } - if (b.button_index == BUTTON_RIGHT) - break; + if (b->get_button_index() == BUTTON_RIGHT) + break; - if (drag_touching) { - set_fixed_process(false); - drag_touching_deaccel = false; - drag_touching = false; - drag_speed = 0; - drag_from = 0; - } + if (drag_touching) { + set_fixed_process(false); + drag_touching_deaccel = false; + drag_touching = false; + drag_speed = 0; + drag_from = 0; + } - if (!click_handled) { - drag_speed = 0; - drag_accum = 0; - //last_drag_accum=0; - drag_from = v_scroll->get_value(); - drag_touching = OS::get_singleton()->has_touchscreen_ui_hint(); - drag_touching_deaccel = false; - if (drag_touching) { - set_fixed_process(true); - } + if (!click_handled) { + drag_speed = 0; + drag_accum = 0; + //last_drag_accum=0; + drag_from = v_scroll->get_value(); + drag_touching = OS::get_singleton()->has_touchscreen_ui_hint(); + drag_touching_deaccel = false; + if (drag_touching) { + set_fixed_process(true); } + } - } break; - case BUTTON_WHEEL_UP: { - - v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * b.factor / 8); - } break; - case BUTTON_WHEEL_DOWN: { + } break; + case BUTTON_WHEEL_UP: { - v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * b.factor / 8); - } break; - } + v_scroll->set_value(v_scroll->get_value() - v_scroll->get_page() * b->get_factor() / 8); + } break; + case BUTTON_WHEEL_DOWN: { - } break; + v_scroll->set_value(v_scroll->get_value() + v_scroll->get_page() * b->get_factor() / 8); + } break; + } } } diff --git a/scene/gui/tree.h b/scene/gui/tree.h index 4bee1adc4b..0c07109e7d 100644 --- a/scene/gui/tree.h +++ b/scene/gui/tree.h @@ -337,14 +337,14 @@ private: void draw_item_rect(const TreeItem::Cell &p_cell, const Rect2i &p_rect, const Color &p_color); int draw_item(const Point2i &p_pos, const Point2 &p_draw_ofs, const Size2 &p_draw_size, TreeItem *p_item); void select_single_item(TreeItem *p_selected, TreeItem *p_current, int p_col, TreeItem *p_prev = NULL, bool *r_in_range = NULL, bool p_force_deselect = false); - int propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_doubleclick, TreeItem *p_item, int p_button, const InputModifierState &p_mod); + int propagate_mouse_event(const Point2i &p_pos, int x_ofs, int y_ofs, bool p_doubleclick, TreeItem *p_item, int p_button, const Ref<InputEventWithModifiers> &p_mod); void text_editor_enter(String p_text); void _text_editor_modal_close(); void value_editor_changed(double p_value); void popup_select(int p_option); - void _gui_input(InputEvent p_event); + void _gui_input(Ref<InputEvent> p_event); void _notification(int p_what); Size2 get_minimum_size() const; diff --git a/scene/main/node.cpp b/scene/main/node.cpp index bf91b109ad..0c65c44392 100755 --- a/scene/main/node.cpp +++ b/scene/main/node.cpp @@ -2938,9 +2938,9 @@ void Node::_bind_methods() { BIND_VMETHOD(MethodInfo("_enter_tree")); BIND_VMETHOD(MethodInfo("_exit_tree")); BIND_VMETHOD(MethodInfo("_ready")); - BIND_VMETHOD(MethodInfo("_input", PropertyInfo(Variant::INPUT_EVENT, "event"))); - BIND_VMETHOD(MethodInfo("_unhandled_input", PropertyInfo(Variant::INPUT_EVENT, "event"))); - BIND_VMETHOD(MethodInfo("_unhandled_key_input", PropertyInfo(Variant::INPUT_EVENT, "key_event"))); + BIND_VMETHOD(MethodInfo("_input", PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); + BIND_VMETHOD(MethodInfo("_unhandled_input", PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEvent"))); + BIND_VMETHOD(MethodInfo("_unhandled_key_input", PropertyInfo(Variant::OBJECT, "event", PROPERTY_HINT_RESOURCE_TYPE, "InputEventKey"))); //ClassDB::bind_method(D_METHOD("get_child",&Node::get_child,PH("index"))); //ClassDB::bind_method(D_METHOD("get_node",&Node::get_node,PH("path"))); diff --git a/scene/main/scene_main_loop.cpp b/scene/main/scene_main_loop.cpp index a43938c661..b55a925f55 100644 --- a/scene/main/scene_main_loop.cpp +++ b/scene/main/scene_main_loop.cpp @@ -379,9 +379,9 @@ bool SceneTree::is_input_handled() { return input_handled; } -void SceneTree::input_event(const InputEvent &p_event) { +void SceneTree::input_event(const Ref<InputEvent> &p_event) { - if (is_editor_hint() && (p_event.type == InputEvent::JOYPAD_MOTION || p_event.type == InputEvent::JOYPAD_BUTTON)) + if (is_editor_hint() && (p_event->cast_to<InputEventJoypadButton>() || p_event->cast_to<InputEventJoypadMotion>())) return; //avoid joy input on editor root_lock++; @@ -389,8 +389,8 @@ void SceneTree::input_event(const InputEvent &p_event) { input_handled = false; - InputEvent ev = p_event; - ev.ID = ++last_id; //this should work better + Ref<InputEvent> ev = p_event; + ev->set_id(++last_id); //this should work better #if 0 switch(ev.type) { @@ -398,9 +398,9 @@ void SceneTree::input_event(const InputEvent &p_event) { Matrix32 ai = root->get_final_transform().affine_inverse(); Vector2 g = ai.xform(Vector2(ev.mouse_button.global_x,ev.mouse_button.global_y)); - Vector2 l = ai.xform(Vector2(ev.mouse_button.x,ev.mouse_button.y)); - ev.mouse_button.x=l.x; - ev.mouse_button.y=l.y; + Vector2 l = ai.xform(Vector2(ev->get_pos().x,ev->get_pos().y)); + ev->get_pos().x=l.x; + ev->get_pos().y=l.y; ev.mouse_button.global_x=g.x; ev.mouse_button.global_y=g.y; @@ -410,13 +410,13 @@ void SceneTree::input_event(const InputEvent &p_event) { Matrix32 ai = root->get_final_transform().affine_inverse(); Vector2 g = ai.xform(Vector2(ev.mouse_motion.global_x,ev.mouse_motion.global_y)); Vector2 l = ai.xform(Vector2(ev.mouse_motion.x,ev.mouse_motion.y)); - Vector2 r = ai.xform(Vector2(ev.mouse_motion.relative_x,ev.mouse_motion.relative_y)); + Vector2 r = ai.xform(Vector2(ev->get_relative().x,ev->get_relative().y)); ev.mouse_motion.x=l.x; ev.mouse_motion.y=l.y; ev.mouse_motion.global_x=g.x; ev.mouse_motion.global_y=g.y; - ev.mouse_motion.relative_x=r.x; - ev.mouse_motion.relative_y=r.y; + ev->get_relative().x=r.x; + ev->get_relative().y=r.y; } break; case InputEvent::SCREEN_TOUCH: { @@ -453,12 +453,12 @@ void SceneTree::input_event(const InputEvent &p_event) { //call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"input","_input",ev); /* - if (ev.type==InputEvent::KEY && ev.key.pressed && !ev.key.echo && ev.key.scancode==KEY_F12) { + if (ev.type==InputEvent::KEY && ev->is_pressed() && !ev->is_echo() && ev->get_scancode()==KEY_F12) { print_line("RAM: "+itos(Memory::get_static_mem_usage())); print_line("DRAM: "+itos(Memory::get_dynamic_mem_usage())); } - if (ev.type==InputEvent::KEY && ev.key.pressed && !ev.key.echo && ev.key.scancode==KEY_F11) { + if (ev.type==InputEvent::KEY && ev->is_pressed() && !ev->is_echo() && ev->get_scancode()==KEY_F11) { Memory::dump_static_mem_to_file("memdump.txt"); } @@ -470,9 +470,13 @@ void SceneTree::input_event(const InputEvent &p_event) { call_group_flags(GROUP_CALL_REALTIME, "_viewports", "_vp_input", ev); //special one for GUI, as controls use their own process check #endif - if (ScriptDebugger::get_singleton() && ScriptDebugger::get_singleton()->is_remote() && ev.type == InputEvent::KEY && ev.key.pressed && !ev.key.echo && ev.key.scancode == KEY_F8) { - ScriptDebugger::get_singleton()->request_quit(); + if (ScriptDebugger::get_singleton() && ScriptDebugger::get_singleton()->is_remote()) { + //quit from game window using F8 + Ref<InputEventKey> k = ev; + if (k.is_valid() && k->is_pressed() && !k->is_echo() && k->get_scancode() == KEY_F8) { + ScriptDebugger::get_singleton()->request_quit(); + } } _flush_ugc(); @@ -878,7 +882,7 @@ bool SceneTree::is_paused() const { return pause; } -void SceneTree::_call_input_pause(const StringName &p_group, const StringName &p_method, const InputEvent &p_input) { +void SceneTree::_call_input_pause(const StringName &p_group, const StringName &p_method, const Ref<InputEvent> &p_input) { Map<StringName, Group>::Element *E = group_map.find(p_group); if (!E) diff --git a/scene/main/scene_main_loop.h b/scene/main/scene_main_loop.h index 52d5f5c88c..5d42c66652 100644 --- a/scene/main/scene_main_loop.h +++ b/scene/main/scene_main_loop.h @@ -237,7 +237,7 @@ private: void remove_from_group(const StringName &p_group, Node *p_node); void _notify_group_pause(const StringName &p_group, int p_notification); - void _call_input_pause(const StringName &p_group, const StringName &p_method, const InputEvent &p_input); + void _call_input_pause(const StringName &p_group, const StringName &p_method, const Ref<InputEvent> &p_input); Variant _call_group_flags(const Variant **p_args, int p_argcount, Variant::CallError &r_error); Variant _call_group(const Variant **p_args, int p_argcount, Variant::CallError &r_error); @@ -341,7 +341,7 @@ public: void set_group(const StringName &p_group, const String &p_name, const Variant &p_value); virtual void input_text(const String &p_text); - virtual void input_event(const InputEvent &p_event); + virtual void input_event(const Ref<InputEvent> &p_event); virtual void init(); virtual bool iteration(float p_time); diff --git a/scene/main/viewport.cpp b/scene/main/viewport.cpp index aaf839b072..f62cebe042 100644 --- a/scene/main/viewport.cpp +++ b/scene/main/viewport.cpp @@ -503,30 +503,36 @@ void Viewport::_notification(int p_what) { while (physics_picking_events.size()) { - InputEvent ev = physics_picking_events.front()->get(); + Ref<InputEvent> ev = physics_picking_events.front()->get(); physics_picking_events.pop_front(); Vector2 pos; - switch (ev.type) { - case InputEvent::MOUSE_MOTION: { - pos.x = ev.mouse_motion.x; - pos.y = ev.mouse_motion.y; - motion_tested = true; - physics_last_mousepos = pos; - } break; - case InputEvent::MOUSE_BUTTON: { - pos.x = ev.mouse_button.x; - pos.y = ev.mouse_button.y; - - } break; - case InputEvent::SCREEN_DRAG: { - pos.x = ev.screen_drag.x; - pos.y = ev.screen_drag.y; - } break; - case InputEvent::SCREEN_TOUCH: { - pos.x = ev.screen_touch.x; - pos.y = ev.screen_touch.y; - } break; + + Ref<InputEventMouseMotion> mm = ev; + + if (mm.is_valid()) { + + pos = mm->get_pos(); + motion_tested = true; + physics_last_mousepos = pos; + } + + Ref<InputEventMouseButton> mb = ev; + + if (mb.is_valid()) { + pos = mb->get_pos(); + } + + Ref<InputEventScreenDrag> sd = ev; + + if (sd.is_valid()) { + pos = sd->get_pos(); + } + + Ref<InputEventScreenTouch> st = ev; + + if (st.is_valid()) { + pos = st->get_pos(); } if (ss2d) { @@ -589,7 +595,7 @@ void Viewport::_notification(int p_what) { if (co) { co->_input_event(camera, ev, Vector3(), Vector3(), 0); captured = true; - if (ev.type == InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index == 1 && !ev.mouse_button.pressed) { + if (mb.is_valid() && mb->get_button_index() == 1 && !mb->is_pressed()) { physics_object_capture = 0; } @@ -609,7 +615,7 @@ void Viewport::_notification(int p_what) { if (ObjectDB::get_instance(last_id)) { //good, exists last_object->_input_event(camera, ev, result.position, result.normal, result.shape); - if (last_object->get_capture_input_on_drag() && ev.type == InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index == 1 && ev.mouse_button.pressed) { + if (last_object->get_capture_input_on_drag() && mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { physics_object_capture = last_id; } } @@ -637,14 +643,14 @@ void Viewport::_notification(int p_what) { last_object = co; last_id = result.collider_id; new_collider = last_id; - if (co->get_capture_input_on_drag() && ev.type == InputEvent::MOUSE_BUTTON && ev.mouse_button.button_index == 1 && ev.mouse_button.pressed) { + if (co->get_capture_input_on_drag() && mb.is_valid() && mb->get_button_index() == 1 && mb->is_pressed()) { physics_object_capture = last_id; } } } } - if (ev.type == InputEvent::MOUSE_MOTION) { + if (mm.is_valid()) { _test_new_mouseover(new_collider); } } @@ -1322,71 +1328,12 @@ Vector2 Viewport::_get_window_offset() const { return Vector2(); } -void Viewport::_make_input_local(InputEvent &ev) { +Ref<InputEvent> Viewport::_make_input_local(const Ref<InputEvent> &ev) { - switch (ev.type) { - - case InputEvent::MOUSE_BUTTON: { - - Vector2 vp_ofs = _get_window_offset(); - - Transform2D ai = get_final_transform().affine_inverse() * _get_input_pre_xform(); - Vector2 g = ai.xform(Vector2(ev.mouse_button.global_x, ev.mouse_button.global_y)); - Vector2 l = ai.xform(Vector2(ev.mouse_button.x, ev.mouse_button.y) - vp_ofs); - - ev.mouse_button.x = l.x; - ev.mouse_button.y = l.y; - ev.mouse_button.global_x = g.x; - ev.mouse_button.global_y = g.y; - - } break; - case InputEvent::MOUSE_MOTION: { - - Vector2 vp_ofs = _get_window_offset(); - - Transform2D ai = get_final_transform().affine_inverse() * _get_input_pre_xform(); - Vector2 g = ai.xform(Vector2(ev.mouse_motion.global_x, ev.mouse_motion.global_y)); - Vector2 l = ai.xform(Vector2(ev.mouse_motion.x, ev.mouse_motion.y) - vp_ofs); - Vector2 r = ai.basis_xform(Vector2(ev.mouse_motion.relative_x, ev.mouse_motion.relative_y)); - Vector2 s = ai.basis_xform(Vector2(ev.mouse_motion.speed_x, ev.mouse_motion.speed_y)); - - ev.mouse_motion.x = l.x; - ev.mouse_motion.y = l.y; - ev.mouse_motion.global_x = g.x; - ev.mouse_motion.global_y = g.y; - ev.mouse_motion.relative_x = r.x; - ev.mouse_motion.relative_y = r.y; - ev.mouse_motion.speed_x = s.x; - ev.mouse_motion.speed_y = s.y; - - } break; - case InputEvent::SCREEN_TOUCH: { + Vector2 vp_ofs = _get_window_offset(); + Transform2D ai = get_final_transform().affine_inverse() * _get_input_pre_xform(); - Vector2 vp_ofs = _get_window_offset(); - - Transform2D ai = get_final_transform().affine_inverse() * _get_input_pre_xform(); - Vector2 t = ai.xform(Vector2(ev.screen_touch.x, ev.screen_touch.y) - vp_ofs); - - ev.screen_touch.x = t.x; - ev.screen_touch.y = t.y; - - } break; - case InputEvent::SCREEN_DRAG: { - - Vector2 vp_ofs = _get_window_offset(); - - Transform2D ai = get_final_transform().affine_inverse() * _get_input_pre_xform(); - Vector2 t = ai.xform(Vector2(ev.screen_drag.x, ev.screen_drag.y) - vp_ofs); - Vector2 r = ai.basis_xform(Vector2(ev.screen_drag.relative_x, ev.screen_drag.relative_y)); - Vector2 s = ai.basis_xform(Vector2(ev.screen_drag.speed_x, ev.screen_drag.speed_y)); - ev.screen_drag.x = t.x; - ev.screen_drag.y = t.y; - ev.screen_drag.relative_x = r.x; - ev.screen_drag.relative_y = r.y; - ev.screen_drag.speed_x = s.x; - ev.screen_drag.speed_y = s.y; - } break; - } + return ev->xformed_by(ai, -vp_ofs); } void Viewport::_vp_input_text(const String &p_text) { @@ -1396,7 +1343,7 @@ void Viewport::_vp_input_text(const String &p_text) { } } -void Viewport::_vp_input(const InputEvent &p_ev) { +void Viewport::_vp_input(const Ref<InputEvent> &p_ev) { if (disable_input) return; @@ -1413,12 +1360,11 @@ void Viewport::_vp_input(const InputEvent &p_ev) { //this one handles system input, p_ev are in system coordinates //they are converted to viewport coordinates - InputEvent ev = p_ev; - _make_input_local(ev); + Ref<InputEvent> ev = _make_input_local(p_ev); input(ev); } -void Viewport::_vp_unhandled_input(const InputEvent &p_ev) { +void Viewport::_vp_unhandled_input(const Ref<InputEvent> &p_ev) { if (disable_input) return; @@ -1439,8 +1385,7 @@ void Viewport::_vp_unhandled_input(const InputEvent &p_ev) { //this one handles system input, p_ev are in system coordinates //they are converted to viewport coordinates - InputEvent ev = p_ev; - _make_input_local(ev); + Ref<InputEvent> ev = _make_input_local(p_ev); unhandled_input(ev); } @@ -1545,18 +1490,22 @@ void Viewport::_gui_show_tooltip() { gui.tooltip_popup->show(); } -void Viewport::_gui_call_input(Control *p_control, const InputEvent &p_input) { +void Viewport::_gui_call_input(Control *p_control, const Ref<InputEvent> &p_input) { //_block(); - InputEvent ev = p_input; + Ref<InputEvent> ev = p_input; //mouse wheel events can't be stopped - bool cant_stop_me_now = (ev.type == InputEvent::MOUSE_BUTTON && - (ev.mouse_button.button_index == BUTTON_WHEEL_DOWN || - ev.mouse_button.button_index == BUTTON_WHEEL_UP || - ev.mouse_button.button_index == BUTTON_WHEEL_LEFT || - ev.mouse_button.button_index == BUTTON_WHEEL_RIGHT)); + Ref<InputEventMouseButton> mb = p_input; + + bool cant_stop_me_now = (mb.is_valid() && + (mb->get_button_index() == BUTTON_WHEEL_DOWN || + mb->get_button_index() == BUTTON_WHEEL_UP || + mb->get_button_index() == BUTTON_WHEEL_LEFT || + mb->get_button_index() == BUTTON_WHEEL_RIGHT)); + + bool ismouse = ev.is_valid() || p_input->cast_to<InputEventMouseMotion>() != NULL; CanvasItem *ci = p_control; while (ci) { @@ -1573,14 +1522,14 @@ void Viewport::_gui_call_input(Control *p_control, const InputEvent &p_input) { break; if (gui.key_event_accepted) break; - if (!cant_stop_me_now && control->data.mouse_filter == Control::MOUSE_FILTER_STOP && (ev.type == InputEvent::MOUSE_BUTTON || ev.type == InputEvent::MOUSE_MOTION)) + if (!cant_stop_me_now && control->data.mouse_filter == Control::MOUSE_FILTER_STOP && ismouse) break; } if (ci->is_set_as_toplevel()) break; - ev = ev.xform_by(ci->get_transform()); //transform event upwards + ev = ev->xformed_by(ci->get_transform()); //transform event upwards ci = ci->get_parent_item(); } @@ -1718,9 +1667,9 @@ bool Viewport::_gui_drop(Control *p_at_control, Point2 p_at_pos, bool p_just_che return false; } -void Viewport::_gui_input_event(InputEvent p_event) { +void Viewport::_gui_input_event(Ref<InputEvent> p_event) { - if (p_event.ID == gui.cancelled_input_ID) { + if (p_event->get_id() == gui.cancelled_input_ID) { return; } //? @@ -1730,430 +1679,427 @@ void Viewport::_gui_input_event(InputEvent p_event) { } */ - switch (p_event.type) { + Ref<InputEventMouseButton> mb = p_event; - case InputEvent::MOUSE_BUTTON: { + if (mb.is_valid()) { - gui.key_event_accepted = false; + gui.key_event_accepted = false; - Point2 mpos = Point2(p_event.mouse_button.x, p_event.mouse_button.y); - if (p_event.mouse_button.pressed) { + Point2 mpos = mb->get_pos(); + if (mb->is_pressed()) { - Size2 pos = mpos; - if (gui.mouse_focus && p_event.mouse_button.button_index != gui.mouse_focus_button) { + Size2 pos = mpos; + if (gui.mouse_focus && mb->get_button_index() != gui.mouse_focus_button) { - //do not steal mouse focus and stuff + //do not steal mouse focus and stuff - } else { - - _gui_sort_modal_stack(); - while (!gui.modal_stack.empty()) { + } else { - Control *top = gui.modal_stack.back()->get(); - Vector2 pos = top->get_global_transform_with_canvas().affine_inverse().xform(mpos); - if (!top->has_point(pos)) { + _gui_sort_modal_stack(); + while (!gui.modal_stack.empty()) { - if (top->data.modal_exclusive || top->data.modal_frame == Engine::get_singleton()->get_frames_drawn()) { - //cancel event, sorry, modal exclusive EATS UP ALL - //alternative, you can't pop out a window the same frame it was made modal (fixes many issues) - get_tree()->set_input_as_handled(); - return; // no one gets the event if exclusive NO ONE - } + Control *top = gui.modal_stack.back()->get(); + Vector2 pos = top->get_global_transform_with_canvas().affine_inverse().xform(mpos); + if (!top->has_point(pos)) { - top->notification(Control::NOTIFICATION_MODAL_CLOSE); - top->_modal_stack_remove(); - top->hide(); - } else { - break; + if (top->data.modal_exclusive || top->data.modal_frame == Engine::get_singleton()->get_frames_drawn()) { + //cancel event, sorry, modal exclusive EATS UP ALL + //alternative, you can't pop out a window the same frame it was made modal (fixes many issues) + get_tree()->set_input_as_handled(); + return; // no one gets the event if exclusive NO ONE } + + top->notification(Control::NOTIFICATION_MODAL_CLOSE); + top->_modal_stack_remove(); + top->hide(); + } else { + break; } + } - //Matrix32 parent_xform; + //Matrix32 parent_xform; - /* - if (data.parent_canvas_item) - parent_xform=data.parent_canvas_item->get_global_transform(); - */ + /* + if (data.parent_canvas_item) + parent_xform=data.parent_canvas_item->get_global_transform(); + */ - gui.mouse_focus = _gui_find_control(pos); - //print_line("has mf "+itos(gui.mouse_focus!=NULL)); - gui.mouse_focus_button = p_event.mouse_button.button_index; + gui.mouse_focus = _gui_find_control(pos); + //print_line("has mf "+itos(gui.mouse_focus!=NULL)); + gui.mouse_focus_button = mb->get_button_index(); - if (!gui.mouse_focus) { - break; - } + if (!gui.mouse_focus) { + return; + } - if (p_event.mouse_button.button_index == BUTTON_LEFT) { - gui.drag_accum = Vector2(); - gui.drag_attempted = false; - } + if (mb->get_button_index() == BUTTON_LEFT) { + gui.drag_accum = Vector2(); + gui.drag_attempted = false; } + } + + mb = mb->xformed_by(Transform2D()); // make a copy of the event + + mb->set_global_pos(pos); - p_event.mouse_button.global_x = pos.x; - p_event.mouse_button.global_y = pos.y; + pos = gui.focus_inv_xform.xform(pos); - pos = gui.focus_inv_xform.xform(pos); - p_event.mouse_button.x = pos.x; - p_event.mouse_button.y = pos.y; + mb->set_pos(pos); #ifdef DEBUG_ENABLED - if (ScriptDebugger::get_singleton()) { + if (ScriptDebugger::get_singleton()) { - Array arr; - arr.push_back(gui.mouse_focus->get_path()); - arr.push_back(gui.mouse_focus->get_class()); - ScriptDebugger::get_singleton()->send_message("click_ctrl", arr); - } + Array arr; + arr.push_back(gui.mouse_focus->get_path()); + arr.push_back(gui.mouse_focus->get_class()); + ScriptDebugger::get_singleton()->send_message("click_ctrl", arr); + } /*if (bool(GLOBAL_DEF("debug/print_clicked_control",false))) { - print_line(String(gui.mouse_focus->get_path())+" - "+pos); - }*/ + print_line(String(gui.mouse_focus->get_path())+" - "+pos); + }*/ #endif - if (p_event.mouse_button.button_index == BUTTON_LEFT) { //assign focus - CanvasItem *ci = gui.mouse_focus; - while (ci) { + if (mb->get_button_index() == BUTTON_LEFT) { //assign focus + CanvasItem *ci = gui.mouse_focus; + while (ci) { - Control *control = ci->cast_to<Control>(); - if (control) { - if (control->get_focus_mode() != Control::FOCUS_NONE) { - if (control != gui.key_focus) { - control->grab_focus(); - } - break; + Control *control = ci->cast_to<Control>(); + if (control) { + if (control->get_focus_mode() != Control::FOCUS_NONE) { + if (control != gui.key_focus) { + control->grab_focus(); } - - if (control->data.mouse_filter == Control::MOUSE_FILTER_STOP) - break; + break; } - if (ci->is_set_as_toplevel()) + if (control->data.mouse_filter == Control::MOUSE_FILTER_STOP) break; - - ci = ci->get_parent_item(); } - } - if (gui.mouse_focus->can_process()) { - _gui_call_input(gui.mouse_focus, p_event); - } + if (ci->is_set_as_toplevel()) + break; - get_tree()->call_group_flags(SceneTree::GROUP_CALL_REALTIME, "windows", "_cancel_input_ID", p_event.ID); - get_tree()->set_input_as_handled(); + ci = ci->get_parent_item(); + } + } - if (gui.drag_data.get_type() != Variant::NIL && p_event.mouse_button.button_index == BUTTON_LEFT) { + if (gui.mouse_focus->can_process()) { + _gui_call_input(gui.mouse_focus, mb); + } - //alternate drop use (when using force_drag(), as proposed by #5342 - if (gui.mouse_focus) { - _gui_drop(gui.mouse_focus, pos, false); - } + get_tree()->call_group_flags(SceneTree::GROUP_CALL_REALTIME, "windows", "_cancel_input_ID", mb->get_id()); + get_tree()->set_input_as_handled(); - gui.drag_data = Variant(); + if (gui.drag_data.get_type() != Variant::NIL && mb->get_button_index() == BUTTON_LEFT) { - if (gui.drag_preview) { - memdelete(gui.drag_preview); - gui.drag_preview = NULL; - } - _propagate_viewport_notification(this, NOTIFICATION_DRAG_END); - //change mouse accordingly + //alternate drop use (when using force_drag(), as proposed by #5342 + if (gui.mouse_focus) { + _gui_drop(gui.mouse_focus, pos, false); } - _gui_cancel_tooltip(); - //gui.tooltip_popup->hide(); + gui.drag_data = Variant(); - } else { + if (gui.drag_preview) { + memdelete(gui.drag_preview); + gui.drag_preview = NULL; + } + _propagate_viewport_notification(this, NOTIFICATION_DRAG_END); + //change mouse accordingly + } - if (gui.drag_data.get_type() != Variant::NIL && p_event.mouse_button.button_index == BUTTON_LEFT) { + _gui_cancel_tooltip(); + //gui.tooltip_popup->hide(); - if (gui.mouse_over) { - Size2 pos = mpos; - pos = gui.focus_inv_xform.xform(pos); + } else { - _gui_drop(gui.mouse_over, pos, false); - } + if (gui.drag_data.get_type() != Variant::NIL && mb->get_button_index() == BUTTON_LEFT) { - if (gui.drag_preview && p_event.mouse_button.button_index == BUTTON_LEFT) { - memdelete(gui.drag_preview); - gui.drag_preview = NULL; - } + if (gui.mouse_over) { + Size2 pos = mpos; + pos = gui.focus_inv_xform.xform(pos); - gui.drag_data = Variant(); - _propagate_viewport_notification(this, NOTIFICATION_DRAG_END); - //change mouse accordingly + _gui_drop(gui.mouse_over, pos, false); } - if (!gui.mouse_focus) { - //release event is only sent if a mouse focus (previously pressed button) exists - break; + if (gui.drag_preview && mb->get_button_index() == BUTTON_LEFT) { + memdelete(gui.drag_preview); + gui.drag_preview = NULL; } - Size2 pos = mpos; - p_event.mouse_button.global_x = pos.x; - p_event.mouse_button.global_y = pos.y; - pos = gui.focus_inv_xform.xform(pos); - p_event.mouse_button.x = pos.x; - p_event.mouse_button.y = pos.y; + gui.drag_data = Variant(); + _propagate_viewport_notification(this, NOTIFICATION_DRAG_END); + //change mouse accordingly + } - if (gui.mouse_focus->can_process()) { - _gui_call_input(gui.mouse_focus, p_event); - } + if (!gui.mouse_focus) { + //release event is only sent if a mouse focus (previously pressed button) exists + return; + } - if (p_event.mouse_button.button_index == gui.mouse_focus_button) { - gui.mouse_focus = NULL; - gui.mouse_focus_button = -1; - } + Size2 pos = mpos; - /*if (gui.drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) { - _propagate_viewport_notification(this,NOTIFICATION_DRAG_END); - gui.drag_data=Variant(); //always clear - }*/ + mb = mb->xformed_by(Transform2D()); //make a copy + mb->set_global_pos(pos); + pos = gui.focus_inv_xform.xform(pos); + mb->set_pos(pos); - get_tree()->call_group_flags(SceneTree::GROUP_CALL_REALTIME, "windows", "_cancel_input_ID", p_event.ID); - get_tree()->set_input_as_handled(); + if (gui.mouse_focus->can_process()) { + _gui_call_input(gui.mouse_focus, mb); } - } break; - case InputEvent::MOUSE_MOTION: { - gui.key_event_accepted = false; - Point2 mpos = Point2(p_event.mouse_motion.x, p_event.mouse_motion.y); + if (mb->get_button_index() == gui.mouse_focus_button) { + gui.mouse_focus = NULL; + gui.mouse_focus_button = -1; + } - gui.last_mouse_pos = mpos; + /*if (gui.drag_data.get_type()!=Variant::NIL && mb->get_button_index()==BUTTON_LEFT) { + _propagate_viewport_notification(this,NOTIFICATION_DRAG_END); + gui.drag_data=Variant(); //always clear + }*/ - Control *over = NULL; + get_tree()->call_group_flags(SceneTree::GROUP_CALL_REALTIME, "windows", "_cancel_input_ID", mb->get_id()); + get_tree()->set_input_as_handled(); + } + } - // D&D - if (!gui.drag_attempted && gui.mouse_focus && p_event.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + Ref<InputEventMouseMotion> mm = p_event; - gui.drag_accum += Point2(p_event.mouse_motion.relative_x, p_event.mouse_motion.relative_y); - float len = gui.drag_accum.length(); - if (len > 10) { + if (mm.is_valid()) { - { //attempt grab, try parent controls too - CanvasItem *ci = gui.mouse_focus; - while (ci) { + gui.key_event_accepted = false; + Point2 mpos = mm->get_pos(); - Control *control = ci->cast_to<Control>(); - if (control) { + gui.last_mouse_pos = mpos; - gui.drag_data = control->get_drag_data(control->get_global_transform_with_canvas().affine_inverse().xform(mpos) - gui.drag_accum); - if (gui.drag_data.get_type() != Variant::NIL) { + Control *over = NULL; - gui.mouse_focus = NULL; - } + // D&D + if (!gui.drag_attempted && gui.mouse_focus && mm->get_button_mask() & BUTTON_MASK_LEFT) { + + gui.drag_accum += mm->get_relative(); + float len = gui.drag_accum.length(); + if (len > 10) { - if (control->data.mouse_filter == Control::MOUSE_FILTER_STOP) - break; + { //attempt grab, try parent controls too + CanvasItem *ci = gui.mouse_focus; + while (ci) { + + Control *control = ci->cast_to<Control>(); + if (control) { + + gui.drag_data = control->get_drag_data(control->get_global_transform_with_canvas().affine_inverse().xform(mpos) - gui.drag_accum); + if (gui.drag_data.get_type() != Variant::NIL) { + + gui.mouse_focus = NULL; } - if (ci->is_set_as_toplevel()) + if (control->data.mouse_filter == Control::MOUSE_FILTER_STOP) break; - - ci = ci->get_parent_item(); } - } - gui.drag_attempted = true; - if (gui.drag_data.get_type() != Variant::NIL) { + if (ci->is_set_as_toplevel()) + break; - _propagate_viewport_notification(this, NOTIFICATION_DRAG_BEGIN); + ci = ci->get_parent_item(); } } + + gui.drag_attempted = true; + if (gui.drag_data.get_type() != Variant::NIL) { + + _propagate_viewport_notification(this, NOTIFICATION_DRAG_BEGIN); + } } + } - if (gui.mouse_focus) { - over = gui.mouse_focus; - //recompute focus_inv_xform again here + if (gui.mouse_focus) { + over = gui.mouse_focus; + //recompute focus_inv_xform again here - } else { + } else { - over = _gui_find_control(mpos); - } + over = _gui_find_control(mpos); + } - if (gui.drag_data.get_type() == Variant::NIL && over && !gui.modal_stack.empty()) { + if (gui.drag_data.get_type() == Variant::NIL && over && !gui.modal_stack.empty()) { - Control *top = gui.modal_stack.back()->get(); - if (over != top && !top->is_a_parent_of(over)) { + Control *top = gui.modal_stack.back()->get(); + if (over != top && !top->is_a_parent_of(over)) { - break; // don't send motion event to anything below modal stack top - } + return; // don't send motion event to anything below modal stack top } + } - if (over != gui.mouse_over) { + if (over != gui.mouse_over) { - if (gui.mouse_over) - gui.mouse_over->notification(Control::NOTIFICATION_MOUSE_EXIT); + if (gui.mouse_over) + gui.mouse_over->notification(Control::NOTIFICATION_MOUSE_EXIT); - _gui_cancel_tooltip(); + _gui_cancel_tooltip(); - if (over) - over->notification(Control::NOTIFICATION_MOUSE_ENTER); - } + if (over) + over->notification(Control::NOTIFICATION_MOUSE_ENTER); + } - gui.mouse_over = over; + gui.mouse_over = over; - if (gui.drag_preview) { - gui.drag_preview->set_position(mpos); - } + if (gui.drag_preview) { + gui.drag_preview->set_position(mpos); + } - if (!over) { - OS::get_singleton()->set_cursor_shape(OS::CURSOR_ARROW); - break; - } + if (!over) { + OS::get_singleton()->set_cursor_shape(OS::CURSOR_ARROW); + return; + } - Transform2D localizer = over->get_global_transform_with_canvas().affine_inverse(); - Size2 pos = localizer.xform(mpos); - Vector2 speed = localizer.basis_xform(Point2(p_event.mouse_motion.speed_x, p_event.mouse_motion.speed_y)); - Vector2 rel = localizer.basis_xform(Point2(p_event.mouse_motion.relative_x, p_event.mouse_motion.relative_y)); + Transform2D localizer = over->get_global_transform_with_canvas().affine_inverse(); + Size2 pos = localizer.xform(mpos); + Vector2 speed = localizer.basis_xform(mm->get_speed()); + Vector2 rel = localizer.basis_xform(mm->get_relative()); - p_event.mouse_motion.global_x = mpos.x; - p_event.mouse_motion.global_y = mpos.y; - p_event.mouse_motion.speed_x = speed.x; - p_event.mouse_motion.speed_y = speed.y; - p_event.mouse_motion.relative_x = rel.x; - p_event.mouse_motion.relative_y = rel.y; + mm = mm->xformed_by(Transform2D()); //make a copy - if (p_event.mouse_motion.button_mask == 0) { - //nothing pressed + mm->set_global_pos(mpos); + mm->set_speed(speed); + mm->set_relative(rel); - bool can_tooltip = true; + if (mm->get_button_mask() == 0) { + //nothing pressed - if (!gui.modal_stack.empty()) { - if (gui.modal_stack.back()->get() != over && !gui.modal_stack.back()->get()->is_a_parent_of(over)) - can_tooltip = false; - } + bool can_tooltip = true; - bool is_tooltip_shown = false; + if (!gui.modal_stack.empty()) { + if (gui.modal_stack.back()->get() != over && !gui.modal_stack.back()->get()->is_a_parent_of(over)) + can_tooltip = false; + } - if (gui.tooltip_popup) { - if (can_tooltip) { - String tooltip = over->get_tooltip(gui.tooltip->get_global_transform().xform_inv(mpos)); + bool is_tooltip_shown = false; - if (tooltip.length() == 0) - _gui_cancel_tooltip(); - else if (tooltip == gui.tooltip_label->get_text()) - is_tooltip_shown = true; - } else + if (gui.tooltip_popup) { + if (can_tooltip) { + String tooltip = over->get_tooltip(gui.tooltip->get_global_transform().xform_inv(mpos)); + + if (tooltip.length() == 0) _gui_cancel_tooltip(); - } + else if (tooltip == gui.tooltip_label->get_text()) + is_tooltip_shown = true; + } else + _gui_cancel_tooltip(); + } - if (can_tooltip && !is_tooltip_shown) { + if (can_tooltip && !is_tooltip_shown) { - gui.tooltip = over; - gui.tooltip_pos = mpos; //(parent_xform * get_transform()).affine_inverse().xform(pos); - gui.tooltip_timer = gui.tooltip_delay; - } + gui.tooltip = over; + gui.tooltip_pos = mpos; //(parent_xform * get_transform()).affine_inverse().xform(pos); + gui.tooltip_timer = gui.tooltip_delay; } + } - //pos = gui.focus_inv_xform.xform(pos); + //pos = gui.focus_inv_xform.xform(pos); - p_event.mouse_motion.x = pos.x; - p_event.mouse_motion.y = pos.y; + mm->set_pos(pos); - Control::CursorShape cursor_shape = over->get_cursor_shape(pos); - OS::get_singleton()->set_cursor_shape((OS::CursorShape)cursor_shape); + Control::CursorShape cursor_shape = over->get_cursor_shape(pos); + OS::get_singleton()->set_cursor_shape((OS::CursorShape)cursor_shape); - if (over->can_process()) { - _gui_call_input(over, p_event); - } + if (over->can_process()) { + _gui_call_input(over, mm); + } - get_tree()->set_input_as_handled(); + get_tree()->set_input_as_handled(); - if (gui.drag_data.get_type() != Variant::NIL && p_event.mouse_motion.button_mask & BUTTON_MASK_LEFT) { + if (gui.drag_data.get_type() != Variant::NIL && mm->get_button_mask() & BUTTON_MASK_LEFT) { - bool can_drop = _gui_drop(over, pos, true); + bool can_drop = _gui_drop(over, pos, true); - if (!can_drop) { - OS::get_singleton()->set_cursor_shape(OS::CURSOR_FORBIDDEN); - } else { - OS::get_singleton()->set_cursor_shape(OS::CURSOR_CAN_DROP); - } - //change mouse accordingly i guess + if (!can_drop) { + OS::get_singleton()->set_cursor_shape(OS::CURSOR_FORBIDDEN); + } else { + OS::get_singleton()->set_cursor_shape(OS::CURSOR_CAN_DROP); } + //change mouse accordingly i guess + } + } - } break; - case InputEvent::ACTION: - case InputEvent::JOYPAD_BUTTON: - case InputEvent::JOYPAD_MOTION: - case InputEvent::KEY: { + if (mm.is_null() && mb.is_null() && p_event->is_action_type()) { - if (gui.key_focus && !gui.key_focus->is_visible_in_tree()) { - gui.key_focus->release_focus(); - } + if (gui.key_focus && !gui.key_focus->is_visible_in_tree()) { + gui.key_focus->release_focus(); + } - if (gui.key_focus) { + if (gui.key_focus) { - gui.key_event_accepted = false; - if (gui.key_focus->can_process()) { - gui.key_focus->call_multilevel(SceneStringNames::get_singleton()->_gui_input, p_event); - if (gui.key_focus) //maybe lost it - gui.key_focus->emit_signal(SceneStringNames::get_singleton()->gui_input, p_event); - } + gui.key_event_accepted = false; + if (gui.key_focus->can_process()) { + gui.key_focus->call_multilevel(SceneStringNames::get_singleton()->_gui_input, p_event); + if (gui.key_focus) //maybe lost it + gui.key_focus->emit_signal(SceneStringNames::get_singleton()->gui_input, p_event); + } - if (gui.key_event_accepted) { + if (gui.key_event_accepted) { - get_tree()->set_input_as_handled(); - break; - } + get_tree()->set_input_as_handled(); + return; } + } - if (p_event.is_pressed() && p_event.is_action("ui_cancel") && !gui.modal_stack.empty()) { + if (p_event->is_pressed() && p_event->is_action("ui_cancel") && !gui.modal_stack.empty()) { - _gui_sort_modal_stack(); - Control *top = gui.modal_stack.back()->get(); - if (!top->data.modal_exclusive) { + _gui_sort_modal_stack(); + Control *top = gui.modal_stack.back()->get(); + if (!top->data.modal_exclusive) { - top->notification(Control::NOTIFICATION_MODAL_CLOSE); - top->_modal_stack_remove(); - top->hide(); - } + top->notification(Control::NOTIFICATION_MODAL_CLOSE); + top->_modal_stack_remove(); + top->hide(); } + } - Control *from = gui.key_focus ? gui.key_focus : NULL; //hmm + Control *from = gui.key_focus ? gui.key_focus : NULL; //hmm - //keyboard focus - //if (from && p_event.key.pressed && !p_event.key.mod.alt && !p_event.key.mod.meta && !p_event.key.mod.command) { + //keyboard focus + //if (from && p_event->is_pressed() && !p_event->get_alt() && !p_event->get_metakey() && !p_event->key->get_command()) { - if (from && p_event.is_pressed()) { - Control *next = NULL; + if (from && p_event->is_pressed()) { + Control *next = NULL; - if (p_event.is_action("ui_focus_next")) { + if (p_event->is_action("ui_focus_next")) { - next = from->find_next_valid_focus(); - } - - if (p_event.is_action("ui_focus_prev")) { + next = from->find_next_valid_focus(); + } - next = from->find_prev_valid_focus(); - } + if (p_event->is_action("ui_focus_prev")) { - if (p_event.is_action("ui_up")) { + next = from->find_prev_valid_focus(); + } - next = from->_get_focus_neighbour(MARGIN_TOP); - } + if (p_event->is_action("ui_up")) { - if (p_event.is_action("ui_left")) { + next = from->_get_focus_neighbour(MARGIN_TOP); + } - next = from->_get_focus_neighbour(MARGIN_LEFT); - } + if (p_event->is_action("ui_left")) { - if (p_event.is_action("ui_right")) { + next = from->_get_focus_neighbour(MARGIN_LEFT); + } - next = from->_get_focus_neighbour(MARGIN_RIGHT); - } + if (p_event->is_action("ui_right")) { - if (p_event.is_action("ui_down")) { + next = from->_get_focus_neighbour(MARGIN_RIGHT); + } - next = from->_get_focus_neighbour(MARGIN_BOTTOM); - } + if (p_event->is_action("ui_down")) { - if (next) { - next->grab_focus(); - get_tree()->set_input_as_handled(); - } + next = from->_get_focus_neighbour(MARGIN_BOTTOM); } - } break; + if (next) { + next->grab_focus(); + get_tree()->set_input_as_handled(); + } + } } } @@ -2366,33 +2312,30 @@ void Viewport::_gui_grab_click_focus(Control *p_control) { if (gui.mouse_focus == p_control) return; - InputEvent ie; - ie.type = InputEvent::MOUSE_BUTTON; - InputEventMouseButton &mb = ie.mouse_button; + Ref<InputEventMouseButton> mb; + mb.instance(); //send unclic Point2 click = gui.mouse_focus->get_global_transform_with_canvas().affine_inverse().xform(gui.last_mouse_pos); - mb.x = click.x; - mb.y = click.y; - mb.button_index = gui.mouse_focus_button; - mb.pressed = false; - gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input, ie); + mb->set_pos(click); + mb->set_button_index(gui.mouse_focus_button); + mb->set_pressed(false); + gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input, mb); gui.mouse_focus = p_control; gui.focus_inv_xform = gui.mouse_focus->get_global_transform_with_canvas().affine_inverse(); click = gui.mouse_focus->get_global_transform_with_canvas().affine_inverse().xform(gui.last_mouse_pos); - mb.x = click.x; - mb.y = click.y; - mb.button_index = gui.mouse_focus_button; - mb.pressed = true; - gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input, ie); + mb->set_pos(click); + mb->set_button_index(gui.mouse_focus_button); + mb->set_pressed(true); + gui.mouse_focus->call_deferred(SceneStringNames::get_singleton()->_gui_input, mb); } } /////////////////////////////// -void Viewport::input(const InputEvent &p_event) { +void Viewport::input(const Ref<InputEvent> &p_event) { ERR_FAIL_COND(!is_inside_tree()); @@ -2401,20 +2344,20 @@ void Viewport::input(const InputEvent &p_event) { //get_tree()->call_group(SceneTree::GROUP_CALL_REVERSE|SceneTree::GROUP_CALL_REALTIME|SceneTree::GROUP_CALL_MULIILEVEL,gui_input_group,"_gui_input",p_event); //special one for GUI, as controls use their own process check } -void Viewport::unhandled_input(const InputEvent &p_event) { +void Viewport::unhandled_input(const Ref<InputEvent> &p_event) { ERR_FAIL_COND(!is_inside_tree()); get_tree()->_call_input_pause(unhandled_input_group, "_unhandled_input", p_event); //call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_input","_unhandled_input",ev); - if (!get_tree()->input_handled && p_event.type == InputEvent::KEY) { + if (!get_tree()->input_handled && p_event->cast_to<InputEventKey>() != NULL) { get_tree()->_call_input_pause(unhandled_key_input_group, "_unhandled_key_input", p_event); //call_group(GROUP_CALL_REVERSE|GROUP_CALL_REALTIME|GROUP_CALL_MULIILEVEL,"unhandled_key_input","_unhandled_key_input",ev); } if (physics_object_picking && !get_tree()->input_handled) { - if (p_event.type == InputEvent::MOUSE_BUTTON || p_event.type == InputEvent::MOUSE_MOTION || p_event.type == InputEvent::SCREEN_DRAG || p_event.type == InputEvent::SCREEN_TOUCH) { + if (p_event->cast_to<InputEventMouseButton>() || p_event->cast_to<InputEventMouseMotion>() || p_event->cast_to<InputEventScreenDrag>() || p_event->cast_to<InputEventScreenTouch>()) { physics_picking_events.push_back(p_event); } } diff --git a/scene/main/viewport.h b/scene/main/viewport.h index e0f9cf1de2..7470cefb49 100644 --- a/scene/main/viewport.h +++ b/scene/main/viewport.h @@ -158,7 +158,7 @@ private: bool gen_mipmaps; bool physics_object_picking; - List<InputEvent> physics_picking_events; + List<Ref<InputEvent> > physics_picking_events; ObjectID physics_object_capture; ObjectID physics_object_over; Vector2 physics_last_mousepos; @@ -237,14 +237,14 @@ private: bool disable_input; - void _gui_call_input(Control *p_control, const InputEvent &p_input); + void _gui_call_input(Control *p_control, const Ref<InputEvent> &p_input); void _gui_sort_subwindows(); void _gui_sort_roots(); void _gui_sort_modal_stack(); Control *_gui_find_control(const Point2 &p_global); Control *_gui_find_control_at_pos(CanvasItem *p_node, const Point2 &p_global, const Transform2D &p_xform, Transform2D &r_inv_xform); - void _gui_input_event(InputEvent p_event); + void _gui_input_event(Ref<InputEvent> p_event); void update_worlds(); @@ -253,10 +253,10 @@ private: void _vp_enter_tree(); void _vp_exit_tree(); - void _vp_input(const InputEvent &p_ev); + void _vp_input(const Ref<InputEvent> &p_ev); void _vp_input_text(const String &p_text); - void _vp_unhandled_input(const InputEvent &p_ev); - void _make_input_local(InputEvent &ev); + void _vp_unhandled_input(const Ref<InputEvent> &p_ev); + Ref<InputEvent> _make_input_local(const Ref<InputEvent> &ev); friend class Control; @@ -388,8 +388,8 @@ public: void set_use_own_world(bool p_world); bool is_using_own_world() const; - void input(const InputEvent &p_event); - void unhandled_input(const InputEvent &p_event); + void input(const Ref<InputEvent> &p_event); + void unhandled_input(const Ref<InputEvent> &p_event); void set_disable_input(bool p_disable); bool is_input_disabled() const; |