Merge branch 'master' of https://github.com/okamstudio/godot

9 files changed, 1297 insertions, 4 deletions

diff --git a/scene/2d/area_2d.cpp b/scene/2d/area_2d.cpp
index 827256c2fa..e30333377f 100644
--- a/scene/2d/area_2d.cpp
+++ b/scene/2d/area_2d.cpp
@@ -535,6 +535,39 @@ uint32_t Area2D::get_layer_mask() const {
 	return layer_mask;
 }
 
+void Area2D::set_collision_mask_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_collision_mask();
+	if (p_value)
+		mask|=1<<p_bit;
+	else
+		mask&=~(1<<p_bit);
+	set_collision_mask(mask);
+
+}
+
+bool Area2D::get_collision_mask_bit(int p_bit) const{
+
+	return get_collision_mask()&(1<<p_bit);
+}
+
+
+void Area2D::set_layer_mask_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_layer_mask();
+	if (p_value)
+		mask|=1<<p_bit;
+	else
+		mask&=~(1<<p_bit);
+	set_layer_mask(mask);
+
+}
+
+bool Area2D::get_layer_mask_bit(int p_bit) const{
+
+	return get_layer_mask()&(1<<p_bit);
+}
+
 
 void Area2D::_bind_methods() {
 
@@ -571,6 +604,12 @@ void Area2D::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_layer_mask","layer_mask"),&Area2D::set_layer_mask);
 	ObjectTypeDB::bind_method(_MD("get_layer_mask"),&Area2D::get_layer_mask);
 
+	ObjectTypeDB::bind_method(_MD("set_collision_mask_bit","bit","value"),&Area2D::set_collision_mask_bit);
+	ObjectTypeDB::bind_method(_MD("get_collision_mask_bit","bit"),&Area2D::get_collision_mask_bit);
+
+	ObjectTypeDB::bind_method(_MD("set_layer_mask_bit","bit","value"),&Area2D::set_layer_mask_bit);
+	ObjectTypeDB::bind_method(_MD("get_layer_mask_bit","bit"),&Area2D::get_layer_mask_bit);
+
 	ObjectTypeDB::bind_method(_MD("set_enable_monitoring","enable"),&Area2D::set_enable_monitoring);
 	ObjectTypeDB::bind_method(_MD("is_monitoring_enabled"),&Area2D::is_monitoring_enabled);
 
diff --git a/scene/2d/area_2d.h b/scene/2d/area_2d.h
index 0c064f54cd..72b507103a 100644
--- a/scene/2d/area_2d.h
+++ b/scene/2d/area_2d.h
@@ -159,6 +159,12 @@ public:
 	void set_layer_mask(uint32_t p_mask);
 	uint32_t get_layer_mask() const;
 
+	void set_collision_mask_bit(int p_bit, bool p_value);
+	bool get_collision_mask_bit(int p_bit) const;
+
+	void set_layer_mask_bit(int p_bit, bool p_value);
+	bool get_layer_mask_bit(int p_bit) const;
+
 	Array get_overlapping_bodies() const; //function for script
 	Array get_overlapping_areas() const; //function for script
 
diff --git a/scene/2d/physics_body_2d.cpp b/scene/2d/physics_body_2d.cpp
index 3d2917d843..c30921eb69 100644
--- a/scene/2d/physics_body_2d.cpp
+++ b/scene/2d/physics_body_2d.cpp
@@ -85,6 +85,14 @@ void PhysicsBody2D::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("get_layer_mask"),&PhysicsBody2D::get_layer_mask);
 	ObjectTypeDB::bind_method(_MD("set_collision_mask","mask"),&PhysicsBody2D::set_collision_mask);
 	ObjectTypeDB::bind_method(_MD("get_collision_mask"),&PhysicsBody2D::get_collision_mask);
+
+
+	ObjectTypeDB::bind_method(_MD("set_collision_mask_bit","bit","value"),&PhysicsBody2D::set_collision_mask_bit);
+	ObjectTypeDB::bind_method(_MD("get_collision_mask_bit","bit"),&PhysicsBody2D::get_collision_mask_bit);
+
+	ObjectTypeDB::bind_method(_MD("set_layer_mask_bit","bit","value"),&PhysicsBody2D::set_layer_mask_bit);
+	ObjectTypeDB::bind_method(_MD("get_layer_mask_bit","bit"),&PhysicsBody2D::get_layer_mask_bit);
+
 	ObjectTypeDB::bind_method(_MD("_set_layers","mask"),&PhysicsBody2D::_set_layers);
 	ObjectTypeDB::bind_method(_MD("_get_layers"),&PhysicsBody2D::_get_layers);
 	ObjectTypeDB::bind_method(_MD("set_one_way_collision_direction","dir"),&PhysicsBody2D::set_one_way_collision_direction);
@@ -122,6 +130,37 @@ uint32_t PhysicsBody2D::get_collision_mask() const {
 	return collision_mask;
 }
 
+void PhysicsBody2D::set_collision_mask_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_collision_mask();
+	if (p_value)
+		mask|=1<<p_bit;
+	else
+		mask&=~(1<<p_bit);
+	set_collision_mask(mask);
+
+}
+bool PhysicsBody2D::get_collision_mask_bit(int p_bit) const{
+
+	return get_collision_mask()&(1<<p_bit);
+}
+
+
+void PhysicsBody2D::set_layer_mask_bit(int p_bit, bool p_value) {
+
+	uint32_t mask = get_layer_mask();
+	if (p_value)
+		mask|=1<<p_bit;
+	else
+		mask&=~(1<<p_bit);
+	set_layer_mask(mask);
+
+}
+
+bool PhysicsBody2D::get_layer_mask_bit(int p_bit) const{
+
+	return get_layer_mask()&(1<<p_bit);
+}
 
 PhysicsBody2D::PhysicsBody2D(Physics2DServer::BodyMode p_mode) : CollisionObject2D( Physics2DServer::get_singleton()->body_create(p_mode), false) {
 
diff --git a/scene/2d/physics_body_2d.h b/scene/2d/physics_body_2d.h
index 03f95959b6..b70fdd59cf 100644
--- a/scene/2d/physics_body_2d.h
+++ b/scene/2d/physics_body_2d.h
@@ -61,6 +61,13 @@ public:
 	void set_collision_mask(uint32_t p_mask);
 	uint32_t get_collision_mask() const;
 
+
+	void set_collision_mask_bit(int p_bit, bool p_value);
+	bool get_collision_mask_bit(int p_bit) const;
+
+	void set_layer_mask_bit(int p_bit, bool p_value);
+	bool get_layer_mask_bit(int p_bit) const;
+
 	void add_collision_exception_with(Node* p_node); //must be physicsbody
 	void remove_collision_exception_with(Node* p_node);
 
diff --git a/scene/3d/spatial.cpp b/scene/3d/spatial.cpp
index 9c69520a85..c672d0e94f 100644
--- a/scene/3d/spatial.cpp
+++ b/scene/3d/spatial.cpp
@@ -626,10 +626,11 @@ void Spatial::rotate_z(float p_radians){
 void Spatial::translate(const Vector3& p_offset){
 
 	Transform t =get_transform();
-	t.origin+=p_offset;
+	t.translate(p_offset);
 	set_transform(t);
 
 }
+
 void Spatial::scale(const Vector3& p_ratio){
 
 	Transform t =get_transform();
diff --git a/scene/gui/item_list.cpp b/scene/gui/item_list.cpp
new file mode 100644
index 0000000000..2fd4d810de
--- /dev/null
+++ b/scene/gui/item_list.cpp
@@ -0,0 +1,1048 @@
+#include "item_list.h"
+#include "os/os.h"
+#include "globals.h"
+
+
+void ItemList::add_item(const String& p_item,const Ref<Texture>& p_texture,bool p_selectable) {
+
+	Item item;
+	item.icon=p_texture;
+	item.text=p_item;
+	item.selectable=p_selectable;
+	item.selected=false;
+	item.disabled=false;
+	items.push_back(item);
+
+	update();
+	shape_changed=true;
+
+}
+
+void ItemList::add_icon_item(const Ref<Texture>& p_item,bool p_selectable){
+
+	Item item;
+	item.icon=p_item;
+	//item.text=p_item;
+	item.selectable=p_selectable;
+	item.selected=false;
+	item.disabled=false;
+	items.push_back(item);
+
+	update();
+	shape_changed=true;
+
+}
+
+void ItemList::set_item_text(int p_idx,const String& p_text){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].text=p_text;
+	update();
+	shape_changed=true;
+
+}
+
+String ItemList::get_item_text(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),String());
+	return items[p_idx].text;
+
+}
+
+void ItemList::set_item_tooltip(int p_idx,const String& p_tooltip){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].tooltip=p_tooltip;
+	update();
+	shape_changed=true;
+
+}
+
+String ItemList::get_item_tooltip(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),String());
+	return items[p_idx].tooltip;
+
+}
+
+void ItemList::set_item_icon(int p_idx,const Ref<Texture>& p_icon){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].icon=p_icon;
+	update();
+	shape_changed=true;
+
+
+}
+Ref<Texture> ItemList::get_item_icon(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),Ref<Texture>());
+
+	return items[p_idx].icon;
+
+}
+
+
+void ItemList::set_item_tag_icon(int p_idx,const Ref<Texture>& p_tag_icon){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].tag_icon=p_tag_icon;
+	update();
+	shape_changed=true;
+
+
+}
+Ref<Texture> ItemList::get_item_tag_icon(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),Ref<Texture>());
+
+	return items[p_idx].tag_icon;
+
+}
+
+void ItemList::set_item_selectable(int p_idx,bool p_selectable){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].selectable=p_selectable;
+
+
+}
+
+
+bool ItemList::is_item_selectable(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),false);
+	return items[p_idx].selectable;
+}
+
+void ItemList::set_item_disabled(int p_idx,bool p_disabled){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].disabled=p_disabled;
+
+
+}
+
+
+bool ItemList::is_item_disabled(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),false);
+	return items[p_idx].disabled;
+}
+
+
+void ItemList::set_item_metadata(int p_idx,const Variant& p_metadata){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items[p_idx].metadata=p_metadata;
+	update();
+	shape_changed=true;
+
+}
+
+Variant ItemList::get_item_metadata(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),Variant());
+	return items[p_idx].metadata;
+
+}
+void ItemList::select(int p_idx,bool p_single){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	if (p_single || select_mode==SELECT_SINGLE) {
+
+		if (!items[p_idx].selectable) {
+			return;
+		}
+
+		for(int i=0;i<items.size();i++) {
+			items[i].selected=p_idx==i;
+		}
+
+		current=p_idx;
+	} else {
+
+		if (items[p_idx].selectable) {
+			items[p_idx].selected=true;
+		}
+	}
+	update();
+
+}
+void ItemList::unselect(int p_idx){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	if (select_mode!=SELECT_MULTI) {
+		items[p_idx].selected=false;
+		current=-1;
+	} else {
+		items[p_idx].selected=false;
+	}
+	update();
+
+}
+bool ItemList::is_selected(int p_idx) const{
+
+	ERR_FAIL_INDEX_V(p_idx,items.size(),false);
+
+	return items[p_idx].selected;
+
+}
+
+void ItemList::set_current(int p_current) {
+	ERR_FAIL_INDEX(p_current,items.size());
+
+	if (select_mode==SELECT_SINGLE)
+		select(p_current,true);
+	else {
+		current=p_current;
+		update();
+	}
+}
+
+int ItemList::get_current() const {
+
+	return current;
+}
+
+
+int ItemList::get_item_count() const{
+
+	return items.size();
+}
+void ItemList::remove_item(int p_idx){
+
+	ERR_FAIL_INDEX(p_idx,items.size());
+
+	items.remove(p_idx);
+	update();
+	shape_changed=true;
+
+}
+
+void ItemList::clear(){
+
+	items.clear();
+	current=-1;
+	update();
+
+}
+
+void ItemList::set_fixed_column_width(int p_size){
+
+	ERR_FAIL_COND(p_size<0);
+	fixed_column_width=p_size;
+	update();
+	shape_changed=true;
+
+}
+int ItemList::get_fixed_column_width() const{
+
+	return fixed_column_width;
+}
+
+void ItemList::set_max_text_lines(int p_lines){
+
+	ERR_FAIL_COND(p_lines<1);
+	max_text_lines=p_lines;
+	update();
+	shape_changed=true;
+
+}
+int ItemList::get_max_text_lines() const{
+
+	return max_text_lines;
+}
+
+void ItemList::set_max_columns(int p_amount){
+
+	ERR_FAIL_COND(p_amount<0);
+	max_columns=p_amount;
+	update();
+}
+int ItemList::get_max_columns() const{
+
+	return max_columns;
+}
+
+void ItemList::set_select_mode(SelectMode p_mode) {
+
+	select_mode=p_mode;
+	update();
+}
+
+ItemList::SelectMode ItemList::get_select_mode() const {
+
+	return select_mode;
+}
+
+void ItemList::set_icon_mode(IconMode p_mode){
+
+	icon_mode=p_mode;
+	update();
+	shape_changed=true;
+
+}
+ItemList::IconMode ItemList::get_icon_mode() const{
+
+	return icon_mode;
+}
+
+void ItemList::set_min_icon_size(const Size2& p_size) {
+
+	min_icon_size=p_size;
+	update();
+}
+
+Size2 ItemList::get_min_icon_size() const {
+
+	return min_icon_size;
+}
+
+
+
+void ItemList::_input_event(const InputEvent& p_event) {
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==BUTTON_LEFT && p_event.mouse_button.pressed) {
+
+		const InputEventMouseButton &mb = p_event.mouse_button;
+
+		search_string=""; //any mousepress cancels
+		Vector2 pos(mb.x,mb.y);
+		Ref<StyleBox> bg = get_stylebox("bg");
+		pos-=bg->get_offset();
+		pos.y+=scroll_bar->get_val();
+
+		int closest = -1;
+		int closest_dist=0x7FFFFFFF;
+
+		for(int i=0;i<items.size();i++) {
+
+			Rect2 rc = items[i].rect_cache;
+			if (i%current_columns==current_columns-1) {
+				rc.size.width=get_size().width; //not right but works
+			}
+
+			if (rc.has_point(pos)) {
+				closest=i;
+				break;
+			}
+
+			float dist = rc.distance_to(pos);
+			if (dist<closest_dist) {
+				closest=i;
+				closest_dist=dist;
+			}
+		}
+
+		if (closest!=-1) {
+
+			int i = closest;
+
+			if (select_mode==SELECT_MULTI && items[i].selected && mb.mod.command) {
+				unselect(i);
+				emit_signal("multi_selected",i,false);
+			} else if (select_mode==SELECT_MULTI && mb.mod.shift && current>=0 && current<items.size() && current!=i) {
+
+				int from = current;
+				int to = i;
+				if (i<current) {
+					SWAP(from,to);
+				}
+				for(int j=from;j<=to;j++) {
+					bool selected = !items[j].selected;
+					select(j,false);
+					if (selected)
+						emit_signal("multi_selected",i,true);
+				}
+			} else {
+				bool selected = !items[i].selected;
+				select(i,select_mode==SELECT_SINGLE || !mb.mod.command);
+				if (selected) {
+					if (select_mode==SELECT_SINGLE) {
+						emit_signal("item_selected",i);
+					} else
+						emit_signal("multi_selected",i,true);
+				}
+
+				if (/*select_mode==SELECT_SINGLE &&*/ mb.doubleclick) {
+
+					emit_signal("item_activated",i);
+
+				}
+
+
+			}
+
+
+			return;
+		}
+	}
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==BUTTON_WHEEL_UP && p_event.mouse_button.pressed) {
+
+		scroll_bar->set_val( scroll_bar->get_val()-scroll_bar->get_page()/8 );
+
+	}
+	if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==BUTTON_WHEEL_DOWN && p_event.mouse_button.pressed) {
+
+		scroll_bar->set_val( scroll_bar->get_val()+scroll_bar->get_page()/8 );
+
+	}
+
+	if (p_event.is_pressed() && items.size()>0) {
+		if (p_event.is_action("ui_up")) {
+
+			if (search_string!="") {
+
+				uint64_t now = OS::get_singleton()->get_ticks_msec();
+				uint64_t diff = now-search_time_msec;
+
+				if (diff<int(Globals::get_singleton()->get("gui/incr_search_max_interval_msec"))*2) {
+
+					for(int i=current-1;i>=0;i--) {
+
+						if (items[i].text.begins_with(search_string)) {
+
+							set_current(i);
+							ensure_current_is_visible();
+							if (select_mode==SELECT_SINGLE) {
+								emit_signal("item_selected",current);
+							}
+
+
+							break;
+						}
+					}
+					accept_event();
+					return;
+				}
+			}
+
+			if (current>=current_columns) {
+				set_current(current-current_columns);
+				ensure_current_is_visible();
+				if (select_mode==SELECT_SINGLE) {
+					emit_signal("item_selected",current);
+				}
+				accept_event();
+			}
+		} else if (p_event.is_action("ui_down")) {
+
+			if (search_string!="") {
+
+				uint64_t now = OS::get_singleton()->get_ticks_msec();
+				uint64_t diff = now-search_time_msec;
+
+				if (diff<int(Globals::get_singleton()->get("gui/incr_search_max_interval_msec"))*2) {
+
+					for(int i=current+1;i<items.size();i++) {
+
+						if (items[i].text.begins_with(search_string)) {
+
+							set_current(i);
+							ensure_current_is_visible();
+							if (select_mode==SELECT_SINGLE) {
+								emit_signal("item_selected",current);
+							}
+							break;
+						}
+					}
+					accept_event();
+					return;
+				}
+			}
+
+			if (current<items.size()-current_columns) {
+				set_current(current+current_columns);
+				ensure_current_is_visible();
+				if (select_mode==SELECT_SINGLE) {
+					emit_signal("item_selected",current);
+				}
+				accept_event();
+
+			}
+		} else if (p_event.is_action("ui_page_up")) {
+
+			search_string=""; //any mousepress cancels
+
+			for(int i=4;i>0;i--) {
+				if (current-current_columns*i >=0 ) {
+					set_current( current- current_columns*i);
+					ensure_current_is_visible();
+					if (select_mode==SELECT_SINGLE) {
+						emit_signal("item_selected",current);
+					}
+					accept_event();
+					break;
+				}
+			}
+		} else if (p_event.is_action("ui_page_down")) {
+
+			search_string=""; //any mousepress cancels
+
+			for(int i=4;i>0;i--) {
+				if (current+current_columns*i < items.size() ) {
+					set_current( current+ current_columns*i);
+					ensure_current_is_visible();
+					if (select_mode==SELECT_SINGLE) {
+						emit_signal("item_selected",current);
+					}
+					accept_event();
+
+					break;
+				}
+			}
+		} else if (p_event.is_action("ui_left")) {
+
+			search_string=""; //any mousepress cancels
+
+			if (current%current_columns!=0) {
+				set_current(current-1);
+				ensure_current_is_visible();
+				if (select_mode==SELECT_SINGLE) {
+					emit_signal("item_selected",current);
+				}
+				accept_event();
+
+			}
+		} else if (p_event.is_action("ui_right")) {
+
+			search_string=""; //any mousepress cancels
+
+			if (current%current_columns!=(current_columns-1)) {
+				set_current(current+1);
+				ensure_current_is_visible();
+				if (select_mode==SELECT_SINGLE) {
+					emit_signal("item_selected",current);
+				}
+				accept_event();
+
+			}
+		} else if (p_event.is_action("ui_cancel")) {
+			search_string="";
+		} else if (p_event.is_action("ui_select")) {
+
+
+			if (select_mode==SELECT_MULTI && current>=0 && current<items.size()) {
+				if (items[current].selectable && !items[current].selected) {
+					select(current,false);
+					emit_signal("multi_selected",current,true);
+				} else if (items[current].selected) {
+					unselect(current);
+					emit_signal("multi_selected",current,false);
+				}
+			}
+		} else if (p_event.is_action("ui_accept")) {
+			search_string=""; //any mousepress cance
+
+			if (current>=0 && current<items.size()) {
+				emit_signal("item_activated",current);
+			}
+		} else if (p_event.type==InputEvent::KEY) {
+
+			if (p_event.key.unicode) {
+
+				uint64_t now = OS::get_singleton()->get_ticks_msec();
+				uint64_t diff = now-search_time_msec;
+				uint64_t max_interval = uint64_t(GLOBAL_DEF("gui/incr_search_max_interval_msec",2000));
+				search_time_msec = now;
+
+				if (diff>max_interval) {
+					search_string="";
+				}
+
+				search_string+=String::chr(p_event.key.unicode);
+				for(int i=0;i<items.size();i++) {
+					if (items[i].text.begins_with(search_string)) {
+						set_current(i);
+						ensure_current_is_visible();
+						if (select_mode==SELECT_SINGLE) {
+							emit_signal("item_selected",current);
+						}
+						break;
+					}
+				}
+
+			}
+
+		}
+	}
+
+
+
+
+}
+
+void ItemList::ensure_current_is_visible() {
+
+	if (current>=0 && current <=items.size()) {
+
+		Rect2 r = items[current].rect_cache;
+		int from = scroll_bar->get_val();
+		int to = from + scroll_bar->get_page();
+
+		if (r.pos.y < from) {
+			scroll_bar->set_val(r.pos.y);
+		} else if (r.pos.y+r.size.y > to) {
+			scroll_bar->set_val(r.pos.y+r.size.y - (to-from));
+		}
+	}
+}
+
+void ItemList::_notification(int p_what) {
+
+	if (p_what==NOTIFICATION_RESIZED) {
+		shape_changed=true;
+		update();
+	}
+
+	if (p_what==NOTIFICATION_DRAW) {
+
+		VS::get_singleton()->canvas_item_set_clip(get_canvas_item(),true);
+		Ref<StyleBox> bg = get_stylebox("bg");
+
+		int mw = scroll_bar->get_minimum_size().x;
+		scroll_bar->set_anchor_and_margin(MARGIN_LEFT,ANCHOR_END,mw+bg->get_margin(MARGIN_RIGHT));
+		scroll_bar->set_anchor_and_margin(MARGIN_RIGHT,ANCHOR_END,bg->get_margin(MARGIN_RIGHT));
+		scroll_bar->set_anchor_and_margin(MARGIN_TOP,ANCHOR_BEGIN,bg->get_margin(MARGIN_TOP));
+		scroll_bar->set_anchor_and_margin(MARGIN_BOTTOM,ANCHOR_END,bg->get_margin(MARGIN_BOTTOM));
+
+
+		Size2 size = get_size();
+
+		float page = size.height-bg->get_minimum_size().height;
+		int width = size.width - mw - bg->get_minimum_size().width;
+		scroll_bar->set_page(page);
+
+		draw_style_box(bg,Rect2(Point2(),size));
+
+		int hseparation = get_constant("hseparation");
+		int vseparation = get_constant("vseparation");
+		int icon_margin = get_constant("icon_margin");
+		int line_separation = get_constant("line_separation");
+
+		Ref<StyleBox> sbsel = has_focus()?get_stylebox("selected_focus"):get_stylebox("selected");
+		Ref<StyleBox> cursor = has_focus()?get_stylebox("cursor"):get_stylebox("cursor_unfocused");
+
+		Ref<Font> font = get_font("font");
+		Color guide_color = get_color("guide_color");
+		Color font_color = get_color("font_color");
+		int font_height = font->get_height();
+		Vector<int> line_size_cache;
+		Vector<int> line_limit_cache;
+
+		if (max_text_lines) {
+			line_size_cache.resize(max_text_lines);
+			line_limit_cache.resize(max_text_lines);
+		}
+
+		if (has_focus()) {
+			VisualServer::get_singleton()->canvas_item_add_clip_ignore(get_canvas_item(),true);
+			draw_style_box(get_stylebox("bg_focus"),Rect2(Point2(),size));
+			VisualServer::get_singleton()->canvas_item_add_clip_ignore(get_canvas_item(),false);
+		}
+
+		if (shape_changed) {
+
+			//1- compute item minimum sizes
+			for(int i=0;i<items.size();i++) {
+
+				Size2 minsize;
+				if (items[i].icon.is_valid()) {
+					minsize=items[i].icon->get_size();
+					if (min_icon_size.x!=0)
+						minsize.x = MAX(minsize.x,min_icon_size.x);
+					if (min_icon_size.y!=0)
+						minsize.y = MAX(minsize.y,min_icon_size.y);
+
+					if (items[i].text!="") {
+						if (icon_mode==ICON_MODE_TOP) {
+							minsize.y+=icon_margin;
+						} else {
+							minsize.x+=icon_margin;
+						}
+					}
+				}
+
+				if (items[i].text!="") {
+
+					Size2 s = font->get_string_size(items[i].text);
+					//s.width=MIN(s.width,fixed_column_width);
+
+
+
+					if (icon_mode==ICON_MODE_TOP) {
+						minsize.x=MAX(minsize.x,s.width);
+						if (max_text_lines>0) {
+							minsize.y+=(font_height+line_separation)*max_text_lines;
+						} else {
+							minsize.y+=s.height;
+						}
+
+					} else {
+						minsize.y=MAX(minsize.y,s.height);
+						minsize.x+=s.width;
+					}
+				}
+
+
+
+				items[i].rect_cache.size=minsize;
+				if (fixed_column_width>0)
+					items[i].rect_cache.size.x=fixed_column_width;
+
+			}
+
+			int fit_size = size.x - bg->get_minimum_size().width - mw;
+
+			//2-attempt best fit
+			current_columns = 0x7FFFFFFF;
+			if (max_columns>0)
+				current_columns=max_columns;
+
+
+			while(true) {
+				//repeat util all fits
+				//print_line("try with "+itos(current_columns));
+				bool all_fit=true;
+				Vector2 ofs;
+				int col=0;
+				int max_h=0;
+				separators.clear();;
+				for(int i=0;i<items.size();i++) {
+
+					if (current_columns>1 && items[i].rect_cache.size.width+ofs.x > fit_size) {
+						//went past
+						current_columns=MAX(col,1);
+						all_fit=false;
+						break;
+					}
+
+					items[i].rect_cache.pos=ofs;
+					max_h=MAX(max_h,items[i].rect_cache.size.y);
+					ofs.x+=items[i].rect_cache.size.x;
+					//print_line("item "+itos(i)+" ofs "+rtos(items[i].rect_cache.size.x));
+					if (col>0)
+						ofs.x+=hseparation;
+					col++;
+					if (col==current_columns) {
+
+						if (i<items.size()-1)
+							separators.push_back(ofs.y+max_h+vseparation/2);
+						ofs.x=0;
+						ofs.y+=max_h+vseparation;
+						col=0;
+						max_h=0;
+					}
+				}
+
+				if (all_fit) {
+					float max = MAX(page,ofs.y+max_h);
+					scroll_bar->set_max(max);
+					//print_line("max: "+rtos(max)+" page "+rtos(page));
+					if (max<=page) {
+						scroll_bar->set_val(0);
+						scroll_bar->hide();
+					} else {
+						scroll_bar->show();
+					}
+					break;
+				}
+			}
+
+
+			shape_changed=false;
+		}
+
+
+
+		Vector2 base_ofs = bg->get_offset();
+		base_ofs.y-=int(scroll_bar->get_val());
+
+		Rect2 clip(Point2(),size-bg->get_minimum_size()+Vector2(0,scroll_bar->get_val()));
+
+		for(int i=0;i<items.size();i++) {
+
+
+			Rect2 rcache = items[i].rect_cache;
+
+			if (!clip.intersects(rcache))
+				continue;
+
+
+			if (current_columns==1) {
+				rcache.size.width = width-rcache.pos.x;
+			}
+			if (items[i].selected) {
+				Rect2 r=rcache;
+				r.pos+=base_ofs;
+
+				r.pos.x-=sbsel->get_margin(MARGIN_LEFT);
+				r.size.x+=sbsel->get_margin(MARGIN_LEFT)+sbsel->get_margin(MARGIN_RIGHT);
+				r.pos.y-=sbsel->get_margin(MARGIN_TOP);
+				r.size.y+=sbsel->get_margin(MARGIN_TOP)+sbsel->get_margin(MARGIN_BOTTOM);
+
+				draw_style_box(sbsel,r);
+
+			}
+
+
+			Vector2 text_ofs;
+			if (items[i].icon.is_valid()) {
+
+				Vector2 icon_ofs;
+				if (min_icon_size!=Vector2()) {
+					icon_ofs = (min_icon_size - items[i].icon->get_size())/2;
+				}
+
+				if (icon_mode==ICON_MODE_TOP) {
+					draw_texture(items[i].icon,icon_ofs+items[i].rect_cache.pos+Vector2(items[i].rect_cache.size.width/2-items[i].icon->get_width()/2,0).floor()+base_ofs);
+					text_ofs.y = MAX(items[i].icon->get_height(),min_icon_size.y)+icon_margin;
+				} else {
+					draw_texture(items[i].icon,icon_ofs+items[i].rect_cache.pos+Vector2(0,items[i].rect_cache.size.height/2-items[i].icon->get_height()/2).floor()+base_ofs);
+					text_ofs.x = MAX(items[i].icon->get_width(),min_icon_size.x)+icon_margin;
+				}
+			}
+
+			if (items[i].tag_icon.is_valid()) {
+
+				draw_texture(items[i].tag_icon,items[i].rect_cache.pos+base_ofs);
+			}
+
+			if (items[i].text!="") {
+
+				int max_len=-1;
+
+				Vector2 size = font->get_string_size(items[i].text);
+				if (fixed_column_width)
+					max_len=fixed_column_width;
+				else
+					max_len=size.x;
+
+				if (icon_mode==ICON_MODE_TOP && max_text_lines>0) {
+
+					int ss = items[i].text.length();
+					float ofs=0;
+					int line=0;
+					for(int j=0;j<=ss;j++) {
+
+						int cs = j<ss?font->get_char_size(items[i].text[j],items[i].text[j+1]).x:0;
+						if (ofs+cs>max_len || j==ss) {
+							line_limit_cache[line]=j;
+							line_size_cache[line]=ofs;
+							line++;
+							ofs=0;
+							if (line>=max_text_lines)
+								break;
+						} else {
+							ofs+=cs;
+						}
+
+					}
+
+					line=0;
+					ofs=0;
+
+					text_ofs.y+=font->get_ascent();
+					text_ofs=text_ofs.floor();
+					text_ofs+=base_ofs;
+					text_ofs+=items[i].rect_cache.pos;
+
+					for(int j=0;j<ss;j++) {
+
+						if (j==line_limit_cache[line]) {
+							line++;
+							ofs=0;
+							if (line>=max_text_lines)
+								break;
+						}
+						ofs+=font->draw_char(get_canvas_item(),text_ofs+Vector2(ofs+(max_len-line_size_cache[line])/2,line*(font_height+line_separation)).floor(),items[i].text[j],items[i].text[j+1],font_color);
+					}
+
+					//special multiline mode
+				} else {
+
+					if (fixed_column_width>0)
+						size.x=MIN(size.x,fixed_column_width);
+
+					if (icon_mode==ICON_MODE_TOP) {
+						text_ofs.x+=(items[i].rect_cache.size.width-size.x)/2;
+					} else {
+						text_ofs.y+=(items[i].rect_cache.size.height-size.y)/2;
+					}
+
+					text_ofs.y+=font->get_ascent();
+					text_ofs=text_ofs.floor();
+					text_ofs+=base_ofs;
+					text_ofs+=items[i].rect_cache.pos;
+
+					draw_string(font,text_ofs,items[i].text,font_color,max_len+1);
+				}
+
+
+			}
+
+			if (select_mode==SELECT_MULTI && i==current) {
+
+				Rect2 r=rcache;
+				r.pos+=base_ofs;
+				draw_style_box(cursor,r);
+
+			}
+		}
+
+		for(int i=0;i<separators.size();i++) {
+			draw_line(Vector2(bg->get_margin(MARGIN_LEFT),base_ofs.y+separators[i]),Vector2(size.width-bg->get_margin(MARGIN_LEFT),base_ofs.y+separators[i]),guide_color);
+		}
+
+	}
+}
+
+void ItemList::_scroll_changed(double) {
+	update();
+}
+
+
+String ItemList::get_tooltip(const Point2& p_pos) const {
+
+	Vector2 pos=p_pos;
+	Ref<StyleBox> bg = get_stylebox("bg");
+	pos-=bg->get_offset();
+	pos.y+=scroll_bar->get_val();
+
+	int closest = -1;
+	int closest_dist=0x7FFFFFFF;
+
+	for(int i=0;i<items.size();i++) {
+
+		Rect2 rc = items[i].rect_cache;
+		if (i%current_columns==current_columns-1) {
+			rc.size.width=get_size().width; //not right but works
+		}
+
+		if (rc.has_point(pos)) {
+			closest=i;
+			break;
+		}
+
+		float dist = rc.distance_to(pos);
+		if (dist<closest_dist) {
+			closest=i;
+			closest_dist=dist;
+		}
+	}
+
+	if (closest!=-1) {
+		if (items[closest].tooltip!="") {
+			return items[closest].tooltip;
+		}
+		if (items[closest].text!="") {
+			return items[closest].text;
+		}
+	}
+
+	return Control::get_tooltip(p_pos);
+
+
+}
+
+
+void ItemList::_bind_methods(){
+
+	ObjectTypeDB::bind_method(_MD("add_item","text","icon:Texture","selectable"),&ItemList::add_item,DEFVAL(Ref<Texture>()),DEFVAL(true));
+	ObjectTypeDB::bind_method(_MD("add_icon_item","icon:Texture","selectable"),&ItemList::add_icon_item,DEFVAL(true));
+
+	ObjectTypeDB::bind_method(_MD("set_item_text","idx","text"),&ItemList::set_item_text);
+	ObjectTypeDB::bind_method(_MD("get_item_text","idx"),&ItemList::get_item_text);
+
+	ObjectTypeDB::bind_method(_MD("set_item_icon","idx","icon:Texture"),&ItemList::set_item_icon);
+	ObjectTypeDB::bind_method(_MD("get_item_icon:Tedture","idx"),&ItemList::get_item_icon);
+
+	ObjectTypeDB::bind_method(_MD("set_item_selectable","idx","selectable"),&ItemList::set_item_selectable);
+	ObjectTypeDB::bind_method(_MD("is_item_selectable","idx"),&ItemList::is_item_selectable);
+
+	ObjectTypeDB::bind_method(_MD("set_item_disabled","idx","disabled"),&ItemList::set_item_disabled);
+	ObjectTypeDB::bind_method(_MD("is_item_disabled","idx"),&ItemList::is_item_disabled);
+
+	ObjectTypeDB::bind_method(_MD("set_item_tooltip","idx","tooltip"),&ItemList::set_item_tooltip);
+	ObjectTypeDB::bind_method(_MD("get_item_tooltip","idx"),&ItemList::get_item_tooltip);
+
+	ObjectTypeDB::bind_method(_MD("select","idx","single"),&ItemList::select,DEFVAL(true));
+	ObjectTypeDB::bind_method(_MD("unselect","idx"),&ItemList::unselect);
+	ObjectTypeDB::bind_method(_MD("is_selected","idx"),&ItemList::is_selected);
+
+	ObjectTypeDB::bind_method(_MD("get_item_count"),&ItemList::get_item_count);
+	ObjectTypeDB::bind_method(_MD("remove_item","idx"),&ItemList::remove_item);
+
+	ObjectTypeDB::bind_method(_MD("clear"),&ItemList::clear);
+
+	ObjectTypeDB::bind_method(_MD("set_fixed_column_width","width"),&ItemList::set_fixed_column_width);
+	ObjectTypeDB::bind_method(_MD("get_fixed_column_width"),&ItemList::get_fixed_column_width);
+
+	ObjectTypeDB::bind_method(_MD("set_max_text_lines","lines"),&ItemList::set_max_text_lines);
+	ObjectTypeDB::bind_method(_MD("get_max_text_lines"),&ItemList::get_max_text_lines);
+
+	ObjectTypeDB::bind_method(_MD("set_max_columns","amount"),&ItemList::set_max_columns);
+	ObjectTypeDB::bind_method(_MD("get_max_columns"),&ItemList::get_max_columns);
+
+	ObjectTypeDB::bind_method(_MD("set_select_mode","mode"),&ItemList::set_select_mode);
+	ObjectTypeDB::bind_method(_MD("get_select_mode"),&ItemList::get_select_mode);
+
+	ObjectTypeDB::bind_method(_MD("set_icon_mode","mode"),&ItemList::set_icon_mode);
+	ObjectTypeDB::bind_method(_MD("get_icon_mode"),&ItemList::get_icon_mode);
+
+	ObjectTypeDB::bind_method(_MD("set_min_icon_size","size"),&ItemList::set_min_icon_size);
+	ObjectTypeDB::bind_method(_MD("get_min_icon_size"),&ItemList::get_min_icon_size);
+
+	ObjectTypeDB::bind_method(_MD("ensure_current_is_visible"),&ItemList::ensure_current_is_visible);
+
+	ObjectTypeDB::bind_method(_MD("_scroll_changed"),&ItemList::_scroll_changed);
+	ObjectTypeDB::bind_method(_MD("_input_event"),&ItemList::_input_event);
+
+	BIND_CONSTANT( ICON_MODE_TOP );
+	BIND_CONSTANT( ICON_MODE_LEFT );
+	BIND_CONSTANT( SELECT_SINGLE );
+	BIND_CONSTANT( SELECT_MULTI );
+
+	ADD_SIGNAL( MethodInfo("item_selected",PropertyInfo(Variant::INT,"index")));
+	ADD_SIGNAL( MethodInfo("multi_selected",PropertyInfo(Variant::INT,"index"),PropertyInfo(Variant::BOOL,"selected")));
+	ADD_SIGNAL( MethodInfo("item_activated",PropertyInfo(Variant::INT,"index")));
+}
+
+
+
+ItemList::ItemList() {
+
+	current=-1;
+
+	select_mode=SELECT_SINGLE;
+	icon_mode=ICON_MODE_LEFT;
+
+	fixed_column_width=0;
+	max_text_lines=1;
+	max_columns=1;
+
+	scroll_bar = memnew( VScrollBar );
+	add_child(scroll_bar);
+
+	shape_changed=true;
+	scroll_bar->connect("value_changed",this,"_scroll_changed");
+
+	set_focus_mode(FOCUS_ALL);
+	current_columns=1;
+	search_time_msec=0;
+
+}
+
+ItemList::~ItemList() {
+
+}
+
diff --git a/scene/gui/item_list.h b/scene/gui/item_list.h
new file mode 100644
index 0000000000..6bbb416970
--- /dev/null
+++ b/scene/gui/item_list.h
@@ -0,0 +1,132 @@
+#ifndef ITEMLIST_H
+#define ITEMLIST_H
+
+#include "scene/gui/control.h"
+#include "scene/gui/scroll_bar.h"
+
+class ItemList : public Control {
+
+	OBJ_TYPE( ItemList, Control );
+public:
+
+	enum IconMode {
+		ICON_MODE_TOP,
+		ICON_MODE_LEFT
+	};
+
+	enum SelectMode {
+		SELECT_SINGLE,
+		SELECT_MULTI
+	};
+private:
+	struct Item {
+
+		Ref<Texture> icon;
+		Ref<Texture> tag_icon;
+		String text;
+		bool selectable;
+		bool selected;
+		bool disabled;
+		Variant metadata;
+		String tooltip;
+
+		Rect2 rect_cache;
+	};
+
+	int current;
+
+	bool shape_changed;
+
+	Vector<Item> items;
+	Vector<int> separators;
+
+	SelectMode select_mode;
+	IconMode icon_mode;
+	VScrollBar *scroll_bar;
+
+	uint64_t search_time_msec;
+	String search_string;
+
+	int current_columns;
+	int fixed_column_width;
+	int max_text_lines;
+	int max_columns;
+	Size2 min_icon_size;
+
+	void _scroll_changed(double);
+	void _input_event(const InputEvent& p_event);
+protected:
+
+	void _notification(int p_what);
+	static void _bind_methods();
+public:
+
+	void add_item(const String& p_item,const Ref<Texture>& p_texture=Ref<Texture>(),bool p_selectable=true);
+	void add_icon_item(const Ref<Texture>& p_item,bool p_selectable=true);
+
+	void set_item_text(int p_idx,const String& p_text);
+	String get_item_text(int p_idx) const;
+
+	void set_item_icon(int p_idx,const Ref<Texture>& p_icon);
+	Ref<Texture> get_item_icon(int p_idx) const;
+
+	void set_item_selectable(int p_idx,bool p_selectable);
+	bool is_item_selectable(int p_idx) const;
+
+	void set_item_disabled(int p_idx,bool p_disabled);
+	bool is_item_disabled(int p_idx) const;
+
+	void set_item_metadata(int p_idx,const Variant& p_metadata);
+	Variant get_item_metadata(int p_idx) const;
+
+	void set_item_tag_icon(int p_idx,const Ref<Texture>& p_tag_icon);
+	Ref<Texture> get_item_tag_icon(int p_idx) const;
+
+	void set_item_tooltip(int p_idx,const String& p_tooltip);
+	String get_item_tooltip(int p_idx) const;
+
+	void select(int p_idx,bool p_single=true);
+	void unselect(int p_idx);
+	bool is_selected(int p_idx) const;
+
+	void set_current(int p_current);
+	int get_current() const;
+
+
+	int get_item_count() const;
+	void remove_item(int p_idx);
+
+	void clear();
+
+	void set_fixed_column_width(int p_size);
+	int get_fixed_column_width() const;
+
+	void set_max_text_lines(int p_amount);
+	int get_max_text_lines() const;
+
+	void set_max_columns(int p_amount);
+	int get_max_columns() const;
+
+	void set_select_mode(SelectMode p_mode);
+	SelectMode get_select_mode() const;
+
+	void set_icon_mode(IconMode p_mode);
+	IconMode get_icon_mode() const;
+
+	void set_min_icon_size(const Size2& p_size);
+	Size2 get_min_icon_size() const;
+
+	void ensure_current_is_visible();
+
+
+	virtual String get_tooltip(const Point2& p_pos) const;
+
+	ItemList();
+	~ItemList();
+};
+
+VARIANT_ENUM_CAST(ItemList::SelectMode);
+VARIANT_ENUM_CAST(ItemList::IconMode);
+
+
+#endif // ITEMLIST_H
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index 687410d192..f78481b745 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -66,6 +66,7 @@
 #include "scene/gui/file_dialog.h"
 #include "scene/gui/dialogs.h"
 #include "scene/gui/tree.h"
+#include "scene/gui/item_list.h"
 #include "scene/gui/text_edit.h"
 #include "scene/gui/texture_button.h"
 #include "scene/gui/separator.h"
@@ -327,7 +328,7 @@ void register_scene_types() {
 	ObjectTypeDB::register_type<HButtonArray>();
 	ObjectTypeDB::register_type<VButtonArray>();
 	ObjectTypeDB::register_type<TextureProgress>();
-
+	ObjectTypeDB::register_type<ItemList>();
 
 #ifndef	ADVANCED_GUI_DISABLED
 
@@ -335,6 +336,7 @@ void register_scene_types() {
 	ObjectTypeDB::register_type<LineEdit>();
 	ObjectTypeDB::register_type<PopupMenu>();
 	ObjectTypeDB::register_type<Tree>();
+
 	ObjectTypeDB::register_type<TextEdit>();
 
 	ObjectTypeDB::register_virtual_type<TreeItem>();
diff --git a/scene/resources/default_theme/default_theme.cpp b/scene/resources/default_theme/default_theme.cpp
index d43ffd2130..62fa01f587 100644
--- a/scene/resources/default_theme/default_theme.cpp
+++ b/scene/resources/default_theme/default_theme.cpp
@@ -574,7 +574,7 @@ void make_default_theme() {
 	// Tree
 
 	Ref<StyleBoxTexture> tree_selected = make_stylebox( selection_png,4,4,4,4,8,0,8,0);
-    Ref<StyleBoxTexture> tree_selected_oof = make_stylebox( selection_oof_png,4,4,4,4,8,0,8,0);
+	Ref<StyleBoxTexture> tree_selected_oof = make_stylebox( selection_oof_png,4,4,4,4,8,0,8,0);
 
 	t->set_stylebox("bg","Tree", make_stylebox( tree_bg_png,4,4,4,5) );
 	t->set_stylebox("bg_focus","Tree", focus );
@@ -605,12 +605,31 @@ void make_default_theme() {
 	t->set_color("guide_color","Tree", Color(0,0,0,0.1) );
 
 	t->set_constant("hseparation","Tree",4);
-	t->set_constant("vseparation","Tree",2);
+	t->set_constant("vseparation","Tree",4);
 	t->set_constant("guide_width","Tree",2);
 	t->set_constant("item_margin","Tree",12);
 	t->set_constant("button_margin","Tree",4);
 
 
+	// ItemList
+	Ref<StyleBoxTexture> item_selected = make_stylebox( selection_png,4,4,4,4,8,2,8,2);
+	Ref<StyleBoxTexture> item_selected_oof = make_stylebox( selection_oof_png,4,4,4,4,8,2,8,2);
+
+	t->set_stylebox("bg","ItemList", make_stylebox( tree_bg_png,4,4,4,5) );
+	t->set_stylebox("bg_focus","ItemList", focus );
+	t->set_constant("hseparation","ItemList",4);
+	t->set_constant("vseparation","ItemList",2);
+	t->set_constant("icon_margin","ItemList",4);
+	t->set_constant("line_separation","ItemList",2);
+	t->set_font("font","ItemList", default_font );
+	t->set_color("font_color","ItemList", control_font_color_low );
+	t->set_color("font_color_selected","ItemList", control_font_color_pressed );
+	t->set_color("guide_color","ItemList", Color(0,0,0,0.1) );
+	t->set_stylebox("selected","ItemList", item_selected_oof );
+	t->set_stylebox("selected_focus","ItemList", item_selected );
+	t->set_stylebox("cursor","ItemList", focus );
+	t->set_stylebox("cursor_unfocused","ItemList", focus );
+
 
 	// TextEdit