godot/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" || name == "frame") {

			float new_time = p_value;

			if (name == "frame") {
				float fps = animation->get_step();
				if (fps > 0) {
					fps = 1.0 / fps;
				}
				new_time /= fps;
			}
			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_key_in_handle", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_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_key_out_handle", track, key, value);
					undo_redo->add_undo_method(animation.ptr(), "bezier_track_set_key_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 == "frame") {
			float fps = animation->get_step();
			if (fps > 0) {
				fps = 1.0 / fps;
			}
			r_ret = key_ofs * fps;
			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);

		if (use_fps && animation->get_step() > 0) {
			float max_frame = animation->get_length() / animation->get_step();
			p_list->push_back(PropertyInfo(Variant::REAL, "frame", PROPERTY_HINT_RANGE, "0," + rtos(max_frame) + ",1"));
		} else {
			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;
	bool use_fps;

	void notify_change() {

		_change_notify();
	}

	Node *get_root_path() {
		return root_path;
	}

	void set_use_fps(bool p_enable) {
		use_fps = p_enable;
		_change_notify();
	}

	AnimationTrackKeyEdit() {
		use_fps = false;
		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);
	if (use_fps && animation->get_step() > 0) {
		p_new_len *= animation->get_step();
	}

	editing = true;
	undo_redo->create_action(TTR("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();
	editing = false;
	update();

	emit_signal("length_changed", p_new_len);
}

void AnimationTimelineEdit::_anim_loop_pressed() {

	undo_redo->create_action(TTR("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();
}

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

		if (use_fps) {

			float step_size = animation->get_step();
			if (step_size > 0) {

				int prev_frame_ofs = -10000000;

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

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

					int frame = pos / step_size;
					int prev_frame = prev / step_size;

					bool sub = Math::floor(prev) == Math::floor(pos);

					if (frame != prev_frame && i >= prev_frame_ofs) {

						draw_line(Point2(get_name_limit() + i, 0), Point2(get_name_limit() + i, h), linecolor, Math::round(EDSCALE));

						draw_string(font, Point2(get_name_limit() + i + 3 * EDSCALE, (h - font->get_height()) / 2 + font->get_ascent()).floor(), itos(frame), sub ? color_time_dec : color_time_sec, zoomw - i);
						prev_frame_ofs = i + font->get_string_size(itos(frame)).x + 5 * EDSCALE;
					}
				}
			}

		} else {
			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, Math::round(EDSCALE));
					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, Math::round(EDSCALE));
	}
}

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_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;
	if (use_fps && animation->get_step() > 0) {
		length->set_value(animation->get_length() / animation->get_step());
		length->set_step(1);
		length->set_tooltip(TTR("Animation length (frames)"));
		time_icon->set_tooltip(TTR("Animation length (frames)"));
	} else {
		length->set_value(animation->get_length());
		length->set_step(0.01);
		length->set_tooltip(TTR("Animation length (seconds)"));
		time_icon->set_tooltip(TTR("Animation length (seconds)"));
	}
	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, Math::round(EDSCALE));
	}
}

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_use_fps(bool p_use_fps) {
	use_fps = p_use_fps;
	update_values();
	update();
}
bool AnimationTimelineEdit::is_using_fps() const {
	return use_fps;
}

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() {

	use_fps = false;
	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 (seconds)"));
	len_hb->add_child(time_icon);
	length = memnew(EditorSpinSlider);
	length->set_min(0.001);
	length->set_max(36000);
	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 (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 {
					text += path.get_concatenated_subnames();
				}
				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 = String() + node->get_name() + ":" + path.get_concatenated_subnames();
				ofs += hsep;
				ofs += icon->get_width();

			} 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, Math::round(EDSCALE));
		}

		// 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, Math::round(EDSCALE));

			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, Math::round(EDSCALE));
				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, Math::round(EDSCALE));
				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, Math::round(EDSCALE));
				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, Math::round(EDSCALE));
		} else {
			draw_line(Vector2(0, get_size().height), get_size(), linecolor, Math::round(EDSCALE));
		}

		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, Math::round(EDSCALE));
			} else {
				draw_line(Vector2(0, get_size().height), get_size(), drop_color, Math::round(EDSCALE));
			}
		}
	}

	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, Math::round(2 * EDSCALE));
}

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

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

NodePath AnimationTrackEdit::get_path() const {
	return node_path;
}

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, Math::round(EDSCALE));
	}
}

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(TTR("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)) {
			undo_redo->create_action(TTR("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();
			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();
			return;
		}

		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);
			undo_redo->create_action(TTR("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();
			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);
			undo_redo->create_action(TTR("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();
			update();
		} break;
		case MENU_LOOP_WRAP:
		case MENU_LOOP_CLAMP: {

			bool loop_wrap = p_index == MENU_LOOP_WRAP;
			undo_redo->create_action(TTR("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();
			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::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;
	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, Math::round(EDSCALE));
		draw_line(Point2(timeline->get_name_limit(), 0), Point2(timeline->get_name_limit(), get_size().height), linecolor, Math::round(EDSCALE));
		draw_line(Point2(get_size().width - timeline->get_buttons_width(), 0), Point2(get_size().width - timeline->get_buttons_width(), get_size().height), linecolor, Math::round(EDSCALE));

		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, Math::round(EDSCALE));
		}
	}
}

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

		_update_step_spinbox();
		step->set_block_signals(false);
		step->set_read_only(false);
		snap->set_disabled(false);
		snap_mode->set_disabled(false);

		imported_anim_warning->hide();
		for (int i = 0; i < animation->get_track_count(); i++) {
			if (animation->track_is_imported(i)) {
				imported_anim_warning->show();
				break;
			}
		}

	} 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);
		snap_mode->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;
}
Dictionary AnimationTrackEditor::get_state() const {
	Dictionary state;
	state["fps_mode"] = timeline->is_using_fps();
	state["zoom"] = zoom->get_value();
	state["offset"] = timeline->get_value();
	state["v_scroll"] = scroll->get_v_scrollbar()->get_value();
	return state;
}
void AnimationTrackEditor::set_state(const Dictionary &p_state) {
	if (p_state.has("fps_mode")) {
		bool fps_mode = p_state["fps_mode"];
		if (fps_mode) {
			snap_mode->select(1);
		} else {
			snap_mode->select(0);
		}
		_snap_mode_changed(snap_mode->get_selected());
	} else {
		snap_mode->select(0);
		_snap_mode_changed(snap_mode->get_selected());
	}
	if (p_state.has("zoom")) {
		zoom->set_value(p_state["zoom"]);
	} else {
		zoom->set_value(1.0);
	}
	if (p_state.has("offset")) {
		timeline->set_value(p_state["offset"]);
	} else {
		timeline->set_value(0);
	}
	if (p_state.has("v_scroll")) {
		scroll->get_v_scrollbar()->set_value(p_state["v_scroll"]);
	} else {
		scroll->get_v_scrollbar()->set_value(0);
	}
}

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()) {
		selection.clear();
		_clear_key_edit();
		//all will be updated after remove anyway, and triggering update here raises error on tracks already removed

		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_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 (animation_changing_awaiting_update) {
		return; //all will be updated, don't bother with anything
	}

	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()) {
			if (animation->track_get_type(key_edit->track) == Animation::TYPE_BEZIER)
				bezier_edit->update();
			else
				track_edits[key_edit->track]->update();
		}
		return;
	}

	animation_changing_awaiting_update = true;
	call_deferred("_animation_update");
}

void AnimationTrackEditor::_snap_mode_changed(int p_mode) {

	timeline->set_use_fps(p_mode == 1);
	if (key_edit) {
		key_edit->set_use_fps(p_mode == 1);
	}
	_update_step_spinbox();
}

void AnimationTrackEditor::_update_step_spinbox() {
	if (!animation.is_valid()) {
		return;
	}
	step->set_block_signals(true);

	if (timeline->is_using_fps()) {
		if (animation->get_step() == 0) {
			step->set_value(0);
		} else {
			step->set_value(1.0 / animation->get_step());
		}

	} else {
		step->set_value(animation->get_step());
	}

	step->set_block_signals(false);
}
void AnimationTrackEditor::_animation_update() {

	timeline->update();
	timeline->update_values();

	bool same = true;

	if (animation.is_null()) {
		return;
	}

	if (track_edits.size() == animation->get_track_count()) {
		//check tracks are the same

		for (int i = 0; i < track_edits.size(); i++) {
			if (track_edits[i]->get_path() != animation->track_get_path(i)) {
				same = false;
				break;
			}
		}
	} else {
		same = false;
	}

	if (same) {
		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();

	_update_step_spinbox();

	animation_changing_awaiting_update = 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"));
		imported_anim_warning->set_icon(get_icon("NodeWarning", "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(TTR("Change Animation Step"));
	float step_value = p_new_step;
	if (timeline->is_using_fps()) {
		if (step_value != 0.0) {
			step_value = 1.0 / step_value;
		}
	}
	undo_redo->add_do_method(animation.ptr(), "set_step", step_value);
	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", step_value);
}

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(TTR("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(TTR("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(TTR("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(TTR("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(TTR("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(TTR("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 = snap_time(p_ofs);
	}
	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(TTR("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(TTR("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(TTR("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(TTR("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(TTR("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(TTR("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;
	key_edit->use_fps = timeline->is_using_fps();

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

	undo_redo->commit_action();

	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(TTR("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()) {

		double snap_increment;
		if (timeline->is_using_fps() && step->get_value() > 0)
			snap_increment = 1.0 / step->get_value();
		else
			snap_increment = step->get_value();

		p_value = Math::stepify(p_value, snap_increment);
	}

	return p_value;
}

void AnimationTrackEditor::_show_imported_anim_warning() const {

	EditorNode::get_singleton()->show_warning(TTR("This animation belongs to an imported scene, so changes to imported tracks will not be saved.\n\n"
												  "To enable the ability to add custom tracks, navigate to the scene's import settings and set\n"
												  "\"Animation > Storage\" to \"Files\", enable \"Animation > Keep Custom Tracks\", then re-import.\n"
												  "Alternatively, use an import preset that imports animations to separate files."),
			TTR("Warning: Editing imported animation"));
}

void AnimationTrackEditor::_bind_methods() {

	ClassDB::bind_method("_animation_changed", &AnimationTrackEditor::_animation_changed);
	ClassDB::bind_method("_animation_update", &AnimationTrackEditor::_animation_update);
	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_tracks", &AnimationTrackEditor::_update_tracks);
	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);
	ClassDB::bind_method("_snap_mode_changed", &AnimationTrackEditor::_snap_mode_changed);
	ClassDB::bind_method("_show_imported_anim_warning", &AnimationTrackEditor::_show_imported_anim_warning);

	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;

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

	imported_anim_warning = memnew(Button);
	imported_anim_warning->hide();
	imported_anim_warning->set_tooltip(TTR("Warning: Editing imported animation"));
	imported_anim_warning->connect("pressed", this, "_show_imported_anim_warning");
	bottom_hb->add_child(imported_anim_warning);

	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:") + " ");
	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(1000000);
	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);

	snap_mode = memnew(OptionButton);
	snap_mode->add_item(TTR("Seconds"));
	snap_mode->add_item(TTR("FPS"));
	bottom_hb->add_child(snap_mode);
	snap_mode->connect("item_selected", this, "_snap_mode_changed");
	snap_mode->set_disabled(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));
	animation_changing_awaiting_update = false;
}

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