A Whole New World (clang-format edition)

I can show you the code
Pretty, with proper whitespace
Tell me, coder, now when did
You last write readable code?

I can open your eyes
Make you see your bad indent
Force you to respect the style
The core devs agreed upon

A whole new world
A new fantastic code format
A de facto standard
With some sugar
Enforced with clang-format

A whole new world
A dazzling style we all dreamed of
And when we read it through
It's crystal clear
That now we're in a whole new world of code

1 files changed, 1087 insertions, 1290 deletions

diff --git a/editor/plugins/canvas_item_editor_plugin.cpp b/editor/plugins/canvas_item_editor_plugin.cpp
index 1a0791d86..ebf2fa5a3 100644
--- a/editor/plugins/canvas_item_editor_plugin.cpp
+++ b/editor/plugins/canvas_item_editor_plugin.cpp
@@ -28,37 +28,35 @@
 /*************************************************************************/
 #include "canvas_item_editor_plugin.h"
 
-#include "print_string.h"
+#include "editor/animation_editor.h"
 #include "editor/editor_node.h"
+#include "editor/editor_settings.h"
+#include "editor/plugins/animation_player_editor_plugin.h"
+#include "editor/plugins/script_editor_plugin.h"
+#include "editor/script_editor_debugger.h"
+#include "global_config.h"
+#include "os/input.h"
 #include "os/keyboard.h"
-#include "scene/main/viewport.h"
-#include "scene/main/canvas_layer.h"
-#include "scene/2d/sprite.h"
+#include "print_string.h"
 #include "scene/2d/light_2d.h"
 #include "scene/2d/particles_2d.h"
 #include "scene/2d/polygon_2d.h"
 #include "scene/2d/screen_button.h"
-#include "global_config.h"
-#include "os/input.h"
-#include "editor/editor_settings.h"
+#include "scene/2d/sprite.h"
 #include "scene/gui/grid_container.h"
 #include "scene/gui/patch_9_rect.h"
-#include "editor/animation_editor.h"
-#include "editor/plugins/animation_player_editor_plugin.h"
-#include "editor/script_editor_debugger.h"
-#include "editor/plugins/script_editor_plugin.h"
+#include "scene/main/canvas_layer.h"
+#include "scene/main/viewport.h"
 #include "scene/resources/packed_scene.h"
 
-
 #define MIN_ZOOM 0.01
 #define MAX_ZOOM 100
 
-
 class SnapDialog : public ConfirmationDialog {
 
-	GDCLASS(SnapDialog,ConfirmationDialog);
+	GDCLASS(SnapDialog, ConfirmationDialog);
 
-friend class CanvasItemEditor;
+	friend class CanvasItemEditor;
 
 	SpinBox *grid_offset_x;
 	SpinBox *grid_offset_y;
@@ -68,7 +66,8 @@ friend class CanvasItemEditor;
 	SpinBox *rotation_step;
 
 public:
-	SnapDialog() : ConfirmationDialog() {
+	SnapDialog()
+		: ConfirmationDialog() {
 		const int SPIN_BOX_GRID_RANGE = 256;
 		const int SPIN_BOX_ROTATION_RANGE = 360;
 		Label *label;
@@ -78,71 +77,71 @@ public:
 		set_title(TTR("Configure Snap"));
 		get_ok()->set_text(TTR("Close"));
 
-		container = memnew( VBoxContainer );
+		container = memnew(VBoxContainer);
 		add_child(container);
 		//set_child_rect(container);
 
-		child_container = memnew( GridContainer );
+		child_container = memnew(GridContainer);
 		child_container->set_columns(3);
 		container->add_child(child_container);
 
-		label = memnew( Label );
+		label = memnew(Label);
 		label->set_text(TTR("Grid Offset:"));
 		child_container->add_child(label);
 		label->set_h_size_flags(SIZE_EXPAND_FILL);
 
-		grid_offset_x = memnew( SpinBox );
+		grid_offset_x = memnew(SpinBox);
 		grid_offset_x->set_min(-SPIN_BOX_GRID_RANGE);
 		grid_offset_x->set_max(SPIN_BOX_GRID_RANGE);
 		grid_offset_x->set_suffix("px");
 		child_container->add_child(grid_offset_x);
 
-		grid_offset_y = memnew( SpinBox );
+		grid_offset_y = memnew(SpinBox);
 		grid_offset_y->set_min(-SPIN_BOX_GRID_RANGE);
 		grid_offset_y->set_max(SPIN_BOX_GRID_RANGE);
 		grid_offset_y->set_suffix("px");
 		child_container->add_child(grid_offset_y);
 
-		label = memnew( Label );
+		label = memnew(Label);
 		label->set_text(TTR("Grid Step:"));
 		child_container->add_child(label);
 		label->set_h_size_flags(SIZE_EXPAND_FILL);
 
-		grid_step_x = memnew( SpinBox );
+		grid_step_x = memnew(SpinBox);
 		grid_step_x->set_min(-SPIN_BOX_GRID_RANGE);
 		grid_step_x->set_max(SPIN_BOX_GRID_RANGE);
 		grid_step_x->set_suffix("px");
 		child_container->add_child(grid_step_x);
 
-		grid_step_y = memnew( SpinBox );
+		grid_step_y = memnew(SpinBox);
 		grid_step_y->set_min(-SPIN_BOX_GRID_RANGE);
 		grid_step_y->set_max(SPIN_BOX_GRID_RANGE);
 		grid_step_y->set_suffix("px");
 		child_container->add_child(grid_step_y);
 
-		container->add_child( memnew( HSeparator ) );
+		container->add_child(memnew(HSeparator));
 
-		child_container = memnew( GridContainer );
+		child_container = memnew(GridContainer);
 		child_container->set_columns(2);
 		container->add_child(child_container);
 
-		label = memnew( Label );
+		label = memnew(Label);
 		label->set_text(TTR("Rotation Offset:"));
 		child_container->add_child(label);
 		label->set_h_size_flags(SIZE_EXPAND_FILL);
 
-		rotation_offset = memnew( SpinBox );
+		rotation_offset = memnew(SpinBox);
 		rotation_offset->set_min(-SPIN_BOX_ROTATION_RANGE);
 		rotation_offset->set_max(SPIN_BOX_ROTATION_RANGE);
 		rotation_offset->set_suffix("deg");
 		child_container->add_child(rotation_offset);
 
-		label = memnew( Label );
+		label = memnew(Label);
 		label->set_text(TTR("Rotation Step:"));
 		child_container->add_child(label);
 		label->set_h_size_flags(SIZE_EXPAND_FILL);
 
-		rotation_step = memnew( SpinBox );
+		rotation_step = memnew(SpinBox);
 		rotation_step->set_min(-SPIN_BOX_ROTATION_RANGE);
 		rotation_step->set_max(SPIN_BOX_ROTATION_RANGE);
 		rotation_step->set_suffix("deg");
@@ -168,12 +167,12 @@ public:
 	}
 };
 
-void CanvasItemEditor::_edit_set_pivot(const Vector2& mouse_pos) {
-	List<Node*> &selection = editor_selection->get_selected_node_list();
+void CanvasItemEditor::_edit_set_pivot(const Vector2 &mouse_pos) {
+	List<Node *> &selection = editor_selection->get_selected_node_list();
 
 	undo_redo->create_action(TTR("Move Pivot"));
 
-	for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+	for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 		Node2D *n2d = E->get()->cast_to<Node2D>();
 
@@ -184,31 +183,27 @@ void CanvasItemEditor::_edit_set_pivot(const Vector2& mouse_pos) {
 
 			Vector2 local_mouse_pos = n2d->get_canvas_transform().affine_inverse().xform(mouse_pos);
 
-			Vector2 motion_ofs = gpos-local_mouse_pos;
+			Vector2 motion_ofs = gpos - local_mouse_pos;
 
-			undo_redo->add_do_method(n2d,"set_global_pos",local_mouse_pos);
-			undo_redo->add_do_method(n2d,"edit_set_pivot",offset+n2d->get_global_transform().affine_inverse().basis_xform(motion_ofs));
-			undo_redo->add_undo_method(n2d,"set_global_pos",gpos);
-			undo_redo->add_undo_method(n2d,"edit_set_pivot",offset);
-			for(int i=0;i<n2d->get_child_count();i++) {
+			undo_redo->add_do_method(n2d, "set_global_pos", local_mouse_pos);
+			undo_redo->add_do_method(n2d, "edit_set_pivot", offset + n2d->get_global_transform().affine_inverse().basis_xform(motion_ofs));
+			undo_redo->add_undo_method(n2d, "set_global_pos", gpos);
+			undo_redo->add_undo_method(n2d, "edit_set_pivot", offset);
+			for (int i = 0; i < n2d->get_child_count(); i++) {
 				Node2D *n2dc = n2d->get_child(i)->cast_to<Node2D>();
 				if (!n2dc)
 					continue;
 
-				undo_redo->add_do_method(n2dc,"set_global_pos",n2dc->get_global_position());
-				undo_redo->add_undo_method(n2dc,"set_global_pos",n2dc->get_global_position());
-
+				undo_redo->add_do_method(n2dc, "set_global_pos", n2dc->get_global_position());
+				undo_redo->add_undo_method(n2dc, "set_global_pos", n2dc->get_global_position());
 			}
-
 		}
-
 	}
 
 	undo_redo->commit_action();
-
 }
 
-void CanvasItemEditor::_unhandled_key_input(const InputEvent& p_ev) {
+void CanvasItemEditor::_unhandled_key_input(const InputEvent &p_ev) {
 
 	if (!is_visible_in_tree() || get_viewport()->gui_has_modal_stack())
 		return;
@@ -216,42 +211,37 @@ void CanvasItemEditor::_unhandled_key_input(const InputEvent& p_ev) {
 	if (p_ev.key.mod.control)
 		return;
 
-	if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode==KEY_V && drag==DRAG_NONE && can_move_pivot) {
+	if (p_ev.key.pressed && !p_ev.key.echo && p_ev.key.scancode == KEY_V && drag == DRAG_NONE && can_move_pivot) {
 
 		if (p_ev.key.mod.shift) {
 			//move drag pivot
-			drag=DRAG_PIVOT;
+			drag = DRAG_PIVOT;
 		} else if (!Input::get_singleton()->is_mouse_button_pressed(0)) {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
 			Vector2 mouse_pos = viewport->get_local_mouse_pos();
 			if (selection.size() && viewport->get_rect().has_point(mouse_pos)) {
 				//just in case, make it work if over viewport
-				mouse_pos=transform.affine_inverse().xform(mouse_pos);
-				mouse_pos=snap_point(mouse_pos);
+				mouse_pos = transform.affine_inverse().xform(mouse_pos);
+				mouse_pos = snap_point(mouse_pos);
 
 				_edit_set_pivot(mouse_pos);
 			}
-
 		}
 	}
-
 }
 
 void CanvasItemEditor::_tool_select(int p_index) {
 
+	ToolButton *tb[TOOL_MAX] = { select_button, list_select_button, move_button, rotate_button, pivot_button, pan_button };
+	for (int i = 0; i < TOOL_MAX; i++) {
 
-	ToolButton *tb[TOOL_MAX]={select_button,list_select_button,move_button,rotate_button,pivot_button,pan_button};
-	for(int i=0;i<TOOL_MAX;i++) {
-
-		tb[i]->set_pressed(i==p_index);
+		tb[i]->set_pressed(i == p_index);
 	}
 
-
 	viewport->update();
-	tool=(Tool)p_index;
-
+	tool = (Tool)p_index;
 }
 
 Object *CanvasItemEditor::_get_editor_data(Object *p_what) {
@@ -260,7 +250,7 @@ Object *CanvasItemEditor::_get_editor_data(Object *p_what) {
 	if (!ci)
 		return NULL;
 
-	return memnew( CanvasItemEditorSelectedItem );
+	return memnew(CanvasItemEditorSelectedItem);
 }
 
 inline float _snap_scalar(float p_offset, float p_step, bool p_snap_relative, float p_target, float p_start) {
@@ -286,89 +276,88 @@ float CanvasItemEditor::snap_angle(float p_target, float p_start) const {
 Dictionary CanvasItemEditor::get_state() const {
 
 	Dictionary state;
-	state["zoom"]=zoom;
-	state["ofs"]=Point2(h_scroll->get_value(),v_scroll->get_value());
+	state["zoom"] = zoom;
+	state["ofs"] = Point2(h_scroll->get_value(), v_scroll->get_value());
 	//state["ofs"]=-transform.get_origin();
-	state["snap_offset"]=snap_offset;
-	state["snap_step"]=snap_step;
-	state["snap_rotation_offset"]=snap_rotation_offset;
-	state["snap_rotation_step"]=snap_rotation_step;
-	state["snap_grid"]=snap_grid;
-	state["snap_show_grid"]=snap_show_grid;
-	state["snap_rotation"]=snap_rotation;
-	state["snap_relative"]=snap_relative;
-	state["snap_pixel"]=snap_pixel;
-	state["skeleton_show_bones"]=skeleton_show_bones;
+	state["snap_offset"] = snap_offset;
+	state["snap_step"] = snap_step;
+	state["snap_rotation_offset"] = snap_rotation_offset;
+	state["snap_rotation_step"] = snap_rotation_step;
+	state["snap_grid"] = snap_grid;
+	state["snap_show_grid"] = snap_show_grid;
+	state["snap_rotation"] = snap_rotation;
+	state["snap_relative"] = snap_relative;
+	state["snap_pixel"] = snap_pixel;
+	state["skeleton_show_bones"] = skeleton_show_bones;
 	return state;
 }
-void CanvasItemEditor::set_state(const Dictionary& p_state){
+void CanvasItemEditor::set_state(const Dictionary &p_state) {
 
-	Dictionary state=p_state;
+	Dictionary state = p_state;
 	if (state.has("zoom")) {
-		zoom=p_state["zoom"];
+		zoom = p_state["zoom"];
 	}
 
 	if (state.has("ofs")) {
 		_update_scrollbars(); // i wonder how safe is calling this here..
-		Point2 ofs=p_state["ofs"];
+		Point2 ofs = p_state["ofs"];
 		h_scroll->set_value(ofs.x);
 		v_scroll->set_value(ofs.y);
 	}
 
 	if (state.has("snap_step")) {
-		snap_step=state["snap_step"];
+		snap_step = state["snap_step"];
 	}
 
 	if (state.has("snap_offset")) {
-		snap_offset=state["snap_offset"];
+		snap_offset = state["snap_offset"];
 	}
 
 	if (state.has("snap_rotation_step")) {
-		snap_rotation_step=state["snap_rotation_step"];
+		snap_rotation_step = state["snap_rotation_step"];
 	}
 
 	if (state.has("snap_rotation_offset")) {
-		snap_rotation_offset=state["snap_rotation_offset"];
+		snap_rotation_offset = state["snap_rotation_offset"];
 	}
 
 	if (state.has("snap_grid")) {
-		snap_grid=state["snap_grid"];
+		snap_grid = state["snap_grid"];
 		int idx = edit_menu->get_popup()->get_item_index(SNAP_USE);
-		edit_menu->get_popup()->set_item_checked(idx,snap_grid);
+		edit_menu->get_popup()->set_item_checked(idx, snap_grid);
 	}
 
 	if (state.has("snap_show_grid")) {
-		snap_show_grid=state["snap_show_grid"];
+		snap_show_grid = state["snap_show_grid"];
 		int idx = edit_menu->get_popup()->get_item_index(SNAP_SHOW_GRID);
-		edit_menu->get_popup()->set_item_checked(idx,snap_show_grid);
+		edit_menu->get_popup()->set_item_checked(idx, snap_show_grid);
 	}
 
 	if (state.has("snap_rotation")) {
-		snap_rotation=state["snap_rotation"];
+		snap_rotation = state["snap_rotation"];
 		int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_ROTATION);
-		edit_menu->get_popup()->set_item_checked(idx,snap_rotation);
+		edit_menu->get_popup()->set_item_checked(idx, snap_rotation);
 	}
 
 	if (state.has("snap_relative")) {
-		snap_relative=state["snap_relative"];
+		snap_relative = state["snap_relative"];
 		int idx = edit_menu->get_popup()->get_item_index(SNAP_RELATIVE);
-		edit_menu->get_popup()->set_item_checked(idx,snap_relative);
+		edit_menu->get_popup()->set_item_checked(idx, snap_relative);
 	}
 
 	if (state.has("snap_pixel")) {
-		snap_pixel=state["snap_pixel"];
+		snap_pixel = state["snap_pixel"];
 		int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL);
-		edit_menu->get_popup()->set_item_checked(idx,snap_pixel);
+		edit_menu->get_popup()->set_item_checked(idx, snap_pixel);
 	}
 
 	if (state.has("skeleton_show_bones")) {
-		skeleton_show_bones=state["skeleton_show_bones"];
+		skeleton_show_bones = state["skeleton_show_bones"];
 		int idx = skeleton_menu->get_item_index(SKELETON_SHOW_BONES);
-		skeleton_menu->set_item_checked(idx,skeleton_show_bones);
+		skeleton_menu->set_item_checked(idx, skeleton_show_bones);
 	}
 }
 
-
 void CanvasItemEditor::_add_canvas_item(CanvasItem *p_canvas_item) {
 
 	editor_selection->add_node(p_canvas_item);
@@ -388,7 +377,6 @@ void CanvasItemEditor::_remove_canvas_item(CanvasItem *p_canvas_item) {
 	p_canvas_item->disconnect("hide",this,"_visibility_changed");
 	canvas_items.erase(p_canvas_item);
 #endif
-
 }
 void CanvasItemEditor::_clear_canvas_items() {
 
@@ -413,7 +401,6 @@ void CanvasItemEditor::_visibility_changed(ObjectID p_canvas_item) {
 #endif
 }
 
-
 void CanvasItemEditor::_node_removed(Node *p_node) {
 #if 0
 	CanvasItem *canvas_item = (CanvasItem*)p_node; //not a good cast, but safe
@@ -434,32 +421,31 @@ void CanvasItemEditor::_keying_changed() {
 
 bool CanvasItemEditor::_is_part_of_subscene(CanvasItem *p_item) {
 
-	Node* scene_node = get_tree()->get_edited_scene_root();
-	Node* item_owner = p_item->get_owner();
+	Node *scene_node = get_tree()->get_edited_scene_root();
+	Node *item_owner = p_item->get_owner();
 
-	return item_owner && item_owner!=scene_node && p_item!=scene_node && item_owner->get_filename()!="";
+	return item_owner && item_owner != scene_node && p_item != scene_node && item_owner->get_filename() != "";
 }
 
 // slow but modern computers should have no problem
-CanvasItem* CanvasItemEditor::_select_canvas_item_at_pos(const Point2& p_pos,Node* p_node,const Transform2D& p_parent_xform,const Transform2D& p_canvas_xform) {
+CanvasItem *CanvasItemEditor::_select_canvas_item_at_pos(const Point2 &p_pos, Node *p_node, const Transform2D &p_parent_xform, const Transform2D &p_canvas_xform) {
 
 	if (!p_node)
 		return NULL;
 	if (p_node->cast_to<Viewport>())
 		return NULL;
 
-	CanvasItem *c=p_node->cast_to<CanvasItem>();
-
+	CanvasItem *c = p_node->cast_to<CanvasItem>();
 
-	for (int i=p_node->get_child_count()-1;i>=0;i--) {
+	for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
 
-		CanvasItem *r=NULL;
+		CanvasItem *r = NULL;
 
 		if (c && !c->is_set_as_toplevel())
-			r=_select_canvas_item_at_pos(p_pos,p_node->get_child(i),p_parent_xform * c->get_transform(),p_canvas_xform);
+			r = _select_canvas_item_at_pos(p_pos, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform);
 		else {
 			CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
-			r=_select_canvas_item_at_pos(p_pos,p_node->get_child(i),transform ,cl ? cl->get_transform() : p_canvas_xform); //use base transform
+			r = _select_canvas_item_at_pos(p_pos, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform); //use base transform
 		}
 
 		if (r)
@@ -471,79 +457,73 @@ CanvasItem* CanvasItemEditor::_select_canvas_item_at_pos(const Point2& p_pos,Nod
 		Rect2 rect = c->get_item_rect();
 		Point2 local_pos = (p_parent_xform * p_canvas_xform * c->get_transform()).affine_inverse().xform(p_pos);
 
-
 		if (rect.has_point(local_pos))
 			return c;
-
 	}
 
 	return NULL;
 }
 
-void CanvasItemEditor::_find_canvas_items_at_pos(const Point2 &p_pos,Node* p_node,const Transform2D& p_parent_xform,const Transform2D& p_canvas_xform, Vector<_SelectResult> &r_items) {
+void CanvasItemEditor::_find_canvas_items_at_pos(const Point2 &p_pos, Node *p_node, const Transform2D &p_parent_xform, const Transform2D &p_canvas_xform, Vector<_SelectResult> &r_items) {
 	if (!p_node)
 		return;
 	if (p_node->cast_to<Viewport>())
 		return;
 
-	CanvasItem *c=p_node->cast_to<CanvasItem>();
+	CanvasItem *c = p_node->cast_to<CanvasItem>();
 
-	for (int i=p_node->get_child_count()-1;i>=0;i--) {
+	for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
 
 		if (c && !c->is_set_as_toplevel())
-			_find_canvas_items_at_pos(p_pos,p_node->get_child(i),p_parent_xform * c->get_transform(),p_canvas_xform, r_items);
+			_find_canvas_items_at_pos(p_pos, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform, r_items);
 		else {
 			CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
-			_find_canvas_items_at_pos(p_pos,p_node->get_child(i),transform ,cl ? cl->get_transform() : p_canvas_xform, r_items); //use base transform
+			_find_canvas_items_at_pos(p_pos, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform, r_items); //use base transform
 		}
 	}
 
-
 	if (c && c->is_visible_in_tree() && !c->has_meta("_edit_lock_") && !c->cast_to<CanvasLayer>()) {
 
 		Rect2 rect = c->get_item_rect();
 		Point2 local_pos = (p_parent_xform * p_canvas_xform * c->get_transform()).affine_inverse().xform(p_pos);
 
-
 		if (rect.has_point(local_pos)) {
-			Node2D *node=c->cast_to<Node2D>();
+			Node2D *node = c->cast_to<Node2D>();
 
 			_SelectResult res;
-			res.item=c;
-			res.z=node?node->get_z():0;
-			res.has_z=node;
+			res.item = c;
+			res.z = node ? node->get_z() : 0;
+			res.has_z = node;
 			r_items.push_back(res);
 		}
-
 	}
 
 	return;
 }
 
-void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2& p_rect,Node* p_node,const Transform2D& p_parent_xform,const Transform2D& p_canvas_xform,List<CanvasItem*> *r_items) {
+void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2 &p_rect, Node *p_node, const Transform2D &p_parent_xform, const Transform2D &p_canvas_xform, List<CanvasItem *> *r_items) {
 
 	if (!p_node)
 		return;
 	if (p_node->cast_to<Viewport>())
 		return;
 
-	CanvasItem *c=p_node->cast_to<CanvasItem>();
-
+	CanvasItem *c = p_node->cast_to<CanvasItem>();
 
-	bool inherited=p_node!=get_tree()->get_edited_scene_root() && p_node->get_filename()!="";
-	bool editable=false;
-	if (inherited){
-		editable=EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(p_node);
+	bool inherited = p_node != get_tree()->get_edited_scene_root() && p_node->get_filename() != "";
+	bool editable = false;
+	if (inherited) {
+		editable = EditorNode::get_singleton()->get_edited_scene()->is_editable_instance(p_node);
 	}
-	bool lock_children=p_node->has_meta("_edit_group_") && p_node->get_meta("_edit_group_");
+	bool lock_children = p_node->has_meta("_edit_group_") && p_node->get_meta("_edit_group_");
 	if (!lock_children && (!inherited || editable)) {
-		for (int i=p_node->get_child_count()-1;i>=0;i--) {
+		for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
 
 			if (c && !c->is_set_as_toplevel())
-				_find_canvas_items_at_rect(p_rect,p_node->get_child(i),p_parent_xform * c->get_transform(),p_canvas_xform,r_items);
+				_find_canvas_items_at_rect(p_rect, p_node->get_child(i), p_parent_xform * c->get_transform(), p_canvas_xform, r_items);
 			else {
 				CanvasLayer *cl = p_node->cast_to<CanvasLayer>();
-				_find_canvas_items_at_rect(p_rect,p_node->get_child(i),transform,cl?cl->get_transform():p_canvas_xform,r_items);
+				_find_canvas_items_at_rect(p_rect, p_node->get_child(i), transform, cl ? cl->get_transform() : p_canvas_xform, r_items);
 			}
 		}
 	}
@@ -553,17 +533,14 @@ void CanvasItemEditor::_find_canvas_items_at_rect(const Rect2& p_rect,Node* p_no
 		Rect2 rect = c->get_item_rect();
 		Transform2D xform = p_parent_xform * p_canvas_xform * c->get_transform();
 
-		if ( p_rect.has_point( xform.xform( rect.pos ) ) &&
-		     p_rect.has_point( xform.xform( rect.pos+Vector2(rect.size.x,0) ) ) &&
-		     p_rect.has_point( xform.xform( rect.pos+Vector2(rect.size.x,rect.size.y) ) ) &&
-		     p_rect.has_point( xform.xform( rect.pos+Vector2(0,rect.size.y) ) ) ) {
+		if (p_rect.has_point(xform.xform(rect.pos)) &&
+				p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, 0))) &&
+				p_rect.has_point(xform.xform(rect.pos + Vector2(rect.size.x, rect.size.y))) &&
+				p_rect.has_point(xform.xform(rect.pos + Vector2(0, rect.size.y)))) {
 
 			r_items->push_back(c);
-
 		}
 	}
-
-
 }
 
 bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_append, bool p_drag) {
@@ -574,10 +551,10 @@ bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_appe
 		if (!item) {
 
 			if (p_drag) {
-				drag_from=transform.affine_inverse().xform(p_click_pos);
+				drag_from = transform.affine_inverse().xform(p_click_pos);
 
-				box_selecting=true;
-				box_selecting_to=drag_from;
+				box_selecting = true;
+				box_selecting_to = drag_from;
 			}
 
 			return false; //nothing to add
@@ -590,7 +567,6 @@ bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_appe
 
 			viewport->update();
 			return false;
-
 		}
 		_append_canvas_item(item);
 		viewport->update();
@@ -605,10 +581,10 @@ bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_appe
 			editor_selection->clear();
 
 			if (p_drag) {
-				drag_from=transform.affine_inverse().xform(p_click_pos);
+				drag_from = transform.affine_inverse().xform(p_click_pos);
 
-				box_selecting=true;
-				box_selecting_to=drag_from;
+				box_selecting = true;
+				box_selecting_to = drag_from;
 			}
 
 			viewport->update();
@@ -621,88 +597,83 @@ bool CanvasItemEditor::_select(CanvasItem *item, Point2 p_click_pos, bool p_appe
 			editor_selection->add_node(item);
 			//reselect
 			if (get_tree()->is_editor_hint()) {
-				editor->call("edit_node",item);
+				editor->call("edit_node", item);
 			}
-
 		}
 
 		if (p_drag) {
 			//prepare to move!
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+				CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 				if (!se)
 					continue;
 
-				se->undo_state=canvas_item->edit_get_state();
+				se->undo_state = canvas_item->edit_get_state();
 				if (canvas_item->cast_to<Node2D>())
-					se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot();
-
+					se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
 			}
 
-			drag=DRAG_ALL;
-			drag_from=transform.affine_inverse().xform(p_click_pos);
-			drag_point_from=_find_topleftmost_point();
+			drag = DRAG_ALL;
+			drag_from = transform.affine_inverse().xform(p_click_pos);
+			drag_point_from = _find_topleftmost_point();
 		}
 
 		viewport->update();
 
 		return true;
-
 	}
 }
 
-void CanvasItemEditor::_key_move(const Vector2& p_dir, bool p_snap, KeyMoveMODE p_move_mode) {
-
+void CanvasItemEditor::_key_move(const Vector2 &p_dir, bool p_snap, KeyMoveMODE p_move_mode) {
 
-	if (drag!=DRAG_NONE)
+	if (drag != DRAG_NONE)
 		return;
 
 	if (editor_selection->get_selected_node_list().empty())
 		return;
 
-	undo_redo->create_action(TTR("Move Action"),UndoRedo::MERGE_ENDS);
+	undo_redo->create_action(TTR("Move Action"), UndoRedo::MERGE_ENDS);
 
-	List<Node*> &selection = editor_selection->get_selected_node_list();
+	List<Node *> &selection = editor_selection->get_selected_node_list();
 
-	for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+	for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 		CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 		if (!canvas_item || !canvas_item->is_visible_in_tree())
 			continue;
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
-		CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+		CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 		if (!se)
 			continue;
 
 		if (canvas_item->has_meta("_edit_lock_"))
 			continue;
 
-
 		Vector2 drag = p_dir;
 		if (p_snap)
-			drag*=snap_step;
+			drag *= snap_step;
 
-		undo_redo->add_undo_method(canvas_item,"edit_set_state",canvas_item->edit_get_state());
+		undo_redo->add_undo_method(canvas_item, "edit_set_state", canvas_item->edit_get_state());
 
-		if (p_move_mode  == MOVE_VIEW_BASE) {
+		if (p_move_mode == MOVE_VIEW_BASE) {
 
 			// drag =  transform.affine_inverse().basis_xform(p_dir); // zoom sensitive
 			drag = canvas_item->get_global_transform_with_canvas().affine_inverse().basis_xform(drag);
 			Rect2 local_rect = canvas_item->get_item_rect();
-			local_rect.pos+=drag;
-			undo_redo->add_do_method(canvas_item,"edit_set_rect",local_rect);
+			local_rect.pos += drag;
+			undo_redo->add_do_method(canvas_item, "edit_set_rect", local_rect);
 
 		} else { // p_move_mode==MOVE_LOCAL_BASE || p_move_mode==MOVE_LOCAL_WITH_ROT
 
@@ -710,14 +681,14 @@ void CanvasItemEditor::_key_move(const Vector2& p_dir, bool p_snap, KeyMoveMODE
 
 				if (p_move_mode == MOVE_LOCAL_WITH_ROT) {
 					Transform2D m;
-					m.rotate( node_2d->get_rotation() );
+					m.rotate(node_2d->get_rotation());
 					drag = m.xform(drag);
 				}
 				node_2d->set_position(node_2d->get_position() + drag);
 
 			} else if (Control *control = canvas_item->cast_to<Control>()) {
 
-				control->set_pos(control->get_pos()+drag);
+				control->set_pos(control->get_pos() + drag);
 			}
 		}
 	}
@@ -727,53 +698,44 @@ void CanvasItemEditor::_key_move(const Vector2& p_dir, bool p_snap, KeyMoveMODE
 
 Point2 CanvasItemEditor::_find_topleftmost_point() {
 
-
-
-	Vector2 tl=Point2(1e10,1e10);
+	Vector2 tl = Point2(1e10, 1e10);
 	Rect2 r2;
-	r2.pos=tl;
-
+	r2.pos = tl;
 
-	List<Node*> &selection = editor_selection->get_selected_node_list();
+	List<Node *> &selection = editor_selection->get_selected_node_list();
 
-	for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+	for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 		CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 		if (!canvas_item || !canvas_item->is_visible_in_tree())
 			continue;
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
-
-
-
-		Rect2 rect=canvas_item->get_item_rect();
-		Transform2D xform=canvas_item->get_global_transform_with_canvas();
+		Rect2 rect = canvas_item->get_item_rect();
+		Transform2D xform = canvas_item->get_global_transform_with_canvas();
 
 		r2.expand_to(xform.xform(rect.pos));
-		r2.expand_to(xform.xform(rect.pos+Vector2(rect.size.x,0)));
-		r2.expand_to(xform.xform(rect.pos+rect.size));
-		r2.expand_to(xform.xform(rect.pos+Vector2(0,rect.size.y)));
-
+		r2.expand_to(xform.xform(rect.pos + Vector2(rect.size.x, 0)));
+		r2.expand_to(xform.xform(rect.pos + rect.size));
+		r2.expand_to(xform.xform(rect.pos + Vector2(0, rect.size.y)));
 	}
 
 	return r2.pos;
 }
 
-
-
 int CanvasItemEditor::get_item_count() {
 
-	List<Node*> &selection = editor_selection->get_selected_node_list();
+	List<Node *> &selection = editor_selection->get_selected_node_list();
 
-	int ic=0;
-	for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+	int ic = 0;
+	for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 		CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 		if (!canvas_item || !canvas_item->is_visible_in_tree())
 			continue;
 
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
 		ic++;
@@ -784,55 +746,54 @@ int CanvasItemEditor::get_item_count() {
 
 CanvasItem *CanvasItemEditor::get_single_item() {
 
+	Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-	Map<Node*,Object*> &selection = editor_selection->get_selection();
-
-	CanvasItem *single_item=NULL;
+	CanvasItem *single_item = NULL;
 
-	for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+	for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 		CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 		if (!canvas_item || !canvas_item->is_visible_in_tree())
 			continue;
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
 		if (single_item)
 			return NULL; //morethan one
 
-		single_item=canvas_item;
+		single_item = canvas_item;
 	};
 
 	return single_item;
 }
 
-CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Transform2D& p_xform, const Rect2& p_local_rect, const Point2& p_click, Vector2& r_point) {
+CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Transform2D &p_xform, const Rect2 &p_local_rect, const Point2 &p_click, Vector2 &r_point) {
 
 	CanvasItem *canvas_item = get_single_item();
 
-	ERR_FAIL_COND_V(!canvas_item,DRAG_NONE);
+	ERR_FAIL_COND_V(!canvas_item, DRAG_NONE);
 
-	Rect2 rect=canvas_item->get_item_rect();
-	Transform2D xforml=canvas_item->get_global_transform_with_canvas();
-	Transform2D xform=transform * xforml;
+	Rect2 rect = canvas_item->get_item_rect();
+	Transform2D xforml = canvas_item->get_global_transform_with_canvas();
+	Transform2D xform = transform * xforml;
 
-	Vector2 endpoints[4]={
+	Vector2 endpoints[4] = {
 
 		xform.xform(rect.pos),
-		xform.xform(rect.pos+Vector2(rect.size.x,0)),
-		xform.xform(rect.pos+rect.size),
-		xform.xform(rect.pos+Vector2(0,rect.size.y))
+		xform.xform(rect.pos + Vector2(rect.size.x, 0)),
+		xform.xform(rect.pos + rect.size),
+		xform.xform(rect.pos + Vector2(0, rect.size.y))
 	};
 
-	Vector2 endpointsl[4]={
+	Vector2 endpointsl[4] = {
 
 		xforml.xform(rect.pos),
-		xforml.xform(rect.pos+Vector2(rect.size.x,0)),
-		xforml.xform(rect.pos+rect.size),
-		xforml.xform(rect.pos+Vector2(0,rect.size.y))
+		xforml.xform(rect.pos + Vector2(rect.size.x, 0)),
+		xforml.xform(rect.pos + rect.size),
+		xforml.xform(rect.pos + Vector2(0, rect.size.y))
 	};
 
-	DragType dragger[]={
+	DragType dragger[] = {
 		DRAG_TOP_LEFT,
 		DRAG_TOP,
 		DRAG_TOP_RIGHT,
@@ -843,34 +804,32 @@ CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Transform2D&
 		DRAG_LEFT
 	};
 
-	float radius = (select_handle->get_size().width/2)*1.5;
+	float radius = (select_handle->get_size().width / 2) * 1.5;
 
 	//try draggers
 
-	for(int i=0;i<4;i++) {
+	for (int i = 0; i < 4; i++) {
 
-		int prev = (i+3)%4;
-		int next = (i+1)%4;
+		int prev = (i + 3) % 4;
+		int next = (i + 1) % 4;
 
-		r_point=endpointsl[i];
+		r_point = endpointsl[i];
 
 		Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized();
-		ofs*=1.4144*(select_handle->get_size().width/2);
+		ofs *= 1.4144 * (select_handle->get_size().width / 2);
 
-		ofs+=endpoints[i];
+		ofs += endpoints[i];
 
-		if (ofs.distance_to(p_click)<radius)
-			return dragger[i*2];
+		if (ofs.distance_to(p_click) < radius)
+			return dragger[i * 2];
 
-		ofs = (endpoints[i]+endpoints[next])/2;
-		ofs += (endpoints[next]-endpoints[i]).tangent().normalized()*(select_handle->get_size().width/2);
+		ofs = (endpoints[i] + endpoints[next]) / 2;
+		ofs += (endpoints[next] - endpoints[i]).tangent().normalized() * (select_handle->get_size().width / 2);
 
-		r_point=(endpointsl[i]+endpointsl[next])/2;
-
-
-		if (ofs.distance_to(p_click)<radius)
-			return dragger[i*2+1];
+		r_point = (endpointsl[i] + endpointsl[next]) / 2;
 
+		if (ofs.distance_to(p_click) < radius)
+			return dragger[i * 2 + 1];
 	}
 
 	/*
@@ -884,70 +843,66 @@ CanvasItemEditor::DragType CanvasItemEditor::_find_drag_type(const Transform2D&
 	return DRAG_NONE;
 }
 
-void CanvasItemEditor::incbeg(float& beg,float &end, float inc, float minsize,bool p_symmetric) {
+void CanvasItemEditor::incbeg(float &beg, float &end, float inc, float minsize, bool p_symmetric) {
 
-	if (minsize<0) {
+	if (minsize < 0) {
 
-		beg+=inc;
+		beg += inc;
 		if (p_symmetric)
-			end-=inc;
+			end -= inc;
 	} else {
 
 		if (p_symmetric) {
-			beg+=inc;
-			end-=inc;
-			if (end-beg < minsize) {
-				float center = (beg+end)/2.0;
-				beg=center-minsize/2.0;
-				end=center+minsize/2.0;
+			beg += inc;
+			end -= inc;
+			if (end - beg < minsize) {
+				float center = (beg + end) / 2.0;
+				beg = center - minsize / 2.0;
+				end = center + minsize / 2.0;
 			}
 
 		} else {
-			if (end-(beg+inc) < minsize)
-				beg=end-minsize;
+			if (end - (beg + inc) < minsize)
+				beg = end - minsize;
 			else
-				beg+=inc;
+				beg += inc;
 		}
-
 	}
 }
 
-void CanvasItemEditor::incend(float &beg,float& end, float inc, float minsize,bool p_symmetric) {
+void CanvasItemEditor::incend(float &beg, float &end, float inc, float minsize, bool p_symmetric) {
 
-	if (minsize<0) {
+	if (minsize < 0) {
 
-		end+=inc;
+		end += inc;
 		if (p_symmetric)
-			beg-=inc;
+			beg -= inc;
 	} else {
 
 		if (p_symmetric) {
 
-			end+=inc;
-			beg-=inc;
-			if (end-beg < minsize) {
-				float center = (beg+end)/2.0;
-				beg=center-minsize/2.0;
-				end=center+minsize/2.0;
+			end += inc;
+			beg -= inc;
+			if (end - beg < minsize) {
+				float center = (beg + end) / 2.0;
+				beg = center - minsize / 2.0;
+				end = center + minsize / 2.0;
 			}
 
 		} else {
-			if ((end+inc)-beg < minsize)
-				end=beg+minsize;
+			if ((end + inc) - beg < minsize)
+				end = beg + minsize;
 			else
-				end+=inc;
+				end += inc;
 		}
-
 	}
 }
 
 void CanvasItemEditor::_append_canvas_item(CanvasItem *c) {
 
 	editor_selection->add_node(c);
-
 }
 
-
 void CanvasItemEditor::_snap_changed() {
 	((SnapDialog *)snap_dialog)->get_fields(snap_offset, snap_step, snap_rotation_offset, snap_rotation_step);
 	viewport->update();
@@ -958,16 +913,16 @@ void CanvasItemEditor::_dialog_value_changed(double) {
 	if (updating_value_dialog)
 		return;
 
-	switch(last_option) {
+	switch (last_option) {
 
 		case ZOOM_SET: {
 
-			zoom=dialog_val->get_value()/100.0;
+			zoom = dialog_val->get_value() / 100.0;
 			_update_scroll(0);
 			viewport->update();
 
 		} break;
-		default:{}
+		default: {}
 	}
 }
 
@@ -976,7 +931,7 @@ void CanvasItemEditor::_selection_result_pressed(int p_result) {
 	if (selection_results.size() <= p_result)
 		return;
 
-	CanvasItem *item=selection_results[p_result].item;
+	CanvasItem *item = selection_results[p_result].item;
 
 	if (item)
 		_select(item, Point2(), additive_selection, false);
@@ -989,31 +944,28 @@ void CanvasItemEditor::_selection_menu_hide() {
 	selection_menu->set_size(Vector2(0, 0));
 }
 
-bool CanvasItemEditor::get_remove_list(List<Node*> *p_list) {
+bool CanvasItemEditor::get_remove_list(List<Node *> *p_list) {
 
-
-	return false;//!p_list->empty();
+	return false; //!p_list->empty();
 }
 
+void CanvasItemEditor::_list_select(const InputEventMouseButton &b) {
 
-void CanvasItemEditor::_list_select(const InputEventMouseButton& b) {
-
-	Point2 click=Point2(b.x,b.y);
+	Point2 click = Point2(b.x, b.y);
 
-	Node* scene = editor->get_edited_scene();
+	Node *scene = editor->get_edited_scene();
 	if (!scene)
 		return;
 
-	_find_canvas_items_at_pos(click, scene,transform,Transform2D(), selection_results);
+	_find_canvas_items_at_pos(click, scene, transform, Transform2D(), selection_results);
 
-	for(int i=0;i<selection_results.size();i++) {
-		CanvasItem *item=selection_results[i].item;
-		if (item!=scene && item->get_owner()!=scene && !scene->is_editable_instance(item->get_owner())) {
+	for (int i = 0; i < selection_results.size(); i++) {
+		CanvasItem *item = selection_results[i].item;
+		if (item != scene && item->get_owner() != scene && !scene->is_editable_instance(item->get_owner())) {
 			//invalid result
 			selection_results.remove(i);
 			i--;
 		}
-
 	}
 
 	if (selection_results.size() == 1) {
@@ -1021,7 +973,7 @@ void CanvasItemEditor::_list_select(const InputEventMouseButton& b) {
 		CanvasItem *item = selection_results[0].item;
 		selection_results.clear();
 
-		additive_selection=b.mod.shift;
+		additive_selection = b.mod.shift;
 		if (!_select(item, click, additive_selection, false))
 			return;
 
@@ -1030,50 +982,47 @@ void CanvasItemEditor::_list_select(const InputEventMouseButton& b) {
 		selection_results.sort();
 
 		NodePath root_path = get_tree()->get_edited_scene_root()->get_path();
-		StringName root_name = root_path.get_name(root_path.get_name_count()-1);
+		StringName root_name = root_path.get_name(root_path.get_name_count() - 1);
 
 		for (int i = 0; i < selection_results.size(); i++) {
 
-			CanvasItem *item=selection_results[i].item;
-
+			CanvasItem *item = selection_results[i].item;
 
 			Ref<Texture> icon;
 			if (item->has_meta("_editor_icon"))
-				icon=item->get_meta("_editor_icon");
+				icon = item->get_meta("_editor_icon");
 			else
-				icon=get_icon( has_icon(item->get_class(),"EditorIcons")?item->get_class():String("Object"),"EditorIcons");
+				icon = get_icon(has_icon(item->get_class(), "EditorIcons") ? item->get_class() : String("Object"), "EditorIcons");
 
-			String node_path="/"+root_name+"/"+root_path.rel_path_to(item->get_path());
+			String node_path = "/" + root_name + "/" + root_path.rel_path_to(item->get_path());
 
 			selection_menu->add_item(item->get_name());
-			selection_menu->set_item_icon(i, icon );
+			selection_menu->set_item_icon(i, icon);
 			selection_menu->set_item_metadata(i, node_path);
-			selection_menu->set_item_tooltip(i,String(item->get_name())+
-					"\nType: "+item->get_class()+"\nPath: "+node_path);
+			selection_menu->set_item_tooltip(i, String(item->get_name()) +
+														"\nType: " + item->get_class() + "\nPath: " + node_path);
 		}
 
-		additive_selection=b.mod.shift;
+		additive_selection = b.mod.shift;
 
-		selection_menu->set_global_pos(Vector2( b.global_x, b.global_y ));
+		selection_menu->set_global_pos(Vector2(b.global_x, b.global_y));
 		selection_menu->popup();
 		selection_menu->call_deferred("grab_click_focus");
 		selection_menu->set_invalidate_click_until_motion();
 
-
 		return;
 	}
-
 }
 
-void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
+void CanvasItemEditor::_viewport_gui_input(const InputEvent &p_event) {
 
-	 {
+	{
 
 		EditorNode *en = editor;
 		EditorPluginList *over_plugin_list = en->get_editor_plugins_over();
 
 		if (!over_plugin_list->empty()) {
-			bool discard = over_plugin_list->forward_gui_input(transform,p_event);
+			bool discard = over_plugin_list->forward_gui_input(transform, p_event);
 			if (discard) {
 				accept_event();
 				return;
@@ -1081,42 +1030,40 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 		}
 	}
 
+	if (p_event.type == InputEvent::MOUSE_BUTTON) {
 
-	if (p_event.type==InputEvent::MOUSE_BUTTON) {
-
-		const InputEventMouseButton &b=p_event.mouse_button;
+		const InputEventMouseButton &b = p_event.mouse_button;
 
+		if (b.button_index == BUTTON_WHEEL_DOWN) {
 
-		if (b.button_index==BUTTON_WHEEL_DOWN) {
-
-			if (zoom<MIN_ZOOM)
+			if (zoom < MIN_ZOOM)
 				return;
 
-			float prev_zoom=zoom;
-			zoom=zoom*0.95;
+			float prev_zoom = zoom;
+			zoom = zoom * 0.95;
 			{
-				Point2 ofs(b.x,b.y);
-				ofs = ofs/prev_zoom - ofs/zoom;
-				h_scroll->set_value( h_scroll->get_value() + ofs.x );
-				v_scroll->set_value( v_scroll->get_value() + ofs.y );
+				Point2 ofs(b.x, b.y);
+				ofs = ofs / prev_zoom - ofs / zoom;
+				h_scroll->set_value(h_scroll->get_value() + ofs.x);
+				v_scroll->set_value(v_scroll->get_value() + ofs.y);
 			}
 			_update_scroll(0);
 			viewport->update();
 			return;
 		}
 
-		if (b.button_index==BUTTON_WHEEL_UP) {
+		if (b.button_index == BUTTON_WHEEL_UP) {
 
-			if (zoom>MAX_ZOOM)
+			if (zoom > MAX_ZOOM)
 				return;
 
-			float prev_zoom=zoom;
-			zoom=zoom*(1.0/0.95);
+			float prev_zoom = zoom;
+			zoom = zoom * (1.0 / 0.95);
 			{
-				Point2 ofs(b.x,b.y);
-				ofs = ofs/prev_zoom - ofs/zoom;
-				h_scroll->set_value( h_scroll->get_value() + ofs.x );
-				v_scroll->set_value( v_scroll->get_value() + ofs.y );
+				Point2 ofs(b.x, b.y);
+				ofs = ofs / prev_zoom - ofs / zoom;
+				h_scroll->set_value(h_scroll->get_value() + ofs.x);
+				v_scroll->set_value(v_scroll->get_value() + ofs.y);
 			}
 
 			_update_scroll(0);
@@ -1124,21 +1071,20 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 			return;
 		}
 
-		if (b.button_index==BUTTON_RIGHT) {
-
+		if (b.button_index == BUTTON_RIGHT) {
 
-			if (b.pressed && (tool==TOOL_SELECT && b.mod.alt)) {
+			if (b.pressed && (tool == TOOL_SELECT && b.mod.alt)) {
 
 				_list_select(b);
 				return;
 			}
 
-			if (get_item_count() > 0 && drag!=DRAG_NONE) {
+			if (get_item_count() > 0 && drag != DRAG_NONE) {
 				//cancel drag
 
 				if (bone_ik_list.size()) {
 
-					for(List<BoneIK>::Element *E=bone_ik_list.back();E;E=E->prev()) {
+					for (List<BoneIK>::Element *E = bone_ik_list.back(); E; E = E->prev()) {
 
 						E->get().node->edit_set_state(E->get().orig_state);
 					}
@@ -1147,35 +1093,32 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 
 				} else {
 
+					List<Node *> &selection = editor_selection->get_selected_node_list();
 
-					List<Node*> &selection = editor_selection->get_selected_node_list();
-
-					for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+					for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 						CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 						if (!canvas_item || !canvas_item->is_visible_in_tree())
 							continue;
-						if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+						if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 							continue;
 
-
-						CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+						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;
+				drag = DRAG_NONE;
 				viewport->update();
-				can_move_pivot=false;
+				can_move_pivot = false;
 
 			} else if (box_selecting) {
-				box_selecting=false;
+				box_selecting = false;
 				viewport->update();
 			} else if (b.pressed) {
 #if 0
@@ -1193,49 +1136,44 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 			return;
 		*/
 
-		if (b.button_index==BUTTON_LEFT && tool==TOOL_LIST_SELECT) {
+		if (b.button_index == BUTTON_LEFT && tool == TOOL_LIST_SELECT) {
 			if (b.pressed)
 				_list_select(b);
 			return;
 		}
 
-
-		if (b.button_index==BUTTON_LEFT && tool==TOOL_EDIT_PIVOT) {
+		if (b.button_index == BUTTON_LEFT && tool == TOOL_EDIT_PIVOT) {
 			if (b.pressed) {
 
-				Point2 mouse_pos(b.x,b.y);
-				mouse_pos=transform.affine_inverse().xform(mouse_pos);
-				mouse_pos=snap_point(mouse_pos);
+				Point2 mouse_pos(b.x, b.y);
+				mouse_pos = transform.affine_inverse().xform(mouse_pos);
+				mouse_pos = snap_point(mouse_pos);
 				_edit_set_pivot(mouse_pos);
 			}
 			return;
 		}
 
-
-
-		if (tool==TOOL_PAN || b.button_index!=BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE))
+		if (tool == TOOL_PAN || b.button_index != BUTTON_LEFT || Input::get_singleton()->is_key_pressed(KEY_SPACE))
 			return;
 
 		if (!b.pressed) {
 
-			if (drag!=DRAG_NONE) {
+			if (drag != DRAG_NONE) {
 
 				if (undo_redo) {
 
-
 					if (bone_ik_list.size()) {
 
-
 						undo_redo->create_action(TTR("Edit IK Chain"));
 
-						for(List<BoneIK>::Element *E=bone_ik_list.back();E;E=E->prev()) {
+						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(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");
+						undo_redo->add_do_method(viewport, "update");
+						undo_redo->add_undo_method(viewport, "update");
 
 						bone_ik_list.clear();
 
@@ -1244,29 +1182,28 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 
 						undo_redo->create_action(TTR("Edit CanvasItem"));
 
+						List<Node *> &selection = editor_selection->get_selected_node_list();
 
-						List<Node*> &selection = editor_selection->get_selected_node_list();
-
-						for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+						for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 							CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 							if (!canvas_item || !canvas_item->is_visible_in_tree())
 								continue;
-							if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+							if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 								continue;
 
-							CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+							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);
+							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->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);
 								}
 							}
 						}
@@ -1274,10 +1211,9 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 					}
 				}
 
-				drag=DRAG_NONE;
+				drag = DRAG_NONE;
 				viewport->update();
-				can_move_pivot=false;
-
+				can_move_pivot = false;
 			}
 
 			if (box_selecting) {
@@ -1286,110 +1222,102 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 				if ( box_selection_end() ) return;
 #endif
 
-				Node* scene = editor->get_edited_scene();
+				Node *scene = editor->get_edited_scene();
 				if (scene) {
 
-					List<CanvasItem*> selitems;
+					List<CanvasItem *> selitems;
 
 					Point2 bsfrom = transform.xform(drag_from);
-					Point2 bsto= transform.xform(box_selecting_to);
-					if (bsfrom.x>bsto.x)
-						SWAP(bsfrom.x,bsto.x);
-					if (bsfrom.y>bsto.y)
-						SWAP(bsfrom.y,bsto.y);
+					Point2 bsto = transform.xform(box_selecting_to);
+					if (bsfrom.x > bsto.x)
+						SWAP(bsfrom.x, bsto.x);
+					if (bsfrom.y > bsto.y)
+						SWAP(bsfrom.y, bsto.y);
 
-					_find_canvas_items_at_rect(Rect2(bsfrom,bsto-bsfrom),scene,transform,Transform2D(),&selitems);
+					_find_canvas_items_at_rect(Rect2(bsfrom, bsto - bsfrom), scene, transform, Transform2D(), &selitems);
 
-					for(List<CanvasItem*>::Element *E=selitems.front();E;E=E->next()) {
+					for (List<CanvasItem *>::Element *E = selitems.front(); E; E = E->next()) {
 
 						_append_canvas_item(E->get());
 					}
-
 				}
 
-				box_selecting=false;
+				box_selecting = false;
 				viewport->update();
-
 			}
 			return;
 		}
 
-
-		Map<ObjectID,BoneList>::Element *Cbone=NULL; //closest
+		Map<ObjectID, BoneList>::Element *Cbone = NULL; //closest
 
 		{
 			bone_ik_list.clear();
-			float closest_dist=1e20;
+			float closest_dist = 1e20;
 			int bone_width = EditorSettings::get_singleton()->get("editors/2d/bone_width");
-			for(Map<ObjectID,BoneList>::Element *E=bone_list.front();E;E=E->next()) {
+			for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
 
 				if (E->get().from == E->get().to)
 					continue;
-				Vector2 s[2]={
+				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;
+				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);
+				Node2D *b = NULL;
+				Object *obj = ObjectDB::get_instance(Cbone->get().bone);
 				if (obj)
-					b=obj->cast_to<Node2D>();
+					b = obj->cast_to<Node2D>();
 
 				if (b) {
 
+					bool ik_found = false;
+					bool first = true;
 
-					bool ik_found=false;
-					bool first=true;
-
-
+					while (b) {
 
-					while(b) {
-
-						CanvasItem *pi=b->get_parent_item();
+						CanvasItem *pi = b->get_parent_item();
 						if (!pi)
 							break;
 
-						float len=pi->get_global_transform().get_origin().distance_to(b->get_global_position());
-						b=pi->cast_to<Node2D>();
+						float len = pi->get_global_transform().get_origin().distance_to(b->get_global_position());
+						b = pi->cast_to<Node2D>();
 						if (!b)
 							break;
 
 						if (first) {
 
-							bone_orig_xform=b->get_global_transform();
-							first=false;
+							bone_orig_xform = b->get_global_transform();
+							first = false;
 						}
 
 						BoneIK bik;
-						bik.node=b;
-						bik.len=len;
-						bik.orig_state=b->edit_get_state();
+						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;
+							ik_found = bone_ik_list.size() > 1;
 							break;
 						}
 
 						if (!pi->has_meta("_edit_bone_"))
 							break;
-
 					}
 
 					if (!ik_found)
 						bone_ik_list.clear();
-
 				}
 			}
 		}
@@ -1400,92 +1328,86 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 			//try single canvas_item edit
 
 			CanvasItem *canvas_item = single_item;
-			CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+			CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 			ERR_FAIL_COND(!se);
 
+			Point2 click(b.x, b.y);
 
-			Point2 click(b.x,b.y);
-
-			if ((b.mod.control && tool==TOOL_SELECT) || tool==TOOL_ROTATE) {
+			if ((b.mod.control && tool == TOOL_SELECT) || tool == TOOL_ROTATE) {
 
-				drag=DRAG_ROTATE;
-				drag_from=transform.affine_inverse().xform(click);
-				se->undo_state=canvas_item->edit_get_state();
+				drag = DRAG_ROTATE;
+				drag_from = transform.affine_inverse().xform(click);
+				se->undo_state = canvas_item->edit_get_state();
 				if (canvas_item->cast_to<Node2D>())
-					se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot();
+					se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
 				if (canvas_item->cast_to<Control>())
-					se->undo_pivot=Vector2();
+					se->undo_pivot = Vector2();
 				return;
 			}
 
 			Transform2D xform = transform * canvas_item->get_global_transform_with_canvas();
-			Rect2 rect=canvas_item->get_item_rect();
+			Rect2 rect = canvas_item->get_item_rect();
 			//float handle_radius = handle_len * 1.4144; //magic number, guess what it means!
 
-			if (tool==TOOL_SELECT) {
-				drag = _find_drag_type(xform,rect,click,drag_point_from);
+			if (tool == TOOL_SELECT) {
+				drag = _find_drag_type(xform, rect, click, drag_point_from);
 
 				if (b.doubleclick) {
 
-					if (canvas_item->get_filename()!="" && canvas_item!=editor->get_edited_scene()) {
+					if (canvas_item->get_filename() != "" && canvas_item != editor->get_edited_scene()) {
 
 						editor->open_request(canvas_item->get_filename());
 						return;
 					}
 				}
 
-				if (drag!=DRAG_NONE && (!Cbone || drag!=DRAG_ALL)) {
-					drag_from=transform.affine_inverse().xform(click);
-					se->undo_state=canvas_item->edit_get_state();
+				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>())
-						se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot();
+						se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
 
 					return;
 				}
 			} else {
 
-				drag=DRAG_NONE;
+				drag = DRAG_NONE;
 			}
 		}
 
 		//multi canvas_item edit
 
+		Point2 click = Point2(b.x, b.y);
 
-		Point2 click=Point2(b.x,b.y);
+		if ((b.mod.alt || tool == TOOL_MOVE) && get_item_count()) {
 
-		if ((b.mod.alt || tool==TOOL_MOVE) && get_item_count()) {
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-
-			List<Node*> &selection = editor_selection->get_selected_node_list();
-
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+				CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 				if (!se)
 					continue;
 
-				se->undo_state=canvas_item->edit_get_state();
+				se->undo_state = canvas_item->edit_get_state();
 				if (canvas_item->cast_to<Node2D>())
-					se->undo_pivot=canvas_item->cast_to<Node2D>()->edit_get_pivot();
-
+					se->undo_pivot = canvas_item->cast_to<Node2D>()->edit_get_pivot();
 			}
 
-
-			drag=DRAG_ALL;
-			drag_from=transform.affine_inverse().xform(click);
-			drag_point_from=_find_topleftmost_point();
+			drag = DRAG_ALL;
+			drag_from = transform.affine_inverse().xform(click);
+			drag_point_from = _find_topleftmost_point();
 			viewport->update();
 			return;
-
 		}
 
-		Node* scene = editor->get_edited_scene();
+		Node *scene = editor->get_edited_scene();
 		if (!scene)
 			return;
 
@@ -1494,33 +1416,30 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 			//no window.... ?
 			click-=current_window->get_scroll();
 		}*/
-		CanvasItem *c=NULL;
+		CanvasItem *c = NULL;
 
 		if (Cbone) {
 
-			Object* obj=ObjectDB::get_instance(Cbone->get().bone);
+			Object *obj = ObjectDB::get_instance(Cbone->get().bone);
 			if (obj)
-				c=obj->cast_to<CanvasItem>();
+				c = obj->cast_to<CanvasItem>();
 			if (c)
-				c=c->get_parent_item();
-
-
+				c = c->get_parent_item();
 		}
 		if (!c) {
-			c =_select_canvas_item_at_pos(click, scene,transform,Transform2D());
-
+			c = _select_canvas_item_at_pos(click, scene, transform, Transform2D());
 
-			CanvasItem* cn = c;
+			CanvasItem *cn = c;
 
-			while(cn) {
+			while (cn) {
 				if (cn->has_meta("_edit_group_")) {
-					c=cn;
+					c = cn;
 				}
-				cn=cn->get_parent_item();
+				cn = cn->get_parent_item();
 			}
 		}
 
-		Node* n = c;
+		Node *n = c;
 
 		while ((n && n != scene && n->get_owner() != scene) || (n && !n->is_class("CanvasItem"))) {
 			n = n->get_parent();
@@ -1530,57 +1449,50 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 		if ( b.pressed ) box_selection_start( click );
 #endif
 
-		additive_selection=b.mod.shift;
+		additive_selection = b.mod.shift;
 		if (!_select(c, click, additive_selection))
 			return;
-
 	}
 
-	if (p_event.type==InputEvent::MOUSE_MOTION) {
+	if (p_event.type == InputEvent::MOUSE_MOTION) {
 
 		if (!viewport->has_focus() && (!get_focus_owner() || !get_focus_owner()->is_text_field()))
 			viewport->call_deferred("grab_focus");
 
-		const InputEventMouseMotion &m=p_event.mouse_motion;
+		const InputEventMouseMotion &m = p_event.mouse_motion;
 
 		if (box_selecting) {
 
-			box_selecting_to=transform.affine_inverse().xform(Point2(m.x,m.y));
+			box_selecting_to = transform.affine_inverse().xform(Point2(m.x, m.y));
 			viewport->update();
 			return;
-
 		}
 
+		if (drag == DRAG_NONE) {
 
-		if (drag==DRAG_NONE) {
-
-
-			if ( (m.button_mask&BUTTON_MASK_LEFT && tool == TOOL_PAN) || m.button_mask&BUTTON_MASK_MIDDLE || (m.button_mask&BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) {
-				h_scroll->set_value( h_scroll->get_value() - m.relative_x/zoom);
-				v_scroll->set_value( v_scroll->get_value() - m.relative_y/zoom);
+			if ((m.button_mask & BUTTON_MASK_LEFT && tool == TOOL_PAN) || m.button_mask & BUTTON_MASK_MIDDLE || (m.button_mask & BUTTON_MASK_LEFT && Input::get_singleton()->is_key_pressed(KEY_SPACE))) {
+				h_scroll->set_value(h_scroll->get_value() - m.relative_x / zoom);
+				v_scroll->set_value(v_scroll->get_value() - m.relative_y / zoom);
 			}
 
 			return;
-
 		}
 
-		List<Node*> &selection = editor_selection->get_selected_node_list();
+		List<Node *> &selection = editor_selection->get_selected_node_list();
 
-
-		for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+		for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 			CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 			if (!canvas_item || !canvas_item->is_visible_in_tree())
 				continue;
-			if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+			if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 				continue;
 
-			CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+			CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 			if (!se)
 				continue;
 
-			bool dragging_bone = drag==DRAG_ALL && selection.size()==1 && bone_ik_list.size();
-
+			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
@@ -1588,23 +1500,20 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 					canvas_item->cast_to<Node2D>()->edit_set_pivot(se->undo_pivot);
 			}
 
-
 			Vector2 dfrom = drag_from;
-			Vector2 dto = transform.affine_inverse().xform(Point2(m.x,m.y));
+			Vector2 dto = transform.affine_inverse().xform(Point2(m.x, m.y));
 			if (canvas_item->has_meta("_edit_lock_"))
 				continue;
 
-
-			if (drag==DRAG_ROTATE) {
+			if (drag == DRAG_ROTATE) {
 
 				Vector2 center = canvas_item->get_global_transform_with_canvas().get_origin();
 				{
 					Node2D *node = canvas_item->cast_to<Node2D>();
 
-
 					if (node) {
 						real_t angle = node->get_rotation();
-						node->set_rotation(snap_angle( angle + (dfrom - center).angle_to(dto-center), angle ));
+						node->set_rotation(snap_angle(angle + (dfrom - center).angle_to(dto - center), angle));
 						display_rotate_to = dto;
 						display_rotate_from = center;
 						viewport->update();
@@ -1614,10 +1523,9 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 				{
 					Control *node = canvas_item->cast_to<Control>();
 
-
 					if (node) {
 						real_t angle = node->get_rotation();
-						node->set_rotation(snap_angle( angle + (dfrom - center).angle_to(dto-center), angle ));
+						node->set_rotation(snap_angle(angle + (dfrom - center).angle_to(dto - center), angle));
 						display_rotate_to = dto;
 						display_rotate_from = center;
 						viewport->update();
@@ -1627,14 +1535,13 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 				continue;
 			}
 
-
 			bool uniform = m.mod.shift;
-			bool symmetric=m.mod.alt;
+			bool symmetric = m.mod.alt;
 
 			dto = dto - (drag == DRAG_ALL ? drag_from - drag_point_from : Vector2(0, 0));
 
-			if(uniform && drag == DRAG_ALL) {
-				if(ABS(dto.x - drag_point_from.x) > ABS(dto.y - drag_point_from.y)) {
+			if (uniform && drag == DRAG_ALL) {
+				if (ABS(dto.x - drag_point_from.x) > ABS(dto.y - drag_point_from.y)) {
 					dto.y = drag_point_from.y;
 				} else {
 					dto.x = drag_point_from.x;
@@ -1649,128 +1556,118 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 					canvas_item->get_global_transform_with_canvas().affine_inverse().xform(dfrom);
 
 			Rect2 local_rect = canvas_item->get_item_rect();
-			Vector2 begin=local_rect.pos;
-			Vector2 end=local_rect.pos+local_rect.size;
+			Vector2 begin = local_rect.pos;
+			Vector2 end = local_rect.pos + local_rect.size;
 			Vector2 minsize = canvas_item->edit_get_minimum_size();
 
 			if (uniform) {
 				float aspect = local_rect.size.aspect();
-				switch(drag) {
+				switch (drag) {
 					case DRAG_BOTTOM_LEFT:
 					case DRAG_TOP_RIGHT: {
 						if (aspect > 1.0) { // width > height, take x as reference
-							drag_vector.y = -drag_vector.x/aspect;
+							drag_vector.y = -drag_vector.x / aspect;
 						} else { // height > width, take y as reference
-							drag_vector.x = -drag_vector.y*aspect;
+							drag_vector.x = -drag_vector.y * aspect;
 						}
 					} break;
 					case DRAG_BOTTOM_RIGHT:
 					case DRAG_TOP_LEFT: {
 						if (aspect > 1.0) { // width > height, take x as reference
-							drag_vector.y = drag_vector.x/aspect;
+							drag_vector.y = drag_vector.x / aspect;
 						} else { // height > width, take y as reference
-							drag_vector.x = drag_vector.y*aspect;
+							drag_vector.x = drag_vector.y * aspect;
 						}
 					} break;
 					default: {}
 				}
 			}
 
-			switch(drag) {
+			switch (drag) {
 				case DRAG_ALL: {
-					begin+=drag_vector;
-					end+=drag_vector;
+					begin += drag_vector;
+					end += drag_vector;
 				} break;
 				case DRAG_RIGHT: {
 
-					incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
+					incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
 
 				} break;
 				case DRAG_BOTTOM: {
 
-					incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
+					incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
 
 				} break;
 				case DRAG_BOTTOM_RIGHT: {
 
-					incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
-					incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
+					incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
+					incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
 				} break;
 				case DRAG_TOP_LEFT: {
 
-					incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
-					incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
+					incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
+					incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
 				} break;
 				case DRAG_TOP: {
 
-					incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
+					incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
 
 				} break;
 				case DRAG_LEFT: {
 
-					incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
+					incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
 
 				} break;
 				case DRAG_TOP_RIGHT: {
 
-					incbeg(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
-					incend(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
+					incbeg(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
+					incend(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
 
 				} break;
 				case DRAG_BOTTOM_LEFT: {
 
-					incbeg(begin.x,end.x,drag_vector.x,minsize.x,symmetric);
-					incend(begin.y,end.y,drag_vector.y,minsize.y,symmetric);
+					incbeg(begin.x, end.x, drag_vector.x, minsize.x, symmetric);
+					incend(begin.y, end.y, drag_vector.y, minsize.y, symmetric);
 				} break;
 				case DRAG_PIVOT: {
 
 					if (canvas_item->cast_to<Node2D>()) {
-						Node2D *n2d =canvas_item->cast_to<Node2D>();
-						n2d->edit_set_pivot(se->undo_pivot+drag_vector);
-
+						Node2D *n2d = canvas_item->cast_to<Node2D>();
+						n2d->edit_set_pivot(se->undo_pivot + drag_vector);
 					}
 					continue;
 				} break;
 
-				default:{}
+				default: {}
 			}
 
-
-
 			if (!dragging_bone) {
 
-				local_rect.pos=begin;
-				local_rect.size=end-begin;
+				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>();
 				Transform2D final_xform = bone_orig_xform;
 
-
-
 				if (n2d) {
 
 					float total_len = 0;
-					for (List<BoneIK>::Element *E=bone_ik_list.front();E;E=E->next()) {
+					for (List<BoneIK>::Element *E = bone_ik_list.front(); E; E = E->next()) {
 						if (E->prev())
-							total_len+=E->get().len;
+							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);
+						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;
@@ -1783,70 +1680,64 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 						//print_line("TOO FAR!");
 						Vector2 rel = leaf_pos - root_pos;
 						rel = rel.normalized() * total_len;
-						leaf_pos=root_pos+rel;
-
+						leaf_pos = root_pos + rel;
 					}
 
-					bone_ik_list.front()->get().pos=leaf_pos;
+					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;
 
-					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()) {
-
+						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()) {
+								if (E == bone_ik_list.back()) {
 
 									break;
 								}
 
 								float len = E->next()->get().len;
 
-								if (E->next()==bone_ik_list.back()) {
+								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;
+									Vector2 desired = E->next()->get().pos + rel.normalized() * len;
 									//print_line("DESIRED "+desired);
-									E->get().pos=E->get().pos.linear_interpolate(desired,solver_k);
+									E->get().pos = E->get().pos.linear_interpolate(desired, solver_k);
 									//print_line("POST "+E->get().pos);
 
-
-								} else if (E==bone_ik_list.front()) {
+								} 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;
+									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);
+									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;
+									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()) {
+				for (List<BoneIK>::Element *E = bone_ik_list.back(); E; E = E->prev()) {
 
 					Node2D *n = E->get().node;
 
@@ -1859,90 +1750,81 @@ void CanvasItemEditor::_viewport_gui_input(const InputEvent& p_event) {
 						Vector2 rel = (E->prev()->get().node->get_global_position() - n->get_global_position()).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) {
+						if (n->get_global_transform().basis_determinant() < 0) {
 							//mirrored, rotate the other way
-							rot=-rot;
+							rot = -rot;
 						}
 
 						n->rotate(rot);
 					}
-
 				}
 
-
-
 				break;
 			}
 		}
 	}
 
-	if (p_event.type==InputEvent::KEY) {
+	if (p_event.type == InputEvent::KEY) {
 
-		const InputEventKey &k=p_event.key;
+		const InputEventKey &k = p_event.key;
 
-		if (k.pressed && drag==DRAG_NONE) {
+		if (k.pressed && drag == DRAG_NONE) {
 
 			KeyMoveMODE move_mode = MOVE_VIEW_BASE;
 			if (k.mod.alt) move_mode = MOVE_LOCAL_BASE;
 			if (k.mod.control || k.mod.meta) move_mode = MOVE_LOCAL_WITH_ROT;
 
-			if (k.scancode==KEY_UP)
-				_key_move( Vector2(0,-1), k.mod.shift, move_mode );
-			else if (k.scancode==KEY_DOWN)
-				_key_move( Vector2(0,1), k.mod.shift, move_mode );
-			else if (k.scancode==KEY_LEFT)
-				_key_move( Vector2(-1,0), k.mod.shift, move_mode );
-			else if (k.scancode==KEY_RIGHT)
-				_key_move( Vector2(1,0), k.mod.shift, move_mode );
-			else if (k.scancode==KEY_ESCAPE) {
+			if (k.scancode == KEY_UP)
+				_key_move(Vector2(0, -1), k.mod.shift, move_mode);
+			else if (k.scancode == KEY_DOWN)
+				_key_move(Vector2(0, 1), k.mod.shift, move_mode);
+			else if (k.scancode == KEY_LEFT)
+				_key_move(Vector2(-1, 0), k.mod.shift, move_mode);
+			else if (k.scancode == KEY_RIGHT)
+				_key_move(Vector2(1, 0), k.mod.shift, move_mode);
+			else if (k.scancode == KEY_ESCAPE) {
 				editor_selection->clear();
 				viewport->update();
-			}
-			else
+			} else
 				return;
 
 			accept_event();
 		}
-
 	}
-
-
-
-
 }
 
 void CanvasItemEditor::_viewport_draw() {
 
 	// TODO fetch the viewport?
 
-	Ref<Texture> pivot = get_icon("EditorPivot","EditorIcons");
+	Ref<Texture> pivot = get_icon("EditorPivot", "EditorIcons");
 	_update_scrollbars();
-	RID ci=viewport->get_canvas_item();
+	RID ci = viewport->get_canvas_item();
 
 	if (snap_show_grid) {
 		Size2 s = viewport->get_size();
 		int last_cell;
 		Transform2D xform = transform.affine_inverse();
 
-		if (snap_step.x!=0) {
-			for(int i=0;i<s.width;i++) {
-				int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(i,0)).x-snap_offset.x)/snap_step.x));
-				if (i==0)
-					last_cell=cell;
-				if (last_cell!=cell)
-					viewport->draw_line(Point2(i,0),Point2(i,s.height),Color(0.3,0.7,1,0.3));
-				last_cell=cell;
+		if (snap_step.x != 0) {
+			for (int i = 0; i < s.width; i++) {
+				int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(i, 0)).x - snap_offset.x) / snap_step.x));
+				if (i == 0)
+					last_cell = cell;
+				if (last_cell != cell)
+					viewport->draw_line(Point2(i, 0), Point2(i, s.height), Color(0.3, 0.7, 1, 0.3));
+				last_cell = cell;
 			}
 		}
 
-		if (snap_step.y!=0) {
-			for(int i=0;i<s.height;i++) {
-				int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(0,i)).y-snap_offset.y)/snap_step.y));
-				if (i==0)
-					last_cell=cell;
-				if (last_cell!=cell)
-					viewport->draw_line(Point2(0,i),Point2(s.width,i),Color(0.3,0.7,1,0.3));
-				last_cell=cell;
+		if (snap_step.y != 0) {
+			for (int i = 0; i < s.height; i++) {
+				int cell = Math::fast_ftoi(Math::floor((xform.xform(Vector2(0, i)).y - snap_offset.y) / snap_step.y));
+				if (i == 0)
+					last_cell = cell;
+				if (last_cell != cell)
+					viewport->draw_line(Point2(0, i), Point2(s.width, i), Color(0.3, 0.7, 1, 0.3));
+				last_cell = cell;
 			}
 		}
 	}
@@ -1950,168 +1832,150 @@ void CanvasItemEditor::_viewport_draw() {
 	if (viewport->has_focus()) {
 		Size2 size = viewport->get_size();
 		if (v_scroll->is_visible_in_tree())
-			size.width-=v_scroll->get_size().width;
+			size.width -= v_scroll->get_size().width;
 		if (h_scroll->is_visible_in_tree())
-			size.height-=h_scroll->get_size().height;
+			size.height -= h_scroll->get_size().height;
 
-		get_stylebox("EditorFocus","EditorStyles")->draw(ci,Rect2(Point2(),size));
+		get_stylebox("EditorFocus", "EditorStyles")->draw(ci, Rect2(Point2(), size));
 	}
 
-	Ref<Texture> lock = get_icon("Lock","EditorIcons");
-	Ref<Texture> group = get_icon("Group","EditorIcons");
+	Ref<Texture> lock = get_icon("Lock", "EditorIcons");
+	Ref<Texture> group = get_icon("Group", "EditorIcons");
 
+	bool single = get_single_item() != NULL;
 
-	bool single = get_single_item()!=NULL;
+	Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-	Map<Node*,Object*> &selection = editor_selection->get_selection();
-
-	bool pivot_found=false;
-
-	for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+	bool pivot_found = false;
 
+	for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 		CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 		if (!canvas_item || !canvas_item->is_visible_in_tree())
 			continue;
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
-		CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+		CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 		if (!se)
 			continue;
 
+		Rect2 rect = canvas_item->get_item_rect();
 
-		Rect2 rect=canvas_item->get_item_rect();
+		Transform2D xform = transform * canvas_item->get_global_transform_with_canvas();
+		VisualServer::get_singleton()->canvas_item_add_set_transform(ci, xform);
 
-		Transform2D xform=transform * canvas_item->get_global_transform_with_canvas();
-		VisualServer::get_singleton()->canvas_item_add_set_transform(ci,xform);
-
-		Vector2 endpoints[4]={
+		Vector2 endpoints[4] = {
 
 			xform.xform(rect.pos),
-			xform.xform(rect.pos+Vector2(rect.size.x,0)),
-			xform.xform(rect.pos+rect.size),
-			xform.xform(rect.pos+Vector2(0,rect.size.y))
+			xform.xform(rect.pos + Vector2(rect.size.x, 0)),
+			xform.xform(rect.pos + rect.size),
+			xform.xform(rect.pos + Vector2(0, rect.size.y))
 		};
 
-		Color c = Color(1,0.6,0.4,0.7);
+		Color c = Color(1, 0.6, 0.4, 0.7);
 
-		VisualServer::get_singleton()->canvas_item_add_set_transform(ci,Transform2D());
+		VisualServer::get_singleton()->canvas_item_add_set_transform(ci, Transform2D());
 
-		for(int i=0;i<4;i++) {
-			viewport->draw_line(endpoints[i],endpoints[(i+1)%4],c,2);
+		for (int i = 0; i < 4; i++) {
+			viewport->draw_line(endpoints[i], endpoints[(i + 1) % 4], c, 2);
 		}
 
-		if (single && (tool==TOOL_SELECT || tool == TOOL_MOVE || tool == TOOL_ROTATE || tool==TOOL_EDIT_PIVOT)) { //kind of sucks
+		if (single && (tool == TOOL_SELECT || tool == TOOL_MOVE || tool == TOOL_ROTATE || tool == TOOL_EDIT_PIVOT)) { //kind of sucks
 
 			if (canvas_item->cast_to<Node2D>()) {
 
-
 				if (canvas_item->cast_to<Node2D>()->edit_has_pivot()) {
-					viewport->draw_texture(pivot,xform.get_origin()+(-pivot->get_size()/2).floor());
-					can_move_pivot=true;
-					pivot_found=true;
+					viewport->draw_texture(pivot, xform.get_origin() + (-pivot->get_size() / 2).floor());
+					can_move_pivot = true;
+					pivot_found = true;
 				}
-
 			}
 
+			if (tool == TOOL_SELECT) {
 
-			if (tool==TOOL_SELECT) {
-
+				for (int i = 0; i < 4; i++) {
 
-				for(int i=0;i<4;i++) {
-
-					int prev = (i+3)%4;
-					int next = (i+1)%4;
+					int prev = (i + 3) % 4;
+					int next = (i + 1) % 4;
 
 					Vector2 ofs = ((endpoints[i] - endpoints[prev]).normalized() + ((endpoints[i] - endpoints[next]).normalized())).normalized();
-					ofs*=1.4144*(select_handle->get_size().width/2);
-
-					select_handle->draw(ci,(endpoints[i]+ofs-(select_handle->get_size()/2)).floor());
+					ofs *= 1.4144 * (select_handle->get_size().width / 2);
 
-					ofs = (endpoints[i]+endpoints[next])/2;
-					ofs += (endpoints[next]-endpoints[i]).tangent().normalized()*(select_handle->get_size().width/2);
+					select_handle->draw(ci, (endpoints[i] + ofs - (select_handle->get_size() / 2)).floor());
 
-					select_handle->draw(ci,(ofs-(select_handle->get_size()/2)).floor());
+					ofs = (endpoints[i] + endpoints[next]) / 2;
+					ofs += (endpoints[next] - endpoints[i]).tangent().normalized() * (select_handle->get_size().width / 2);
 
+					select_handle->draw(ci, (ofs - (select_handle->get_size() / 2)).floor());
 				}
-
 			}
 		}
 
-
-
 		//DRAW_EMPTY_RECT( Rect2( current_window->get_scroll()-Point2(1,1), get_size()+Size2(2,2)), Color(0.8,0.8,1.0,0.8) );
 		//E->get().last_rect = rect;
 	}
 
 	pivot_button->set_disabled(!pivot_found);
-	VisualServer::get_singleton()->canvas_item_add_set_transform(ci,Transform2D());
+	VisualServer::get_singleton()->canvas_item_add_set_transform(ci, Transform2D());
 
+	Color x_axis_color(1.0, 0.4, 0.4, 0.6);
+	Color y_axis_color(0.4, 1.0, 0.4, 0.6);
+	Color area_axis_color(0.4, 0.4, 1.0, 0.4);
+	Color rotate_color(0.4, 0.7, 1.0, 0.8);
 
-
-	Color x_axis_color(1.0,0.4,0.4,0.6);
-	Color y_axis_color(0.4,1.0,0.4,0.6);
-	Color area_axis_color(0.4,0.4,1.0,0.4);
-	Color rotate_color(0.4,0.7,1.0,0.8);
-
-	VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(h_scroll->get_min(),0)+transform.get_origin(),Point2(h_scroll->get_max(),0)+transform.get_origin(),x_axis_color);
-	VisualServer::get_singleton()->canvas_item_add_line(ci,Point2(0,v_scroll->get_min())+transform.get_origin(),Point2(0,v_scroll->get_max())+transform.get_origin(),y_axis_color);
-
+	VisualServer::get_singleton()->canvas_item_add_line(ci, Point2(h_scroll->get_min(), 0) + transform.get_origin(), Point2(h_scroll->get_max(), 0) + transform.get_origin(), x_axis_color);
+	VisualServer::get_singleton()->canvas_item_add_line(ci, Point2(0, v_scroll->get_min()) + transform.get_origin(), Point2(0, v_scroll->get_max()) + transform.get_origin(), y_axis_color);
 
 	if (box_selecting) {
 
 		Point2 bsfrom = transform.xform(drag_from);
-		Point2 bsto= transform.xform(box_selecting_to);
+		Point2 bsto = transform.xform(box_selecting_to);
 
-
-		VisualServer::get_singleton()->canvas_item_add_rect(ci,Rect2(bsfrom,bsto-bsfrom),Color(0.7,0.7,1.0,0.3));
+		VisualServer::get_singleton()->canvas_item_add_rect(ci, Rect2(bsfrom, bsto - bsfrom), Color(0.7, 0.7, 1.0, 0.3));
 	}
 
-	if (drag==DRAG_ROTATE) {
-		VisualServer::get_singleton()->canvas_item_add_line(ci,transform.xform(display_rotate_from), transform.xform(display_rotate_to),rotate_color);
+	if (drag == DRAG_ROTATE) {
+		VisualServer::get_singleton()->canvas_item_add_line(ci, transform.xform(display_rotate_from), transform.xform(display_rotate_to), rotate_color);
 	}
 
-	Size2 screen_size = Size2( GlobalConfig::get_singleton()->get("display/window/width"), GlobalConfig::get_singleton()->get("display/window/height") );
+	Size2 screen_size = Size2(GlobalConfig::get_singleton()->get("display/window/width"), GlobalConfig::get_singleton()->get("display/window/height"));
 
-	Vector2 screen_endpoints[4]= {
-		transform.xform(Vector2(0,0)),
-		transform.xform(Vector2(screen_size.width,0)),
-		transform.xform(Vector2(screen_size.width,screen_size.height)),
-		transform.xform(Vector2(0,screen_size.height))
+	Vector2 screen_endpoints[4] = {
+		transform.xform(Vector2(0, 0)),
+		transform.xform(Vector2(screen_size.width, 0)),
+		transform.xform(Vector2(screen_size.width, screen_size.height)),
+		transform.xform(Vector2(0, screen_size.height))
 	};
 
-	for(int i=0;i<4;i++) {
-
-		VisualServer::get_singleton()->canvas_item_add_line(ci,screen_endpoints[i], screen_endpoints[(i+1)%4],area_axis_color);
+	for (int i = 0; i < 4; i++) {
 
+		VisualServer::get_singleton()->canvas_item_add_line(ci, screen_endpoints[i], screen_endpoints[(i + 1) % 4], area_axis_color);
 	}
 
-	for(List<LockList>::Element*E=lock_list.front();E;E=E->next()) {
+	for (List<LockList>::Element *E = lock_list.front(); E; E = E->next()) {
 
 		Vector2 ofs = transform.xform(E->get().pos);
 		if (E->get().lock) {
 
-			lock->draw(ci,ofs);
-			ofs.x+=lock->get_width();
+			lock->draw(ci, ofs);
+			ofs.x += lock->get_width();
 		}
 		if (E->get().group) {
 
-			group->draw(ci,ofs);
+			group->draw(ci, ofs);
 		}
-
 	}
 
 	{
 
-	       EditorNode *en = editor;
-	       EditorPluginList *over_plugin_list = en->get_editor_plugins_over();
-
-	       if (!over_plugin_list->empty()) {
+		EditorNode *en = editor;
+		EditorPluginList *over_plugin_list = en->get_editor_plugins_over();
 
-		       over_plugin_list->forward_draw_over_canvas(transform,viewport);
+		if (!over_plugin_list->empty()) {
 
-	       }
-       }
+			over_plugin_list->forward_draw_over_canvas(transform, viewport);
+		}
+	}
 
 	if (skeleton_show_bones) {
 		int bone_width = EditorSettings::get_singleton()->get("editors/2d/bone_width");
@@ -2120,16 +1984,16 @@ void CanvasItemEditor::_viewport_draw() {
 		Color bone_ik_color = EditorSettings::get_singleton()->get("editors/2d/bone_ik_color");
 		Color bone_selected_color = EditorSettings::get_singleton()->get("editors/2d/bone_selected_color");
 
-		for(Map<ObjectID,BoneList>::Element*E=bone_list.front();E;E=E->next()) {
+		for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
 
-			E->get().from=Vector2();
-			E->get().to=Vector2();
+			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>();
+			Node2D *n2d = obj->cast_to<Node2D>();
 			if (!n2d)
 				continue;
 
@@ -2138,8 +2002,7 @@ void CanvasItemEditor::_viewport_draw() {
 
 			CanvasItem *pi = n2d->get_parent_item();
 
-
-			Node2D* pn2d=n2d->get_parent()->cast_to<Node2D>();
+			Node2D *pn2d = n2d->get_parent()->cast_to<Node2D>();
 
 			if (!pn2d)
 				continue;
@@ -2147,19 +2010,17 @@ void CanvasItemEditor::_viewport_draw() {
 			Vector2 from = transform.xform(pn2d->get_global_position());
 			Vector2 to = transform.xform(n2d->get_global_position());
 
-			E->get().from=from;
-			E->get().to=to;
-
-			Vector2 rel = to-from;
-			Vector2 relt = rel.tangent().normalized()*bone_width;
-
+			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(from + rel * 0.2 + relt);
 			bone_shape.push_back(to);
-			bone_shape.push_back(from+rel*0.2-relt);
+			bone_shape.push_back(from + rel * 0.2 - relt);
 			Vector<Color> colors;
 			if (pi->has_meta("_edit_ik_")) {
 
@@ -2174,57 +2035,54 @@ void CanvasItemEditor::_viewport_draw() {
 				colors.push_back(bone_color2);
 			}
 
-
-			VisualServer::get_singleton()->canvas_item_add_primitive(ci,bone_shape,colors,Vector<Vector2>(),RID());
+			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++) {
+				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);
+					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) {
 
-	if (p_what==NOTIFICATION_FIXED_PROCESS) {
+	if (p_what == NOTIFICATION_FIXED_PROCESS) {
 
-		List<Node*> &selection = editor_selection->get_selected_node_list();
+		List<Node *> &selection = editor_selection->get_selected_node_list();
 
-		bool all_control=true;
-		bool has_control=false;
+		bool all_control = true;
+		bool has_control = false;
 
-		for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+		for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 			CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 			if (!canvas_item || !canvas_item->is_visible_in_tree())
 				continue;
 
-			if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+			if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 				continue;
 
 			if (canvas_item->cast_to<Control>())
-				has_control=true;
+				has_control = true;
 			else
-				all_control=false;
+				all_control = false;
 
-			CanvasItemEditorSelectedItem *se=editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
+			CanvasItemEditorSelectedItem *se = editor_selection->get_node_editor_data<CanvasItemEditorSelectedItem>(canvas_item);
 			if (!se)
 				continue;
 
-			Rect2 r=canvas_item->get_item_rect();
+			Rect2 r = canvas_item->get_item_rect();
 
 			Transform2D xform = canvas_item->get_transform();
 
-			if (r != se->prev_rect || xform!=se->prev_xform) {
+			if (r != se->prev_rect || xform != se->prev_xform) {
 				viewport->update();
-				se->prev_rect=r;
-				se->prev_xform=xform;
+				se->prev_rect = r;
+				se->prev_xform = xform;
 			}
-
 		}
 
 		bool show_anchor = all_control && has_control;
@@ -2235,7 +2093,7 @@ void CanvasItemEditor::_notification(int p_what) {
 				anchor_menu->hide();
 		}
 
-		for(Map<ObjectID,BoneList>::Element *E=bone_list.front();E;E=E->next()) {
+		for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
 
 			Object *b = ObjectDB::get_instance(E->get().bone);
 			if (!b) {
@@ -2249,123 +2107,110 @@ void CanvasItemEditor::_notification(int p_what) {
 				continue;
 			}
 
-			if (b2->get_global_transform()!=E->get().xform) {
+			if (b2->get_global_transform() != E->get().xform) {
 
-				E->get().xform=b2->get_global_transform();
+				E->get().xform = b2->get_global_transform();
 				viewport->update();
 			}
 		}
 	}
 
-	if (p_what==NOTIFICATION_ENTER_TREE) {
+	if (p_what == NOTIFICATION_ENTER_TREE) {
 
-		select_sb->set_texture( get_icon("EditorRect2D","EditorIcons") );
-		for(int i=0;i<4;i++) {
-			select_sb->set_margin_size(Margin(i),4);
-			select_sb->set_default_margin(Margin(i),4);
+		select_sb->set_texture(get_icon("EditorRect2D", "EditorIcons"));
+		for (int i = 0; i < 4; i++) {
+			select_sb->set_margin_size(Margin(i), 4);
+			select_sb->set_default_margin(Margin(i), 4);
 		}
 
-		select_button->set_icon( get_icon("ToolSelect","EditorIcons"));
-		list_select_button->set_icon( get_icon("ListSelect","EditorIcons"));
-		move_button->set_icon( get_icon("ToolMove","EditorIcons"));
-		rotate_button->set_icon( get_icon("ToolRotate","EditorIcons"));
-		pan_button->set_icon( get_icon("ToolPan", "EditorIcons"));
-		pivot_button->set_icon( get_icon("EditPivot", "EditorIcons"));
-		select_handle=get_icon("EditorHandle","EditorIcons");
-		lock_button->set_icon(get_icon("Lock","EditorIcons"));
-		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"));
-
+		select_button->set_icon(get_icon("ToolSelect", "EditorIcons"));
+		list_select_button->set_icon(get_icon("ListSelect", "EditorIcons"));
+		move_button->set_icon(get_icon("ToolMove", "EditorIcons"));
+		rotate_button->set_icon(get_icon("ToolRotate", "EditorIcons"));
+		pan_button->set_icon(get_icon("ToolPan", "EditorIcons"));
+		pivot_button->set_icon(get_icon("EditPivot", "EditorIcons"));
+		select_handle = get_icon("EditorHandle", "EditorIcons");
+		lock_button->set_icon(get_icon("Lock", "EditorIcons"));
+		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"));
 
 		//anchor_menu->add_icon_override("Align Top Left");
-		anchor_menu->set_icon(get_icon("Anchor","EditorIcons"));
-		PopupMenu *p=anchor_menu->get_popup();
+		anchor_menu->set_icon(get_icon("Anchor", "EditorIcons"));
+		PopupMenu *p = anchor_menu->get_popup();
 
-		p->add_icon_item(get_icon("ControlAlignTopLeft","EditorIcons"),"Top Left",ANCHOR_ALIGN_TOP_LEFT);
-		p->add_icon_item(get_icon("ControlAlignTopRight","EditorIcons"),"Top Right",ANCHOR_ALIGN_TOP_RIGHT);
-		p->add_icon_item(get_icon("ControlAlignBottomRight","EditorIcons"),"Bottom Right",ANCHOR_ALIGN_BOTTOM_RIGHT);
-		p->add_icon_item(get_icon("ControlAlignBottomLeft","EditorIcons"),"Bottom Left",ANCHOR_ALIGN_BOTTOM_LEFT);
+		p->add_icon_item(get_icon("ControlAlignTopLeft", "EditorIcons"), "Top Left", ANCHOR_ALIGN_TOP_LEFT);
+		p->add_icon_item(get_icon("ControlAlignTopRight", "EditorIcons"), "Top Right", ANCHOR_ALIGN_TOP_RIGHT);
+		p->add_icon_item(get_icon("ControlAlignBottomRight", "EditorIcons"), "Bottom Right", ANCHOR_ALIGN_BOTTOM_RIGHT);
+		p->add_icon_item(get_icon("ControlAlignBottomLeft", "EditorIcons"), "Bottom Left", ANCHOR_ALIGN_BOTTOM_LEFT);
 		p->add_separator();
-		p->add_icon_item(get_icon("ControlAlignLeftCenter","EditorIcons"),"Center Left",ANCHOR_ALIGN_CENTER_LEFT);
-		p->add_icon_item(get_icon("ControlAlignTopCenter","EditorIcons"),"Center Top",ANCHOR_ALIGN_CENTER_TOP);
-		p->add_icon_item(get_icon("ControlAlignRightCenter","EditorIcons"),"Center Right",ANCHOR_ALIGN_CENTER_RIGHT);
-		p->add_icon_item(get_icon("ControlAlignBottomCenter","EditorIcons"),"Center Bottom",ANCHOR_ALIGN_CENTER_BOTTOM);
-		p->add_icon_item(get_icon("ControlAlignCenter","EditorIcons"),"Center",ANCHOR_ALIGN_CENTER);
+		p->add_icon_item(get_icon("ControlAlignLeftCenter", "EditorIcons"), "Center Left", ANCHOR_ALIGN_CENTER_LEFT);
+		p->add_icon_item(get_icon("ControlAlignTopCenter", "EditorIcons"), "Center Top", ANCHOR_ALIGN_CENTER_TOP);
+		p->add_icon_item(get_icon("ControlAlignRightCenter", "EditorIcons"), "Center Right", ANCHOR_ALIGN_CENTER_RIGHT);
+		p->add_icon_item(get_icon("ControlAlignBottomCenter", "EditorIcons"), "Center Bottom", ANCHOR_ALIGN_CENTER_BOTTOM);
+		p->add_icon_item(get_icon("ControlAlignCenter", "EditorIcons"), "Center", ANCHOR_ALIGN_CENTER);
 		p->add_separator();
-		p->add_icon_item(get_icon("ControlAlignLeftWide","EditorIcons"),"Left Wide",ANCHOR_ALIGN_LEFT_WIDE);
-		p->add_icon_item(get_icon("ControlAlignTopWide","EditorIcons"),"Top Wide",ANCHOR_ALIGN_TOP_WIDE);
-		p->add_icon_item(get_icon("ControlAlignRightWide","EditorIcons"),"Right Wide",ANCHOR_ALIGN_RIGHT_WIDE);
-		p->add_icon_item(get_icon("ControlAlignBottomWide","EditorIcons"),"Bottom Wide",ANCHOR_ALIGN_BOTTOM_WIDE);
-		p->add_icon_item(get_icon("ControlVcenterWide","EditorIcons"),"VCenter Wide ",ANCHOR_ALIGN_VCENTER_WIDE);
-		p->add_icon_item(get_icon("ControlHcenterWide","EditorIcons"),"HCenter Wide ",ANCHOR_ALIGN_HCENTER_WIDE);
+		p->add_icon_item(get_icon("ControlAlignLeftWide", "EditorIcons"), "Left Wide", ANCHOR_ALIGN_LEFT_WIDE);
+		p->add_icon_item(get_icon("ControlAlignTopWide", "EditorIcons"), "Top Wide", ANCHOR_ALIGN_TOP_WIDE);
+		p->add_icon_item(get_icon("ControlAlignRightWide", "EditorIcons"), "Right Wide", ANCHOR_ALIGN_RIGHT_WIDE);
+		p->add_icon_item(get_icon("ControlAlignBottomWide", "EditorIcons"), "Bottom Wide", ANCHOR_ALIGN_BOTTOM_WIDE);
+		p->add_icon_item(get_icon("ControlVcenterWide", "EditorIcons"), "VCenter Wide ", ANCHOR_ALIGN_VCENTER_WIDE);
+		p->add_icon_item(get_icon("ControlHcenterWide", "EditorIcons"), "HCenter Wide ", ANCHOR_ALIGN_HCENTER_WIDE);
 		p->add_separator();
-		p->add_icon_item(get_icon("ControlAlignWide","EditorIcons"),"Full Rect",ANCHOR_ALIGN_WIDE);
-
+		p->add_icon_item(get_icon("ControlAlignWide", "EditorIcons"), "Full Rect", ANCHOR_ALIGN_WIDE);
 
-		AnimationPlayerEditor::singleton->get_key_editor()->connect("visibility_changed",this,"_keying_changed");
+		AnimationPlayerEditor::singleton->get_key_editor()->connect("visibility_changed", this, "_keying_changed");
 		_keying_changed();
 	}
 
-	if (p_what==NOTIFICATION_READY) {
+	if (p_what == NOTIFICATION_READY) {
 
-		get_tree()->connect("node_removed",this,"_node_removed");
+		get_tree()->connect("node_removed", this, "_node_removed");
 	}
 
-	if (p_what==NOTIFICATION_DRAW) {
-
-
-
+	if (p_what == NOTIFICATION_DRAW) {
 	}
 }
 
 void CanvasItemEditor::edit(CanvasItem *p_canvas_item) {
 
-	drag=DRAG_NONE;
+	drag = DRAG_NONE;
 
-	editor_selection->clear();//_clear_canvas_items();
+	editor_selection->clear(); //_clear_canvas_items();
 	editor_selection->add_node(p_canvas_item);
 	//_add_canvas_item(p_canvas_item);
 	viewport->update();
-
 }
 
-
-void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2& r_rect, const Transform2D& p_xform) {
-
-
+void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2 &r_rect, const Transform2D &p_xform) {
 
 	if (!p_node)
 		return;
 
-	CanvasItem *c=p_node->cast_to<CanvasItem>();
-
+	CanvasItem *c = p_node->cast_to<CanvasItem>();
 
-	for (int i=p_node->get_child_count()-1;i>=0;i--) {
+	for (int i = p_node->get_child_count() - 1; i >= 0; i--) {
 
 		//CanvasItem *r=NULL;
 
 		if (c && !c->is_set_as_toplevel())
-			_find_canvas_items_span(p_node->get_child(i),r_rect,p_xform * c->get_transform());
+			_find_canvas_items_span(p_node->get_child(i), r_rect, p_xform * c->get_transform());
 		else
-			_find_canvas_items_span(p_node->get_child(i),r_rect,Transform2D());
+			_find_canvas_items_span(p_node->get_child(i), r_rect, Transform2D());
 	}
 
-
-
 	if (c && c->is_visible_in_tree()) {
 
 		Rect2 rect = c->get_item_rect();
 		Transform2D xform = p_xform * c->get_transform();
 
-
 		LockList lock;
-		lock.lock=c->has_meta("_edit_lock_");
-		lock.group=c->has_meta("_edit_group_");
+		lock.lock = c->has_meta("_edit_lock_");
+		lock.group = c->has_meta("_edit_group_");
 
 		if (lock.group || lock.lock) {
-			lock.pos=xform.xform(rect.pos);
+			lock.pos = xform.xform(rect.pos);
 			lock_list.push_back(lock);
 		}
 
@@ -2374,221 +2219,205 @@ void CanvasItemEditor::_find_canvas_items_span(Node *p_node, Rect2& r_rect, cons
 			ObjectID id = c->get_instance_ID();
 			if (!bone_list.has(id)) {
 				BoneList bone;
-				bone.bone=id;
-				bone_list[id]=bone;
+				bone.bone = id;
+				bone_list[id] = bone;
 			}
 
-			bone_list[id].last_pass=bone_last_frame;
+			bone_list[id].last_pass = bone_last_frame;
 		}
 
-		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)) );
-		r_rect.expand_to( xform.xform(rect.pos+rect.size) );
-
+		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)));
+		r_rect.expand_to(xform.xform(rect.pos + rect.size));
 	}
-
 }
 
 void CanvasItemEditor::_update_scrollbars() {
 
-
-	updating_scroll=true;
+	updating_scroll = true;
 
 	Size2 size = viewport->get_size();
 	Size2 hmin = h_scroll->get_minimum_size();
 	Size2 vmin = v_scroll->get_minimum_size();
 
-	v_scroll->set_begin( Point2(size.width - vmin.width, 0) );
-	v_scroll->set_end( Point2(size.width, size.height) );
-
-	h_scroll->set_begin( Point2( 0, size.height - hmin.height) );
-	h_scroll->set_end( Point2(size.width-vmin.width, size.height) );
-
+	v_scroll->set_begin(Point2(size.width - vmin.width, 0));
+	v_scroll->set_end(Point2(size.width, size.height));
 
-	Size2 screen_rect = Size2( GlobalConfig::get_singleton()->get("display/window/width"), GlobalConfig::get_singleton()->get("display/window/height") );
+	h_scroll->set_begin(Point2(0, size.height - hmin.height));
+	h_scroll->set_end(Point2(size.width - vmin.width, size.height));
 
+	Size2 screen_rect = Size2(GlobalConfig::get_singleton()->get("display/window/width"), GlobalConfig::get_singleton()->get("display/window/height"));
 
-	Rect2 local_rect = Rect2(Point2(),viewport->get_size()-Size2(vmin.width,hmin.height));
+	Rect2 local_rect = Rect2(Point2(), viewport->get_size() - Size2(vmin.width, hmin.height));
 
-	Rect2 canvas_item_rect=Rect2(Point2(),screen_rect);
+	Rect2 canvas_item_rect = Rect2(Point2(), screen_rect);
 
 	lock_list.clear();
 	bone_last_frame++;
 
-
-
 	if (editor->get_edited_scene())
-		_find_canvas_items_span(editor->get_edited_scene(),canvas_item_rect,Transform2D());
+		_find_canvas_items_span(editor->get_edited_scene(), canvas_item_rect, Transform2D());
 
-	List<Map<ObjectID,BoneList>::Element*> bone_to_erase;
+	List<Map<ObjectID, BoneList>::Element *> bone_to_erase;
 
-	for(Map<ObjectID,BoneList>::Element*E=bone_list.front();E;E=E->next()) {
+	for (Map<ObjectID, BoneList>::Element *E = bone_list.front(); E; E = E->next()) {
 
-		if (E->get().last_pass!=bone_last_frame) {
+		if (E->get().last_pass != bone_last_frame) {
 			bone_to_erase.push_back(E);
 		}
 	}
 
-	while(bone_to_erase.size()) {
+	while (bone_to_erase.size()) {
 		bone_list.erase(bone_to_erase.front()->get());
 		bone_to_erase.pop_front();
 	}
 
 	//expand area so it's easier to do animations and stuff at 0,0
-	canvas_item_rect.size+=screen_rect*2;
-	canvas_item_rect.pos-=screen_rect;
+	canvas_item_rect.size += screen_rect * 2;
+	canvas_item_rect.pos -= screen_rect;
 
 	Point2 ofs;
 
-
-	if (canvas_item_rect.size.height <= (local_rect.size.y/zoom)) {
+	if (canvas_item_rect.size.height <= (local_rect.size.y / zoom)) {
 
 		v_scroll->hide();
-		ofs.y=canvas_item_rect.pos.y;
+		ofs.y = canvas_item_rect.pos.y;
 	} else {
 
 		v_scroll->show();
 		v_scroll->set_min(canvas_item_rect.pos.y);
-		v_scroll->set_max(canvas_item_rect.pos.y+canvas_item_rect.size.y);
-		v_scroll->set_page(local_rect.size.y/zoom);
+		v_scroll->set_max(canvas_item_rect.pos.y + canvas_item_rect.size.y);
+		v_scroll->set_page(local_rect.size.y / zoom);
 		if (first_update) {
 			//so 0,0 is visible
 			v_scroll->set_value(-10);
 			h_scroll->set_value(-10);
-			first_update=false;
-
+			first_update = false;
 		}
 
-		ofs.y=v_scroll->get_value();
+		ofs.y = v_scroll->get_value();
 	}
 
-	if (canvas_item_rect.size.width <= (local_rect.size.x/zoom)) {
+	if (canvas_item_rect.size.width <= (local_rect.size.x / zoom)) {
 
 		h_scroll->hide();
-		ofs.x=canvas_item_rect.pos.x;
+		ofs.x = canvas_item_rect.pos.x;
 	} else {
 
 		h_scroll->show();
 		h_scroll->set_min(canvas_item_rect.pos.x);
-		h_scroll->set_max(canvas_item_rect.pos.x+canvas_item_rect.size.x);
-		h_scroll->set_page(local_rect.size.x/zoom);
-		ofs.x=h_scroll->get_value();
+		h_scroll->set_max(canvas_item_rect.pos.x + canvas_item_rect.size.x);
+		h_scroll->set_page(local_rect.size.x / zoom);
+		ofs.x = h_scroll->get_value();
 	}
 
 	//transform=Matrix32();
-	transform.elements[2]=-ofs*zoom;
+	transform.elements[2] = -ofs * zoom;
 
 	editor->get_scene_root()->set_global_canvas_transform(transform);
 
-
-	updating_scroll=false;
+	updating_scroll = false;
 
 	//transform.scale_basis(Vector2(zoom,zoom));
-
-
 }
 
 void CanvasItemEditor::_update_scroll(float) {
 
-
 	if (updating_scroll)
 		return;
 
 	Point2 ofs;
-	ofs.x=h_scroll->get_value();
-	ofs.y=v_scroll->get_value();
+	ofs.x = h_scroll->get_value();
+	ofs.y = v_scroll->get_value();
 
 	//current_window->set_scroll(-ofs);
 
-	transform=Transform2D();
+	transform = Transform2D();
 
-	transform.scale_basis(Size2(zoom,zoom));
-	transform.elements[2]=-ofs;
+	transform.scale_basis(Size2(zoom, zoom));
+	transform.elements[2] = -ofs;
 
 	editor->get_scene_root()->set_global_canvas_transform(transform);
 
-
 	viewport->update();
-
 }
 
-void CanvasItemEditor::_set_anchor(Control::AnchorType p_left,Control::AnchorType p_top,Control::AnchorType p_right,Control::AnchorType p_bottom) {
-	List<Node*> &selection = editor_selection->get_selected_node_list();
+void CanvasItemEditor::_set_anchor(Control::AnchorType p_left, Control::AnchorType p_top, Control::AnchorType p_right, Control::AnchorType p_bottom) {
+	List<Node *> &selection = editor_selection->get_selected_node_list();
 
 	undo_redo->create_action(TTR("Change Anchors"));
-	for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+	for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 		Control *c = E->get()->cast_to<Control>();
 
-		undo_redo->add_do_method(c,"set_anchor",MARGIN_LEFT,p_left);
-		undo_redo->add_do_method(c,"set_anchor",MARGIN_TOP,p_top);
-		undo_redo->add_do_method(c,"set_anchor",MARGIN_RIGHT,p_right);
-		undo_redo->add_do_method(c,"set_anchor",MARGIN_BOTTOM,p_bottom);
-		undo_redo->add_undo_method(c,"set_anchor",MARGIN_LEFT,c->get_anchor(MARGIN_LEFT));
-		undo_redo->add_undo_method(c,"set_anchor",MARGIN_TOP,c->get_anchor(MARGIN_TOP));
-		undo_redo->add_undo_method(c,"set_anchor",MARGIN_RIGHT,c->get_anchor(MARGIN_RIGHT));
-		undo_redo->add_undo_method(c,"set_anchor",MARGIN_BOTTOM,c->get_anchor(MARGIN_BOTTOM));
+		undo_redo->add_do_method(c, "set_anchor", MARGIN_LEFT, p_left);
+		undo_redo->add_do_method(c, "set_anchor", MARGIN_TOP, p_top);
+		undo_redo->add_do_method(c, "set_anchor", MARGIN_RIGHT, p_right);
+		undo_redo->add_do_method(c, "set_anchor", MARGIN_BOTTOM, p_bottom);
+		undo_redo->add_undo_method(c, "set_anchor", MARGIN_LEFT, c->get_anchor(MARGIN_LEFT));
+		undo_redo->add_undo_method(c, "set_anchor", MARGIN_TOP, c->get_anchor(MARGIN_TOP));
+		undo_redo->add_undo_method(c, "set_anchor", MARGIN_RIGHT, c->get_anchor(MARGIN_RIGHT));
+		undo_redo->add_undo_method(c, "set_anchor", MARGIN_BOTTOM, c->get_anchor(MARGIN_BOTTOM));
 	}
 
 	undo_redo->commit_action();
-
 }
 
 void CanvasItemEditor::_popup_callback(int p_op) {
 
-	last_option=MenuOption(p_op);
-	switch(p_op) {
+	last_option = MenuOption(p_op);
+	switch (p_op) {
 
 		case SNAP_USE: {
 			snap_grid = !snap_grid;
 			int idx = edit_menu->get_popup()->get_item_index(SNAP_USE);
-			edit_menu->get_popup()->set_item_checked(idx,snap_grid);
+			edit_menu->get_popup()->set_item_checked(idx, snap_grid);
 		} break;
 		case SNAP_SHOW_GRID: {
 			snap_show_grid = !snap_show_grid;
 			int idx = edit_menu->get_popup()->get_item_index(SNAP_SHOW_GRID);
-			edit_menu->get_popup()->set_item_checked(idx,snap_show_grid);
+			edit_menu->get_popup()->set_item_checked(idx, snap_show_grid);
 			viewport->update();
 		} break;
 		case SNAP_USE_ROTATION: {
 			snap_rotation = !snap_rotation;
 			int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_ROTATION);
-			edit_menu->get_popup()->set_item_checked(idx,snap_rotation);
+			edit_menu->get_popup()->set_item_checked(idx, snap_rotation);
 		} break;
 		case SNAP_RELATIVE: {
 			snap_relative = !snap_relative;
 			int idx = edit_menu->get_popup()->get_item_index(SNAP_RELATIVE);
-			edit_menu->get_popup()->set_item_checked(idx,snap_relative);
+			edit_menu->get_popup()->set_item_checked(idx, snap_relative);
 		} break;
 		case SNAP_USE_PIXEL: {
 			snap_pixel = !snap_pixel;
 			int idx = edit_menu->get_popup()->get_item_index(SNAP_USE_PIXEL);
-			edit_menu->get_popup()->set_item_checked(idx,snap_pixel);
+			edit_menu->get_popup()->set_item_checked(idx, snap_pixel);
 		} break;
 		case SNAP_CONFIGURE: {
 			((SnapDialog *)snap_dialog)->set_fields(snap_offset, snap_step, snap_rotation_offset, snap_rotation_step);
-			snap_dialog->popup_centered(Size2(220,160));
+			snap_dialog->popup_centered(Size2(220, 160));
 		} break;
 		case SKELETON_SHOW_BONES: {
 			skeleton_show_bones = !skeleton_show_bones;
 			int idx = skeleton_menu->get_item_index(SKELETON_SHOW_BONES);
-			skeleton_menu->set_item_checked(idx,skeleton_show_bones);
+			skeleton_menu->set_item_checked(idx, skeleton_show_bones);
 			viewport->update();
 		} break;
 		case ZOOM_IN: {
-			if (zoom>MAX_ZOOM)
+			if (zoom > MAX_ZOOM)
 				return;
-			zoom=zoom*(1.0/0.5);
+			zoom = zoom * (1.0 / 0.5);
 			_update_scroll(0);
 			viewport->update();
 			return;
 		} break;
 		case ZOOM_OUT: {
-			if (zoom<MIN_ZOOM)
+			if (zoom < MIN_ZOOM)
 				return;
 
-			zoom=zoom*0.5;
+			zoom = zoom * 0.5;
 			_update_scroll(0);
 			viewport->update();
 			return;
@@ -2596,7 +2425,7 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 		} break;
 		case ZOOM_RESET: {
 
-			zoom=1;
+			zoom = 1;
 			_update_scroll(0);
 			viewport->update();
 			return;
@@ -2604,51 +2433,49 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 		} break;
 		case ZOOM_SET: {
 
-			updating_value_dialog=true;
+			updating_value_dialog = true;
 
 			dialog_label->set_text(TTR("Zoom (%):"));
 			dialog_val->set_min(0.1);
 			dialog_val->set_step(0.1);
 			dialog_val->set_max(800);
-			dialog_val->set_value(zoom*100);
-			value_dialog->popup_centered(Size2(200,85));
-			updating_value_dialog=false;
-
+			dialog_val->set_value(zoom * 100);
+			value_dialog->popup_centered(Size2(200, 85));
+			updating_value_dialog = false;
 
 		} break;
 		case LOCK_SELECTED: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				canvas_item->set_meta("_edit_lock_",true);
+				canvas_item->set_meta("_edit_lock_", true);
 				emit_signal("item_lock_status_changed");
 			}
 			viewport->update();
 		} break;
 		case UNLOCK_SELECTED: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-
-				canvas_item->set_meta("_edit_lock_",Variant());
+				canvas_item->set_meta("_edit_lock_", Variant());
 				emit_signal("item_lock_status_changed");
 			}
 
@@ -2657,36 +2484,36 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 		} break;
 		case GROUP_SELECTED: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				canvas_item->set_meta("_edit_group_",true);
+				canvas_item->set_meta("_edit_group_", true);
 				emit_signal("item_group_status_changed");
 			}
 			viewport->update();
 		} break;
 		case UNGROUP_SELECTED: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				canvas_item->set_meta("_edit_group_",Variant());
+				canvas_item->set_meta("_edit_group_", Variant());
 				emit_signal("item_group_status_changed");
 			}
 
@@ -2696,23 +2523,21 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 
 		case EXPAND_TO_PARENT: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-
 				Control *c = canvas_item->cast_to<Control>();
 				if (!c)
 					continue;
 				c->set_area_as_parent_rect();
-
 			}
 
 			viewport->update();
@@ -2763,114 +2588,111 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 			//space_selected_items< proj_vector2_y, compare_items_y >();
 		} break;
 		case ANCHOR_ALIGN_TOP_LEFT: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_BEGIN);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN);
 		} break;
 		case ANCHOR_ALIGN_TOP_RIGHT: {
-			_set_anchor(ANCHOR_END,ANCHOR_BEGIN,ANCHOR_END,ANCHOR_BEGIN);
+			_set_anchor(ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN);
 		} break;
 		case ANCHOR_ALIGN_BOTTOM_LEFT: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_END,ANCHOR_BEGIN,ANCHOR_END);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_BOTTOM_RIGHT: {
-			_set_anchor(ANCHOR_END,ANCHOR_END,ANCHOR_END,ANCHOR_END);
+			_set_anchor(ANCHOR_END, ANCHOR_END, ANCHOR_END, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_CENTER_LEFT: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_CENTER,ANCHOR_BEGIN,ANCHOR_CENTER);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER);
 		} break;
 		case ANCHOR_ALIGN_CENTER_RIGHT: {
 
-			_set_anchor(ANCHOR_END,ANCHOR_CENTER,ANCHOR_END,ANCHOR_CENTER);
+			_set_anchor(ANCHOR_END, ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER);
 		} break;
 		case ANCHOR_ALIGN_CENTER_TOP: {
-			_set_anchor(ANCHOR_CENTER,ANCHOR_BEGIN,ANCHOR_CENTER,ANCHOR_BEGIN);
+			_set_anchor(ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_BEGIN);
 		} break;
 		case ANCHOR_ALIGN_CENTER_BOTTOM: {
-			_set_anchor(ANCHOR_CENTER,ANCHOR_END,ANCHOR_CENTER,ANCHOR_END);
+			_set_anchor(ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_CENTER: {
-			_set_anchor(ANCHOR_CENTER,ANCHOR_CENTER,ANCHOR_CENTER,ANCHOR_CENTER);
+			_set_anchor(ANCHOR_CENTER, ANCHOR_CENTER, ANCHOR_CENTER, ANCHOR_CENTER);
 		} break;
 		case ANCHOR_ALIGN_TOP_WIDE: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_END,ANCHOR_BEGIN);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_BEGIN);
 		} break;
 		case ANCHOR_ALIGN_LEFT_WIDE: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_END);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_RIGHT_WIDE: {
-			_set_anchor(ANCHOR_END,ANCHOR_BEGIN,ANCHOR_END,ANCHOR_END);
+			_set_anchor(ANCHOR_END, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_BOTTOM_WIDE: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_END,ANCHOR_END,ANCHOR_END);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_VCENTER_WIDE: {
-			_set_anchor(ANCHOR_CENTER,ANCHOR_BEGIN,ANCHOR_CENTER,ANCHOR_END);
+			_set_anchor(ANCHOR_CENTER, ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_END);
 		} break;
 		case ANCHOR_ALIGN_HCENTER_WIDE: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_CENTER,ANCHOR_END,ANCHOR_CENTER);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_CENTER, ANCHOR_END, ANCHOR_CENTER);
 		} break;
 		case ANCHOR_ALIGN_WIDE: {
-			_set_anchor(ANCHOR_BEGIN,ANCHOR_BEGIN,ANCHOR_END,ANCHOR_END);
+			_set_anchor(ANCHOR_BEGIN, ANCHOR_BEGIN, ANCHOR_END, ANCHOR_END);
 		} break;
 
 		case ANIM_INSERT_KEY:
 		case ANIM_INSERT_KEY_EXISTING: {
 
-			bool existing = p_op==ANIM_INSERT_KEY_EXISTING;
+			bool existing = p_op == ANIM_INSERT_KEY_EXISTING;
 
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
 				if (canvas_item->cast_to<Node2D>()) {
 					Node2D *n2d = canvas_item->cast_to<Node2D>();
 
 					if (key_pos)
-						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d,"transform/pos",n2d->get_position(),existing);
+						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d, "transform/pos", n2d->get_position(), existing);
 					if (key_rot)
-						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d,"transform/rot",Math::rad2deg(n2d->get_rotation()),existing);
+						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d, "transform/rot", Math::rad2deg(n2d->get_rotation()), existing);
 					if (key_scale)
-						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(n2d,"transform/scale",n2d->get_scale(),existing);
-
+						AnimationPlayerEditor::singleton->get_key_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;
+						List<Node2D *> ik_chain;
 
 						Node2D *n = n2d->get_parent_item()->cast_to<Node2D>();
-						bool has_chain=false;
+						bool has_chain = false;
 
-						while(n) {
+						while (n) {
 
 							ik_chain.push_back(n);
 							if (n->has_meta("_edit_ik_")) {
-								has_chain=true;
+								has_chain = true;
 								break;
 							}
 
 							if (!n->get_parent_item())
 								break;
-							n=n->get_parent_item()->cast_to<Node2D>();
+							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()) {
+							for (List<Node2D *>::Element *F = ik_chain.front(); F; F = F->next()) {
 
 								if (key_pos)
-									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(),"transform/pos",F->get()->get_position(),existing);
+									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/pos", F->get()->get_position(), existing);
 								if (key_rot)
-									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(),"transform/rot",Math::rad2deg(F->get()->get_rotation()),existing);
+									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/rot", Math::rad2deg(F->get()->get_rotation()), existing);
 								if (key_scale)
-									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(),"transform/scale",F->get()->get_scale(),existing);
-
-
+									AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(F->get(), "transform/scale", F->get()->get_scale(), existing);
 							}
 						}
 					}
@@ -2880,11 +2702,10 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 					Control *ctrl = canvas_item->cast_to<Control>();
 
 					if (key_pos)
-						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl,"rect/pos",ctrl->get_pos(),existing);
+						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl, "rect/pos", ctrl->get_pos(), existing);
 					if (key_scale)
-						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl,"rect/size",ctrl->get_size(),existing);
+						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl, "rect/size", ctrl->get_size(), existing);
 				}
-
 			}
 
 		} break;
@@ -2900,7 +2721,7 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 
 			key_scale = key_scale_button->is_pressed();
 		} break;
-			/*
+		/*
 		case ANIM_INSERT_POS_ROT
 		case ANIM_INSERT_POS_SCALE:
 		case ANIM_INSERT_ROT_SCALE:
@@ -2929,32 +2750,29 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 
 			pose_clipboard.clear();
 
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
-
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-
 				if (canvas_item->cast_to<Node2D>()) {
 
 					Node2D *n2d = canvas_item->cast_to<Node2D>();
 					PoseClipboard pc;
-					pc.pos=n2d->get_position();
-					pc.rot=n2d->get_rotation();
-					pc.scale=n2d->get_scale();
-					pc.id=n2d->get_instance_ID();
+					pc.pos = n2d->get_position();
+					pc.rot = n2d->get_rotation();
+					pc.scale = n2d->get_scale();
+					pc.id = n2d->get_instance_ID();
 					pose_clipboard.push_back(pc);
 				}
 			}
 
-
 		} break;
 		case ANIM_PASTE_POSE: {
 
@@ -2962,7 +2780,7 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				break;
 
 			undo_redo->create_action(TTR("Paste Pose"));
-			for (List<PoseClipboard>::Element *E=pose_clipboard.front();E;E=E->next()) {
+			for (List<PoseClipboard>::Element *E = pose_clipboard.front(); E; E = E->next()) {
 
 				Object *o = ObjectDB::get_instance(E->get().id);
 				if (!o)
@@ -2970,27 +2788,27 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				Node2D *n2d = o->cast_to<Node2D>();
 				if (!n2d)
 					continue;
-				undo_redo->add_do_method(n2d,"set_pos",E->get().pos);
-				undo_redo->add_do_method(n2d,"set_rot",E->get().rot);
-				undo_redo->add_do_method(n2d,"set_scale",E->get().scale);
-				undo_redo->add_undo_method(n2d,"set_pos",n2d->get_position());
-				undo_redo->add_undo_method(n2d,"set_rot",n2d->get_rotation());
-				undo_redo->add_undo_method(n2d,"set_scale",n2d->get_scale());
+				undo_redo->add_do_method(n2d, "set_pos", E->get().pos);
+				undo_redo->add_do_method(n2d, "set_rot", E->get().rot);
+				undo_redo->add_do_method(n2d, "set_scale", E->get().scale);
+				undo_redo->add_undo_method(n2d, "set_pos", n2d->get_position());
+				undo_redo->add_undo_method(n2d, "set_rot", n2d->get_rotation());
+				undo_redo->add_undo_method(n2d, "set_scale", n2d->get_scale());
 			}
 			undo_redo->commit_action();
 
 		} break;
 		case ANIM_CLEAR_POSE: {
 
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
 				if (canvas_item->cast_to<Node2D>()) {
@@ -3001,7 +2819,7 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 					if (key_rot)
 						n2d->set_rotation(0);
 					if (key_scale)
-						n2d->set_scale(Vector2(1,1));
+						n2d->set_scale(Vector2(1, 1));
 				} else if (canvas_item->cast_to<Control>()) {
 
 					Control *ctrl = canvas_item->cast_to<Control>();
@@ -3013,10 +2831,8 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 						AnimationPlayerEditor::singleton->get_key_editor()->insert_node_value_key(ctrl,"rect/size",ctrl->get_size());
 					*/
 				}
-
 			}
 
-
 		} break;
 		case VIEW_CENTER_TO_SELECTION:
 		case VIEW_FRAME_TO_SELECTION: {
@@ -3026,11 +2842,9 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 		} break;
 		case SKELETON_MAKE_BONES: {
 
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
-
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				Node2D *n2d = E->key()->cast_to<Node2D>();
 				if (!n2d)
@@ -3040,19 +2854,18 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				if (!n2d->get_parent_item())
 					continue;
 
-				n2d->set_meta("_edit_bone_",true);
+				n2d->set_meta("_edit_bone_", true);
 				if (!skeleton_show_bones)
 					skeleton_menu->activate_item(skeleton_menu->get_item_index(SKELETON_SHOW_BONES));
-
 			}
 			viewport->update();
 
 		} break;
 		case SKELETON_CLEAR_BONES: {
 
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				Node2D *n2d = E->key()->cast_to<Node2D>();
 				if (!n2d)
@@ -3060,31 +2873,29 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				if (!n2d->is_visible_in_tree())
 					continue;
 
-				n2d->set_meta("_edit_bone_",Variant());
+				n2d->set_meta("_edit_bone_", Variant());
 				if (!skeleton_show_bones)
 					skeleton_menu->activate_item(skeleton_menu->get_item_index(SKELETON_SHOW_BONES));
-
 			}
 			viewport->update();
 
 		} break;
 		case SKELETON_SET_IK_CHAIN: {
 
-			List<Node*> &selection = editor_selection->get_selected_node_list();
+			List<Node *> &selection = editor_selection->get_selected_node_list();
 
-			for(List<Node*>::Element *E=selection.front();E;E=E->next()) {
+			for (List<Node *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *canvas_item = E->get()->cast_to<CanvasItem>();
 				if (!canvas_item || !canvas_item->is_visible_in_tree())
 					continue;
 
-				if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+				if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 					continue;
 
-				canvas_item->set_meta("_edit_ik_",true);
+				canvas_item->set_meta("_edit_ik_", true);
 				if (!skeleton_show_bones)
 					skeleton_menu->activate_item(skeleton_menu->get_item_index(SKELETON_SHOW_BONES));
-
 			}
 
 			viewport->update();
@@ -3092,9 +2903,9 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 		} break;
 		case SKELETON_CLEAR_IK_CHAIN: {
 
-			Map<Node*,Object*> &selection = editor_selection->get_selection();
+			Map<Node *, Object *> &selection = editor_selection->get_selection();
 
-			for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+			for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 
 				CanvasItem *n2d = E->key()->cast_to<CanvasItem>();
 				if (!n2d)
@@ -3102,15 +2913,13 @@ void CanvasItemEditor::_popup_callback(int p_op) {
 				if (!n2d->is_visible_in_tree())
 					continue;
 
-				n2d->set_meta("_edit_ik_",Variant());
+				n2d->set_meta("_edit_ik_", Variant());
 				if (!skeleton_show_bones)
 					skeleton_menu->activate_item(skeleton_menu->get_item_index(SKELETON_SHOW_BONES));
-
 			}
 			viewport->update();
 
 		} break;
-
 	}
 }
 #if 0
@@ -3142,20 +2951,18 @@ template< class P, class C > void CanvasItemEditor::space_selected_items() {
 }
 #endif
 
-
 void CanvasItemEditor::_focus_selection(int p_op) {
 	Vector2 center(0.f, 0.f);
 	Rect2 rect;
 	int count = 0;
 
-	Map<Node*,Object*> &selection = editor_selection->get_selection();
-	for(Map<Node*,Object*>::Element *E=selection.front();E;E=E->next()) {
+	Map<Node *, Object *> &selection = editor_selection->get_selection();
+	for (Map<Node *, Object *>::Element *E = selection.front(); E; E = E->next()) {
 		CanvasItem *canvas_item = E->key()->cast_to<CanvasItem>();
 		if (!canvas_item) continue;
-		if (canvas_item->get_viewport()!=EditorNode::get_singleton()->get_scene_root())
+		if (canvas_item->get_viewport() != EditorNode::get_singleton()->get_scene_root())
 			continue;
 
-
 		// counting invisible items, for now
 		//if (!canvas_item->is_visible_in_tree()) continue;
 		++count;
@@ -3166,30 +2973,30 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 		Vector2 scale = canvas_item->get_global_transform().get_scale();
 		real_t angle = canvas_item->get_global_transform().get_rotation();
 
-		Transform2D t(angle, Vector2(0.f,0.f));
+		Transform2D t(angle, Vector2(0.f, 0.f));
 		item_rect = t.xform(item_rect);
-		Rect2 canvas_item_rect(pos + scale*item_rect.pos, scale*item_rect.size);
+		Rect2 canvas_item_rect(pos + scale * item_rect.pos, scale * item_rect.size);
 		if (count == 1) {
 			rect = canvas_item_rect;
 		} else {
 			rect = rect.merge(canvas_item_rect);
 		}
 	};
-	if (count==0) return;
+	if (count == 0) return;
 
 	if (p_op == VIEW_CENTER_TO_SELECTION) {
 
-		center = rect.pos + rect.size/2;
-		Vector2 offset = viewport->get_size()/2 - editor->get_scene_root()->get_global_canvas_transform().xform(center);
-		h_scroll->set_value(h_scroll->get_value() - offset.x/zoom);
-		v_scroll->set_value(v_scroll->get_value() - offset.y/zoom);
+		center = rect.pos + rect.size / 2;
+		Vector2 offset = viewport->get_size() / 2 - editor->get_scene_root()->get_global_canvas_transform().xform(center);
+		h_scroll->set_value(h_scroll->get_value() - offset.x / zoom);
+		v_scroll->set_value(v_scroll->get_value() - offset.y / zoom);
 
 	} else { // VIEW_FRAME_TO_SELECTION
 
 		if (rect.size.x > CMP_EPSILON && rect.size.y > CMP_EPSILON) {
-			float scale_x = viewport->get_size().x/rect.size.x;
-			float scale_y = viewport->get_size().y/rect.size.y;
-			zoom = scale_x < scale_y? scale_x:scale_y;
+			float scale_x = viewport->get_size().x / rect.size.x;
+			float scale_y = viewport->get_size().y / rect.size.y;
+			zoom = scale_x < scale_y ? scale_x : scale_y;
 			zoom *= 0.90;
 			_update_scroll(0);
 			call_deferred("_popup_callback", VIEW_CENTER_TO_SELECTION);
@@ -3197,27 +3004,25 @@ void CanvasItemEditor::_focus_selection(int p_op) {
 	}
 }
 
-
 void CanvasItemEditor::_bind_methods() {
 
-	ClassDB::bind_method("_node_removed",&CanvasItemEditor::_node_removed);
-	ClassDB::bind_method("_update_scroll",&CanvasItemEditor::_update_scroll);
-	ClassDB::bind_method("_popup_callback",&CanvasItemEditor::_popup_callback);
-	ClassDB::bind_method("_visibility_changed",&CanvasItemEditor::_visibility_changed);
-	ClassDB::bind_method("_dialog_value_changed",&CanvasItemEditor::_dialog_value_changed);
-	ClassDB::bind_method("_get_editor_data",&CanvasItemEditor::_get_editor_data);
-	ClassDB::bind_method("_tool_select",&CanvasItemEditor::_tool_select);
-	ClassDB::bind_method("_keying_changed",&CanvasItemEditor::_keying_changed);
-	ClassDB::bind_method("_unhandled_key_input",&CanvasItemEditor::_unhandled_key_input);
-	ClassDB::bind_method("_viewport_draw",&CanvasItemEditor::_viewport_draw);
-	ClassDB::bind_method("_viewport_gui_input",&CanvasItemEditor::_viewport_gui_input);
-	ClassDB::bind_method("_snap_changed",&CanvasItemEditor::_snap_changed);
-	ClassDB::bind_method(D_METHOD("_selection_result_pressed"),&CanvasItemEditor::_selection_result_pressed);
-	ClassDB::bind_method(D_METHOD("_selection_menu_hide"),&CanvasItemEditor::_selection_menu_hide);
-
-	ADD_SIGNAL( MethodInfo("item_lock_status_changed") );
-	ADD_SIGNAL( MethodInfo("item_group_status_changed") );
+	ClassDB::bind_method("_node_removed", &CanvasItemEditor::_node_removed);
+	ClassDB::bind_method("_update_scroll", &CanvasItemEditor::_update_scroll);
+	ClassDB::bind_method("_popup_callback", &CanvasItemEditor::_popup_callback);
+	ClassDB::bind_method("_visibility_changed", &CanvasItemEditor::_visibility_changed);
+	ClassDB::bind_method("_dialog_value_changed", &CanvasItemEditor::_dialog_value_changed);
+	ClassDB::bind_method("_get_editor_data", &CanvasItemEditor::_get_editor_data);
+	ClassDB::bind_method("_tool_select", &CanvasItemEditor::_tool_select);
+	ClassDB::bind_method("_keying_changed", &CanvasItemEditor::_keying_changed);
+	ClassDB::bind_method("_unhandled_key_input", &CanvasItemEditor::_unhandled_key_input);
+	ClassDB::bind_method("_viewport_draw", &CanvasItemEditor::_viewport_draw);
+	ClassDB::bind_method("_viewport_gui_input", &CanvasItemEditor::_viewport_gui_input);
+	ClassDB::bind_method("_snap_changed", &CanvasItemEditor::_snap_changed);
+	ClassDB::bind_method(D_METHOD("_selection_result_pressed"), &CanvasItemEditor::_selection_result_pressed);
+	ClassDB::bind_method(D_METHOD("_selection_menu_hide"), &CanvasItemEditor::_selection_menu_hide);
 
+	ADD_SIGNAL(MethodInfo("item_lock_status_changed"));
+	ADD_SIGNAL(MethodInfo("item_group_status_changed"));
 }
 
 #if 0
@@ -3303,142 +3108,135 @@ VSplitContainer *CanvasItemEditor::get_bottom_split() {
 	return bottom_split;
 }
 
-
 void CanvasItemEditor::focus_selection() {
 	_focus_selection(VIEW_CENTER_TO_SELECTION);
 }
 
-
 CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 
 	tool = TOOL_SELECT;
-	undo_redo=p_editor->get_undo_redo();
-	editor=p_editor;
-	editor_selection=p_editor->get_editor_selection();
+	undo_redo = p_editor->get_undo_redo();
+	editor = p_editor;
+	editor_selection = p_editor->get_editor_selection();
 	editor_selection->add_editor_plugin(this);
-	editor_selection->connect("selection_changed",this,"update");
+	editor_selection->connect("selection_changed", this, "update");
 
-
-	hb = memnew( HBoxContainer );
-	add_child( hb );
+	hb = memnew(HBoxContainer);
+	add_child(hb);
 	hb->set_area_as_parent_rect();
 
-	bottom_split = memnew( VSplitContainer );
+	bottom_split = memnew(VSplitContainer);
 	bottom_split->set_v_size_flags(SIZE_EXPAND_FILL);
 	add_child(bottom_split);
 
-	palette_split = memnew( HSplitContainer);
+	palette_split = memnew(HSplitContainer);
 	palette_split->set_v_size_flags(SIZE_EXPAND_FILL);
 	bottom_split->add_child(palette_split);
 
-	Control *vp_base = memnew (Control);
+	Control *vp_base = memnew(Control);
 	vp_base->set_v_size_flags(SIZE_EXPAND_FILL);
 	palette_split->add_child(vp_base);
 
-	ViewportContainer *vp = memnew (ViewportContainer);
+	ViewportContainer *vp = memnew(ViewportContainer);
 	vp->set_stretch(true);
 	vp_base->add_child(vp);
 	vp->set_area_as_parent_rect();
 	vp->add_child(p_editor->get_scene_root());
 
-
-	viewport = memnew( CanvasItemEditorViewport(p_editor, this) );
+	viewport = memnew(CanvasItemEditorViewport(p_editor, this));
 	vp_base->add_child(viewport);
 	viewport->set_area_as_parent_rect();
 	viewport->set_clip_contents(true);
 
-	h_scroll = memnew( HScrollBar );
-	v_scroll = memnew( VScrollBar );
+	h_scroll = memnew(HScrollBar);
+	v_scroll = memnew(VScrollBar);
 
 	viewport->add_child(h_scroll);
 	viewport->add_child(v_scroll);
-	viewport->connect("draw",this,"_viewport_draw");
-	viewport->connect("gui_input",this,"_viewport_gui_input");
+	viewport->connect("draw", this, "_viewport_draw");
+	viewport->connect("gui_input", this, "_viewport_gui_input");
 
-
-	h_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),Object::CONNECT_DEFERRED);
-	v_scroll->connect("value_changed", this,"_update_scroll",Vector<Variant>(),Object::CONNECT_DEFERRED);
+	h_scroll->connect("value_changed", this, "_update_scroll", Vector<Variant>(), Object::CONNECT_DEFERRED);
+	v_scroll->connect("value_changed", this, "_update_scroll", Vector<Variant>(), Object::CONNECT_DEFERRED);
 
 	h_scroll->hide();
 	v_scroll->hide();
-	updating_scroll=false;
+	updating_scroll = false;
 	viewport->set_focus_mode(FOCUS_ALL);
-	handle_len=10;
-	first_update=true;
-
+	handle_len = 10;
+	first_update = true;
 
-	select_button = memnew( ToolButton );
+	select_button = memnew(ToolButton);
 	select_button->set_toggle_mode(true);
 	hb->add_child(select_button);
-	select_button->connect("pressed",this,"_tool_select",make_binds(TOOL_SELECT));
+	select_button->connect("pressed", this, "_tool_select", make_binds(TOOL_SELECT));
 	select_button->set_pressed(true);
-	select_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/select_mode",TTR("Select Mode"),KEY_Q));
-	select_button->set_tooltip(TTR("Select Mode")+" $sc\n"+keycode_get_string(KEY_MASK_CMD)+TTR("Drag: Rotate")+"\n"+TTR("Alt+Drag: Move")+"\n"+TTR("Press 'v' to Change Pivot, 'Shift+v' to Drag Pivot (while moving).")+"\n"+TTR("Alt+RMB: Depth list selection"));
+	select_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/select_mode", TTR("Select Mode"), KEY_Q));
+	select_button->set_tooltip(TTR("Select Mode") + " $sc\n" + keycode_get_string(KEY_MASK_CMD) + TTR("Drag: Rotate") + "\n" + TTR("Alt+Drag: Move") + "\n" + TTR("Press 'v' to Change Pivot, 'Shift+v' to Drag Pivot (while moving).") + "\n" + TTR("Alt+RMB: Depth list selection"));
 
-
-	move_button = memnew( ToolButton );
+	move_button = memnew(ToolButton);
 	move_button->set_toggle_mode(true);
 	hb->add_child(move_button);
-	move_button->connect("pressed",this,"_tool_select",make_binds(TOOL_MOVE));
-	move_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/move_mode",TTR("Move Mode"),KEY_W));
+	move_button->connect("pressed", this, "_tool_select", make_binds(TOOL_MOVE));
+	move_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/move_mode", TTR("Move Mode"), KEY_W));
 	move_button->set_tooltip(TTR("Move Mode"));
 
-	rotate_button = memnew( ToolButton );
+	rotate_button = memnew(ToolButton);
 	rotate_button->set_toggle_mode(true);
 	hb->add_child(rotate_button);
-	rotate_button->connect("pressed",this,"_tool_select",make_binds(TOOL_ROTATE));
-	rotate_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/rotate_mode",TTR("Rotate Mode"),KEY_E));
+	rotate_button->connect("pressed", this, "_tool_select", make_binds(TOOL_ROTATE));
+	rotate_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/rotate_mode", TTR("Rotate Mode"), KEY_E));
 	rotate_button->set_tooltip(TTR("Rotate Mode"));
 
 	hb->add_child(memnew(VSeparator));
 
-	list_select_button = memnew( ToolButton );
+	list_select_button = memnew(ToolButton);
 	list_select_button->set_toggle_mode(true);
 	hb->add_child(list_select_button);
-	list_select_button->connect("pressed",this,"_tool_select",make_binds(TOOL_LIST_SELECT));
+	list_select_button->connect("pressed", this, "_tool_select", make_binds(TOOL_LIST_SELECT));
 	list_select_button->set_tooltip(TTR("Show a list of all objects at the position clicked\n(same as Alt+RMB in select mode)."));
 
-	pivot_button = memnew( ToolButton );
+	pivot_button = memnew(ToolButton);
 	pivot_button->set_toggle_mode(true);
 	hb->add_child(pivot_button);
-	pivot_button->connect("pressed",this,"_tool_select",make_binds(TOOL_EDIT_PIVOT));
+	pivot_button->connect("pressed", this, "_tool_select", make_binds(TOOL_EDIT_PIVOT));
 	pivot_button->set_tooltip(TTR("Click to change object's rotation pivot."));
 
-	pan_button = memnew( ToolButton );
+	pan_button = memnew(ToolButton);
 	pan_button->set_toggle_mode(true);
 	hb->add_child(pan_button);
-	pan_button->connect("pressed",this,"_tool_select",make_binds(TOOL_PAN));
+	pan_button->connect("pressed", this, "_tool_select", make_binds(TOOL_PAN));
 	pan_button->set_tooltip(TTR("Pan Mode"));
 
 	hb->add_child(memnew(VSeparator));
 
-	lock_button = memnew( ToolButton );
+	lock_button = memnew(ToolButton);
 	hb->add_child(lock_button);
 
-	lock_button->connect("pressed",this,"_popup_callback",varray(LOCK_SELECTED));
+	lock_button->connect("pressed", this, "_popup_callback", varray(LOCK_SELECTED));
 	lock_button->set_tooltip(TTR("Lock the selected object in place (can't be moved)."));
 
-	unlock_button = memnew( ToolButton );
+	unlock_button = memnew(ToolButton);
 	hb->add_child(unlock_button);
-	unlock_button->connect("pressed",this,"_popup_callback",varray(UNLOCK_SELECTED));
+	unlock_button->connect("pressed", this, "_popup_callback", varray(UNLOCK_SELECTED));
 	unlock_button->set_tooltip(TTR("Unlock the selected object (can be moved)."));
 
-	group_button = memnew( ToolButton );
+	group_button = memnew(ToolButton);
 	hb->add_child(group_button);
-	group_button->connect("pressed",this,"_popup_callback",varray(GROUP_SELECTED));
+	group_button->connect("pressed", this, "_popup_callback", varray(GROUP_SELECTED));
 	group_button->set_tooltip(TTR("Makes sure the object's children are not selectable."));
 
-	ungroup_button = memnew( ToolButton );
+	ungroup_button = memnew(ToolButton);
 	hb->add_child(ungroup_button);
-	ungroup_button->connect("pressed",this,"_popup_callback",varray(UNGROUP_SELECTED));
+	ungroup_button->connect("pressed", this, "_popup_callback", varray(UNGROUP_SELECTED));
 	ungroup_button->set_tooltip(TTR("Restores the object's children's ability to be selected."));
 
 	hb->add_child(memnew(VSeparator));
 
-	edit_menu = memnew( MenuButton );
+	edit_menu = memnew(MenuButton);
 	edit_menu->set_text(TTR("Edit"));
 	hb->add_child(edit_menu);
-	edit_menu->get_popup()->connect("id_pressed", this,"_popup_callback");
+	edit_menu->get_popup()->connect("id_pressed", this, "_popup_callback");
 
 	PopupMenu *p;
 	p = edit_menu->get_popup();
@@ -3452,19 +3250,18 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_separator();
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/expand_to_parent", TTR("Expand to Parent"), KEY_MASK_CMD | KEY_P), EXPAND_TO_PARENT);
 	p->add_separator();
-	p->add_submenu_item(TTR("Skeleton.."),"skeleton");
+	p->add_submenu_item(TTR("Skeleton.."), "skeleton");
 	skeleton_menu = memnew(PopupMenu);
 	p->add_child(skeleton_menu);
 	skeleton_menu->set_name("skeleton");
-	skeleton_menu->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_make_bones", TTR("Make Bones"), KEY_MASK_CMD | KEY_MASK_SHIFT | KEY_B ),SKELETON_MAKE_BONES);
+	skeleton_menu->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_make_bones", TTR("Make Bones"), KEY_MASK_CMD | KEY_MASK_SHIFT | KEY_B), SKELETON_MAKE_BONES);
 	skeleton_menu->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_clear_bones", TTR("Clear Bones")), SKELETON_CLEAR_BONES);
 	skeleton_menu->add_separator();
 	skeleton_menu->add_check_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_show_bones", TTR("Show Bones")), SKELETON_SHOW_BONES);
 	skeleton_menu->add_separator();
 	skeleton_menu->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_set_ik_chain", TTR("Make IK Chain")), SKELETON_SET_IK_CHAIN);
 	skeleton_menu->add_shortcut(ED_SHORTCUT("canvas_item_editor/skeleton_clear_ik_chain", TTR("Clear IK Chain")), SKELETON_CLEAR_IK_CHAIN);
-	skeleton_menu->connect("id_pressed", this,"_popup_callback");
-
+	skeleton_menu->connect("id_pressed", this, "_popup_callback");
 
 	/*
 	p->add_item("Align Horizontal",ALIGN_HORIZONTAL);
@@ -3472,10 +3269,10 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_item("Space Horizontal",SPACE_HORIZONTAL);
 	p->add_item("Space Vertical",SPACE_VERTICAL);*/
 
-	view_menu = memnew( MenuButton );
+	view_menu = memnew(MenuButton);
 	view_menu->set_text(TTR("View"));
 	hb->add_child(view_menu);
-	view_menu->get_popup()->connect("id_pressed", this,"_popup_callback");
+	view_menu->get_popup()->connect("id_pressed", this, "_popup_callback");
 
 	p = view_menu->get_popup();
 
@@ -3487,123 +3284,121 @@ CanvasItemEditor::CanvasItemEditor(EditorNode *p_editor) {
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/center_selection", TTR("Center Selection"), KEY_F), VIEW_CENTER_TO_SELECTION);
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/frame_selection", TTR("Frame Selection"), KEY_MASK_SHIFT | KEY_F), VIEW_FRAME_TO_SELECTION);
 
-	anchor_menu = memnew( MenuButton );
+	anchor_menu = memnew(MenuButton);
 	anchor_menu->set_text(TTR("Anchor"));
 	hb->add_child(anchor_menu);
-	anchor_menu->get_popup()->connect("id_pressed", this,"_popup_callback");
+	anchor_menu->get_popup()->connect("id_pressed", this, "_popup_callback");
 	anchor_menu->hide();
 
 	//p = anchor_menu->get_popup();
 
-
-
-	animation_hb = memnew( HBoxContainer );
+	animation_hb = memnew(HBoxContainer);
 	hb->add_child(animation_hb);
-	animation_hb->add_child( memnew( VSeparator ));
+	animation_hb->add_child(memnew(VSeparator));
 	animation_hb->hide();
 
-	key_loc_button = memnew( Button("loc"));
+	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));
+	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 = 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));
+	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 = 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));
+	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 = 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->connect("pressed", this, "_popup_callback", varray(ANIM_INSERT_KEY));
 	key_insert_button->set_tooltip(TTR("Insert Keys"));
 	key_insert_button->set_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key", TTR("Insert Key"), KEY_INSERT));
 
 	animation_hb->add_child(key_insert_button);
 
-	animation_menu = memnew( MenuButton );
+	animation_menu = memnew(MenuButton);
 	animation_menu->set_text(TTR("Animation"));
 	animation_hb->add_child(animation_menu);
-	animation_menu->get_popup()->connect("id_pressed", this,"_popup_callback");
+	animation_menu->get_popup()->connect("id_pressed", this, "_popup_callback");
 
 	p = animation_menu->get_popup();
 
 	p->add_shortcut(ED_GET_SHORTCUT("canvas_item_editor/anim_insert_key"), ANIM_INSERT_KEY);
-	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key_existing_tracks", TTR("Insert Key (Existing Tracks)"), KEY_MASK_CMD+KEY_INSERT), ANIM_INSERT_KEY_EXISTING);
+	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_insert_key_existing_tracks", TTR("Insert Key (Existing Tracks)"), KEY_MASK_CMD + KEY_INSERT), ANIM_INSERT_KEY_EXISTING);
 	p->add_separator();
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_copy_pose", TTR("Copy Pose")), ANIM_COPY_POSE);
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_paste_pose", TTR("Paste Pose")), ANIM_PASTE_POSE);
 	p->add_shortcut(ED_SHORTCUT("canvas_item_editor/anim_clear_pose", TTR("Clear Pose"), KEY_MASK_SHIFT | KEY_K), ANIM_CLEAR_POSE);
 
-	snap_dialog = memnew( SnapDialog );
-	snap_dialog->connect("confirmed",this,"_snap_changed");
+	snap_dialog = memnew(SnapDialog);
+	snap_dialog->connect("confirmed", this, "_snap_changed");
 	add_child(snap_dialog);
 
-	value_dialog = memnew( AcceptDialog );
+	value_dialog = memnew(AcceptDialog);
 	value_dialog->set_title(TTR("Set a Value"));
 	value_dialog->get_ok()->set_text(TTR("Close"));
 	add_child(value_dialog);
 
 	Label *l = memnew(Label);
 	l->set_text(TTR("Snap (Pixels):"));
-	l->set_pos(Point2(5,5));
+	l->set_pos(Point2(5, 5));
 	value_dialog->add_child(l);
-	dialog_label=l;
+	dialog_label = l;
 
-	dialog_val=memnew(SpinBox);
-	dialog_val->set_anchor(MARGIN_RIGHT,ANCHOR_END);
-	dialog_val->set_begin(Point2(15,25));
-	dialog_val->set_end(Point2(10,25));
+	dialog_val = memnew(SpinBox);
+	dialog_val->set_anchor(MARGIN_RIGHT, ANCHOR_END);
+	dialog_val->set_begin(Point2(15, 25));
+	dialog_val->set_end(Point2(10, 25));
 	value_dialog->add_child(dialog_val);
-	dialog_val->connect("value_changed",this,"_dialog_value_changed");
-	select_sb = Ref<StyleBoxTexture>( memnew( StyleBoxTexture) );
+	dialog_val->connect("value_changed", this, "_dialog_value_changed");
+	select_sb = Ref<StyleBoxTexture>(memnew(StyleBoxTexture));
 
-	selection_menu = memnew( PopupMenu );
+	selection_menu = memnew(PopupMenu);
 	add_child(selection_menu);
 	selection_menu->set_custom_minimum_size(Vector2(100, 0));
 	selection_menu->connect("id_pressed", this, "_selection_result_pressed");
 	selection_menu->connect("popup_hide", this, "_selection_menu_hide");
 
-	key_pos=true;
-	key_rot=true;
-	key_scale=false;
+	key_pos = true;
+	key_rot = true;
+	key_scale = false;
 
-	zoom=1;
-	snap_offset=Vector2(0, 0);
-	snap_step=Vector2(10, 10);
-	snap_rotation_offset=0;
-	snap_rotation_step=15 / (180 / Math_PI);
-	snap_grid=false;
-	snap_show_grid=false;
-	snap_rotation=false;
-	snap_pixel=false;
-	skeleton_show_bones=true;
-	skeleton_menu->set_item_checked(skeleton_menu->get_item_index(SKELETON_SHOW_BONES),true);
-	updating_value_dialog=false;
-	box_selecting=false;
+	zoom = 1;
+	snap_offset = Vector2(0, 0);
+	snap_step = Vector2(10, 10);
+	snap_rotation_offset = 0;
+	snap_rotation_step = 15 / (180 / Math_PI);
+	snap_grid = false;
+	snap_show_grid = false;
+	snap_rotation = false;
+	snap_pixel = false;
+	skeleton_show_bones = true;
+	skeleton_menu->set_item_checked(skeleton_menu->get_item_index(SKELETON_SHOW_BONES), true);
+	updating_value_dialog = false;
+	box_selecting = false;
 	//zoom=0.5;
-	singleton=this;
+	singleton = this;
 
 	set_process_unhandled_key_input(true);
-	can_move_pivot=false;
-	drag=DRAG_NONE;
-	bone_last_frame=0;
-	additive_selection=false;
+	can_move_pivot = false;
+	drag = DRAG_NONE;
+	bone_last_frame = 0;
+	additive_selection = false;
 }
 
-CanvasItemEditor *CanvasItemEditor::singleton=NULL;
+CanvasItemEditor *CanvasItemEditor::singleton = NULL;
 
 void CanvasItemEditorPlugin::edit(Object *p_object) {
 
@@ -3621,88 +3416,83 @@ void CanvasItemEditorPlugin::make_visible(bool p_visible) {
 	if (p_visible) {
 		canvas_item_editor->show();
 		canvas_item_editor->set_fixed_process(true);
-		VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport_rid(),false);
+		VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport_rid(), false);
 		canvas_item_editor->viewport->grab_focus();
 
 	} else {
 
 		canvas_item_editor->hide();
 		canvas_item_editor->set_fixed_process(false);
-		VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport_rid(),true);
+		VisualServer::get_singleton()->viewport_set_hide_canvas(editor->get_scene_root()->get_viewport_rid(), true);
 	}
-
 }
 
 Dictionary CanvasItemEditorPlugin::get_state() const {
 
 	return canvas_item_editor->get_state();
 }
-void CanvasItemEditorPlugin::set_state(const Dictionary& p_state) {
+void CanvasItemEditorPlugin::set_state(const Dictionary &p_state) {
 
 	canvas_item_editor->set_state(p_state);
 }
 
 CanvasItemEditorPlugin::CanvasItemEditorPlugin(EditorNode *p_node) {
 
-	editor=p_node;
-	canvas_item_editor = memnew( CanvasItemEditor(editor) );
+	editor = p_node;
+	canvas_item_editor = memnew(CanvasItemEditor(editor));
 	canvas_item_editor->set_v_size_flags(Control::SIZE_EXPAND_FILL);
 	editor->get_viewport()->add_child(canvas_item_editor);
 	canvas_item_editor->set_area_as_parent_rect();
 	canvas_item_editor->hide();
-
 }
 
-
-CanvasItemEditorPlugin::~CanvasItemEditorPlugin()
-{
+CanvasItemEditorPlugin::~CanvasItemEditorPlugin() {
 }
 
-
 void CanvasItemEditorViewport::_on_mouse_exit() {
-	if (!selector->is_visible()){
+	if (!selector->is_visible()) {
 		_remove_preview();
 	}
 }
 
-void CanvasItemEditorViewport::_on_select_type(Object* selected) {
-	CheckBox* check = selected->cast_to<CheckBox>();
+void CanvasItemEditorViewport::_on_select_type(Object *selected) {
+	CheckBox *check = selected->cast_to<CheckBox>();
 	String type = check->get_text();
-	selector_label->set_text(vformat(TTR("Add %s"),type));
-	label->set_text(vformat(TTR("Adding %s..."),type));
+	selector_label->set_text(vformat(TTR("Add %s"), type));
+	label->set_text(vformat(TTR("Adding %s..."), type));
 }
 
 void CanvasItemEditorViewport::_on_change_type() {
 	if (!button_group->get_pressed_button())
 		return;
 
-	CheckBox* check=button_group->get_pressed_button()->cast_to<CheckBox>();
-	default_type=check->get_text();
+	CheckBox *check = button_group->get_pressed_button()->cast_to<CheckBox>();
+	default_type = check->get_text();
 	_perform_drop_data();
 	selector->hide();
 }
 
-void CanvasItemEditorViewport::_create_preview(const Vector<String>& files) const {
-	label->set_pos(get_global_pos()+Point2(14,14));
-	label_desc->set_pos(label->get_pos()+Point2(0,label->get_size().height));
-	for (int i=0;i<files.size();i++) {
-		String path=files[i];
-		RES res=ResourceLoader::load(path);
-		String type=res->get_class();
-		if (type=="ImageTexture" || type=="PackedScene") {
-			if (type=="ImageTexture") {
-				Ref<ImageTexture> texture=Ref<ImageTexture> ( ResourceCache::get(path)->cast_to<ImageTexture>() );
-				Sprite* sprite=memnew(Sprite);
+void CanvasItemEditorViewport::_create_preview(const Vector<String> &files) const {
+	label->set_pos(get_global_pos() + Point2(14, 14));
+	label_desc->set_pos(label->get_pos() + Point2(0, label->get_size().height));
+	for (int i = 0; i < files.size(); i++) {
+		String path = files[i];
+		RES res = ResourceLoader::load(path);
+		String type = res->get_class();
+		if (type == "ImageTexture" || type == "PackedScene") {
+			if (type == "ImageTexture") {
+				Ref<ImageTexture> texture = Ref<ImageTexture>(ResourceCache::get(path)->cast_to<ImageTexture>());
+				Sprite *sprite = memnew(Sprite);
 				sprite->set_texture(texture);
-				sprite->set_modulate(Color(1,1,1,0.7f));
+				sprite->set_modulate(Color(1, 1, 1, 0.7f));
 				preview->add_child(sprite);
 				label->show();
 				label_desc->show();
-			} else if (type=="PackedScene") {
-				Ref<PackedScene> scn=ResourceLoader::load(path);
-				if (scn.is_valid()){
-					Node* instance=scn->instance();
-					if (instance){
+			} else if (type == "PackedScene") {
+				Ref<PackedScene> scn = ResourceLoader::load(path);
+				if (scn.is_valid()) {
+					Node *instance = scn->instance();
+					if (instance) {
 						preview->add_child(instance);
 					}
 				}
@@ -3713,10 +3503,10 @@ void CanvasItemEditorViewport::_create_preview(const Vector<String>& files) cons
 }
 
 void CanvasItemEditorViewport::_remove_preview() {
-	if (preview->get_parent()){
+	if (preview->get_parent()) {
 		editor->get_scene_root()->remove_child(preview);
-		for (int i=preview->get_child_count()-1;i>=0;i--){
-			Node* node=preview->get_child(i);
+		for (int i = preview->get_child_count() - 1; i >= 0; i--) {
+			Node *node = preview->get_child(i);
 			memdelete(node);
 		}
 		label->hide();
@@ -3724,152 +3514,159 @@ void CanvasItemEditorViewport::_remove_preview() {
 	}
 }
 
-bool CanvasItemEditorViewport::_cyclical_dependency_exists(const String& p_target_scene_path, Node* p_desired_node) {
-	if (p_desired_node->get_filename()==p_target_scene_path) {
+bool CanvasItemEditorViewport::_cyclical_dependency_exists(const String &p_target_scene_path, Node *p_desired_node) {
+	if (p_desired_node->get_filename() == p_target_scene_path) {
 		return true;
 	}
 
-	int childCount=p_desired_node->get_child_count();
-	for (int i=0;i<childCount;i++) {
-		Node* child=p_desired_node->get_child(i);
-		if(_cyclical_dependency_exists(p_target_scene_path,child)) {
+	int childCount = p_desired_node->get_child_count();
+	for (int i = 0; i < childCount; i++) {
+		Node *child = p_desired_node->get_child(i);
+		if (_cyclical_dependency_exists(p_target_scene_path, child)) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void CanvasItemEditorViewport::_create_nodes(Node* parent, Node* child, String& path, const Point2& p_point) {
+void CanvasItemEditorViewport::_create_nodes(Node *parent, Node *child, String &path, const Point2 &p_point) {
 	child->set_name(path.get_file().get_basename());
-	Ref<ImageTexture> texture=Ref<ImageTexture> ( ResourceCache::get(path)->cast_to<ImageTexture>() );
+	Ref<ImageTexture> texture = Ref<ImageTexture>(ResourceCache::get(path)->cast_to<ImageTexture>());
 	Size2 texture_size = texture->get_size();
 
-	editor_data->get_undo_redo().add_do_method(parent,"add_child",child);
-	editor_data->get_undo_redo().add_do_method(child,"set_owner",editor->get_edited_scene());
+	editor_data->get_undo_redo().add_do_method(parent, "add_child", child);
+	editor_data->get_undo_redo().add_do_method(child, "set_owner", editor->get_edited_scene());
 	editor_data->get_undo_redo().add_do_reference(child);
-	editor_data->get_undo_redo().add_undo_method(parent,"remove_child",child);
+	editor_data->get_undo_redo().add_undo_method(parent, "remove_child", child);
 
-	String new_name=parent->validate_child_name(child);
-	ScriptEditorDebugger *sed=ScriptEditor::get_singleton()->get_debugger();
-	editor_data->get_undo_redo().add_do_method(sed,"live_debug_create_node",editor->get_edited_scene()->get_path_to(parent),child->get_class(),new_name);
-	editor_data->get_undo_redo().add_undo_method(sed,"live_debug_remove_node",NodePath(String(editor->get_edited_scene()->get_path_to(parent))+"/"+new_name));
+	String new_name = parent->validate_child_name(child);
+	ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
+	editor_data->get_undo_redo().add_do_method(sed, "live_debug_create_node", editor->get_edited_scene()->get_path_to(parent), child->get_class(), new_name);
+	editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(editor->get_edited_scene()->get_path_to(parent)) + "/" + new_name));
 
 	// handle with different property for texture
 	String property = "texture";
 	List<PropertyInfo> props;
 	child->get_property_list(&props);
-	for(const List<PropertyInfo>::Element *E=props.front();E;E=E->next() ) {
-		if (E->get().name=="config/texture") { // Particles2D
-			property="config/texture";
+	for (const List<PropertyInfo>::Element *E = props.front(); E; E = E->next()) {
+		if (E->get().name == "config/texture") { // Particles2D
+			property = "config/texture";
 			break;
-		} else if (E->get().name=="texture/texture") { // Polygon2D
-			property="texture/texture";
+		} else if (E->get().name == "texture/texture") { // Polygon2D
+			property = "texture/texture";
 			break;
-		} else if (E->get().name=="normal") { // TouchScreenButton
-			property="normal";
+		} else if (E->get().name == "normal") { // TouchScreenButton
+			property = "normal";
 			break;
 		}
 	}
-	editor_data->get_undo_redo().add_do_property(child,property,texture);
+	editor_data->get_undo_redo().add_do_property(child, property, texture);
 
 	// make visible for certain node type
-	if (default_type=="Patch9Rect") {
-		editor_data->get_undo_redo().add_do_property(child,"rect/size",texture_size);
-	} else if (default_type=="Polygon2D") {
+	if (default_type == "Patch9Rect") {
+		editor_data->get_undo_redo().add_do_property(child, "rect/size", texture_size);
+	} else if (default_type == "Polygon2D") {
 		PoolVector<Vector2> list;
-		list.push_back(Vector2(0,0));
-		list.push_back(Vector2(texture_size.width,0));
-		list.push_back(Vector2(texture_size.width,texture_size.height));
-		list.push_back(Vector2(0,texture_size.height));
-		editor_data->get_undo_redo().add_do_property(child,"polygon",list);
+		list.push_back(Vector2(0, 0));
+		list.push_back(Vector2(texture_size.width, 0));
+		list.push_back(Vector2(texture_size.width, texture_size.height));
+		list.push_back(Vector2(0, texture_size.height));
+		editor_data->get_undo_redo().add_do_property(child, "polygon", list);
 	}
 
 	// locate at preview position
 	Point2 pos;
 	if (parent->has_method("get_global_pos")) {
-		pos=parent->call("get_global_pos");
+		pos = parent->call("get_global_pos");
 	}
-	Transform2D trans=canvas->get_canvas_transform();
-	Point2 target_pos = (p_point-trans.get_origin())/trans.get_scale().x-pos;
-	if (default_type=="Polygon2D" || default_type=="TouchScreenButton" || default_type=="TextureRect" || default_type=="Patch9Rect") {
-		target_pos -= texture_size/2;
+	Transform2D trans = canvas->get_canvas_transform();
+	Point2 target_pos = (p_point - trans.get_origin()) / trans.get_scale().x - pos;
+	if (default_type == "Polygon2D" || default_type == "TouchScreenButton" || default_type == "TextureRect" || default_type == "Patch9Rect") {
+		target_pos -= texture_size / 2;
 	}
-	editor_data->get_undo_redo().add_do_method(child,"set_pos",target_pos);
+	editor_data->get_undo_redo().add_do_method(child, "set_pos", target_pos);
 }
 
-bool CanvasItemEditorViewport::_create_instance(Node* parent, String& path, const Point2& p_point) {
-	Ref<PackedScene> sdata=ResourceLoader::load(path);
+bool CanvasItemEditorViewport::_create_instance(Node *parent, String &path, const Point2 &p_point) {
+	Ref<PackedScene> sdata = ResourceLoader::load(path);
 	if (!sdata.is_valid()) { // invalid scene
 		return false;
 	}
 
-	Node* instanced_scene=sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
+	Node *instanced_scene = sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
 	if (!instanced_scene) { // error on instancing
 		return false;
 	}
 
-	if (editor->get_edited_scene()->get_filename()!="") { // cyclical instancing
+	if (editor->get_edited_scene()->get_filename() != "") { // cyclical instancing
 		if (_cyclical_dependency_exists(editor->get_edited_scene()->get_filename(), instanced_scene)) {
 			memdelete(instanced_scene);
 			return false;
 		}
 	}
 
-	instanced_scene->set_filename( GlobalConfig::get_singleton()->localize_path(path) );
+	instanced_scene->set_filename(GlobalConfig::get_singleton()->localize_path(path));
 
-	editor_data->get_undo_redo().add_do_method(parent,"add_child",instanced_scene);
-	editor_data->get_undo_redo().add_do_method(instanced_scene,"set_owner",editor->get_edited_scene());
+	editor_data->get_undo_redo().add_do_method(parent, "add_child", instanced_scene);
+	editor_data->get_undo_redo().add_do_method(instanced_scene, "set_owner", editor->get_edited_scene());
 	editor_data->get_undo_redo().add_do_reference(instanced_scene);
-	editor_data->get_undo_redo().add_undo_method(parent,"remove_child",instanced_scene);
+	editor_data->get_undo_redo().add_undo_method(parent, "remove_child", instanced_scene);
 
-	String new_name=parent->validate_child_name(instanced_scene);
-	ScriptEditorDebugger *sed=ScriptEditor::get_singleton()->get_debugger();
-	editor_data->get_undo_redo().add_do_method(sed,"live_debug_instance_node",editor->get_edited_scene()->get_path_to(parent),path,new_name);
-	editor_data->get_undo_redo().add_undo_method(sed,"live_debug_remove_node",NodePath(String(editor->get_edited_scene()->get_path_to(parent))+"/"+new_name));
+	String new_name = parent->validate_child_name(instanced_scene);
+	ScriptEditorDebugger *sed = ScriptEditor::get_singleton()->get_debugger();
+	editor_data->get_undo_redo().add_do_method(sed, "live_debug_instance_node", editor->get_edited_scene()->get_path_to(parent), path, new_name);
+	editor_data->get_undo_redo().add_undo_method(sed, "live_debug_remove_node", NodePath(String(editor->get_edited_scene()->get_path_to(parent)) + "/" + new_name));
 
 	Point2 pos;
-	Node2D* parent_node2d=parent->cast_to<Node2D>();
+	Node2D *parent_node2d = parent->cast_to<Node2D>();
 	if (parent_node2d) {
-		pos=parent_node2d->get_global_position();
+		pos = parent_node2d->get_global_position();
 	} else {
-		Control* parent_control=parent->cast_to<Control>();
+		Control *parent_control = parent->cast_to<Control>();
 		if (parent_control) {
-			pos=parent_control->get_global_pos();
+			pos = parent_control->get_global_pos();
 		}
 	}
-	Transform2D trans=canvas->get_canvas_transform();
-	editor_data->get_undo_redo().add_do_method(instanced_scene,"set_pos",(p_point-trans.get_origin())/trans.get_scale().x-pos);
+	Transform2D trans = canvas->get_canvas_transform();
+	editor_data->get_undo_redo().add_do_method(instanced_scene, "set_pos", (p_point - trans.get_origin()) / trans.get_scale().x - pos);
 
 	return true;
 }
 
-void CanvasItemEditorViewport::_perform_drop_data(){
+void CanvasItemEditorViewport::_perform_drop_data() {
 	_remove_preview();
 
 	Vector<String> error_files;
 
 	editor_data->get_undo_redo().create_action(TTR("Create Node"));
 
-	for (int i=0;i<selected_files.size();i++) {
-		String path=selected_files[i];
-		RES res=ResourceLoader::load(path);
+	for (int i = 0; i < selected_files.size(); i++) {
+		String path = selected_files[i];
+		RES res = ResourceLoader::load(path);
 		if (res.is_null()) {
 			continue;
 		}
-		String type=res->get_class();
-		if (type=="ImageTexture") {
-			Node* child;
-			if      (default_type=="Light2D")           child=memnew(Light2D);
-			else if (default_type=="Particles2D")       child=memnew(Particles2D);
-			else if (default_type=="Polygon2D")         child=memnew(Polygon2D);
-			else if (default_type=="TouchScreenButton") child=memnew(TouchScreenButton);
-			else if (default_type=="TextureRect")       child=memnew(TextureRect);
-			else if (default_type=="Patch9Rect")        child=memnew(NinePatchRect);
-			else child=memnew(Sprite); // default
+		String type = res->get_class();
+		if (type == "ImageTexture") {
+			Node *child;
+			if (default_type == "Light2D")
+				child = memnew(Light2D);
+			else if (default_type == "Particles2D")
+				child = memnew(Particles2D);
+			else if (default_type == "Polygon2D")
+				child = memnew(Polygon2D);
+			else if (default_type == "TouchScreenButton")
+				child = memnew(TouchScreenButton);
+			else if (default_type == "TextureRect")
+				child = memnew(TextureRect);
+			else if (default_type == "Patch9Rect")
+				child = memnew(NinePatchRect);
+			else
+				child = memnew(Sprite); // default
 
 			_create_nodes(target_node, child, path, drop_pos);
-		} else if (type=="PackedScene") {
-			bool success=_create_instance(target_node, path, drop_pos);
+		} else if (type == "PackedScene") {
+			bool success = _create_instance(target_node, path, drop_pos);
 			if (!success) {
 				error_files.push_back(path);
 			}
@@ -3878,48 +3675,48 @@ void CanvasItemEditorViewport::_perform_drop_data(){
 
 	editor_data->get_undo_redo().commit_action();
 
-	if (error_files.size()>0) {
+	if (error_files.size() > 0) {
 		String files_str;
-		for (int i=0;i<error_files.size();i++) {
+		for (int i = 0; i < error_files.size(); i++) {
 			files_str += error_files[i].get_file().get_basename() + ",";
 		}
-		files_str=files_str.substr(0,files_str.length()-1);
+		files_str = files_str.substr(0, files_str.length() - 1);
 		accept->get_ok()->set_text(TTR("Ugh"));
-		accept->set_text(vformat(TTR("Error instancing scene from %s"),files_str.c_str()));
+		accept->set_text(vformat(TTR("Error instancing scene from %s"), files_str.c_str()));
 		accept->popup_centered_minsize();
 	}
 }
 
-bool CanvasItemEditorViewport::can_drop_data(const Point2& p_point,const Variant& p_data) const {
-	Dictionary d=p_data;
+bool CanvasItemEditorViewport::can_drop_data(const Point2 &p_point, const Variant &p_data) const {
+	Dictionary d = p_data;
 	if (d.has("type")) {
-		if (String(d["type"])=="files") {
-			Vector<String> files=d["files"];
-			bool can_instance=false;
-			for (int i=0;i<files.size();i++) { // check if dragged files contain resource or scene can be created at least one
-				RES res=ResourceLoader::load(files[i]);
+		if (String(d["type"]) == "files") {
+			Vector<String> files = d["files"];
+			bool can_instance = false;
+			for (int i = 0; i < files.size(); i++) { // check if dragged files contain resource or scene can be created at least one
+				RES res = ResourceLoader::load(files[i]);
 				if (res.is_null()) {
 					continue;
 				}
-				String type=res->get_class();
-				if (type=="PackedScene") {
-					Ref<PackedScene> sdata=ResourceLoader::load(files[i]);
-					Node* instanced_scene=sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
+				String type = res->get_class();
+				if (type == "PackedScene") {
+					Ref<PackedScene> sdata = ResourceLoader::load(files[i]);
+					Node *instanced_scene = sdata->instance(PackedScene::GEN_EDIT_STATE_INSTANCE);
 					if (!instanced_scene) {
 						continue;
 					}
 					memdelete(instanced_scene);
 				}
-				can_instance=true;
+				can_instance = true;
 				break;
 			}
 			if (can_instance) {
-				if (!preview->get_parent()){ // create preview only once
+				if (!preview->get_parent()) { // create preview only once
 					_create_preview(files);
 				}
-				Transform2D trans=canvas->get_canvas_transform();
-				preview->set_position((p_point-trans.get_origin())/trans.get_scale().x);
-				label->set_text(vformat(TTR("Adding %s..."),default_type));
+				Transform2D trans = canvas->get_canvas_transform();
+				preview->set_position((p_point - trans.get_origin()) / trans.get_scale().x);
+				label->set_text(vformat(TTR("Adding %s..."), default_type));
 			}
 			return can_instance;
 		}
@@ -3928,25 +3725,25 @@ bool CanvasItemEditorViewport::can_drop_data(const Point2& p_point,const Variant
 	return false;
 }
 
-void CanvasItemEditorViewport::drop_data(const Point2& p_point,const Variant& p_data) {
-	bool is_shift=Input::get_singleton()->is_key_pressed(KEY_SHIFT);
-	bool is_alt=Input::get_singleton()->is_key_pressed(KEY_ALT);
+void CanvasItemEditorViewport::drop_data(const Point2 &p_point, const Variant &p_data) {
+	bool is_shift = Input::get_singleton()->is_key_pressed(KEY_SHIFT);
+	bool is_alt = Input::get_singleton()->is_key_pressed(KEY_ALT);
 
 	selected_files.clear();
-	Dictionary d=p_data;
-	if (d.has("type") && String(d["type"])=="files"){
-		selected_files=d["files"];
+	Dictionary d = p_data;
+	if (d.has("type") && String(d["type"]) == "files") {
+		selected_files = d["files"];
 	}
 
-	List<Node*> list=editor->get_editor_selection()->get_selected_node_list();
-	if (list.size()==0) {
+	List<Node *> list = editor->get_editor_selection()->get_selected_node_list();
+	if (list.size() == 0) {
 		accept->get_ok()->set_text(TTR("OK :("));
 		accept->set_text(TTR("No parent to instance a child at."));
 		accept->popup_centered_minsize();
 		_remove_preview();
 		return;
 	}
-	if (list.size()!=1) {
+	if (list.size() != 1) {
 		accept->get_ok()->set_text(TTR("I see.."));
 		accept->set_text(TTR("This operation requires a single selected node."));
 		accept->popup_centered_minsize();
@@ -3954,21 +3751,21 @@ void CanvasItemEditorViewport::drop_data(const Point2& p_point,const Variant& p_
 		return;
 	}
 
-	target_node=list[0];
-	if (is_shift && target_node!=editor->get_edited_scene()) {
-		target_node=target_node->get_parent();
+	target_node = list[0];
+	if (is_shift && target_node != editor->get_edited_scene()) {
+		target_node = target_node->get_parent();
 	}
-	drop_pos=p_point;
+	drop_pos = p_point;
 
 	if (is_alt) {
-		List<BaseButton*> btn_list;
+		List<BaseButton *> btn_list;
 		button_group->get_buttons(&btn_list);
 
-		for (int i=0;i<btn_list.size();i++) {
-			CheckBox* check=btn_list[i]->cast_to<CheckBox>();
-			check->set_pressed(check->get_text()==default_type);
+		for (int i = 0; i < btn_list.size(); i++) {
+			CheckBox *check = btn_list[i]->cast_to<CheckBox>();
+			check->set_pressed(check->get_text() == default_type);
 		}
-		selector_label->set_text(vformat(TTR("Add %s"),default_type));
+		selector_label->set_text(vformat(TTR("Add %s"), default_type));
 		selector->popup_centered_minsize();
 	} else {
 		_perform_drop_data();
@@ -3976,21 +3773,21 @@ void CanvasItemEditorViewport::drop_data(const Point2& p_point,const Variant& p_
 }
 
 void CanvasItemEditorViewport::_notification(int p_what) {
-	if (p_what==NOTIFICATION_ENTER_TREE) {
-		connect("mouse_exited",this,"_on_mouse_exit");
-	} else if (p_what==NOTIFICATION_EXIT_TREE) {
-		disconnect("mouse_exited",this,"_on_mouse_exit");
+	if (p_what == NOTIFICATION_ENTER_TREE) {
+		connect("mouse_exited", this, "_on_mouse_exit");
+	} else if (p_what == NOTIFICATION_EXIT_TREE) {
+		disconnect("mouse_exited", this, "_on_mouse_exit");
 	}
 }
 
 void CanvasItemEditorViewport::_bind_methods() {
-	ClassDB::bind_method(D_METHOD("_on_select_type"),&CanvasItemEditorViewport::_on_select_type);
-	ClassDB::bind_method(D_METHOD("_on_change_type"),&CanvasItemEditorViewport::_on_change_type);
-	ClassDB::bind_method(D_METHOD("_on_mouse_exit"),&CanvasItemEditorViewport::_on_mouse_exit);
+	ClassDB::bind_method(D_METHOD("_on_select_type"), &CanvasItemEditorViewport::_on_select_type);
+	ClassDB::bind_method(D_METHOD("_on_change_type"), &CanvasItemEditorViewport::_on_change_type);
+	ClassDB::bind_method(D_METHOD("_on_mouse_exit"), &CanvasItemEditorViewport::_on_mouse_exit);
 }
 
-CanvasItemEditorViewport::CanvasItemEditorViewport(EditorNode *p_node, CanvasItemEditor* p_canvas) {
-	default_type="Sprite";
+CanvasItemEditorViewport::CanvasItemEditorViewport(EditorNode *p_node, CanvasItemEditor *p_canvas) {
+	default_type = "Sprite";
 	// Node2D
 	types.push_back("Sprite");
 	types.push_back("Light2D");
@@ -4001,42 +3798,42 @@ CanvasItemEditorViewport::CanvasItemEditorViewport(EditorNode *p_node, CanvasIte
 	types.push_back("TextureRect");
 	types.push_back("Patch9Rect");
 
-	target_node=NULL;
-	editor=p_node;
-	editor_data=editor->get_scene_tree_dock()->get_editor_data();
-	canvas=p_canvas;
-	preview=memnew( Node2D );
-	accept=memnew( AcceptDialog );
+	target_node = NULL;
+	editor = p_node;
+	editor_data = editor->get_scene_tree_dock()->get_editor_data();
+	canvas = p_canvas;
+	preview = memnew(Node2D);
+	accept = memnew(AcceptDialog);
 	editor->get_gui_base()->add_child(accept);
 
-	selector=memnew( WindowDialog );
+	selector = memnew(WindowDialog);
 	selector->set_title(TTR("Change default type"));
 
-	VBoxContainer* vbc=memnew(VBoxContainer);
-	vbc->add_constant_override("separation",10*EDSCALE);
-	vbc->set_custom_minimum_size(Size2(200,260)*EDSCALE);
+	VBoxContainer *vbc = memnew(VBoxContainer);
+	vbc->add_constant_override("separation", 10 * EDSCALE);
+	vbc->set_custom_minimum_size(Size2(200, 260) * EDSCALE);
 
-	selector_label=memnew(Label);
+	selector_label = memnew(Label);
 	selector_label->set_align(Label::ALIGN_CENTER);
 	selector_label->set_valign(Label::VALIGN_BOTTOM);
-	selector_label->set_custom_minimum_size(Size2(0,30)*EDSCALE);
+	selector_label->set_custom_minimum_size(Size2(0, 30) * EDSCALE);
 	vbc->add_child(selector_label);
 
 	button_group.instance();
 
-	btn_group=memnew( VBoxContainer );
+	btn_group = memnew(VBoxContainer);
 	btn_group->set_h_size_flags(0);
 	btn_group->connect("button_selected", this, "_on_select_type");
 
-	for (int i=0;i<types.size();i++) {
-		CheckBox* check=memnew(CheckBox);
+	for (int i = 0; i < types.size(); i++) {
+		CheckBox *check = memnew(CheckBox);
 		check->set_text(types[i]);
 		btn_group->add_child(check);
 		check->set_button_group(button_group);
 	}
 	vbc->add_child(btn_group);
 
-	Button* ok=memnew(Button);
+	Button *ok = memnew(Button);
 	ok->set_text(TTR("OK"));
 	ok->set_h_size_flags(0);
 	vbc->add_child(ok);
@@ -4045,18 +3842,18 @@ CanvasItemEditorViewport::CanvasItemEditorViewport(EditorNode *p_node, CanvasIte
 	selector->add_child(vbc);
 	editor->get_gui_base()->add_child(selector);
 
-	label=memnew(Label);
-	label->add_color_override("font_color", Color(1,1,0,1));
-	label->add_color_override("font_color_shadow", Color(0,0,0,1));
-	label->add_constant_override("shadow_as_outline", 1*EDSCALE);
+	label = memnew(Label);
+	label->add_color_override("font_color", Color(1, 1, 0, 1));
+	label->add_color_override("font_color_shadow", Color(0, 0, 0, 1));
+	label->add_constant_override("shadow_as_outline", 1 * EDSCALE);
 	label->hide();
 	editor->get_gui_base()->add_child(label);
 
-	label_desc=memnew(Label);
+	label_desc = memnew(Label);
 	label_desc->set_text(TTR("Drag & drop + Shift : Add node as sibling\nDrag & drop + Alt : Change node type"));
-	label_desc->add_color_override("font_color", Color(0.6,0.6,0.6,1));
-	label_desc->add_color_override("font_color_shadow", Color(0.2,0.2,0.2,1));
-	label_desc->add_constant_override("shadow_as_outline", 1*EDSCALE);
+	label_desc->add_color_override("font_color", Color(0.6, 0.6, 0.6, 1));
+	label_desc->add_color_override("font_color_shadow", Color(0.2, 0.2, 0.2, 1));
+	label_desc->add_constant_override("shadow_as_outline", 1 * EDSCALE);
 	label_desc->add_constant_override("line_spacing", 0);
 	label_desc->hide();
 	editor->get_gui_base()->add_child(label_desc);