virtualx-engine/editor/animation_track_editor.cpp

/*************************************************************************/
/*  animation_track_editor.cpp                                           */
/*************************************************************************/
/*                       This file is part of:                           */
/*                           GODOT ENGINE                                */
/*                      https://godotengine.org                          */
/*************************************************************************/
/* Copyright (c) 2007-2019 Juan Linietsky, Ariel Manzur.                 */
/* Copyright (c) 2014-2019 Godot Engine contributors (cf. AUTHORS.md)    */
/*                                                                       */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the       */
/* "Software"), to deal in the Software without restriction, including   */
/* without limitation the rights to use, copy, modify, merge, publish,   */
/* distribute, sublicense, and/or sell copies of the Software, and to    */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions:                                             */
/*                                                                       */
/* The above copyright notice and this permission notice shall be        */
/* included in all copies or substantial portions of the Software.       */
/*                                                                       */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
/*************************************************************************/

#include "animation_track_editor.h"

#include "animation_track_editor_plugins.h"
#include "core/os/keyboard.h"
#include "editor/animation_bezier_editor.h"
#include "editor/plugins/animation_player_editor_plugin.h"
#include "editor_node.h"
#include "editor_scale.h"
#include "scene/main/viewport.h"
#include "servers/audio/audio_stream.h"

class AnimationTrackKeyEdit : public Object {

	GDCLASS(AnimationTrackKeyEdit, Object);

public:
	bool setting;

	bool _hide_script_from_inspector() {
		return true;
	}

	bool _dont_undo_redo() {
		return true;
	}

	static void _bind_methods() {

		ClassDB::bind_method("_update_obj", &AnimationTrackKeyEdit::_update_obj);
		ClassDB::bind_method("_key_ofs_changed", &AnimationTrackKeyEdit::_key_ofs_changed);
		ClassDB::bind_method("_hide_script_from_inspector", &AnimationTrackKeyEdit::_hide_script_from_inspector);
		ClassDB::bind_method("get_root_path", &AnimationTrackKeyEdit::get_root_path);
		ClassDB::bind_method("_dont_undo_redo", &AnimationTrackKeyEdit::_dont_undo_redo);
	}

	//PopupDialog *ke_dialog;

	void _fix_node_path(Variant &value) {

		NodePath np = value;

		if (np == NodePath())
			return;

		Node *root = EditorNode::get_singleton()->get_tree()->get_root();

		Node *np_node = root->get_node(np);
		ERR_FAIL_COND(!np_node);

		Node *edited_node = root->get_node(base);
		ERR_FAIL_COND(!edited_node);

		value = edited_node->get_path_to(np_node);
	}

	void _update_obj(const Ref<Animation> &p_anim) {
		if (setting)
			return;
		if (!(animation == p_anim))
			return;

		notify_change();
	}

	void _key_ofs_changed(const Ref<Animation> &p_anim, float from, float to) {
		if (!(animation == p_anim))
			return;
		if (from != key_ofs)
			return;
		key_ofs = to;
		if (setting)
			return;
		notify_change();
	}

	bool _set(const StringName &p_name, const Variant &p_value) {

		int key = animation->track_find_key(track, key_ofs, true);
		ERR_FAIL_COND_V(key == -1, false);

		String name = p_name;
		if (name == "time") {

			float new_time = p_value;
			if (new_time == key_ofs)
				return true;

			int existing = animation->track_find_key(track, new_time, true);

			setting = true;
			undo_redo->create_action(TTR("Anim Change Keyframe Time"), UndoRedo::MERGE_ENDS);

			Variant val = animation->track_get_key_value(track, key);
			float trans = animation->track_get_key_transition(track, key);

			undo_redo->add_do_method(animation.ptr(), "track_remove_key", track, key);
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", track, new_time, val, trans);
			undo_redo->add_do_method(this, "_key_ofs_changed", animation, key_ofs, new_time);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", track, new_time);
			undo_redo->add_undo_method(animation.ptr(), "track_insert_key", track, key_ofs, val, trans);
			undo_redo->add_undo_method(this, "_key_ofs_changed", animation, new_time, key_ofs);

			if (existing != -1) {
				Variant v = animation->track_get_key_value(track, existing);
				trans = animation->track_get_key_transition(track, existing);
				undo_redo->add_undo_method(animation.ptr(), "track_insert_key", track, new_time, v, trans);
			}

			undo_redo->commit_action();
			setting = false;

			return true;
		} else if (name == "easing") {

			float val = p_value;
			float prev_val = animation->track_get_key_transition(track, key);
			setting = true;
			undo_redo->create_action(TTR("Anim Change Transition"), UndoRedo::MERGE_ENDS);
			undo_redo->add_do_method(animation.ptr(), "track_set_key_transition", track, key, val);
			undo_redo->add_undo_method(animation.ptr(), "track_set_key_transition", track, key, prev_val);
			undo_redo->add_do_method(this, "_update_obj", animation);
			undo_redo->add_undo_method(this, "_update_obj", animation);
			undo_redo->commit_action();
			setting = false;
			return true;
		}

		switch (animation->track_get_type(track)) {

			case Animation::TYPE_TRANSFORM: {

				Dictionary d_old = animation->track_get_key_value(track, key);
				Dictionary d_new = d_old;
				d_new[p_name] = p_value;
				setting = true;
				undo_redo->create_action(TTR("Anim Change Transform"));
				undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, d_new);
				undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, d_old);
				undo_redo->add_do_method(this, "_update_obj", animation);
				undo_redo->add_undo_method(this, "_update_obj", animation);
				undo_redo->commit_action();

				setting = false;
				return true;

			} break;
			case Animation::TYPE_VALUE: {

				if (name == "value") {

					Variant value = p_value;

					if (value.get_type() == Variant::NODE_PATH) {

						_fix_node_path(value);
					}

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					Variant prev = animation->track_get_key_value(track, key);
					undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}

			} break;
			case Animation::TYPE_METHOD: {

				Dictionary d_old = animation->track_get_key_value(track, key);
				Dictionary d_new = d_old;

				bool change_notify_deserved = false;
				bool mergeable = false;

				if (name == "name") {

					d_new["method"] = p_value;
				}

				if (name == "arg_count") {

					Vector<Variant> args = d_old["args"];
					args.resize(p_value);
					d_new["args"] = args;
					change_notify_deserved = true;
				}

				if (name.begins_with("args/")) {

					Vector<Variant> args = d_old["args"];
					int idx = name.get_slice("/", 1).to_int();
					ERR_FAIL_INDEX_V(idx, args.size(), false);

					String what = name.get_slice("/", 2);
					if (what == "type") {
						Variant::Type t = Variant::Type(int(p_value));

						if (t != args[idx].get_type()) {
							Variant::CallError err;
							if (Variant::can_convert(args[idx].get_type(), t)) {
								Variant old = args[idx];
								Variant *ptrs[1] = { &old };
								args.write[idx] = Variant::construct(t, (const Variant **)ptrs, 1, err);
							} else {

								args.write[idx] = Variant::construct(t, NULL, 0, err);
							}
							change_notify_deserved = true;
							d_new["args"] = args;
						}
					}
					if (what == "value") {

						Variant value = p_value;
						if (value.get_type() == Variant::NODE_PATH) {

							_fix_node_path(value);
						}

						args.write[idx] = value;
						d_new["args"] = args;
						mergeable = true;
					}
				}

				if (mergeable)
					undo_redo->create_action(TTR("Anim Change Call"), UndoRedo::MERGE_ENDS);
				else
					undo_redo->create_action(TTR("Anim Change Call"));

				Variant prev = animation->track_get_key_value(track, key);
				setting = true;
				undo_redo->add_do_method(animation.ptr(), "track_set_key_value", track, key, d_new);
				undo_redo->add_undo_method(animation.ptr(), "track_set_key_value", track, key, d_old);
				undo_redo->add_do_method(this, "_update_obj", animation);
				undo_redo->add_undo_method(this, "_update_obj", animation);
				undo_redo->commit_action();

				setting = false;
				if (change_notify_deserved)
					notify_change();
				return true;
			} break;
			case Animation::TYPE_BEZIER: {

				if (name == "value") {

					Variant value = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					float prev = animation->bezier_track_get_key_value(track, key);
					undo_redo->add_do_method(animation.ptr(), "bezier_track_set_key_value", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_value", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}
				if (name == "in_handle") {

					Variant value = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					Vector2 prev = animation->bezier_track_get_key_in_handle(track, key);
					undo_redo->add_do_method(animation.ptr(), "bezier_track_set_in_handle", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_in_handle", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}
				if (name == "out_handle") {

					Variant value = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					Vector2 prev = animation->bezier_track_get_key_out_handle(track, key);
					undo_redo->add_do_method(animation.ptr(), "bezier_track_set_out_handle", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_out_handle", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}

			} break;
			case Animation::TYPE_AUDIO: {

				if (name == "stream") {

					Ref<AudioStream> stream = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					RES prev = animation->audio_track_get_key_stream(track, key);
					undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_stream", track, key, stream);
					undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_stream", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}
				if (name == "start_offset") {

					float value = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					float prev = animation->audio_track_get_key_start_offset(track, key);
					undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_start_offset", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_start_offset", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}
				if (name == "end_offset") {

					float value = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					float prev = animation->audio_track_get_key_end_offset(track, key);
					undo_redo->add_do_method(animation.ptr(), "audio_track_set_key_end_offset", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "audio_track_set_key_end_offset", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();

					setting = false;
					return true;
				}

			} break;
			case Animation::TYPE_ANIMATION: {

				if (name == "animation") {

					StringName anim_name = p_value;

					setting = true;
					undo_redo->create_action(TTR("Anim Change Keyframe Value"), UndoRedo::MERGE_ENDS);
					StringName prev = animation->animation_track_get_key_animation(track, key);
					undo_redo->add_do_method(animation.ptr(), "animation_track_set_key_animation", track, key, anim_name);
					undo_redo->add_undo_method(animation.ptr(), "animation_track_set_key_animation", track, key, prev);
					undo_redo->add_do_method(this, "_update_obj", animation);
					undo_redo->add_undo_method(this, "_update_obj", animation);
					undo_redo->commit_action();
					setting = false;
					return true;
				}

			} break;
		}

		return false;
	}

	bool _get(const StringName &p_name, Variant &r_ret) const {

		int key = animation->track_find_key(track, key_ofs, true);
		ERR_FAIL_COND_V(key == -1, false);

		String name = p_name;
		if (name == "time") {
			r_ret = key_ofs;
			return true;
		} else if (name == "easing") {
			r_ret = animation->track_get_key_transition(track, key);
			return true;
		}

		switch (animation->track_get_type(track)) {

			case Animation::TYPE_TRANSFORM: {

				Dictionary d = animation->track_get_key_value(track, key);
				ERR_FAIL_COND_V(!d.has(name), false);
				r_ret = d[p_name];
				return true;

			} break;
			case Animation::TYPE_VALUE: {

				if (name == "value") {
					r_ret = animation->track_get_key_value(track, key);
					return true;
				}

			} break;
			case Animation::TYPE_METHOD: {

				Dictionary d = animation->track_get_key_value(track, key);

				if (name == "name") {

					ERR_FAIL_COND_V(!d.has("method"), false);
					r_ret = d["method"];
					return true;
				}

				ERR_FAIL_COND_V(!d.has("args"), false);

				Vector<Variant> args = d["args"];

				if (name == "arg_count") {

					r_ret = args.size();
					return true;
				}

				if (name.begins_with("args/")) {

					int idx = name.get_slice("/", 1).to_int();
					ERR_FAIL_INDEX_V(idx, args.size(), false);

					String what = name.get_slice("/", 2);
					if (what == "type") {
						r_ret = args[idx].get_type();
						return true;
					}
					if (what == "value") {
						r_ret = args[idx];
						return true;
					}
				}

			} break;
			case Animation::TYPE_BEZIER: {

				if (name == "value") {
					r_ret = animation->bezier_track_get_key_value(track, key);
					return true;
				}
				if (name == "in_handle") {
					r_ret = animation->bezier_track_get_key_in_handle(track, key);
					return true;
				}
				if (name == "out_handle") {
					r_ret = animation->bezier_track_get_key_out_handle(track, key);
					return true;
				}

			} break;
			case Animation::TYPE_AUDIO: {

				if (name == "stream") {
					r_ret = animation->audio_track_get_key_stream(track, key);
					return true;
				}
				if (name == "start_offset") {
					r_ret = animation->audio_track_get_key_start_offset(track, key);
					return true;
				}
				if (name == "end_offset") {
					r_ret = animation->audio_track_get_key_end_offset(track, key);
					return true;
				}

			} break;
			case Animation::TYPE_ANIMATION: {

				if (name == "animation") {
					r_ret = animation->animation_track_get_key_animation(track, key);
					return true;
				}

			} break;
		}

		return false;
	}
	void _get_property_list(List<PropertyInfo> *p_list) const {

		if (animation.is_null())
			return;

		ERR_FAIL_INDEX(track, animation->get_track_count());
		int key = animation->track_find_key(track, key_ofs, true);
		ERR_FAIL_COND(key == -1);

		p_list->push_back(PropertyInfo(Variant::REAL, "time", PROPERTY_HINT_RANGE, "0," + rtos(animation->get_length()) + ",0.01"));

		switch (animation->track_get_type(track)) {

			case Animation::TYPE_TRANSFORM: {

				p_list->push_back(PropertyInfo(Variant::VECTOR3, "location"));
				p_list->push_back(PropertyInfo(Variant::QUAT, "rotation"));
				p_list->push_back(PropertyInfo(Variant::VECTOR3, "scale"));

			} break;
			case Animation::TYPE_VALUE: {

				Variant v = animation->track_get_key_value(track, key);

				if (hint.type != Variant::NIL) {

					PropertyInfo pi = hint;
					pi.name = "value";
					p_list->push_back(pi);
				} else {

					PropertyHint hint = PROPERTY_HINT_NONE;
					String hint_string;

					if (v.get_type() == Variant::OBJECT) {
						//could actually check the object property if exists..? yes i will!
						Ref<Resource> res = v;
						if (res.is_valid()) {

							hint = PROPERTY_HINT_RESOURCE_TYPE;
							hint_string = res->get_class();
						}
					}

					if (v.get_type() != Variant::NIL)
						p_list->push_back(PropertyInfo(v.get_type(), "value", hint, hint_string));
				}

			} break;
			case Animation::TYPE_METHOD: {

				p_list->push_back(PropertyInfo(Variant::STRING, "name"));
				p_list->push_back(PropertyInfo(Variant::INT, "arg_count", PROPERTY_HINT_RANGE, "0,5,1"));

				Dictionary d = animation->track_get_key_value(track, key);
				ERR_FAIL_COND(!d.has("args"));
				Vector<Variant> args = d["args"];
				String vtypes;
				for (int i = 0; i < Variant::VARIANT_MAX; i++) {

					if (i > 0)
						vtypes += ",";
					vtypes += Variant::get_type_name(Variant::Type(i));
				}

				for (int i = 0; i < args.size(); i++) {

					p_list->push_back(PropertyInfo(Variant::INT, "args/" + itos(i) + "/type", PROPERTY_HINT_ENUM, vtypes));
					if (args[i].get_type() != Variant::NIL)
						p_list->push_back(PropertyInfo(args[i].get_type(), "args/" + itos(i) + "/value"));
				}

			} break;
			case Animation::TYPE_BEZIER: {

				p_list->push_back(PropertyInfo(Variant::REAL, "value"));
				p_list->push_back(PropertyInfo(Variant::VECTOR2, "in_handle"));
				p_list->push_back(PropertyInfo(Variant::VECTOR2, "out_handle"));

			} break;
			case Animation::TYPE_AUDIO: {

				p_list->push_back(PropertyInfo(Variant::OBJECT, "stream", PROPERTY_HINT_RESOURCE_TYPE, "AudioStream"));
				p_list->push_back(PropertyInfo(Variant::REAL, "start_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));
				p_list->push_back(PropertyInfo(Variant::REAL, "end_offset", PROPERTY_HINT_RANGE, "0,3600,0.01,or_greater"));

			} break;
			case Animation::TYPE_ANIMATION: {

				String animations;

				if (root_path && root_path->has_node(animation->track_get_path(track))) {

					AnimationPlayer *ap = Object::cast_to<AnimationPlayer>(root_path->get_node(animation->track_get_path(track)));
					if (ap) {
						List<StringName> anims;
						ap->get_animation_list(&anims);
						for (List<StringName>::Element *E = anims.front(); E; E = E->next()) {
							if (animations != String()) {
								animations += ",";
							}

							animations += String(E->get());
						}
					}
				}

				if (animations != String()) {
					animations += ",";
				}
				animations += "[stop]";

				p_list->push_back(PropertyInfo(Variant::STRING, "animation", PROPERTY_HINT_ENUM, animations));

			} break;
		}

		if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
			p_list->push_back(PropertyInfo(Variant::REAL, "easing", PROPERTY_HINT_EXP_EASING));
		}
	}

	UndoRedo *undo_redo;
	Ref<Animation> animation;
	int track;
	float key_ofs;
	Node *root_path;

	PropertyInfo hint;
	NodePath base;

	void notify_change() {

		_change_notify();
	}

	Node *get_root_path() {
		return root_path;
	}

	AnimationTrackKeyEdit() {
		key_ofs = 0;
		track = -1;
		setting = false;
		root_path = NULL;
	}
};

void AnimationTimelineEdit::_zoom_changed(double) {

	update();
	play_position->update();
	emit_signal("zoom_changed");
}

float AnimationTimelineEdit::get_zoom_scale() const {

	float zv = zoom->get_value();
	if (zv < 1) {
		zv = 1.0 - zv;
		return Math::pow(1.0f + zv, 8.0f) * 100;
	} else {
		return 1.0 / Math::pow(zv, 8.0f) * 100;
	}
}

void AnimationTimelineEdit::_anim_length_changed(double p_new_len) {

	if (editing)
		return;

	p_new_len = MAX(0.001, p_new_len);

	editing = true;
	*block_animation_update_ptr = true;
	undo_redo->create_action("Change animation length");
	undo_redo->add_do_method(animation.ptr(), "set_length", p_new_len);
	undo_redo->add_undo_method(animation.ptr(), "set_length", animation->get_length());
	undo_redo->commit_action();
	*block_animation_update_ptr = false;
	editing = false;
	update();

	emit_signal("length_changed", p_new_len);
}

void AnimationTimelineEdit::_anim_loop_pressed() {

	*block_animation_update_ptr = true;
	undo_redo->create_action("Change animation loop");
	undo_redo->add_do_method(animation.ptr(), "set_loop", loop->is_pressed());
	undo_redo->add_undo_method(animation.ptr(), "set_loop", animation->has_loop());
	undo_redo->commit_action();
	*block_animation_update_ptr = false;
}

int AnimationTimelineEdit::get_buttons_width() const {

	Ref<Texture> interp_mode = get_icon("TrackContinuous", "EditorIcons");
	Ref<Texture> interp_type = get_icon("InterpRaw", "EditorIcons");
	Ref<Texture> loop_type = get_icon("InterpWrapClamp", "EditorIcons");
	Ref<Texture> remove_icon = get_icon("Remove", "EditorIcons");
	Ref<Texture> down_icon = get_icon("select_arrow", "Tree");

	int total_w = interp_mode->get_width() + interp_type->get_width() + loop_type->get_width() + remove_icon->get_width();
	total_w += (down_icon->get_width() + 4 * EDSCALE) * 4;

	return total_w;
}

int AnimationTimelineEdit::get_name_limit() const {

	Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");

	int limit = MAX(name_limit, add_track->get_minimum_size().width + hsize_icon->get_width());

	limit = MIN(limit, get_size().width - get_buttons_width() - 1);

	return limit;
}

void AnimationTimelineEdit::_notification(int p_what) {

	if (p_what == NOTIFICATION_ENTER_TREE) {
		add_track->set_icon(get_icon("Add", "EditorIcons"));
		loop->set_icon(get_icon("Loop", "EditorIcons"));
		time_icon->set_texture(get_icon("Time", "EditorIcons"));

		add_track->get_popup()->clear();
		add_track->get_popup()->add_icon_item(get_icon("KeyValue", "EditorIcons"), TTR("Property Track"));
		add_track->get_popup()->add_icon_item(get_icon("KeyXform", "EditorIcons"), TTR("3D Transform Track"));
		add_track->get_popup()->add_icon_item(get_icon("KeyCall", "EditorIcons"), TTR("Call Method Track"));
		add_track->get_popup()->add_icon_item(get_icon("KeyBezier", "EditorIcons"), TTR("Bezier Curve Track"));
		add_track->get_popup()->add_icon_item(get_icon("KeyAudio", "EditorIcons"), TTR("Audio Playback Track"));
		add_track->get_popup()->add_icon_item(get_icon("KeyAnimation", "EditorIcons"), TTR("Animation Playback Track"));
	}

	if (p_what == NOTIFICATION_RESIZED) {
		len_hb->set_position(Vector2(get_size().width - get_buttons_width(), 0));
		len_hb->set_size(Size2(get_buttons_width(), get_size().height));
	}

	if (p_what == NOTIFICATION_DRAW) {

		int key_range = get_size().width - get_buttons_width() - get_name_limit();

		if (!animation.is_valid())
			return;

		Ref<Font> font = get_font("font", "Label");
		Color color = get_color("font_color", "Label");

		int zoomw = key_range;
		float scale = get_zoom_scale();
		int h = get_size().height;

		float l = animation->get_length();
		if (l <= 0)
			l = 0.001; //avoid crashor

		Ref<Texture> hsize_icon = get_icon("Hsize", "EditorIcons");
		hsize_rect = Rect2(get_name_limit() - hsize_icon->get_width() - 2 * EDSCALE, (get_size().height - hsize_icon->get_height()) / 2, hsize_icon->get_width(), hsize_icon->get_height());
		draw_texture(hsize_icon, hsize_rect.position);

		{
			float time_min = 0;
			float time_max = animation->get_length();
			for (int i = 0; i < animation->get_track_count(); i++) {

				if (animation->track_get_key_count(i) > 0) {

					float beg = animation->track_get_key_time(i, 0);
					/*if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
						beg += animation->bezier_track_get_key_in_handle(i, 0).x;
					}* not worth it since they have no use */

					if (beg < time_min)
						time_min = beg;

					float end = animation->track_get_key_time(i, animation->track_get_key_count(i) - 1);
					/*if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {
						end += animation->bezier_track_get_key_out_handle(i, animation->track_get_key_count(i) - 1).x;
					} not worth it since they have no use */

					if (end > time_max)
						time_max = end;
				}
			}

			float extra = (zoomw / scale) * 0.5;

			//if (time_min < -0.001)
			//	time_min -= extra;
			time_max += extra;
			set_min(time_min);
			set_max(time_max);

			if (zoomw / scale < (time_max - time_min)) {
				hscroll->show();

			} else {

				hscroll->hide();
			}
		}

		set_page(zoomw / scale);

		int end_px = (l - get_value()) * scale;
		int begin_px = -get_value() * scale;
		Color notimecol = get_color("dark_color_2", "Editor");
		Color timecolor = color;
		timecolor.a = 0.2;
		Color linecolor = color;
		linecolor.a = 0.2;

		{

			draw_rect(Rect2(Point2(get_name_limit(), 0), Point2(zoomw - 1, h)), notimecol);

			if (begin_px < zoomw && end_px > 0) {

				if (begin_px < 0)
					begin_px = 0;
				if (end_px > zoomw)
					end_px = zoomw;

				draw_rect(Rect2(Point2(get_name_limit() + begin_px, 0), Point2(end_px - begin_px - 1, h)), timecolor);
			}
		}

		Color color_time_sec = color;
		Color color_time_dec = color;
		color_time_dec.a *= 0.5;
#define SC_ADJ 100
		int min = 30;
		int dec = 1;
		int step = 1;
		int decimals = 2;
		bool step_found = false;

		const int period_width = font->get_char_size('.').width;
		int max_digit_width = font->get_char_size('0').width;
		for (int i = 1; i <= 9; i++) {
			const int digit_width = font->get_char_size('0' + i).width;
			max_digit_width = MAX(digit_width, max_digit_width);
		}
		const int max_sc = int(Math::ceil(zoomw / scale));
		const int max_sc_width = String::num(max_sc).length() * max_digit_width;

		while (!step_found) {

			min = max_sc_width;
			if (decimals > 0)
				min += period_width + max_digit_width * decimals;

			static const int _multp[3] = { 1, 2, 5 };
			for (int i = 0; i < 3; i++) {

				step = (_multp[i] * dec);
				if (step * scale / SC_ADJ > min) {
					step_found = true;
					break;
				}
			}
			if (step_found)
				break;
			dec *= 10;
			decimals--;
			if (decimals < 0)
				decimals = 0;
		}

		for (int i = 0; i < zoomw; i++) {

			float pos = get_value() + double(i) / scale;
			float prev = get_value() + (double(i) - 1.0) / scale;

			int sc = int(Math::floor(pos * SC_ADJ));
			int prev_sc = int(Math::floor(prev * SC_ADJ));
			bool sub = (sc % SC_ADJ);

			if ((sc / step) != (prev_sc / step) || (prev_sc < 0 && sc >= 0)) {

				int scd = sc < 0 ? prev_sc : sc;
				draw_line(Point2(get_name_limit() + i, 0), Point2(get_name_limit() + i, h), linecolor);
				draw_string(font, Point2(get_name_limit() + i + 3, (h - font->get_height()) / 2 + font->get_ascent()).floor(), String::num((scd - (scd % step)) / double(SC_ADJ), decimals), sub ? color_time_dec : color_time_sec, zoomw - i);
			}
		}

		draw_line(Vector2(0, get_size().height), get_size(), linecolor);
	}
}

void AnimationTimelineEdit::set_animation(const Ref<Animation> &p_animation) {
	animation = p_animation;
	if (animation.is_valid()) {
		len_hb->show();
		add_track->show();
		play_position->show();
	} else {
		len_hb->hide();
		add_track->hide();
		play_position->hide();
	}
	update();
	update_values();
}

Size2 AnimationTimelineEdit::get_minimum_size() const {

	Size2 ms = add_track->get_minimum_size();
	Ref<Font> font = get_font("font", "Label");
	ms.height = MAX(ms.height, font->get_height());
	ms.width = get_buttons_width() + add_track->get_minimum_size().width + get_icon("Hsize", "EditorIcons")->get_width() + 2;
	return ms;
}

void AnimationTimelineEdit::set_block_animation_update_ptr(bool *p_block_ptr) {
	block_animation_update_ptr = p_block_ptr;
}

void AnimationTimelineEdit::set_undo_redo(UndoRedo *p_undo_redo) {
	undo_redo = p_undo_redo;
}

void AnimationTimelineEdit::set_zoom(Range *p_zoom) {
	zoom = p_zoom;
	zoom->connect("value_changed", this, "_zoom_changed");
}

void AnimationTimelineEdit::set_play_position(float p_pos) {

	play_position_pos = p_pos;
	play_position->update();
}

float AnimationTimelineEdit::get_play_position() const {
	return play_position_pos;
}

void AnimationTimelineEdit::update_play_position() {
	play_position->update();
}

void AnimationTimelineEdit::update_values() {

	if (!animation.is_valid() || editing)
		return;

	editing = true;
	length->set_value(animation->get_length());
	loop->set_pressed(animation->has_loop());
	editing = false;
}

void AnimationTimelineEdit::_play_position_draw() {

	if (!animation.is_valid() || play_position_pos < 0)
		return;

	float scale = get_zoom_scale();
	int h = play_position->get_size().height;

	int px = (-get_value() + play_position_pos) * scale + get_name_limit();

	if (px >= get_name_limit() && px < (play_position->get_size().width - get_buttons_width())) {
		Color color = get_color("accent_color", "Editor");
		play_position->draw_line(Point2(px, 0), Point2(px, h), color);
	}
}

void AnimationTimelineEdit::_gui_input(const Ref<InputEvent> &p_event) {

	Ref<InputEventMouseButton> mb = p_event;

	if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && hsize_rect.has_point(mb->get_position())) {

		dragging_hsize = true;
		dragging_hsize_from = mb->get_position().x;
		dragging_hsize_at = name_limit;
	}

	if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && dragging_hsize) {
		dragging_hsize = false;
	}
	if (mb.is_valid() && mb->get_position().x > get_name_limit() && mb->get_position().x < (get_size().width - get_buttons_width())) {

		if (!panning_timeline && mb->get_button_index() == BUTTON_LEFT) {
			int x = mb->get_position().x - get_name_limit();

			float ofs = x / get_zoom_scale() + get_value();
			emit_signal("timeline_changed", ofs, false);
			dragging_timeline = true;
		}
		if (!dragging_timeline && mb->get_button_index() == BUTTON_MIDDLE) {
			int x = mb->get_position().x - get_name_limit();
			panning_timeline_from = x / get_zoom_scale();
			panning_timeline = true;
			panning_timeline_at = get_value();
		}
	}

	if (dragging_timeline && mb.is_valid() && mb->get_button_index() == BUTTON_LEFT && !mb->is_pressed()) {
		dragging_timeline = false;
	}

	if (panning_timeline && mb.is_valid() && mb->get_button_index() == BUTTON_MIDDLE && !mb->is_pressed()) {
		panning_timeline = false;
	}

	Ref<InputEventMouseMotion> mm = p_event;

	if (mm.is_valid()) {

		if (dragging_hsize) {
			int ofs = mm->get_position().x - dragging_hsize_from;
			name_limit = dragging_hsize_at + ofs;
			update();
			emit_signal("name_limit_changed");
			play_position->update();
		}
		if (dragging_timeline) {
			int x = mm->get_position().x - get_name_limit();
			float ofs = x / get_zoom_scale() + get_value();
			emit_signal("timeline_changed", ofs, false);
		}
		if (panning_timeline) {
			int x = mm->get_position().x - get_name_limit();
			float ofs = x / get_zoom_scale();
			float diff = ofs - panning_timeline_from;
			set_value(panning_timeline_at - diff);
		}
	}
}

void AnimationTimelineEdit::set_hscroll(HScrollBar *p_hscroll) {

	hscroll = p_hscroll;
}

void AnimationTimelineEdit::_track_added(int p_track) {
	emit_signal("track_added", p_track);
}

void AnimationTimelineEdit::_bind_methods() {
	ClassDB::bind_method("_zoom_changed", &AnimationTimelineEdit::_zoom_changed);
	ClassDB::bind_method("_anim_length_changed", &AnimationTimelineEdit::_anim_length_changed);
	ClassDB::bind_method("_anim_loop_pressed", &AnimationTimelineEdit::_anim_loop_pressed);
	ClassDB::bind_method("_play_position_draw", &AnimationTimelineEdit::_play_position_draw);
	ClassDB::bind_method("_gui_input", &AnimationTimelineEdit::_gui_input);
	ClassDB::bind_method("_track_added", &AnimationTimelineEdit::_track_added);

	ADD_SIGNAL(MethodInfo("zoom_changed"));
	ADD_SIGNAL(MethodInfo("name_limit_changed"));
	ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
	ADD_SIGNAL(MethodInfo("track_added", PropertyInfo(Variant::INT, "track")));
	ADD_SIGNAL(MethodInfo("length_changed", PropertyInfo(Variant::REAL, "size")));
}

AnimationTimelineEdit::AnimationTimelineEdit() {

	block_animation_update_ptr = NULL;
	editing = false;
	name_limit = 150;
	zoom = NULL;

	play_position_pos = 0;
	play_position = memnew(Control);
	play_position->set_mouse_filter(MOUSE_FILTER_PASS);
	add_child(play_position);
	play_position->set_anchors_and_margins_preset(PRESET_WIDE);
	play_position->connect("draw", this, "_play_position_draw");

	add_track = memnew(MenuButton);
	add_track->set_position(Vector2(0, 0));
	add_child(add_track);
	add_track->set_text(TTR("Add Track"));

	len_hb = memnew(HBoxContainer);

	Control *expander = memnew(Control);
	expander->set_h_size_flags(SIZE_EXPAND_FILL);
	len_hb->add_child(expander);
	time_icon = memnew(TextureRect);
	time_icon->set_v_size_flags(SIZE_SHRINK_CENTER);
	time_icon->set_tooltip(TTR("Animation Length Time (seconds)"));
	len_hb->add_child(time_icon);
	length = memnew(EditorSpinSlider);
	length->set_min(0.001);
	length->set_max(3600);
	length->set_step(0.01);
	length->set_allow_greater(true);
	length->set_custom_minimum_size(Vector2(70 * EDSCALE, 0));
	length->set_hide_slider(true);
	length->set_tooltip(TTR("Animation Length Time (seconds)"));
	length->connect("value_changed", this, "_anim_length_changed");
	len_hb->add_child(length);
	loop = memnew(ToolButton);
	loop->set_tooltip(TTR("Animation Looping"));
	loop->connect("pressed", this, "_anim_loop_pressed");
	loop->set_toggle_mode(true);
	len_hb->add_child(loop);
	add_child(len_hb);

	add_track->hide();
	add_track->get_popup()->connect("index_pressed", this, "_track_added");
	len_hb->hide();

	panning_timeline = false;
	dragging_timeline = false;
	dragging_hsize = false;
}

////////////////////////////////////

void AnimationTrackEdit::_notification(int p_what) {
	if (p_what == NOTIFICATION_DRAW) {
		if (animation.is_null())
			return;
		ERR_FAIL_INDEX(track, animation->get_track_count());

		int limit = timeline->get_name_limit();

		if (has_focus()) {
			Color accent = get_color("accent_color", "Editor");
			accent.a *= 0.7;
			draw_rect(Rect2(Point2(), get_size()), accent, false);
		}

		Ref<Font> font = get_font("font", "Label");
		Color color = get_color("font_color", "Label");
		Ref<Texture> type_icons[6] = {
			get_icon("KeyValue", "EditorIcons"),
			get_icon("KeyXform", "EditorIcons"),
			get_icon("KeyCall", "EditorIcons"),
			get_icon("KeyBezier", "EditorIcons"),
			get_icon("KeyAudio", "EditorIcons"),
			get_icon("KeyAnimation", "EditorIcons")
		};
		int hsep = get_constant("hseparation", "ItemList");
		Color linecolor = color;
		linecolor.a = 0.2;

		// NAMES AND ICONS //

		{

			Ref<Texture> check = animation->track_is_enabled(track) ? get_icon("checked", "CheckBox") : get_icon("unchecked", "CheckBox");

			int ofs = in_group ? check->get_width() : 0; //not the best reference for margin but..

			check_rect = Rect2(Point2(ofs, int(get_size().height - check->get_height()) / 2), check->get_size());

			draw_texture(check, check_rect.position);

			ofs += check->get_width() + hsep;

			Ref<Texture> type_icon = type_icons[animation->track_get_type(track)];

			draw_texture(type_icon, Point2(ofs, int(get_size().height - type_icon->get_height()) / 2));
			ofs += type_icon->get_width() + hsep;

			NodePath path = animation->track_get_path(track);

			Node *node = NULL;

			if (root && root->has_node(path)) {
				node = root->get_node(path);
			}

			String text;
			Color text_color = color;
			if (node && EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
				text_color = get_color("accent_color", "Editor");
			}

			if (in_group) {

				if (animation->track_get_type(track) == Animation::TYPE_METHOD) {
					text = TTR("Functions:");
				} else if (animation->track_get_type(track) == Animation::TYPE_AUDIO) {
					text = TTR("Audio Clips:");
				} else if (animation->track_get_type(track) == Animation::TYPE_ANIMATION) {
					text = TTR("Anim Clips:");
				} else {
					Vector<StringName> sn = path.get_subnames();
					for (int i = 0; i < sn.size(); i++) {
						if (i > 0) {
							text += ".";
						}
						text += sn[i];
					}
				}
				text_color.a *= 0.7;
			} else if (node) {
				Ref<Texture> icon;
				if (has_icon(node->get_class(), "EditorIcons")) {
					icon = get_icon(node->get_class(), "EditorIcons");
				} else {
					icon = get_icon("Node", "EditorIcons");
				}

				draw_texture(icon, Point2(ofs, int(get_size().height - icon->get_height()) / 2));
				icon_cache = icon;

				text = node->get_name();
				ofs += hsep;
				ofs += icon->get_width();
				Vector<StringName> sn = path.get_subnames();
				for (int i = 0; i < sn.size(); i++) {
					text += ".";
					text += sn[i];
				}
			} else {
				icon_cache = type_icon;

				text = path;
			}

			path_cache = text;

			path_rect = Rect2(ofs, 0, limit - ofs - hsep, get_size().height);

			Vector2 string_pos = Point2(ofs, (get_size().height - font->get_height()) / 2 + font->get_ascent());
			string_pos = string_pos.floor();
			draw_string(font, string_pos, text, text_color, limit - ofs - hsep);

			draw_line(Point2(limit, 0), Point2(limit, get_size().height), linecolor);
		}

		// KEYFAMES //

		draw_bg(limit, get_size().width - timeline->get_buttons_width());

		{

			float scale = timeline->get_zoom_scale();
			int limit_end = get_size().width - timeline->get_buttons_width();

			for (int i = 0; i < animation->track_get_key_count(track); i++) {

				float offset = animation->track_get_key_time(track, i) - timeline->get_value();
				if (editor->is_key_selected(track, i) && editor->is_moving_selection()) {
					offset = editor->snap_time(offset + editor->get_moving_selection_offset());
				}
				offset = offset * scale + limit;
				if (i < animation->track_get_key_count(track) - 1) {

					float offset_n = animation->track_get_key_time(track, i + 1) - timeline->get_value();
					if (editor->is_key_selected(track, i + 1) && editor->is_moving_selection()) {
						offset_n = editor->snap_time(offset_n + editor->get_moving_selection_offset());
					}
					offset_n = offset_n * scale + limit;

					draw_key_link(i, scale, int(offset), int(offset_n), limit, limit_end);
				}

				draw_key(i, scale, int(offset), editor->is_key_selected(track, i), limit, limit_end);
			}
		}

		draw_fg(limit, get_size().width - timeline->get_buttons_width());

		// BUTTONS //
		{

			Ref<Texture> wrap_icon[2] = {
				get_icon("InterpWrapClamp", "EditorIcons"),
				get_icon("InterpWrapLoop", "EditorIcons"),
			};

			Ref<Texture> interp_icon[3] = {
				get_icon("InterpRaw", "EditorIcons"),
				get_icon("InterpLinear", "EditorIcons"),
				get_icon("InterpCubic", "EditorIcons")
			};
			Ref<Texture> cont_icon[4] = {
				get_icon("TrackContinuous", "EditorIcons"),
				get_icon("TrackDiscrete", "EditorIcons"),
				get_icon("TrackTrigger", "EditorIcons"),
				get_icon("TrackCapture", "EditorIcons")
			};

			int ofs = get_size().width - timeline->get_buttons_width();

			Ref<Texture> down_icon = get_icon("select_arrow", "Tree");

			draw_line(Point2(ofs, 0), Point2(ofs, get_size().height), linecolor);

			ofs += hsep;
			{
				//callmode

				Animation::UpdateMode update_mode;

				if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
					update_mode = animation->value_track_get_update_mode(track);
				} else {
					update_mode = Animation::UPDATE_CONTINUOUS;
				}

				Ref<Texture> update_icon = cont_icon[update_mode];

				update_mode_rect.position.x = ofs;
				update_mode_rect.position.y = int(get_size().height - update_icon->get_height()) / 2;
				update_mode_rect.size = update_icon->get_size();

				if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
					draw_texture(update_icon, update_mode_rect.position);
				}
				//make it easier to click
				update_mode_rect.position.y = 0;
				update_mode_rect.size.y = get_size().height;

				ofs += update_icon->get_width() + hsep;
				update_mode_rect.size.x += hsep;

				if (animation->track_get_type(track) == Animation::TYPE_VALUE) {
					draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
					update_mode_rect.size.x += down_icon->get_width();
					bezier_edit_rect = Rect2();
				} else if (animation->track_get_type(track) == Animation::TYPE_BEZIER) {
					Ref<Texture> bezier_icon = get_icon("EditBezier", "EditorIcons");
					update_mode_rect.size.x += down_icon->get_width();
					bezier_edit_rect.position = update_mode_rect.position + (update_mode_rect.size - bezier_icon->get_size()) / 2;
					bezier_edit_rect.size = bezier_icon->get_size();
					draw_texture(bezier_icon, bezier_edit_rect.position);
					update_mode_rect = Rect2();
				} else {
					update_mode_rect = Rect2();
					bezier_edit_rect = Rect2();
				}

				ofs += down_icon->get_width();
				draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor);
				ofs += hsep;
			}

			{
				//interp

				Animation::InterpolationType interp_mode = animation->track_get_interpolation_type(track);

				Ref<Texture> icon = interp_icon[interp_mode];

				interp_mode_rect.position.x = ofs;
				interp_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
				interp_mode_rect.size = icon->get_size();

				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
					draw_texture(icon, interp_mode_rect.position);
				}
				//make it easier to click
				interp_mode_rect.position.y = 0;
				interp_mode_rect.size.y = get_size().height;

				ofs += icon->get_width() + hsep;
				interp_mode_rect.size.x += hsep;

				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
					draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
					interp_mode_rect.size.x += down_icon->get_width();
				} else {
					interp_mode_rect = Rect2();
				}

				ofs += down_icon->get_width();
				draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor);
				ofs += hsep;
			}

			{
				//loop

				bool loop_wrap = animation->track_get_interpolation_loop_wrap(track);

				Ref<Texture> icon = wrap_icon[loop_wrap ? 1 : 0];

				loop_mode_rect.position.x = ofs;
				loop_mode_rect.position.y = int(get_size().height - icon->get_height()) / 2;
				loop_mode_rect.size = icon->get_size();

				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
					draw_texture(icon, loop_mode_rect.position);
				}

				loop_mode_rect.position.y = 0;
				loop_mode_rect.size.y = get_size().height;

				ofs += icon->get_width() + hsep;
				loop_mode_rect.size.x += hsep;

				if (animation->track_get_type(track) == Animation::TYPE_VALUE || animation->track_get_type(track) == Animation::TYPE_TRANSFORM) {
					draw_texture(down_icon, Vector2(ofs, int(get_size().height - down_icon->get_height()) / 2));
					loop_mode_rect.size.x += down_icon->get_width();
				} else {
					loop_mode_rect = Rect2();
				}

				ofs += down_icon->get_width();
				draw_line(Point2(ofs + hsep * 0.5, 0), Point2(ofs + hsep * 0.5, get_size().height), linecolor);
				ofs += hsep;
			}

			{
				//erase

				Ref<Texture> icon = get_icon("Remove", "EditorIcons");

				remove_rect.position.x = ofs + ((get_size().width - ofs) - icon->get_width()) / 2;
				remove_rect.position.y = int(get_size().height - icon->get_height()) / 2;
				remove_rect.size = icon->get_size();

				draw_texture(icon, remove_rect.position);
			}
		}

		if (in_group) {
			draw_line(Vector2(timeline->get_name_limit(), get_size().height), get_size(), linecolor);
		} else {
			draw_line(Vector2(0, get_size().height), get_size(), linecolor);
		}

		if (dropping_at != 0) {
			Color drop_color = get_color("accent_color", "Editor");
			if (dropping_at < 0) {
				draw_line(Vector2(0, 0), Vector2(get_size().width, 0), drop_color);
			} else {
				draw_line(Vector2(0, get_size().height), get_size(), drop_color);
			}
		}
	}

	if (p_what == NOTIFICATION_MOUSE_EXIT || p_what == NOTIFICATION_DRAG_END) {
		cancel_drop();
	}
}

int AnimationTrackEdit::get_key_height() const {
	if (!animation.is_valid())
		return 0;

	return type_icon->get_height();
}
Rect2 AnimationTrackEdit::get_key_rect(int p_index, float p_pixels_sec) {

	if (!animation.is_valid())
		return Rect2();
	Rect2 rect = Rect2(-type_icon->get_width() / 2, 0, type_icon->get_width(), get_size().height);

	//make it a big easier to click
	rect.position.x -= rect.size.x * 0.5;
	rect.size.x *= 2;
	return rect;
}

bool AnimationTrackEdit::is_key_selectable_by_distance() const {
	return true;
}

void AnimationTrackEdit::draw_key_link(int p_index, float p_pixels_sec, int p_x, int p_next_x, int p_clip_left, int p_clip_right) {
	if (p_next_x < p_clip_left)
		return;
	if (p_x > p_clip_right)
		return;

	Variant current = animation->track_get_key_value(get_track(), p_index);
	Variant next = animation->track_get_key_value(get_track(), p_index + 1);
	if (current != next)
		return;

	Color color = get_color("font_color", "Label");
	color.a = 0.5;

	int from_x = MAX(p_x, p_clip_left);
	int to_x = MIN(p_next_x, p_clip_right);

	draw_line(Point2(from_x + 1, get_size().height / 2), Point2(to_x, get_size().height / 2), color, 2);
}

void AnimationTrackEdit::draw_key(int p_index, float p_pixels_sec, int p_x, bool p_selected, int p_clip_left, int p_clip_right) {

	if (!animation.is_valid())
		return;

	if (p_x < p_clip_left || p_x > p_clip_right)
		return;

	Vector2 ofs(p_x - type_icon->get_width() / 2, int(get_size().height - type_icon->get_height()) / 2);

	if (animation->track_get_type(track) == Animation::TYPE_METHOD) {
		Ref<Font> font = get_font("font", "Label");
		Color color = get_color("font_color", "Label");
		color.a = 0.5;

		Dictionary d = animation->track_get_key_value(track, p_index);
		String text;

		if (d.has("method"))
			text += String(d["method"]);
		text += "(";
		Vector<Variant> args;
		if (d.has("args"))
			args = d["args"];
		for (int i = 0; i < args.size(); i++) {

			if (i > 0)
				text += ", ";
			text += String(args[i]);
		}
		text += ")";

		int limit = MAX(0, p_clip_right - p_x - type_icon->get_width());
		if (limit > 0) {
			draw_string(font, Vector2(p_x + type_icon->get_width(), int(get_size().height - font->get_height()) / 2 + font->get_ascent()), text, color, limit);
		}
	}
	if (p_selected) {
		draw_texture(selected_icon, ofs);
	} else {
		draw_texture(type_icon, ofs);
	}
}

//helper
void AnimationTrackEdit::draw_rect_clipped(const Rect2 &p_rect, const Color &p_color, bool p_filled) {

	int clip_left = timeline->get_name_limit();
	int clip_right = get_size().width - timeline->get_buttons_width();

	if (p_rect.position.x > clip_right)
		return;
	if (p_rect.position.x + p_rect.size.x < clip_left)
		return;
	Rect2 clip = Rect2(clip_left, 0, clip_right - clip_left, get_size().height);
	draw_rect(clip.clip(p_rect), p_color, p_filled);
}

void AnimationTrackEdit::draw_bg(int p_clip_left, int p_clip_right) {
}

void AnimationTrackEdit::draw_fg(int p_clip_left, int p_clip_right) {
}

void AnimationTrackEdit::draw_texture_clipped(const Ref<Texture> &p_texture, const Vector2 &p_pos) {

	draw_texture_region_clipped(p_texture, Rect2(p_pos, p_texture->get_size()), Rect2(Point2(), p_texture->get_size()));
}

void AnimationTrackEdit::draw_texture_region_clipped(const Ref<Texture> &p_texture, const Rect2 &p_rect, const Rect2 &p_region) {

	int clip_left = timeline->get_name_limit();
	int clip_right = get_size().width - timeline->get_buttons_width();

	//clip left and right
	if (clip_left > p_rect.position.x + p_rect.size.x)
		return;
	if (clip_right < p_rect.position.x)
		return;

	Rect2 rect = p_rect;
	Rect2 region = p_region;

	if (clip_left > rect.position.x) {
		int rect_pixels = (clip_left - rect.position.x);
		int region_pixels = rect_pixels * region.size.x / rect.size.x;

		rect.position.x += rect_pixels;
		rect.size.x -= rect_pixels;

		region.position.x += region_pixels;
		region.size.x -= region_pixels;
	}

	if (clip_right < rect.position.x + rect.size.x) {

		int rect_pixels = rect.position.x + rect.size.x - clip_right;
		int region_pixels = rect_pixels * region.size.x / rect.size.x;

		rect.size.x -= rect_pixels;
		region.size.x -= region_pixels;
	}

	draw_texture_rect_region(p_texture, rect, region);
}

int AnimationTrackEdit::get_track() const {
	return track;
}

Ref<Animation> AnimationTrackEdit::get_animation() const {
	return animation;
}

void AnimationTrackEdit::set_animation_and_track(const Ref<Animation> &p_animation, int p_track) {

	animation = p_animation;
	track = p_track;
	update();

	Ref<Texture> type_icons[6] = {
		get_icon("KeyValue", "EditorIcons"),
		get_icon("KeyXform", "EditorIcons"),
		get_icon("KeyCall", "EditorIcons"),
		get_icon("KeyBezier", "EditorIcons"),
		get_icon("KeyAudio", "EditorIcons"),
		get_icon("KeyAnimation", "EditorIcons")
	};

	ERR_FAIL_INDEX(track, animation->get_track_count());

	type_icon = type_icons[animation->track_get_type(track)];
	selected_icon = get_icon("KeySelected", "EditorIcons");
}

Size2 AnimationTrackEdit::get_minimum_size() const {

	Ref<Texture> texture = get_icon("Object", "EditorIcons");
	Ref<Font> font = get_font("font", "Label");
	int separation = get_constant("vseparation", "ItemList");

	int max_h = MAX(texture->get_height(), font->get_height());
	max_h = MAX(max_h, get_key_height());

	return Vector2(1, max_h + separation);
}

void AnimationTrackEdit::set_undo_redo(UndoRedo *p_undo_redo) {
	undo_redo = p_undo_redo;
}

void AnimationTrackEdit::set_timeline(AnimationTimelineEdit *p_timeline) {
	timeline = p_timeline;
	timeline->connect("zoom_changed", this, "_zoom_changed");
	timeline->connect("name_limit_changed", this, "_zoom_changed");
}
void AnimationTrackEdit::set_editor(AnimationTrackEditor *p_editor) {
	editor = p_editor;
}

void AnimationTrackEdit::_play_position_draw() {

	if (!animation.is_valid() || play_position_pos < 0)
		return;

	float scale = timeline->get_zoom_scale();
	int h = get_size().height;

	int px = (-timeline->get_value() + play_position_pos) * scale + timeline->get_name_limit();

	if (px >= timeline->get_name_limit() && px < (get_size().width - timeline->get_buttons_width())) {
		Color color = get_color("accent_color", "Editor");
		play_position->draw_line(Point2(px, 0), Point2(px, h), color);
	}
}

void AnimationTrackEdit::set_play_position(float p_pos) {

	play_position_pos = p_pos;
	play_position->update();
}

void AnimationTrackEdit::update_play_position() {
	play_position->update();
}

void AnimationTrackEdit::set_root(Node *p_root) {
	root = p_root;
}
void AnimationTrackEdit::_zoom_changed() {
	update();
	play_position->update();
}

void AnimationTrackEdit::_path_entered(const String &p_text) {
	undo_redo->create_action("Change Track Path");
	undo_redo->add_do_method(animation.ptr(), "track_set_path", track, p_text);
	undo_redo->add_undo_method(animation.ptr(), "track_set_path", track, animation->track_get_path(track));
	undo_redo->commit_action();
}

String AnimationTrackEdit::get_tooltip(const Point2 &p_pos) const {

	if (check_rect.has_point(p_pos)) {
		return TTR("Toggle this track on/off.");
	}

	if (path_rect.has_point(p_pos)) {
		return animation->track_get_path(track);
	}

	if (update_mode_rect.has_point(p_pos)) {
		return TTR("Update Mode (How this property is set)");
	}

	if (interp_mode_rect.has_point(p_pos)) {
		return TTR("Interpolation Mode");
	}

	if (loop_mode_rect.has_point(p_pos)) {
		return TTR("Loop Wrap Mode (Interpolate end with beginning on loop)");
	}

	if (remove_rect.has_point(p_pos)) {
		return TTR("Remove this track.");
	}

	if (p_pos.x >= timeline->get_name_limit() && p_pos.x <= (get_size().width - timeline->get_buttons_width())) {

		int key_idx = -1;
		float key_distance = 1e20;

		for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select

			Rect2 rect = const_cast<AnimationTrackEdit *>(this)->get_key_rect(i, timeline->get_zoom_scale());
			float offset = animation->track_get_key_time(track, i) - timeline->get_value();
			offset = offset * timeline->get_zoom_scale() + timeline->get_name_limit();
			rect.position.x += offset;

			if (rect.has_point(p_pos)) {

				if (const_cast<AnimationTrackEdit *>(this)->is_key_selectable_by_distance()) {
					float distance = ABS(offset - p_pos.x);
					if (key_idx == -1 || distance < key_distance) {
						key_idx = i;
						key_distance = distance;
					}
				} else {
					//first one does it
					break;
				}
			}
		}

		if (key_idx != -1) {

			String text = TTR("Time (s): ") + rtos(animation->track_get_key_time(track, key_idx)) + "\n";
			switch (animation->track_get_type(track)) {

				case Animation::TYPE_TRANSFORM: {

					Dictionary d = animation->track_get_key_value(track, key_idx);
					if (d.has("location"))
						text += "Pos: " + String(d["location"]) + "\n";
					if (d.has("rotation"))
						text += "Rot: " + String(d["rotation"]) + "\n";
					if (d.has("scale"))
						text += "Scale: " + String(d["scale"]) + "\n";
				} break;
				case Animation::TYPE_VALUE: {

					Variant v = animation->track_get_key_value(track, key_idx);
					//text+="value: "+String(v)+"\n";

					bool prop_exists = false;
					Variant::Type valid_type = Variant::NIL;
					Object *obj = NULL;

					RES res;
					Vector<StringName> leftover_path;
					Node *node = root->get_node_and_resource(animation->track_get_path(track), res, leftover_path);

					if (res.is_valid()) {
						obj = res.ptr();
					} else if (node) {
						obj = node;
					}

					if (obj) {
						valid_type = obj->get_static_property_type_indexed(leftover_path, &prop_exists);
					}

					text += "Type: " + Variant::get_type_name(v.get_type()) + "\n";
					if (prop_exists && !Variant::can_convert(v.get_type(), valid_type)) {
						text += "Value: " + String(v) + "  (Invalid, expected type: " + Variant::get_type_name(valid_type) + ")\n";
					} else {
						text += "Value: " + String(v) + "\n";
					}
					text += "Easing: " + rtos(animation->track_get_key_transition(track, key_idx));

				} break;
				case Animation::TYPE_METHOD: {

					Dictionary d = animation->track_get_key_value(track, key_idx);
					if (d.has("method"))
						text += String(d["method"]);
					text += "(";
					Vector<Variant> args;
					if (d.has("args"))
						args = d["args"];
					for (int i = 0; i < args.size(); i++) {

						if (i > 0)
							text += ", ";
						text += String(args[i]);
					}
					text += ")\n";

				} break;
				case Animation::TYPE_BEZIER: {

					float h = animation->bezier_track_get_key_value(track, key_idx);
					text += "Value: " + rtos(h) + "\n";
					Vector2 ih = animation->bezier_track_get_key_in_handle(track, key_idx);
					text += "In-Handle: " + ih + "\n";
					Vector2 oh = animation->bezier_track_get_key_out_handle(track, key_idx);
					text += "Out-Handle: " + oh + "\n";
				} break;
				case Animation::TYPE_AUDIO: {

					String stream_name = "null";
					RES stream = animation->audio_track_get_key_stream(track, key_idx);
					if (stream.is_valid()) {
						if (stream->get_path().is_resource_file()) {
							stream_name = stream->get_path().get_file();
						} else if (stream->get_name() != "") {
							stream_name = stream->get_name();
						} else {
							stream_name = stream->get_class();
						}
					}

					text += "Stream: " + stream_name + "\n";
					float so = animation->audio_track_get_key_start_offset(track, key_idx);
					text += "Start (s): " + rtos(so) + "\n";
					float eo = animation->audio_track_get_key_end_offset(track, key_idx);
					text += "End (s): " + rtos(eo) + "\n";
				} break;
				case Animation::TYPE_ANIMATION: {

					String name = animation->animation_track_get_key_animation(track, key_idx);
					text += "Animation Clip: " + name + "\n";
				} break;
			}
			return text;
		}
	}

	return Control::get_tooltip(p_pos);
}

void AnimationTrackEdit::_gui_input(const Ref<InputEvent> &p_event) {

	if (p_event->is_pressed()) {
		if (ED_GET_SHORTCUT("animation_editor/duplicate_selection")->is_shortcut(p_event)) {
			emit_signal("duplicate_request");
			accept_event();
		}

		if (ED_GET_SHORTCUT("animation_editor/duplicate_selection_transposed")->is_shortcut(p_event)) {
			emit_signal("duplicate_transpose_request");
			accept_event();
		}

		if (ED_GET_SHORTCUT("animation_editor/delete_selection")->is_shortcut(p_event)) {
			emit_signal("delete_request");
			accept_event();
		}
	}

	Ref<InputEventMouseButton> mb = p_event;
	if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
		Point2 pos = mb->get_position();

		if (check_rect.has_point(pos)) {
			*block_animation_update_ptr = true;
			undo_redo->create_action("Toggle track enabled");
			undo_redo->add_do_method(animation.ptr(), "track_set_enabled", track, !animation->track_is_enabled(track));
			undo_redo->add_undo_method(animation.ptr(), "track_set_enabled", track, animation->track_is_enabled(track));
			undo_redo->commit_action();
			*block_animation_update_ptr = false;
			update();
			accept_event();
		}
		if (path_rect.has_point(pos)) {

			clicking_on_name = true;
			accept_event();
		}

		if (update_mode_rect.has_point(pos)) {
			if (!menu) {
				menu = memnew(PopupMenu);
				add_child(menu);
				menu->connect("id_pressed", this, "_menu_selected");
			}
			menu->clear();
			menu->add_icon_item(get_icon("TrackContinuous", "EditorIcons"), TTR("Continuous"), MENU_CALL_MODE_CONTINUOUS);
			menu->add_icon_item(get_icon("TrackDiscrete", "EditorIcons"), TTR("Discrete"), MENU_CALL_MODE_DISCRETE);
			menu->add_icon_item(get_icon("TrackTrigger", "EditorIcons"), TTR("Trigger"), MENU_CALL_MODE_TRIGGER);
			menu->add_icon_item(get_icon("TrackCapture", "EditorIcons"), TTR("Capture"), MENU_CALL_MODE_CAPTURE);
			menu->set_as_minsize();

			Vector2 popup_pos = get_global_position() + update_mode_rect.position + Vector2(0, update_mode_rect.size.height);
			menu->set_global_position(popup_pos);
			menu->popup();
			accept_event();
		}

		if (interp_mode_rect.has_point(pos)) {
			if (!menu) {
				menu = memnew(PopupMenu);
				add_child(menu);
				menu->connect("id_pressed", this, "_menu_selected");
			}
			menu->clear();
			menu->add_icon_item(get_icon("InterpRaw", "EditorIcons"), TTR("Nearest"), MENU_INTERPOLATION_NEAREST);
			menu->add_icon_item(get_icon("InterpLinear", "EditorIcons"), TTR("Linear"), MENU_INTERPOLATION_LINEAR);
			menu->add_icon_item(get_icon("InterpCubic", "EditorIcons"), TTR("Cubic"), MENU_INTERPOLATION_CUBIC);
			menu->set_as_minsize();

			Vector2 popup_pos = get_global_position() + interp_mode_rect.position + Vector2(0, interp_mode_rect.size.height);
			menu->set_global_position(popup_pos);
			menu->popup();
			accept_event();
		}

		if (loop_mode_rect.has_point(pos)) {
			if (!menu) {
				menu = memnew(PopupMenu);
				add_child(menu);
				menu->connect("id_pressed", this, "_menu_selected");
			}
			menu->clear();
			menu->add_icon_item(get_icon("InterpWrapClamp", "EditorIcons"), TTR("Clamp Loop Interp"), MENU_LOOP_CLAMP);
			menu->add_icon_item(get_icon("InterpWrapLoop", "EditorIcons"), TTR("Wrap Loop Interp"), MENU_LOOP_WRAP);
			menu->set_as_minsize();

			Vector2 popup_pos = get_global_position() + loop_mode_rect.position + Vector2(0, loop_mode_rect.size.height);
			menu->set_global_position(popup_pos);
			menu->popup();
			accept_event();
		}

		if (remove_rect.has_point(pos)) {
			emit_signal("remove_request", track);
			accept_event();
		}

		if (bezier_edit_rect.has_point(pos)) {
			emit_signal("bezier_edit");
			accept_event();
		}

		//check keyframes

		float scale = timeline->get_zoom_scale();
		int limit = timeline->get_name_limit();
		int limit_end = get_size().width - timeline->get_buttons_width();

		if (pos.x >= limit && pos.x <= limit_end) {

			int key_idx = -1;
			float key_distance = 1e20;

			for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select

				Rect2 rect = get_key_rect(i, scale);
				float offset = animation->track_get_key_time(track, i) - timeline->get_value();
				offset = offset * scale + limit;
				rect.position.x += offset;

				if (rect.has_point(pos)) {

					if (is_key_selectable_by_distance()) {
						float distance = ABS(offset - pos.x);
						if (key_idx == -1 || distance < key_distance) {
							key_idx = i;
							key_distance = distance;
						}
					} else {
						//first one does it
						key_idx = i;
						break;
					}
				}
			}

			if (key_idx != -1) {
				if (mb->get_command() || mb->get_shift()) {
					if (editor->is_key_selected(track, key_idx)) {
						emit_signal("deselect_key", key_idx);

					} else {
						emit_signal("select_key", key_idx, false);
						moving_selection_attempt = true;
						select_single_attempt = -1;
						moving_selection_from_ofs = (mb->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
					}
				} else {
					if (!editor->is_key_selected(track, key_idx)) {
						emit_signal("select_key", key_idx, true);
						select_single_attempt = -1;
					} else {
						select_single_attempt = key_idx;
					}

					moving_selection_attempt = true;
					moving_selection_from_ofs = (mb->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
				}
				accept_event();
			} else {
				emit_signal("clear_selection");
			}
		}

		/*using focus instead
		 * if (!selected && pos.x >= timeline->get_name_limit() && pos.x < (get_size().width - timeline->get_buttons_width())) {
			set_selected(true);
			emit_signal("selected");
		}
		*/
	}

	if (mb.is_valid() && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
		Point2 pos = mb->get_position();
		if (pos.x >= timeline->get_name_limit() && pos.x <= get_size().width - timeline->get_buttons_width()) {
			//can do something with menu too! show insert key
			float offset = (pos.x - timeline->get_name_limit()) / timeline->get_zoom_scale();
			if (!menu) {
				menu = memnew(PopupMenu);
				add_child(menu);
				menu->connect("id_pressed", this, "_menu_selected");
			}

			menu->clear();
			menu->add_icon_item(get_icon("Key", "EditorIcons"), TTR("Insert Key"), MENU_KEY_INSERT);
			if (editor->is_selection_active()) {
				menu->add_separator();
				menu->add_icon_item(get_icon("Duplicate", "EditorIcons"), TTR("Duplicate Key(s)"), MENU_KEY_DUPLICATE);
				menu->add_separator();
				menu->add_icon_item(get_icon("Remove", "EditorIcons"), TTR("Delete Key(s)"), MENU_KEY_DELETE);
			}
			menu->set_as_minsize();

			Vector2 popup_pos = get_global_transform().xform(get_local_mouse_position());
			menu->set_global_position(popup_pos);
			menu->popup();

			insert_at_pos = offset + timeline->get_value();
			accept_event();
		}
	}

	if (mb.is_valid() && !mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT && clicking_on_name) {

		if (!path) {
			path = memnew(LineEdit);
			add_child(path);
			path->set_as_toplevel(true);
			path->connect("text_entered", this, "_path_entered");
		}

		path->set_text(animation->track_get_path(track));
		Vector2 theme_ofs = path->get_stylebox("normal", "LineEdit")->get_offset();
		path->set_position(get_global_position() + path_rect.position - theme_ofs);
		path->set_size(path_rect.size);
		path->show_modal();
		path->grab_focus();
		path->set_cursor_position(path->get_text().length());
		clicking_on_name = false;
	}

	if (mb.is_valid() && moving_selection_attempt) {

		if (!mb->is_pressed() && mb->get_button_index() == BUTTON_LEFT) {
			moving_selection_attempt = false;
			if (moving_selection) {
				emit_signal("move_selection_commit");
			} else if (select_single_attempt != -1) {
				emit_signal("select_key", select_single_attempt, true);
			}
			moving_selection = false;
			select_single_attempt = -1;
		}

		if (moving_selection && mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {

			moving_selection_attempt = false;
			moving_selection = false;
			emit_signal("move_selection_cancel");
		}
	}

	Ref<InputEventMouseMotion> mm = p_event;
	if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_LEFT && moving_selection_attempt) {

		if (!moving_selection) {
			moving_selection = true;
			emit_signal("move_selection_begin");
		}

		float new_ofs = (mm->get_position().x - timeline->get_name_limit()) / timeline->get_zoom_scale();
		emit_signal("move_selection", new_ofs - moving_selection_from_ofs);
	}
}

Variant AnimationTrackEdit::get_drag_data(const Point2 &p_point) {

	if (!clicking_on_name)
		return Variant();

	Dictionary drag_data;
	drag_data["type"] = "animation_track";
	drag_data["index"] = track;

	ToolButton *tb = memnew(ToolButton);
	tb->set_text(path_cache);
	tb->set_icon(icon_cache);
	set_drag_preview(tb);

	clicking_on_name = false;

	return drag_data;
}

bool AnimationTrackEdit::can_drop_data(const Point2 &p_point, const Variant &p_data) const {

	Dictionary d = p_data;
	if (!d.has("type")) {
		return false;
	}

	String type = d["type"];
	if (type != "animation_track")
		return false;

	if (p_point.y < get_size().height / 2) {
		dropping_at = -1;
	} else {
		dropping_at = 1;
	}

	const_cast<AnimationTrackEdit *>(this)->update();
	const_cast<AnimationTrackEdit *>(this)->emit_signal("drop_attempted", track);

	return true;
}
void AnimationTrackEdit::drop_data(const Point2 &p_point, const Variant &p_data) {

	Dictionary d = p_data;
	if (!d.has("type")) {
		return;
	}

	String type = d["type"];
	if (type != "animation_track")
		return;

	int from_track = d["index"];

	if (dropping_at < 0) {
		emit_signal("dropped", from_track, track);
	} else {
		emit_signal("dropped", from_track, track + 1);
	}
}

void AnimationTrackEdit::_menu_selected(int p_index) {

	switch (p_index) {
		case MENU_CALL_MODE_CONTINUOUS:
		case MENU_CALL_MODE_DISCRETE:
		case MENU_CALL_MODE_TRIGGER:
		case MENU_CALL_MODE_CAPTURE: {

			Animation::UpdateMode update_mode = Animation::UpdateMode(p_index);
			*block_animation_update_ptr = true;
			undo_redo->create_action("Change animation update mode");
			undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", track, update_mode);
			undo_redo->add_undo_method(animation.ptr(), "value_track_set_update_mode", track, animation->value_track_get_update_mode(track));
			undo_redo->commit_action();
			*block_animation_update_ptr = false;
			update();

		} break;
		case MENU_INTERPOLATION_NEAREST:
		case MENU_INTERPOLATION_LINEAR:
		case MENU_INTERPOLATION_CUBIC: {

			Animation::InterpolationType interp_mode = Animation::InterpolationType(p_index - MENU_INTERPOLATION_NEAREST);
			*block_animation_update_ptr = true;
			undo_redo->create_action("Change animation interpolation mode");
			undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_type", track, interp_mode);
			undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_type", track, animation->track_get_interpolation_type(track));
			undo_redo->commit_action();
			*block_animation_update_ptr = false;
			update();
		} break;
		case MENU_LOOP_WRAP:
		case MENU_LOOP_CLAMP: {

			bool loop_wrap = p_index == MENU_LOOP_WRAP;
			*block_animation_update_ptr = true;
			undo_redo->create_action("Change animation loop mode");
			undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_loop_wrap", track, loop_wrap);
			undo_redo->add_undo_method(animation.ptr(), "track_set_interpolation_loop_wrap", track, animation->track_get_interpolation_loop_wrap(track));
			undo_redo->commit_action();
			*block_animation_update_ptr = false;
			update();

		} break;
		case MENU_KEY_INSERT: {
			emit_signal("insert_key", insert_at_pos);
		} break;
		case MENU_KEY_DUPLICATE: {
			emit_signal("duplicate_request");

		} break;
		case MENU_KEY_DELETE: {
			emit_signal("delete_request");

		} break;
	}
}

void AnimationTrackEdit::set_block_animation_update_ptr(bool *p_block_ptr) {
	block_animation_update_ptr = p_block_ptr;
}

void AnimationTrackEdit::cancel_drop() {
	if (dropping_at != 0) {
		dropping_at = 0;
		update();
	}
}
void AnimationTrackEdit::set_in_group(bool p_enable) {
	in_group = p_enable;
	update();
}

void AnimationTrackEdit::append_to_selection(const Rect2 &p_box) {

	Rect2 select_rect(timeline->get_name_limit(), 0, get_size().width - timeline->get_name_limit() - timeline->get_buttons_width(), get_size().height);
	select_rect = select_rect.clip(p_box);

	for (int i = animation->track_get_key_count(track) - 1; i >= 0; i--) { //select should happen in the opposite order of drawing for more accurate overlap select

		Rect2 rect = const_cast<AnimationTrackEdit *>(this)->get_key_rect(i, timeline->get_zoom_scale());
		float offset = animation->track_get_key_time(track, i) - timeline->get_value();
		offset = offset * timeline->get_zoom_scale() + timeline->get_name_limit();
		rect.position.x += offset;

		if (select_rect.intersects(rect)) {
			emit_signal("select_key", i, false);
		}
	}
}

void AnimationTrackEdit::_bind_methods() {

	ClassDB::bind_method("_zoom_changed", &AnimationTrackEdit::_zoom_changed);
	ClassDB::bind_method("_menu_selected", &AnimationTrackEdit::_menu_selected);
	ClassDB::bind_method("_gui_input", &AnimationTrackEdit::_gui_input);
	ClassDB::bind_method("_path_entered", &AnimationTrackEdit::_path_entered);
	ClassDB::bind_method("_play_position_draw", &AnimationTrackEdit::_play_position_draw);

	ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
	ADD_SIGNAL(MethodInfo("remove_request", PropertyInfo(Variant::INT, "track")));
	ADD_SIGNAL(MethodInfo("dropped", PropertyInfo(Variant::INT, "from_track"), PropertyInfo(Variant::INT, "to_track")));
	ADD_SIGNAL(MethodInfo("insert_key", PropertyInfo(Variant::REAL, "ofs")));
	ADD_SIGNAL(MethodInfo("select_key", PropertyInfo(Variant::INT, "index"), PropertyInfo(Variant::BOOL, "single")));
	ADD_SIGNAL(MethodInfo("deselect_key", PropertyInfo(Variant::INT, "index")));
	ADD_SIGNAL(MethodInfo("clear_selection"));
	ADD_SIGNAL(MethodInfo("bezier_edit"));

	ADD_SIGNAL(MethodInfo("move_selection_begin"));
	ADD_SIGNAL(MethodInfo("move_selection", PropertyInfo(Variant::REAL, "ofs")));
	ADD_SIGNAL(MethodInfo("move_selection_commit"));
	ADD_SIGNAL(MethodInfo("move_selection_cancel"));

	ADD_SIGNAL(MethodInfo("duplicate_request"));
	ADD_SIGNAL(MethodInfo("duplicate_transpose_request"));
	ADD_SIGNAL(MethodInfo("delete_request"));
}

AnimationTrackEdit::AnimationTrackEdit() {
	undo_redo = NULL;
	timeline = NULL;
	root = NULL;
	path = NULL;
	menu = NULL;
	block_animation_update_ptr = NULL;
	clicking_on_name = false;
	dropping_at = 0;

	in_group = false;

	moving_selection_attempt = false;
	moving_selection = false;
	select_single_attempt = -1;

	play_position_pos = 0;
	play_position = memnew(Control);
	play_position->set_mouse_filter(MOUSE_FILTER_PASS);
	add_child(play_position);
	play_position->set_anchors_and_margins_preset(PRESET_WIDE);
	play_position->connect("draw", this, "_play_position_draw");
	set_focus_mode(FOCUS_CLICK);
	set_mouse_filter(MOUSE_FILTER_PASS); //scroll has to work too for selection
}

//////////////////////////////////////

AnimationTrackEdit *AnimationTrackEditPlugin::create_value_track_edit(Object *p_object, Variant::Type p_type, const String &p_property, PropertyHint p_hint, const String &p_hint_string, int p_usage) {
	if (get_script_instance()) {
		Variant args[6] = {
			p_object,
			p_type,
			p_property,
			p_hint,
			p_hint_string,
			p_usage
		};

		Variant *argptrs[6] = {
			&args[0],
			&args[1],
			&args[2],
			&args[3],
			&args[4],
			&args[5]
		};

		Variant::CallError ce;
		return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_value_track_edit", (const Variant **)&argptrs, 6, ce).operator Object *());
	}
	return NULL;
}

AnimationTrackEdit *AnimationTrackEditPlugin::create_audio_track_edit() {

	if (get_script_instance()) {
		return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_audio_track_edit").operator Object *());
	}
	return NULL;
}

AnimationTrackEdit *AnimationTrackEditPlugin::create_animation_track_edit(Object *p_object) {
	if (get_script_instance()) {
		return Object::cast_to<AnimationTrackEdit>(get_script_instance()->call("create_animation_track_edit", p_object).operator Object *());
	}
	return NULL;
}

///////////////////////////////////////

void AnimationTrackEditGroup::_notification(int p_what) {

	if (p_what == NOTIFICATION_DRAW) {
		Ref<Font> font = get_font("font", "Label");
		int separation = get_constant("hseparation", "ItemList");
		Color color = get_color("font_color", "Label");

		if (root && root->has_node(node)) {
			Node *n = root->get_node(node);
			if (n && EditorNode::get_singleton()->get_editor_selection()->is_selected(n)) {
				color = get_color("accent_color", "Editor");
			}
		}

		Color bgcol = get_color("dark_color_2", "Editor");
		bgcol.a *= 0.6;
		draw_rect(Rect2(Point2(), get_size()), bgcol);
		Color linecolor = color;
		linecolor.a = 0.2;

		draw_line(Point2(), Point2(get_size().width, 0), linecolor);
		draw_line(Point2(timeline->get_name_limit(), 0), Point2(timeline->get_name_limit(), get_size().height), linecolor);
		draw_line(Point2(get_size().width - timeline->get_buttons_width(), 0), Point2(get_size().width - timeline->get_buttons_width(), get_size().height), linecolor);

		int ofs = 0;
		draw_texture(icon, Point2(ofs, int(get_size().height - icon->get_height()) / 2));
		ofs += separation + icon->get_width();
		draw_string(font, Point2(ofs, int(get_size().height - font->get_height()) / 2 + font->get_ascent()), node_name, color, timeline->get_name_limit() - ofs);

		int px = (-timeline->get_value() + timeline->get_play_position()) * timeline->get_zoom_scale() + timeline->get_name_limit();

		if (px >= timeline->get_name_limit() && px < (get_size().width - timeline->get_buttons_width())) {
			Color accent = get_color("accent_color", "Editor");
			draw_line(Point2(px, 0), Point2(px, get_size().height), accent);
		}
	}
}

void AnimationTrackEditGroup::set_type_and_name(const Ref<Texture> &p_type, const String &p_name, const NodePath &p_node) {
	icon = p_type;
	node_name = p_name;
	node = p_node;
	update();
	minimum_size_changed();
}

Size2 AnimationTrackEditGroup::get_minimum_size() const {

	Ref<Font> font = get_font("font", "Label");
	int separation = get_constant("vseparation", "ItemList");

	return Vector2(0, MAX(font->get_height(), icon->get_height()) + separation);
}

void AnimationTrackEditGroup::set_timeline(AnimationTimelineEdit *p_timeline) {
	timeline = p_timeline;
	timeline->connect("zoom_changed", this, "_zoom_changed");
	timeline->connect("name_limit_changed", this, "_zoom_changed");
}

void AnimationTrackEditGroup::set_root(Node *p_root) {
	root = p_root;
	update();
}

void AnimationTrackEditGroup::_zoom_changed() {
	update();
}

void AnimationTrackEditGroup::_bind_methods() {
	ClassDB::bind_method("_zoom_changed", &AnimationTrackEditGroup::_zoom_changed);
}

AnimationTrackEditGroup::AnimationTrackEditGroup() {
	set_mouse_filter(MOUSE_FILTER_PASS);
}

//////////////////////////////////////

void AnimationTrackEditor::add_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) {

	if (track_edit_plugins.find(p_plugin) != -1)
		return;
	track_edit_plugins.push_back(p_plugin);
}

void AnimationTrackEditor::remove_track_edit_plugin(const Ref<AnimationTrackEditPlugin> &p_plugin) {

	track_edit_plugins.erase(p_plugin);
}

void AnimationTrackEditor::set_animation(const Ref<Animation> &p_anim) {

	if (animation != p_anim && _get_track_selected() >= 0) {
		track_edits[_get_track_selected()]->release_focus();
	}
	if (animation.is_valid()) {
		animation->disconnect("changed", this, "_animation_changed");
		_clear_selection();
	}
	animation = p_anim;
	timeline->set_animation(p_anim);

	_cancel_bezier_edit();
	_update_tracks();

	if (animation.is_valid()) {
		animation->connect("changed", this, "_animation_changed");

		hscroll->show();
		edit->set_disabled(false);
		step->set_block_signals(true);
		step->set_value(animation->get_step());
		step->set_block_signals(false);
		step->set_read_only(false);
		snap->set_disabled(false);
	} else {
		hscroll->hide();
		edit->set_disabled(true);
		step->set_block_signals(true);
		step->set_value(0);
		step->set_block_signals(false);
		step->set_read_only(true);
		snap->set_disabled(true);
	}
}

Ref<Animation> AnimationTrackEditor::get_current_animation() const {

	return animation;
}
void AnimationTrackEditor::_root_removed(Node *p_root) {
	root = NULL;
}

void AnimationTrackEditor::set_root(Node *p_root) {
	if (root) {
		root->disconnect("tree_exiting", this, "_root_removed");
	}

	root = p_root;

	if (root) {
		root->connect("tree_exiting", this, "_root_removed", make_binds(), CONNECT_ONESHOT);
	}

	_update_tracks();
}

Node *AnimationTrackEditor::get_root() const {

	return root;
}

void AnimationTrackEditor::update_keying() {
	bool keying_enabled = is_visible_in_tree() && animation.is_valid();

	if (keying_enabled == keying)
		return;

	keying = keying_enabled;
	//_update_menu();
	emit_signal("keying_changed");
}

bool AnimationTrackEditor::has_keying() const {
	return keying;
}

void AnimationTrackEditor::cleanup() {
	set_animation(Ref<Animation>());
}

void AnimationTrackEditor::_name_limit_changed() {

	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}
}

void AnimationTrackEditor::_timeline_changed(float p_new_pos, bool p_drag) {

	emit_signal("timeline_changed", p_new_pos, p_drag);
}

void AnimationTrackEditor::_track_remove_request(int p_track) {

	int idx = p_track;
	if (idx >= 0 && idx < animation->get_track_count()) {
		_clear_selection();
		undo_redo->create_action(TTR("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++) {

			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);
		}

		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_update_mode", idx, animation->value_track_get_update_mode(idx));
		}

		undo_redo->commit_action();
	}
}

void AnimationTrackEditor::set_anim_pos(float p_pos) {

	timeline->set_play_position(p_pos);
	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->set_play_position(p_pos);
	}
	for (int i = 0; i < groups.size(); i++) {
		groups[i]->update();
	}
	bezier_edit->set_play_position(p_pos);
}

void AnimationTrackEditor::_query_insert(const InsertData &p_id) {

	if (insert_frame != Engine::get_singleton()->get_frames_drawn()) {
		//clear insert list for the frame if frame changed
		if (insert_confirm->is_visible_in_tree())
			return; //do nothing
		insert_data.clear();
		insert_query = false;
	}
	insert_frame = Engine::get_singleton()->get_frames_drawn();

	for (List<InsertData>::Element *E = insert_data.front(); E; E = E->next()) {
		//prevent insertion of multiple tracks
		if (E->get().path == p_id.path)
			return; //already inserted a track for this on this frame
	}

	insert_data.push_back(p_id);

	if (p_id.track_idx == -1) {
		if (bool(EDITOR_DEF("editors/animation/confirm_insert_track", true))) {
			//potential new key, does not exist
			if (insert_data.size() == 1)
				insert_confirm_text->set_text(vformat(TTR("Create NEW track for %s and insert key?"), p_id.query));
			else
				insert_confirm_text->set_text(vformat(TTR("Create %d NEW tracks and insert keys?"), insert_data.size()));

			bool all_bezier = true;
			for (int i = 0; i < insert_data.size(); i++) {
				if (insert_data[i].type != Animation::TYPE_VALUE && insert_data[i].type != Animation::TYPE_BEZIER) {
					all_bezier = false;
				}

				if (insert_data[i].type != Animation::TYPE_VALUE) {
					continue;
				}
				switch (insert_data[i].value.get_type()) {
					case Variant::INT:
					case Variant::REAL:
					case Variant::VECTOR2:
					case Variant::VECTOR3:
					case Variant::QUAT:
					case Variant::PLANE:
					case Variant::COLOR: {
						//good
					} break;
					default: {
						all_bezier = false;
					}
				}
			}

			insert_confirm_bezier->set_visible(all_bezier);
			insert_confirm->get_ok()->set_text(TTR("Create"));
			insert_confirm->popup_centered_minsize();
			insert_query = true;
		} else {
			call_deferred("_insert_delay");
			insert_queue = true;
		}

	} else {
		if (!insert_query && !insert_queue) {
			call_deferred("_insert_delay");
			insert_queue = true;
		}
	}
}

void AnimationTrackEditor::_insert_delay() {

	if (insert_query) {
		//discard since it's entered into query mode
		insert_queue = false;
		return;
	}

	undo_redo->create_action(TTR("Anim Insert"));

	int last_track = animation->get_track_count();
	bool advance = false;
	while (insert_data.size()) {

		if (insert_data.front()->get().advance)
			advance = true;
		last_track = _confirm_insert(insert_data.front()->get(), last_track);
		insert_data.pop_front();
	}

	undo_redo->commit_action();

	if (advance) {
		float step = animation->get_step();
		if (step == 0)
			step = 1;

		float pos = timeline->get_play_position();

		pos = Math::stepify(pos + step, step);
		if (pos > animation->get_length())
			pos = animation->get_length();
		set_anim_pos(pos);
		emit_signal("timeline_changed", pos, true);
	}
	insert_queue = false;
}

void AnimationTrackEditor::insert_transform_key(Spatial *p_node, const String &p_sub, const Transform &p_xform) {

	if (!keying)
		return;
	if (!animation.is_valid())
		return;

	ERR_FAIL_COND(!root);
	//let's build a node path
	String path = root->get_path_to(p_node);
	if (p_sub != "")
		path += ":" + p_sub;

	NodePath np = path;

	int track_idx = -1;

	for (int i = 0; i < animation->get_track_count(); i++) {

		if (animation->track_get_type(i) != Animation::TYPE_TRANSFORM)
			continue;
		if (animation->track_get_path(i) != np)
			continue;

		track_idx = i;
		break;
	}

	InsertData id;
	Dictionary val;

	id.path = np;
	id.track_idx = track_idx;
	id.value = p_xform;
	id.type = Animation::TYPE_TRANSFORM;
	id.query = "node '" + p_node->get_name() + "'";
	id.advance = false;

	//dialog insert

	_query_insert(id);
}

void AnimationTrackEditor::_insert_animation_key(NodePath p_path, const Variant &p_value) {

	String path = p_path;

	//animation property is a special case, always creates an animation track
	for (int i = 0; i < animation->get_track_count(); i++) {

		String np = animation->track_get_path(i);

		if (path == np && animation->track_get_type(i) == Animation::TYPE_ANIMATION) {
			//exists
			InsertData id;
			id.path = path;
			id.track_idx = i;
			id.value = p_value;
			id.type = Animation::TYPE_ANIMATION;
			id.query = "animation";
			id.advance = false;
			//dialog insert
			_query_insert(id);
			return;
		}
	}

	InsertData id;
	id.path = path;
	id.track_idx = -1;
	id.value = p_value;
	id.type = Animation::TYPE_ANIMATION;
	id.query = "animation";
	id.advance = false;
	//dialog insert
	_query_insert(id);
}

void AnimationTrackEditor::insert_node_value_key(Node *p_node, const String &p_property, const Variant &p_value, bool p_only_if_exists) {

	ERR_FAIL_COND(!root);
	//let's build a node path

	Node *node = p_node;

	String path = root->get_path_to(node);

	if (Object::cast_to<AnimationPlayer>(node) && p_property == "current_animation") {
		if (node == AnimationPlayerEditor::singleton->get_player()) {
			EditorNode::get_singleton()->show_warning(TTR("AnimationPlayer can't animate itself, only other players."));
			return;
		}
		_insert_animation_key(path, p_value);
		return;
	}

	EditorHistory *history = EditorNode::get_singleton()->get_editor_history();
	for (int i = 1; i < history->get_path_size(); i++) {

		String prop = history->get_path_property(i);
		ERR_FAIL_COND(prop == "");
		path += ":" + prop;
	}

	path += ":" + p_property;

	NodePath np = path;

	//locate track

	bool inserted = false;

	for (int i = 0; i < animation->get_track_count(); i++) {

		if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
			if (animation->track_get_path(i) != np)
				continue;

			InsertData id;
			id.path = np;
			id.track_idx = i;
			id.value = p_value;
			id.type = Animation::TYPE_VALUE;
			id.query = "property '" + p_property + "'";
			id.advance = false;
			//dialog insert
			_query_insert(id);
			inserted = true;
		} else if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {

			Variant value;
			if (animation->track_get_path(i) == np) {
				value = p_value; //all good
			} else {
				String tpath = animation->track_get_path(i);
				if (NodePath(tpath.get_basename()) == np) {
					String subindex = tpath.get_extension();
					value = p_value.get(subindex);
				} else {
					continue;
				}
			}

			InsertData id;
			id.path = animation->track_get_path(i);
			id.track_idx = i;
			id.value = value;
			id.type = Animation::TYPE_BEZIER;
			id.query = "property '" + p_property + "'";
			id.advance = false;
			//dialog insert
			_query_insert(id);
			inserted = true;
		}
	}

	if (inserted || p_only_if_exists)
		return;
	InsertData id;
	id.path = np;
	id.track_idx = -1;
	id.value = p_value;
	id.type = Animation::TYPE_VALUE;
	id.query = "property '" + p_property + "'";
	id.advance = false;
	//dialog insert
	_query_insert(id);
}

void AnimationTrackEditor::insert_value_key(const String &p_property, const Variant &p_value, bool p_advance) {

	EditorHistory *history = EditorNode::get_singleton()->get_editor_history();

	ERR_FAIL_COND(!root);
	//let's build a node path
	ERR_FAIL_COND(history->get_path_size() == 0);
	Object *obj = ObjectDB::get_instance(history->get_path_object(0));
	ERR_FAIL_COND(!Object::cast_to<Node>(obj));

	Node *node = Object::cast_to<Node>(obj);

	String path = root->get_path_to(node);

	if (Object::cast_to<AnimationPlayer>(node) && p_property == "current_animation") {
		if (node == AnimationPlayerEditor::singleton->get_player()) {
			EditorNode::get_singleton()->show_warning(TTR("AnimationPlayer can't animate itself, only other players."));
			return;
		}
		_insert_animation_key(path, p_value);
		return;
	}

	for (int i = 1; i < history->get_path_size(); i++) {

		String prop = history->get_path_property(i);
		ERR_FAIL_COND(prop == "");
		path += ":" + prop;
	}

	path += ":" + p_property;

	NodePath np = path;

	//locate track

	bool inserted = false;

	for (int i = 0; i < animation->get_track_count(); i++) {

		if (animation->track_get_type(i) == Animation::TYPE_VALUE) {
			if (animation->track_get_path(i) != np)
				continue;

			InsertData id;
			id.path = np;
			id.track_idx = i;
			id.value = p_value;
			id.type = Animation::TYPE_VALUE;
			id.query = "property '" + p_property + "'";
			id.advance = p_advance;
			//dialog insert
			_query_insert(id);
			inserted = true;
		} else if (animation->track_get_type(i) == Animation::TYPE_BEZIER) {

			Variant value;
			if (animation->track_get_path(i) == np) {
				value = p_value; //all good
			} else {
				String tpath = animation->track_get_path(i);
				if (NodePath(tpath.get_basename()) == np) {
					String subindex = tpath.get_extension();
					value = p_value.get(subindex);
				} else {
					continue;
				}
			}

			InsertData id;
			id.path = animation->track_get_path(i);
			id.track_idx = i;
			id.value = value;
			id.type = Animation::TYPE_BEZIER;
			id.query = "property '" + p_property + "'";
			id.advance = p_advance;
			//dialog insert
			_query_insert(id);
			inserted = true;
		}
	}

	if (!inserted) {
		InsertData id;
		id.path = np;
		id.track_idx = -1;
		id.value = p_value;
		id.type = Animation::TYPE_VALUE;
		id.query = "property '" + p_property + "'";
		id.advance = p_advance;
		//dialog insert
		_query_insert(id);
	}
}

void AnimationTrackEditor::_confirm_insert_list() {

	undo_redo->create_action(TTR("Anim Create & Insert"));

	int last_track = animation->get_track_count();
	while (insert_data.size()) {

		last_track = _confirm_insert(insert_data.front()->get(), last_track, insert_confirm_bezier->is_pressed());
		insert_data.pop_front();
	}

	undo_redo->commit_action();
}

PropertyInfo AnimationTrackEditor::_find_hint_for_track(int p_idx, NodePath &r_base_path, Variant *r_current_val) {

	r_base_path = NodePath();
	ERR_FAIL_COND_V(!animation.is_valid(), PropertyInfo());
	ERR_FAIL_INDEX_V(p_idx, animation->get_track_count(), PropertyInfo());

	if (!root) {
		return PropertyInfo();
	}

	NodePath path = animation->track_get_path(p_idx);

	if (!root->has_node_and_resource(path)) {
		return PropertyInfo();
	}

	RES res;
	Vector<StringName> leftover_path;
	Node *node = root->get_node_and_resource(path, res, leftover_path, true);

	if (node) {
		r_base_path = node->get_path();
	}

	if (leftover_path.empty()) {
		if (r_current_val) {
			if (res.is_valid()) {
				*r_current_val = res;
			} else if (node) {
				*r_current_val = node;
			}
		}
		return PropertyInfo();
	}

	Variant property_info_base;
	if (res.is_valid()) {
		property_info_base = res;
		if (r_current_val) {
			*r_current_val = res->get_indexed(leftover_path);
		}
	} else if (node) {
		property_info_base = node;
		if (r_current_val) {
			*r_current_val = node->get_indexed(leftover_path);
		}
	}

	for (int i = 0; i < leftover_path.size() - 1; i++) {
		property_info_base = property_info_base.get_named(leftover_path[i]);
	}

	List<PropertyInfo> pinfo;
	property_info_base.get_property_list(&pinfo);

	for (List<PropertyInfo>::Element *E = pinfo.front(); E; E = E->next()) {

		if (E->get().name == leftover_path[leftover_path.size() - 1]) {
			return E->get();
		}
	}

	return PropertyInfo();
}

static Vector<String> _get_bezier_subindices_for_type(Variant::Type p_type, bool *r_valid = NULL) {
	Vector<String> subindices;
	if (r_valid) {
		*r_valid = true;
	}
	switch (p_type) {
		case Variant::INT: {
			subindices.push_back("");
		} break;
		case Variant::REAL: {
			subindices.push_back("");
		} break;
		case Variant::VECTOR2: {
			subindices.push_back(":x");
			subindices.push_back(":y");
		} break;
		case Variant::VECTOR3: {
			subindices.push_back(":x");
			subindices.push_back(":y");
			subindices.push_back(":z");
		} break;
		case Variant::QUAT: {
			subindices.push_back(":x");
			subindices.push_back(":y");
			subindices.push_back(":z");
			subindices.push_back(":w");
		} break;
		case Variant::COLOR: {
			subindices.push_back(":r");
			subindices.push_back(":g");
			subindices.push_back(":b");
			subindices.push_back(":a");
		} break;
		case Variant::PLANE: {
			subindices.push_back(":x");
			subindices.push_back(":y");
			subindices.push_back(":z");
			subindices.push_back(":d");
		} break;
		default: {
			if (r_valid) {
				*r_valid = false;
			}
		}
	}

	return subindices;
}

int AnimationTrackEditor::_confirm_insert(InsertData p_id, int p_last_track, bool p_create_beziers) {

	if (p_last_track == -1)
		p_last_track = animation->get_track_count();

	bool created = false;
	if (p_id.track_idx < 0) {

		if (p_create_beziers && (p_id.value.get_type() == Variant::VECTOR2 ||
										p_id.value.get_type() == Variant::VECTOR3 ||
										p_id.value.get_type() == Variant::QUAT ||
										p_id.value.get_type() == Variant::COLOR ||
										p_id.value.get_type() == Variant::PLANE)) {

			Vector<String> subindices = _get_bezier_subindices_for_type(p_id.value.get_type());

			for (int i = 0; i < subindices.size(); i++) {
				InsertData id = p_id;
				id.type = Animation::TYPE_BEZIER;
				id.value = p_id.value.get(subindices[i].substr(1, subindices[i].length()));
				id.path = String(p_id.path) + subindices[i];
				_confirm_insert(id, p_last_track + i);
			}

			return p_last_track + subindices.size() - 1;
		}
		created = true;
		undo_redo->create_action(TTR("Anim Insert Track & Key"));
		Animation::UpdateMode update_mode = Animation::UPDATE_DISCRETE;

		if (p_id.type == Animation::TYPE_VALUE || p_id.type == Animation::TYPE_BEZIER) {
			//wants a new tack

			{
				//hack
				NodePath np;
				animation->add_track(p_id.type);
				animation->track_set_path(animation->get_track_count() - 1, p_id.path);
				PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
				animation->remove_track(animation->get_track_count() - 1); //hack

				if (h.type == Variant::REAL ||
						h.type == Variant::VECTOR2 ||
						h.type == Variant::RECT2 ||
						h.type == Variant::VECTOR3 ||
						h.type == Variant::AABB ||
						h.type == Variant::QUAT ||
						h.type == Variant::COLOR ||
						h.type == Variant::PLANE ||
						h.type == Variant::TRANSFORM2D ||
						h.type == Variant::TRANSFORM) {

					update_mode = Animation::UPDATE_CONTINUOUS;
				}

				if (h.usage & PROPERTY_USAGE_ANIMATE_AS_TRIGGER) {
					update_mode = Animation::UPDATE_TRIGGER;
				}
			}
		}

		p_id.track_idx = p_last_track;

		undo_redo->add_do_method(animation.ptr(), "add_track", p_id.type);
		undo_redo->add_do_method(animation.ptr(), "track_set_path", p_id.track_idx, p_id.path);
		if (p_id.type == Animation::TYPE_VALUE)
			undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", p_id.track_idx, update_mode);

	} else {
		undo_redo->create_action(TTR("Anim Insert Key"));
	}

	float time = timeline->get_play_position();
	Variant value;

	switch (p_id.type) {

		case Animation::TYPE_VALUE: {

			value = p_id.value;

		} break;
		case Animation::TYPE_TRANSFORM: {

			Transform tr = p_id.value;
			Dictionary d;
			d["location"] = tr.origin;
			d["scale"] = tr.basis.get_scale();
			d["rotation"] = Quat(tr.basis); //.orthonormalized();
			value = d;
		} break;
		case Animation::TYPE_BEZIER: {
			Array array;
			array.resize(5);
			array[0] = p_id.value;
			array[1] = -0.25;
			array[2] = 0;
			array[3] = 0.25;
			array[4] = 0;
			value = array;

		} break;
		case Animation::TYPE_ANIMATION: {
			value = p_id.value;
		} break;
		default: {
		}
	}

	undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_id.track_idx, time, value);

	if (created) {

		//just remove the track
		undo_redo->add_undo_method(animation.ptr(), "remove_track", p_last_track);
		p_last_track++;
	} else {

		undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_id.track_idx, time);
		int existing = animation->track_find_key(p_id.track_idx, time, true);
		if (existing != -1) {
			Variant v = animation->track_get_key_value(p_id.track_idx, existing);
			float trans = animation->track_get_key_transition(p_id.track_idx, existing);
			undo_redo->add_undo_method(animation.ptr(), "track_insert_key", p_id.track_idx, time, v, trans);
		}
	}

	undo_redo->commit_action();

	return p_last_track;
}

void AnimationTrackEditor::show_select_node_warning(bool p_show) {
}

bool AnimationTrackEditor::is_key_selected(int p_track, int p_key) const {

	SelectedKey sk;
	sk.key = p_key;
	sk.track = p_track;

	return selection.has(sk);
}

bool AnimationTrackEditor::is_selection_active() const {
	return selection.size();
}

void AnimationTrackEditor::_update_tracks() {

	int selected = _get_track_selected();

	while (track_vbox->get_child_count()) {
		memdelete(track_vbox->get_child(0));
	}

	track_edits.clear();
	groups.clear();

	if (animation.is_null())
		return;

	Map<String, VBoxContainer *> group_sort;

	bool use_grouping = !view_group->is_pressed();
	bool use_filter = selected_filter->is_pressed();

	for (int i = 0; i < animation->get_track_count(); i++) {
		AnimationTrackEdit *track_edit = NULL;

		//find hint and info for plugin

		if (use_filter) {
			NodePath path = animation->track_get_path(i);

			if (root && root->has_node(path)) {
				Node *node = root->get_node(path);
				if (!node) {
					continue; // no node, no filter
				}
				if (!EditorNode::get_singleton()->get_editor_selection()->is_selected(node)) {
					continue; //skip track due to not selected
				}
			}
		}

		if (animation->track_get_type(i) == Animation::TYPE_VALUE) {

			NodePath path = animation->track_get_path(i);

			if (root && root->has_node_and_resource(path)) {
				RES res;
				NodePath base_path;
				Vector<StringName> leftover_path;
				Node *node = root->get_node_and_resource(path, res, leftover_path, true);
				PropertyInfo pinfo = _find_hint_for_track(i, base_path);

				Object *object = node;
				if (res.is_valid()) {
					object = res.ptr();
				}

				if (object && !leftover_path.empty()) {
					if (pinfo.name.empty()) {
						pinfo.name = leftover_path[leftover_path.size() - 1];
					}

					for (int j = 0; j < track_edit_plugins.size(); j++) {
						track_edit = track_edit_plugins.write[j]->create_value_track_edit(object, pinfo.type, pinfo.name, pinfo.hint, pinfo.hint_string, pinfo.usage);
						if (track_edit) {
							break;
						}
					}
				}
			}
		}
		if (animation->track_get_type(i) == Animation::TYPE_AUDIO) {

			for (int j = 0; j < track_edit_plugins.size(); j++) {
				track_edit = track_edit_plugins.write[j]->create_audio_track_edit();
				if (track_edit) {
					break;
				}
			}
		}

		if (animation->track_get_type(i) == Animation::TYPE_ANIMATION) {
			NodePath path = animation->track_get_path(i);

			Node *node = NULL;
			if (root && root->has_node(path)) {
				node = root->get_node(path);
			}

			if (node && Object::cast_to<AnimationPlayer>(node)) {
				for (int j = 0; j < track_edit_plugins.size(); j++) {
					track_edit = track_edit_plugins.write[j]->create_animation_track_edit(node);
					if (track_edit) {
						break;
					}
				}
			}
		}

		if (track_edit == NULL) {
			//no valid plugin_found
			track_edit = memnew(AnimationTrackEdit);
		}

		track_edits.push_back(track_edit);

		if (use_grouping) {
			String base_path = animation->track_get_path(i);
			base_path = base_path.get_slice(":", 0); // remove subpath

			if (!group_sort.has(base_path)) {
				AnimationTrackEditGroup *g = memnew(AnimationTrackEditGroup);
				Ref<Texture> icon = get_icon("Node", "EditorIcons");
				String name = base_path;
				String tooltip;
				if (root) {
					Node *n = root->get_node(base_path);
					if (n) {
						if (has_icon(n->get_class(), "EditorIcons")) {
							icon = get_icon(n->get_class(), "EditorIcons");
						}
						name = n->get_name();
						tooltip = root->get_path_to(n);
					}
				}

				g->set_type_and_name(icon, name, animation->track_get_path(i));
				g->set_root(root);
				g->set_tooltip(tooltip);
				g->set_timeline(timeline);
				groups.push_back(g);
				VBoxContainer *vb = memnew(VBoxContainer);
				vb->add_constant_override("separation", 0);
				vb->add_child(g);
				track_vbox->add_child(vb);
				group_sort[base_path] = vb;
			}

			track_edit->set_in_group(true);
			group_sort[base_path]->add_child(track_edit);

		} else {
			track_edit->set_in_group(false);
			track_vbox->add_child(track_edit);
		}

		track_edit->set_undo_redo(undo_redo);
		track_edit->set_timeline(timeline);
		track_edit->set_block_animation_update_ptr(&block_animation_update);
		track_edit->set_root(root);
		track_edit->set_animation_and_track(animation, i);
		track_edit->set_play_position(timeline->get_play_position());
		track_edit->set_editor(this);

		if (selected == i) {
			track_edit->grab_focus();
		}

		track_edit->connect("timeline_changed", this, "_timeline_changed");
		track_edit->connect("remove_request", this, "_track_remove_request", varray(), CONNECT_DEFERRED);
		track_edit->connect("dropped", this, "_dropped_track", varray(), CONNECT_DEFERRED);
		track_edit->connect("insert_key", this, "_insert_key_from_track", varray(i), CONNECT_DEFERRED);
		track_edit->connect("select_key", this, "_key_selected", varray(i), CONNECT_DEFERRED);
		track_edit->connect("deselect_key", this, "_key_deselected", varray(i), CONNECT_DEFERRED);
		track_edit->connect("bezier_edit", this, "_bezier_edit", varray(i), CONNECT_DEFERRED);
		track_edit->connect("clear_selection", this, "_clear_selection");
		track_edit->connect("move_selection_begin", this, "_move_selection_begin");
		track_edit->connect("move_selection", this, "_move_selection");
		track_edit->connect("move_selection_commit", this, "_move_selection_commit");
		track_edit->connect("move_selection_cancel", this, "_move_selection_cancel");

		track_edit->connect("duplicate_request", this, "_edit_menu_pressed", varray(EDIT_DUPLICATE_SELECTION), CONNECT_DEFERRED);
		track_edit->connect("duplicate_transpose_request", this, "_edit_menu_pressed", varray(EDIT_DUPLICATE_TRANSPOSED), CONNECT_DEFERRED);
		track_edit->connect("delete_request", this, "_edit_menu_pressed", varray(EDIT_DELETE_SELECTION), CONNECT_DEFERRED);
	}
}

void AnimationTrackEditor::_animation_changed() {

	if (key_edit && key_edit->setting) {
		//if editing a key, just update the edited track, makes refresh less costly
		if (key_edit->track < track_edits.size()) {
			track_edits[key_edit->track]->update();
		}
		return;
	}

	timeline->update();
	timeline->update_values();
	if (block_animation_update) {
		for (int i = 0; i < track_edits.size(); i++) {
			track_edits[i]->update();
		}
		for (int i = 0; i < groups.size(); i++) {
			groups[i]->update();
		}
	} else {
		_update_tracks();
	}

	bezier_edit->update();

	step->set_block_signals(true);
	step->set_value(animation->get_step());
	step->set_block_signals(false);
}

MenuButton *AnimationTrackEditor::get_edit_menu() {
	return edit;
}

void AnimationTrackEditor::_notification(int p_what) {
	if (p_what == NOTIFICATION_THEME_CHANGED || p_what == NOTIFICATION_ENTER_TREE) {
		zoom_icon->set_texture(get_icon("Zoom", "EditorIcons"));
		snap->set_icon(get_icon("Snap", "EditorIcons"));
		view_group->set_icon(get_icon(view_group->is_pressed() ? "AnimationTrackList" : "AnimationTrackGroup", "EditorIcons"));
		selected_filter->set_icon(get_icon("AnimationFilter", "EditorIcons"));
		main_panel->add_style_override("panel", get_stylebox("bg", "Tree"));
	}

	if (p_what == NOTIFICATION_READY) {
		EditorNode::get_singleton()->get_editor_selection()->connect("selection_changed", this, "_selection_changed");
	}

	if (p_what == NOTIFICATION_VISIBILITY_CHANGED) {
		update_keying();
		EditorNode::get_singleton()->update_keying();
		emit_signal("keying_changed");
	}
}

void AnimationTrackEditor::_update_scroll(double) {
	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}
	for (int i = 0; i < groups.size(); i++) {
		groups[i]->update();
	}
}

void AnimationTrackEditor::_update_step(double p_new_step) {

	undo_redo->create_action("Change animation step");
	undo_redo->add_do_method(animation.ptr(), "set_step", p_new_step);
	undo_redo->add_undo_method(animation.ptr(), "set_step", animation->get_step());
	step->set_block_signals(true);
	undo_redo->commit_action();
	step->set_block_signals(false);
	emit_signal("animation_step_changed", p_new_step);
}

void AnimationTrackEditor::_update_length(double p_new_len) {

	emit_signal("animation_len_changed", p_new_len);
}

void AnimationTrackEditor::_dropped_track(int p_from_track, int p_to_track) {
	if (p_to_track >= track_edits.size()) {
		p_to_track = track_edits.size() - 1;
	}

	if (p_from_track == p_to_track)
		return;

	_clear_selection();
	undo_redo->create_action("Rearrange tracks");
	undo_redo->add_do_method(animation.ptr(), "track_swap", p_from_track, p_to_track);
	undo_redo->add_undo_method(animation.ptr(), "track_swap", p_to_track, p_from_track);
	undo_redo->commit_action();
}

void AnimationTrackEditor::_new_track_node_selected(NodePath p_path) {

	ERR_FAIL_COND(!root);
	Node *node = get_node(p_path);
	ERR_FAIL_COND(!node);
	NodePath path_to = root->get_path_to(node);

	if (adding_track_type == Animation::TYPE_TRANSFORM && !node->is_class("Spatial")) {
		EditorNode::get_singleton()->show_warning(TTR("Transform tracks only apply to Spatial-based nodes."));
		return;
	}

	switch (adding_track_type) {
		case Animation::TYPE_VALUE: {
			adding_track_path = path_to;
			prop_selector->set_type_filter(Vector<Variant::Type>());
			prop_selector->select_property_from_instance(node);
		} break;
		case Animation::TYPE_TRANSFORM:
		case Animation::TYPE_METHOD: {

			undo_redo->create_action("Add Track");
			undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
			undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
			undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
			undo_redo->commit_action();

		} break;
		case Animation::TYPE_BEZIER: {

			Vector<Variant::Type> filter;
			filter.push_back(Variant::INT);
			filter.push_back(Variant::REAL);
			filter.push_back(Variant::VECTOR2);
			filter.push_back(Variant::VECTOR3);
			filter.push_back(Variant::QUAT);
			filter.push_back(Variant::PLANE);
			filter.push_back(Variant::COLOR);

			adding_track_path = path_to;
			prop_selector->set_type_filter(filter);
			prop_selector->select_property_from_instance(node);
		} break;
		case Animation::TYPE_AUDIO: {

			if (!node->is_class("AudioStreamPlayer") && !node->is_class("AudioStreamPlayer2D") && !node->is_class("AudioStreamPlayer3D")) {
				EditorNode::get_singleton()->show_warning(TTR("Audio tracks can only point to nodes of type:\n-AudioStreamPlayer\n-AudioStreamPlayer2D\n-AudioStreamPlayer3D"));
				return;
			}

			undo_redo->create_action("Add Track");
			undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
			undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
			undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
			undo_redo->commit_action();

		} break;
		case Animation::TYPE_ANIMATION: {

			if (!node->is_class("AnimationPlayer")) {
				EditorNode::get_singleton()->show_warning(TTR("Animation tracks can only point to AnimationPlayer nodes."));
				return;
			}

			if (node == AnimationPlayerEditor::singleton->get_player()) {
				EditorNode::get_singleton()->show_warning(TTR("An animation player can't animate itself, only other players."));
				return;
			}

			undo_redo->create_action("Add Track");
			undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
			undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), path_to);
			undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
			undo_redo->commit_action();

		} break;
	}
}

void AnimationTrackEditor::_add_track(int p_type) {
	if (!root) {
		EditorNode::get_singleton()->show_warning(TTR("Not possible to add a new track without a root"));
		return;
	}
	adding_track_type = p_type;
	pick_track->popup_centered_ratio();
}

void AnimationTrackEditor::_new_track_property_selected(String p_name) {

	String full_path = String(adding_track_path) + ":" + p_name;

	if (adding_track_type == Animation::TYPE_VALUE) {

		Animation::UpdateMode update_mode = Animation::UPDATE_DISCRETE;
		{
			//hack
			NodePath np;
			animation->add_track(Animation::TYPE_VALUE);
			animation->track_set_path(animation->get_track_count() - 1, full_path);
			PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
			animation->remove_track(animation->get_track_count() - 1); //hack
			if (h.type == Variant::REAL ||
					h.type == Variant::VECTOR2 ||
					h.type == Variant::RECT2 ||
					h.type == Variant::VECTOR3 ||
					h.type == Variant::AABB ||
					h.type == Variant::QUAT ||
					h.type == Variant::COLOR ||
					h.type == Variant::PLANE ||
					h.type == Variant::TRANSFORM2D ||
					h.type == Variant::TRANSFORM) {

				update_mode = Animation::UPDATE_CONTINUOUS;
			}

			if (h.usage & PROPERTY_USAGE_ANIMATE_AS_TRIGGER) {
				update_mode = Animation::UPDATE_TRIGGER;
			}
		}

		undo_redo->create_action("Add Track");
		undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
		undo_redo->add_do_method(animation.ptr(), "track_set_path", animation->get_track_count(), full_path);
		undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", animation->get_track_count(), update_mode);
		undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());
		undo_redo->commit_action();
	} else {
		Vector<String> subindices;
		{
			//hack
			NodePath np;
			animation->add_track(Animation::TYPE_VALUE);
			animation->track_set_path(animation->get_track_count() - 1, full_path);
			PropertyInfo h = _find_hint_for_track(animation->get_track_count() - 1, np);
			animation->remove_track(animation->get_track_count() - 1); //hack
			bool valid;
			subindices = _get_bezier_subindices_for_type(h.type, &valid);
			if (!valid) {
				EditorNode::get_singleton()->show_warning("Invalid track for Bezier (no suitable sub-properties)");
				return;
			}
		}

		undo_redo->create_action("Add Bezier Track");
		int base_track = animation->get_track_count();
		for (int i = 0; i < subindices.size(); i++) {
			undo_redo->add_do_method(animation.ptr(), "add_track", adding_track_type);
			undo_redo->add_do_method(animation.ptr(), "track_set_path", base_track + i, full_path + subindices[i]);
			undo_redo->add_undo_method(animation.ptr(), "remove_track", base_track + i);
		}
		undo_redo->commit_action();
	}
}

void AnimationTrackEditor::_timeline_value_changed(double) {

	timeline->update_play_position();

	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
		track_edits[i]->update_play_position();
	}

	for (int i = 0; i < groups.size(); i++) {
		groups[i]->update();
	}

	bezier_edit->update();
	bezier_edit->update_play_position();
}

int AnimationTrackEditor::_get_track_selected() {

	for (int i = 0; i < track_edits.size(); i++) {
		if (track_edits[i]->has_focus())
			return i;
	}

	return -1;
}

void AnimationTrackEditor::_insert_key_from_track(float p_ofs, int p_track) {

	ERR_FAIL_INDEX(p_track, animation->get_track_count());

	if (snap->is_pressed() && step->get_value() != 0) {
		p_ofs = Math::stepify(p_ofs, step->get_value());
	}
	while (animation->track_find_key(p_track, p_ofs, true) != -1) { //make sure insertion point is valid
		p_ofs += 0.001;
	}

	switch (animation->track_get_type(p_track)) {
		case Animation::TYPE_TRANSFORM: {
			if (!root->has_node(animation->track_get_path(p_track))) {
				EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a key."));
				return;
			}
			Spatial *base = Object::cast_to<Spatial>(root->get_node(animation->track_get_path(p_track)));

			if (!base) {
				EditorNode::get_singleton()->show_warning(TTR("Track is not of type Spatial, can't insert key"));
				return;
			}

			Transform xf = base->get_transform();

			Vector3 loc = xf.get_origin();
			Vector3 scale = xf.basis.get_scale_local();
			Quat rot = xf.basis;

			undo_redo->create_action("Add Transform Track Key");
			undo_redo->add_do_method(animation.ptr(), "transform_track_insert_key", p_track, p_ofs, loc, rot, scale);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
			undo_redo->commit_action();

		} break;
		case Animation::TYPE_VALUE: {

			NodePath bp;
			Variant value;
			_find_hint_for_track(p_track, bp, &value);

			undo_redo->create_action("Add Track Key");
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, value);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
			undo_redo->commit_action();

		} break;
		case Animation::TYPE_METHOD: {
			if (!root->has_node(animation->track_get_path(p_track))) {
				EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a method key."));
				return;
			}
			Node *base = root->get_node(animation->track_get_path(p_track));

			method_selector->select_method_from_instance(base);

			insert_key_from_track_call_ofs = p_ofs;
			insert_key_from_track_call_track = p_track;

		} break;
		case Animation::TYPE_BEZIER: {

			NodePath bp;
			Variant value;
			_find_hint_for_track(p_track, bp, &value);
			Array arr;
			arr.resize(5);
			arr[0] = value;
			arr[1] = -0.25;
			arr[2] = 0;
			arr[3] = 0.25;
			arr[4] = 0;

			undo_redo->create_action("Add Track Key");
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, arr);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
			undo_redo->commit_action();

		} break;
		case Animation::TYPE_AUDIO: {

			Dictionary ak;
			ak["stream"] = RES();
			ak["start_offset"] = 0;
			ak["end_offset"] = 0;

			undo_redo->create_action("Add Track Key");
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, ak);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
			undo_redo->commit_action();
		} break;
		case Animation::TYPE_ANIMATION: {

			StringName anim = "[stop]";

			undo_redo->create_action("Add Track Key");
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", p_track, p_ofs, anim);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", p_track, p_ofs);
			undo_redo->commit_action();
		} break;
	}
}

void AnimationTrackEditor::_add_method_key(const String &p_method) {

	if (!root->has_node(animation->track_get_path(insert_key_from_track_call_track))) {
		EditorNode::get_singleton()->show_warning(TTR("Track path is invalid, so can't add a method key."));
		return;
	}
	Node *base = root->get_node(animation->track_get_path(insert_key_from_track_call_track));

	List<MethodInfo> minfo;
	base->get_method_list(&minfo);

	for (List<MethodInfo>::Element *E = minfo.front(); E; E = E->next()) {
		if (E->get().name == p_method) {

			Dictionary d;
			d["method"] = p_method;
			Array params;
			int first_defarg = E->get().arguments.size() - E->get().default_arguments.size();

			for (int i = 0; i < E->get().arguments.size(); i++) {

				if (i >= first_defarg) {
					Variant arg = E->get().default_arguments[i - first_defarg];
					params.push_back(arg);
				} else {
					Variant::CallError ce;
					Variant arg = Variant::construct(E->get().arguments[i].type, NULL, 0, ce);
					params.push_back(arg);
				}
			}
			d["args"] = params;

			undo_redo->create_action("Add Method Track Key");
			undo_redo->add_do_method(animation.ptr(), "track_insert_key", insert_key_from_track_call_track, insert_key_from_track_call_ofs, d);
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", insert_key_from_track_call_track, insert_key_from_track_call_ofs);
			undo_redo->commit_action();

			return;
		}
	}

	EditorNode::get_singleton()->show_warning(TTR("Method not found in object: ") + p_method);
}

void AnimationTrackEditor::_key_selected(int p_key, bool p_single, int p_track) {

	ERR_FAIL_INDEX(p_track, animation->get_track_count());
	ERR_FAIL_INDEX(p_key, animation->track_get_key_count(p_track));

	SelectedKey sk;
	sk.key = p_key;
	sk.track = p_track;

	if (p_single) {
		_clear_selection();
	}

	KeyInfo ki;
	ki.pos = animation->track_get_key_time(p_track, p_key);
	selection[sk] = ki;

	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}

	_update_key_edit();
}

void AnimationTrackEditor::_key_deselected(int p_key, int p_track) {

	ERR_FAIL_INDEX(p_track, animation->get_track_count());
	ERR_FAIL_INDEX(p_key, animation->track_get_key_count(p_track));

	SelectedKey sk;
	sk.key = p_key;
	sk.track = p_track;

	selection.erase(sk);

	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}

	_update_key_edit();
}

void AnimationTrackEditor::_move_selection_begin() {
	moving_selection = true;
	moving_selection_offset = 0;
}

void AnimationTrackEditor::_move_selection(float p_offset) {
	moving_selection_offset = p_offset;

	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}
}

struct _AnimMoveRestore {

	int track;
	float time;
	Variant key;
	float transition;
};
//used for undo/redo

void AnimationTrackEditor::_clear_key_edit() {
	if (key_edit) {

#if 0
		// going back seems like the most comfortable thing to do, but it results
		// in weird behaviors and crashes, because going back to animation editor
		// triggers the editor setting up again itself

		bool go_back = false;
		if (EditorNode::get_singleton()->get_inspector()->get_edited_object() == key_edit) {
			EditorNode::get_singleton()->push_item(NULL);
			go_back = true;
		}

		memdelete(key_edit);
		key_edit = NULL;

		if (go_back) {
			EditorNode::get_singleton()->get_inspector_dock()->go_back();
		}
#else
		//if key edit is the object being inspected, remove it first
		if (EditorNode::get_singleton()->get_inspector()->get_edited_object() == key_edit) {
			EditorNode::get_singleton()->push_item(NULL);
		}
		//then actually delete it
		memdelete(key_edit);
		key_edit = NULL;
#endif
	}
}

void AnimationTrackEditor::_clear_selection() {
	selection.clear();
	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}
	_clear_key_edit();
}

void AnimationTrackEditor::_update_key_edit() {

	_clear_key_edit();
	if (!animation.is_valid())
		return;
	if (selection.size() != 1) {
		return;
	}

	key_edit = memnew(AnimationTrackKeyEdit);
	key_edit->animation = animation;
	key_edit->track = selection.front()->key().track;

	float ofs = animation->track_get_key_time(key_edit->track, selection.front()->key().key);
	key_edit->key_ofs = ofs;
	key_edit->root_path = root;

	NodePath np;
	key_edit->hint = _find_hint_for_track(key_edit->track, np);
	key_edit->undo_redo = undo_redo;
	key_edit->base = np;

	EditorNode::get_singleton()->push_item(key_edit);
}

void AnimationTrackEditor::_clear_selection_for_anim(const Ref<Animation> &p_anim) {

	if (!(animation == p_anim))
		return;
	//selection.clear();
	_clear_selection();
}

void AnimationTrackEditor::_select_at_anim(const Ref<Animation> &p_anim, int p_track, float p_pos) {

	if (!(animation == p_anim))
		return;

	int idx = animation->track_find_key(p_track, p_pos, true);
	ERR_FAIL_COND(idx < 0);

	SelectedKey sk;
	sk.track = p_track;
	sk.key = idx;
	KeyInfo ki;
	ki.pos = p_pos;

	selection.insert(sk, ki);
}

void AnimationTrackEditor::_move_selection_commit() {

	undo_redo->create_action(TTR("Anim Move Keys"));

	List<_AnimMoveRestore> to_restore;

	float motion = moving_selection_offset;
	// 1-remove the keys
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
	}
	// 2- remove overlapped keys
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		float newtime = snap_time(E->get().pos + motion);
		int idx = animation->track_find_key(E->key().track, newtime, true);
		if (idx == -1)
			continue;
		SelectedKey sk;
		sk.key = idx;
		sk.track = E->key().track;
		if (selection.has(sk))
			continue; //already in selection, don't save

		undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newtime);
		_AnimMoveRestore amr;

		amr.key = animation->track_get_key_value(E->key().track, idx);
		amr.track = E->key().track;
		amr.time = newtime;
		amr.transition = animation->track_get_key_transition(E->key().track, idx);

		to_restore.push_back(amr);
	}

	// 3-move the keys (re insert them)
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		float newpos = snap_time(E->get().pos + 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));
	}

	// 4-(undo) remove inserted keys
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		float newpos = snap_time(E->get().pos + motion);
		/*
		if (newpos<0)
			continue; //no remove what no inserted
		*/
		undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newpos);
	}

	// 5-(undo) reinsert keys
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
	}

	// 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);
	}

	undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
	undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);

	// 7-reselect
	for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

		float oldpos = E->get().pos;
		float newpos = snap_time(oldpos + 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);
	}

	block_animation_update = true; //animation will change and this is triggered from a signal, so block updates
	undo_redo->commit_action();
	block_animation_update = false;

	moving_selection = false;
	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}

	_update_key_edit();
}
void AnimationTrackEditor::_move_selection_cancel() {

	moving_selection = false;
	for (int i = 0; i < track_edits.size(); i++) {
		track_edits[i]->update();
	}
}

bool AnimationTrackEditor::is_moving_selection() const {
	return moving_selection;
}
float AnimationTrackEditor::get_moving_selection_offset() const {
	return moving_selection_offset;
}

void AnimationTrackEditor::_box_selection_draw() {

	Color color = get_color("accent_color", "Editor");
	color.a = 0.2;
	Rect2 rect = Rect2(Point2(), box_selection->get_size());
	box_selection->draw_rect(rect, color);
}

void AnimationTrackEditor::_scroll_input(const Ref<InputEvent> &p_event) {

	Ref<InputEventMouseButton> mb = p_event;

	if (mb.is_valid() && mb->is_pressed() && mb->get_command() && mb->get_button_index() == BUTTON_WHEEL_DOWN) {

		timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() * 1.05);
		scroll->accept_event();
	}

	if (mb.is_valid() && mb->is_pressed() && mb->get_command() && mb->get_button_index() == BUTTON_WHEEL_UP) {

		timeline->get_zoom()->set_value(timeline->get_zoom()->get_value() / 1.05);
		scroll->accept_event();
	}

	if (mb.is_valid() && mb->get_button_index() == BUTTON_LEFT) {
		if (mb->is_pressed()) {
			box_selecting = true;
			box_selecting_from = scroll->get_global_transform().xform(mb->get_position());
			box_select_rect = Rect2();
		} else if (box_selecting) {

			if (box_selection->is_visible_in_tree()) {
				//only if moved
				for (int i = 0; i < track_edits.size(); i++) {

					Rect2 local_rect = box_select_rect;
					local_rect.position -= track_edits[i]->get_global_position();
					track_edits[i]->append_to_selection(local_rect);
				}

				if (_get_track_selected() == -1 && track_edits.size() > 0) { //minimal hack to make shortcuts work
					track_edits[track_edits.size() - 1]->grab_focus();
				}
			} else {
				_clear_selection(); //clear it
			}

			box_selection->hide();
			box_selecting = false;
		}
	}

	Ref<InputEventMouseMotion> mm = p_event;

	if (mm.is_valid() && mm->get_button_mask() & BUTTON_MASK_MIDDLE) {

		timeline->set_value(timeline->get_value() - mm->get_relative().x / timeline->get_zoom_scale());
	}

	if (mm.is_valid() && box_selecting) {

		if (!(mm->get_button_mask() & BUTTON_MASK_LEFT)) {
			//no longer
			box_selection->hide();
			box_selecting = false;
			return;
		}

		if (!box_selection->is_visible_in_tree()) {
			if (!mm->get_shift()) {
				_clear_selection(); //only append if shift is pressed
			}
			box_selection->show();
		}

		Vector2 from = box_selecting_from;
		Vector2 to = scroll->get_global_transform().xform(mm->get_position());

		if (from.x > to.x) {
			SWAP(from.x, to.x);
		}

		if (from.y > to.y) {
			SWAP(from.y, to.y);
		}

		Rect2 rect(from, to - from);
		Rect2 scroll_rect = Rect2(scroll->get_global_position(), scroll->get_size());
		rect = scroll_rect.clip(rect);
		box_selection->set_position(rect.position);
		box_selection->set_size(rect.size);

		box_select_rect = rect;

		if (get_local_mouse_position().y < 0) {
			//avoid box selection from going up and lose focus to viewport
			warp_mouse(Vector2(mm->get_position().x, 0));
		}
	}
}

void AnimationTrackEditor::_cancel_bezier_edit() {
	bezier_edit->hide();
	scroll->show();
}

void AnimationTrackEditor::_bezier_edit(int p_for_track) {

	_clear_selection(); //bezier probably wants to use a separate selection mode
	bezier_edit->set_root(root);
	bezier_edit->set_animation_and_track(animation, p_for_track);
	scroll->hide();
	bezier_edit->show();
	//search everything within the track and curve- edit it
}

void AnimationTrackEditor::_anim_duplicate_keys(bool transpose) {
	//duplicait!
	if (selection.size() && animation.is_valid() && (!transpose || (_get_track_selected() >= 0 && _get_track_selected() < animation->get_track_count()))) {

		int top_track = 0x7FFFFFFF;
		float top_time = 1e10;
		for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

			const SelectedKey &sk = E->key();

			float t = animation->track_get_key_time(sk.track, sk.key);
			if (t < top_time)
				top_time = t;
			if (sk.track < top_track)
				top_track = sk.track;
		}
		ERR_FAIL_COND(top_track == 0x7FFFFFFF || top_time == 1e10);

		//

		int start_track = transpose ? _get_track_selected() : top_track;

		undo_redo->create_action(TTR("Anim Duplicate Keys"));

		List<Pair<int, float> > new_selection_values;

		for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

			const SelectedKey &sk = E->key();

			float t = animation->track_get_key_time(sk.track, sk.key);

			float dst_time = t + (timeline->get_play_position() - top_time);
			int dst_track = sk.track + (start_track - top_track);

			if (dst_track < 0 || dst_track >= animation->get_track_count())
				continue;

			if (animation->track_get_type(dst_track) != animation->track_get_type(sk.track))
				continue;

			int existing_idx = animation->track_find_key(dst_track, dst_time, true);

			undo_redo->add_do_method(animation.ptr(), "track_insert_key", dst_track, dst_time, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
			undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", dst_track, dst_time);

			Pair<int, float> p;
			p.first = dst_track;
			p.second = dst_time;
			new_selection_values.push_back(p);

			if (existing_idx != -1) {

				undo_redo->add_undo_method(animation.ptr(), "track_insert_key", dst_track, dst_time, animation->track_get_key_value(dst_track, existing_idx), animation->track_get_key_transition(dst_track, existing_idx));
			}
		}

		undo_redo->commit_action();

		//reselect duplicated

		Map<SelectedKey, KeyInfo> new_selection;
		for (List<Pair<int, float> >::Element *E = new_selection_values.front(); E; E = E->next()) {

			int track = E->get().first;
			float time = E->get().second;

			int existing_idx = animation->track_find_key(track, time, true);

			if (existing_idx == -1)
				continue;
			SelectedKey sk2;
			sk2.track = track;
			sk2.key = existing_idx;

			KeyInfo ki;
			ki.pos = time;

			new_selection[sk2] = ki;
		}

		selection = new_selection;
		_update_tracks();
		_update_key_edit();
	}
}
void AnimationTrackEditor::_edit_menu_pressed(int p_option) {

	last_menu_track_opt = p_option;
	switch (p_option) {
		case EDIT_COPY_TRACKS: {
			track_copy_select->clear();
			TreeItem *troot = track_copy_select->create_item();

			for (int i = 0; i < animation->get_track_count(); i++) {

				NodePath path = animation->track_get_path(i);
				Node *node = NULL;

				if (root && root->has_node(path)) {
					node = root->get_node(path);
				}

				String text;
				Ref<Texture> icon = get_icon("Node", "EditorIcons");
				if (node) {
					if (has_icon(node->get_class(), "EditorIcons")) {
						icon = get_icon(node->get_class(), "EditorIcons");
					}

					text = node->get_name();
					Vector<StringName> sn = path.get_subnames();
					for (int j = 0; j < sn.size(); j++) {
						text += ".";
						text += sn[j];
					}

					path = NodePath(node->get_path().get_names(), path.get_subnames(), true); //store full path instead for copying
				} else {
					text = path;
					int sep = text.find(":");
					if (sep != -1) {
						text = text.substr(sep + 1, text.length());
					}
				}

				switch (animation->track_get_type(i)) {
					case Animation::TYPE_TRANSFORM: text += " (Transform)"; break;
					case Animation::TYPE_METHOD: text += " (Methods)"; break;
					case Animation::TYPE_BEZIER: text += " (Bezier)"; break;
					case Animation::TYPE_AUDIO: text += " (Audio)"; break;
					default: {
					};
				}

				TreeItem *it = track_copy_select->create_item(troot);
				it->set_editable(0, true);
				it->set_selectable(0, true);
				it->set_cell_mode(0, TreeItem::CELL_MODE_CHECK);
				it->set_icon(0, icon);
				it->set_text(0, text);
				Dictionary md;
				md["track_idx"] = i;
				md["path"] = path;
				it->set_metadata(0, md);
			}

			track_copy_dialog->popup_centered_minsize(Size2(300, 500) * EDSCALE);
		} break;
		case EDIT_COPY_TRACKS_CONFIRM: {

			track_clipboard.clear();
			TreeItem *root = track_copy_select->get_root();
			if (root) {

				TreeItem *it = root->get_children();
				while (it) {
					Dictionary md = it->get_metadata(0);
					int idx = md["track_idx"];
					if (it->is_checked(0) && idx >= 0 && idx < animation->get_track_count()) {
						TrackClipboard tc;
						tc.base_path = animation->track_get_path(idx);
						tc.full_path = md["path"];
						tc.track_type = animation->track_get_type(idx);
						tc.interp_type = animation->track_get_interpolation_type(idx);
						if (tc.track_type == Animation::TYPE_VALUE) {
							tc.update_mode = animation->value_track_get_update_mode(idx);
						}
						tc.loop_wrap = animation->track_get_interpolation_loop_wrap(idx);
						tc.enabled = animation->track_is_enabled(idx);
						for (int i = 0; i < animation->track_get_key_count(idx); i++) {
							TrackClipboard::Key k;
							k.time = animation->track_get_key_time(idx, i);
							k.value = animation->track_get_key_value(idx, i);
							k.transition = animation->track_get_key_transition(idx, i);
							tc.keys.push_back(k);
						}
						track_clipboard.push_back(tc);
					}
					it = it->get_next();
				}
			}
		} break;
		case EDIT_PASTE_TRACKS: {

			if (track_clipboard.size() == 0) {
				EditorNode::get_singleton()->show_warning(TTR("Clipboard is empty"));
				break;
			}

			int base_track = animation->get_track_count();
			undo_redo->create_action("Paste Tracks");
			for (int i = 0; i < track_clipboard.size(); i++) {
				undo_redo->add_do_method(animation.ptr(), "add_track", track_clipboard[i].track_type);
				Node *exists = NULL;
				NodePath path = track_clipboard[i].base_path;

				if (root) {
					NodePath np = track_clipboard[i].full_path;
					exists = root->get_node(np);
					if (exists) {
						path = NodePath(root->get_path_to(exists).get_names(), track_clipboard[i].full_path.get_subnames(), false);
					}
				}

				undo_redo->add_do_method(animation.ptr(), "track_set_path", base_track, path);
				undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_type", base_track, track_clipboard[i].interp_type);
				undo_redo->add_do_method(animation.ptr(), "track_set_interpolation_loop_wrap", base_track, track_clipboard[i].loop_wrap);
				undo_redo->add_do_method(animation.ptr(), "track_set_enabled", base_track, track_clipboard[i].enabled);
				if (track_clipboard[i].track_type == Animation::TYPE_VALUE) {
					undo_redo->add_do_method(animation.ptr(), "value_track_set_update_mode", base_track, track_clipboard[i].update_mode);
				}

				for (int j = 0; j < track_clipboard[i].keys.size(); j++) {
					undo_redo->add_do_method(animation.ptr(), "track_insert_key", base_track, track_clipboard[i].keys[j].time, track_clipboard[i].keys[j].value, track_clipboard[i].keys[j].transition);
				}

				undo_redo->add_undo_method(animation.ptr(), "remove_track", animation->get_track_count());

				base_track++;
			}

			undo_redo->commit_action();
		} break;

		case EDIT_SCALE_SELECTION:
		case EDIT_SCALE_FROM_CURSOR: {
			scale_dialog->popup_centered(Size2(200, 100) * EDSCALE);
		} break;
		case EDIT_SCALE_CONFIRM: {
			if (selection.empty())
				return;

			float from_t = 1e20;
			float to_t = -1e20;
			float len = -1e20;
			float pivot = 0;

			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;
				if (t > to_t)
					to_t = t;
			}

			len = to_t - from_t;
			if (last_menu_track_opt == EDIT_SCALE_FROM_CURSOR) {
				pivot = timeline->get_play_position();

			} else {

				pivot = from_t;
			}

			float s = scale->get_value();
			if (s == 0) {
				ERR_PRINT("Can't scale to 0");
			}

			undo_redo->create_action(TTR("Anim Scale Keys"));

			List<_AnimMoveRestore> to_restore;

			// 1-remove the keys
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
			}
			// 2- remove overlapped keys
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				float newtime = (E->get().pos - from_t) * s + from_t;
				int idx = animation->track_find_key(E->key().track, newtime, true);
				if (idx == -1)
					continue;
				SelectedKey sk;
				sk.key = idx;
				sk.track = E->key().track;
				if (selection.has(sk))
					continue; //already in selection, don't save

				undo_redo->add_do_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newtime);
				_AnimMoveRestore amr;

				amr.key = animation->track_get_key_value(E->key().track, idx);
				amr.track = E->key().track;
				amr.time = newtime;
				amr.transition = animation->track_get_key_transition(E->key().track, idx);

				to_restore.push_back(amr);
			}

#define _NEW_POS(m_ofs) (((s > 0) ? m_ofs : from_t + (len - (m_ofs - from_t))) - pivot) * ABS(s) + from_t
			// 3-move the keys (re insert them)
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				float newpos = _NEW_POS(E->get().pos);
				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));
			}

			// 4-(undo) remove inserted keys
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				float newpos = _NEW_POS(E->get().pos);
				undo_redo->add_undo_method(animation.ptr(), "track_remove_key_at_position", E->key().track, newpos);
			}

			// 5-(undo) reinsert keys
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				undo_redo->add_undo_method(animation.ptr(), "track_insert_key", E->key().track, E->get().pos, animation->track_get_key_value(E->key().track, E->key().key), animation->track_get_key_transition(E->key().track, E->key().key));
			}

			// 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);
			}

			undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
			undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);

			// 7-reselect
			for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

				float oldpos = E->get().pos;
				float newpos = _NEW_POS(oldpos);
				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);
			}
#undef _NEW_POS
			undo_redo->commit_action();
		} break;
		case EDIT_DUPLICATE_SELECTION: {

			if (bezier_edit->is_visible()) {
				bezier_edit->duplicate_selection();
				break;
			}
			_anim_duplicate_keys(false);
		} break;
		case EDIT_DUPLICATE_TRANSPOSED: {
			if (bezier_edit->is_visible()) {
				EditorNode::get_singleton()->show_warning(TTR("This option does not work for Bezier editing, as it's only a single track."));
				break;
			}
			_anim_duplicate_keys(true);
		} break;
		case EDIT_DELETE_SELECTION: {

			if (bezier_edit->is_visible()) {
				bezier_edit->delete_selection();
				break;
			}

			if (selection.size()) {
				undo_redo->create_action(TTR("Anim Delete Keys"));

				for (Map<SelectedKey, KeyInfo>::Element *E = selection.back(); E; E = E->prev()) {

					undo_redo->add_do_method(animation.ptr(), "track_remove_key", E->key().track, E->key().key);
					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));
				}
				undo_redo->add_do_method(this, "_clear_selection_for_anim", animation);
				undo_redo->add_undo_method(this, "_clear_selection_for_anim", animation);
				undo_redo->commit_action();
				//selection.clear();
				_update_key_edit();
			}
		} break;
		case EDIT_GOTO_NEXT_STEP: {

			if (animation.is_null())
				break;
			float step = animation->get_step();
			if (step == 0)
				step = 1;

			float pos = timeline->get_play_position();

			pos = Math::stepify(pos + step, step);
			if (pos > animation->get_length())
				pos = animation->get_length();
			set_anim_pos(pos);

			emit_signal("timeline_changed", pos, true);

		} break;
		case EDIT_GOTO_PREV_STEP: {
			if (animation.is_null())
				break;
			float step = animation->get_step();
			if (step == 0)
				step = 1;

			float pos = timeline->get_play_position();
			pos = Math::stepify(pos - step, step);
			if (pos < 0)
				pos = 0;
			set_anim_pos(pos);
			emit_signal("timeline_changed", pos, true);

		} break;
		case EDIT_OPTIMIZE_ANIMATION: {
			optimize_dialog->popup_centered(Size2(250, 180) * EDSCALE);

		} break;
		case EDIT_OPTIMIZE_ANIMATION_CONFIRM: {
			animation->optimize(optimize_linear_error->get_value(), optimize_angular_error->get_value(), optimize_max_angle->get_value());
			_update_tracks();
			undo_redo->clear_history();

		} break;
		case EDIT_CLEAN_UP_ANIMATION: {
			cleanup_dialog->popup_centered_minsize(Size2(300, 0) * EDSCALE);

		} break;
		case EDIT_CLEAN_UP_ANIMATION_CONFIRM: {
			if (cleanup_all->is_pressed()) {
				List<StringName> names;
				AnimationPlayerEditor::singleton->get_player()->get_animation_list(&names);
				for (List<StringName>::Element *E = names.front(); E; E = E->next()) {
					_cleanup_animation(AnimationPlayerEditor::singleton->get_player()->get_animation(E->get()));
				}
			} else {
				_cleanup_animation(animation);
			}

		} break;
	}
}

void AnimationTrackEditor::_cleanup_animation(Ref<Animation> p_animation) {

	for (int i = 0; i < p_animation->get_track_count(); i++) {

		bool prop_exists = false;
		Variant::Type valid_type = Variant::NIL;
		Object *obj = NULL;

		RES res;
		Vector<StringName> leftover_path;

		Node *node = root->get_node_and_resource(p_animation->track_get_path(i), res, leftover_path);

		if (res.is_valid()) {
			obj = res.ptr();
		} else if (node) {
			obj = node;
		}

		if (obj && p_animation->track_get_type(i) == Animation::TYPE_VALUE) {
			valid_type = obj->get_static_property_type_indexed(leftover_path, &prop_exists);
		}

		if (!obj && cleanup_tracks->is_pressed()) {

			p_animation->remove_track(i);
			i--;
			continue;
		}

		if (!prop_exists || p_animation->track_get_type(i) != Animation::TYPE_VALUE || cleanup_keys->is_pressed() == false)
			continue;

		for (int j = 0; j < p_animation->track_get_key_count(i); j++) {

			Variant v = p_animation->track_get_key_value(i, j);

			if (!Variant::can_convert(v.get_type(), valid_type)) {
				p_animation->track_remove_key(i, j);
				j--;
			}
		}

		if (p_animation->track_get_key_count(i) == 0 && cleanup_tracks->is_pressed()) {
			p_animation->remove_track(i);
			i--;
		}
	}

	undo_redo->clear_history();
	_update_tracks();
}

void AnimationTrackEditor::_view_group_toggle() {
	_update_tracks();
	view_group->set_icon(get_icon(view_group->is_pressed() ? "AnimationTrackList" : "AnimationTrackGroup", "EditorIcons"));
}

void AnimationTrackEditor::_selection_changed() {

	if (selected_filter->is_pressed()) {
		_update_tracks(); //needs updatin
	} else {
		for (int i = 0; i < track_edits.size(); i++) {
			track_edits[i]->update();
		}

		for (int i = 0; i < groups.size(); i++) {
			groups[i]->update();
		}
	}
}

float AnimationTrackEditor::snap_time(float p_value) {

	if (snap->is_pressed()) {
		p_value = Math::stepify(p_value, step->get_value());
	}

	return p_value;
}

void AnimationTrackEditor::_bind_methods() {

	ClassDB::bind_method("_animation_changed", &AnimationTrackEditor::_animation_changed);
	ClassDB::bind_method("_timeline_changed", &AnimationTrackEditor::_timeline_changed);
	ClassDB::bind_method("_track_remove_request", &AnimationTrackEditor::_track_remove_request);
	ClassDB::bind_method("_name_limit_changed", &AnimationTrackEditor::_name_limit_changed);
	ClassDB::bind_method("_update_scroll", &AnimationTrackEditor::_update_scroll);
	ClassDB::bind_method("_update_step", &AnimationTrackEditor::_update_step);
	ClassDB::bind_method("_update_length", &AnimationTrackEditor::_update_length);
	ClassDB::bind_method("_dropped_track", &AnimationTrackEditor::_dropped_track);
	ClassDB::bind_method("_add_track", &AnimationTrackEditor::_add_track);
	ClassDB::bind_method("_new_track_node_selected", &AnimationTrackEditor::_new_track_node_selected);
	ClassDB::bind_method("_new_track_property_selected", &AnimationTrackEditor::_new_track_property_selected);
	ClassDB::bind_method("_root_removed", &AnimationTrackEditor::_root_removed);
	ClassDB::bind_method("_confirm_insert_list", &AnimationTrackEditor::_confirm_insert_list);
	ClassDB::bind_method("_insert_delay", &AnimationTrackEditor::_insert_delay);
	ClassDB::bind_method("_timeline_value_changed", &AnimationTrackEditor::_timeline_value_changed);
	ClassDB::bind_method("_insert_key_from_track", &AnimationTrackEditor::_insert_key_from_track);
	ClassDB::bind_method("_add_method_key", &AnimationTrackEditor::_add_method_key);
	ClassDB::bind_method("_key_selected", &AnimationTrackEditor::_key_selected);
	ClassDB::bind_method("_key_deselected", &AnimationTrackEditor::_key_deselected);
	ClassDB::bind_method("_clear_selection", &AnimationTrackEditor::_clear_selection);
	ClassDB::bind_method("_move_selection_begin", &AnimationTrackEditor::_move_selection_begin);
	ClassDB::bind_method("_move_selection", &AnimationTrackEditor::_move_selection);
	ClassDB::bind_method("_move_selection_commit", &AnimationTrackEditor::_move_selection_commit);
	ClassDB::bind_method("_move_selection_cancel", &AnimationTrackEditor::_move_selection_cancel);
	ClassDB::bind_method("_clear_selection_for_anim", &AnimationTrackEditor::_clear_selection_for_anim);
	ClassDB::bind_method("_select_at_anim", &AnimationTrackEditor::_select_at_anim);
	ClassDB::bind_method("_scroll_input", &AnimationTrackEditor::_scroll_input);
	ClassDB::bind_method("_box_selection_draw", &AnimationTrackEditor::_box_selection_draw);
	ClassDB::bind_method("_bezier_edit", &AnimationTrackEditor::_bezier_edit);
	ClassDB::bind_method("_cancel_bezier_edit", &AnimationTrackEditor::_cancel_bezier_edit);
	ClassDB::bind_method("_edit_menu_pressed", &AnimationTrackEditor::_edit_menu_pressed);
	ClassDB::bind_method("_view_group_toggle", &AnimationTrackEditor::_view_group_toggle);
	ClassDB::bind_method("_selection_changed", &AnimationTrackEditor::_selection_changed);

	ADD_SIGNAL(MethodInfo("timeline_changed", PropertyInfo(Variant::REAL, "position"), PropertyInfo(Variant::BOOL, "drag")));
	ADD_SIGNAL(MethodInfo("keying_changed"));
	ADD_SIGNAL(MethodInfo("animation_len_changed", PropertyInfo(Variant::REAL, "len")));
	ADD_SIGNAL(MethodInfo("animation_step_changed", PropertyInfo(Variant::REAL, "step")));
}

AnimationTrackEditor::AnimationTrackEditor() {
	root = NULL;
	block_animation_update = false;

	undo_redo = EditorNode::get_singleton()->get_undo_redo();

	main_panel = memnew(PanelContainer);
	add_child(main_panel);
	main_panel->set_v_size_flags(SIZE_EXPAND_FILL);
	HBoxContainer *timeline_scroll = memnew(HBoxContainer);
	main_panel->add_child(timeline_scroll);
	timeline_scroll->set_v_size_flags(SIZE_EXPAND_FILL);

	VBoxContainer *timeline_vbox = memnew(VBoxContainer);
	timeline_scroll->add_child(timeline_vbox);
	timeline_vbox->set_v_size_flags(SIZE_EXPAND_FILL);
	timeline_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
	timeline_vbox->add_constant_override("separation", 0);

	timeline = memnew(AnimationTimelineEdit);
	timeline->set_block_animation_update_ptr(&block_animation_update);
	timeline->set_undo_redo(undo_redo);
	timeline_vbox->add_child(timeline);
	timeline->connect("timeline_changed", this, "_timeline_changed");
	timeline->connect("name_limit_changed", this, "_name_limit_changed");
	timeline->connect("track_added", this, "_add_track");
	timeline->connect("value_changed", this, "_timeline_value_changed");
	timeline->connect("length_changed", this, "_update_length");

	scroll = memnew(ScrollContainer);
	timeline_vbox->add_child(scroll);
	scroll->set_v_size_flags(SIZE_EXPAND_FILL);
	VScrollBar *sb = scroll->get_v_scrollbar();
	scroll->remove_child(sb);
	timeline_scroll->add_child(sb); //move here so timeline and tracks are always aligned
	scroll->connect("gui_input", this, "_scroll_input");

	bezier_edit = memnew(AnimationBezierTrackEdit);
	timeline_vbox->add_child(bezier_edit);
	bezier_edit->set_block_animation_update_ptr(&block_animation_update);
	bezier_edit->set_undo_redo(undo_redo);
	bezier_edit->set_editor(this);
	bezier_edit->set_timeline(timeline);
	bezier_edit->hide();
	bezier_edit->set_v_size_flags(SIZE_EXPAND_FILL);
	bezier_edit->connect("close_request", this, "_cancel_bezier_edit");

	timeline_vbox->set_custom_minimum_size(Size2(0, 150) * EDSCALE);

	hscroll = memnew(HScrollBar);
	hscroll->share(timeline);
	hscroll->hide();
	hscroll->connect("value_changed", this, "_update_scroll");
	timeline_vbox->add_child(hscroll);
	timeline->set_hscroll(hscroll);

	track_vbox = memnew(VBoxContainer);
	scroll->add_child(track_vbox);
	track_vbox->set_h_size_flags(SIZE_EXPAND_FILL);
	scroll->set_enable_h_scroll(false);
	scroll->set_enable_v_scroll(true);
	track_vbox->add_constant_override("separation", 0);

	//timeline_vbox->add_child(memnew(HSeparator));
	HBoxContainer *bottom_hb = memnew(HBoxContainer);
	add_child(bottom_hb);
	bottom_hb->add_spacer();

	selected_filter = memnew(ToolButton);
	selected_filter->connect("pressed", this, "_view_group_toggle"); //same function works the same
	selected_filter->set_toggle_mode(true);
	selected_filter->set_tooltip(TTR("Only show tracks from nodes selected in tree."));

	bottom_hb->add_child(selected_filter);

	view_group = memnew(ToolButton);
	view_group->connect("pressed", this, "_view_group_toggle");
	view_group->set_toggle_mode(true);
	view_group->set_tooltip(TTR("Group tracks by node or display them as plain list."));

	bottom_hb->add_child(view_group);
	bottom_hb->add_child(memnew(VSeparator));

	snap = memnew(ToolButton);
	snap->set_text(TTR("Snap (s): "));
	bottom_hb->add_child(snap);
	snap->set_disabled(true);
	snap->set_toggle_mode(true);
	snap->set_pressed(true);

	step = memnew(EditorSpinSlider);
	step->set_min(0);
	step->set_max(1000);
	step->set_step(0.01);
	step->set_hide_slider(true);
	step->set_custom_minimum_size(Size2(100, 0) * EDSCALE);
	step->set_tooltip(TTR("Animation step value."));
	bottom_hb->add_child(step);
	step->connect("value_changed", this, "_update_step");
	step->set_read_only(true);

	bottom_hb->add_child(memnew(VSeparator));

	zoom_icon = memnew(TextureRect);
	zoom_icon->set_v_size_flags(SIZE_SHRINK_CENTER);
	bottom_hb->add_child(zoom_icon);
	zoom = memnew(HSlider);
	zoom->set_step(0.01);
	zoom->set_min(0.0);
	zoom->set_max(2.0);
	zoom->set_value(1.0);
	zoom->set_custom_minimum_size(Size2(200, 0) * EDSCALE);
	zoom->set_v_size_flags(SIZE_SHRINK_CENTER);
	bottom_hb->add_child(zoom);
	timeline->set_zoom(zoom);

	edit = memnew(MenuButton);
	edit->set_text(TTR("Edit"));
	edit->set_flat(false);
	edit->set_disabled(true);
	edit->set_tooltip(TTR("Animation properties."));
	edit->get_popup()->add_item(TTR("Copy Tracks"), EDIT_COPY_TRACKS);
	edit->get_popup()->add_item(TTR("Paste Tracks"), EDIT_PASTE_TRACKS);
	edit->get_popup()->add_separator();
	edit->get_popup()->add_item(TTR("Scale Selection"), EDIT_SCALE_SELECTION);
	edit->get_popup()->add_item(TTR("Scale From Cursor"), EDIT_SCALE_FROM_CURSOR);
	edit->get_popup()->add_separator();
	edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/duplicate_selection", TTR("Duplicate Selection"), KEY_MASK_CMD | KEY_D), EDIT_DUPLICATE_SELECTION);
	edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/duplicate_selection_transposed", TTR("Duplicate Transposed"), KEY_MASK_SHIFT | KEY_MASK_CMD | KEY_D), EDIT_DUPLICATE_TRANSPOSED);
	edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DUPLICATE_SELECTION), true);
	edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DUPLICATE_TRANSPOSED), true);
	edit->get_popup()->add_separator();
	edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/delete_selection", TTR("Delete Selection"), KEY_DELETE), EDIT_DELETE_SELECTION);
	edit->get_popup()->set_item_shortcut_disabled(edit->get_popup()->get_item_index(EDIT_DELETE_SELECTION), true);
	//this shortcut will be checked from the track itself. so no need to enable it here (will conflict with scenetree dock)

	edit->get_popup()->add_separator();
	edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/goto_next_step", TTR("Go to Next Step"), KEY_MASK_CMD | KEY_RIGHT), EDIT_GOTO_NEXT_STEP);
	edit->get_popup()->add_shortcut(ED_SHORTCUT("animation_editor/goto_prev_step", TTR("Go to Previous Step"), KEY_MASK_CMD | KEY_LEFT), EDIT_GOTO_PREV_STEP);
	edit->get_popup()->add_separator();
	edit->get_popup()->add_item(TTR("Optimize Animation"), EDIT_OPTIMIZE_ANIMATION);
	edit->get_popup()->add_item(TTR("Clean-Up Animation"), EDIT_CLEAN_UP_ANIMATION);

	edit->get_popup()->connect("id_pressed", this, "_edit_menu_pressed");

	pick_track = memnew(SceneTreeDialog);
	add_child(pick_track);
	pick_track->set_title(TTR("Pick the node that will be animated:"));
	pick_track->connect("selected", this, "_new_track_node_selected");
	prop_selector = memnew(PropertySelector);
	add_child(prop_selector);
	prop_selector->connect("selected", this, "_new_track_property_selected");

	method_selector = memnew(PropertySelector);
	add_child(method_selector);
	method_selector->connect("selected", this, "_add_method_key");

	inserting = false;
	insert_query = false;
	insert_frame = 0;
	insert_queue = false;

	insert_confirm = memnew(ConfirmationDialog);
	add_child(insert_confirm);
	insert_confirm->connect("confirmed", this, "_confirm_insert_list");
	VBoxContainer *icvb = memnew(VBoxContainer);
	insert_confirm->add_child(icvb);
	insert_confirm_text = memnew(Label);
	icvb->add_child(insert_confirm_text);
	insert_confirm_bezier = memnew(CheckBox);
	insert_confirm_bezier->set_text(TTR("Use Bezier Curves"));
	icvb->add_child(insert_confirm_bezier);
	keying = false;
	moving_selection = 0;
	key_edit = NULL;

	box_selection = memnew(Control);
	add_child(box_selection);
	box_selection->set_as_toplevel(true);
	box_selection->set_mouse_filter(MOUSE_FILTER_IGNORE);
	box_selection->hide();
	box_selection->connect("draw", this, "_box_selection_draw");
	box_selecting = false;

	//default plugins

	Ref<AnimationTrackEditDefaultPlugin> def_plugin;
	def_plugin.instance();
	add_track_edit_plugin(def_plugin);

	//dialogs

	optimize_dialog = memnew(ConfirmationDialog);
	add_child(optimize_dialog);
	optimize_dialog->set_title(TTR("Anim. Optimizer"));
	VBoxContainer *optimize_vb = memnew(VBoxContainer);
	optimize_dialog->add_child(optimize_vb);

	optimize_linear_error = memnew(SpinBox);
	optimize_linear_error->set_max(1.0);
	optimize_linear_error->set_min(0.001);
	optimize_linear_error->set_step(0.001);
	optimize_linear_error->set_value(0.05);
	optimize_vb->add_margin_child(TTR("Max. Linear Error:"), optimize_linear_error);
	optimize_angular_error = memnew(SpinBox);
	optimize_angular_error->set_max(1.0);
	optimize_angular_error->set_min(0.001);
	optimize_angular_error->set_step(0.001);
	optimize_angular_error->set_value(0.01);

	optimize_vb->add_margin_child(TTR("Max. Angular Error:"), optimize_angular_error);
	optimize_max_angle = memnew(SpinBox);
	optimize_vb->add_margin_child(TTR("Max Optimizable Angle:"), optimize_max_angle);
	optimize_max_angle->set_max(360.0);
	optimize_max_angle->set_min(0.0);
	optimize_max_angle->set_step(0.1);
	optimize_max_angle->set_value(22);

	optimize_dialog->get_ok()->set_text(TTR("Optimize"));
	optimize_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_CLEAN_UP_ANIMATION_CONFIRM));

	//

	cleanup_dialog = memnew(ConfirmationDialog);
	add_child(cleanup_dialog);
	VBoxContainer *cleanup_vb = memnew(VBoxContainer);
	cleanup_dialog->add_child(cleanup_vb);

	cleanup_keys = memnew(CheckButton);
	cleanup_keys->set_text(TTR("Remove invalid keys"));
	cleanup_keys->set_pressed(true);
	cleanup_vb->add_child(cleanup_keys);

	cleanup_tracks = memnew(CheckButton);
	cleanup_tracks->set_text(TTR("Remove unresolved and empty tracks"));
	cleanup_tracks->set_pressed(true);
	cleanup_vb->add_child(cleanup_tracks);

	cleanup_all = memnew(CheckButton);
	cleanup_all->set_text(TTR("Clean-up all animations"));
	cleanup_vb->add_child(cleanup_all);

	cleanup_dialog->set_title(TTR("Clean-Up Animation(s) (NO UNDO!)"));
	cleanup_dialog->get_ok()->set_text(TTR("Clean-Up"));

	cleanup_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_CLEAN_UP_ANIMATION_CONFIRM));

	//
	scale_dialog = memnew(ConfirmationDialog);
	VBoxContainer *vbc = memnew(VBoxContainer);
	scale_dialog->add_child(vbc);

	scale = memnew(SpinBox);
	scale->set_min(-99999);
	scale->set_max(99999);
	scale->set_step(0.001);
	vbc->add_margin_child(TTR("Scale Ratio:"), scale);
	scale_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_SCALE_CONFIRM));
	add_child(scale_dialog);

	track_copy_dialog = memnew(ConfirmationDialog);
	add_child(track_copy_dialog);
	track_copy_dialog->set_title(TTR("Select tracks to copy:"));
	track_copy_dialog->get_ok()->set_text(TTR("Copy"));

	track_copy_select = memnew(Tree);
	track_copy_select->set_hide_root(true);
	track_copy_dialog->add_child(track_copy_select);
	track_copy_dialog->connect("confirmed", this, "_edit_menu_pressed", varray(EDIT_COPY_TRACKS_CONFIRM));
}

AnimationTrackEditor::~AnimationTrackEditor() {
	if (key_edit) {
		memdelete(key_edit);
	}
}