diff --git a/.gitignore b/.gitignore
index ae7c1ae6..fbb1211b 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,3 +1,4 @@
+.idea
 *.a
 *.o
 *.os
diff --git a/CMakeLists.txt b/CMakeLists.txt
index c0af7209..84716551 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -20,12 +20,16 @@ option( SFGUI_BUILD_EXAMPLES    "Build examples."
 option( SFGUI_BUILD_DOC         "Generate API documentation."                   OFF)
 option( SFGUI_INCLUDE_FONT      "Include default font in library (DejaVuSans)." ON)
 option( SFML_STATIC_LIBRARIES   "Do you want to link SFML statically?"          OFF)
+option( SFGUI_BOOST_FILESYSTEM_SUPPORT "Do you want SFGUI to support Boost.FileSystem? (enable FilePickerDialog widget)" OFF)
 
 
 # Find packages.
 find_package( OpenGL REQUIRED )
 find_package( SFML 2.5 REQUIRED COMPONENTS graphics window system )
 
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/include/SFGUI/Config.hpp.in ${CMAKE_CURRENT_BINARY_DIR}/include/SFGUI/Config.hpp)
+include_directories(${CMAKE_CURRENT_BINARY_DIR}/include)
+
 set( INCLUDE_PATH "${PROJECT_SOURCE_DIR}/include/" )
 set( SOURCE_PATH "${PROJECT_SOURCE_DIR}/src/" )
 
@@ -59,6 +63,11 @@ endif()
 
 target_link_libraries( ${TARGET} PUBLIC sfml-graphics sfml-window sfml-system ${OPENGL_gl_LIBRARY} )
 
+# Link to Boost.FileSystem if enabled
+if( SFGUI_BOOST_FILESYSTEM_SUPPORT )
+	target_link_libraries( sfgui ${Boost_SYSTEM_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} )
+endif()
+
 # Tell the compiler to export when necessary.
 set_target_properties( ${TARGET} PROPERTIES DEFINE_SYMBOL SFGUI_EXPORTS )
 
@@ -115,7 +124,7 @@ elseif( APPLE )
 			IMPORTED_LOCATION "${COREFOUNDATION_LIBRARY}"
 			INTERFACE_INCLUDE_DIRECTORIES "/System/Library/Frameworks/CoreFoundation.framework/Headers"
 	)
-	
+
 	target_link_libraries( ${TARGET} PUBLIC CoreFoundation )
 	set( SHARE_PATH "${CMAKE_INSTALL_PREFIX}/share/SFGUI" )
 	set( LIB_PATH "lib" )
@@ -165,6 +174,11 @@ install(
 	DESTINATION include
 )
 
+install(
+	DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/include
+	DESTINATION .
+)
+
 install(
 	FILES README.md AUTHORS.md LICENSE.md FONT.LICENSE.md CHANGELOG.md
 	DESTINATION "${SHARE_PATH}"
diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt
index b966d5c2..d7edba36 100644
--- a/examples/CMakeLists.txt
+++ b/examples/CMakeLists.txt
@@ -38,8 +38,15 @@ build_example( "ProgressBar" "ProgressBar.cpp" )
 build_example( "SpinButton" "SpinButton.cpp" )
 build_example( "Canvas" "Canvas.cpp" )
 build_example( "CustomWidget" "CustomWidget.cpp" )
+build_example( "ListBox" "ListBox.cpp" )
 build_example( "SFGUI-Test" "Test.cpp" )
 
+if( SFGUI_BOOST_FILESYSTEM_SUPPORT )
+	build_example( "FilePickerDialog" "FilePickerDialog.cpp" )
+	include_directories( SYSTEM ${Boost_INCLUDE_DIR} )
+	target_link_libraries( FilePickerDialog ${Boost_SYSTEM_LIBRARY} ${Boost_FILESYSTEM_LIBRARY} )
+endif()
+
 # Copy data directory to build cache directory to be able to run examples from
 # there. Useful for testing stuff.
 # Don't try to copy if the directories are the same.
@@ -49,13 +56,13 @@ if( NOT ( "${PROJECT_SOURCE_DIR}" STREQUAL "${PROJECT_BINARY_DIR}" ) )
 		COMMAND "${CMAKE_COMMAND}"
 		ARGS -E copy_directory "${PROJECT_SOURCE_DIR}/examples/data" "${PROJECT_BINARY_DIR}/examples/data"
 	)
-	
+
 	add_custom_command(
 		TARGET "Image"
 		COMMAND "${CMAKE_COMMAND}"
 		ARGS -E copy_directory "${PROJECT_SOURCE_DIR}/examples/data" "${PROJECT_BINARY_DIR}/examples/data"
 	)
-	
+
 	add_custom_command(
 		TARGET "Canvas"
 		COMMAND "${CMAKE_COMMAND}"
diff --git a/examples/CustomWidget.cpp b/examples/CustomWidget.cpp
index 49b6b980..9ab1beaa 100644
--- a/examples/CustomWidget.cpp
+++ b/examples/CustomWidget.cpp
@@ -96,7 +96,7 @@ class MyCustomWidget : public sfg::Widget {
 						5.f,
 						inverted_color,
 						background_color,
-						20.f
+						20
 					)
 				);
 
@@ -120,7 +120,7 @@ class MyCustomWidget : public sfg::Widget {
 							255
 						),
 						inner_border_color,
-						20.f
+						20
 					)
 				);
 
diff --git a/examples/FilePickerDialog.cpp b/examples/FilePickerDialog.cpp
new file mode 100644
index 00000000..115196dd
--- /dev/null
+++ b/examples/FilePickerDialog.cpp
@@ -0,0 +1,88 @@
+// Always include the necessary header files.
+// Including SFGUI/Widgets.hpp includes everything
+// you can possibly need automatically.
+#include <SFGUI/SFGUI.hpp>
+#include <SFGUI/Widgets.hpp>
+
+#include <SFML/Graphics.hpp>
+
+int main() {
+	// Create the main SFML window
+	sf::RenderWindow app_window( sf::VideoMode( 800, 600 ), "SFGUI Window Example", sf::Style::Titlebar | sf::Style::Close );
+
+	// We have to do this because we don't use SFML to draw.
+	app_window.resetGLStates();
+
+	// Create an SFGUI. This is required before doing anything with SFGUI.
+	sfg::SFGUI sfgui;
+
+	// Create our main SFGUI window
+
+	// Almost everything in SFGUI is handled through smart pointers
+	// for automatic resource management purposes. You create them
+	// and they will automatically be destroyed when the time comes.
+
+	// Creation of widgets is always done with it's Create() method
+	// which will return a smart pointer owning the new widget.
+	auto window = sfg::FilePickerDialog::Create( "/home/victor" );
+
+	// Here we can set the window's title bar text.
+	window->SetTitle( "A really really really really long title" );
+
+	window->GetSignal( sfg::FilePickerDialog::OnCancel ).Connect(
+		[]()
+		{
+			std::cout << "Path selection cancelled !" << std::endl;
+		}
+	);
+	window->GetSignal( sfg::FilePickerDialog::OnOk ).Connect(
+		[window]()
+		{
+			std::cout << "Selected path : \"" << window->GetSelectedPath().toAnsiString() << "\"" << std::endl;
+		}
+	);
+
+	// For more things to set around the window refer to the
+	// API documentation.
+
+	// Start the game loop
+	while ( app_window.isOpen() ) {
+		// Process events
+		sf::Event event;
+
+		while ( app_window.pollEvent( event ) ) {
+			// Every frame we have to send SFML events to the window
+			// to enable user interactivity. Without doing this your
+			// GUI is nothing but a big colorful picture ;)
+			window->HandleEvent( event );
+
+			// Close window : exit
+			if ( event.type == sf::Event::Closed ) {
+				app_window.close();
+			}
+		}
+
+		// Update the GUI, note that you shouldn't normally
+		// pass 0 seconds to the update method.
+		window->Update( 0.f );
+
+		// Clear screen
+		app_window.clear();
+
+		// After drawing the rest of your game, you have to let the GUI
+		// render itself. If you don't do this you will never be able
+		// to see it ;)
+		sfgui.Display( app_window );
+
+		// NOTICE
+		// Because the window doesn't have any children it will shrink to
+		// it's minimum size of (0,0) resulting in you not seeing anything
+		// except the title bar text ;) Don't worry, in the Label example
+		// you'll get to see more.
+
+		// Update the window
+		app_window.display();
+	}
+
+	return EXIT_SUCCESS;
+}
diff --git a/examples/ListBox.cpp b/examples/ListBox.cpp
new file mode 100644
index 00000000..38574fd9
--- /dev/null
+++ b/examples/ListBox.cpp
@@ -0,0 +1,138 @@
+// Always include the necessary header files.
+// Including SFGUI/Widgets.hpp includes everything
+// you can possibly need automatically.
+#include <SFGUI/SFGUI.hpp>
+#include <SFGUI/Widgets.hpp>
+
+#include <SFML/Graphics.hpp>
+
+int main() {
+	sfg::SFGUI sfgui;
+	sf::RenderWindow window(sf::VideoMode(800, 600), "ListBox Example");
+    window.setVerticalSyncEnabled(true);
+    window.setFramerateLimit(30);
+
+	sf::Image firstImage;
+	firstImage.loadFromFile("data/add.png");
+
+	sf::Image secondImage;
+	secondImage.loadFromFile("data/delete.png");
+
+    sfg::Desktop desktop;
+
+	auto window1 = sfg::Window::Create();
+	window1->SetTitle( "ListBox with ItemTextPolicy::RESIZE_LISTBOX" );
+
+	auto box1 = sfg::Box::Create( sfg::Box::Orientation::VERTICAL );
+	box1->SetSpacing( 5.f );
+	box1->PackEnd( sfg::Label::Create( "The minimum width\nof this ListBox\ncorresponds to the largest\nitem's text width." ), false, true );
+
+	auto listbox1 = sfg::ListBox::Create();
+	listbox1->AppendItem( "This is the first item" );
+	listbox1->AppendItem( "Second item" );
+	listbox1->AppendItem( "Third item which is a bit large" );
+	listbox1->AppendItem( "Fourth item" );
+	listbox1->AppendItem( "Fifth item" );
+	listbox1->AppendItem( "Sixth item" );
+	listbox1->AppendItem( "Last one !" );
+	box1->PackEnd( listbox1 );
+	listbox1->SetImagesSize(sf::Vector2f(32.f, 32.f));
+
+	window1->Add( box1 );
+
+	auto window2 = sfg::Window::Create();
+	window2->SetTitle( "ListBox with ItemTextPolicy::SHRINK" );
+
+	auto box2 = sfg::Box::Create( sfg::Box::Orientation::VERTICAL );
+	box2->SetSpacing( 5.f );
+	auto label2 = sfg::Label::Create( "The items' texts\nare shrinked if the\nListBox is not big\nenough." );
+	box2->PackEnd( label2, false, true );
+
+	auto listbox2 = sfg::ListBox::Create();
+	listbox2->AppendItem( "This is the first item (long text)" );
+	listbox2->AppendItem( "Second item", firstImage );
+	listbox2->AppendItem( "Third item which is very long !", secondImage );
+	listbox2->AppendItem( "Fourth item" );
+	listbox2->AppendItem( "Fifth item" );
+	listbox2->AppendItem( "Sixth item, again it's too large !" );
+	listbox2->AppendItem( "Last one !" );
+	listbox2->SetItemTextPolicy( sfg::ListBox::ItemTextPolicy::SHRINK );
+	box2->PackEnd( listbox2 );
+	listbox2->SetImagesSize(sf::Vector2f(32.f, 32.f));
+
+	window2->Add( box2 );
+
+	auto window3 = sfg::Window::Create();
+	window3->SetTitle( "ListBox with ItemTextPolicy::SHRINK" );
+
+	auto box3 = sfg::Box::Create( sfg::Box::Orientation::VERTICAL );
+	box3->SetSpacing( 5.f );
+	auto label3 = sfg::Label::Create( "You can select multiple\nitems in this ListBox." );
+	box3->PackEnd( label3, false, true );
+
+	auto listbox3 = sfg::ListBox::Create();
+	listbox3->AppendItem( "First item" );
+	listbox3->AppendItem( "Second item" );
+	listbox3->AppendItem( "Third item" );
+	listbox3->AppendItem( "Fourth item" );
+	listbox3->AppendItem( "Fifth item" );
+	listbox3->AppendItem( "Sixth item" );
+	listbox3->AppendItem( "Last one !" );
+	listbox3->SetSelectionMode( sfg::ListBox::SelectionMode::MULTI_SELECTION );
+	listbox3->SetSelection( {1, 3, 4, 5} );
+	box3->PackEnd( listbox3 );
+
+	window3->Add( box3 );
+
+	desktop.Add( window1 );
+	desktop.Add( window2 );
+	desktop.Add( window3 );
+
+	sf::Vector2f windowSize( static_cast<float>( window.getSize().x ), static_cast<float>( window.getSize().y ) );
+
+	window2->SetPosition(sf::Vector2f(windowSize.x/2.f - window2->GetRequisition().x/2.f, windowSize.y/2.f - window2->GetRequisition().y/2.f));
+	window3->SetPosition(sf::Vector2f(windowSize.x - window3->GetRequisition().x - 100.f, windowSize.y - window3->GetRequisition().y - 100.f));
+
+    sf::Event event;
+    sf::Clock clock;
+
+    window.resetGLStates();
+
+	int i = 0;
+
+    while (window.isOpen())
+        {
+            while (window.pollEvent(event))
+            {
+                desktop.HandleEvent( event );
+                switch(event.type)
+                {
+                    case sf::Event::Closed:
+                        window.close();
+                    	break;
+					case sf::Event::KeyPressed:
+						if( event.key.code == sf::Keyboard::R ) {
+							listbox3->RemoveItem(2);
+						} else if( event.key.code == sf::Keyboard::I ) {
+							listbox3->InsertItem(3, "Inserted item #" + std::to_string(i));
+							++i;
+						} else if( event.key.code == sf::Keyboard::A) {
+							listbox3->AppendItem("Appended item #" + std::to_string(i));
+							++i;
+						} else if( event.key.code == sf::Keyboard::P) {
+							listbox3->PrependItem("Prepended item #" + std::to_string(i));
+							++i;
+						}
+						break;
+					default:
+						break;
+                }
+            }
+            desktop.Update( clock.restart().asSeconds() );
+            window.clear();
+            sfgui.Display( window );
+            window.display();
+        }
+
+    return 0;
+}
diff --git a/include/SFGUI/Button.hpp b/include/SFGUI/Button.hpp
index f2ed9c8a..048563d5 100644
--- a/include/SFGUI/Button.hpp
+++ b/include/SFGUI/Button.hpp
@@ -13,6 +13,16 @@ class Image;
  */
 class SFGUI_API Button : public Bin {
 	public:
+		enum Alignment {
+			CENTER,
+			LEFT		= 0x1,
+			RIGHT		= 0x2,
+			TOP			= 0x4,
+			BOTTOM		= 0x8,
+			HORIZONTAL	= LEFT + RIGHT,
+			VERTICAL	= TOP + BOTTOM,
+		};
+
 		typedef std::shared_ptr<Button> Ptr; //!< Shared pointer.
 		typedef std::shared_ptr<const Button> PtrConst; //!< Shared pointer.
 
@@ -24,6 +34,16 @@ class SFGUI_API Button : public Bin {
 
 		const std::string& GetName() const override;
 
+		/** Set alignment.
+		 * @param alignment Alignment.
+		 */
+		void SetAlignment(Alignment alignment);
+
+		/** Get alignment.
+		 * @return Alignment.
+		 */
+		const Alignment& GetAlignment() const;
+
 		/** Set label.
 		 * @param label Label.
 		 */
@@ -69,6 +89,9 @@ class SFGUI_API Button : public Bin {
 		void AllocateChild();
 
 		sf::String m_label;
+		Alignment m_alignment;
 };
 
 }
+
+sfg::Button::Alignment operator|(sfg::Button::Alignment a, sfg::Button::Alignment b);
diff --git a/include/SFGUI/Config.hpp b/include/SFGUI/Config.hpp.in
similarity index 95%
rename from include/SFGUI/Config.hpp
rename to include/SFGUI/Config.hpp.in
index 102ed736..cf6139e7 100644
--- a/include/SFGUI/Config.hpp
+++ b/include/SFGUI/Config.hpp.in
@@ -35,3 +35,5 @@
 	#define SFGUI_DEBUG
 	#include <iostream> // XXX Only for debugging purposes.
 #endif
+
+#cmakedefine SFGUI_BOOST_FILESYSTEM_SUPPORT
diff --git a/include/SFGUI/Desktop.hpp b/include/SFGUI/Desktop.hpp
index b7f4f81c..5d9dbae8 100644
--- a/include/SFGUI/Desktop.hpp
+++ b/include/SFGUI/Desktop.hpp
@@ -99,6 +99,11 @@ class SFGUI_API Desktop {
 		 */
 		void BringToFront( std::shared_ptr<const Widget> child );
 
+		/** Is any widget focused.
+		 * @return true if any widget is focused, false otherwise.
+		 */
+		bool IsAnyWidgetFocused();
+
 	private:
 		typedef std::deque<std::shared_ptr<Widget>> WidgetsList;
 
diff --git a/include/SFGUI/Engine.hpp b/include/SFGUI/Engine.hpp
index be76ffe3..b6375439 100644
--- a/include/SFGUI/Engine.hpp
+++ b/include/SFGUI/Engine.hpp
@@ -40,6 +40,7 @@ class Notebook;
 class Spinner;
 class ComboBox;
 class SpinButton;
+class ListBox;
 
 class Selector;
 class RenderQueue;
@@ -164,6 +165,12 @@ class SFGUI_API Engine {
 		 */
 		virtual std::unique_ptr<RenderQueue> CreateSpinButtonDrawable( std::shared_ptr<const SpinButton> spinbutton ) const = 0;
 
+		/** Create drawable for listbox widgets.
+		 * @param listbox Widget.
+		 * @return New drawable object (unmanaged memory!).
+		 */
+		virtual std::unique_ptr<RenderQueue> CreateListBoxDrawable( std::shared_ptr<const ListBox> listbox ) const = 0;
+
 		/** Get maximum line height.
 		 * @param font Font.
 		 * @param font_size Font size.
diff --git a/include/SFGUI/Engines/BREW.hpp b/include/SFGUI/Engines/BREW.hpp
index 34a88232..0d5ef5b2 100644
--- a/include/SFGUI/Engines/BREW.hpp
+++ b/include/SFGUI/Engines/BREW.hpp
@@ -43,6 +43,7 @@ class SFGUI_API BREW : public Engine {
 		std::unique_ptr<RenderQueue> CreateSpinnerDrawable( std::shared_ptr<const Spinner> spinner ) const override;
 		std::unique_ptr<RenderQueue> CreateComboBoxDrawable( std::shared_ptr<const ComboBox> combo_box ) const override;
 		std::unique_ptr<RenderQueue> CreateSpinButtonDrawable( std::shared_ptr<const SpinButton> spinbutton ) const override;
+		std::unique_ptr<RenderQueue> CreateListBoxDrawable( std::shared_ptr<const ListBox> listbox ) const override;
 
 	private:
 		static std::unique_ptr<RenderQueue> CreateBorder( const sf::FloatRect& rect, float border_width, const sf::Color& light_color, const sf::Color& dark_color );
diff --git a/include/SFGUI/Entry.hpp b/include/SFGUI/Entry.hpp
index 6223607c..9fa23276 100644
--- a/include/SFGUI/Entry.hpp
+++ b/include/SFGUI/Entry.hpp
@@ -52,6 +52,11 @@ class SFGUI_API Entry : public Widget {
 		 */
 		int GetVisibleOffset() const;
 
+		/** Get length of the visible text.
+		 * @return Length.
+		 */
+		int GetVisibleLength() const;
+
 		/** Get current cursor position.
 		 * @return Cursor position.
 		 */
@@ -87,8 +92,20 @@ class SFGUI_API Entry : public Widget {
 		 */
 		void SetMaximumLength( int max_length );
 
+		/** Get selection bounds.
+		 * @param left Selection's left side cursor position.
+		 * @param right Selection's right side cursor position.
+		 */
+		void GetSelectionBounds(int& left, int& right) const;
+
+		/** Get selected string.
+		 * @return Selected text.
+		 */
+		sf::String GetSelectedText() const;
+
 		// Signals.
 		static Signal::SignalID OnTextChanged; //!< Fired when the text changes.
+		static Signal::SignalID OnReturnPressed; //!< Fired when enter is pressed.
 
 	protected:
 		/** Ctor.
@@ -103,6 +120,7 @@ class SFGUI_API Entry : public Widget {
 		std::unique_ptr<RenderQueue> InvalidateImpl() const override;
 		sf::Vector2f CalculateRequisition() override;
 
+		void HandleMouseMoveEvent( int x, int y ) override;
 		void HandleMouseButtonEvent( sf::Mouse::Button button, bool press, int x, int y ) override;
 		void HandleUpdate( float seconds ) override;
 		void HandleTextEvent( sf::Uint32 character ) override;
@@ -143,6 +161,7 @@ class SFGUI_API Entry : public Widget {
 		int m_max_length;
 
 		int m_cursor_position;
+		int m_cursor_selection_start;
 
 		float m_elapsed_time;
 
diff --git a/include/SFGUI/FilePickerDialog.hpp b/include/SFGUI/FilePickerDialog.hpp
new file mode 100644
index 00000000..530b8d91
--- /dev/null
+++ b/include/SFGUI/FilePickerDialog.hpp
@@ -0,0 +1,71 @@
+#pragma once
+
+#include <SFGUI/Config.hpp>
+
+#if defined(SFGUI_BOOST_FILESYSTEM_SUPPORT)
+
+#include <boost/filesystem.hpp>
+
+#include <SFGUI/Box.hpp>
+#include <SFGUI/Button.hpp>
+#include <SFGUI/ComboBox.hpp>
+#include <SFGUI/Entry.hpp>
+#include <SFGUI/ListBox.hpp>
+#include <SFGUI/Window.hpp>
+
+namespace sfg {
+
+class SFGUI_API FilePickerDialog : public Window {
+    public:
+        typedef std::shared_ptr<FilePickerDialog> Ptr; //!< Shared pointer.
+		typedef std::shared_ptr<const FilePickerDialog> PtrConst; //!< Shared pointer.
+
+        static Ptr Create( boost::filesystem::path initial_path );
+
+        sf::String GetSelectedPath() const;
+
+        static Signal::SignalID OnCancel;
+        static Signal::SignalID OnOk;
+
+    protected:
+        FilePickerDialog( boost::filesystem::path initial_path );
+
+    private:
+        sfg::Box::Ptr m_main_box;
+            sfg::Box::Ptr m_panel_box;
+                sfg::ListBox::Ptr m_locations_listbox;
+
+                sfg::Box::Ptr m_directory_box;
+                    sfg::Box::Ptr m_directory_entry_box;
+                        sfg::Button::Ptr m_new_directory_button;
+                        sfg::Entry::Ptr m_current_directory_entry;
+                    sfg::ListBox::Ptr m_directory_paths_listbox;
+
+                    sfg::Box::Ptr m_filename_box;
+                        sfg::Entry::Ptr m_filename_entry;
+
+            sfg::Box::Ptr m_buttons_box;
+                sfg::Button::Ptr m_ok_button;
+                sfg::Button::Ptr m_cancel_button;
+
+        boost::filesystem::path m_current_path;
+
+        bool m_show_hidden_files;
+
+        void UpdateLocationsPaths();
+        void UpdateCurrentDirectoryPath();
+        void UpdateDirectoryPaths();
+        void UpdateOkButtonState();
+
+        void CancelDialog();
+        void OkDialog();
+
+        void OnLocationsListBoxSelectionChanged();
+        void OnCurrentDirectoryEntryTextChanged();
+        void OnPathsListBoxSelectionChanged();
+        void OnFilenameEntryTextChanged();
+};
+
+}
+
+#endif
diff --git a/include/SFGUI/ListBox.hpp b/include/SFGUI/ListBox.hpp
new file mode 100644
index 00000000..76be28a3
--- /dev/null
+++ b/include/SFGUI/ListBox.hpp
@@ -0,0 +1,152 @@
+#pragma once
+
+#include <SFGUI/Container.hpp>
+#include <SFGUI/Scrollbar.hpp>
+
+#include <SFML/Graphics/Image.hpp>
+#include <SFML/System/String.hpp>
+
+#include <initializer_list>
+#include <memory>
+#include <set>
+#include <vector>
+
+namespace sfg {
+
+class SFGUI_API ListBox : public Container {
+	public:
+
+		struct Item {
+			sf::String text;
+			sf::Image image;
+		};
+
+		typedef std::shared_ptr<ListBox> Ptr; //!< Shared pointer.
+		typedef std::shared_ptr<const ListBox> PtrConst; //!< Shared pointer.
+		typedef int IndexType;
+
+		static const IndexType NONE;
+
+		enum class SelectionMode : char {
+			NO_SELECTION,
+			SINGLE_SELECTION,
+			MULTI_SELECTION,
+			DEFAULT = SINGLE_SELECTION
+		};
+
+		enum class ScrollbarPolicy : char {
+			VERTICAL_ALWAYS,
+			VERTICAL_AUTOMATIC,
+			VERTICAL_NEVER,
+			DEFAULT = VERTICAL_AUTOMATIC
+		};
+
+		enum class ItemTextPolicy : char {
+			RESIZE_LISTBOX,
+			SHRINK,
+			DEFAULT = RESIZE_LISTBOX
+		};
+
+		/** Create listbox.
+		 * @return ListBox.
+		 */
+		static Ptr Create(  );
+
+		const std::string& GetName() const override;
+
+		void AppendItem( const sf::String& str, const sf::Image& image = sf::Image() );
+		void InsertItem( IndexType index, const sf::String& str, const sf::Image& image = sf::Image() );
+		void PrependItem( const sf::String& str, const sf::Image& image = sf::Image() );
+		void ChangeItemText( IndexType index, const sf::String& str );
+		void ChangeItemImage( IndexType index, const sf::Image& image );
+		void RemoveItem( IndexType index );
+		void Clear();
+
+		IndexType GetItemsCount() const;
+		const sf::String& GetItemText( IndexType index ) const;
+		const sf::String& GetDisplayedItemText( IndexType index ) const;
+		const sf::Image& GetItemImage( IndexType index ) const;
+
+		IndexType GetHighlightedItem() const;
+
+		void SetSelection( IndexType index );
+		void SetSelection( std::initializer_list<IndexType> indices );
+		void AppendToSelection( IndexType index );
+		void RemoveFromSelection( IndexType index );
+		void ClearSelection();
+
+		bool IsItemSelected( IndexType index ) const;
+        IndexType GetSelectedItemsCount() const;
+		IndexType GetSelectedItemIndex( IndexType index = 0 ) const;
+		const sf::String& GetSelectedItemText( IndexType index = 0 ) const;
+
+		IndexType GetFirstDisplayedItemIndex() const;
+		IndexType GetDisplayedItemsCount() const;
+		IndexType GetMaxDisplayedItemsCount() const;
+
+		SelectionMode GetSelectionMode() const;
+		void SetSelectionMode( SelectionMode mode );
+
+		ScrollbarPolicy GetScrollbarPolicy() const;
+		void SetScrollbarPolicy( ScrollbarPolicy policy );
+
+		ItemTextPolicy GetItemTextPolicy() const;
+		void SetItemTextPolicy( ItemTextPolicy policy );
+
+		sf::Vector2f GetImagesSize() const;
+		void SetImagesSize(sf::Vector2f size);
+
+		float GetItemHeight() const;
+
+        // Signals.
+		static Signal::SignalID OnSelect; //!< Fired when an entry is selected.
+
+	protected:
+		/** Ctor.
+		 */
+		ListBox();
+
+		std::unique_ptr<RenderQueue> InvalidateImpl() const override;
+		sf::Vector2f CalculateRequisition() override;
+
+	private:
+        void HandleMouseEnter( int x, int y ) override;
+		void HandleMouseLeave( int x, int y ) override;
+		void HandleMouseMoveEvent( int x, int y ) override;
+		void HandleMouseButtonEvent( sf::Mouse::Button button, bool press, int x, int y ) override;
+		void HandleSizeChange() override;
+		bool HandleAdd( Widget::Ptr ) override;
+		void HandleRemove( Widget::Ptr ) override;
+
+		IndexType GetItemAt( float y ) const;
+
+		bool IsScrollbarVisible() const;
+
+		void UpdateDisplayedItems();
+		void UpdateScrollbarAdjustment();
+		void UpdateScrollbarAllocation();
+
+		void UpdateDisplayedItemsText();
+
+		void OnScrollbarChanged();
+
+		std::vector<Item> m_items;
+
+		SelectionMode m_selection_mode;
+		std::set<IndexType> m_selected_items;
+
+		IndexType m_highlighted_item;
+
+		IndexType m_first_displayed_item;
+		IndexType m_max_displayed_items_count;
+
+		Scrollbar::Ptr m_vertical_scrollbar;
+		ScrollbarPolicy m_scrollbar_policy;
+
+		ItemTextPolicy m_item_text_policy;
+		std::vector<sf::String> m_displayed_items_texts;
+
+		sf::Vector2f m_images_size;
+};
+
+}
diff --git a/include/SFGUI/ResizableImage.hpp b/include/SFGUI/ResizableImage.hpp
new file mode 100644
index 00000000..c8a5427b
--- /dev/null
+++ b/include/SFGUI/ResizableImage.hpp
@@ -0,0 +1,352 @@
+#pragma once
+
+#include <SFGUI/Image.hpp>
+#include <SFML/Graphics/RenderTexture.hpp>
+#include <SFML/Graphics/Sprite.hpp>
+#include <SFML/Graphics/Texture.hpp>
+
+namespace sfg
+{
+    /**
+    *   \brief An extension of sfg::Image with the ability to resize the image.
+    **/
+    class SFGUI_API ResizableImage : public Image
+    {
+    public:
+        typedef std::shared_ptr<ResizableImage> Ptr; //!< Shared pointer of ResizableImage
+        typedef std::shared_ptr<const ResizableImage> PtrConst; //!< Shared pointer of ResizableImage
+
+        /**
+        *   \brief Create new sfg::ResizableImage instance.
+        *
+        *   You have to create a new instance of ResizableImage by calling this static function.
+        *   Since SFGUI keeps tracking of created objects for You, so You don't have to hassle
+        *   with \c new and \c delete.
+        *
+        *   You will receive a shared pointer \c sfg::ResizableImage::Ptr to the new instance of ResizableImage
+        *   that You can use to access members of ResizableImage.
+        *
+        *   \code
+        *   sf::Image sfImage;
+        *   sfImage.loadFromFile( "image.png" );
+        *
+        *   // Create new instance and get a shared pointer
+        *   sfg::ResizableImage::Ptr resizableImage = sfg::ResizableImage::Create( sfImage );
+        *
+        *   // Now You can use the shared pointer
+        *   resizableImage->Resize( 100, 100 );
+        *   \endcode
+        *
+        *   \param image Source sf::Image. Empty sf::Image if not specified.
+        *   \return sfg::ResizableImage::Ptr, a shared pointer to the new instance of ResizableImage.
+        */
+        static Ptr Create(const sf::Image& image = sf::Image())
+        {
+            Ptr resizableImagePointer(new ResizableImage(image));
+            return resizableImagePointer;
+        }
+
+        /**
+        *   \brief Get the Widget's name.
+        *
+        *   Used by rendering engine to apply CSS like style to the Widget.
+        *
+        *   \return "ResizableImage" as std::string
+        */
+        virtual const std::string& GetName() const
+        {
+            static const std::string name("ResizableImage");
+            return name;
+        }
+
+        /**
+        *   \brief Dtor.
+        **/
+        ~ResizableImage()
+        {}
+
+        /**
+        *   \brief Set the original sf::Image that will be used for resizing.
+        *
+        *   It overwrites the old sf::Image.
+        *   If You want to resize the image, then You need to call Resize again,
+        *   otherwise the image will be displayed in full size.
+        *
+        *   \param image New sf::Image
+        *
+        *   \code
+        *   sf::Image newImage;
+        *   newImage.loadFromFile( "newImage.png" );
+        *
+        *   resizableImage->SetImage( newImage );
+        *   resizableImage->Resize( 100, 100 ); // Don't forget to call if You want it resized
+        *   \endcode
+        *
+        *   \see GetImage, GetResizedImage
+        **/
+        void SetImage(const sf::Image& image)
+        {
+            this->m_OriginalImage = image;
+            Image::SetImage(this->m_OriginalImage);
+        }
+
+        /**
+        *   \brief Get the associated sf::Image.
+        *
+        *   \return The original full size sf::Image used for resizing.
+        *
+        *   \code
+        *   // Get the original full size image
+        *   sf::Image sfImage = resizableImage->GetImage();
+        *   \endcode
+        *
+        *   \see GetResizedImage, SetImage
+        **/
+        const sf::Image& GetImage() const
+        {
+            return m_OriginalImage;
+        }
+
+        /**
+        *   \brief Get the generated resized sf::Image.
+        *
+        *   You can get the generated resized sf::Image by calling
+        *   GetResizedImage. If the Resize wasn't called, the
+        *   full size sf::Image will be returned, since You have
+        *   to call Resize first to generate the new resized sf::Image.
+        *
+        *   \return The generated resized sf::Image, if Resize was called.
+        *
+        *   \code
+        *   resizableImage->Resize( 100, 100 ); // Call Resize to generate the image
+        *   sf::Image resizedImage = resizableImage->GetResizedImage();
+        *   \endcode
+        *
+        *   \see GetImage, SetImage
+        **/
+        const sf::Image& GetResizedImage() const
+        {
+            return Image::GetImage();
+        }
+
+        /** Resize the image to a new size.
+         *  \param sizeX unsigned int
+         *  \param sizeY unsigned int
+         */
+        void Resize(const unsigned int sizeX, const unsigned int sizeY)
+        {
+            this->Resize(sf::Vector2u(sizeX, sizeY));
+        }
+
+        /**
+        *   \brief Resize the image to a new size.
+        *
+        *   Resize generates new sf::Image that will have the requested size. If no size is
+        *   given (or null size), original image size will be used.
+        *   Original sf::Image is _never_ modified. New sf::Image is created when resizing.
+        *
+        *   By default, aspect of the image is kept when resizing. Image is then centered inside
+        *   the specified area. If You want to stretch the image instead, You can call
+        *   SetKeepAspect with true parameter to change how the image will be generated.
+        *
+        *   You _need_ to call Resize to generate new image.
+        *
+        *   Resized image can be then retrieved by calling GetResizedImage.
+        *
+        *   \param customSize sf::Vector2u ( sizeX, sizeY ), if not specified, default ( 0, 0 )
+        *
+        *   \see GetImage, GetResizedImage, SetImage, SetKeepAspect, GetKeepAspect
+        */
+        void Resize(const sf::Vector2u& customSize = sf::Vector2u(0, 0))
+        {
+            // If no size is given (0,0) , use original image...
+            if (!customSize.x || !customSize.y)
+            {
+                Image::SetImage(m_OriginalImage);
+                return;
+            }
+
+            // Let the flood begin
+            float originalX = static_cast<float>(m_OriginalImage.getSize().x);
+            float originalY = static_cast<float>(m_OriginalImage.getSize().y);
+            float desiredX = static_cast<float>(customSize.x);
+            float desiredY = static_cast<float>(customSize.y);
+
+            // Compute the scale we will apply to image
+            float scaleX = desiredX / originalX;
+            float scaleY = desiredY / originalY;
+
+            // Get texture of the original image
+            sf::Texture tempTexture;
+            tempTexture.loadFromImage(m_OriginalImage);
+
+            // Sprite allows transformations to be made to it, so let's assign our texture to it
+            //      (warn: sprite doesn't own the texture, keep it alive till we're done)
+            sf::Sprite tempSprite;
+            tempSprite.setTexture(tempTexture, true);
+
+
+            if (m_KeepAspect)
+            {
+                // Use same scale for both sides of the sprite
+                float lowerScale = std::min(scaleX, scaleY);
+
+                tempSprite.scale(lowerScale, lowerScale);
+
+
+                // Since the image will not be stretched out because we want to keep the aspect of the
+                //  image, there will be an empty space to the right/down of the resized image. I think
+                //  it's better if the empty place is distributed around the resized image on all sides,
+                //  so we move the sprite to the center of the rectangle we set by size we want.
+                //
+                // Example
+                //           ###                                ###00
+                //           ###                                ###00
+                //           ###                                ###00
+                //           ###                                ###00
+                // image 5x3 ###  resize it to 5x5, keep aspect ###00 0=empty space only on one side
+                //
+                //
+                //                     0###0
+                //                     0###0
+                //                     0###0
+                //                     0###0
+                // so center the image 0###0 and now empty space is distributed to both sides
+
+                // Move the sprite to the center of the resized image
+                float offsetX = (desiredX - (originalX * (lowerScale))) / 2;
+                float offsetY = (desiredY - (originalY * (lowerScale))) / 2;
+
+                tempSprite.move(offsetX, offsetY);
+            }
+            else
+            {
+                tempSprite.scale(scaleX, scaleY);
+            }
+
+            // Transformations on Sprite are set, so we can pre-render the sprite on
+            //  a new texture with a transparent background
+            sf::RenderTexture tempRenderTexture;
+            tempRenderTexture.create(customSize.x, customSize.y);
+            tempRenderTexture.setSmooth(true);
+            tempRenderTexture.clear(sf::Color(255, 255, 255, 0));
+            tempRenderTexture.draw(tempSprite);
+            tempRenderTexture.display();
+
+            // Now when we have the new texture with our resized image ready
+            //  we can set it as a new image to the underlying base Image
+            //  class, and we are done.
+            Image::SetImage(tempRenderTexture.getTexture().copyToImage());
+        }
+
+        /**
+        *   \brief Should aspect of image be kept when resizing of image?
+        *
+        *   Set true, if aspect should be kept, or false if image should be stretched to given size.
+        *   You should set this before calling Resize.
+        *
+        *   \param value bool value, true if You want to keep aspect, false if You want the image stretched.
+        *
+        *   \code
+        *   // Set You want to stretch the image, and remember to call Resize
+        *   resizableImage->SetKeepAspect( false );
+        *   resizableImage->Resize( 100, 100 );
+        *   \endcode
+        *
+        *   \see GetKeepAspect, Resize
+        **/
+        void SetKeepAspect(const bool& value = true)
+        {
+            this->m_KeepAspect = value;
+        }
+
+        /**
+        *   \brief Get whether aspect of image is kept when resizing of image.
+        *
+        *   \param True if aspect of image is kept, false if image is stretched.
+        *
+        *   \see SetKeepAspect, Resize
+        **/
+        const bool GetKeepAspect() const
+        {
+            return this->m_KeepAspect;
+        }
+
+    protected:
+        /**
+        *   \brief Construct sfg::ResizableImage from a source sf::Image.
+        *
+        *   We want to disallow instantiation.
+        *   SFGUI keeps track of it's objects with shared pointers.
+        *
+        *   \param image Existing sf::Image, or if not specified then default empty sf::Image.
+        **/
+        ResizableImage(const sf::Image& image = sf::Image())
+        {
+            m_OriginalImage = image;
+            this->SetImage(image);
+        }
+
+    private:
+        sf::Image m_OriginalImage;      //!< Original unmodified sf::Image.
+        bool m_KeepAspect = { true };   //!< Whether we want to keep aspect of image when resizing.
+
+    }; // class ResizableImage
+} // namespace sfg
+
+/**
+*   \class sfg::ResizableImage
+*
+*   sfg::ResizableImage is a class that allows to easily resize
+*   an image and display it.
+*
+*   It inherits all the functions from sfg::Image and adds property
+*   to specify if You want to keep aspect of an image, when resizing
+*   the image, and function to perform the resizing of the image.
+*
+*   Resizing of the image is done only when the Resize function is
+*   called. If Resize function isn't called, the image will remain
+*   in it's original size.
+*
+*   The sf::Image You assign to the sfg::ResizableImage is _never_
+*   modified. When You perform resizing, a new sf::Image is created
+*   and displayed. You can retrieve the resized image with
+*   GetResizedImage function. GetImage will return the original image.
+*
+*   Please note that the resize is done with a really simple method
+*   of applying transformations in OpenGL. Don't expect great quality.
+*   If You need great quality, You may need to implement better algorithm
+*   or use sf::Shader.
+*
+*   Resizing of a large image or alot of images can be lengthy. Use
+*   proper caching method to speed up the loading of Your images.
+*   If You want to save the image after resizing, You can use the
+*   GetResizedImage().saveToFile( fileName ) function.
+*
+*   Usage example:
+*   \code
+*   // Declare and load sf::Image
+*   sf::Image sfImage;
+*   sfImage.loadFromFile( "image.png" ); // 132x68 px size
+*
+*   // Get shared pointer of new sfg::ResizableImage
+*   sfg::ResizableImage::Ptr image = sfg::ResizableImage::Create( sfImage );
+*
+*   // If You don't want to keep the aspect of the image, You may set false. Default is true.
+*   // image->SetKeepAspect( false );
+*
+*   // Perform resizing
+*   image->Resize( 100, 100 );
+*
+*   // Add it to Your layout
+*   box->Pack( image );
+*   window->Add( box );
+*   desktop.Add( window );
+*
+*   // Draw
+*   desktop.Update( .0f ); // You shouldn't pass 0.0 to update function.
+*   m_SFGUI.Display( renderWindow );
+*   \endcode
+*
+*   \see sfg::Image, sf::Image
+**/
diff --git a/include/SFGUI/Widget.hpp b/include/SFGUI/Widget.hpp
index cabeafb2..d8a9ff9b 100644
--- a/include/SFGUI/Widget.hpp
+++ b/include/SFGUI/Widget.hpp
@@ -273,6 +273,16 @@ class SFGUI_API Widget : public Object, public std::enable_shared_from_this<Widg
 		 */
 		static bool HasModal();
 
+		/** Check if a widget has focus.
+		 * @param widget Checked widget.
+		 * @return true if widget has focus.
+		 */
+		static bool HasFocus(PtrConst widget);
+
+		/** Remove focus from focused widget.
+		 */
+		static void LoseFocus();
+
 		// Signals.
 		static Signal::SignalID OnStateChange; //!< Fired when state changed.
 		static Signal::SignalID OnGainFocus; //!< Fired when focus gained.
@@ -428,12 +438,6 @@ class SFGUI_API Widget : public Object, public std::enable_shared_from_this<Widg
 		 */
 		static void GrabFocus( Ptr widget );
 
-		/** Check if a widget has focus.
-		 * @param widget Checked widget.
-		 * @return true if widget has focus.
-		 */
-		static bool HasFocus( PtrConst widget );
-
 		/** Set this widget as the current modal widget.
 		 * Consumes all events.
 		 */
diff --git a/include/SFGUI/Widgets.hpp b/include/SFGUI/Widgets.hpp
index 45774997..7470a600 100644
--- a/include/SFGUI/Widgets.hpp
+++ b/include/SFGUI/Widgets.hpp
@@ -15,15 +15,18 @@
 #include <SFGUI/Desktop.hpp>
 #include <SFGUI/Engine.hpp>
 #include <SFGUI/Entry.hpp>
+#include <SFGUI/FilePickerDialog.hpp>
 #include <SFGUI/Fixed.hpp>
 #include <SFGUI/Frame.hpp>
 #include <SFGUI/Image.hpp>
 #include <SFGUI/Label.hpp>
+#include <SFGUI/ListBox.hpp>
 #include <SFGUI/Notebook.hpp>
 #include <SFGUI/ProgressBar.hpp>
 #include <SFGUI/RadioButton.hpp>
 #include <SFGUI/Range.hpp>
 #include <SFGUI/Renderer.hpp>
+#include <SFGUI/ResizableImage.hpp>
 #include <SFGUI/Scale.hpp>
 #include <SFGUI/Scrollbar.hpp>
 #include <SFGUI/ScrolledWindow.hpp>
diff --git a/src/SFGUI/Button.cpp b/src/SFGUI/Button.cpp
index 4d992218..7e89123e 100644
--- a/src/SFGUI/Button.cpp
+++ b/src/SFGUI/Button.cpp
@@ -9,6 +9,7 @@ namespace sfg {
 Button::Ptr Button::Create( const sf::String& label ) {
 	auto ptr = Ptr( new Button );
 	ptr->SetLabel( label );
+	ptr->SetAlignment(Alignment::CENTER);
 	return ptr;
 }
 
@@ -26,7 +27,7 @@ const sf::String& Button::GetLabel() const {
 	return m_label;
 }
 
-void Button::SetImage( Image::Ptr image ) {
+void Button::SetImage( std::shared_ptr<Image> image ) {
 	ClearImage();
 	Add( image );
 }
@@ -104,8 +105,18 @@ const std::string& Button::GetName() const {
 	return name;
 }
 
+void Button::SetAlignment(Button::Alignment alignment)
+{
+	m_alignment = alignment;
+}
+
+const Button::Alignment& Button::GetAlignment() const
+{
+	return m_alignment;
+}
+
 bool Button::HandleAdd( Widget::Ptr child ) {
-	if( child && child->GetName() != "Image" ) {
+	if( child && child->GetName() != "Image" && child->GetName() != "ResizableImage") {
 #if defined( SFGUI_DEBUG )
 		std::cerr << "SFGUI warning: Only an Image can be added to a Button.\n";
 #endif
@@ -151,3 +162,8 @@ void Button::HandleStateChange( State old_state ) {
 }
 
 }
+
+sfg::Button::Alignment operator|(sfg::Button::Alignment a, sfg::Button::Alignment b)
+{
+	return (sfg::Button::Alignment)(((int)a) | ((int)b));
+}
diff --git a/src/SFGUI/Container.cpp b/src/SFGUI/Container.cpp
index 9150edde..fa6e2336 100644
--- a/src/SFGUI/Container.cpp
+++ b/src/SFGUI/Container.cpp
@@ -74,9 +74,25 @@ void Container::HandleEvent( const sf::Event& event ) {
 		local_event.mouseButton.y -= static_cast<int>( GetAllocation().top );
 	}
 
+	bool children_lost_focus = false;
+
 	// Pass event to children.
 	for( const auto& child : m_children ) {
 		child->HandleEvent( local_event );
+		if (event.type == sf::Event::MouseButtonPressed) {
+			if (children_lost_focus) {
+				if (static_cast<const Container*>(&*child)->Widget::IsMouseInWidget()) {
+					children_lost_focus = false;
+				}
+			}
+			else if (child->HasFocus() && !(static_cast<const Container*>(&*child)->Widget::IsMouseInWidget())) {
+				children_lost_focus = true;
+			}
+		}
+	}
+
+	if (children_lost_focus) {
+		GrabFocus();
 	}
 
 	// Process event for own widget.
diff --git a/src/SFGUI/Desktop.cpp b/src/SFGUI/Desktop.cpp
index 2214101d..15629b5a 100644
--- a/src/SFGUI/Desktop.cpp
+++ b/src/SFGUI/Desktop.cpp
@@ -25,6 +25,7 @@ void Desktop::HandleEvent( const sf::Event& event ) {
 	Context::Activate( m_context );
 
 	sf::Vector2f position;
+	bool any_inside( false );
 	bool check_inside( false );
 	Widget::Ptr last_receiver( m_last_receiver.lock() );
 
@@ -51,6 +52,9 @@ void Desktop::HandleEvent( const sf::Event& event ) {
 		}
 
 		bool is_inside( widget->GetAllocation().contains( position ) );
+		if (is_inside) {
+			any_inside = true;
+		}
 
 		// If the event is a mouse button press, check if we need to focus another widget.
 		// If there is a modal widget, skip reordering.
@@ -93,6 +97,10 @@ void Desktop::HandleEvent( const sf::Event& event ) {
 		}
 	}
 
+	if (event.type == sf::Event::MouseButtonPressed && !any_inside) {
+		Widget::LoseFocus();
+	}
+
 	// Restore previous context.
 	Context::Deactivate();
 }
@@ -203,6 +211,11 @@ void Desktop::BringToFront( std::shared_ptr<const Widget> child ) {
 	}
 }
 
+bool Desktop::IsAnyWidgetFocused()
+{
+	return !Widget::HasFocus(NULL);
+}
+
 void Desktop::SendFakeMouseMoveEvent( std::shared_ptr<Widget> widget, int x, int y ) const {
 	sf::Event fake_event;
 	fake_event.type = sf::Event::MouseMoved;
diff --git a/src/SFGUI/Engines/BREW.cpp b/src/SFGUI/Engines/BREW.cpp
index a221c1ed..50c5d8d9 100644
--- a/src/SFGUI/Engines/BREW.cpp
+++ b/src/SFGUI/Engines/BREW.cpp
@@ -82,6 +82,9 @@ void BREW::ResetProperties() {
 	// Entry-specific.
 	SetProperty( "Entry", "BackgroundColor", sf::Color( 0x5e, 0x5e, 0x5e ) );
 	SetProperty( "Entry", "Color", sf::Color::White );
+	SetProperty( "Entry", "SelectionColor", sf::Color::White );
+	SetProperty( "Entry", "SelectedTextColor", sf::Color::Black );
+	SetProperty( "Entry:PRELIGHT", "BackgroundColor", sf::Color(0x68, 0x68, 0x68));
 
 	// Scale-specific.
 	SetProperty( "Scale", "SliderColor", sf::Color( 0x68, 0x6a, 0x65 ) );
@@ -153,6 +156,12 @@ void BREW::ResetProperties() {
 	SetProperty( "SpinButton", "StepperSpeed", 10.f );
 	SetProperty( "SpinButton", "StepperRepeatDelay", 500 );
 
+	// ListBox-specific.
+	SetProperty( "ListBox", "BackgroundColor", sf::Color( 0x5e, 0x5e, 0x5e ) );
+	SetProperty( "ListBox", "Color", sf::Color::White );
+	SetProperty( "ListBox", "HighlightedColor", sf::Color( 0x65, 0x67, 0x62 ) );
+	SetProperty( "ListBox", "SelectedColor", sf::Color( 0x5a, 0x6a, 0x50 ) );
+
 	// (Re)Enable automatic widget refreshing after we are done setting all these properties.
 	SetAutoRefresh( true );
 }
diff --git a/src/SFGUI/Engines/BREW/Button.cpp b/src/SFGUI/Engines/BREW/Button.cpp
index a5d4d271..c981f26e 100644
--- a/src/SFGUI/Engines/BREW/Button.cpp
+++ b/src/SFGUI/Engines/BREW/Button.cpp
@@ -45,22 +45,45 @@ std::unique_ptr<RenderQueue> BREW::CreateButtonDrawable( std::shared_ptr<const B
 		sf::Text text( button->GetLabel(), *font, font_size );
 		auto offset = ( button->GetState() == Button::State::ACTIVE ) ? border_width : 0.f;
 		sfg::Widget::PtrConst child( button->GetChild() );
+		const Button::Alignment& alignment = button->GetAlignment();
+		sf::Vector2f nPosition;
+		nPosition.y = button->GetAllocation().height / 2.f;
+
+		switch (alignment & Button::Alignment::VERTICAL) {
+		case Button::Alignment::TOP:
+			nPosition.y += offset - button->GetAllocation().height / 2.f + spacing;
+			break;
+		case Button::Alignment::BOTTOM:
+			nPosition.y -= metrics.y + offset - button->GetAllocation().height / 2.f + spacing;
+			break;
+		default:
+			nPosition.y -= metrics.y / 2.f - offset + 1.f;
+			break;
+		}
 
 		if( !child ) {
-			text.setPosition(
-				button->GetAllocation().width / 2.f - metrics.x / 2.f + offset,
-				button->GetAllocation().height / 2.f - metrics.y / 2.f + offset
-			);
+			nPosition.x = button->GetAllocation().width / 2.f;
 		}
 		else {
-			float width( button->GetAllocation().width - spacing - child->GetAllocation().width );
+			float width(button->GetAllocation().width - spacing - child->GetAllocation().width);
+			nPosition.x = child->GetAllocation().width + spacing + width / 2.f;
+		}
 
-			text.setPosition(
-				child->GetAllocation().width + spacing + (width / 2.f - metrics.x / 2.f) + offset,
-				button->GetAllocation().height / 2.f - metrics.y / 2.f + offset
-			);
+		switch (alignment & Button::Alignment::HORIZONTAL) {
+		case Button::Alignment::LEFT:
+			nPosition.x += offset - button->GetAllocation().width / 2.f + spacing;
+			if (child) nPosition.x += child->GetAllocation().width / 2.f + spacing;
+			break;
+		case Button::Alignment::RIGHT:
+			nPosition.x -= metrics.x + offset - button->GetAllocation().width / 2.f + spacing;
+			if (child) nPosition.x -= child->GetAllocation().width / 2.f + spacing;
+			break;
+		default:
+			nPosition.x -= metrics.x / 2.f - offset;
+			break;
 		}
 
+		text.setPosition(nPosition.x, nPosition.y);
 		text.setFillColor( color );
 		queue->Add( Renderer::Get().CreateText( text ) );
 	}
diff --git a/src/SFGUI/Engines/BREW/Entry.cpp b/src/SFGUI/Engines/BREW/Entry.cpp
index 40c7b28d..0d84c4c9 100644
--- a/src/SFGUI/Engines/BREW/Entry.cpp
+++ b/src/SFGUI/Engines/BREW/Entry.cpp
@@ -13,6 +13,8 @@ std::unique_ptr<RenderQueue> BREW::CreateEntryDrawable( std::shared_ptr<const En
 	auto background_color = GetProperty<sf::Color>( "BackgroundColor", entry );
 	auto text_color = GetProperty<sf::Color>( "Color", entry );
 	auto cursor_color = GetProperty<sf::Color>( "Color", entry );
+	auto selection_color = GetProperty<sf::Color>( "SelectionColor", entry );
+	auto selected_text_color = GetProperty<sf::Color>( "SelectedTextColor", entry );
 	auto text_padding = GetProperty<float>( "Padding", entry );
 	auto cursor_thickness = GetProperty<float>( "Thickness", entry );
 	auto border_width = GetProperty<float>( "BorderWidth", entry );
@@ -42,11 +44,13 @@ std::unique_ptr<RenderQueue> BREW::CreateEntryDrawable( std::shared_ptr<const En
 
 	queue->Add( Renderer::Get().CreateText( vis_label ) );
 
+	int visibleOffset = entry->GetVisibleOffset();
+
 	// Draw cursor if entry is active and cursor is visible.
 	if( entry->HasFocus() && entry->IsCursorVisible() ) {
 		sf::String cursor_string( entry->GetVisibleText() );
-		if( entry->GetCursorPosition() - entry->GetVisibleOffset() < static_cast<int>( cursor_string.getSize() ) ) {
-			cursor_string.erase( static_cast<std::size_t>( entry->GetCursorPosition() - entry->GetVisibleOffset() ), cursor_string.getSize() );
+		if( entry->GetCursorPosition() - visibleOffset < static_cast<int>( cursor_string.getSize() ) ) {
+			cursor_string.erase( static_cast<std::size_t>( entry->GetCursorPosition() - visibleOffset), cursor_string.getSize() );
 		}
 
 		// Get metrics.
@@ -65,6 +69,45 @@ std::unique_ptr<RenderQueue> BREW::CreateEntryDrawable( std::shared_ptr<const En
 		);
 	}
 
+	// Draw selection if entry is active and any side of selection is visible.
+	if (entry->HasFocus()) {
+		int left, right;
+		entry->GetSelectionBounds(left, right);
+
+		if (left != right) {
+			int visibleLength = entry->GetVisibleLength();
+
+			left = std::max(left, visibleOffset);
+			right = std::min(right, visibleLength);
+
+			if (left != right) {
+				const sf::String& visibleText = entry->GetVisibleText();
+				std::string pre_selection_str(visibleText.begin(), visibleText.begin() + left);
+				std::string selection_str(visibleText.begin() + left, visibleText.begin() + right);
+				sf::Vector2f pre_selection_metrics(GetTextStringMetrics(pre_selection_str, *font, font_size));
+				sf::Vector2f selection_metrics(GetTextStringMetrics(selection_str, *font, font_size));
+
+				queue->Add(
+					Renderer::Get().CreateRect(
+						sf::FloatRect(
+							pre_selection_metrics.x + text_padding,
+							entry->GetAllocation().height / 2.f - line_height / 2.f,
+							selection_metrics.x,
+							line_height
+						),
+						selection_color
+					)
+				);
+
+				sf::Text selection_label(selection_str, *font, font_size);
+				selection_label.setFillColor(selected_text_color);
+				selection_label.setPosition(pre_selection_metrics.x + text_padding, entry->GetAllocation().height / 2.f - line_height / 2.f);
+
+				queue->Add(Renderer::Get().CreateText(selection_label));
+			}
+		}
+	}
+
 	return queue;
 }
 
diff --git a/src/SFGUI/Engines/BREW/ListBox.cpp b/src/SFGUI/Engines/BREW/ListBox.cpp
new file mode 100644
index 00000000..907de834
--- /dev/null
+++ b/src/SFGUI/Engines/BREW/ListBox.cpp
@@ -0,0 +1,109 @@
+#include <SFGUI/Engines/BREW.hpp>
+#include <SFGUI/Renderer.hpp>
+#include <SFGUI/ListBox.hpp>
+#include <SFGUI/RenderQueue.hpp>
+
+#include <SFML/Graphics/Text.hpp>
+
+namespace sfg {
+namespace eng {
+
+std::unique_ptr<RenderQueue> BREW::CreateListBoxDrawable( std::shared_ptr<const ListBox> listbox ) const {
+    auto border_color = GetProperty<sf::Color>( "BorderColor", listbox );
+	auto background_color = GetProperty<sf::Color>( "BackgroundColor", listbox );
+    auto highlighted_color = GetProperty<sf::Color>( "HighlightedColor", listbox );
+    auto selected_color = GetProperty<sf::Color>( "SelectedColor", listbox );
+	auto text_color = GetProperty<sf::Color>( "Color", listbox );
+	auto text_padding = GetProperty<float>( "Padding", listbox );
+	auto border_width = GetProperty<float>( "BorderWidth", listbox );
+	auto border_color_shift = GetProperty<int>( "BorderColorShift", listbox );
+	const auto& font_name = GetProperty<std::string>( "FontName", listbox );
+	const auto& font = GetResourceManager().GetFont( font_name );
+	auto font_size = GetProperty<unsigned int>( "FontSize", listbox );
+
+    std::unique_ptr<RenderQueue> queue( new RenderQueue );
+
+    // Pane.
+	queue->Add(
+		Renderer::Get().CreatePane(
+			sf::Vector2f( 0.f, 0.f ),
+			sf::Vector2f( listbox->GetAllocation().width, listbox->GetAllocation().height ),
+			border_width,
+			background_color,
+			border_color,
+			-border_color_shift
+		)
+	);
+
+    // Items.
+    sf::Vector2f itemPosition = sf::Vector2f( border_width + text_padding, border_width + text_padding );
+    for( ListBox::IndexType i = listbox->GetFirstDisplayedItemIndex();
+        i < std::min(listbox->GetFirstDisplayedItemIndex() + listbox->GetMaxDisplayedItemsCount(), listbox->GetItemsCount());
+        ++i ) {
+        auto& itemText = listbox->GetDisplayedItemText( i );
+
+        auto metrics = GetTextStringMetrics( itemText, *font, font_size );
+		metrics.y = GetFontLineHeight( *font, font_size ); // Text only size
+
+        auto item_height = listbox->GetItemHeight(); // Height of an item (including the image)
+
+        sf::Text text( itemText, *font, font_size );
+        text.setPosition(
+            itemPosition.x + ( listbox->GetImagesSize() != sf::Vector2f() ? text_padding + listbox->GetImagesSize().x : 0.f ),
+            itemPosition.y + item_height/2.f - metrics.y / 2.f
+        );
+        text.setFillColor(text_color);
+
+        if( listbox->IsItemSelected( i ) ) {
+            queue->Add(
+                Renderer::Get().CreateRect(
+                    sf::FloatRect(
+                        itemPosition.x - text_padding,
+                        itemPosition.y - text_padding,
+                        listbox->GetAllocation().width - 2 * border_width,
+                        std::min(item_height + text_padding * 2, listbox->GetAllocation().height - (itemPosition.y - text_padding) - border_width)
+                        // Avoid the selection box to go further than the widget's height when the last displayed item padding space is not fully displayed.
+                    ),
+                    selected_color
+                )
+            );
+        } else if( i == listbox->GetHighlightedItem() ) {
+            queue->Add(
+                Renderer::Get().CreateRect(
+                    sf::FloatRect(
+                        itemPosition.x - text_padding,
+                        itemPosition.y - text_padding,
+                        listbox->GetAllocation().width - 2 * border_width,
+                        std::min(item_height + text_padding * 2, listbox->GetAllocation().height - (itemPosition.y - text_padding) - border_width)
+                        // Avoid the highlight box to go further than the widget's height when the last displayed item padding space is not fully displayed.
+                    ),
+                    highlighted_color
+                )
+            );
+        }
+
+        if( listbox->GetImagesSize() != sf::Vector2f() && listbox->GetItemImage( i ).getSize() != sf::Vector2u() ) {
+            auto texture = Renderer::Get().LoadTexture( listbox->GetItemImage( i ) );
+            queue->Add(
+        		Renderer::Get().CreateSprite(
+        			sf::FloatRect(
+        				itemPosition.x,
+        				itemPosition.y,
+        				listbox->GetImagesSize().x,
+        				listbox->GetImagesSize().y
+        			),
+        			texture
+        		)
+        	);
+        }
+
+        queue->Add( Renderer::Get().CreateText(text) );
+
+        itemPosition += sf::Vector2f( 0.f, item_height + text_padding * 2 );
+    }
+
+    return queue;
+}
+
+}
+}
diff --git a/src/SFGUI/Entry.cpp b/src/SFGUI/Entry.cpp
index a1153843..510721f0 100644
--- a/src/SFGUI/Entry.cpp
+++ b/src/SFGUI/Entry.cpp
@@ -4,12 +4,14 @@
 #include <SFGUI/Engine.hpp>
 
 #include <SFML/Graphics/Font.hpp>
+#include <SFML/Window/Clipboard.hpp>
 #include <cmath>
 
 namespace sfg {
 
 // Signals.
 Signal::SignalID Entry::OnTextChanged = 0;
+Signal::SignalID Entry::OnReturnPressed = 0;
 
 Entry::Entry() :
 	m_string(),
@@ -18,6 +20,7 @@ Entry::Entry() :
 	m_text_placeholder( 0 ),
 	m_max_length( 0 ),
 	m_cursor_position( 0 ),
+	m_cursor_selection_start( 0 ),
 	m_elapsed_time( 0.f ),
 	m_text_margin( 0.f ),
 	m_cursor_status( false )
@@ -160,14 +163,25 @@ void Entry::MoveCursor( int delta ) {
 }
 
 void Entry::HandleTextEvent( sf::Uint32 character ) {
-	if( m_max_length > 0 && static_cast<int>( m_string.getSize() ) >= m_max_length ) {
+	int left, right;
+	GetSelectionBounds(left, right);
+
+	if( m_max_length > 0 && left == right && static_cast<int>( m_string.getSize() ) >= m_max_length ) {
 		return;
 	}
 
 	if( character > 0x1f && character != 0x7f ) {
 		// not a control character
+		if (left != right) {
+			m_string.erase(static_cast<std::size_t>(left), static_cast<std::size_t>(right - left));
+			if (m_cursor_position == right) {
+				m_cursor_position -= right - left;
+			}
+		}
+
 		m_string.insert( static_cast<std::size_t>( m_cursor_position ), character );
 		MoveCursor( 1 );
+		m_cursor_selection_start = m_cursor_position;
 
 		GetSignals().Emit( OnTextChanged );
 	}
@@ -179,14 +193,80 @@ void Entry::HandleKeyEvent( sf::Keyboard::Key key, bool press ) {
 	}
 
 	switch( key ) {
-	case sf::Keyboard::BackSpace: { // backspace
-		if( ( m_string.getSize() > 0 ) && ( m_cursor_position > 0 ) ) {
-			m_string.erase( static_cast<std::size_t>( m_cursor_position - 1 ) );
+	case sf::Keyboard::A: {
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl)) {
+			m_cursor_selection_start = 0;
+			size_t end = m_string.getSize();
 
+			if (m_cursor_position == end) {
+				m_cursor_position = 0; // make sure that is gets updated
+			}
+			SetCursorPosition(end);
+		}
+	} break;
+	case sf::Keyboard::C: {
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl)) {
+			int left, right;
+			GetSelectionBounds(left, right);
+
+			if (left != right) {
+				sf::Clipboard::setString(GetSelectedText());
+			}
+		}
+	} break;
+	case sf::Keyboard::V: {
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl)) {
+			int left, right;
+			GetSelectionBounds(left, right);
+			const sf::String& str = sf::Clipboard::getString();
+
+			if (!str.isEmpty()) {
+				sf::String left_substr = m_string.substring(0, left);
+				sf::String right_substr = m_string.substring(right, m_string.getSize() - right);
+
+				SetText(left_substr + str + right_substr);
+				SetCursorPosition(left_substr.getSize() + str.getSize());
+				m_cursor_selection_start = m_cursor_position;
+			}
+		}
+	} break;
+	case sf::Keyboard::X: {
+		if (sf::Keyboard::isKeyPressed(sf::Keyboard::LControl)) {
+			int left, right;
+			GetSelectionBounds(left, right);
+
+			if (left != right) {
+				sf::String selected = GetSelectedText();
+				sf::Clipboard::setString(selected);
+				sf::String left_substr = m_string.substring(0, left);
+				sf::String right_substr = m_string.substring(right, m_string.getSize() - right);
+
+				SetText(left_substr + right_substr);
+				SetCursorPosition(left_substr.getSize());
+				m_cursor_selection_start = m_cursor_position;
+			}
+		}
+	} break;
+	case sf::Keyboard::BackSpace: { // backspace
+		if( ( m_string.getSize() > 0 ) && ( m_cursor_position > 0 || m_cursor_selection_start > 0 ) ) {
 			// Store old number of visible characters.
 			auto old_num_visible_chars = m_visible_string.getSize();
 
-			MoveCursor( -1 );
+			int left, right;
+			GetSelectionBounds(left, right);
+
+			if (left == right) {
+				m_string.erase(static_cast<std::size_t>(left - 1));
+				MoveCursor(-1);
+			}
+			else {
+				m_string.erase(static_cast<std::size_t>(left), static_cast<std::size_t>(right - left));
+				if (m_cursor_position == right) {
+					MoveCursor(left - right);
+				}
+			}
+			m_cursor_selection_start = m_cursor_position;
+
 			RecalculateVisibleString();
 
 			// If new amount of chars is less and we have some chars in front, go
@@ -203,12 +283,24 @@ void Entry::HandleKeyEvent( sf::Keyboard::Key key, bool press ) {
 		}
 	} break;
 	case sf::Keyboard::Delete: {
-		if( ( m_string.getSize() > 0 ) && ( m_cursor_position < static_cast<int>( m_string.getSize() ) ) ) {
-			m_string.erase( static_cast<std::size_t>( m_cursor_position ) );
-
+		if( ( m_string.getSize() > 0 ) && ( std::min(m_cursor_position, m_cursor_selection_start) < static_cast<int>( m_string.getSize() ) ) ) {
 			// Store old number of visible characters.
 			auto old_num_visible_chars = m_visible_string.getSize();
 
+			int left, right;
+			GetSelectionBounds(left, right);
+
+			if (left == right) {
+				m_string.erase(static_cast<std::size_t>(left));
+			}
+			else {
+				m_string.erase(static_cast<std::size_t>(left), static_cast<std::size_t>(right - left));
+				if (m_cursor_position == right) {
+					MoveCursor(left - right);
+				}
+			}
+			m_cursor_selection_start = m_cursor_position;
+
 			RecalculateVisibleString();
 
 			// If new amount of chars is less and we have some chars in front, go
@@ -229,18 +321,33 @@ void Entry::HandleKeyEvent( sf::Keyboard::Key key, bool press ) {
 			m_visible_offset = 0;
 			SetCursorPosition( 0 );
 		}
+		if (!sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LShift)) {
+			m_cursor_selection_start = m_cursor_position;
+		}
 	} break;
 	case sf::Keyboard::End: {
 		if( m_string.getSize() > 0 ) {
 			m_visible_offset = 0;
 			SetCursorPosition( static_cast<int>( m_string.getSize() ) );
 		}
+		if (!sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LShift)) {
+			m_cursor_selection_start = m_cursor_position;
+		}
 	} break;
 	case sf::Keyboard::Left: {
 		MoveCursor( -1 );
+		if (!sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LShift)) {
+			m_cursor_selection_start = m_cursor_position;
+		}
 	} break;
 	case sf::Keyboard::Right: {
 		MoveCursor( 1 );
+		if (!sf::Keyboard::isKeyPressed(sf::Keyboard::Key::LShift)) {
+			m_cursor_selection_start = m_cursor_position;
+		}
+	} break;
+	case sf::Keyboard::Return: {
+		GetSignals().Emit( OnReturnPressed );
 	} break;
 	default: break;
 	}
@@ -258,8 +365,15 @@ void Entry::HandleMouseLeave( int /*x*/, int /*y*/ ) {
 	}
 }
 
+void Entry::HandleMouseMoveEvent(int x, int y)
+{
+	if (sf::Mouse::isButtonPressed(sf::Mouse::Button::Left)) {
+		SetCursorPosition(GetPositionFromMouseX(x));
+	}
+}
+
 void Entry::HandleMouseButtonEvent( sf::Mouse::Button button, bool press, int x, int /*y*/ ) {
-	if( !press || !IsMouseInWidget() ) {
+	if( !IsMouseInWidget() ) {
 		return;
 	}
 
@@ -268,8 +382,14 @@ void Entry::HandleMouseButtonEvent( sf::Mouse::Button button, bool press, int x,
 		return;
 	}
 
-	GrabFocus();
-	SetCursorPosition( GetPositionFromMouseX( x ) );
+	if (press) {
+		GrabFocus();
+		SetCursorPosition(GetPositionFromMouseX(x));
+		m_cursor_selection_start = m_cursor_position;
+	}
+	else {
+		SetCursorPosition(GetPositionFromMouseX(x));
+	}
 }
 
 void Entry::HandleUpdate( float seconds ) {
@@ -292,6 +412,10 @@ void Entry::HandleFocusChange( Widget::Ptr focused_widget ) {
 		m_elapsed_time = 0.f;
 		m_cursor_status = true;
 	}
+	else {
+		m_cursor_position = 0;
+		m_cursor_selection_start = 0;
+	}
 
 	Invalidate();
 
@@ -326,6 +450,11 @@ int Entry::GetVisibleOffset() const {
 	return m_visible_offset;
 }
 
+int Entry::GetVisibleLength() const
+{
+	return m_visible_string.getSize();
+}
+
 int Entry::GetCursorPosition() const {
 	return m_cursor_position;
 }
@@ -356,6 +485,25 @@ void Entry::SetMaximumLength( int max_length ) {
 	}
 }
 
+void Entry::GetSelectionBounds(int& left, int& right) const
+{
+	if (m_cursor_position < m_cursor_selection_start) {
+		left = m_cursor_position;
+		right = m_cursor_selection_start;
+	}
+	else {
+		left = m_cursor_selection_start;
+		right = m_cursor_position;
+	}
+}
+
+sf::String Entry::GetSelectedText() const
+{
+	int left, right;
+	GetSelectionBounds(left, right);
+	return m_string.substring(left, right - left);
+}
+
 void Entry::SetTextMargin( float margin ) {
 	m_text_margin = margin;
 }
diff --git a/src/SFGUI/FilePickerDialog.cpp b/src/SFGUI/FilePickerDialog.cpp
new file mode 100644
index 00000000..76103a0c
--- /dev/null
+++ b/src/SFGUI/FilePickerDialog.cpp
@@ -0,0 +1,247 @@
+#include <SFGUI/FilePickerDialog.hpp>
+
+#if defined(SFGUI_BOOST_FILESYSTEM_SUPPORT)
+
+#include <boost/predef.h>
+#if BOOST_OS_LINUX
+#include <unistd.h>
+#include <sys/types.h>
+#include <pwd.h>
+#endif
+
+namespace fs = boost::filesystem;
+
+namespace sfg {
+
+Signal::SignalID FilePickerDialog::OnCancel = 0;
+Signal::SignalID FilePickerDialog::OnOk = 0;
+
+FilePickerDialog::Ptr FilePickerDialog::Create( boost::filesystem::path initial_path ) {
+    auto ptr = Ptr( new FilePickerDialog( initial_path ) );
+    ptr->Add(ptr->m_main_box);
+
+    ptr->m_main_box->PackEnd(ptr->m_panel_box, true, true);
+    ptr->m_main_box->PackEnd(ptr->m_buttons_box, false, true);
+
+    ptr->m_panel_box->PackEnd(ptr->m_locations_listbox, false, true);
+    ptr->m_panel_box->PackEnd(ptr->m_directory_box, true, true);
+
+    ptr->m_directory_box->PackEnd(ptr->m_directory_entry_box, false, true);
+    ptr->m_directory_box->PackEnd(ptr->m_directory_paths_listbox, true, true);
+    ptr->m_directory_box->PackEnd(ptr->m_filename_box, false, true);
+
+    ptr->m_directory_entry_box->PackEnd(ptr->m_current_directory_entry, true, true);
+    ptr->m_directory_entry_box->PackEnd(ptr->m_new_directory_button, false, true);
+
+    ptr->m_filename_box->PackEnd(ptr->m_filename_entry, true, true);
+
+    ptr->m_buttons_box->PackEnd(ptr->m_ok_button, true, true);
+    ptr->m_buttons_box->PackEnd(ptr->m_cancel_button, false, true);
+
+    ptr->RequestResize();
+    ptr->m_locations_listbox->RequestResize();
+    ptr->m_new_directory_button->RequestResize();
+    ptr->m_current_directory_entry->RequestResize();
+    ptr->m_directory_paths_listbox->RequestResize();
+    ptr->m_filename_entry->RequestResize();
+    ptr->m_ok_button->RequestResize();
+    ptr->m_cancel_button->RequestResize();
+
+    return ptr;
+}
+
+FilePickerDialog::FilePickerDialog( boost::filesystem::path initial_path ) :
+    Window( Window::Style::TOPLEVEL | Window::Style::CLOSE ),
+    m_main_box( sfg::Box::Create( sfg::Box::Orientation::VERTICAL, 5.f ) ),
+    m_panel_box( sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5.f ) ),
+    m_locations_listbox( sfg::ListBox::Create( ) ),
+    m_directory_box( sfg::Box::Create( sfg::Box::Orientation::VERTICAL, 5.f ) ),
+    m_directory_entry_box( sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5.f ) ),
+    m_new_directory_button( sfg::Button::Create( "+" ) ),
+    m_current_directory_entry( sfg::Entry::Create( ) ),
+    m_directory_paths_listbox( sfg::ListBox::Create( ) ),
+    m_filename_box( sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5.f ) ),
+    m_filename_entry( sfg::Entry::Create( ) ),
+    m_buttons_box( sfg::Box::Create( sfg::Box::Orientation::HORIZONTAL, 5.f ) ),
+    m_ok_button( sfg::Button::Create( "Ok" ) ),
+    m_cancel_button( sfg::Button::Create( "Cancel" ) ),
+    m_current_path( initial_path ),
+    m_show_hidden_files( false )
+{
+    UpdateLocationsPaths();
+    UpdateCurrentDirectoryPath();
+    UpdateDirectoryPaths();
+    UpdateOkButtonState();
+
+    m_locations_listbox->GetSignal( sfg::ListBox::OnSelect ).Connect( std::bind( &FilePickerDialog::OnLocationsListBoxSelectionChanged, this ) );
+    m_current_directory_entry->GetSignal( sfg::Entry::OnTextChanged ).Connect( std::bind( &FilePickerDialog::OnCurrentDirectoryEntryTextChanged, this ) );
+    m_directory_paths_listbox->GetSignal( sfg::ListBox::OnSelect ).Connect( std::bind( &FilePickerDialog::OnPathsListBoxSelectionChanged, this ) );
+    m_filename_entry->GetSignal( sfg::Entry::OnTextChanged ).Connect( std::bind( &FilePickerDialog::OnFilenameEntryTextChanged, this ) );
+
+    //Connect buttons and the close button
+    GetSignal( sfg::Window::OnCloseButton ).Connect( std::bind( &FilePickerDialog::CancelDialog, this ) );
+    m_cancel_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &FilePickerDialog::CancelDialog, this ) );
+    m_ok_button->GetSignal( sfg::Widget::OnLeftClick ).Connect( std::bind( &FilePickerDialog::OkDialog, this ) );
+}
+
+sf::String FilePickerDialog::GetSelectedPath() const {
+    if( m_filename_entry->GetText().getSize() > 0 &&
+        fs::exists( fs::absolute( m_filename_entry->GetText().toWideString(), m_current_path ) ) &&
+        fs::is_regular_file( fs::absolute( m_filename_entry->GetText().toWideString(), m_current_path ) ) ) {
+
+        return sf::String( fs::canonical( m_filename_entry->GetText().toWideString(), m_current_path ).wstring() );
+    }
+    else {
+        return sf::String();
+    }
+}
+
+void FilePickerDialog::UpdateLocationsPaths() {
+#if BOOST_OS_WINDOWS
+    //Test all possible drives and add the existing ones into the location list
+    for( wchar_t driveLetter = L'A'; driveLetter != L'Z'; driveLetter++ ) {
+        std::wstring drivePath;
+        drivePath += driveLetter;
+        drivePath += L":\\";
+        if( fs::exists( fs::path( drivePath ) ) ) {
+            m_locations_listbox->AppendItem( drivePath );
+        }
+    }
+#elif BOOST_OS_LINUX
+    //Add some common locations
+    m_locations_listbox->AppendItem( "/" );
+
+    //Add the current user's home
+    const char *homedir;
+    if ((homedir = getenv("HOME")) == NULL) {
+        homedir = getpwuid(getuid())->pw_dir;
+    }
+
+    m_locations_listbox->AppendItem( std::string(homedir) );
+
+#endif
+}
+
+void FilePickerDialog::UpdateCurrentDirectoryPath() {
+    m_current_directory_entry->SetText( m_current_path.wstring() );
+}
+
+void FilePickerDialog::UpdateDirectoryPaths() {
+    m_directory_paths_listbox->Clear();
+    m_filename_entry->SetText( "" ); //Clear the selected filename
+
+    try {
+        if( fs::exists( m_current_path ) && fs::is_directory( m_current_path ) ) {
+            m_directory_paths_listbox->AppendItem("..");
+
+            std::vector<fs::path> subdirectories;
+            std::vector<fs::path> subfiles;
+
+            //Iterate all files and directories
+            for( fs::directory_entry& e : fs::directory_iterator( m_current_path ) ) {
+                if( fs::is_directory( e.path() ) ) {
+                    if( e.path().filename().wstring()[0] != L'.' || m_show_hidden_files ) {
+                        subdirectories.push_back( e.path().filename() );
+                    }
+                }
+                else if( fs::is_regular_file( e.path() ) ) {
+                    if( e.path().filename().wstring()[0] != L'.' || m_show_hidden_files ) {
+                        subfiles.push_back( e.path().filename() );
+                    }
+                }
+            }
+
+            std::sort( subdirectories.begin(), subdirectories.end() );
+            std::sort( subfiles.begin(), subfiles.end() );
+
+            for( fs::path& path : subdirectories ) {
+                m_directory_paths_listbox->AppendItem(path.filename().wstring());
+            }
+            for( fs::path& path : subfiles ) {
+                m_directory_paths_listbox->AppendItem(path.filename().wstring());
+            }
+        }
+    }
+    catch( const fs::filesystem_error& ex ) {
+
+    }
+}
+
+void FilePickerDialog::UpdateOkButtonState() {
+    if( m_filename_entry->GetText().getSize() > 0 &&
+        fs::exists( fs::absolute( m_filename_entry->GetText().toWideString(), m_current_path ) ) &&
+        fs::is_regular_file( fs::absolute( m_filename_entry->GetText().toWideString(), m_current_path ) ) ) {
+        m_ok_button->SetState( sfg::Widget::State::NORMAL );
+    }
+    else {
+        m_ok_button->SetState( sfg::Widget::State::INSENSITIVE );
+    }
+}
+
+void FilePickerDialog::CancelDialog() {
+    Show(false);
+
+    GetSignals().Emit( OnCancel );
+}
+
+void FilePickerDialog::OkDialog() {
+    Show(false);
+
+    GetSignals().Emit( OnOk );
+}
+
+void FilePickerDialog::OnLocationsListBoxSelectionChanged() {
+    if( m_locations_listbox->GetSelectedItemsCount() > 0 ) {
+        fs::path selected_path = m_locations_listbox->GetSelectedItemText(0).toWideString();
+        if( fs::exists( selected_path ) ) {
+            m_current_path = selected_path;
+
+            UpdateCurrentDirectoryPath();
+            UpdateDirectoryPaths();
+            UpdateOkButtonState();
+        }
+    }
+}
+
+void FilePickerDialog::OnCurrentDirectoryEntryTextChanged() {
+    m_current_path = m_current_directory_entry->GetText().toWideString();
+
+    UpdateDirectoryPaths();
+    UpdateOkButtonState();
+}
+
+void FilePickerDialog::OnPathsListBoxSelectionChanged() {
+    if( m_directory_paths_listbox->GetSelectedItemsCount() > 0 ) {
+        fs::path selected_path = m_directory_paths_listbox->GetSelectedItemText(0).toWideString();
+
+        if( fs::is_directory( fs::absolute(selected_path, m_current_path) ) ) {
+            fs::path new_path = fs::canonical(selected_path, m_current_path);
+            m_current_path = new_path;
+
+            UpdateCurrentDirectoryPath();
+            UpdateDirectoryPaths();
+            UpdateOkButtonState();
+        }
+        else if( fs::is_regular_file( fs::absolute(selected_path, m_current_path) ) ) {
+            m_filename_entry->SetText( selected_path.wstring() );
+            UpdateOkButtonState();
+        }
+    }
+}
+
+void FilePickerDialog::OnFilenameEntryTextChanged() {
+    m_directory_paths_listbox->ClearSelection();
+
+    //Try to select the corresponding entry in the folder subpaths list.
+    for( sfg::ListBox::IndexType i = 0; i < m_directory_paths_listbox->GetItemsCount(); ++i ) {
+        if( m_filename_entry->GetText() == m_directory_paths_listbox->GetItemText( i ) ) {
+            m_directory_paths_listbox->SetSelection( i );
+        }
+    }
+
+    UpdateOkButtonState();
+}
+
+}
+
+#endif
diff --git a/src/SFGUI/ListBox.cpp b/src/SFGUI/ListBox.cpp
new file mode 100644
index 00000000..1b4f1670
--- /dev/null
+++ b/src/SFGUI/ListBox.cpp
@@ -0,0 +1,612 @@
+#include <SFGUI/ListBox.hpp>
+#include <SFGUI/Context.hpp>
+#include <SFGUI/Engine.hpp>
+#include <SFGUI/RenderQueue.hpp>
+#include <SFGUI/Widgets.hpp>
+
+#include <algorithm>
+
+#include <SFML/Graphics.hpp>
+
+namespace sfg {
+
+const ListBox::IndexType ListBox::NONE = -1;
+static const sf::String EMPTY = "";
+static const sf::Image EMPTY_IMAGE = sf::Image();
+
+Signal::SignalID ListBox::OnSelect = 0;
+
+ListBox::Ptr ListBox::Create(  ) {
+	auto ptr = Ptr( new ListBox );
+	static_cast<Container::Ptr>( ptr )->Add( ptr->m_vertical_scrollbar );
+	return ptr;
+}
+
+ListBox::ListBox() :
+	Container(),
+	m_items(),
+	m_selection_mode(SelectionMode::DEFAULT),
+	m_selected_items(),
+	m_highlighted_item(NONE),
+	m_first_displayed_item(0),
+	m_max_displayed_items_count(0),
+	m_vertical_scrollbar(nullptr),
+	m_scrollbar_policy(ScrollbarPolicy::DEFAULT),
+	m_item_text_policy(ItemTextPolicy::DEFAULT),
+	m_displayed_items_texts(),
+	m_images_size()
+{
+	m_vertical_scrollbar = Scrollbar::Create(Scrollbar::Orientation::VERTICAL);
+	m_vertical_scrollbar->GetAdjustment()->GetSignal(sfg::Adjustment::OnChange).Connect(std::bind(&ListBox::OnScrollbarChanged, this));
+}
+
+std::unique_ptr<sfg::RenderQueue> ListBox::InvalidateImpl() const {
+	return Context::Get().GetEngine().CreateListBoxDrawable( std::dynamic_pointer_cast<const ListBox>( shared_from_this() ) );
+}
+
+sf::Vector2f ListBox::CalculateRequisition() {
+	auto text_padding = Context::Get().GetEngine().GetProperty<float>( "Padding", shared_from_this() );
+	auto border_width = Context::Get().GetEngine().GetProperty<float>( "BorderWidth", shared_from_this() );
+	const auto& font_name = Context::Get().GetEngine().GetProperty<std::string>( "FontName", shared_from_this() );
+	const auto& font = Context::Get().GetEngine().GetResourceManager().GetFont( font_name );
+	auto font_size = Context::Get().GetEngine().GetProperty<unsigned int>( "FontSize", shared_from_this() );
+	auto dots_width = Context::Get().GetEngine().GetTextStringMetrics("...", *font, font_size).x;
+
+	// Calculate the max width of items
+	float items_max_width = 0.f;
+	for( const Item& item : m_items ) {
+		items_max_width = std::max(items_max_width, Context::Get().GetEngine().GetTextStringMetrics(item.text, *font, font_size).x);
+	}
+
+	return sf::Vector2f(
+		border_width * 2 + text_padding * 2
+			+ ( m_item_text_policy == ItemTextPolicy::RESIZE_LISTBOX ? items_max_width : dots_width )
+			+ ( IsScrollbarVisible() ? m_vertical_scrollbar->GetRequisition().x : 0.f )
+			+ ( GetImagesSize() != sf::Vector2f() ? m_images_size.x + text_padding : 0.f ), /* Add a supplementary text padding between the image and the text */
+		std::max(std::max(m_vertical_scrollbar->GetRequisition().y, 50.f), GetItemHeight() + 2*text_padding)
+	);
+}
+
+const std::string& ListBox::GetName() const {
+	static const std::string name( "ListBox" );
+	return name;
+}
+
+void ListBox::AppendItem( const sf::String& str, const sf::Image& image ) {
+    m_items.push_back( Item{ str, image } );
+
+	UpdateDisplayedItems();
+    RequestResize();
+	HandleSizeChange();
+    Invalidate();
+}
+
+void ListBox::InsertItem( IndexType index, const sf::String& str, const sf::Image& image ) {
+	m_items.insert( m_items.begin() + index, Item{ str, image } );
+
+	// Update next selected indexes (decrement them).
+	std::set<IndexType> new_selected_items;
+	std::transform(
+		m_selected_items.cbegin(),
+		m_selected_items.cend(),
+		std::inserter(new_selected_items, new_selected_items.end()),
+		[&](IndexType i){
+			if( i < index )
+			 	return i;
+			else
+				return ++i;
+		}
+	);
+	m_selected_items = std::move(new_selected_items);
+
+	UpdateDisplayedItems();
+    RequestResize();
+	HandleSizeChange();
+    Invalidate();
+}
+
+void ListBox::PrependItem( const sf::String& str, const sf::Image& image ) {
+    m_items.insert( m_items.begin(), Item{ str, image } );
+
+	// Update selected items indexes.
+	std::set<IndexType> new_selected_items;
+	std::transform(
+		m_selected_items.cbegin(),
+		m_selected_items.cend(),
+		std::inserter(new_selected_items, new_selected_items.end()),
+		[&](IndexType i){
+			return ++i;
+		}
+	);
+	m_selected_items = std::move(new_selected_items);
+
+	UpdateDisplayedItems();
+	RequestResize();
+	HandleSizeChange();
+    Invalidate();
+}
+
+void ListBox::ChangeItemText( IndexType index, const sf::String& str ) {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return;
+	}
+
+	m_items[ static_cast<std::size_t>( index ) ].text = str;
+
+	UpdateDisplayedItems();
+	Invalidate();
+}
+
+void ListBox::ChangeItemImage( IndexType index, const sf::Image& image ) {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return;
+	}
+
+	m_items[ static_cast<std::size_t>( index ) ].image = image;
+
+	Invalidate();
+}
+
+void ListBox::RemoveItem( IndexType index ) {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return;
+	}
+
+    m_items.erase( m_items.begin() + index );
+
+	// Remove it from the selected indexes.
+	m_selected_items.erase( index );
+
+	// Update next selected indexes (decrement them).
+	std::set<IndexType> new_selected_items;
+	std::transform(
+		m_selected_items.cbegin(),
+		m_selected_items.cend(),
+		std::inserter(new_selected_items, new_selected_items.end()),
+		[&](IndexType i){
+			if( i > index )
+			 	return --i;
+			else
+				return i;
+		}
+	);
+	m_selected_items = std::move(new_selected_items);
+
+	UpdateDisplayedItems();
+	RequestResize();
+	HandleSizeChange();
+    Invalidate();
+}
+
+void ListBox::Clear() {
+    m_items.clear();
+	m_selected_items.clear();
+
+	UpdateDisplayedItems();
+	RequestResize();
+	HandleSizeChange();
+	Invalidate();
+}
+
+ListBox::IndexType ListBox::GetItemsCount() const {
+	return static_cast<IndexType>( m_items.size() );
+}
+
+const sf::String& ListBox::GetItemText( IndexType index ) const {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return EMPTY;
+	}
+
+	return m_items[ static_cast<std::size_t>( index )].text;
+}
+
+const sf::String& ListBox::GetDisplayedItemText( IndexType index ) const {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return EMPTY;
+	}
+
+	if(m_item_text_policy == ItemTextPolicy::RESIZE_LISTBOX) {
+		return GetItemText( index );
+	} else {
+		return m_displayed_items_texts[ static_cast<std::size_t>( index ) ];
+	}
+}
+
+const sf::Image& ListBox::GetItemImage( IndexType index ) const {
+	if( index >= static_cast<IndexType>( m_items.size() ) || index < 0 ) {
+		return EMPTY_IMAGE;
+	}
+
+	return m_items[ static_cast<std::size_t>( index )].image;
+}
+
+ListBox::IndexType ListBox::GetHighlightedItem() const {
+	return m_highlighted_item;
+}
+
+void ListBox::SetSelection( IndexType index ) {
+	if( m_selection_mode == SelectionMode::NO_SELECTION ) {
+		return;
+	}
+
+	m_selected_items.clear();
+	if( index != NONE ) {
+		m_selected_items.insert( index );
+	}
+
+	Invalidate();
+}
+
+void ListBox::SetSelection( std::initializer_list<IndexType> indices ) {
+	if( m_selection_mode == SelectionMode::MULTI_SELECTION ) {
+		m_selected_items = std::set<IndexType>( indices.begin(), indices.end() );
+
+		Invalidate();
+	} else if( m_selection_mode == SelectionMode::SINGLE_SELECTION ) {
+		if( indices.size() > 0) {
+			SetSelection( *( indices.begin() ) );
+		} else {
+			SetSelection( NONE );
+		}
+
+		Invalidate();
+	}
+}
+
+void ListBox::AppendToSelection( IndexType index ) {
+	if( m_selection_mode == SelectionMode::NO_SELECTION ) {
+		return;
+	}
+
+	if( m_selected_items.size() == 0 || m_selection_mode == SelectionMode::MULTI_SELECTION ) {
+		m_selected_items.insert( index );
+	}
+
+	Invalidate();
+}
+
+void ListBox::RemoveFromSelection( IndexType index ) {
+	m_selected_items.erase( index );
+
+	Invalidate();
+}
+
+void ListBox::ClearSelection() {
+	m_selected_items.clear();
+
+	Invalidate();
+}
+
+bool ListBox::IsItemSelected(IndexType index) const {
+	return m_selected_items.find( index ) != m_selected_items.end();
+}
+
+ListBox::IndexType ListBox::GetSelectedItemsCount() const {
+    return static_cast<IndexType>( m_selected_items.size() );
+}
+
+ListBox::IndexType ListBox::GetSelectedItemIndex( IndexType index ) const {
+	if( index >= static_cast<IndexType>( m_selected_items.size() ) || index < 0 ) {
+		return NONE;
+	}
+
+	auto it = m_selected_items.cbegin();
+	std::advance( it, index );
+	return *it;
+}
+
+const sf::String& ListBox::GetSelectedItemText( IndexType index ) const {
+	return m_items[ static_cast<std::size_t>( GetSelectedItemIndex( index ) ) ].text;
+}
+
+ListBox::IndexType ListBox::GetFirstDisplayedItemIndex() const {
+	return m_first_displayed_item;
+}
+
+ListBox::IndexType ListBox::GetDisplayedItemsCount() const {
+	return std::min(m_max_displayed_items_count, static_cast<IndexType>( m_items.size() ) - m_first_displayed_item);
+}
+
+ListBox::IndexType ListBox::GetMaxDisplayedItemsCount() const {
+	return m_max_displayed_items_count;
+}
+
+ListBox::SelectionMode ListBox::GetSelectionMode() const {
+	return m_selection_mode;
+}
+
+void ListBox::SetSelectionMode( SelectionMode mode ) {
+	m_selection_mode = mode;
+
+	if( m_selection_mode == SelectionMode::NO_SELECTION ) {
+		m_selected_items.clear();
+		Invalidate();
+	} else if( m_selection_mode == SelectionMode::SINGLE_SELECTION && m_selected_items.size() > 1 ) {
+		auto it = m_selected_items.begin();
+		std::advance( it, 1 );
+		m_selected_items.erase( it, m_selected_items.end() );
+	}
+}
+
+ListBox::ScrollbarPolicy ListBox::GetScrollbarPolicy() const {
+	return m_scrollbar_policy;
+}
+
+void ListBox::SetScrollbarPolicy( ScrollbarPolicy policy ) {
+	m_scrollbar_policy = policy;
+
+	RequestResize();
+	Invalidate();
+}
+
+ListBox::ItemTextPolicy ListBox::GetItemTextPolicy() const {
+	return m_item_text_policy;
+}
+
+void ListBox::SetItemTextPolicy( ItemTextPolicy policy ) {
+	m_item_text_policy = policy;
+
+	RequestResize();
+	Invalidate();
+}
+
+sf::Vector2f ListBox::GetImagesSize() const {
+	return m_images_size;
+}
+
+void ListBox::SetImagesSize(sf::Vector2f size) {
+	m_images_size = size;
+
+	UpdateDisplayedItems();
+	UpdateScrollbarAdjustment();
+	UpdateScrollbarAllocation();
+
+	UpdateDisplayedItemsText();
+
+	Invalidate();
+}
+
+float ListBox::GetItemHeight() const {
+	const auto& font_name = Context::Get().GetEngine().GetProperty<std::string>( "FontName", shared_from_this() );
+	const auto& font = Context::Get().GetEngine().GetResourceManager().GetFont( font_name );
+	auto font_size = Context::Get().GetEngine().GetProperty<unsigned int>( "FontSize", shared_from_this() );
+	auto line_height = Context::Get().GetEngine().GetFontLineHeight( *font, font_size );
+
+	return std::max(line_height, m_images_size.y);
+}
+
+void ListBox::HandleMouseEnter( int /*x*/, int /*y*/ ) {
+	if( !HasFocus() ) {
+		SetState( State::PRELIGHT );
+	}
+}
+
+void ListBox::HandleMouseLeave( int /*x*/, int /*y*/ ) {
+	if( !HasFocus() ) {
+		SetState( State::NORMAL );
+	}
+}
+
+void ListBox::HandleMouseMoveEvent( int x, int y ) {
+	if( ( x == std::numeric_limits<int>::min() ) || ( y == std::numeric_limits<int>::min() ) ) {
+		return;
+	}
+
+	float realX = static_cast<float>( x ) - GetAllocation().left;
+	float realY = static_cast<float>( y ) - GetAllocation().top;
+
+	if( IsMouseInWidget() && ( !IsScrollbarVisible() || ( IsScrollbarVisible() && realX < m_vertical_scrollbar->GetAllocation().left ) ) ) {
+		//Highlight the item under the mouse
+		IndexType hovered_item_index = GetItemAt( realY );
+		m_highlighted_item = hovered_item_index;
+
+		Invalidate();
+	} else if( m_highlighted_item != NONE ) {
+		m_highlighted_item = NONE;
+
+		Invalidate();
+	}
+}
+
+void ListBox::HandleMouseButtonEvent( sf::Mouse::Button button, bool press, int x, int y ) {
+	if( ( x == std::numeric_limits<int>::min() ) || ( y == std::numeric_limits<int>::min() ) ) {
+		return;
+	}
+
+	float realX = static_cast<float>( x ) - GetAllocation().left;
+	float realY = static_cast<float>( y ) - GetAllocation().top;
+
+	if( IsMouseInWidget() ) {
+		if( button == sf::Mouse::Left && press ) {
+			if( !IsScrollbarVisible() || ( IsScrollbarVisible() && realX < m_vertical_scrollbar->GetAllocation().left ) ) {
+				if( m_selection_mode != SelectionMode::NO_SELECTION ) {
+					// Find out and select which item has been clicked.
+					IndexType clicked_item_index = GetItemAt( realY );
+
+					if( clicked_item_index != NONE ) { // Only change the selection if the user has clicked on an item.
+						// Determine whether the clicked item is new to the selection.
+						bool selection_changed = false;
+						if( m_selection_mode == SelectionMode::SINGLE_SELECTION || ( !sf::Keyboard::isKeyPressed( sf::Keyboard::LControl ) && !sf::Keyboard::isKeyPressed( sf::Keyboard::RControl ) ) ) {
+							// In SINGLE_SELECTION mode or when Ctrl is not pressed, if the clicked item was not in the selected items list, the selection has changed.
+							selection_changed = std::find( m_selected_items.begin(), m_selected_items.end(), clicked_item_index ) == m_selected_items.end();
+
+							// Clear the selection and add the item to the selection.
+							m_selected_items.clear();
+							m_selected_items.insert( clicked_item_index );
+						} else {
+							// In MULTI_SELECTION and when Ctrl is pressed, the selection has changed (as if the clicked item is already selected, it is removed from the selection).
+							selection_changed = true;
+
+							// Add or remove the clicked item, depending on if it was in the selection or not.
+							if(m_selected_items.find( clicked_item_index ) == m_selected_items.end() )
+								m_selected_items.insert( clicked_item_index );
+							else
+								m_selected_items.erase( clicked_item_index );
+						}
+
+						if( selection_changed ) // Only emit the OnSelect signal if the selection changed.
+							GetSignals().Emit( OnSelect );
+					}
+				}
+
+				GrabFocus();
+				Invalidate();
+			}
+		}
+	}
+}
+
+ListBox::IndexType ListBox::GetItemAt( float y ) const {
+	auto text_padding = Context::Get().GetEngine().GetProperty<float>( "Padding", shared_from_this() );
+	auto border_width = Context::Get().GetEngine().GetProperty<float>( "BorderWidth", shared_from_this() );
+	const auto& font_name = Context::Get().GetEngine().GetProperty<std::string>( "FontName", shared_from_this() );
+	const auto& font = Context::Get().GetEngine().GetResourceManager().GetFont( font_name );
+	auto line_height = GetItemHeight();
+
+	IndexType item_index = 0;
+	while(y > border_width + static_cast<float>( item_index ) * ( line_height + text_padding * 2 ) ) {
+		++item_index;
+	}
+
+	if( item_index == 0 )
+		return 0 + m_first_displayed_item;
+	else if( item_index > GetDisplayedItemsCount() )
+		return NONE;
+	else
+		return item_index - 1 + m_first_displayed_item;
+}
+
+bool ListBox::IsScrollbarVisible() const {
+	return ( m_scrollbar_policy == ScrollbarPolicy::VERTICAL_ALWAYS || ( m_scrollbar_policy == ScrollbarPolicy::VERTICAL_AUTOMATIC && GetMaxDisplayedItemsCount() < GetItemsCount() ) );
+}
+
+void ListBox::HandleSizeChange() {
+	UpdateDisplayedItems();
+	UpdateScrollbarAdjustment();
+	UpdateScrollbarAllocation();
+
+	UpdateDisplayedItemsText();
+
+	Invalidate();
+}
+
+bool ListBox::HandleAdd( Widget::Ptr widget ) {
+	// The user can't add widgets to the ListBox.
+
+	if( widget == m_vertical_scrollbar && GetChildren().size() == 0 ) { // The scrollbar is an exception (added while creating the widget).
+		Container::HandleAdd( widget );
+		return true;
+	}
+
+	#if defined( SFGUI_DEBUG )
+		std::cerr << "SFGUI warning: No widgets can be added to a ListBox.\n";
+	#endif
+
+	return false;
+}
+
+void ListBox::HandleRemove( Widget::Ptr /*widget*/ ){
+#if defined( SFGUI_DEBUG )
+	std::cerr << "SFGUI warning: No widgets can be removed from a ListBox.\n";
+#endif
+}
+
+void ListBox::UpdateDisplayedItems() {
+	auto text_padding = Context::Get().GetEngine().GetProperty<float>( "Padding", shared_from_this() );
+	auto border_width = Context::Get().GetEngine().GetProperty<float>( "BorderWidth", shared_from_this() );
+	const auto& font_name = Context::Get().GetEngine().GetProperty<std::string>( "FontName", shared_from_this() );
+	const auto& font = Context::Get().GetEngine().GetResourceManager().GetFont( font_name );
+	auto line_height = GetItemHeight();
+
+	// Update the displayed items count.
+	float items_height = 0.f;
+	m_max_displayed_items_count = 0;
+	while(items_height < GetAllocation().height - border_width * 2.f + text_padding ) {
+		items_height += line_height + text_padding * 2.f;
+		++m_max_displayed_items_count;
+	}
+	if(m_max_displayed_items_count > 0)
+		--m_max_displayed_items_count;
+
+	// If there aren't enough items from m_first_displayed_item to
+	// m_first_displayed_item + m_max_displayed_items_count, decrement
+	// m_first_displayed_item.
+	if(m_first_displayed_item + m_max_displayed_items_count > static_cast<IndexType>( m_items.size() ) ) {
+		m_first_displayed_item = std::max( static_cast<IndexType>( m_items.size() ) - m_max_displayed_items_count, static_cast<IndexType>( 0 ) );
+	}
+}
+
+void ListBox::UpdateScrollbarAdjustment() {
+	m_vertical_scrollbar->GetAdjustment()->Configure(
+		static_cast<float>( m_first_displayed_item ),
+		0.f,
+		static_cast<float>( m_items.size() ),
+		1.f,
+		static_cast<float>( m_max_displayed_items_count ),
+		static_cast<float>( m_max_displayed_items_count )
+	);
+}
+
+void ListBox::UpdateScrollbarAllocation() {
+	auto border_width = Context::Get().GetEngine().GetProperty<float>( "BorderWidth", shared_from_this() );
+	m_vertical_scrollbar->SetAllocation( sf::FloatRect(
+		GetAllocation().width - border_width - m_vertical_scrollbar->GetRequisition().x,
+		border_width,
+		m_vertical_scrollbar->GetRequisition().x,
+		GetAllocation().height - border_width * 2.f
+	) );
+
+	m_vertical_scrollbar->RequestResize();
+	m_vertical_scrollbar->Invalidate();
+	m_vertical_scrollbar->Show( IsScrollbarVisible() );
+
+	Invalidate();
+}
+
+void ListBox::UpdateDisplayedItemsText() {
+	m_displayed_items_texts.clear();
+	if(m_item_text_policy == ItemTextPolicy::RESIZE_LISTBOX)
+		return;
+
+	auto text_padding = Context::Get().GetEngine().GetProperty<float>( "Padding", shared_from_this() );
+	auto border_width = Context::Get().GetEngine().GetProperty<float>( "BorderWidth", shared_from_this() );
+	const auto& font_name = Context::Get().GetEngine().GetProperty<std::string>( "FontName", shared_from_this() );
+	const auto& font = Context::Get().GetEngine().GetResourceManager().GetFont( font_name );
+	auto font_size = Context::Get().GetEngine().GetProperty<unsigned int>( "FontSize", shared_from_this() );
+	auto dots_width = Context::Get().GetEngine().GetTextStringMetrics("...", *font, font_size).x;
+
+	float max_width = GetAllocation().width - border_width * 2 - text_padding * 2 - ( IsScrollbarVisible() ? m_vertical_scrollbar->GetAllocation().width : 0 );
+
+	for(auto& item : m_items) {
+		if( Context::Get().GetEngine().GetTextStringMetrics( item.text, *font, font_size ).x < max_width - ( GetImagesSize() != sf::Vector2f() ? m_images_size.x + text_padding : 0.f ) ) {
+			// The item's text is fully displayable in the listbox's width.
+			m_displayed_items_texts.push_back( item.text );
+		} else {
+			// We need to shrink the text so that it will fit inside the listbox (and don't forget some width for "...").
+			sf::String displayableText;
+
+			while( displayableText.getSize() < item.text.getSize() &&
+				Context::Get().GetEngine().GetTextStringMetrics( displayableText, *font, font_size ).x
+				<= max_width - dots_width - ( GetImagesSize() != sf::Vector2f() ? m_images_size.x + text_padding : 0.f ) ) {
+				displayableText += item.text[ displayableText.getSize() ];
+			}
+
+			if(displayableText.getSize() > 0)
+				displayableText.erase( displayableText.getSize() - 1 ); // Removes the last character as it is going outside of the available space.
+
+			displayableText += "...";
+			m_displayed_items_texts.push_back( displayableText );
+		}
+	}
+
+	Invalidate();
+}
+
+void ListBox::OnScrollbarChanged() {
+	m_first_displayed_item = static_cast<IndexType>( m_vertical_scrollbar->GetAdjustment()->GetValue() );
+	UpdateDisplayedItems();
+
+	Invalidate();
+}
+
+}
diff --git a/src/SFGUI/Widget.cpp b/src/SFGUI/Widget.cpp
index 3a25ca2e..7ffee1af 100644
--- a/src/SFGUI/Widget.cpp
+++ b/src/SFGUI/Widget.cpp
@@ -121,6 +121,17 @@ bool Widget::HasFocus( PtrConst widget ) {
 	return false;
 }
 
+void Widget::LoseFocus()
+{
+	// Notify old focused widget.
+	if (focus_widget.lock()) {
+		focus_widget.lock()->GetSignals().Emit(OnLostFocus);
+		focus_widget.lock()->HandleFocusChange(NULL);
+	}
+
+	focus_widget.reset();
+}
+
 void Widget::SetAllocation( const sf::FloatRect& rect ) {
 	sf::FloatRect oldallocation( m_allocation );