Removal of InputEvent as built-in Variant type..

this might cause bugs I haven't found yet..

86 files changed, 3435 insertions, 3369 deletions

diff --git a/editor/animation_editor.cpp b/editor/animation_editor.cpp
index e4ae1993a..7c29162e6 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)) {
-
-							float kpos = animation->track_get_key_time(idx, kidx_n);
-							if (ABS(pos - kpos) <= w_time) {
+					if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) {
 
-								key = kidx_n;
-							}
-						}
-
-						if (key == -1) {
+						float kpos = animation->track_get_key_time(idx, kidx_n);
+						if (ABS(pos - kpos) <= w_time) {
 
-							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;
+							key = kidx_n;
 						}
+					}
 
-						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;
-
-						if (!mb.mod.shift && !selection.has(sk))
-							_clear_selection();
-
-						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();
-
-						if (_edit_if_single_selection() && mb.mod.command) {
-							edit_button->set_pressed(true);
-							key_editor_tab->show();
-						}
+						//drag select region
+						return;
 					}
-				}
 
-				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);
+					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;
 
-					track_menu->set_position(te->get_global_position() + mpos);
+					if (!mb->get_shift() && !selection.has(sk))
+						_clear_selection();
 
-					interp_editing = -1;
-					cont_editing = -1;
-					wrap_editing = -1;
+					selection.insert(sk, ki);
 
-					track_menu->popup();
+					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->get_command()) {
+						edit_button->set_pressed(true);
+						key_editor_tab->show();
+					}
 				}
 			}
 
-			if (mb.button_index == BUTTON_LEFT && !(mb.button_mask & ~BUTTON_MASK_LEFT)) {
+			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 (mb.pressed) {
+				track_menu->set_position(te->get_global_position() + mpos);
 
-					Point2 mpos = Point2(mb.x, mb.y) - ofs;
+				interp_editing = -1;
+				cont_editing = -1;
+				wrap_editing = -1;
 
-					if (mpos.y < h) {
+				track_menu->popup();
+			}
+		}
 
-						if (mpos.x < name_limit && mpos.x > (name_limit - hsep - hsize_icon->get_width())) {
+		if (mb->get_button_index() == BUTTON_LEFT && !(mb->get_button_mask() & ~BUTTON_MASK_LEFT)) {
 
-							click.click = ClickOver::CLICK_RESIZE_NAMES;
-							click.at = Point2(mb.x, mb.y);
-							click.to = click.at;
-							click.at.y = name_limit;
-						}
+			if (mb->is_pressed()) {
 
-						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());
+				Point2 mpos = mb->get_pos() - ofs;
 
-							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.y < h) {
 
-						return;
+					if (mpos.x < name_limit && mpos.x > (name_limit - hsep - hsize_icon->get_width())) {
+
+						click.click = ClickOver::CLICK_RESIZE_NAMES;
+						click.at = mb->get_pos();
+						click.to = click.at;
+						click.at.y = name_limit;
 					}
 
-					mpos.y -= h;
+					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());
 
-					int idx = mpos.y / h;
-					idx += v_scroll->get_value();
-					if (idx < 0)
-						break;
+						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);
+					}
 
-					if (idx >= animation->get_track_count()) {
+					return;
+				}
 
-						if (mpos.x >= name_limit && mpos.x < settings_limit) {
+				mpos.y -= h;
 
-							click.click = ClickOver::CLICK_SELECT_KEYS;
-							click.at = Point2(mb.x, mb.y);
-							click.to = click.at;
-							//drag select region
-						}
+				int idx = mpos.y / h;
+				idx += v_scroll->get_value();
+				if (idx < 0)
+					return;
 
-						break;
-					}
+				if (idx >= animation->get_track_count()) {
 
-					if (mpos.x < name_limit) {
-						//name column
+					if (mpos.x >= name_limit && mpos.x < settings_limit) {
 
-						// area
-						if (idx != selected_track) {
+						click.click = ClickOver::CLICK_SELECT_KEYS;
+						click.at = mb->get_pos();
+						click.to = click.at;
+						//drag select region
+					}
 
-							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) {
-
-							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;
-						}
+					if (key == -1 && kidx_n >= 0 && kidx_n < animation->track_get_key_count(idx)) {
 
-						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();
+						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 (ofsx < move_down_icon->get_width()) {
-
-							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()) {
 
-								undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newtime);
-								_AnimMoveRestore amr;
+							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
 
-								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);
+							undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_pos", E->key().track, newtime);
+							_AnimMoveRestore amr;
 
-								to_restore.push_back(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);
 
-							// 3-move the keys (re insert them)
-							for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
+							to_restore.push_back(amr);
+						}
 
-								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));
-							}
+						// 3-move the keys (re insert them)
+						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()) {
+							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));
+						}
 
-								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);
-							}
+						// 4-(undo) remove inserted keys
+						for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
 
-							// 5-(undo) reinsert keys
-							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);
+						}
 
-								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));
-							}
+						// 5-(undo) reinsert keys
+						for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
 
-							// 6-(undo) reinsert overlapped keys
-							for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) {
+							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));
+						}
 
-								_AnimMoveRestore &amr = E->get();
-								undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition);
-							}
+						// 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);
-							}
+						// 6-(undo) reinsert overlapped keys
+						for (List<_AnimMoveRestore>::Element *E = to_restore.front(); E; E = E->next()) {
 
-							undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
-							undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
+							_AnimMoveRestore &amr = E->get();
+							undo_redo->add_undo_method(animation.ptr(), "track_insert_key", amr.track, amr.time, amr.key, amr.transition);
+						}
 
-							// 7-reselect
+						undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
+						undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
 
-							for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
+						// 7-reselect
 
-								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);
-							}
+						for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {
 
-							undo_redo->commit_action();
-							_edit_if_single_selection();
+							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);
+						}
 
-						} break;
-						default: {}
-					}
+						undo_redo->commit_action();
+						_edit_if_single_selection();
 
-					//button released
-					click.click = ClickOver::CLICK_NONE;
-					track_editor->update();
+					} break;
+					default: {}
 				}
-			}
 
-		} break;
+				//button released
+				click.click = ClickOver::CLICK_NONE;
+				track_editor->update();
+			}
+		}
+	}
 
-		case InputEvent::MOUSE_MOTION: {
+	Ref<InputEventMouseMotion> mm = p_input;
 
-			const InputEventMouseMotion &mb = p_input.mouse_motion;
+	if (mm.is_valid()) {
 
-			mouse_over.over = MouseOver::OVER_NONE;
-			mouse_over.track = -1;
-			te->update();
-			track_editor->set_tooltip("");
+		mouse_over.over = MouseOver::OVER_NONE;
+		mouse_over.track = -1;
+		te->update();
+		track_editor->set_tooltip("");
 
-			if (!track_editor->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field()))
-				track_editor->call_deferred("grab_focus");
+		if (!track_editor->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field()))
+			track_editor->call_deferred("grab_focus");
 
-			if (click.click != ClickOver::CLICK_NONE) {
+		if (click.click != ClickOver::CLICK_NONE) {
 
-				switch (click.click) {
-					case ClickOver::CLICK_RESIZE_NAMES: {
+			switch (click.click) {
+				case ClickOver::CLICK_RESIZE_NAMES: {
 
-						float base = click.at.y;
-						float clickp = click.at.x - ofs.x;
-						float dif = base - clickp;
+					float base = click.at.y;
+					float clickp = click.at.x - ofs.x;
+					float dif = base - clickp;
 
-						float target = mb.x + dif - ofs.x;
+					float target = mb->get_pos().x + dif - ofs.x;
 
-						float ratio = target / settings_limit;
+					float ratio = target / settings_limit;
 
-						if (ratio > 0.9)
-							ratio = 0.9;
-						else if (ratio < 0.2)
-							ratio = 0.2;
+					if (ratio > 0.9)
+						ratio = 0.9;
+					else if (ratio < 0.2)
+						ratio = 0.2;
 
-						name_column_ratio = ratio;
+					name_column_ratio = ratio;
 
-					} break;
-					case ClickOver::CLICK_DRAG_TIMELINE: {
+				} 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;
-							*/
+					Point2 mpos = mb->get_pos() - ofs;
+					/*
+					if (mpos.x<name_limit)
+						mpos.x=name_limit;
+					if (mpos.x>settings_limit)
+						mpos.x=settings_limit;
+						*/
 
-						//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();
+					//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);
-						}
+					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);
+					}
 
-						timeline_pos = pos;
-						emit_signal("timeline_changed", pos, true);
+					timeline_pos = pos;
+					emit_signal("timeline_changed", pos, true);
 
-					} break;
-					case ClickOver::CLICK_SELECT_KEYS: {
+				} break;
+				case ClickOver::CLICK_SELECT_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();
+					if (click.to.y < h && click.at.y > h && mm->get_relative().y < 0) {
 
-							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) {
+						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) {
 
-							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;
-						}
+						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_MOVE_KEYS: {
+				} break;
+				case ClickOver::CLICK_MOVE_KEYS: {
 
-						click.to = Point2(mb.x, mb.y);
-					} break;
-					default: {}
-				}
+					click.to = mb->get_pos();
+				} break;
+				default: {}
+			}
 
-				return;
-			} else if (mb.button_mask & BUTTON_MASK_MIDDLE) {
+			return;
+		} else if (mb->get_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);
-			}
+			int rel = mm->get_relative().x;
+			float relf = rel / _get_zoom_scale();
+			h_scroll->set_value(h_scroll->get_value() - relf);
+		}
 
-			if (mb.button_mask == 0) {
+		if (mb->get_button_mask() == 0) {
 
-				Point2 mpos = Point2(mb.x, mb.y) - ofs;
+			Point2 mpos = mb->get_pos() - ofs;
 
-				if (mpos.y < h) {
+			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);
+				//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;
-				}
+				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;
 
-				mouse_over.track = idx;
+			mouse_over.track = idx;
 
-				if (mpos.x < name_limit) {
-					//name column
+			if (mpos.x < name_limit) {
+				//name column
 
-					mouse_over.over = MouseOver::OVER_NAME;
+				mouse_over.over = MouseOver::OVER_NAME;
 
-				} else if (mpos.x < settings_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;
+				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 kidx = animation->track_find_key(idx, pos);
+				int kidx_n = kidx + 1;
 
-					bool found = false;
+				bool found = false;
 
-					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) {
 
-							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;
+						found = true;
 					}
+				}
 
-					if (!found && kidx_n >= 0 && kidx_n < 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_n);
-						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_n;
-							found = true;
-						}
+						mouse_over.over = MouseOver::OVER_KEY;
+						mouse_over.track = idx;
+						mouse_over.over_key = kidx_n;
+						found = true;
 					}
+				}
 
-					if (found) {
-
-						String text;
-						text = "time: " + rtos(animation->track_get_key_time(idx, mouse_over.over_key)) + "\n";
+				if (found) {
 
-						switch (animation->track_get_type(idx)) {
+					String text;
+					text = "time: " + rtos(animation->track_get_key_time(idx, mouse_over.over_key)) + "\n";
 
-							case Animation::TYPE_TRANSFORM: {
+					switch (animation->track_get_type(idx)) {
 
-								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: {
+						case Animation::TYPE_TRANSFORM: {
 
-								Variant v = animation->track_get_key_value(idx, mouse_over.over_key);
-								//text+="value: "+String(v)+"\n";
+							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: {
 
-								bool prop_exists = false;
-								Variant::Type valid_type = Variant::NIL;
-								Object *obj = NULL;
+							Variant v = animation->track_get_key_value(idx, mouse_over.over_key);
+							//text+="value: "+String(v)+"\n";
 
-								RES res;
-								Node *node = root->get_node_and_resource(animation->track_get_path(idx), res);
+							bool prop_exists = false;
+							Variant::Type valid_type = Variant::NIL;
+							Object *obj = NULL;
 
-								if (res.is_valid()) {
-									obj = res.ptr();
-								} else if (node) {
-									obj = node;
-								}
+							RES res;
+							Node *node = root->get_node_and_resource(animation->track_get_path(idx), res);
 
-								if (obj) {
-									valid_type = obj->get_static_property_type(animation->track_get_path(idx).get_property(), &prop_exists);
-								}
+							if (res.is_valid()) {
+								obj = res.ptr();
+							} else if (node) {
+								obj = node;
+							}
 
-								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";
-								}
+							if (obj) {
+								valid_type = obj->get_static_property_type(animation->track_get_path(idx).get_property(), &prop_exists);
+							}
 
-							} break;
-							case Animation::TYPE_METHOD: {
+							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";
+							}
 
-								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++) {
+						} break;
+						case Animation::TYPE_METHOD: {
 
-									if (i > 0)
-										text += ", ";
-									text += String(args[i]);
-								}
-								text += ")\n";
+							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++) {
 
-							} break;
-						}
-						text += "easing: " + rtos(animation->track_get_key_transition(idx, mouse_over.over_key));
+								if (i > 0)
+									text += ", ";
+								text += String(args[i]);
+							}
+							text += ")\n";
 
-						track_editor->set_tooltip(text);
-						return;
+						} break;
 					}
+					text += "easing: " + rtos(animation->track_get_key_transition(idx, mouse_over.over_key));
 
-				} else {
-					//button column
-					int ofsx = size.width - mpos.x;
-					if (ofsx < 0)
-						break;
-					/*
-					if (ofsx < remove_icon->get_width()) {
+					track_editor->set_tooltip(text);
+					return;
+				}
 
-						mouse_over.over=MouseOver::OVER_REMOVE;
+			} else {
+				//button column
+				int ofsx = size.width - mpos.x;
+				if (ofsx < 0)
+					return;
+				/*
+				if (ofsx < remove_icon->get_width()) {
 
-						return;
-					}
+					mouse_over.over=MouseOver::OVER_REMOVE;
 
-					ofsx-=hsep+remove_icon->get_width();
+					return;
+				}
 
-					if (ofsx < move_down_icon->get_width()) {
+				ofsx-=hsep+remove_icon->get_width();
 
-						mouse_over.over=MouseOver::OVER_DOWN;
-						return;
-					}
+				if (ofsx < move_down_icon->get_width()) {
 
-					ofsx-=hsep+move_down_icon->get_width();
+					mouse_over.over=MouseOver::OVER_DOWN;
+					return;
+				}
 
-					if (ofsx < move_up_icon->get_width()) {
+				ofsx-=hsep+move_down_icon->get_width();
 
-						mouse_over.over=MouseOver::OVER_UP;
-						return;
-					}
+				if (ofsx < move_up_icon->get_width()) {
 
-					ofsx-=hsep*3+move_up_icon->get_width();
+					mouse_over.over=MouseOver::OVER_UP;
+					return;
+				}
 
-	*/
+				ofsx-=hsep*3+move_up_icon->get_width();
 
-					if (ofsx < down_icon->get_width() + wrap_icon[0]->get_width() + hsep * 3) {
+*/
 
-						mouse_over.over = MouseOver::OVER_WRAP;
-						return;
-					}
+				if (ofsx < down_icon->get_width() + wrap_icon[0]->get_width() + hsep * 3) {
+
+					mouse_over.over = MouseOver::OVER_WRAP;
+					return;
+				}
 
-					ofsx -= hsep * 3 + wrap_icon[0]->get_width() + down_icon->get_width();
+				ofsx -= hsep * 3 + wrap_icon[0]->get_width() + down_icon->get_width();
 
-					if (ofsx < down_icon->get_width() + interp_icon[0]->get_width() + hsep * 3) {
+				if (ofsx < down_icon->get_width() + interp_icon[0]->get_width() + hsep * 3) {
 
-						mouse_over.over = MouseOver::OVER_INTERP;
-						return;
-					}
+					mouse_over.over = MouseOver::OVER_INTERP;
+					return;
+				}
 
-					ofsx -= hsep * 2 + interp_icon[0]->get_width() + down_icon->get_width();
+				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) {
+				if (ofsx < down_icon->get_width() + cont_icon[0]->get_width() + hsep * 3) {
 
-						mouse_over.over = MouseOver::OVER_VALUE;
-						return;
-					}
+					mouse_over.over = MouseOver::OVER_VALUE;
+					return;
+				}
 
-					ofsx -= hsep * 3 + cont_icon[0]->get_width() + down_icon->get_width();
+				ofsx -= hsep * 3 + cont_icon[0]->get_width() + down_icon->get_width();
 
-					if (ofsx < add_key_icon->get_width()) {
+				if (ofsx < add_key_icon->get_width()) {
 
-						mouse_over.over = MouseOver::OVER_ADD_KEY;
-						return;
-					}
+					mouse_over.over = MouseOver::OVER_ADD_KEY;
+					return;
 				}
 			}
-
-		} break;
+		}
 	}
 }
 
diff --git a/editor/animation_editor.h b/editor/animation_editor.h
index 0f6cc9563..128481c83 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 a84d65de0..2e406fb23 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 44d526fda..8d48c5650 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 dc28fc902..c5cfea0b9 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 6170149c6..02ce76272 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 75d872175..6a79f9935 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 10cd29b81..79a8f79a7 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 6ef32a6af..f60186e3b 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 4a3d78479..f5bf464fd 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 c47e3fc0d..25fade46d 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 f8c85c4ad..f44193c70 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 11fa9396a..d550ce93d 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 d22d61b91..d6fc0e3bf 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 29d5dda65..d4c418bfc 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 eeeee34d7..57586951d 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 4a4b720e8..4ecb29202 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 5215809da..667f58e6d 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 98e0808ba..8ce4f8859 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 a142cba44..7b73e7ebb 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 5e5b31aac..1b8d1b167 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 5f4b47cae..1ef447a6b 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 9d12ad687..d42712673 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 35b5ae366..4998d45a8 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 cd8e68bc5..ebd464353 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 a876f2313..7b45e2835 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 69a1f07fb..22b306f94 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 bd26621c8..7bd9feb63 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 8a1e220fe..17fb953f3 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 ac60090d1..ceaa73569 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 e126cdf40..fccd527ed 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: {
+				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: {}
-					}
+						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 (mb->get_button_index() == 2) {
 
-					if (click_type != CLICK_NONE) {
-						click_type = CLICK_NONE;
-						update();
-					} else {
-						// try to disconnect/remove
+				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) {
+					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);
-								}
+						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);
 							}
-
-							node_popup->set_position(rclick_pos + get_global_position());
-							node_popup->popup();
 						}
 
-						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);
+							anim_tree->connect_nodes(id, click_node, click_slot);
+						}
 
-						} break;
-						default: {}
-					}
+					} 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);
 
-					click_type = CLICK_NONE;
-					update();
+					} 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 8bbe22387..785f042dd 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 efb431839..2f1a4ce11 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->get_alt()) move_mode = MOVE_LOCAL_BASE;
+			if (k->get_control() || k->get_metakey()) 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_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 7f09b92f4..22fa5b5db 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 ae426ba29..b7cfcaae0 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++) {
+							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_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										closest_idx = i;
-									}
-								}
+								Vector2 points[2] = { xform.xform(poly[i]),
+									xform.xform(poly[(i + 1) % poly.size()]) };
 
-								if (closest_idx >= 0) {
+								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
 
-									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;
+								real_t d = cp.distance_to(gpoint);
+								if (d < closest_dist && d < grab_treshold) {
+									closest_dist = d;
+									closest_pos = cp;
+									closest_idx = i;
 								}
-							} else {
+							}
 
-								//look for points to move
+							if (closest_idx >= 0) {
 
-								int closest_idx = -1;
-								Vector2 closest_pos;
-								real_t closest_dist = 1e10;
-								for (int i = 0; i < poly.size(); i++) {
+								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 {
 
-									Vector2 cp = xform.xform(poly[i]);
+							//look for points to move
 
-									real_t d = cp.distance_to(gpoint);
-									if (d < closest_dist && d < grab_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										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->get_viewport_control()->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
-
-								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();
+							if (closest_idx >= 0) {
 
-								edited_point = -1;
+								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 (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) {
+					} else {
 
-						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 (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]);
+
+						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) {
 
-			const InputEventMouseMotion &mm = p_event.mouse_motion;
+						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;
+		}
+	}
 
-			if (edited_point != -1 && (wip_active || mm.button_mask & BUTTON_MASK_LEFT)) {
+	Ref<InputEventMouseMotion> mm = p_event;
 
-				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 (mm.is_valid()) {
 
-				canvas_item_editor->get_viewport_control()->update();
-			}
+		if (edited_point != -1 && (wip_active || mm->get_button_mask() & BUTTON_MASK_LEFT)) {
 
-		} break;
+			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 babe65358..382c0d6c3 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 fdb1bf984..c89e6f59a 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 70cc81efb..e2184c615 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 bbd94516a..09aefc65c 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 f3ad5c0fd..6dd94863a 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 ebe05539a..4e75ba407 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 005633a10..40f7de478 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 cb2f6b406..842d58654 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 73b615d81..9c9e010b4 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: {
+			} 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) {
-
-									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_control()) {
 
-								//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->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;
+							}
 
-									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_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										closest_idx = i;
-									}
-								}
+								Vector2 points[2] = { xform.xform(poly[i]),
+									xform.xform(poly[(i + 1) % poly.size()]) };
 
-								if (closest_idx >= 0) {
+								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
 
-									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;
+								real_t d = cp.distance_to(gpoint);
+								if (d < closest_dist && d < grab_treshold) {
+									closest_dist = d;
+									closest_pos = cp;
+									closest_idx = i;
 								}
-							} else {
+							}
 
-								//look for points to move
+							if (closest_idx >= 0) {
 
-								int closest_idx = -1;
-								Vector2 closest_pos;
-								real_t closest_dist = 1e10;
-								for (int i = 0; i < poly.size(); i++) {
+								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 {
 
-									Vector2 cp = xform.xform(poly[i]);
+							//look for points to move
 
-									real_t d = cp.distance_to(gpoint);
-									if (d < closest_dist && d < grab_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										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->get_viewport_control()->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
-
-								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();
+							if (closest_idx >= 0) {
 
-								edited_point = -1;
+								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 (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) {
+					} else {
 
-						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 (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 8e0817e61..d6579fc94 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 4df0d2605..3497af360 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) {
+	Ref<InputEventMouseButton> mb = p_event;
 
-		case InputEvent::MOUSE_BUTTON: {
+	if (mb.is_valid()) {
 
-			const InputEventMouseButton &mb = p_event.mouse_button;
+		Vector2 gpoint = mb->get_pos();
+		Vector2 cpoint = mouse_to_local_pos(gpoint, mb->get_alt());
 
-			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;
+		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;
+		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;
+		}
+	}
 
-		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;
+	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 7477f7eee..3a1f84155 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 61da860ca..f377d3a7c 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 be8c46f37..a7fc1d5ad 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) {
+							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 {
+								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) {
+					if (closest_idx >= 0) {
 
-							PoolVector<Vector2> poly = node->get_navigation_polygon()->get_outline(closest_outline);
+						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 {
+						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;
+							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 6de77b5ef..62a83983f 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 045084d2e..38a2a0c46 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 67c6f3c8c..70911444a 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 9e18a5c4c..12b6dce79 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 896a26c8e..c2edc608a 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) {
+			} break;
 
-							if (mb.mod.control) {
+			case MODE_EDIT: {
 
-								if (poly.size() < 3) {
+				if (mb->get_button_index() == BUTTON_LEFT) {
+					if (mb->is_pressed()) {
 
-									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_control()) {
 
-								//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] + node->get_offset()),
-										xform.xform(poly[(i + 1) % poly.size()] + node->get_offset()) };
+								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_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										closest_idx = i;
-									}
-								}
+								Vector2 points[2] = { xform.xform(poly[i] + node->get_offset()),
+									xform.xform(poly[(i + 1) % poly.size()] + node->get_offset()) };
 
-								if (closest_idx >= 0) {
+								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
 
-									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;
+								real_t d = cp.distance_to(gpoint);
+								if (d < closest_dist && d < grab_treshold) {
+									closest_dist = d;
+									closest_pos = cp;
+									closest_idx = i;
 								}
-							} else {
+							}
 
-								//look for points to move
+							if (closest_idx >= 0) {
 
-								int closest_idx = -1;
-								Vector2 closest_pos;
-								real_t closest_dist = 1e10;
-								for (int i = 0; i < poly.size(); i++) {
+								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 {
 
-									Vector2 cp = xform.xform(poly[i] + node->get_offset());
+							//look for points to move
 
-									real_t d = cp.distance_to(gpoint);
-									if (d < closest_dist && d < grab_treshold) {
-										closest_dist = d;
-										closest_pos = cp;
-										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] + node->get_offset());
 
-									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;
+								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 - 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;
+								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 (mb.button_index == BUTTON_RIGHT && mb.pressed && edited_point == -1) {
+					} else {
 
-						int closest_idx = -1;
-						Vector2 closest_pos;
-						real_t closest_dist = 1e10;
-						for (int i = 0; i < poly.size(); i++) {
+						if (edited_point != -1) {
 
-							Vector2 cp = xform.xform(poly[i] + node->get_offset());
+							//apply
 
-							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) {
-
-							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 00926bf2d..0901cc908 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 3b8d655af..ea7a84d2f 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 fad3ba93f..1f54620ba 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 458210821..d36906405 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 983847dda..fb2f10827 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 3bb1c7852..2d3a14e52 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 77bce59f2..fdae03949 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 0fd28a0b5..9c65ef667 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 91900465a..c4595b477 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()) {
 
-			if (spatial_editor->get_over_gizmo_handle() == -1 && !(m.button_mask & 1) && !_edit.gizmo.is_valid()) {
+				int selected_handle = -1;
 
-				_gizmo_select(_edit.mouse_pos, true);
+				int handle = -1;
+				Vector3 point;
+				Vector3 normal;
+				bool inters = seg->intersect_ray(camera, _edit.mouse_pos, point, normal, &handle, false);
+				if (inters && handle != -1) {
+
+					selected_handle = handle;
+				}
+
+				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;
+
+						if (_edit.snap || spatial_editor->is_snap_enabled()) {
 
-							set_message(vformat(TTR("Scaling to %s%%."), String::num(scale, 1)));
-							scale /= 100.0;
+							scale = Math::stepify(scale, spatial_editor->get_scale_snap());
+						}
 
-							Transform r;
-							r.basis.scale(Vector3(scale, scale, scale));
+						set_message(vformat(TTR("Scaling to %s%%."), String::num(scale, 1)));
+						scale /= 100.0;
 
-							List<Node *> &selection = editor_selection->get_selected_node_list();
+						Transform r;
+						r.basis.scale(Vector3(scale, scale, scale));
 
-							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()) {
 
-								SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp);
-								if (!se)
-									continue;
+							Spatial *sp = E->get()->cast_to<Spatial>();
+							if (!sp)
+								continue;
 
-								Transform original = se->original;
+							SpatialEditorSelectedItem *se = editor_selection->get_node_editor_data<SpatialEditorSelectedItem>(sp);
+							if (!se)
+								continue;
 
-								Transform base = Transform(Basis(), _edit.center);
-								Transform t = base * (r * (base.inverse() * original));
+							Transform original = se->original;
 
-								sp->set_global_transform(t);
-							}
+							Transform base = Transform(Basis(), _edit.center);
+							Transform t = base * (r * (base.inverse() * original));
 
-							surface->update();
+							sp->set_global_transform(t);
+						}
 
-						} break;
+						surface->update();
 
-						case TRANSFORM_TRANSLATE: {
+					} break;
 
-							Vector3 motion_mask;
-							Plane plane;
+					case TRANSFORM_TRANSLATE: {
 
-							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;
-							}
+						Vector3 motion_mask;
+						Plane plane;
 
-							Vector3 intersection;
-							if (!plane.intersects_ray(ray_pos, ray, &intersection))
+						switch (_edit.plane) {
+							case TRANSFORM_VIEW:
+								motion_mask = Vector3(0, 0, 0);
+								plane = Plane(_edit.center, _get_camera_normal());
 								break;
-
-							Vector3 click;
-							if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click))
+							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 y_axis = (click - _edit.center).normalized();
-							Vector3 x_axis = plane.normal.cross(y_axis).normalized();
+						Vector3 intersection;
+						if (!plane.intersects_ray(ray_pos, ray, &intersection))
+							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 click;
+						if (!plane.intersects_ray(_edit.click_ray_pos, _edit.click_ray, &click))
+							break;
 
-								float snap = spatial_editor->get_rotate_snap();
+						Vector3 y_axis = (click - _edit.center).normalized();
+						Vector3 x_axis = plane.normal.cross(y_axis).normalized();
 
-								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 angle = Math::atan2(x_axis.dot(intersection - _edit.center), y_axis.dot(intersection - _edit.center));
+						if (_edit.snap || spatial_editor->is_snap_enabled()) {
 
-							} else {
-								set_message(vformat(TTR("Rotating %s degrees."), rtos(Math::rad2deg(angle))));
-							}
+							float snap = spatial_editor->get_rotate_snap();
 
-							Transform r;
-							r.basis.rotate(plane.normal, angle);
+							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))));
 
-							List<Node *> &selection = editor_selection->get_selected_node_list();
+						} else {
+							set_message(vformat(TTR("Rotating %s degrees."), rtos(Math::rad2deg(angle))));
+						}
 
-							for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
+						Transform r;
+						r.basis.rotate(plane.normal, angle);
 
-								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();
-							/*
-							VisualServer::get_singleton()->poly_clear(indicators);
+							Transform base = Transform(Basis(), _edit.center);
+							Transform t = base * r * base.inverse() * original;
 
-							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: {}
-					}
-				}
+							sp->set_global_transform(t);
+						}
 
-			} else if (m.button_mask & BUTTON_MASK_RIGHT) {
+						surface->update();
+						/*
+						VisualServer::get_singleton()->poly_clear(indicators);
 
-				if (nav_scheme == NAVIGATION_MAYA && m.mod.alt) {
-					nav_mode = NAVIGATION_ZOOM;
-				} else {
-					nav_mode = NAVIGATION_LOOK;
+						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_MIDDLE) {
-
-				if (nav_scheme == NAVIGATION_GODOT) {
+		} else if (m->get_button_mask() & BUTTON_MASK_RIGHT) {
 
-					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 (nav_scheme == NAVIGATION_MAYA && m->get_alt()) {
+				nav_mode = NAVIGATION_ZOOM;
+			} else {
+				nav_mode = NAVIGATION_LOOK;
+			}
 
-					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 (m->get_button_mask() & BUTTON_MASK_MIDDLE) {
 
-				} else if (nav_scheme == NAVIGATION_MAYA) {
-					if (m.mod.alt)
-						nav_mode = NAVIGATION_PAN;
-				}
+			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;
 
-					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;
+			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;
+			}
+		}
 
-					Point2i relative = _get_warped_mouse_motion(m);
+		switch (nav_mode) {
+			case NAVIGATION_PAN: {
 
-					Transform camera_transform;
+				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;
 
-					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;
+				Point2i relative = _get_warped_mouse_motion(m);
 
-				} break;
+				Transform camera_transform;
 
-				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;
+				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;
 
-					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));
-					}
+			} 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;
+			} break;
 
-						// 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;
+			default: {}
+		}
+	}
 
-						name = "";
-						_update_name();
-					}
+	Ref<InputEventKey> k = p_event;
 
-				} break;
+	if (k.is_valid()) {
+		if (!k->is_pressed())
+			return;
 
-				default: {}
+		if (ED_IS_SHORTCUT("spatial_editor/snap", p_event)) {
+			if (_edit.mode != TRANSFORM_NONE) {
+				_edit.snap = true;
 			}
-		} break;
-		case InputEvent::KEY: {
-			const InputEventKey &k = p_event.key;
-			if (!k.pressed)
-				break;
+		}
+		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;
 
-			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 (!AnimationPlayerEditor::singleton->get_key_editor()->has_keying()) {
+				set_message(TTR("Keying is disabled (no key inserted)."));
+				return;
 			}
-			if (ED_IS_SHORTCUT("spatial_editor/insert_anim_key", p_event)) {
-				if (!get_selected_count() || _edit.mode != TRANSFORM_NONE)
-					break;
-
-				if (!AnimationPlayerEditor::singleton->get_key_editor()->has_keying()) {
-					set_message(TTR("Keying is disabled (no key inserted)."));
-					break;
-				}
-
-				List<Node *> &selection = editor_selection->get_selected_node_list();
 
-				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 0f07ec4c6..1f76d9bfb 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 c7c77fa96..d06c065f4 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 3778e4ca5..c9081c599 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 62977d86e..3b705aae2 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 8750ce4d5..938298353 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 89995edf0..799bfbf35 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 093e2f7d0..cb0b9fc37 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 9f99a9b97..9f7a41b8b 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 3eedb6c94..981d5c66a 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 2d3b3a220..50b518afb 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 5be28ce2f..27886132c 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 c9a6d4df6..1c4ca3cb5 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: {
+
+			Ref<InputEventJoypadButton> jb;
+			jb.instance();
 
-			ie.joy_button.button_index = device_index->get_selected();
+			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) {
+			Ref<InputEventKey> k = ie;
+			if (k.is_valid()) {
 
-				case InputEvent::KEY: {
+				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;
 
-					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"));
+			}
+
+			Ref<InputEventJoypadButton> jb = ie;
 
-					action->set_text(0, str);
-					action->set_icon(0, get_icon("Keyboard", "EditorIcons"));
+			if (jb.is_valid()) {
 
-				} break;
-				case InputEvent::JOYPAD_BUTTON: {
+				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"));
+			}
 
-					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 += ".";
+			Ref<InputEventMouseButton> mb = ie;
 
-					action->set_text(0, str);
-					action->set_icon(0, get_icon("JoyButton", "EditorIcons"));
-				} break;
-				case InputEvent::MOUSE_BUTTON: {
+			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"));
+			}
 
-					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) + ".";
-					}
+			Ref<InputEventJoypadMotion> jm = ie;
 
-					action->set_text(0, str);
-					action->set_icon(0, get_icon("Mouse", "EditorIcons"));
-				} break;
-				case InputEvent::JOYPAD_MOTION: {
+			if (jm.is_valid()) {
 
-					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;
+				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 a5a9e0425..47fb45cf8 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 2cc7acd26..1c8a1c0ee 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 b88ba38e1..c02c301ac 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 752965c80..47e5994e3 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 6dc259217..def791a3f 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 7fce485f3..7fb9666af 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 0e5766033..44f8c025e 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 7916b6b63..0f05cc79f 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 de6b81d44..f190025dd 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 16ab43132..563de7841 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 7b6e8862d..cda191ac3 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();