GODOT IS OPEN SOURCE

1 files changed, 2886 insertions, 0 deletions

diff --git a/scene/gui/control.cpp b/scene/gui/control.cpp
new file mode 100644
index 0000000000..3e44b5af16
--- /dev/null
+++ b/scene/gui/control.cpp
@@ -0,0 +1,2886 @@
+/*************************************************************************/
+/*  control.cpp                                                          */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "control.h"
+#include "servers/visual_server.h"
+#include "scene/main/viewport.h"
+#include "scene/main/canvas_layer.h"
+#include "globals.h"
+
+#include "print_string.h"
+#include "os/keyboard.h"
+#include "os/os.h"
+#include "message_queue.h"
+#include "scene/scene_string_names.h"
+#include "scene/gui/panel.h"
+#include "scene/gui/label.h"
+#include <stdio.h>
+
+
+class TooltipPanel : public Panel {
+
+	OBJ_TYPE(TooltipPanel,Panel)
+public:
+	TooltipPanel() {};
+
+};
+
+class TooltipLabel : public Label {
+
+	OBJ_TYPE(TooltipLabel,Label)
+public:
+	TooltipLabel() {};
+
+};
+
+Control::Window::Window() {
+
+
+	mouse_focus=NULL;
+	mouse_focus_button=-1;
+	key_focus=NULL;
+	mouse_over=NULL;
+	disable_input=false;
+
+	cancelled_input_ID=0;
+	tooltip=NULL;
+	tooltip_popup=NULL;
+	tooltip_label=NULL;
+	subwindow_order_dirty=false;
+}
+
+
+Variant Control::edit_get_state() const {
+
+	return get_rect();
+
+}
+void Control::edit_set_state(const Variant& p_state) {
+
+	Rect2 state=p_state;
+	set_pos(state.pos);
+	set_size(state.size);
+}
+
+void Control::set_custom_minimum_size(const Size2& p_custom) {
+
+	if (p_custom==data.custom_minimum_size)
+		return;
+	data.custom_minimum_size=p_custom;
+	minimum_size_changed();
+}
+
+Size2 Control::get_custom_minimum_size() const{
+
+	return data.custom_minimum_size;
+}
+
+Size2 Control::get_combined_minimum_size() const {
+
+	Size2 minsize = get_minimum_size();
+	minsize.x = MAX(minsize.x,data.custom_minimum_size.x);
+	minsize.y = MAX(minsize.y,data.custom_minimum_size.y);
+	return minsize;
+}
+
+Size2 Control::edit_get_minimum_size() const {
+
+	return get_combined_minimum_size();
+}
+
+void Control::edit_set_rect(const Rect2& p_edit_rect) {
+
+
+	Rect2 new_rect=get_rect();
+
+	new_rect.pos+=p_edit_rect.pos.snapped(Vector2(1,1));
+	new_rect.size=p_edit_rect.size.snapped(Vector2(1,1));
+
+	set_pos(new_rect.pos);
+	set_size(new_rect.size);
+
+}
+
+bool Control::_set(const StringName& p_name, const Variant& p_value) {
+
+
+	String name= p_name;
+	if (!name.begins_with("custom"))
+		return false;
+
+	if (p_value.get_type()==Variant::NIL) {
+
+		if (name.begins_with("custom_icons/")) {
+			String dname = name.get_slice("/",1);
+			data.icon_override.erase(dname);
+			update();
+		} else if (name.begins_with("custom_styles/")) {
+			String dname = name.get_slice("/",1);
+			data.style_override.erase(dname);
+			update();
+		} else if (name.begins_with("custom_fonts/")) {
+			String dname = name.get_slice("/",1);
+			data.font_override.erase(dname);
+			update();
+		} else if (name.begins_with("custom_colors/")) {
+			String dname = name.get_slice("/",1);
+			data.color_override.erase(dname);
+			update();
+		} else if (name.begins_with("custom_constants/")) {
+			String dname = name.get_slice("/",1);
+			data.constant_override.erase(dname);
+			update();
+		} else
+			return false;
+
+	} else {
+		if (name.begins_with("custom_icons/")) {
+			String dname = name.get_slice("/",1);
+			add_icon_override(dname,p_value);
+		} else if (name.begins_with("custom_styles/")) {
+			String dname = name.get_slice("/",1);
+			add_style_override(dname,p_value);
+		} else if (name.begins_with("custom_fonts/")) {
+			String dname = name.get_slice("/",1);
+			add_font_override(dname,p_value);
+		} else if (name.begins_with("custom_colors/")) {
+			String dname = name.get_slice("/",1);
+			add_color_override(dname,p_value);
+		} else if (name.begins_with("custom_constants/")) {
+			String dname = name.get_slice("/",1);
+			add_constant_override(dname,p_value);
+		} else
+			return false;
+	}
+	return true;
+
+}
+
+void Control::_update_minimum_size() {
+
+	if (!is_inside_scene())
+		return;
+
+	data.pending_min_size_update=false;
+	Size2 minsize = get_combined_minimum_size();
+	if (minsize.x > data.size_cache.x ||
+	    minsize.y > data.size_cache.y
+	    ) {
+		_size_changed();
+	}
+
+	emit_signal(SceneStringNames::get_singleton()->minimum_size_changed);
+
+}
+
+bool Control::_get(const StringName& p_name,Variant &r_ret) const {
+
+
+	String sname=p_name;
+
+	if (!sname.begins_with("custom"))
+		return false;
+
+	if (sname.begins_with("custom_icons/")) {
+		String name = sname.get_slice("/",1);
+
+		r_ret= data.icon_override.has(name)?Variant(data.icon_override[name]):Variant();
+	} else if (sname.begins_with("custom_styles/")) {
+		String name = sname.get_slice("/",1);
+
+		r_ret= data.style_override.has(name)?Variant(data.style_override[name]):Variant();
+	} else if (sname.begins_with("custom_fonts/")) {
+		String name = sname.get_slice("/",1);
+
+		r_ret= data.font_override.has(name)?Variant(data.font_override[name]):Variant();
+	} else if (sname.begins_with("custom_colors/")) {
+		String name = sname.get_slice("/",1);
+		r_ret= data.color_override.has(name)?Variant(data.color_override[name]):Variant();
+	} else if (sname.begins_with("custom_constants/")) {
+		String name = sname.get_slice("/",1);
+
+		r_ret= data.constant_override.has(name)?Variant(data.constant_override[name]):Variant();
+	} else
+		return false;
+
+
+	
+	return true;
+	
+
+}
+void Control::_get_property_list( List<PropertyInfo> *p_list) const {
+
+	Ref<Theme> theme;
+	if (data.theme.is_valid()) {
+
+		theme=data.theme;
+	} else {
+		theme=Theme::get_default();
+	}
+
+
+	{
+		List<StringName> names;
+		theme->get_icon_list(get_type_name(),&names);
+		for(List<StringName>::Element *E=names.front();E;E=E->next()) {
+
+			uint32_t hint= PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_CHECKABLE;
+			if (data.icon_override.has(E->get()))
+				hint|=PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_CHECKED;
+
+			p_list->push_back( PropertyInfo(Variant::OBJECT,"custom_icons/"+E->get(),PROPERTY_HINT_RESOURCE_TYPE, "Texture",hint) );
+		}
+	}
+	{
+		List<StringName> names;
+		theme->get_stylebox_list(get_type_name(),&names);
+		for(List<StringName>::Element *E=names.front();E;E=E->next()) {
+
+			uint32_t hint= PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_CHECKABLE;
+			if (data.style_override.has(E->get()))
+				hint|=PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_CHECKED;
+
+			p_list->push_back( PropertyInfo(Variant::OBJECT,"custom_styles/"+E->get(),PROPERTY_HINT_RESOURCE_TYPE, "StyleBox",hint) );
+		}
+	}
+	{
+		List<StringName> names;
+		theme->get_font_list(get_type_name(),&names);
+		for(List<StringName>::Element *E=names.front();E;E=E->next()) {
+
+			uint32_t hint= PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_CHECKABLE;
+			if (data.font_override.has(E->get()))
+				hint|=PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_CHECKED;
+
+			p_list->push_back( PropertyInfo(Variant::OBJECT,"custom_fonts/"+E->get(),PROPERTY_HINT_RESOURCE_TYPE, "Font",hint) );
+		}
+	}
+	{
+		List<StringName> names;
+		theme->get_color_list(get_type_name(),&names);
+		for(List<StringName>::Element *E=names.front();E;E=E->next()) {
+
+			uint32_t hint= PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_CHECKABLE;
+			if (data.color_override.has(E->get()))
+				hint|=PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_CHECKED;
+
+			p_list->push_back( PropertyInfo(Variant::COLOR,"custom_colors/"+E->get(),PROPERTY_HINT_NONE, "",hint) );
+		}
+	}
+	{
+		List<StringName> names;
+		theme->get_constant_list(get_type_name(),&names);
+		for(List<StringName>::Element *E=names.front();E;E=E->next()) {
+
+			uint32_t hint= PROPERTY_USAGE_EDITOR|PROPERTY_USAGE_CHECKABLE;
+			if (data.constant_override.has(E->get()))
+				hint|=PROPERTY_USAGE_STORAGE|PROPERTY_USAGE_CHECKED;
+
+			p_list->push_back( PropertyInfo(Variant::INT,"custom_constants/"+E->get(),PROPERTY_HINT_RANGE, "-16384,16384",hint) );
+		}
+	}
+
+
+}
+
+
+Control *Control::get_parent_control() const {
+
+	return data.parent;
+}
+
+void Control::_input_text(const String& p_text) {
+
+	if (!window)
+		return;
+	if (window->key_focus)
+		window->key_focus->call("set_text",p_text);
+
+}
+
+void Control::_gui_input(const InputEvent& p_event) {
+
+	_window_input_event(p_event);
+}
+
+void Control::_resize(const Size2& p_size) {
+	
+	_size_changed();
+}
+
+
+
+void Control::_notification(int p_notification) {
+
+
+	switch(p_notification) {
+
+		case NOTIFICATION_ENTER_SCENE: {
+
+			if (data.window==this) {
+
+				window = memnew( Window );
+				add_to_group("_gui_input");
+				add_to_group("windows");
+
+				window->tooltip_timer = memnew( Timer );
+				add_child(window->tooltip_timer);
+				window->tooltip_timer->set_wait_time( GLOBAL_DEF("display/tooltip_delay",0.7));
+				window->tooltip_timer->connect("timeout",this,"_window_show_tooltip");
+				window->tooltip=NULL;
+				window->tooltip_popup = memnew( TooltipPanel );
+				add_child(window->tooltip_popup);
+				window->tooltip_label = memnew( TooltipLabel );
+				window->tooltip_popup->add_child(window->tooltip_label);
+				window->tooltip_popup->set_as_toplevel(true);
+				window->tooltip_popup->hide();
+				window->drag_attempted=false;
+				window->drag_preview=NULL;
+
+				if (get_scene()->is_editor_hint()) {
+
+					Node *n = this;
+					while(n) {
+
+						if (n->has_meta("_editor_disable_input")) {
+							window->disable_input=true;
+							break;
+						}
+						n=n->get_parent();
+					}
+				}
+
+			} else {
+				window=NULL;
+			}
+
+			_size_changed();
+
+		} break;
+		case NOTIFICATION_EXIT_SCENE: {
+
+			if (data.window) {
+
+				if (data.window->window->mouse_focus == this)
+					data.window->window->mouse_focus=NULL;
+				if (data.window->window->key_focus == this)
+					data.window->window->key_focus=NULL;
+				if (data.window->window->mouse_over == this)
+					data.window->window->mouse_over=NULL;
+				if (data.window->window->tooltip == this)
+					data.window->window->tooltip=NULL;
+			}
+
+			if (window) {
+
+				remove_from_group("_gui_input");
+				remove_from_group("windows");
+				if (window->tooltip_timer)
+					memdelete(window->tooltip_timer);
+				window->tooltip_timer=NULL;
+				window->tooltip=NULL;
+				if (window->tooltip_popup)
+					memdelete(window->tooltip_popup);
+				window->tooltip_popup=NULL;
+
+				memdelete(window);
+				window=NULL;
+
+			}
+
+
+
+		} break;
+
+
+		case NOTIFICATION_ENTER_CANVAS: {
+
+			data.window=NULL;
+			data.viewport=NULL;
+			data.parent=NULL;
+
+			Control *_window=this;
+			bool gap=false;
+			bool gap_valid=true;
+			bool window_found=false;
+
+			Node *parent=_window->get_parent();
+			if (parent && parent->cast_to<Control>()) {
+
+				data.parent=parent->cast_to<Control>();
+			}
+
+			Viewport *viewport=NULL;
+
+			parent=this; //meh
+
+			while(parent) {
+
+				Control *c=parent->cast_to<Control>();
+
+				if (!window_found && c) {
+					if (!gap && c!=this) {
+						gap_valid=false;
+					}
+
+					_window = c;
+				}
+
+				CanvasItem *ci =parent->cast_to<CanvasItem>();
+
+				if ((ci && ci->is_set_as_toplevel()) || !ci) {
+					gap=true;
+				}
+
+				if (parent->cast_to<CanvasLayer>()) {
+					window_found=true; //don't go beyond canvas layer
+				}
+
+				viewport =parent->cast_to<Viewport>();
+				if (viewport) {
+					break; //no go beyond viewport either
+				}
+
+				parent=parent->get_parent();
+			}
+
+			data.window=_window;
+			data.viewport=viewport;
+			data.parent_canvas_item=get_parent_item();
+
+			if (data.parent_canvas_item) {
+
+				data.parent_canvas_item->connect("item_rect_changed",this,"_size_changed");
+			} else if (data.viewport) {
+
+				//connect viewport
+				data.viewport->connect("size_changed",this,"_size_changed");
+			} else {
+
+			}
+
+
+			if (gap && gap_valid && data.window!=this) {
+				//is a subwindow, conditions to meet subwindow status are quite complex..
+				data.SI = data.window->window->subwindows.push_back(this);
+				data.window->window->subwindow_order_dirty=true;
+
+			}
+
+
+		} break;
+		case NOTIFICATION_EXIT_CANVAS: {
+
+
+			if (data.parent_canvas_item) {
+
+				data.parent_canvas_item->disconnect("item_rect_changed",this,"_size_changed");
+				data.parent_canvas_item=NULL;
+			} else if (data.viewport) {
+
+				//disconnect viewport
+				data.viewport->disconnect("size_changed",this,"_size_changed");
+			} else {
+
+			}
+
+			if (data.MI) {
+
+				data.window->window->modal_stack.erase(data.MI);
+				data.MI=NULL;
+			}
+
+			if (data.SI) {
+				//erase from subwindows
+				data.window->window->subwindows.erase(data.SI);
+				data.SI=NULL;
+			}
+
+			data.viewport=NULL;
+			data.window=NULL;
+			data.parent=NULL;
+
+		} break;
+
+
+		case NOTIFICATION_PARENTED: {
+
+			Control * parent = get_parent()->cast_to<Control>();
+
+			//make children reference them theme
+			if (parent && data.theme.is_null() && parent->data.theme_owner)
+				_propagate_theme_changed(parent->data.theme_owner);
+
+		} break;
+		case NOTIFICATION_UNPARENTED: {
+
+			//make children unreference the theme
+			if (data.theme.is_null() && data.theme_owner)
+				_propagate_theme_changed(NULL);
+
+		} break;
+		 case NOTIFICATION_MOVED_IN_PARENT: {
+			 // some parents need to know the order of the childrens to draw (like TabContainer)
+			 // update if necesary
+			 if (data.parent)
+				 data.parent->update();
+			 update();
+
+			 if (data.SI && data.window) {
+				 data.window->window->subwindow_order_dirty=true;
+			 }
+
+		 } break;
+		case NOTIFICATION_RESIZED: {
+
+			emit_signal(SceneStringNames::get_singleton()->resized);
+		} break;
+		case NOTIFICATION_DRAW: {
+
+			Matrix32 xform;
+			xform.set_origin(get_pos());
+			VisualServer::get_singleton()->canvas_item_set_transform(get_canvas_item(),xform);
+			VisualServer::get_singleton()->canvas_item_set_custom_rect( get_canvas_item(),true, Rect2(Point2(),get_size()));
+			//emit_signal(SceneStringNames::get_singleton()->draw);
+
+		} break;
+		case NOTIFICATION_MOUSE_ENTER: {
+
+			emit_signal(SceneStringNames::get_singleton()->mouse_enter);
+		} break;
+		case NOTIFICATION_MOUSE_EXIT: {
+
+			emit_signal(SceneStringNames::get_singleton()->mouse_exit);
+		} break;
+		case NOTIFICATION_FOCUS_ENTER: {
+
+			emit_signal(SceneStringNames::get_singleton()->focus_enter);
+			update();
+		} break;
+		case NOTIFICATION_FOCUS_EXIT: {
+
+			emit_signal(SceneStringNames::get_singleton()->focus_exit);
+			update();
+
+		} break;
+		case NOTIFICATION_THEME_CHANGED: {
+
+			update();
+		} break;
+		case NOTIFICATION_VISIBILITY_CHANGED: {
+
+			if (!is_visible()) {
+
+				if (data.window->window->mouse_focus == this) {
+					data.window->window->mouse_focus=NULL;
+				}
+				if (data.window==this) {
+					window->drag_data=Variant();
+					if (window->drag_preview) {
+						memdelete( window->drag_preview);
+						window->drag_preview=NULL;
+					}
+				}
+
+				if (data.window->window->key_focus == this)
+					data.window->window->key_focus=NULL;
+				if (data.window->window->mouse_over == this)
+					data.window->window->mouse_over=NULL;
+				if (data.window->window->tooltip == this)
+					data.window->window->tooltip=NULL;
+				if (data.window->window->tooltip == this)
+					data.window->window->tooltip=NULL;
+
+				_modal_stack_remove();
+				minimum_size_changed();
+
+				//remove key focus
+				//remove modalness
+			} else {
+
+				_size_changed();
+			}
+
+		} break;
+		case SceneMainLoop::NOTIFICATION_WM_UNFOCUS_REQUEST: {
+
+			if (!window)
+				return;
+			if (window->key_focus)
+				window->key_focus->release_focus();
+
+		} break;
+
+
+
+	}
+}
+
+
+Size2 Control::_window_get_pos() const {
+
+	if (data.viewport) {
+
+		Rect2 r = data.viewport->get_visible_rect();
+		return r.pos;
+	} else
+		return Point2();
+
+	//return get_global_transform().get_origin();
+}
+
+
+bool Control::clips_input() const {
+
+	return false;
+}
+bool Control::has_point(const Point2& p_point) const {
+
+	if (get_script_instance()) {
+		Variant v=p_point;
+		const Variant *p=&v;
+		Variant::CallError ce;
+		Variant ret = get_script_instance()->call(SceneStringNames::get_singleton()->has_point,&p,1,ce);
+		if (ce.error==Variant::CallError::CALL_OK) {
+			return ret;
+		}
+	}
+	/*if (has_stylebox("mask")) {
+		Ref<StyleBox> mask = get_stylebox("mask");
+		return mask->test_mask(p_point,Rect2(Point2(),get_size()));
+	}*/
+	return Rect2( Point2(), get_size() ).has_point(p_point);
+}
+
+Variant Control::get_drag_data(const Point2& p_point) {
+
+	if (get_script_instance()) {
+		Variant v=p_point;
+		const Variant *p=&v;
+		Variant::CallError ce;
+		Variant ret = get_script_instance()->call(SceneStringNames::get_singleton()->get_drag_data,&p,1,ce);
+		if (ce.error==Variant::CallError::CALL_OK)
+			return ret;
+	}
+
+	return Variant();
+}
+
+
+bool Control::can_drop_data(const Point2& p_point,const Variant& p_data) const {
+
+	if (get_script_instance()) {
+		Variant v=p_point;
+		const Variant *p[2]={&v,&p_data};
+		Variant::CallError ce;
+		Variant ret = get_script_instance()->call(SceneStringNames::get_singleton()->can_drop_data,p,2,ce);
+		if (ce.error==Variant::CallError::CALL_OK)
+			return ret;
+	}
+
+	return Variant();
+
+}
+void Control::drop_data(const Point2& p_point,const Variant& p_data){
+
+	if (get_script_instance()) {
+		Variant v=p_point;
+		const Variant *p[2]={&v,&p_data};
+		Variant::CallError ce;
+		Variant ret = get_script_instance()->call(SceneStringNames::get_singleton()->drop_data,p,2,ce);
+		if (ce.error==Variant::CallError::CALL_OK)
+			return;
+	}
+}
+
+void Control::force_drag(const Variant& p_data,Control *p_control) {
+
+	ERR_FAIL_COND(!is_inside_scene());
+	ERR_FAIL_COND(!data.window);
+	ERR_FAIL_COND(p_data.get_type()==Variant::NIL);
+
+
+
+	data.window->window->drag_data=p_data;
+	data.window->window->mouse_focus=NULL;
+
+	if (p_control) {
+		data.window->set_drag_preview(p_control);
+	}
+}
+
+void Control::set_drag_preview(Control *p_control) {
+
+	ERR_FAIL_NULL(p_control);
+	ERR_FAIL_COND( !((Object*)p_control)->cast_to<Control>());
+	ERR_FAIL_COND(!is_inside_scene() || !data.window);
+	ERR_FAIL_COND(p_control->is_inside_scene());
+	ERR_FAIL_COND(p_control->get_parent()!=NULL);
+
+	if (data.window->window->drag_preview) {
+		memdelete(data.window->window->drag_preview);
+	}
+	p_control->set_as_toplevel(true);
+	p_control->set_pos(data.window->window->last_mouse_pos);
+	data.window->add_child(p_control);
+	if (data.window->window->drag_preview) {
+		memdelete( data.window->window->drag_preview );
+	}
+
+	data.window->window->drag_preview=p_control;
+
+}
+
+
+Control* Control::_find_next_visible_control_at_pos(Node* p_node,const Point2& p_global,Matrix32& r_xform) const {
+
+	return NULL;
+}
+
+Control* Control::_find_control_at_pos(CanvasItem* p_node,const Point2& p_global,const Matrix32& p_xform,Matrix32& r_inv_xform)  {
+
+	if (p_node->cast_to<Viewport>())
+		return NULL;
+
+	Control *c=p_node->cast_to<Control>();
+
+	if (c) {
+	//	print_line("at "+String(c->get_path())+" POS "+c->get_pos()+" bt "+p_xform);
+	}
+
+	if (c==data.window) {
+		//try subwindows first!!
+
+		c->_window_sort_subwindows(); // sort them
+
+		for (List<Control*>::Element *E=c->window->subwindows.back();E;E=E->prev()) {
+
+			Control *sw = E->get();
+			if (!sw->is_visible())
+				continue;
+
+			Matrix32 xform;
+			CanvasItem *pci = sw->get_parent_item();
+			if (pci)
+				xform=pci->get_global_transform();
+
+			Control *ret = _find_control_at_pos(sw,p_global,xform,r_inv_xform);
+			if (ret)
+				return ret;
+
+		}
+	}
+
+	if (p_node->is_hidden()) {
+		//return _find_next_visible_control_at_pos(p_node,p_global,r_inv_xform);
+		return NULL; //canvas item hidden, discard
+	}
+
+	Matrix32 matrix = p_xform * p_node->get_transform();
+
+	if (!c || !c->clips_input() || c->has_point(matrix.affine_inverse().xform(p_global))) {
+
+		for(int i=p_node->get_child_count()-1;i>=0;i--) {
+
+			if (p_node==data.window->window->tooltip_popup)
+				continue;
+
+			CanvasItem *ci = p_node->get_child(i)->cast_to<CanvasItem>();
+			if (!ci || ci->is_set_as_toplevel())
+				continue;
+
+			Control *ret=_find_control_at_pos(ci,p_global,matrix,r_inv_xform);;
+			if (ret)
+				return ret;
+		}
+	}
+
+	if (!c)
+		return NULL;
+
+	matrix.affine_invert();
+
+	//conditions for considering this as a valid control for return
+	if (!c->data.ignore_mouse && c->has_point(matrix.xform(p_global)) && (!window->drag_preview || (c!=window->drag_preview && !window->drag_preview->is_a_parent_of(c)))) {
+		r_inv_xform=matrix;
+		return c;
+	} else
+		return NULL;
+}
+		
+void Control::_window_cancel_input_ID(int p_input) {
+
+	window->cancelled_input_ID=(unsigned int)p_input;
+}
+		
+void Control::_window_remove_focus() {
+	
+	if (window->key_focus) {
+		
+		Node *f=window->key_focus;
+		window->key_focus=NULL;
+		f->notification( NOTIFICATION_FOCUS_EXIT,true );
+
+	}		
+}
+
+bool Control::window_has_modal_stack() const {
+
+
+	if (!data.window)
+		return false;
+	return data.window->window->modal_stack.size();
+}
+
+void Control::_window_cancel_tooltip() {
+
+	window->tooltip=NULL;
+	if (window->tooltip_timer)
+		window->tooltip_timer->stop();
+	if (window->tooltip_popup)
+		window->tooltip_popup->hide();
+
+}
+
+void Control::_window_show_tooltip() {
+
+	if (!window->tooltip) {
+		return;
+	}
+
+	String tooltip = window->tooltip->get_tooltip( window->tooltip->get_global_transform().xform_inv(window->tooltip_pos) );
+	if (tooltip.length()==0)
+		return; // bye
+
+
+	if (!window->tooltip_label) {
+		return;
+	}
+	Ref<StyleBox> ttp = get_stylebox("panel","TooltipPanel");
+
+	window->tooltip_label->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_BEGIN,ttp->get_margin(MARGIN_LEFT));
+	window->tooltip_label->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,ttp->get_margin(MARGIN_TOP));
+	window->tooltip_label->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,ttp->get_margin(MARGIN_RIGHT));
+	window->tooltip_label->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,ttp->get_margin(MARGIN_BOTTOM));
+	window->tooltip_label->set_text(tooltip);
+	Rect2 r(window->tooltip_pos+Point2(10,10),window->tooltip_label->get_combined_minimum_size()+ttp->get_minimum_size());
+	Rect2 vr = get_viewport_rect();
+	if (r.size.x+r.pos.x>vr.size.x)
+		r.pos.x=vr.size.x-r.size.x;
+	else if (r.pos.x<0)
+		r.pos.x=0;
+
+	if (r.size.y+r.pos.y>vr.size.y)
+		r.pos.y=vr.size.y-r.size.y;
+	else if (r.pos.y<0)
+		r.pos.y=0;
+
+	window->tooltip_popup->set_pos(r.pos);
+	window->tooltip_popup->set_size(r.size);
+
+	window->tooltip_popup->raise();
+
+	window->tooltip_popup->show();
+}
+
+
+void Control::_window_call_input(Control *p_control,const InputEvent& p_input) {
+
+
+	while(p_control) {
+
+		p_control->call_multilevel(SceneStringNames::get_singleton()->_input_event,p_input);
+		if (window->key_event_accepted)
+			break;
+		p_control->emit_signal(SceneStringNames::get_singleton()->input_event,p_input);
+		if (p_control->is_set_as_toplevel()) {
+			break;
+		}
+		if (window->key_event_accepted)
+			break;
+		if (p_control->data.stop_mouse && (p_input.type==InputEvent::MOUSE_BUTTON || p_input.type==InputEvent::MOUSE_MOTION))
+			break;
+		p_control=p_control->data.parent;
+	}
+}
+
+void Control::_window_input_event(InputEvent p_event) {
+
+
+
+	if (!window)
+		return;
+
+	if (window->disable_input)
+		return;
+
+	if (p_event.ID==window->cancelled_input_ID) {
+		return;
+	}
+	if (!is_visible()) {
+		return; //simple and plain
+	}
+	switch(p_event.type) {
+	
+		case InputEvent::MOUSE_BUTTON: {
+
+
+		window->key_event_accepted=false;
+
+		Point2 mpos =(get_viewport_transform()).affine_inverse().xform(Point2(p_event.mouse_button.x,p_event.mouse_button.y));
+
+		if (p_event.mouse_button.pressed) {
+
+
+
+			Size2 pos = mpos - _window_get_pos();
+			if (window->mouse_focus && p_event.mouse_button.button_index!=window->mouse_focus_button) {
+
+				//do not steal mouse focus and stuff
+
+			} else {
+
+
+				_window_sort_modal_stack();
+				while (!window->modal_stack.empty()) {
+
+					Control *top = window->modal_stack.back()->get();
+					if (!top->has_point(top->get_global_transform().affine_inverse().xform(pos))) {
+
+						if (top->data.modal_exclusive) {
+							//cancel event, sorry, modal exclusive EATS UP ALL
+							get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+							get_scene()->set_input_as_handled();
+							return; // no one gets the event if exclusive NO ONE
+						}
+
+						top->notification(NOTIFICATION_MODAL_CLOSE);
+						top->_modal_stack_remove();
+						top->hide();
+					} else {
+						break;
+					}
+				}
+
+
+
+				Matrix32 parent_xform;
+
+				if (data.parent_canvas_item)
+					parent_xform=data.parent_canvas_item->get_global_transform();
+
+
+
+				window->mouse_focus = _find_control_at_pos(this,pos,parent_xform,window->focus_inv_xform);
+				//print_line("has mf "+itos(window->mouse_focus!=NULL));
+				window->mouse_focus_button=p_event.mouse_button.button_index;
+
+				if (!window->mouse_focus) {
+					break;
+				}
+
+				if (p_event.mouse_button.button_index==BUTTON_LEFT) {
+					window->drag_accum=Vector2();
+					window->drag_attempted=false;
+					window->drag_data=Variant();
+				}
+
+
+			}
+
+			p_event.mouse_button.global_x = pos.x;
+				p_event.mouse_button.global_y = pos.y;
+
+				pos = window->focus_inv_xform.xform(pos);
+				p_event.mouse_button.x = pos.x;
+				p_event.mouse_button.y = pos.y;
+
+#ifdef DEBUG_ENABLED
+				if (ScriptDebugger::get_singleton()) {
+
+					Array arr;
+					arr.push_back(window->mouse_focus->get_path());
+					arr.push_back(window->mouse_focus->get_type());
+					ScriptDebugger::get_singleton()->send_message("click_ctrl",arr);
+				}
+
+				/*if (bool(GLOBAL_DEF("debug/print_clicked_control",false))) {
+
+					print_line(String(window->mouse_focus->get_path())+" - "+pos);
+				}*/
+#endif
+
+				if (window->mouse_focus->get_focus_mode()!=FOCUS_NONE && window->mouse_focus!=window->key_focus && p_event.mouse_button.button_index==BUTTON_LEFT) {
+					// also get keyboard focus
+					window->mouse_focus->grab_focus();
+				}
+
+
+				if (window->mouse_focus->can_process()) {
+					_window_call_input(window->mouse_focus,p_event);
+				}
+				
+				get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+				get_scene()->set_input_as_handled();
+
+			} else {
+
+				if (window->drag_preview && p_event.mouse_button.button_index==BUTTON_LEFT) {
+					memdelete( window->drag_preview );
+					window->drag_preview=NULL;
+				}
+
+				if (!window->mouse_focus) {
+
+					if (window->mouse_over && window->drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) {
+
+						Size2 pos = mpos - _window_get_pos();
+						pos = window->focus_inv_xform.xform(pos);
+						window->mouse_over->drop_data(pos,window->drag_data);
+						window->drag_data=Variant();
+						//change mouse accordingly
+					}
+
+					break;
+				}
+
+				Size2 pos = mpos - _window_get_pos();
+				p_event.mouse_button.global_x = pos.x;
+				p_event.mouse_button.global_y = pos.y;
+				pos = window->focus_inv_xform.xform(pos);
+				p_event.mouse_button.x = pos.x;
+				p_event.mouse_button.y = pos.y;
+
+				if (window->mouse_focus->can_process()) {
+					_window_call_input(window->mouse_focus,p_event);
+				}
+
+				if (p_event.mouse_button.button_index==window->mouse_focus_button) {
+					window->mouse_focus=NULL;
+					window->mouse_focus_button=-1;
+				}
+
+				if (window->drag_data.get_type()!=Variant::NIL && p_event.mouse_button.button_index==BUTTON_LEFT) {
+					window->drag_data=Variant(); //always clear
+				}
+
+
+				get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+				get_scene()->set_input_as_handled();
+
+			}
+		} break;
+		case InputEvent::MOUSE_MOTION: {
+
+			window->key_event_accepted=false;
+
+			Matrix32 localizer = (get_viewport_transform()).affine_inverse();
+			Size2 pos = localizer.xform(Size2(p_event.mouse_motion.x,p_event.mouse_motion.y)) - _window_get_pos();
+			Vector2 speed = localizer.basis_xform(Point2(p_event.mouse_motion.speed_x,p_event.mouse_motion.speed_y));
+			Vector2 rel = localizer.basis_xform(Point2(p_event.mouse_motion.relative_x,p_event.mouse_motion.relative_y));
+
+			window->last_mouse_pos=pos;
+			
+			Control *over = NULL;
+
+			Matrix32 parent_xform;
+			if (data.parent_canvas_item)
+				parent_xform=data.parent_canvas_item->get_global_transform();
+
+			// D&D
+			if (!window->drag_attempted && window->mouse_focus && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) {
+
+				window->drag_accum+=rel;
+				float len = window->drag_accum.length();
+				if (len>10) {
+					window->drag_data=window->mouse_focus->get_drag_data(window->focus_inv_xform.xform(pos)-window->drag_accum);
+					if (window->drag_data.get_type()!=Variant::NIL) {
+
+						window->mouse_focus=NULL;
+					}
+					window->drag_attempted=true;
+				}
+			}
+
+
+			if (window->mouse_focus) {
+				over=window->mouse_focus;
+				//recompute focus_inv_xform again here
+
+			} else {
+
+				over = _find_control_at_pos(this,pos,parent_xform,window->focus_inv_xform);
+			}
+
+			if (window->drag_data.get_type()==Variant::NIL && over && !window->modal_stack.empty()) {
+
+				Control *top = window->modal_stack.back()->get();
+				if (over!=top && !top->is_a_parent_of(over)) {
+
+					break; // don't send motion event to anything below modal stack top
+				}
+			}
+
+			if (over!=window->mouse_over) {
+			
+				if (window->mouse_over)
+					window->mouse_over->notification(NOTIFICATION_MOUSE_EXIT);
+					
+				if (over)
+					over->notification(NOTIFICATION_MOUSE_ENTER);
+					
+			}
+			
+			window->mouse_over=over;
+
+			get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_tooltip");
+
+			if (window->drag_preview) {
+				window->drag_preview->set_pos(pos);
+			}
+
+			if (!over) {
+				OS::get_singleton()->set_cursor_shape(OS::CURSOR_ARROW);
+			 	break;
+			}
+			 	
+			p_event.mouse_motion.global_x = pos.x;
+			p_event.mouse_motion.global_y = pos.y;
+			p_event.mouse_motion.speed_x=speed.x;
+			p_event.mouse_motion.speed_y=speed.y;
+			p_event.mouse_motion.relative_x=rel.x;
+			p_event.mouse_motion.relative_y=rel.y;
+
+			if (p_event.mouse_motion.button_mask==0 && window->tooltip_timer) {
+				//nothing pressed
+
+				bool can_tooltip=true;
+
+				if (!window->modal_stack.empty()) {
+					if (window->modal_stack.back()->get()!=over && !window->modal_stack.back()->get()->is_a_parent_of(over))
+						can_tooltip=false;
+
+				}
+
+
+				if (can_tooltip) {
+
+					window->tooltip=over;
+					window->tooltip_pos=(parent_xform * get_transform()).affine_inverse().xform(pos);
+					window->tooltip_timer->start();
+				}
+			}
+
+
+			pos = window->focus_inv_xform.xform(pos);
+
+
+			p_event.mouse_motion.x = pos.x;
+			p_event.mouse_motion.y = pos.y;
+
+
+			CursorShape cursor_shape = over->get_cursor_shape(pos);
+			OS::get_singleton()->set_cursor_shape( (OS::CursorShape)cursor_shape );
+
+
+			if (over->can_process()) {
+				_window_call_input(over,p_event);
+			}
+
+
+			
+			get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+			get_scene()->set_input_as_handled();
+
+
+			if (window->drag_data.get_type()!=Variant::NIL && p_event.mouse_motion.button_mask&BUTTON_MASK_LEFT) {
+
+				/*bool can_drop =*/ over->can_drop_data(pos,window->drag_data);
+				//change mouse accordingly i guess
+			}
+
+		} break;
+		case InputEvent::ACTION:
+		case InputEvent::JOYSTICK_BUTTON:
+		case InputEvent::KEY: {
+	
+			if (window->key_focus) {
+			
+				window->key_event_accepted=false;
+				if (window->key_focus->can_process()) {
+					window->key_focus->call_multilevel("_input_event",p_event);
+					if (window->key_focus) //maybe lost it
+						window->key_focus->emit_signal(SceneStringNames::get_singleton()->input_event,p_event);
+				}
+
+
+				if (window->key_event_accepted) {
+
+					get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+					break;
+				}
+			}
+
+
+			if (p_event.is_pressed() && p_event.is_action("ui_cancel") && !window->modal_stack.empty()) {
+
+				_window_sort_modal_stack();
+				Control *top = window->modal_stack.back()->get();
+				if (!top->data.modal_exclusive) {
+
+					top->notification(NOTIFICATION_MODAL_CLOSE);
+					top->_modal_stack_remove();
+					top->hide();
+				}
+			}
+
+
+			Control * from = window->key_focus ? window->key_focus : NULL; //hmm
+
+			//keyboard focus
+			//if (from && p_event.key.pressed && !p_event.key.mod.alt && !p_event.key.mod.meta && !p_event.key.mod.command) {
+
+			if (from && p_event.is_pressed()) {
+				Control * next=NULL;
+
+				if (p_event.is_action("ui_focus_next")) {
+
+					next = from->find_next_valid_focus();
+				}
+
+				if (p_event.is_action("ui_focus_prev")) {
+
+					next = from->find_prev_valid_focus();
+				}
+
+				if (p_event.is_action("ui_up")) {
+
+					next = from->_get_focus_neighbour(MARGIN_TOP);
+				}
+
+				if (p_event.is_action("ui_left")) {
+
+					next = from->_get_focus_neighbour(MARGIN_LEFT);
+				}
+
+				if (p_event.is_action("ui_right")) {
+
+					next = from->_get_focus_neighbour(MARGIN_RIGHT);
+				}
+
+				if (p_event.is_action("ui_down")) {
+
+					next = from->_get_focus_neighbour(MARGIN_BOTTOM);
+				}
+
+
+				if (next) {
+					next->grab_focus();
+					get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_cancel_input_ID",p_event.ID);
+				}
+			}
+
+		} break;
+	}
+}
+
+Control *Control::get_window() const {
+	
+	return data.window;
+}
+
+bool Control::is_window() const {
+
+	return (is_inside_scene() && window);
+}
+
+
+Size2 Control::get_minimum_size() const {
+	
+	ScriptInstance *si = const_cast<Control*>(this)->get_script_instance();
+	if (si) {
+
+		Variant::CallError ce;
+		Variant s = si->call(SceneStringNames::get_singleton()->get_minimum_size,NULL,0,ce);
+		if (ce.error==Variant::CallError::CALL_OK)
+			return s;
+	}
+	return Size2();
+}
+
+
+Ref<Texture> Control::get_icon(const StringName& p_name,const StringName& p_type) const {
+	
+	const Ref<Texture>* tex = data.icon_override.getptr(p_name);
+	if (tex)
+		return *tex;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_icon(p_name, type ) )
+			return data.theme_owner->data.theme->get_icon(p_name, type );
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->get_icon( p_name, type );
+
+}
+
+Ref<StyleBox> Control::get_stylebox(const StringName& p_name,const StringName& p_type) const {
+		
+	
+	const Ref<StyleBox>* style = data.style_override.getptr(p_name);
+	
+	
+	if (style)
+		return *style;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_stylebox(p_name, type ) )
+			return data.theme_owner->data.theme->get_stylebox(p_name, type );
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+	}
+
+	return Theme::get_default()->get_stylebox( p_name, type );
+
+}
+Ref<Font> Control::get_font(const StringName& p_name,const StringName& p_type) const {
+	
+	const Ref<Font>* font = data.font_override.getptr(p_name);
+	if (font)
+		return *font;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_font(p_name, type ) )
+			return data.theme_owner->data.theme->get_font(p_name, type );
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->get_font( p_name, type );
+
+}
+Color Control::get_color(const StringName& p_name,const StringName& p_type) const {
+	
+	const Color* color = data.color_override.getptr(p_name);
+	if (color)
+		return *color;	
+
+	StringName type = p_type?p_type:get_type_name();
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_color(p_name, type ) )
+			return data.theme_owner->data.theme->get_color(p_name, type );
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->get_color( p_name, type );
+
+}
+
+int Control::get_constant(const StringName& p_name,const StringName& p_type) const {
+	
+	const int* constant = data.constant_override.getptr(p_name);
+	if (constant)
+		return *constant;	
+
+	StringName type = p_type?p_type:get_type_name();
+		// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_constant(p_name, type ) )
+			return data.theme_owner->data.theme->get_constant(p_name, type );
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->get_constant( p_name, type );
+
+	
+}
+
+
+bool Control::has_icon(const StringName& p_name,const StringName& p_type) const {
+	
+	const Ref<Texture>* tex = data.icon_override.getptr(p_name);
+	if (tex)
+		return true;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_icon(p_name, type ) )
+			return true;
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->has_icon( p_name, type );
+
+}
+bool Control::has_stylebox(const StringName& p_name,const StringName& p_type) const {
+		
+	
+	const Ref<StyleBox>* style = data.style_override.getptr(p_name);
+		
+	if (style)
+		return true;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_stylebox(p_name, type ) )
+			return true;
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->has_stylebox( p_name, type );
+
+}
+bool Control::has_font(const StringName& p_name,const StringName& p_type) const {
+	
+	const Ref<Font>* font = data.font_override.getptr(p_name);
+	if (font)
+		return true;	
+
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_font(p_name, type ) )
+			return true;
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->has_font( p_name, type );
+
+}
+bool Control::has_color(const StringName& p_name,const StringName& p_type) const {
+	
+	const Color* color = data.color_override.getptr(p_name);
+	if (color)
+		return true;	
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_color(p_name, type ) )
+			return true;
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->has_color( p_name, type );
+
+}
+
+bool Control::has_constant(const StringName& p_name,const StringName& p_type) const {
+	
+	const int* constant = data.constant_override.getptr(p_name);
+	if (constant)
+		return true;	
+
+
+	StringName type = p_type?p_type:get_type_name();
+
+	// try with custom themes
+	Control *theme_owner = data.theme_owner;
+
+	while(theme_owner) {
+
+		if (theme_owner->data.theme->has_constant(p_name, type ) )
+			return true;
+		Control *parent = theme_owner->get_parent()?theme_owner->get_parent()->cast_to<Control>():NULL;
+
+		if (parent)
+			theme_owner=parent->data.theme_owner;
+		else
+			theme_owner=NULL;
+
+	}
+
+	return Theme::get_default()->has_constant( p_name, type );
+}
+
+Size2 Control::get_parent_area_size() const {
+
+	ERR_FAIL_COND_V(!is_inside_scene(),Size2());
+
+	Size2 parent_size;
+
+	if (data.parent_canvas_item) {
+
+		parent_size=data.parent_canvas_item->get_item_rect().size;
+	} else if (data.viewport) {
+
+		parent_size=data.viewport->get_visible_rect().size;
+	} 
+	return parent_size;
+
+}
+
+void Control::_size_changed() {
+
+	if (!is_inside_scene())
+		return;
+
+	Size2 parent_size = get_parent_area_size();
+
+	float margin_pos[4];
+
+	for(int i=0;i<4;i++) {
+
+		float area = parent_size[i&1];
+		switch(data.anchor[i]) {
+
+			case ANCHOR_BEGIN: {
+
+				margin_pos[i]=data.margin[i];
+			} break;
+			case ANCHOR_END: {
+
+				margin_pos[i]=area-data.margin[i];
+			} break;
+			case ANCHOR_RATIO: {
+
+				margin_pos[i]=area*data.margin[i];
+			} break;
+		}
+	}
+
+	Point2 new_pos_cache=Point2(margin_pos[0],margin_pos[1]).floor();
+	Size2 new_size_cache=Point2(margin_pos[2],margin_pos[3]).floor()-new_pos_cache;
+	Size2 minimum_size=get_combined_minimum_size();
+
+	new_size_cache.x = MAX( minimum_size.x, new_size_cache.x );
+	new_size_cache.y = MAX( minimum_size.y, new_size_cache.y );
+
+
+	if (new_pos_cache == data.pos_cache && new_size_cache == data.size_cache)
+		return; // did not change, don't emit signal
+
+	data.pos_cache=new_pos_cache;
+	data.size_cache=new_size_cache;
+
+	notification(NOTIFICATION_RESIZED);
+	item_rect_changed();
+	_change_notify_margins();
+	_notify_transform();
+}
+
+float Control::_get_parent_range(int p_idx) const {
+	
+	if (!is_inside_scene()) {
+	
+		return 1.0;
+		
+	} if (data.parent_canvas_item) {
+
+		return data.parent_canvas_item->get_item_rect().size[p_idx&1];
+	} else if (data.viewport) {
+		return data.viewport->get_visible_rect().size[p_idx&1];
+	}
+
+	return 1.0;
+}
+
+
+float Control::_get_range(int p_idx) const {
+	
+	p_idx&=1;
+
+	float parent_range = _get_parent_range( p_idx );
+	float from = _a2s( data.margin[p_idx], data.anchor[p_idx], parent_range );
+	float to = _a2s( data.margin[p_idx+2], data.anchor[p_idx+2], parent_range );
+	
+	return to-from;
+}
+
+float Control::_s2a(float p_val, AnchorType p_anchor,float p_range) const {
+	
+	switch(p_anchor) {
+		
+		case ANCHOR_BEGIN: {			
+			return p_val;
+		} break;
+		case ANCHOR_END: {
+			return p_range-p_val;
+		} break;
+		case ANCHOR_RATIO: {
+			return p_val/p_range;
+		} break;			
+	}	
+	
+	return 0;
+}
+
+
+float Control::_a2s(float p_val, AnchorType p_anchor,float p_range) const {
+	
+	switch(p_anchor) {
+		
+		case ANCHOR_BEGIN: {			
+			return Math::floor(p_val);
+		} break;
+		case ANCHOR_END: {
+			return Math::floor(p_range-p_val);
+		} break;
+		case ANCHOR_RATIO: {
+			return Math::floor(p_range*p_val);
+		} break;			
+	}
+	return 0;
+}
+
+
+void Control::set_anchor(Margin p_margin,AnchorType p_anchor) {
+	
+	if (!is_inside_scene()) {
+		
+		data.anchor[p_margin]=p_anchor;
+	} else {
+		float pr = _get_parent_range(p_margin);
+		float s = _a2s( data.margin[p_margin], data.anchor[p_margin], pr );
+		data.anchor[p_margin]=p_anchor;
+		data.margin[p_margin] = _s2a( s, p_anchor, pr );
+	}
+	_change_notify();
+}
+
+void Control::set_anchor_and_margin(Margin p_margin,AnchorType p_anchor, float p_pos) {
+
+	set_anchor(p_margin,p_anchor);
+	set_margin(p_margin,p_pos);
+}
+
+
+Control::AnchorType Control::get_anchor(Margin p_margin) const {
+	
+	return data.anchor[p_margin];	
+}
+
+
+
+
+
+void Control::_change_notify_margins() {
+
+	// this avoids sending the whole object data again on a change
+	_change_notify("margin/left");
+	_change_notify("margin/top");
+	_change_notify("margin/right");
+	_change_notify("margin/bottom");
+	_change_notify("rect/pos");
+	_change_notify("rect/size");
+
+}
+
+
+void Control::set_margin(Margin p_margin,float p_value) {
+
+	data.margin[p_margin]=p_value;
+	_size_changed();
+
+}
+
+void Control::set_begin(const Size2& p_point) {
+	
+	data.margin[0]=p_point.x;
+	data.margin[1]=p_point.y;
+	_size_changed();
+}
+
+void Control::set_end(const Size2& p_point) {
+	
+	data.margin[2]=p_point.x;
+	data.margin[3]=p_point.y;
+	_size_changed();
+}
+
+float Control::get_margin(Margin p_margin) const {
+	
+	return data.margin[p_margin];
+}
+
+Size2 Control::get_begin() const {
+	
+	return Size2( data.margin[0], data.margin[1] );
+}
+Size2 Control::get_end() const {
+	
+	return Size2( data.margin[2], data.margin[3] );
+}
+
+Point2 Control::get_global_pos() const {
+	
+	return get_global_transform().get_origin();
+}
+
+void Control::set_global_pos(const Point2& p_point) {
+	
+	Matrix32 inv;
+
+	if (data.parent_canvas_item) {
+
+		inv = data.parent_canvas_item->get_global_transform().affine_inverse();
+	}
+
+	set_pos(inv.xform(p_point));
+}
+
+void Control::set_pos(const Size2& p_point) {
+
+	float pw = _get_parent_range(0);
+	float ph = _get_parent_range(1);
+
+	float x = _a2s( data.margin[0], data.anchor[0], pw );
+	float y = _a2s( data.margin[1], data.anchor[1], ph );
+	float x2 = _a2s( data.margin[2], data.anchor[2], pw );
+	float y2 = _a2s( data.margin[3], data.anchor[3], ph );
+
+	Size2 ret = Size2(x2-x,y2-y);
+	Size2 min = get_combined_minimum_size();
+
+	Size2 size = Size2(MAX( min.width, ret.width),MAX( min.height, ret.height));
+	float w=size.x;
+	float h=size.y;
+	
+	x=p_point.x;
+	y=p_point.y;
+	
+	data.margin[0] = _s2a( x, data.anchor[0], pw );
+	data.margin[1] = _s2a( y, data.anchor[1], ph );
+	data.margin[2] = _s2a( x+w, data.anchor[2], pw );
+	data.margin[3] = _s2a( y+h, data.anchor[3], ph );
+
+	_size_changed();
+}
+
+void Control::set_size(const Size2& p_size) {
+		
+	Size2 new_size=p_size;
+	Size2 min=get_combined_minimum_size();
+	if (new_size.x<min.x)
+		new_size.x=min.x;
+	if (new_size.y<min.y)
+		new_size.y=min.y;
+	
+	float pw = _get_parent_range(0);
+	float ph = _get_parent_range(1);
+	
+	float x = _a2s( data.margin[0], data.anchor[0], pw );
+	float y = _a2s( data.margin[1], data.anchor[1], ph );
+	
+	float w=new_size.width;
+	float h=new_size.height;
+	
+	data.margin[2] = _s2a( x+w, data.anchor[2], pw );
+	data.margin[3] = _s2a( y+h, data.anchor[3], ph );
+	
+	_size_changed();
+}
+
+
+Size2 Control::get_pos() const {
+
+	return data.pos_cache;
+}
+
+Size2 Control::get_size() const {
+	
+	return data.size_cache;
+}
+
+Rect2 Control::get_global_rect() const {
+						    
+	return Rect2( get_global_pos(), get_size() );				    
+}
+
+Rect2 Control::get_window_rect() const {
+
+	Rect2 gr = get_global_rect();
+	if (data.viewport)
+		gr.pos+=data.viewport->get_visible_rect().pos;
+	return gr;
+}
+
+
+Rect2 Control::get_rect() const {
+	
+	return Rect2(get_pos(),get_size());
+}
+
+Rect2 Control::get_item_rect() const {
+
+	return Rect2(Point2(),get_size());
+}
+
+void Control::set_area_as_parent_rect(int p_margin) {
+	
+	data.anchor[MARGIN_LEFT]=ANCHOR_BEGIN;
+	data.anchor[MARGIN_TOP]=ANCHOR_BEGIN;
+	data.anchor[MARGIN_RIGHT]=ANCHOR_END;
+	data.anchor[MARGIN_BOTTOM]=ANCHOR_END;
+	for(int i=0;i<4;i++)
+		data.margin[i]=p_margin;
+
+	_size_changed();
+	
+}
+
+void Control::add_icon_override(const StringName& p_name, const Ref<Texture>& p_icon) {
+
+	ERR_FAIL_COND(p_icon.is_null());
+	data.icon_override[p_name]=p_icon;
+	notification(NOTIFICATION_THEME_CHANGED);
+	update();
+
+}
+void Control::add_style_override(const StringName& p_name, const Ref<StyleBox>& p_style) {
+
+	ERR_FAIL_COND(p_style.is_null());
+	data.style_override[p_name]=p_style;
+	notification(NOTIFICATION_THEME_CHANGED);
+	update();
+}
+
+
+void Control::add_font_override(const StringName& p_name, const Ref<Font>& p_font) {
+
+	ERR_FAIL_COND(p_font.is_null());
+	data.font_override[p_name]=p_font;
+	notification(NOTIFICATION_THEME_CHANGED);
+	update();
+}
+void Control::add_color_override(const StringName& p_name, const Color& p_color) {
+
+	data.color_override[p_name]=p_color;
+	notification(NOTIFICATION_THEME_CHANGED);
+	update();
+}
+void Control::add_constant_override(const StringName& p_name, int p_constant) {
+
+	data.constant_override[p_name]=p_constant;
+	notification(NOTIFICATION_THEME_CHANGED);
+	update();
+}
+
+void Control::set_focus_mode(FocusMode p_focus_mode) {
+
+	if (is_inside_scene() && p_focus_mode == FOCUS_NONE && data.focus_mode!=FOCUS_NONE && has_focus())
+		release_focus();
+
+	data.focus_mode=p_focus_mode;
+
+}
+
+static Control *_next_control(Control *p_from) {
+
+	if (p_from->is_set_as_toplevel())
+		return NULL; // can't go above
+
+	Control *parent = p_from->get_parent()?p_from->get_parent()->cast_to<Control>():NULL;	
+
+	if (!parent) {
+
+		return NULL;
+	}
+
+
+	int next = p_from->get_position_in_parent();
+	ERR_FAIL_INDEX_V(next,parent->get_child_count(),NULL);
+	for(int i=(next+1);i<parent->get_child_count();i++) {
+
+		Control *c = parent->get_child(i)->cast_to<Control>();
+		if (!c || !c->is_visible() || c->is_set_as_toplevel())
+			continue;
+
+		return c;
+	}
+
+	//no next in parent, try the same in parent
+	return _next_control(parent);
+}
+
+Control *Control::find_next_valid_focus() const {
+
+	Control *from = const_cast<Control*>(this);
+	
+	while(true) {
+	
+		
+		// find next child
+
+		Control *next_child=NULL;
+
+
+		for(int i=0;i<from->get_child_count();i++) {
+
+			Control *c = from->get_child(i)->cast_to<Control>();
+			if (!c || !c->is_visible() || c->is_set_as_toplevel()) {
+				continue;
+			}
+
+			next_child=c;
+			break;
+		}
+
+		if (next_child) {
+
+			from = next_child;
+		} else {
+
+			next_child=_next_control(from);
+			if (!next_child) { //nothing else.. go up and find either window or subwindow
+				next_child=const_cast<Control*>(this);
+				while(next_child && !next_child->is_set_as_toplevel()) {
+					if (next_child->get_parent()) {
+						next_child=next_child->get_parent()->cast_to<Control>();
+					} else
+						next_child=NULL;
+
+				}
+
+				if (!next_child) {
+					next_child=get_window();
+				}
+			}
+
+		}
+
+
+		if (next_child==this) // no next control->
+			return (get_focus_mode()==FOCUS_ALL)?next_child:NULL;
+
+		if (next_child->get_focus_mode()==FOCUS_ALL)
+			return next_child;
+
+		from = next_child;
+	}
+	
+	return NULL;
+
+
+}
+
+
+
+
+static Control *_prev_control(Control *p_from) {
+
+
+	Control *child=NULL;
+	for(int i=p_from->get_child_count()-1;i>=0;i--) {
+
+		Control *c = p_from->get_child(i)->cast_to<Control>();
+		if (!c || !c->is_visible() || c->is_set_as_toplevel())
+			continue;
+
+		child=c;
+		break;
+	}
+
+	if (!child)
+		return p_from;
+
+	//no prev in parent, try the same in parent
+	return _prev_control(child);
+}
+
+Control *Control::find_prev_valid_focus() const {
+	Control *from = const_cast<Control*>(this);
+
+	while(true) {
+
+
+		// find prev child
+
+
+			Control *prev_child = NULL;
+
+
+
+			if ( from->is_set_as_toplevel() || !from->get_parent() || !from->get_parent()->cast_to<Control>()) {
+
+				//find last of the childs
+
+				prev_child=_prev_control(from);
+
+			} else {
+
+				for(int i=(from->get_position_in_parent()-1);i>=0;i--) {
+
+
+					Control *c = from->get_parent()->get_child(i)->cast_to<Control>();
+
+					if (!c || !c->is_visible() || c->is_set_as_toplevel()) {
+						continue;
+					}
+
+					prev_child=c;
+					break;
+
+				}
+
+				if (!prev_child) {
+
+
+
+					prev_child = from->get_parent()->cast_to<Control>();
+				} else {
+
+
+
+					prev_child = _prev_control(prev_child);
+				}
+			}
+
+
+
+
+			if (prev_child==this) // no prev control->
+				return (get_focus_mode()==FOCUS_ALL)?prev_child:NULL;
+
+			if (prev_child->get_focus_mode()==FOCUS_ALL)
+				return prev_child;
+
+			from = prev_child;
+
+		}
+
+		return NULL;
+
+	return NULL;
+}
+
+
+Control::FocusMode Control::get_focus_mode() const {
+
+	return data.focus_mode;
+}
+bool Control::has_focus() const {
+
+	return (data.window && data.window->window->key_focus==this);
+}
+
+void Control::grab_focus() {
+
+	ERR_FAIL_COND(!is_inside_scene());
+	ERR_FAIL_COND(!data.window);
+	
+	if (data.focus_mode==FOCUS_NONE)
+		return;
+	
+	//no need for change
+	if (data.window->window->key_focus && data.window->window->key_focus==this)
+		return;
+		
+	get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_window_remove_focus");	
+	data.window->window->key_focus=this;
+	notification(NOTIFICATION_FOCUS_ENTER);
+#ifdef DEBUG_ENABLED
+	if (GLOBAL_DEF("debug/print_clicked_control", false)) {
+		print_line(String(get_path())+" - focus");
+	};
+#endif
+	update();
+
+}	
+
+void Control::release_focus() {
+
+	ERR_FAIL_COND(!is_inside_scene());
+	ERR_FAIL_COND(!data.window);
+
+	if (!has_focus())
+		return;
+
+	get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,"windows","_window_remove_focus");
+	//data.window->window->key_focus=this;
+	//notification(NOTIFICATION_FOCUS_ENTER);
+	update();
+
+}
+
+bool Control::is_toplevel_control() const {
+
+	return is_inside_scene() && (!data.parent_canvas_item && !window && is_set_as_toplevel());
+}
+
+void Control::show_modal(bool p_exclusive) {
+	
+	ERR_FAIL_COND(!is_inside_scene());
+	ERR_FAIL_COND(!data.SI && data.window!=this);
+	ERR_FAIL_COND(!data.window);
+
+	if (is_visible())
+		hide();
+
+	ERR_FAIL_COND( data.MI );
+	show();
+	raise();
+
+	data.window->window->modal_stack.push_back(this);
+	data.MI = data.window->window->modal_stack.back();
+	data.modal_exclusive=p_exclusive;
+	if (data.window->window->key_focus)
+		data.modal_prev_focus_owner = data.window->window->key_focus->get_instance_ID();
+	else
+		data.modal_prev_focus_owner=0;
+	
+}
+
+void Control::_window_sort_subwindows() {
+
+	if (!window->subwindow_order_dirty)
+		return;
+
+	window->modal_stack.sort_custom<CComparator>();
+	window->subwindow_order_dirty=false;
+
+}
+
+void Control::_window_sort_modal_stack() {
+
+	window->modal_stack.sort_custom<CComparator>();
+}
+
+void Control::_modal_stack_remove() {
+
+
+	List<Control*>::Element *next=NULL; //transfer the focus stack to the next
+
+
+	if (data.window && data.MI) {
+
+		next = data.MI->next();
+
+
+		data.window->window->modal_stack.erase(data.MI);
+		data.MI=NULL;
+	}
+
+	if (data.modal_prev_focus_owner) {
+
+		if (!next) { //top of stack
+
+			Object *pfo = ObjectDB::get_instance(data.modal_prev_focus_owner);
+			Control *pfoc = pfo->cast_to<Control>();
+			if (!pfoc)
+				return;
+
+			if (!pfoc->is_inside_scene() || !pfoc->is_visible())
+				return;
+			pfoc->grab_focus();
+		} else {
+
+			next->get()->data.modal_prev_focus_owner=data.modal_prev_focus_owner;
+		}
+
+		data.modal_prev_focus_owner=0;
+	}
+}
+
+void Control::_propagate_theme_changed(Control *p_owner) {
+
+	for(int i=0;i<get_child_count();i++) {
+
+		Control *child = get_child(i)->cast_to<Control>();
+		if (child && child->data.theme.is_null()) //has no theme, propagate
+			child->_propagate_theme_changed(p_owner);
+	}
+
+	data.theme_owner=p_owner;
+	_notification(NOTIFICATION_THEME_CHANGED);
+	update();
+}
+
+void Control::set_theme(const Ref<Theme>& p_theme) {
+
+	data.theme=p_theme;
+	if (!p_theme.is_null()) {
+
+		_propagate_theme_changed(this);
+	} else {
+
+		Control *parent = get_parent()?get_parent()->cast_to<Control>():NULL;
+		if (parent && parent->data.theme_owner) {
+			_propagate_theme_changed(parent->data.theme_owner);
+		} else {
+
+			_propagate_theme_changed(NULL);
+		}
+
+	}
+
+
+}
+
+void Control::_window_accept_event() {
+
+	window->key_event_accepted=true;
+	if (is_inside_scene())
+		get_scene()->set_input_as_handled();
+
+}
+void Control::accept_event() {
+
+	if (is_inside_scene() && get_window())
+		get_window()->_window_accept_event();
+
+}
+
+Ref<Theme> Control::get_theme() const {
+
+	return data.theme;
+}
+
+void Control::set_tooltip(const String& p_tooltip) {
+
+	data.tooltip=p_tooltip;
+}
+String Control::get_tooltip(const Point2& p_pos) const {
+
+	return data.tooltip;
+}
+
+void Control::set_default_cursor_shape(CursorShape p_shape) {
+
+	data.default_cursor=p_shape;
+}
+
+Control::CursorShape Control::get_default_cursor_shape() const {
+
+	return data.default_cursor;
+}
+Control::CursorShape Control::get_cursor_shape(const Point2& p_pos) const {
+
+	return data.default_cursor;
+}
+
+Matrix32 Control::get_transform() const {
+
+	Matrix32 xf;
+	xf.set_origin(get_pos());
+	return xf;
+}
+
+String Control::_get_tooltip() const {
+
+	return data.tooltip;
+}
+
+void Control::set_focus_neighbour(Margin p_margin, const NodePath &p_neighbour) {
+
+	ERR_FAIL_INDEX(p_margin,4);
+	data.focus_neighbour[p_margin]=p_neighbour;
+}
+
+NodePath Control::get_focus_neighbour(Margin p_margin) const {
+
+	ERR_FAIL_INDEX_V(p_margin,4,NodePath());
+	return data.focus_neighbour[p_margin];
+}
+
+#define MAX_NEIGHBOUR_SEARCH_COUNT 512
+
+Control *Control::_get_focus_neighbour(Margin p_margin,int p_count) {
+
+	if (p_count >= MAX_NEIGHBOUR_SEARCH_COUNT)
+		return NULL;
+	if (!data.focus_neighbour[p_margin].is_empty()) {
+
+		Control *c=NULL;
+		Node * n = get_node(data.focus_neighbour[p_margin]);
+		if (n) {
+			c=n->cast_to<Control>();
+
+			if (!c) {
+
+				ERR_EXPLAIN("Next focus node is not a control: "+n->get_name());
+				ERR_FAIL_V(NULL);
+			}
+		} else {
+			return NULL;
+		}
+		bool valid=true;
+		if (c->is_hidden())
+			valid=false;
+		if (c->get_focus_mode()==FOCUS_NONE)
+			valid=false;
+		if (valid)
+			return c;
+
+		c=c->_get_focus_neighbour(p_margin,p_count+1);
+		return c;
+	}
+
+
+	float dist=1e7;
+	Control * result=NULL;
+
+	Point2 points[4];
+
+	Matrix32 xform = get_global_transform();
+	Rect2 rect = get_item_rect();
+
+	points[0]=xform.xform(rect.pos);
+	points[1]=xform.xform(rect.pos + Point2(rect.size.x, 0));
+	points[2]=xform.xform(rect.pos + rect.size);
+	points[3]=xform.xform(rect.pos + Point2(0, rect.size.y));
+
+	const Vector2 dir[4]={
+		Vector2(-1,0),
+		Vector2(0,-1),
+		Vector2(1,0),
+		Vector2(0,1)
+	};
+
+	Vector2 vdir=dir[p_margin];
+
+	float maxd=-1e7;
+
+	for(int i=0;i<4;i++) {
+
+		float d = vdir.dot(points[i]);
+		if (d>maxd)
+			maxd=d;
+	}
+
+	Node *base=this;
+
+	while (base) {
+
+		Control *c = base->cast_to<Control>();
+		if (c) {
+			if (c->data.SI)
+				break;
+			if (c==data.window)
+				break;
+		}
+		base=base->get_parent();
+	}
+
+	if (!base)
+		return NULL;
+
+	_window_find_focus_neighbour(vdir,base,points,maxd,dist,&result);
+
+	return result;
+
+}
+
+void Control::_window_find_focus_neighbour(const Vector2& p_dir, Node *p_at,const Point2* p_points,float p_min ,float &r_closest_dist,Control **r_closest) {
+
+	if (p_at->cast_to<Viewport>())
+		return; //bye
+
+	Control *c = p_at->cast_to<Control>();
+
+	if (c && c !=this && c->get_focus_mode()==FOCUS_ALL && c->is_visible()) {
+
+		Point2 points[4];
+
+		Matrix32 xform = c->get_global_transform();
+		Rect2 rect = c->get_item_rect();
+
+		points[0]=xform.xform(rect.pos);
+		points[1]=xform.xform(rect.pos + Point2(rect.size.x, 0));
+		points[2]=xform.xform(rect.pos + rect.size);
+		points[3]=xform.xform(rect.pos + Point2(0, rect.size.y));
+
+
+		float min=1e7;
+
+		for(int i=0;i<4;i++) {
+
+			float d = p_dir.dot(points[i]);
+			if (d < min)
+				min =d;
+		}
+
+
+		if (min>(p_min-CMP_EPSILON)) {
+
+			for(int i=0;i<4;i++) {
+
+				Vector2 la=p_points[i];
+				Vector2 lb=p_points[(i+1)%4];
+
+				for(int j=0;j<4;j++) {
+
+					Vector2 fa=points[j];
+					Vector2 fb=points[(j+1)%4];
+
+					Vector2 pa,pb;
+					float d=Geometry::get_closest_points_between_segments(la,lb,fa,fb,pa,pb);
+					//float d = Geometry::get_closest_distance_between_segments(Vector3(la.x,la.y,0),Vector3(lb.x,lb.y,0),Vector3(fa.x,fa.y,0),Vector3(fb.x,fb.y,0));
+					if (d<r_closest_dist) {
+						r_closest_dist=d;
+						*r_closest=c;
+					}
+				}
+			}
+		}
+
+	}
+
+	for(int i=0;i<p_at->get_child_count();i++) {
+
+		Node *child=p_at->get_child(i);
+		Control *childc = child->cast_to<Control>();
+		if (childc && childc->data.SI)
+			continue; //subwindow, ignore
+		_window_find_focus_neighbour(p_dir,p_at->get_child(i),p_points,p_min,r_closest_dist,r_closest);
+	}
+}
+
+void Control::set_h_size_flags(int p_flags) {
+
+	if (data.h_size_flags==p_flags)
+		return;
+	data.h_size_flags=p_flags;
+	emit_signal(SceneStringNames::get_singleton()->size_flags_changed);
+}
+
+int Control::get_h_size_flags() const{
+	return data.h_size_flags;
+}
+void Control::set_v_size_flags(int p_flags) {
+
+	if (data.v_size_flags==p_flags)
+		return;
+	data.v_size_flags=p_flags;
+	emit_signal(SceneStringNames::get_singleton()->size_flags_changed);
+}
+
+
+void Control::set_stretch_ratio(float p_ratio) {
+
+	if (data.expand==p_ratio)
+		return;
+
+	data.expand=p_ratio;
+	emit_signal(SceneStringNames::get_singleton()->size_flags_changed);
+}
+
+float Control::get_stretch_ratio() const {
+
+	return data.expand;
+}
+
+
+void Control::grab_click_focus() {
+
+	ERR_FAIL_COND(!is_inside_scene());
+
+	if (data.window && data.window->window->mouse_focus) {
+
+		Window *w=data.window->window;
+		if (w->mouse_focus==this)
+			return;
+		InputEvent ie;
+		ie.type=InputEvent::MOUSE_BUTTON;
+		InputEventMouseButton &mb=ie.mouse_button;
+
+		//send unclic
+
+		Point2 click =w->mouse_focus->get_global_transform().affine_inverse().xform(w->last_mouse_pos);
+		mb.x=click.x;
+		mb.y=click.y;
+		mb.button_index=w->mouse_focus_button;
+		mb.pressed=false;
+		w->mouse_focus->call_deferred("_input_event",ie);
+
+
+		w->mouse_focus=this;
+		w->focus_inv_xform=w->mouse_focus->get_global_transform().affine_inverse();
+		click =w->mouse_focus->get_global_transform().affine_inverse().xform(w->last_mouse_pos);
+		mb.x=click.x;
+		mb.y=click.y;
+		mb.button_index=w->mouse_focus_button;
+		mb.pressed=true;
+		w->mouse_focus->call_deferred("_input_event",ie);
+
+	}
+}
+
+void Control::minimum_size_changed() {
+
+	if (!is_inside_scene())
+		return;
+
+	if (data.pending_min_size_update)
+		return;
+
+
+	data.pending_min_size_update=true;
+	MessageQueue::get_singleton()->push_call(this,"_update_minimum_size");
+
+	if (!is_toplevel_control()) {
+		Control *pc = get_parent_control();
+		if (pc)
+			pc->minimum_size_changed();
+	}
+}
+
+int Control::get_v_size_flags() const{
+	return data.v_size_flags;
+}
+
+void Control::set_ignore_mouse(bool p_ignore) {
+
+	data.ignore_mouse=p_ignore;
+}
+
+bool Control::is_ignoring_mouse() const {
+
+	return data.ignore_mouse;
+}
+
+void Control::set_stop_mouse(bool p_stop) {
+
+	data.stop_mouse=p_stop;
+}
+
+bool Control::is_stopping_mouse() const {
+
+	return data.stop_mouse;
+}
+
+Control *Control::get_focus_owner() const {
+
+	ERR_FAIL_COND_V(!is_inside_scene(),NULL);
+	ERR_FAIL_COND_V(!window,NULL);
+	return window->key_focus;
+}
+
+void Control::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("_window_input_event"),&Control::_window_input_event);
+	ObjectTypeDB::bind_method(_MD("_gui_input"),&Control::_gui_input);
+	ObjectTypeDB::bind_method(_MD("_input_text"),&Control::_input_text);
+//	ObjectTypeDB::bind_method(_MD("_window_resize_event"),&Control::_window_resize_event);
+	ObjectTypeDB::bind_method(_MD("_window_remove_focus"),&Control::_window_remove_focus);
+	ObjectTypeDB::bind_method(_MD("_cancel_input_ID"),&Control::_window_cancel_input_ID);
+	ObjectTypeDB::bind_method(_MD("_cancel_tooltip"),&Control::_window_cancel_tooltip);
+	ObjectTypeDB::bind_method(_MD("_window_show_tooltip"),&Control::_window_show_tooltip);
+	ObjectTypeDB::bind_method(_MD("_size_changed"),&Control::_size_changed);
+	ObjectTypeDB::bind_method(_MD("_update_minimum_size"),&Control::_update_minimum_size);
+
+	ObjectTypeDB::bind_method(_MD("accept_event"),&Control::accept_event);
+	ObjectTypeDB::bind_method(_MD("get_minimum_size"),&Control::get_minimum_size);
+	ObjectTypeDB::bind_method(_MD("get_combined_minimum_size"),&Control::get_combined_minimum_size);
+	ObjectTypeDB::bind_method(_MD("is_window"),&Control::is_window);
+	ObjectTypeDB::bind_method(_MD("get_window"),&Control::get_window);
+	ObjectTypeDB::bind_method(_MD("set_anchor","margin","anchor_mode"),&Control::set_anchor);
+	ObjectTypeDB::bind_method(_MD("get_anchor","margin"),&Control::get_anchor);
+	ObjectTypeDB::bind_method(_MD("set_margin","margin","offset"),&Control::set_margin);
+	ObjectTypeDB::bind_method(_MD("set_anchor_and_margin","margin","anchor_mode","offset"),&Control::set_anchor_and_margin);
+	ObjectTypeDB::bind_method(_MD("set_begin","pos"),&Control::set_begin);
+	ObjectTypeDB::bind_method(_MD("set_end","pos"),&Control::set_end);
+	ObjectTypeDB::bind_method(_MD("set_pos","pos"),&Control::set_pos);
+	ObjectTypeDB::bind_method(_MD("set_size","size"),&Control::set_size);
+	ObjectTypeDB::bind_method(_MD("set_custom_minimum_size","size"),&Control::set_custom_minimum_size);
+	ObjectTypeDB::bind_method(_MD("set_global_pos","pos"),&Control::set_global_pos);
+	ObjectTypeDB::bind_method(_MD("get_margin","margin"),&Control::get_margin);
+	ObjectTypeDB::bind_method(_MD("get_begin"),&Control::get_begin);
+	ObjectTypeDB::bind_method(_MD("get_end"),&Control::get_end);
+	ObjectTypeDB::bind_method(_MD("get_pos"),&Control::get_pos);
+	ObjectTypeDB::bind_method(_MD("get_size"),&Control::get_size);
+	ObjectTypeDB::bind_method(_MD("get_custom_minimum_size"),&Control::get_custom_minimum_size);
+	ObjectTypeDB::bind_method(_MD("get_parent_area_size"),&Control::get_size);
+	ObjectTypeDB::bind_method(_MD("get_global_pos"),&Control::get_global_pos);
+	ObjectTypeDB::bind_method(_MD("get_rect"),&Control::get_rect);
+	ObjectTypeDB::bind_method(_MD("get_global_rect"),&Control::get_global_rect);
+	ObjectTypeDB::bind_method(_MD("set_area_as_parent_rect","margin"),&Control::set_area_as_parent_rect,DEFVAL(0));
+	ObjectTypeDB::bind_method(_MD("show_modal","exclusive"),&Control::show_modal,DEFVAL(false));
+	ObjectTypeDB::bind_method(_MD("set_focus_mode","mode"),&Control::set_focus_mode);
+	ObjectTypeDB::bind_method(_MD("has_focus"),&Control::has_focus);
+	ObjectTypeDB::bind_method(_MD("grab_focus"),&Control::grab_focus);
+	ObjectTypeDB::bind_method(_MD("release_focus"),&Control::release_focus);
+	ObjectTypeDB::bind_method(_MD("get_focus_owner:Control"),&Control::get_focus_owner);
+
+	ObjectTypeDB::bind_method(_MD("set_h_size_flags","flags"),&Control::set_h_size_flags);
+	ObjectTypeDB::bind_method(_MD("get_h_size_flags"),&Control::get_h_size_flags);
+
+	ObjectTypeDB::bind_method(_MD("set_stretch_ratio","ratio"),&Control::set_stretch_ratio);
+	ObjectTypeDB::bind_method(_MD("get_stretch_ratio"),&Control::get_stretch_ratio);
+
+	ObjectTypeDB::bind_method(_MD("set_v_size_flags","flags"),&Control::set_v_size_flags);
+	ObjectTypeDB::bind_method(_MD("get_v_size_flags"),&Control::get_v_size_flags);
+
+	ObjectTypeDB::bind_method(_MD("set_theme","theme:Theme"),&Control::set_theme);
+	ObjectTypeDB::bind_method(_MD("get_theme:Theme"),&Control::get_theme);
+
+	ObjectTypeDB::bind_method(_MD("add_icon_override","name","texture:Texture"),&Control::add_icon_override);
+	ObjectTypeDB::bind_method(_MD("add_style_override","name","stylebox:StyleBox"),&Control::add_style_override);
+	ObjectTypeDB::bind_method(_MD("add_font_override","name","font:Font"),&Control::add_font_override);
+	ObjectTypeDB::bind_method(_MD("add_color_override","name","color"),&Control::add_color_override);
+	ObjectTypeDB::bind_method(_MD("add_constant_override","name","constant"),&Control::add_constant_override);
+
+	ObjectTypeDB::bind_method(_MD("get_icon:Texture","name","type"),&Control::get_icon,DEFVAL(""));
+	ObjectTypeDB::bind_method(_MD("get_stylebox:StyleBox","name","type"),&Control::get_stylebox,DEFVAL(""));
+	ObjectTypeDB::bind_method(_MD("get_font:Font","name","type"),&Control::get_font,DEFVAL(""));
+	ObjectTypeDB::bind_method(_MD("get_color","name","type"),&Control::get_color,DEFVAL(""));
+	ObjectTypeDB::bind_method(_MD("get_constant","name","type"),&Control::get_constant,DEFVAL(""));
+
+
+	ObjectTypeDB::bind_method(_MD("get_parent_control:Control"),&Control::get_parent_control);	
+
+	ObjectTypeDB::bind_method(_MD("set_tooltip","tooltip"),&Control::set_tooltip);
+	ObjectTypeDB::bind_method(_MD("get_tooltip","atpos"),&Control::get_tooltip,DEFVAL(Point2()));
+	ObjectTypeDB::bind_method(_MD("_get_tooltip"),&Control::_get_tooltip);
+
+	ObjectTypeDB::bind_method(_MD("set_default_cursor_shape","shape"),&Control::set_default_cursor_shape);
+	ObjectTypeDB::bind_method(_MD("get_default_cursor_shape"),&Control::get_default_cursor_shape);
+	ObjectTypeDB::bind_method(_MD("get_cursor_shape","pos"),&Control::get_cursor_shape,DEFVAL(Point2()));
+
+	ObjectTypeDB::bind_method(_MD("set_focus_neighbour","margin","neighbour"),&Control::set_focus_neighbour);
+	ObjectTypeDB::bind_method(_MD("get_focus_neighbour","margin"),&Control::get_focus_neighbour);
+
+	ObjectTypeDB::bind_method(_MD("set_ignore_mouse","ignore"),&Control::set_ignore_mouse);
+	ObjectTypeDB::bind_method(_MD("is_ignoring_mouse"),&Control::is_ignoring_mouse);
+
+	ObjectTypeDB::bind_method(_MD("force_drag","data","preview"),&Control::force_drag);
+
+	ObjectTypeDB::bind_method(_MD("set_stop_mouse","stop"),&Control::set_stop_mouse);
+	ObjectTypeDB::bind_method(_MD("is_stopping_mouse"),&Control::is_stopping_mouse);
+
+	ObjectTypeDB::bind_method(_MD("grab_click_focus"),&Control::grab_click_focus);
+
+	ObjectTypeDB::bind_method(_MD("set_drag_preview","control:Control"),&Control::set_drag_preview);
+
+	BIND_VMETHOD(MethodInfo("_input_event",PropertyInfo(Variant::INPUT_EVENT,"event")));
+	BIND_VMETHOD(MethodInfo(Variant::VECTOR2,"get_minimum_size"));
+	BIND_VMETHOD(MethodInfo(Variant::OBJECT,"get_drag_data",PropertyInfo(Variant::VECTOR2,"pos")));
+	BIND_VMETHOD(MethodInfo(Variant::BOOL,"can_drop_data",PropertyInfo(Variant::VECTOR2,"pos"),PropertyInfo(Variant::NIL,"data")));
+	BIND_VMETHOD(MethodInfo("drop_data",PropertyInfo(Variant::VECTOR2,"pos"),PropertyInfo(Variant::NIL,"data")));
+
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"anchor/left", PROPERTY_HINT_ENUM, "Begin,End,Ratio"), _SCS("set_anchor"),_SCS("get_anchor"), MARGIN_LEFT );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"anchor/top", PROPERTY_HINT_ENUM, "Begin,End,Ratio"), _SCS("set_anchor"),_SCS("get_anchor"), MARGIN_TOP );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"anchor/right", PROPERTY_HINT_ENUM, "Begin,End,Ratio"), _SCS("set_anchor"),_SCS("get_anchor"), MARGIN_RIGHT );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"anchor/bottom", PROPERTY_HINT_ENUM, "Begin,End,Ratio"), _SCS("set_anchor"),_SCS("get_anchor"), MARGIN_BOTTOM );
+
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"margin/left", PROPERTY_HINT_RANGE, "-4096,4096"), _SCS("set_margin"),_SCS("get_margin"), MARGIN_LEFT );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"margin/top", PROPERTY_HINT_RANGE, "-4096,4096"), _SCS("set_margin"),_SCS("get_margin"), MARGIN_TOP );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"margin/right", PROPERTY_HINT_RANGE, "-4096,4096"), _SCS("set_margin"),_SCS("get_margin"), MARGIN_RIGHT );
+	ADD_PROPERTYINZ( PropertyInfo(Variant::INT,"margin/bottom", PROPERTY_HINT_RANGE, "-4096,4096"), _SCS("set_margin"),_SCS("get_margin"), MARGIN_BOTTOM );
+
+	ADD_PROPERTYNZ( PropertyInfo(Variant::VECTOR2,"rect/pos", PROPERTY_HINT_NONE, "",PROPERTY_USAGE_EDITOR), _SCS("set_pos"),_SCS("get_pos") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::VECTOR2,"rect/size", PROPERTY_HINT_NONE, "",PROPERTY_USAGE_EDITOR), _SCS("set_size"),_SCS("get_size") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::VECTOR2,"rect/min_size"), _SCS("set_custom_minimum_size"),_SCS("get_custom_minimum_size") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::STRING,"hint/tooltip", PROPERTY_HINT_MULTILINE_TEXT), _SCS("set_tooltip"),_SCS("_get_tooltip") );
+	ADD_PROPERTYI( PropertyInfo(Variant::NODE_PATH,"focus_neighbour/left" ), _SCS("set_focus_neighbour"),_SCS("get_focus_neighbour"),MARGIN_LEFT );
+	ADD_PROPERTYI( PropertyInfo(Variant::NODE_PATH,"focus_neighbour/top" ), _SCS("set_focus_neighbour"),_SCS("get_focus_neighbour"),MARGIN_TOP );
+	ADD_PROPERTYI( PropertyInfo(Variant::NODE_PATH,"focus_neighbour/right" ), _SCS("set_focus_neighbour"),_SCS("get_focus_neighbour"),MARGIN_RIGHT );
+	ADD_PROPERTYI( PropertyInfo(Variant::NODE_PATH,"focus_neighbour/bottom" ), _SCS("set_focus_neighbour"),_SCS("get_focus_neighbour"),MARGIN_BOTTOM );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"focus/ignore_mouse"), _SCS("set_ignore_mouse"),_SCS("is_ignoring_mouse") );
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"focus/stop_mouse"), _SCS("set_stop_mouse"),_SCS("is_stopping_mouse") );
+
+	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"size_flags/horizontal", PROPERTY_HINT_FLAGS, "Expand,Fill"), _SCS("set_h_size_flags"),_SCS("get_h_size_flags") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"size_flags/vertical", PROPERTY_HINT_FLAGS, "Expand,Fill"), _SCS("set_v_size_flags"),_SCS("get_v_size_flags") );
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"size_flags/stretch_ratio", PROPERTY_HINT_RANGE, "1,128,0.01"), _SCS("set_stretch_ratio"),_SCS("get_stretch_ratio") );
+
+	BIND_CONSTANT( ANCHOR_BEGIN );
+	BIND_CONSTANT( ANCHOR_END );
+	BIND_CONSTANT( ANCHOR_RATIO );	
+	BIND_CONSTANT( FOCUS_NONE );
+	BIND_CONSTANT( FOCUS_CLICK );
+	BIND_CONSTANT( FOCUS_ALL );
+
+
+	BIND_CONSTANT( NOTIFICATION_RESIZED );
+	BIND_CONSTANT( NOTIFICATION_MOUSE_ENTER );
+	BIND_CONSTANT( NOTIFICATION_MOUSE_EXIT );
+	BIND_CONSTANT( NOTIFICATION_FOCUS_ENTER );
+	BIND_CONSTANT( NOTIFICATION_FOCUS_EXIT );
+	BIND_CONSTANT( NOTIFICATION_THEME_CHANGED );
+	BIND_CONSTANT( NOTIFICATION_MODAL_CLOSE );
+
+	BIND_CONSTANT( CURSOR_ARROW );
+	BIND_CONSTANT( CURSOR_IBEAM );
+	BIND_CONSTANT( CURSOR_POINTING_HAND );
+	BIND_CONSTANT( CURSOR_CROSS );
+	BIND_CONSTANT( CURSOR_WAIT );
+	BIND_CONSTANT( CURSOR_BUSY );
+	BIND_CONSTANT( CURSOR_DRAG );
+	BIND_CONSTANT( CURSOR_CAN_DROP );
+	BIND_CONSTANT( CURSOR_FORBIDDEN );
+	BIND_CONSTANT( CURSOR_VSIZE );
+	BIND_CONSTANT( CURSOR_HSIZE );
+	BIND_CONSTANT( CURSOR_BDIAGSIZE );
+	BIND_CONSTANT( CURSOR_FDIAGSIZE );
+	BIND_CONSTANT( CURSOR_MOVE );
+	BIND_CONSTANT( CURSOR_VSPLIT );
+	BIND_CONSTANT( CURSOR_HSPLIT );
+	BIND_CONSTANT( CURSOR_HELP );
+
+	BIND_CONSTANT( SIZE_EXPAND );
+	BIND_CONSTANT( SIZE_FILL );
+	BIND_CONSTANT( SIZE_EXPAND_FILL );
+
+	ADD_SIGNAL( MethodInfo("resized") );
+	ADD_SIGNAL( MethodInfo("input_event") );
+	ADD_SIGNAL( MethodInfo("mouse_enter") );
+	ADD_SIGNAL( MethodInfo("mouse_exit") );
+	ADD_SIGNAL( MethodInfo("focus_enter") );
+	ADD_SIGNAL( MethodInfo("focus_exit") );
+	ADD_SIGNAL( MethodInfo("size_flags_changed") );
+	ADD_SIGNAL( MethodInfo("minimum_size_changed") );
+
+	
+}
+Control::Control() {
+	
+	data.parent=NULL;
+	data.window=NULL;
+	data.viewport=NULL;
+	data.ignore_mouse=false;
+	data.stop_mouse=true;
+	window=NULL;
+
+	data.SI=NULL;
+	data.MI=NULL;
+	data.modal=false;
+	data.theme_owner=NULL;
+	data.modal_exclusive=false;
+	data.default_cursor = CURSOR_ARROW;
+	data.h_size_flags=SIZE_FILL;
+	data.v_size_flags=SIZE_FILL;
+	data.expand=1;
+	data.pending_min_size_update=false;
+
+
+	for (int i=0;i<4;i++) {
+		data.anchor[i]=ANCHOR_BEGIN;
+		data.margin[i]=0;
+	}
+	data.focus_mode=FOCUS_NONE;
+	data.modal_prev_focus_owner=0;
+
+
+
+
+			
+}
+
+
+Control::~Control()
+{
+}
+
+