10 files changed, 851 insertions, 170 deletions

diff --git a/tools/editor/editor_settings.cpp b/tools/editor/editor_settings.cpp
index 139d237989..0b896a725e 100644
--- a/tools/editor/editor_settings.cpp
+++ b/tools/editor/editor_settings.cpp
@@ -419,6 +419,12 @@ void EditorSettings::_load_defaults() {
 	set("3d_editor/zoom_modifier",4);
 	hints["3d_editor/zoom_modifier"]=PropertyInfo(Variant::INT,"3d_editor/zoom_modifier",PROPERTY_HINT_ENUM,"None,Shift,Alt,Meta,Ctrl");
 
+	set("2d_editor/bone_width",5);
+	set("2d_editor/bone_color1",Color(1.0,1.0,1.0,0.9));
+	set("2d_editor/bone_color2",Color(0.75,0.75,0.75,0.9));
+	set("2d_editor/bone_selected_color",Color(0.9,0.45,0.45,0.9));
+	set("2d_editor/bone_ik_color",Color(0.9,0.9,0.45,0.9));
+
 	set("on_save/compress_binary_resources",true);
 	set("on_save/save_modified_external_resources",true);
 	set("on_save/save_paths_as_relative",false);
diff --git a/tools/editor/icons/icon_bone.png b/tools/editor/icons/icon_bone.png
new file mode 100644
index 0000000000..174b0bc167
--- /dev/null
+++ b/tools/editor/icons/icon_bone.png
diff --git a/tools/editor/icons/icon_curve_curve.png b/tools/editor/icons/icon_curve_curve.png
new file mode 100644
index 0000000000..52625a3438
--- /dev/null
+++ b/tools/editor/icons/icon_curve_curve.png
diff --git a/tools/editor/icons/icon_unbone.png b/tools/editor/icons/icon_unbone.png
new file mode 100644
index 0000000000..819e8a8e5d
--- /dev/null
+++ b/tools/editor/icons/icon_unbone.png
diff --git a/tools/editor/plugins/canvas_item_editor_plugin.cpp b/tools/editor/plugins/canvas_item_editor_plugin.cpp
index 6540ae9288..10028a2f21 100644
--- a/tools/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/tools/editor/plugins/canvas_item_editor_plugin.cpp
@@ -35,7 +35,7 @@
 #include "scene/2d/node_2d.h"
 #include "globals.h"
 #include "os/input.h"
-
+#include "tools/editor/editor_settings.h"
 void CanvasItemEditor::_unhandled_key_input(const InputEvent& p_ev) {
 
 	if (!is_visible())
@@ -180,9 +180,9 @@ void CanvasItemEditor::_node_removed(Node *p_node) {
 void CanvasItemEditor::_keying_changed(bool p_changed) {
 
 	if (p_changed)
-		animation_menu->show();
+		animation_hb->show();
 	else
-		animation_menu->hide();
+		animation_hb->hide();
 }
 
 // slow but modern computers should have no problem
@@ -639,30 +639,48 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 
 		if (b.button_index==BUTTON_RIGHT) {
 
+
+
 			if (get_item_count() > 0 && drag!=DRAG_NONE) {
 				//cancel drag
 
+				if (bone_ik_list.size()) {
 
-				List<Node*> &selection = editor_selection->get_selected_node_list();
+					for(List<BoneIK>::Element *E=bone_ik_list.back();E;E=E->prev()) {
 
-				for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+						E->get().node->edit_set_state(E->get().orig_state);
+					}
 
-					CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
-					if (!canvas_item)
-						continue;
-					if (!canvas_item->is_visible())
-						continue;
+					bone_ik_list.clear();
 
-					CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
-					if (!se)
-						continue;
+				} else {
 
-					canvas_item->edit_set_state(se->undo_state);
-					if (canvas_item->cast_to<Node2D>())
-						canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
 
+					List<Node*> &selection = editor_selection->get_selected_node_list();
+
+					for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+
+						CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
+						if (!canvas_item)
+							continue;
+						if (!canvas_item->is_visible())
+							continue;
+
+						CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+						if (!se)
+							continue;
+
+						canvas_item->edit_set_state(se->undo_state);
+						if (canvas_item->cast_to<Node2D>())
+							canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
+
+					}
 				}
 
+				drag=DRAG_NONE;
+				viewport->update();
+				can_move_pivot=false;
+
 			} else if (box_selecting) {
 				box_selecting=false;
 				viewport->update();
@@ -689,34 +707,55 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 
 				if (undo_redo) {
 
-					undo_redo->create_action("Edit CanvasItem");
 
+					if (bone_ik_list.size()) {
 
-					List<Node*> &selection = editor_selection->get_selected_node_list();
 
-					for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+						undo_redo->create_action("Edit IK Chain");
+
+						for(List<BoneIK>::Element *E=bone_ik_list.back();E;E=E->prev()) {
+
+							undo_redo->add_do_method(E->get().node,"edit_set_state",E->get().node->edit_get_state());
+							undo_redo->add_undo_method(E->get().node,"edit_set_state",E->get().orig_state);
+						}
+
+						undo_redo->add_do_method(viewport,"update");
+						undo_redo->add_undo_method(viewport,"update");
+
+						bone_ik_list.clear();
+
+						undo_redo->commit_action();
+					} else {
+
+						undo_redo->create_action("Edit CanvasItem");
 
-						CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
-						if (!canvas_item)
-							continue;
-						if (!canvas_item->is_visible())
-							continue;
-						CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
-						if (!se)
-							continue;
 
-						Variant state=canvas_item->edit_get_state();
-						undo_redo->add_do_method(canvas_item,"edit_set_state",state);
-						undo_redo->add_undo_method(canvas_item,"edit_set_state",se->undo_state);
-						if (canvas_item->cast_to<Node2D>()) {
-							Node2D *pvt = canvas_item->cast_to<Node2D>();
-							if (pvt->edit_has_pivot()) {
-								undo_redo->add_do_method(canvas_item,"edit_set_pivot",pvt->edit_get_pivot());
-								undo_redo->add_undo_method(canvas_item,"edit_set_pivot",se->undo_pivot);
+						List<Node*> &selection = editor_selection->get_selected_node_list();
+
+						for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+
+							CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
+							if (!canvas_item)
+								continue;
+							if (!canvas_item->is_visible())
+								continue;
+							CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+							if (!se)
+								continue;
+
+							Variant state=canvas_item->edit_get_state();
+							undo_redo->add_do_method(canvas_item,"edit_set_state",state);
+							undo_redo->add_undo_method(canvas_item,"edit_set_state",se->undo_state);
+							if (canvas_item->cast_to<Node2D>()) {
+								Node2D *pvt = canvas_item->cast_to<Node2D>();
+								if (pvt->edit_has_pivot()) {
+									undo_redo->add_do_method(canvas_item,"edit_set_pivot",pvt->edit_get_pivot());
+									undo_redo->add_undo_method(canvas_item,"edit_set_pivot",se->undo_pivot);
+								}
 							}
 						}
+						undo_redo->commit_action();
 					}
-					undo_redo->commit_action();
 				}
 
 				drag=DRAG_NONE;
@@ -759,6 +798,86 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 			return;
 		}
 
+
+		List<BoneList>::Element *Cbone=NULL; //closest
+
+		{
+			bone_ik_list.clear();
+			float closest_dist=1e20;
+			int bone_width = EditorSettings::get_singleton()->get("2d_editor/bone_width");
+			for(List<BoneList>::Element *E=bone_list.front();E;E=E->next()) {
+
+				if (E->get().from == E->get().to)
+					continue;
+				Vector2 s[2]={
+					E->get().from,
+					E->get().to
+				};
+
+				Vector2 p = Geometry::get_closest_point_to_segment_2d(Vector2(b.x,b.y),s);
+				float d = p.distance_to(Vector2(b.x,b.y));
+				if (d<bone_width && d<closest_dist) {
+					Cbone=E;
+					closest_dist=d;
+				}
+			}
+
+			if (Cbone) {
+				Node2D *b=NULL;
+				Object* obj=ObjectDB::get_instance(Cbone->get().bone);
+				if (obj)
+					b=obj->cast_to<Node2D>();
+
+				if (b) {
+
+
+					bool ik_found=false;
+					bool first=true;
+
+
+
+					while(b) {
+
+						CanvasItem *pi=b->get_parent_item();
+						if (!pi)
+							break;
+
+						float len=pi->get_global_transform().get_origin().distance_to(b->get_global_pos());
+						b=pi->cast_to<Node2D>();
+						if (!b)
+							break;
+
+						if (first) {
+
+							bone_orig_xform=b->get_global_transform();
+							first=false;
+						}
+
+						BoneIK bik;						
+						bik.node=b;
+						bik.len=len;
+						bik.orig_state=b->edit_get_state();
+
+						bone_ik_list.push_back(bik);
+
+						if (b->has_meta("_edit_ik_")) {
+
+							ik_found=bone_ik_list.size()>1;
+							break;
+						}
+
+						if (!pi->has_meta("_edit_bone_"))
+							break;
+
+					}
+
+					if (!ik_found)
+						bone_ik_list.clear();
+
+				}
+			}
+		}
+
 		CanvasItem *single_item = get_single_item();
 
 		if (single_item) {
@@ -797,7 +916,7 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 					}
 				}
 
-				if (drag!=DRAG_NONE) {
+				if (drag!=DRAG_NONE && (!Cbone || drag!=DRAG_ALL)) {
 					drag_from=transform.affine_inverse().xform(click);
 					se->undo_state=canvas_item->edit_get_state();
 					if (canvas_item->cast_to<Node2D>())
@@ -856,16 +975,30 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 			//no window.... ?
 			click-=current_window->get_scroll();
 		}*/
-		CanvasItem *c=_select_canvas_item_at_pos(click, scene,transform,Matrix32());
+		CanvasItem *c=NULL;
 
+		if (Cbone) {
 
-		CanvasItem* cn = c;
+			Object* obj=ObjectDB::get_instance(Cbone->get().bone);
+			if (obj)
+				c=obj->cast_to<CanvasItem>();
+			if (c)
+				c=c->get_parent_item();
 
-		while(cn) {
-			if (cn->has_meta("_edit_group_")) {
-				c=cn;
+
+		}
+		if (!c) {
+			c =_select_canvas_item_at_pos(click, scene,transform,Matrix32());
+
+
+			CanvasItem* cn = c;
+
+			while(cn) {
+				if (cn->has_meta("_edit_group_")) {
+					c=cn;
+				}
+				cn=cn->get_parent_item();
 			}
-			cn=cn->get_parent_item();
 		}
 
 		Node* n = c;
@@ -989,6 +1122,7 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 
 		List<Node*> &selection = editor_selection->get_selected_node_list();
 
+
 		for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
 
 			CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
@@ -1000,9 +1134,14 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 			if (!se)
 				continue;
 
-			canvas_item->edit_set_state(se->undo_state); //reset state and reapply
-			if (canvas_item->cast_to<Node2D>())
-				canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
+			bool dragging_bone = drag==DRAG_ALL && selection.size()==1 && bone_ik_list.size();
+
+
+			if (!dragging_bone) {
+				canvas_item->edit_set_state(se->undo_state); //reset state and reapply
+				if (canvas_item->cast_to<Node2D>())
+					canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
+			}
 
 
 			Vector2 dfrom = drag_from;
@@ -1153,10 +1292,145 @@ void CanvasItemEditor::_viewport_input_event(const InputEvent& p_event) {
 			}
 
 
-			local_rect.pos=begin;
-			local_rect.size=end-begin;
-			canvas_item->edit_set_rect(local_rect);
 
+
+
+			if (!dragging_bone) {
+
+				local_rect.pos=begin;
+				local_rect.size=end-begin;
+				canvas_item->edit_set_rect(local_rect);
+
+			} else {
+				//ok, all that had to be done was done, now solve IK
+
+
+
+
+				Node2D *n2d = canvas_item->cast_to<Node2D>();
+				Matrix32 final_xform = bone_orig_xform;
+
+
+
+				if (n2d) {
+
+					float total_len = 0;
+					for (List<BoneIK>::Element *E=bone_ik_list.front();E;E=E->next()) {
+						if (E->prev())
+							total_len+=E->get().len;
+						E->get().pos = E->get().node->get_global_transform().get_origin();
+					}
+
+					{
+
+						final_xform.elements[2]+=dto-dfrom;//final_xform.affine_inverse().basis_xform_inv(drag_vector);
+						//n2d->set_global_transform(final_xform);
+
+					}
+
+
+					CanvasItem *last = bone_ik_list.back()->get().node;
+					if (!last)
+						break;
+
+					Vector2 root_pos = last->get_global_transform().get_origin();
+					Vector2 leaf_pos = final_xform.get_origin();
+
+					if ((leaf_pos.distance_to(root_pos)) > total_len) {
+						//oops dude you went too far
+						//print_line("TOO FAR!");
+						Vector2 rel = leaf_pos - root_pos;
+						rel = rel.normalized() * total_len;
+						leaf_pos=root_pos+rel;
+
+					}
+
+					bone_ik_list.front()->get().pos=leaf_pos;
+
+					//print_line("BONE IK LIST "+itos(bone_ik_list.size()));
+
+
+					if (bone_ik_list.size()>2) {
+						int solver_iterations=64;
+						float solver_k=0.3;
+
+						for(int i=0;i<solver_iterations;i++) {
+
+							for (List<BoneIK>::Element *E=bone_ik_list.front();E;E=E->next()) {
+
+
+
+								if (E==bone_ik_list.back()) {
+
+									break;
+								}
+
+								float len = E->next()->get().len;
+
+								if (E->next()==bone_ik_list.back()) {
+
+									//print_line("back");
+
+									Vector2 rel = E->get().pos - E->next()->get().pos;
+									//print_line("PREV "+E->get().pos);
+									Vector2 desired = E->next()->get().pos+rel.normalized()*len;
+									//print_line("DESIRED "+desired);
+									E->get().pos=E->get().pos.linear_interpolate(desired,solver_k);
+									//print_line("POST "+E->get().pos);
+
+
+								} else if (E==bone_ik_list.front()) {
+									//only adjust parent
+									//print_line("front");
+									Vector2 rel = E->next()->get().pos - E->get().pos;
+									//print_line("PREV "+E->next()->get().pos);
+									Vector2 desired = E->get().pos+rel.normalized()*len;
+									//print_line("DESIRED "+desired);
+									E->next()->get().pos=E->next()->get().pos.linear_interpolate(desired,solver_k);
+									//print_line("POST "+E->next()->get().pos);
+								} else {
+
+									Vector2 rel = E->next()->get().pos - E->get().pos;
+									Vector2 cen = (E->next()->get().pos + E->get().pos)*0.5;
+									rel=rel.linear_interpolate(rel.normalized()*len,solver_k);
+									rel*=0.5;
+									E->next()->get().pos=cen+rel;
+									E->get().pos=cen-rel;
+									//print_line("mid");
+
+								}
+							}
+						}
+					}
+				}
+
+				for (List<BoneIK>::Element *E=bone_ik_list.back();E;E=E->prev()) {
+
+					Node2D *n = E->get().node;
+
+					if (!E->prev()) {
+						//last goes to what it was
+						final_xform.set_origin(n->get_global_pos());
+						n->set_global_transform(final_xform);
+
+					} else {
+						Vector2 rel = (E->prev()->get().node->get_global_pos() - n->get_global_pos()).normalized();
+						Vector2 rel2 = (E->prev()->get().pos - E->get().pos).normalized();
+						float rot = rel.angle_to(rel2);
+						if (n->get_global_transform().basis_determinant()<0) {
+							//mirrored, rotate the other way
+							rot=-rot;
+						}
+
+						n->rotate(rot);
+					}
+
+				}
+
+
+
+				break;
+			}
 		}
 	}
 
@@ -1393,7 +1667,77 @@ void CanvasItemEditor::_viewport_draw() {
 
 	}
 
+	int bone_width = EditorSettings::get_singleton()->get("2d_editor/bone_width");
+	Color bone_color1 = EditorSettings::get_singleton()->get("2d_editor/bone_color1");
+	Color bone_color2 = EditorSettings::get_singleton()->get("2d_editor/bone_color2");
+	Color bone_ik_color = EditorSettings::get_singleton()->get("2d_editor/bone_ik_color");
+	Color bone_selected_color = EditorSettings::get_singleton()->get("2d_editor/bone_selected_color");
+
+	for(List<BoneList>::Element*E=bone_list.front();E;E=E->next()) {
+
+		E->get().from=Vector2();
+		E->get().to=Vector2();
+
+		Object *obj = ObjectDB::get_instance(E->get().bone);
+		if (!obj)
+			continue;
+
+		Node2D* n2d = obj->cast_to<Node2D>();
+		if (!n2d)
+			continue;
+
+		if (!n2d->get_parent())
+			continue;
+
+		CanvasItem *pi = n2d->get_parent_item();
+
+
+		Node2D* pn2d=n2d->get_parent()->cast_to<Node2D>();
+
+		if (!pn2d)
+			continue;
+
+		Vector2 from = transform.xform(pn2d->get_global_pos());
+		Vector2 to = transform.xform(n2d->get_global_pos());
+
+		E->get().from=from;
+		E->get().to=to;
+
+		Vector2 rel = to-from;
+		Vector2 relt = rel.tangent().normalized()*bone_width;
+
+
+
+		Vector<Vector2> bone_shape;
+		bone_shape.push_back(from);
+		bone_shape.push_back(from+rel*0.2+relt);
+		bone_shape.push_back(to);
+		bone_shape.push_back(from+rel*0.2-relt);
+		Vector<Color> colors;
+		if (pi->has_meta("_edit_ik_")) {
+
+			colors.push_back(bone_ik_color);
+			colors.push_back(bone_ik_color);
+			colors.push_back(bone_ik_color);
+			colors.push_back(bone_ik_color);
+		} else {
+			colors.push_back(bone_color1);
+			colors.push_back(bone_color2);
+			colors.push_back(bone_color1);
+			colors.push_back(bone_color2);
+		}
+
+
+		VisualServer::get_singleton()->canvas_item_add_primitive(ci,bone_shape,colors,Vector<Vector2>(),RID());
 
+		if (editor_selection->is_selected(pi)) {
+			for(int i=0;i<bone_shape.size();i++) {
+
+				VisualServer::get_singleton()->canvas_item_add_line(ci,bone_shape[i],bone_shape[(i+1)%bone_shape.size()],bone_selected_color,2);
+			}
+		}
+
+	}
 }
 
 void CanvasItemEditor::_notification(int p_what) {
@@ -1445,6 +1789,7 @@ void CanvasItemEditor::_notification(int p_what) {
 		unlock_button->set_icon(get_icon("Unlock","EditorIcons"));
 		group_button->set_icon(get_icon("Group","EditorIcons"));
 		ungroup_button->set_icon(get_icon("Ungroup","EditorIcons"));
+		key_insert_button->set_icon(get_icon("Key","EditorIcons"));
 
 	}
 
@@ -1509,6 +1854,13 @@ void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2& r_rect, cons
 			lock_list.push_back(lock);
 		}
 
+		if (c->has_meta("_edit_bone_")) {
+
+			BoneList bone;
+			bone.bone=c->get_instance_ID();
+			bone_list.push_back(bone);
+		}
+
 		r_rect.expand_to( xform.xform(rect.pos) );
 		r_rect.expand_to( xform.xform(rect.pos+Point2(rect.size.x,0)) );
 		r_rect.expand_to( xform.xform(rect.pos+Point2(0,rect.size.y)) );
@@ -1541,6 +1893,7 @@ void CanvasItemEditor::_update_scrollbars() {
 	Rect2 canvas_item_rect=Rect2(Point2(),screen_rect);
 
 	lock_list.clear();;
+	bone_list.clear();;
 
 	if (editor->get_edited_scene())
 		_find_canvas_items_span(editor->get_edited_scene(),canvas_item_rect,Matrix32());
@@ -1878,6 +2231,44 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 						editor->get_animation_editor()->insert_node_value_key(n2d,"transform/rot",Math::rad2deg(n2d->get_rot()),existing);
 					if (key_scale)
 						editor->get_animation_editor()->insert_node_value_key(n2d,"transform/scale",n2d->get_scale(),existing);
+
+
+					if (n2d->has_meta("_edit_bone_") && n2d->get_parent_item()) {
+						//look for an IK chain
+						List<Node2D*> ik_chain;
+
+						Node2D *n = n2d->get_parent_item()->cast_to<Node2D>();
+						bool has_chain=false;
+
+						while(n) {
+
+							ik_chain.push_back(n);
+							if (n->has_meta("_edit_ik_")) {
+								has_chain=true;
+								break;
+							}
+
+							if (!n->get_parent_item())
+								break;
+							n=n->get_parent_item()->cast_to<Node2D>();
+						}
+
+						if (has_chain && ik_chain.size()) {
+
+							for(List<Node2D*>::Element *F=ik_chain.front();F;F=F->next()) {
+
+								if (key_pos)
+									editor->get_animation_editor()->insert_node_value_key(F->get(),"transform/pos",F->get()->get_pos(),existing);
+								if (key_rot)
+									editor->get_animation_editor()->insert_node_value_key(F->get(),"transform/rot",Math::rad2deg(F->get()->get_rot()),existing);
+								if (key_scale)
+									editor->get_animation_editor()->insert_node_value_key(F->get(),"transform/scale",F->get()->get_scale(),existing);
+
+
+							}
+						}
+					}
+
 				} else if (canvas_item->cast_to<Control>()) {
 
 					Control *ctrl = canvas_item->cast_to<Control>();
@@ -1891,10 +2282,20 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 			}
 
 		} break;
-		case ANIM_INSERT_POS:
-		case ANIM_INSERT_ROT:
-		case ANIM_INSERT_SCALE:
-		case ANIM_INSERT_POS_ROT:
+		case ANIM_INSERT_POS: {
+
+			key_pos = key_loc_button->is_pressed();
+		} break;
+		case ANIM_INSERT_ROT: {
+
+			key_pos = key_rot_button->is_pressed();
+		} break;
+		case ANIM_INSERT_SCALE: {
+
+			key_scale = key_scale_button->is_pressed();
+		} break;
+			/*
+		case ANIM_INSERT_POS_ROT
 		case ANIM_INSERT_POS_SCALE:
 		case ANIM_INSERT_ROT_SCALE:
 		case ANIM_INSERT_POS_ROT_SCALE: {
@@ -1917,7 +2318,7 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				animation_menu->get_popup()->set_item_checked(idx,i==p_op);
 			}
 
-		} break;
+		} break;*/
 		case ANIM_COPY_POSE: {
 
 			pose_clipboard.clear();;
@@ -2061,6 +2462,85 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 			}
 
 		} break;
+		case SKELETON_MAKE_BONES: {
+
+
+
+			Map<Node*,Object*> &selection = editor_selection->get_selection();
+
+			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+
+				Node2D *n2d = E->key()->cast_to<Node2D>();
+				if (!n2d)
+					continue;
+				if (!n2d->is_visible())
+					continue;
+				if (!n2d->get_parent_item())
+					continue;
+
+				n2d->set_meta("_edit_bone_",true);
+
+			}
+			viewport->update();
+
+		} break;
+		case SKELETON_CLEAR_BONES: {
+
+			Map<Node*,Object*> &selection = editor_selection->get_selection();
+
+			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+
+				Node2D *n2d = E->key()->cast_to<Node2D>();
+				if (!n2d)
+					continue;
+				if (!n2d->is_visible())
+					continue;
+
+				n2d->set_meta("_edit_bone_",Variant());
+
+			}
+			viewport->update();
+
+		} break;
+		case SKELETON_SET_IK_CHAIN: {
+
+			List<Node*> &selection = editor_selection->get_selected_node_list();
+
+			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+
+				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
+				if (!canvas_item)
+					continue;
+				if (!canvas_item->is_visible())
+					continue;
+
+
+				canvas_item->set_meta("_edit_ik_",true);
+
+			}
+
+			viewport->update();
+
+		} break;
+		case SKELETON_CLEAR_IK_CHAIN: {
+
+			Map<Node*,Object*> &selection = editor_selection->get_selection();
+
+			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+
+				CanvasItem *n2d = E->key()->cast_to<CanvasItem>();
+				if (!n2d)
+					continue;
+				if (!n2d->is_visible())
+					continue;
+
+				n2d->set_meta("_edit_ik_",Variant());
+
+			}
+			viewport->update();
+
+		} break;
+
 	}
 }
 #if 0
@@ -2296,6 +2776,18 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_check_item("Use Pixel Snap",SNAP_USE_PIXEL);
 	p->add_separator();
 	p->add_item("Expand to Parent",EXPAND_TO_PARENT,KEY_MASK_CMD|KEY_P);
+	p->add_separator();
+	p->add_submenu_item("Skeleton..","skeleton");
+	PopupMenu *p2 = memnew(PopupMenu);
+	p->add_child(p2);
+	p2->set_name("skeleton");
+	p2->add_item("Make Bones",SKELETON_MAKE_BONES,KEY_MASK_CMD|KEY_SHIFT|KEY_B);
+	p2->add_item("Clear Bones",SKELETON_CLEAR_BONES);
+	p2->add_separator();
+	p2->add_item("Make IK Chain",SKELETON_SET_IK_CHAIN);
+	p2->add_item("Clear IK Chain",SKELETON_CLEAR_IK_CHAIN);
+	p2->connect("item_pressed", this,"_popup_callback");
+
 
 	/*
 	p->add_item("Align Horizontal",ALIGN_HORIZONTAL);
@@ -2314,12 +2806,50 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_item("Zoom Out",ZOOM_OUT);
 	p->add_item("Zoom Reset",ZOOM_RESET);
 	p->add_item("Zoom Set..",ZOOM_SET);
+	p->add_separator();
 	p->add_item("Center Selection", VIEW_CENTER_TO_SELECTION, KEY_F);
 	p->add_item("Frame Selection", VIEW_FRAME_TO_SELECTION, KEY_MASK_CMD|KEY_F);
 
+
+
+	animation_hb = memnew( HBoxContainer );
+	hb->add_child(animation_hb);
+	animation_hb->add_child( memnew( VSeparator ));
+	animation_hb->hide();
+
+	key_loc_button = memnew( Button("loc"));
+	key_loc_button->set_toggle_mode(true);
+	key_loc_button->set_pressed(true);
+	key_loc_button->set_focus_mode(FOCUS_NONE);
+	key_loc_button->add_color_override("font_color",Color(1,0.6,0.6));
+	key_loc_button->add_color_override("font_color_pressed",Color(0.6,1,0.6));
+	key_loc_button->connect("pressed",this,"_popup_callback",varray(ANIM_INSERT_POS));
+	animation_hb->add_child(key_loc_button);
+	key_rot_button = memnew( Button("rot"));
+	key_rot_button->set_toggle_mode(true);
+	key_rot_button->set_pressed(true);
+	key_rot_button->set_focus_mode(FOCUS_NONE);
+	key_rot_button->add_color_override("font_color",Color(1,0.6,0.6));
+	key_rot_button->add_color_override("font_color_pressed",Color(0.6,1,0.6));
+	key_rot_button->connect("pressed",this,"_popup_callback",varray(ANIM_INSERT_ROT));
+	animation_hb->add_child(key_rot_button);
+	key_scale_button = memnew( Button("scl"));
+	key_scale_button->set_toggle_mode(true);
+	key_scale_button->set_focus_mode(FOCUS_NONE);
+	key_scale_button->add_color_override("font_color",Color(1,0.6,0.6));
+	key_scale_button->add_color_override("font_color_pressed",Color(0.6,1,0.6));
+	key_scale_button->connect("pressed",this,"_popup_callback",varray(ANIM_INSERT_SCALE));
+	animation_hb->add_child(key_scale_button);
+	key_insert_button = memnew( Button );
+	key_insert_button->set_focus_mode(FOCUS_NONE);
+	key_insert_button->connect("pressed",this,"_popup_callback",varray(ANIM_INSERT_KEY));
+	key_insert_button->set_tooltip("Insert Keys (Insert)");
+
+	animation_hb->add_child(key_insert_button);
+
 	animation_menu = memnew( MenuButton );
 	animation_menu->set_text("Animation");
-	hb->add_child(animation_menu);
+	animation_hb->add_child(animation_menu);
 	animation_menu->get_popup()->connect("item_pressed", this,"_popup_callback");
 
 	p = animation_menu->get_popup();
@@ -2327,22 +2857,10 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_item("Insert Key",ANIM_INSERT_KEY,KEY_INSERT);
 	p->add_item("Insert Key (Existing Tracks)",ANIM_INSERT_KEY_EXISTING,KEY_MASK_CMD+KEY_INSERT);
 	p->add_separator();
-	p->add_check_item("Pos",ANIM_INSERT_POS);
-	p->add_check_item("Rot",ANIM_INSERT_ROT);
-	p->add_check_item("Scale",ANIM_INSERT_SCALE);
-	p->add_check_item("Pos+Rot",ANIM_INSERT_POS_ROT);
-	p->set_item_checked(p->get_item_index(ANIM_INSERT_POS_ROT),true);
-	p->add_check_item("Pos+Scale",ANIM_INSERT_POS_SCALE);
-	p->add_check_item("Rot+Scale",ANIM_INSERT_ROT_SCALE);
-	p->add_check_item("Loc+Rot+Scale",ANIM_INSERT_POS_ROT_SCALE);
-	p->add_separator();
 	p->add_item("Copy Pose",ANIM_COPY_POSE);
 	p->add_item("Paste Pose",ANIM_PASTE_POSE);
 	p->add_item("Clear Pose",ANIM_CLEAR_POSE,KEY_MASK_ALT|KEY_K);
 
-	animation_menu->hide();
-
-
 	value_dialog = memnew( AcceptDialog );
 	value_dialog->set_title("Set a Value");
 	value_dialog->get_ok()->set_text("Close");
diff --git a/tools/editor/plugins/canvas_item_editor_plugin.h b/tools/editor/plugins/canvas_item_editor_plugin.h
index 3d9b50c01c..425e691f07 100644
--- a/tools/editor/plugins/canvas_item_editor_plugin.h
+++ b/tools/editor/plugins/canvas_item_editor_plugin.h
@@ -95,15 +95,15 @@ class CanvasItemEditor : public VBoxContainer {
 		ANIM_INSERT_POS,
 		ANIM_INSERT_ROT,
 		ANIM_INSERT_SCALE,
-		ANIM_INSERT_POS_ROT,
-		ANIM_INSERT_POS_SCALE,
-		ANIM_INSERT_ROT_SCALE,
-		ANIM_INSERT_POS_ROT_SCALE,
 		ANIM_COPY_POSE,
 		ANIM_PASTE_POSE,
 		ANIM_CLEAR_POSE,
 		VIEW_CENTER_TO_SELECTION,
 		VIEW_FRAME_TO_SELECTION,
+		SKELETON_MAKE_BONES,
+		SKELETON_CLEAR_BONES,
+		SKELETON_SET_IK_CHAIN,
+		SKELETON_CLEAR_IK_CHAIN
 
 	};
 
@@ -165,6 +165,26 @@ class CanvasItemEditor : public VBoxContainer {
 
 	List<LockList> lock_list;
 
+	struct BoneList {
+
+		Vector2 from;
+		Vector2 to;
+		ObjectID bone;
+	};
+
+	List<BoneList> bone_list;
+	Matrix32 bone_orig_xform;
+
+	struct BoneIK {
+
+		Variant orig_state;
+		Vector2 pos;
+		float len;
+		Node2D *node;
+	};
+
+	List<BoneIK> bone_ik_list;
+
 	struct PoseClipboard {
 
 		Vector2 pos;
@@ -189,7 +209,14 @@ class CanvasItemEditor : public VBoxContainer {
 
 	MenuButton *edit_menu;
 	MenuButton *view_menu;
+	HBoxContainer *animation_hb;
 	MenuButton *animation_menu;
+
+	Button *key_loc_button;
+	Button *key_rot_button;
+	Button *key_scale_button;
+	Button *key_insert_button;
+
 	//PopupMenu *popup;
 	DragType drag;
 	Point2 drag_from;
diff --git a/tools/editor/plugins/path_2d_editor_plugin.cpp b/tools/editor/plugins/path_2d_editor_plugin.cpp
index 5e4cd98127..33ea5f3588 100644
--- a/tools/editor/plugins/path_2d_editor_plugin.cpp
+++ b/tools/editor/plugins/path_2d_editor_plugin.cpp
@@ -31,7 +31,7 @@
 #include "canvas_item_editor_plugin.h"
 #include "os/file_access.h"
 #include "tools/editor/editor_settings.h"
-
+#include "os/keyboard.h"
 void Path2DEditor::_notification(int p_what) {
 
 	switch(p_what) {
@@ -103,7 +103,7 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 
 			// Test move point!!
 
-			if ( mb.pressed && mb.button_index==BUTTON_LEFT ) {
+			if ( mb.pressed && action==ACTION_NONE ) {
 
 				Ref<Curve2D> curve = node->get_curve();
 
@@ -115,21 +115,30 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 						Point2 p = xform.xform( curve->get_point_pos(i) );
 						if (gpoint.distance_to(p) < grab_treshold ) {
 
-							if (!mb.mod.shift) {
+							if (mb.button_index==BUTTON_LEFT && !mb.mod.shift && mode==MODE_EDIT) {
 
 								action=ACTION_MOVING_POINT;
 								action_point=i;
 								moving_from=curve->get_point_pos(i);
 								moving_screen_from=gpoint;
 								return true;
+							} else if  ((mb.button_index==BUTTON_RIGHT && mode==MODE_EDIT) || (mb.button_index==BUTTON_LEFT && mode==MODE_DELETE)) {
+
+								undo_redo->create_action("Remove Point from Curve");
+								undo_redo->add_do_method(curve.ptr(),"remove_point",i);
+								undo_redo->add_undo_method(curve.ptr(),"add_point",curve->get_point_pos(i),curve->get_point_in(i),curve->get_point_out(i),i);
+								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->commit_action();
+								return true;
 							} else
 								pointunder=true;
 						}
 					}
 
-					if (i<(curve->get_point_count()-1)) {
+					if (mb.button_index==BUTTON_LEFT && i<(curve->get_point_count()-1)) {
 						Point2 p = xform.xform( curve->get_point_pos(i)+curve->get_point_out(i) );
-						if (gpoint.distance_to(p) < grab_treshold ) {
+						if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode==MODE_EDIT_CURVE) ) {
 
 							action=ACTION_MOVING_OUT;
 							action_point=i;
@@ -139,9 +148,9 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 						}
 					}
 
-					if (i>0) {
+					if (mb.button_index==BUTTON_LEFT && i>0) {
 						Point2 p = xform.xform( curve->get_point_pos(i)+curve->get_point_in(i) );
-						if (gpoint.distance_to(p) < grab_treshold ) {
+						if (gpoint.distance_to(p) < grab_treshold && (mode == MODE_EDIT || mode==MODE_EDIT_CURVE)) {
 
 							action=ACTION_MOVING_IN;
 							action_point=i;
@@ -160,15 +169,15 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 
 			// Test add point in empty space!
 
-			if ( mb.pressed && mb.mod.control && mb.button_index==BUTTON_LEFT ) {
+			if ( mb.pressed && mb.button_index==BUTTON_LEFT && ((mb.mod.command && mode == MODE_EDIT) || mode == MODE_CREATE)) {
 
 				Ref<Curve2D> curve = node->get_curve();
 
 				undo_redo->create_action("Add Point to Curve");
 				undo_redo->add_do_method(curve.ptr(),"add_point",cpoint);
 				undo_redo->add_undo_method(curve.ptr(),"remove_point",curve->get_point_count());
-				undo_redo->add_do_method(canvas_item_editor,"update");
-				undo_redo->add_undo_method(canvas_item_editor,"update");
+				undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+				undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 				undo_redo->commit_action();
 
 				action=ACTION_MOVING_POINT;
@@ -195,8 +204,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 						undo_redo->create_action("Move Point in Curve");
 						undo_redo->add_do_method(curve.ptr(),"set_point_pos",action_point,cpoint);
 						undo_redo->add_undo_method(curve.ptr(),"set_point_pos",action_point,moving_from);
-						undo_redo->add_do_method(canvas_item_editor,"update");
-						undo_redo->add_undo_method(canvas_item_editor,"update");
+						undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+						undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 						undo_redo->commit_action();
 
 					} break;
@@ -205,8 +214,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 						undo_redo->create_action("Move In-Control in Curve");
 						undo_redo->add_do_method(curve.ptr(),"set_point_in",action_point,new_pos);
 						undo_redo->add_undo_method(curve.ptr(),"set_point_in",action_point,moving_from);
-						undo_redo->add_do_method(canvas_item_editor,"update");
-						undo_redo->add_undo_method(canvas_item_editor,"update");
+						undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+						undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 						undo_redo->commit_action();
 
 					} break;
@@ -215,8 +224,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 						undo_redo->create_action("Move Out-Control in Curve");
 						undo_redo->add_do_method(curve.ptr(),"set_point_out",action_point,new_pos);
 						undo_redo->add_undo_method(curve.ptr(),"set_point_out",action_point,moving_from);
-						undo_redo->add_do_method(canvas_item_editor,"update");
-						undo_redo->add_undo_method(canvas_item_editor,"update");
+						undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+						undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 						undo_redo->commit_action();
 
 					} break;
@@ -286,8 +295,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 									undo_redo->add_undo_method(node,"set_polygon",poly);
 									poly.push_back(cpoint);
 									undo_redo->add_do_method(node,"set_polygon",poly);
-									undo_redo->add_do_method(canvas_item_editor,"update");
-									undo_redo->add_undo_method(canvas_item_editor,"update");
+									undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+									undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 									undo_redo->commit_action();
 									return true;
 								}
@@ -365,8 +374,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 								undo_redo->create_action("Edit Poly");
 								undo_redo->add_do_method(node,"set_polygon",poly);
 								undo_redo->add_undo_method(node,"set_polygon",pre_move_edit);
-								undo_redo->add_do_method(canvas_item_editor,"update");
-								undo_redo->add_undo_method(canvas_item_editor,"update");
+								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 								undo_redo->commit_action();
 
 								edited_point=-1;
@@ -400,8 +409,8 @@ bool Path2DEditor::forward_input_event(const InputEvent& p_event) {
 							undo_redo->add_undo_method(node,"set_polygon",poly);
 							poly.remove(closest_idx);
 							undo_redo->add_do_method(node,"set_polygon",poly);
-							undo_redo->add_do_method(canvas_item_editor,"update");
-							undo_redo->add_undo_method(canvas_item_editor,"update");
+							undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+							undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
 							undo_redo->commit_action();
 							return true;
 						}
@@ -554,6 +563,60 @@ void Path2DEditor::_bind_methods() {
 	//ObjectTypeDB::bind_method(_MD("_menu_option"),&Path2DEditor::_menu_option);
 	ObjectTypeDB::bind_method(_MD("_canvas_draw"),&Path2DEditor::_canvas_draw);
 	ObjectTypeDB::bind_method(_MD("_node_visibility_changed"),&Path2DEditor::_node_visibility_changed);
+	ObjectTypeDB::bind_method(_MD("_mode_selected"),&Path2DEditor::_mode_selected);
+}
+
+void Path2DEditor::_mode_selected(int p_mode) {
+
+	if (p_mode==MODE_CREATE) {
+
+		curve_create->set_pressed(true);
+		curve_edit->set_pressed(false);
+		curve_edit_curve->set_pressed(false);
+		curve_del->set_pressed(false);
+	} else if (p_mode==MODE_EDIT) {
+
+		curve_create->set_pressed(false);
+		curve_edit->set_pressed(true);
+		curve_edit_curve->set_pressed(false);
+		curve_del->set_pressed(false);
+	} else if (p_mode==MODE_EDIT_CURVE) {
+
+		curve_create->set_pressed(false);
+		curve_edit->set_pressed(false);
+		curve_edit_curve->set_pressed(true);
+		curve_del->set_pressed(false);
+	} else if (p_mode==MODE_DELETE) {
+
+		curve_create->set_pressed(false);
+		curve_edit->set_pressed(false);
+		curve_edit_curve->set_pressed(false);
+		curve_del->set_pressed(true);
+	} else if (p_mode==ACTION_CLOSE) {
+
+		//?
+
+		if (!node->get_curve().is_valid())
+			return ;
+		if (node->get_curve()->get_point_count()<3)
+			return;
+
+		Vector2 begin = node->get_curve()->get_point_pos(0);
+		Vector2 end = node->get_curve()->get_point_pos( node->get_curve()->get_point_count() -1 );
+		if (begin.distance_to(end)<CMP_EPSILON)
+			return;
+
+		undo_redo->create_action("Remove Point from Curve");
+		undo_redo->add_do_method(node->get_curve().ptr(),"add_point",begin);
+		undo_redo->add_undo_method(node->get_curve().ptr(),"remove_point",node->get_curve()->get_point_count());
+		undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+		undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+		undo_redo->commit_action();
+		return;
+	}
+
+	mode=Mode(p_mode);
+
 }
 
 Path2DEditor::Path2DEditor(EditorNode *p_editor) {
@@ -573,6 +636,50 @@ Path2DEditor::Path2DEditor(EditorNode *p_editor) {
 	options->get_popup()->connect("item_pressed", this,"_menu_option");
 #endif
 
+	base_hb = memnew( HBoxContainer );
+	CanvasItemEditor::get_singleton()->add_control_to_menu_panel(base_hb);
+
+	sep = memnew( VSeparator);
+	base_hb->add_child(sep);
+	curve_edit = memnew( ToolButton );
+	curve_edit->set_icon(CanvasItemEditor::get_singleton()->get_icon("CurveEdit","EditorIcons"));
+	curve_edit->set_toggle_mode(true);
+	curve_edit->set_focus_mode(Control::FOCUS_NONE);
+	curve_edit->set_tooltip("Select Points\nShift+Drag: Select Control Points\n"+keycode_get_string(KEY_MASK_CMD)+"Click: Add Point\nRight Click: Delete Point.");
+	curve_edit->connect("pressed",this,"_mode_selected",varray(MODE_EDIT));
+	base_hb->add_child(curve_edit);
+	curve_edit_curve = memnew( ToolButton );
+	curve_edit_curve->set_icon(CanvasItemEditor::get_singleton()->get_icon("CurveCurve","EditorIcons"));
+	curve_edit_curve->set_toggle_mode(true);
+	curve_edit_curve->set_focus_mode(Control::FOCUS_NONE);
+	curve_edit_curve->set_tooltip("Select Control Points (Shift+Drag)");
+	curve_edit_curve->connect("pressed",this,"_mode_selected",varray(MODE_EDIT_CURVE));
+	base_hb->add_child(curve_edit_curve);
+	curve_create = memnew( ToolButton );
+	curve_create->set_icon(CanvasItemEditor::get_singleton()->get_icon("CurveCreate","EditorIcons"));
+	curve_create->set_toggle_mode(true);
+	curve_create->set_focus_mode(Control::FOCUS_NONE);
+	curve_create->set_tooltip("Add Point (in empty space)\nSplit Segment (in curve).");
+	curve_create->connect("pressed",this,"_mode_selected",varray(MODE_CREATE));
+	base_hb->add_child(curve_create);
+	curve_del = memnew( ToolButton );
+	curve_del->set_icon(CanvasItemEditor::get_singleton()->get_icon("CurveDelete","EditorIcons"));
+	curve_del->set_toggle_mode(true);
+	curve_del->set_focus_mode(Control::FOCUS_NONE);
+	curve_del->set_tooltip("Delete Point.");
+	curve_del->connect("pressed",this,"_mode_selected",varray(MODE_DELETE));
+	base_hb->add_child(curve_del);
+	curve_close = memnew( ToolButton );
+	curve_close->set_icon(CanvasItemEditor::get_singleton()->get_icon("CurveClose","EditorIcons"));
+	curve_close->set_focus_mode(Control::FOCUS_NONE);
+	curve_close->set_tooltip("Close Curve");
+	curve_close->connect("pressed",this,"_mode_selected",varray(ACTION_CLOSE));
+	base_hb->add_child(curve_close);
+	base_hb->hide();
+
+
+
+	curve_edit->set_pressed(true);
 
 
 }
@@ -592,9 +699,12 @@ void Path2DEditorPlugin::make_visible(bool p_visible) {
 
 	if (p_visible) {
 		path2d_editor->show();
+		path2d_editor->base_hb->show();
+
 	} else {
 
 		path2d_editor->hide();
+		path2d_editor->base_hb->hide();
 		path2d_editor->edit(NULL);
 	}
 
@@ -605,8 +715,9 @@ Path2DEditorPlugin::Path2DEditorPlugin(EditorNode *p_node) {
 	editor=p_node;
 	path2d_editor = memnew( Path2DEditor(p_node) );
 	CanvasItemEditor::get_singleton()->add_control_to_menu_panel(path2d_editor);
-
 	path2d_editor->hide();
+
+
 }
 
 
diff --git a/tools/editor/plugins/path_2d_editor_plugin.h b/tools/editor/plugins/path_2d_editor_plugin.h
index 1ddda3f65f..73de2cc838 100644
--- a/tools/editor/plugins/path_2d_editor_plugin.h
+++ b/tools/editor/plugins/path_2d_editor_plugin.h
@@ -51,6 +51,24 @@ class Path2DEditor : public HBoxContainer {
 	Panel *panel;
 	Path2D *node;
 
+	HBoxContainer *base_hb;
+	Separator *sep;
+
+	enum Mode {
+		MODE_CREATE,
+		MODE_EDIT,
+		MODE_EDIT_CURVE,
+		MODE_DELETE,
+		ACTION_CLOSE
+	};
+
+	Mode mode;
+	ToolButton *curve_create;
+	ToolButton *curve_edit;
+	ToolButton *curve_edit_curve;
+	ToolButton *curve_del;
+	ToolButton *curve_close;
+
 	enum Action {
 
 		ACTION_NONE,
@@ -65,10 +83,11 @@ class Path2DEditor : public HBoxContainer {
 	Point2 moving_from;
 	Point2 moving_screen_from;
 
+	void _mode_selected(int p_mode);
 
 	void _canvas_draw();
 	void _node_visibility_changed();
-
+friend class Path2DEditorPlugin;
 protected:
 	void _notification(int p_what);
 	void _node_removed(Node *p_node);
diff --git a/tools/editor/plugins/path_editor_plugin.cpp b/tools/editor/plugins/path_editor_plugin.cpp
index 61b1df9ca8..7b0ff971d2 100644
--- a/tools/editor/plugins/path_editor_plugin.cpp
+++ b/tools/editor/plugins/path_editor_plugin.cpp
@@ -564,12 +564,12 @@ PathEditorPlugin::PathEditorPlugin(EditorNode *p_node) {
 	curve_del->set_focus_mode(Control::FOCUS_NONE);

 	curve_del->set_tooltip("Delete Point.");

 	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_del);

-    curve_close = memnew( ToolButton );

+	curve_close = memnew( ToolButton );

 	curve_close->set_icon(SpatialEditor::get_singleton()->get_icon("CurveClose","EditorIcons"));

 	curve_close->hide();

-    curve_close->set_focus_mode(Control::FOCUS_NONE);

-    curve_close->set_tooltip("Close Curve");

-    SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_close);

+	curve_close->set_focus_mode(Control::FOCUS_NONE);

+	curve_close->set_tooltip("Close Curve");

+	SpatialEditor::get_singleton()->add_control_to_menu_panel(curve_close);

 

 

 

diff --git a/tools/editor/plugins/path_editor_plugin.h b/tools/editor/plugins/path_editor_plugin.h
index b938358d37..d730d33551 100644
--- a/tools/editor/plugins/path_editor_plugin.h
+++ b/tools/editor/plugins/path_editor_plugin.h
@@ -26,74 +26,74 @@
 /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
 /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
 /*************************************************************************/
-#ifndef PATH_EDITOR_PLUGIN_H

-#define PATH_EDITOR_PLUGIN_H

-

-

-#include "tools/editor/spatial_editor_gizmos.h"

-#include "scene/3d/path.h"

-class PathSpatialGizmo  : public SpatialGizmoTool {

-

-	OBJ_TYPE(PathSpatialGizmo,SpatialGizmoTool);

-

-	Path* path;

-	mutable Vector3 original;

-

-public:

-

-	virtual String get_handle_name(int p_idx) const;

-	virtual Variant get_handle_value(int p_idx) const;

-	virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);

-	virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);

-

-	void redraw();

-	PathSpatialGizmo(Path* p_path=NULL);

-

-};

-

-class PathEditorPlugin : public EditorPlugin {

-

-	OBJ_TYPE( PathEditorPlugin, EditorPlugin );

-

-

-	Separator *sep;

-	ToolButton *curve_create;

-	ToolButton *curve_edit;

-	ToolButton *curve_del;

-    ToolButton *curve_close;

-

-	EditorNode *editor;

-

-

-	Path *path;

-

-	void _mode_changed(int p_idx);

-    void _close_curve();

-protected:

-	void _notification(int p_what);

-	static void _bind_methods();

-

-public:

-

-	Path *get_edited_path() { return path; }

-

-	static PathEditorPlugin* singleton;

-	Ref<FixedMaterial> path_material;

-	Ref<FixedMaterial> path_thin_material;

-	virtual bool forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event);

-

-//	virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); }

-	virtual bool create_spatial_gizmo(Spatial* p_spatial);

-	virtual String get_name() const { return "Path"; }

-	bool has_main_screen() const { return false; }

-	virtual void edit(Object *p_node);

-	virtual bool handles(Object *p_node) const;

-	virtual void make_visible(bool p_visible);

-

-	PathEditorPlugin(EditorNode *p_node);

-	~PathEditorPlugin();

-

-};

-

-

-#endif // PATH_EDITOR_PLUGIN_H

+#ifndef PATH_EDITOR_PLUGIN_H
+#define PATH_EDITOR_PLUGIN_H
+
+
+#include "tools/editor/spatial_editor_gizmos.h"
+#include "scene/3d/path.h"
+class PathSpatialGizmo  : public SpatialGizmoTool {
+
+	OBJ_TYPE(PathSpatialGizmo,SpatialGizmoTool);
+
+	Path* path;
+	mutable Vector3 original;
+
+public:
+
+	virtual String get_handle_name(int p_idx) const;
+	virtual Variant get_handle_value(int p_idx) const;
+	virtual void set_handle(int p_idx,Camera *p_camera, const Point2& p_point);
+	virtual void commit_handle(int p_idx,const Variant& p_restore,bool p_cancel=false);
+
+	void redraw();
+	PathSpatialGizmo(Path* p_path=NULL);
+
+};
+
+class PathEditorPlugin : public EditorPlugin {
+
+	OBJ_TYPE( PathEditorPlugin, EditorPlugin );
+
+
+	Separator *sep;
+	ToolButton *curve_create;
+	ToolButton *curve_edit;
+	ToolButton *curve_del;
+	ToolButton *curve_close;
+
+	EditorNode *editor;
+
+
+	Path *path;
+
+	void _mode_changed(int p_idx);
+    void _close_curve();
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+
+public:
+
+	Path *get_edited_path() { return path; }
+
+	static PathEditorPlugin* singleton;
+	Ref<FixedMaterial> path_material;
+	Ref<FixedMaterial> path_thin_material;
+	virtual bool forward_spatial_input_event(Camera* p_camera,const InputEvent& p_event);
+
+//	virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); }
+	virtual bool create_spatial_gizmo(Spatial* p_spatial);
+	virtual String get_name() const { return "Path"; }
+	bool has_main_screen() const { return false; }
+	virtual void edit(Object *p_node);
+	virtual bool handles(Object *p_node) const;
+	virtual void make_visible(bool p_visible);
+
+	PathEditorPlugin(EditorNode *p_node);
+	~PathEditorPlugin();
+
+};
+
+
+#endif // PATH_EDITOR_PLUGIN_H