client: add GUI infrastructure + functional login dialog

6 files changed, 1646 insertions, 4 deletions

diff --git a/client/gui/gui.cpp b/client/gui/gui.cpp
new file mode 100644
index 00000000..1bbf3c42
--- /dev/null
+++ b/client/gui/gui.cpp
@@ -0,0 +1,1354 @@
+#include "common.h"
+
+#include <limits.h>
+#include <stdlib.h>
+
+#include "gui.h"
+#include "screen.h"
+#include "utils.h"
+#include "debug.h"
+#include "red_pixmap_cairo.h"
+#include "resource_provider.h"
+
+#include "CEGUISystem.h"
+#include "CEGUIWindowManager.h"
+#include "CEGUIWindow.h"
+#include "CEGUIFontManager.h"
+#include "CEGUIExceptions.h"
+#include "CEGUIScheme.h"
+#include "elements/CEGUIPushButton.h"
+#include "elements/CEGUIEditbox.h"
+#include "elements/CEGUITabControl.h"
+#include "elements/CEGUIListbox.h"
+#include "elements/CEGUIListboxTextItem.h"
+
+#define MAIN_GUI_WIDTH 640
+#define MAIN_GUI_HEIGHT 480
+#define BUTTON_WIDTH 90
+#define BUTTON_HEIGHT 22
+#define GUI_SPACE 10
+#define GUI_LABEL_WIDTH 65
+#define GUI_LABEL_HEIGHT 22
+#define GUI_PORT_WIDTH 50
+#define GUI_TEXT_BOX_HEIGHT GUI_LABEL_HEIGHT
+
+#define LOGIN_DIALOG_WIDTH 400
+#define LOGIN_DIALOG_HEIGHT 300
+#define LOGIN_DIALOG_V_START 150
+
+#define CONNECTING_DIALOG_WIDTH 400
+#define CONNECTING_DIALOG_HEIGHT 300
+
+#define MESSAGE_BOX_WIDTH 380
+#define MESSAGE_BOX_HEIGHT 150
+
+#define CONNECT_OPTION_DIALOG_WIDTH LOGIN_DIALOG_WIDTH
+#define CONNECT_OPTION_DIALOG_HEIGHT LOGIN_DIALOG_HEIGHT
+
+static inline void set_win_pos(CEGUI::Window* win, int x, int y)
+{
+    win->setPosition(CEGUI::UVector2(cegui_absdim((float)x), cegui_absdim((float)y)));
+}
+
+static inline void set_win_size(CEGUI::Window* win, int width, int height)
+{
+    win->setSize(CEGUI::UVector2(cegui_absdim((float)width), cegui_absdim((float)height)));
+}
+
+static void add_bottom_button(CEGUI::Window* parent, const char *str,
+                              CEGUI::SubscriberSlot subscriber,
+                              int& position)
+{
+    CEGUI::Window* button = CEGUI::WindowManager::getSingleton().createWindow("TaharezLook/Button");
+    int win_width = (int)parent->getWidth().asAbsolute(1);
+    int win_height = (int)parent->getHeight().asAbsolute(1);
+    int y_pos = win_height - BUTTON_HEIGHT - GUI_SPACE;
+
+    position += BUTTON_WIDTH + GUI_SPACE;
+    set_win_pos(button, win_width - position, y_pos);
+    set_win_size(button, BUTTON_WIDTH, BUTTON_HEIGHT);
+    button->setText(str);
+    button->subscribeEvent(CEGUI::PushButton::EventClicked, subscriber);
+    button->setInheritsAlpha(false);
+    //button->setTooltipText("tool tip");
+    parent->addChildWindow(button);
+}
+
+#ifdef GUI_DEMO
+
+class SampleTabFactory: public GUI::TabFactory {
+public:
+
+    class MyListItem : public CEGUI::ListboxTextItem {
+    public:
+        MyListItem (const CEGUI::String& text)
+            : CEGUI::ListboxTextItem(text)
+        {
+            setSelectionBrushImage("TaharezLook", "MultiListSelectionBrush");
+        }
+    };
+
+    class SampleTab: public GUI::Tab {
+    public:
+        SampleTab(int id, int width, int height)
+        {
+            string_printf(_name, "SampleTab-%d", id);
+            CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+            _root_window = winMgr.createWindow("TaharezLook/StaticText");
+            set_win_pos(_root_window, 0, 0);
+            set_win_size(_root_window, width, height);
+            _root_window->setText("Tab of SampleTabFactory");
+
+            if (id != 1) {
+                return;
+            }
+
+            _list = (CEGUI::Listbox*)winMgr.createWindow("TaharezLook/Listbox");
+            set_win_pos(_list, 10, 10);
+            set_win_size(_list, 200, 100);
+            _list->setMultiselectEnabled(false);
+            _list->addItem(new MyListItem("Item-1"));
+            _list->addItem(new MyListItem("Item-2"));
+            _list->addItem(new MyListItem("Item-3"));
+            _list->addItem(new MyListItem("Item-4"));
+            _list->addItem(new MyListItem("Item-5"));
+            _list->addItem(new MyListItem("Item-6"));
+
+            _list->subscribeEvent(CEGUI::Listbox::EventSelectionChanged,
+                                  CEGUI::Event::Subscriber(&SampleTab::handle_list_selection,
+                                                           this));
+
+            _root_window->addChildWindow(_list);
+
+            _label = winMgr.createWindow("TaharezLook/StaticText");
+            set_win_pos(_label, 220, 10);
+            set_win_size(_label, 200, 22);
+            _root_window->addChildWindow(_label);
+
+            _list->setItemSelectState((size_t)0, true);
+
+        }
+
+        virtual ~SampleTab()
+        {
+            CEGUI::WindowManager::getSingleton().destroyWindow(_root_window);
+        }
+
+        virtual CEGUI::Window& get_root_window()
+        {
+            return *_root_window;
+        }
+
+        virtual const std::string& get_name()
+        {
+            return _name;
+        }
+
+        bool handle_list_selection(const CEGUI::EventArgs& e)
+        {
+            DBG(0, "changed");
+            CEGUI::ListboxItem* selection = _list->getFirstSelectedItem();
+            if (selection) {
+                _label->setText(selection->getText());
+                return true;
+            }
+
+            if (_list->getItemCount()) {
+                _list->setItemSelectState((size_t)_list->getItemCount() - 1, true);
+            }
+
+            return true;
+         }
+
+    private:
+         std::string _name;
+         CEGUI::Window* _root_window;
+         CEGUI::Listbox* _list;
+         CEGUI::Window* _label;
+    };
+
+    SampleTabFactory(int id)
+        : GUI::TabFactory(id)
+        , _id (id)
+    {
+    }
+
+    GUI::Tab* create_tab(bool connected, int width, int height)
+    {
+        if (!connected && _id % 2 == 0) {
+            return NULL;
+        }
+        return new SampleTab(_id, width, height);
+    }
+
+private:
+    int _id;
+};
+
+#endif
+
+class GUI::Dialog {
+public:
+    Dialog(GUI& gui, bool close_on_message_click = false)
+        : _gui (gui)
+        , _root (NULL)
+        , _message_box (NULL)
+        , _box_response (NULL)
+        , _close_on_message_click (close_on_message_click)
+    {
+    }
+
+    virtual ~Dialog()
+    {
+        if (gui_system().getGUISheet() == _root) {
+            gui_system().setGUISheet(NULL);
+        }
+
+        CEGUI::WindowManager::getSingleton().destroyWindow(_root);
+    }
+
+    CEGUI::Window& root_window() { return *_root;}
+    Application& application() { return _gui.get_application();}
+    CEGUI::System& gui_system() { return _gui.gui_system();}
+
+    void set_dialog(Dialog* dialog) { _gui.set_dialog(dialog);}
+    TabFactorys& get_factoris() { return _gui._tab_factorys;}
+
+    bool message_box(MessageType type, const char *text, const ButtonsList& buttons,
+                     BoxResponse* response_handler);
+    void error_box(const char* error_message);
+
+    void pre_destroy();
+
+private:
+    void handle_message_click(int id);
+    void set_opaque(CEGUI::Window* win);
+
+    void dim();
+    void undim();
+
+protected:
+    GUI& _gui;
+    CEGUI::Window* _root;
+
+private:
+    class BottonAction {
+    public:
+        BottonAction(Dialog& dialog, int id)
+            : _dialog (dialog)
+            , _id (id)
+        {
+        }
+
+        bool operator () (const CEGUI::EventArgs& e)
+        {
+            _dialog.handle_message_click(_id);
+            return true;
+        }
+
+    private:
+        Dialog& _dialog;
+        int _id;
+    };
+
+    CEGUI::Window* _message_box;
+    BoxResponse* _box_response;
+
+    class UndimInfo {
+    public:
+        UndimInfo(const CEGUI::String& name, float alpha, bool inherits)
+            : _name (name)
+            , _alpha (alpha)
+            , _inherits (inherits)
+        {
+        }
+
+        void restore()
+        {
+            try {
+                CEGUI::Window* win = CEGUI::WindowManager::getSingleton().getWindow(_name);
+                win->setAlpha(_alpha);
+                win->setInheritsAlpha(_inherits);
+            } catch (...) {
+            }
+        }
+
+    private:
+        CEGUI::String _name;
+        float _alpha;
+        bool _inherits;
+
+    };
+
+    std::list<UndimInfo*> _undim_info_list;
+    bool _close_on_message_click;
+};
+
+
+void GUI::Dialog::set_opaque(CEGUI::Window* win)
+{
+    float alpha = win->getAlpha();
+    bool inherits = win->inheritsAlpha();
+
+    if (alpha != 1 || !inherits ) {
+        _undim_info_list.push_back(new UndimInfo(win->getName(), alpha, inherits));
+        win->setInheritsAlpha(true);
+        win->setAlpha(1);
+    }
+
+    size_t child_count = win->getChildCount();
+    for (size_t i = 0; i < child_count; ++i) {
+        CEGUI::Window* child = win->getChildAtIdx(i);
+        set_opaque(child);
+    }
+}
+
+void GUI::Dialog::dim()
+{
+    set_opaque(_root);
+    _root->setAlpha(0.5);
+}
+
+void GUI::Dialog::undim()
+{
+    while (!_undim_info_list.empty()) {
+        UndimInfo* inf = _undim_info_list.front();
+        _undim_info_list.pop_front();
+        inf->restore();
+        delete inf;
+    }
+    _root->setAlpha(1);
+}
+
+bool GUI::Dialog::message_box(MessageType type, const char *text, const ButtonsList& buttons,
+                              BoxResponse* response_handler)
+{
+    if (_message_box) {
+        return false;
+    }
+
+    try {
+        CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+
+        CEGUI::Window* wnd = _message_box = winMgr.createWindow("TaharezLook/StaticText");
+        int x_pos = (MAIN_GUI_WIDTH - MESSAGE_BOX_WIDTH) / 2;
+        int y_pos = (MAIN_GUI_HEIGHT - MESSAGE_BOX_HEIGHT) / 3;
+        set_win_pos(wnd, x_pos, y_pos);
+        set_win_size(wnd, MESSAGE_BOX_WIDTH, MESSAGE_BOX_HEIGHT);
+        wnd->setModalState(true);
+        wnd->setInheritsAlpha(false);
+        dim();
+        _root->addChildWindow(wnd);
+
+        CEGUI::Window* text_wnd = winMgr.createWindow("TaharezLook/StaticText");
+        set_win_pos(text_wnd, GUI_SPACE, GUI_SPACE);
+        set_win_size(text_wnd, MESSAGE_BOX_WIDTH - 2 * GUI_SPACE,
+                     MESSAGE_BOX_HEIGHT - 3 * GUI_SPACE - BUTTON_HEIGHT);
+        text_wnd->setProperty("FrameEnabled", "false");
+        text_wnd->setProperty("HorzFormatting", "WordWrapLeftAligned");
+        text_wnd->setProperty("VertFormatting", "TopAligned");
+        text_wnd->setText(text);
+        //text_wnd->getTextRenderArea();
+        wnd->addChildWindow(text_wnd);
+
+        x_pos = 0;
+
+        for (unsigned int i = 0; i < buttons.size(); i++) {
+            add_bottom_button(wnd, buttons[i].text,
+                              CEGUI::Event::Subscriber(BottonAction(*this, buttons[i].id)),
+                              x_pos);
+        }
+
+        _box_response = response_handler;
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+        throw;
+    }
+
+    return true;
+}
+
+class BoxResponseEvent: public Event {
+public:
+    BoxResponseEvent(GUI::BoxResponse* box_response, int id)
+        : _box_response (box_response)
+        , _id (id)
+    {
+    }
+
+    virtual void response(AbstractProcessLoop &events_loop)
+    {
+        _box_response->response(_id);
+    }
+
+private:
+    GUI::BoxResponse* _box_response;
+    int _id;
+};
+
+class BoxAbortEvent: public Event {
+public:
+    BoxAbortEvent(GUI::BoxResponse* box_response)
+        : _box_response (box_response)
+    {
+    }
+
+    virtual void response(AbstractProcessLoop &events_loop)
+    {
+        _box_response->aborted();
+    }
+
+private:
+    GUI::BoxResponse* _box_response;
+};
+
+void GUI::Dialog::handle_message_click(int id)
+{
+    DBG(0, "");
+    ASSERT(_message_box);
+    _message_box->setModalState(false);
+    _root->removeChildWindow(_message_box);
+    CEGUI::Window *win = _message_box;
+    _message_box = NULL;
+    CEGUI::WindowManager::getSingleton().destroyWindow(win);
+    undim();
+    if (_box_response) {
+        AutoRef<BoxResponseEvent> event(new BoxResponseEvent(_box_response, id));
+        _box_response = NULL;
+        application().push_event(*event);
+    }
+
+    if (_close_on_message_click) {
+        application().hide_me();
+    }
+}
+
+void GUI::Dialog::pre_destroy()
+ {
+    if (_box_response) {
+        AutoRef<BoxAbortEvent> event(new BoxAbortEvent(_box_response));
+        _box_response = NULL;
+        application().push_event(*event);
+    }
+}
+
+void GUI::Dialog::error_box(const char* message)
+{
+    ASSERT(message && strlen(message) > 0);
+    DBG(0, "%s", message);
+    ButtonsList list(1);
+    list[0].id = 0;
+    list[0].text = res_get_string(STR_BUTTON_OK);
+    message_box(INFO, message, list, NULL);
+}
+
+class TabDialog : public GUI::Dialog {
+public:
+    TabDialog(GUI& gui, bool connected);
+    virtual ~TabDialog();
+
+protected:
+    CEGUI::Window* _main_win;
+
+private:
+    typedef std::list<GUI::Tab*> Tabs;
+    Tabs _tabs;
+};
+
+class MessageDialog : public GUI::Dialog {
+public:
+    MessageDialog(GUI& gui);
+    virtual ~MessageDialog() {}
+};
+
+class LoginDialog : public GUI::Dialog {
+public:
+    LoginDialog(GUI& guip);
+
+    bool handle_connect(const CEGUI::EventArgs& e);
+    bool handle_quit(const CEGUI::EventArgs& e);
+    bool handle_options(const CEGUI::EventArgs& e);
+
+private:
+    static void set_port_text(CEGUI::Window* win, int port);
+
+private:
+    CEGUI::Window* _host_box;
+    CEGUI::Window* _port_box;
+    CEGUI::Window* _sport_box;
+    CEGUI::Window* _pass_box;
+};
+
+class PreLoginDialog: public TabDialog {
+public:
+    PreLoginDialog(GUI& gui);
+
+    bool handle_back(const CEGUI::EventArgs& e);
+    bool handle_quit(const CEGUI::EventArgs& e);
+};
+
+PreLoginDialog::PreLoginDialog(GUI& gui)
+    : TabDialog(gui, false)
+{
+    try {
+
+        int position = 0;
+        add_bottom_button(_main_win, res_get_string(STR_BUTTON_BACK),
+                          CEGUI::Event::Subscriber(&PreLoginDialog::handle_back, this),
+                          position);
+        add_bottom_button(_main_win, res_get_string(STR_BUTTON_QUIT),
+                          CEGUI::Event::Subscriber(&PreLoginDialog::handle_quit, this),
+                          position);
+
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+    } catch (...) {
+        throw;
+    }
+}
+
+bool PreLoginDialog::handle_back(const CEGUI::EventArgs& e)
+{
+    set_dialog(new LoginDialog(_gui));
+    return true;
+}
+
+bool PreLoginDialog::handle_quit(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().quit();
+    return true;
+}
+
+MessageDialog::MessageDialog(GUI& gui)
+    : GUI::Dialog(gui, true)
+{
+    try {
+        CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+        _root = winMgr.createWindow("DefaultWindow");
+        set_win_size(_root, MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT);
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+        throw;
+    }
+}
+
+LoginDialog::LoginDialog(GUI& gui)
+    : GUI::Dialog(gui)
+{
+    try {
+        CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+        _root = winMgr.createWindow("DefaultWindow");
+
+        CEGUI::Window* wnd = winMgr.createWindow("TaharezLook/StaticText");
+        int x_pos = (MAIN_GUI_WIDTH - LOGIN_DIALOG_WIDTH) / 2;
+        int y_pos = (MAIN_GUI_HEIGHT - LOGIN_DIALOG_HEIGHT) / 3;
+        set_win_pos(wnd, x_pos, y_pos);
+        set_win_size(wnd, LOGIN_DIALOG_WIDTH, LOGIN_DIALOG_HEIGHT);
+        _root->addChildWindow(wnd);
+
+        CEGUI::Window* host_label = winMgr.createWindow("TaharezLook/StaticText");
+        host_label->setText(res_get_string(STR_LABEL_HOST));
+        host_label->setProperty("FrameEnabled", "false");
+        host_label->setProperty("BackgroundEnabled", "false");
+        set_win_pos(host_label, GUI_SPACE, LOGIN_DIALOG_V_START);
+        set_win_size(host_label, GUI_LABEL_WIDTH, GUI_LABEL_HEIGHT);
+
+        wnd->addChildWindow(host_label);
+
+        _host_box = winMgr.createWindow("TaharezLook/Editbox");
+        set_win_pos(_host_box, GUI_LABEL_WIDTH + GUI_SPACE, LOGIN_DIALOG_V_START);
+        int width = LOGIN_DIALOG_WIDTH - GUI_LABEL_WIDTH - 2 * GUI_SPACE;
+        set_win_size(_host_box, width, GUI_LABEL_HEIGHT);
+        _host_box->setText(application().get_host());
+        wnd->addChildWindow(_host_box);
+
+        CEGUI::Window* port_label = winMgr.createWindow("TaharezLook/StaticText");
+        port_label->setText(res_get_string(STR_LABEL_PORT));
+        port_label->setProperty("FrameEnabled", "false");
+        port_label->setProperty("BackgroundEnabled", "false");
+        y_pos = LOGIN_DIALOG_V_START + GUI_LABEL_HEIGHT + GUI_SPACE;
+        set_win_pos(port_label, GUI_SPACE, y_pos);
+        set_win_size(port_label, GUI_LABEL_WIDTH, GUI_LABEL_HEIGHT);
+        wnd->addChildWindow(port_label);
+
+        _port_box = winMgr.createWindow("TaharezLook/Editbox");
+        set_win_pos(_port_box, GUI_SPACE + GUI_LABEL_WIDTH, y_pos);
+        set_win_size(_port_box, GUI_PORT_WIDTH, GUI_TEXT_BOX_HEIGHT);
+        set_port_text(_port_box, application().get_port());
+        wnd->addChildWindow(_port_box);
+
+        _sport_box = winMgr.createWindow("TaharezLook/Editbox");
+        x_pos = LOGIN_DIALOG_WIDTH - GUI_SPACE - GUI_PORT_WIDTH;
+        set_win_pos(_sport_box, x_pos, y_pos);
+        set_win_size(_sport_box, GUI_PORT_WIDTH, GUI_TEXT_BOX_HEIGHT);
+        set_port_text(_sport_box, application().get_sport());
+        wnd->addChildWindow(_sport_box);
+
+        CEGUI::Window* sport_label = winMgr.createWindow("TaharezLook/StaticText");
+        sport_label->setText(res_get_string(STR_LABEL_SPORT));
+        sport_label->setProperty("FrameEnabled", "false");
+        sport_label->setProperty("BackgroundEnabled", "false");
+        x_pos -= GUI_LABEL_WIDTH;
+        set_win_pos(sport_label, x_pos, y_pos);
+        set_win_size(sport_label, GUI_LABEL_WIDTH, GUI_LABEL_HEIGHT);
+        wnd->addChildWindow(sport_label);
+
+        CEGUI::Window* label = winMgr.createWindow("TaharezLook/StaticText");
+        label->setText(res_get_string(STR_LABEL_PASSWORD));
+        label->setProperty("FrameEnabled", "false");
+        label->setProperty("BackgroundEnabled", "false");
+        y_pos += GUI_LABEL_HEIGHT + GUI_SPACE;
+        set_win_pos(label, GUI_SPACE, y_pos);
+        set_win_size(label, GUI_LABEL_WIDTH, GUI_LABEL_HEIGHT);
+        wnd->addChildWindow(label);
+
+        _pass_box = winMgr.createWindow("TaharezLook/Editbox");
+        x_pos = GUI_LABEL_WIDTH + GUI_SPACE;
+        set_win_pos(_pass_box, x_pos, y_pos);
+        width = LOGIN_DIALOG_WIDTH - GUI_LABEL_WIDTH - 2 * GUI_SPACE;
+        set_win_size(_pass_box, width, GUI_TEXT_BOX_HEIGHT);
+        ((CEGUI::Editbox*)_pass_box)->setTextMasked(true);
+        ((CEGUI::Editbox*)_pass_box)->setMaskCodePoint(/*0x000026AB*/ 0x00002022 );
+        _pass_box->setText(application().get_password().c_str());
+        wnd->addChildWindow(_pass_box);
+
+        x_pos = 0;
+        add_bottom_button(wnd,
+                          res_get_string(STR_BUTTON_CONNECT),
+                          CEGUI::Event::Subscriber(&LoginDialog::handle_connect, this),
+                          x_pos);
+        add_bottom_button(wnd,
+                          res_get_string(STR_BUTTON_QUIT),
+                          CEGUI::Event::Subscriber(&LoginDialog::handle_quit, this),
+                          x_pos);
+        add_bottom_button(wnd,
+                          res_get_string(STR_BUTTON_OPTIONS),
+                          CEGUI::Event::Subscriber(&LoginDialog::handle_options, this),
+                          x_pos);
+
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+        throw;
+    }
+}
+
+bool LoginDialog::handle_connect(const CEGUI::EventArgs& e)
+{
+    const char* host_name = _host_box->getText().c_str();
+
+    if (strlen(host_name) == 0) {
+        error_box(res_get_string(STR_MESG_MISSING_HOST_NAME));
+        return true;
+    }
+    int port = -1;
+    int sport = -1;
+
+    const char* port_str = _port_box->getText().c_str();
+    if (strlen(port_str) != 0 && (port = str_to_port(port_str)) == -1) {
+        error_box(res_get_string(STR_MESG_INVALID_PORT));
+        return true;
+    }
+
+    const char* sport_str = _sport_box->getText().c_str();
+    if (strlen(sport_str) != 0 && (sport = str_to_port(sport_str)) == -1) {
+        error_box(res_get_string(STR_MESG_INVALID_SPORT));
+        return true;
+    }
+
+    if (port == sport && port == -1) {
+        error_box(res_get_string(STR_MESG_MISSING_PORT));
+        return true;
+    }
+
+    DBG(0, "host %s port %d sport %d", host_name, port, sport);
+    application().connect(host_name, port, sport, _pass_box->getText().c_str());
+    return true;
+}
+
+bool LoginDialog::handle_quit(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().quit();
+    return true;
+}
+
+bool LoginDialog::handle_options(const CEGUI::EventArgs& e)
+{
+    set_dialog(new PreLoginDialog(_gui));
+    return true;
+}
+
+void LoginDialog::set_port_text(CEGUI::Window* win, int port)
+{
+    if (port == -1) {
+        win->setText("");
+        return;
+    }
+
+    char port_string[25];
+    sprintf(port_string, "%d", port);
+    win->setText(port_string);
+}
+
+class ConnectingDialog : public GUI::Dialog {
+public:
+    ConnectingDialog(GUI& gui);
+
+private:
+    bool handle_cancel(const CEGUI::EventArgs& e);
+    bool handle_quit(const CEGUI::EventArgs& e);
+};
+
+bool ConnectingDialog::handle_cancel(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().disconnect();
+    return true;
+}
+
+bool ConnectingDialog::handle_quit(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().quit();
+    return true;
+}
+
+ConnectingDialog::ConnectingDialog(GUI& gui)
+    :  GUI::Dialog(gui)
+{
+    try {
+        CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+        _root = winMgr.createWindow("DefaultWindow");
+
+        CEGUI::Window* wnd = winMgr.createWindow("TaharezLook/StaticText");
+        int x_pos = (MAIN_GUI_WIDTH - CONNECTING_DIALOG_WIDTH) / 2;
+        int y_pos = (MAIN_GUI_HEIGHT - CONNECTING_DIALOG_HEIGHT) / 2;
+        set_win_pos(wnd, x_pos, y_pos);
+        set_win_size(wnd, CONNECTING_DIALOG_WIDTH, CONNECTING_DIALOG_HEIGHT);
+        CEGUI::String text(res_get_string(STR_MESG_CONNECTING));
+        wnd->setText(text + " " + application().get_host());
+        wnd->setProperty("HorzFormatting", "LeftAligned");
+        wnd->setProperty("VertFormatting", "TopAligned");
+        _root->addChildWindow(wnd);
+
+        x_pos = 0;
+
+        add_bottom_button(wnd, res_get_string(STR_BUTTON_CANCEL),
+                          CEGUI::Event::Subscriber(&ConnectingDialog::handle_cancel, this),
+                          x_pos);
+
+        if (_gui.is_disconnect_allowed()) {
+            add_bottom_button(wnd, res_get_string(STR_BUTTON_QUIT),
+                              CEGUI::Event::Subscriber(&ConnectingDialog::handle_quit, this),
+                              x_pos);
+        }
+
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+        throw;
+    }
+}
+
+TabDialog::TabDialog(GUI& gui, bool connected)
+    : GUI::Dialog(gui)
+{
+    CEGUI::WindowManager& winMgr = CEGUI::WindowManager::getSingleton();
+
+    try {
+         _root = winMgr.createWindow("DefaultWindow");
+
+        CEGUI::Window* wnd = _main_win = winMgr.createWindow("TaharezLook/StaticText");
+        set_win_pos(wnd, 0, 0);
+        set_win_size(wnd, MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT);
+        wnd->setAlpha(0.5);
+        _root->addChildWindow(wnd);
+
+        CEGUI::TabControl* tab_ctrl;
+        tab_ctrl = static_cast<CEGUI::TabControl*>(winMgr.createWindow("TaharezLook/TabControl"));
+        set_win_pos(tab_ctrl, GUI_SPACE, GUI_SPACE);
+        int tab_width = MAIN_GUI_WIDTH - GUI_SPACE * 2;
+        int tab_height = MAIN_GUI_HEIGHT - GUI_SPACE * 3 - BUTTON_HEIGHT;
+        set_win_size(tab_ctrl, tab_width, tab_height);
+        tab_ctrl->setInheritsAlpha(false);
+        tab_ctrl->setTabHeight(cegui_absdim(22));
+        tab_ctrl->setTabTextPadding(cegui_absdim(10));
+        tab_height = (int)tab_ctrl->getTabHeight().asAbsolute(1);
+        wnd->addChildWindow(tab_ctrl);
+
+        GUI::TabFactorys& _tab_factorys = get_factoris();
+        GUI::TabFactorys::iterator iter = _tab_factorys.begin();
+
+        int tab_content_width = MAIN_GUI_WIDTH - GUI_SPACE * 4;
+        int tab_content_height = MAIN_GUI_HEIGHT - GUI_SPACE * 5 - BUTTON_HEIGHT - tab_height;
+
+        for (; iter != _tab_factorys.end(); iter++) {
+
+            GUI::Tab* tab = (*iter)->create_tab(connected, tab_content_width,
+                                                    tab_content_height);
+
+            if (!tab) {
+                continue;
+            }
+
+            _tabs.push_front(tab);
+            CEGUI::Window* gui_sheet = winMgr.createWindow("DefaultGUISheet");
+            gui_sheet->setText(tab->get_name());
+            set_win_pos(gui_sheet, GUI_SPACE, GUI_SPACE);
+            set_win_size(gui_sheet, tab_content_width, tab_content_height);
+            tab_ctrl->addTab(gui_sheet);
+            CEGUI::Window& tab_window = tab->get_root_window();
+            tab_window.setDestroyedByParent(false);
+            gui_sheet->addChildWindow(&tab_window);
+        }
+
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+    } catch (...) {
+        throw;
+    }
+}
+
+TabDialog::~TabDialog()
+{
+    while (!_tabs.empty()) {
+        GUI::Tab* tab = *_tabs.begin();
+        _tabs.pop_front();
+        delete tab;
+    }
+}
+
+class SettingsDialog : public TabDialog {
+public:
+    SettingsDialog(GUI& gui);
+
+    bool handle_close(const CEGUI::EventArgs& e);
+    bool handle_quit(const CEGUI::EventArgs& e);
+    bool handle_disconnect(const CEGUI::EventArgs& e);
+};
+
+bool SettingsDialog::handle_close(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().hide_me();
+    return true;
+}
+
+bool SettingsDialog::handle_quit(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().quit();
+    return true;
+}
+
+bool SettingsDialog::handle_disconnect(const CEGUI::EventArgs& e)
+{
+    DBG(0, "");
+    application().disconnect();
+    return true;
+}
+
+SettingsDialog::SettingsDialog(GUI& gui)
+    :  TabDialog(gui, true)
+{
+    try {
+
+        int position = 0;
+        add_bottom_button(_main_win, res_get_string(STR_BUTTON_CLOSE),
+                          CEGUI::Event::Subscriber(&SettingsDialog::handle_close, this),
+                          position);
+        add_bottom_button(_main_win, res_get_string(STR_BUTTON_QUIT),
+                          CEGUI::Event::Subscriber(&SettingsDialog::handle_quit, this),
+                          position);
+
+        if (_gui.is_disconnect_allowed()) {
+            add_bottom_button(_main_win, res_get_string(STR_BUTTON_DISCONNECT),
+                              CEGUI::Event::Subscriber(&SettingsDialog::handle_disconnect, this),
+                              position);
+        }
+
+    } catch (CEGUI::Exception& e) {
+        LOG_ERROR("Exception: %s", e.getMessage().c_str());
+    } catch (...) {
+        throw;
+    }
+}
+
+GUI::GUI(Application& app, Application::State state)
+    : ScreenLayer (SCREEN_LAYER_GUI, false)
+    , _app (app)
+    , _state (state)
+    , _pixmap (new RedPixmapCairo(MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT, RedPixmap::RGB32, true, NULL,
+                                  NULL))
+    , _renderer (new CEGUI::SoftRenderer(_pixmap->get_data(), MAIN_GUI_WIDTH, MAIN_GUI_HEIGHT,
+                                         _pixmap->get_stride()))
+    , _gui_system (new CEGUI::System(_renderer, new CEGUIResourceProvider()))
+    , _dialog (NULL)
+    , _prev_time (Platform::get_monolithic_time())
+
+{
+    LOG_INFO("");
+    init_cegui();
+#ifdef GUI_DEMO
+    register_tab_factory(*(new SampleTabFactory(2)));
+    register_tab_factory(*(new SampleTabFactory(3)));
+    register_tab_factory(*(new SampleTabFactory(1)));
+    register_tab_factory(*(new SampleTabFactory(4)));
+    register_tab_factory(*(new SampleTabFactory(5)));
+#endif
+    create_dialog();
+}
+
+GUI::~GUI()
+{
+    delete _dialog;
+    detach();
+    delete _gui_system;
+    delete _renderer;
+    delete _pixmap;
+}
+
+void GUI::init_cegui()
+{
+    CEGUI::SchemeManager::getSingleton().loadScheme("TaharezLook.scheme");
+    _gui_system->setDefaultMouseCursor("TaharezLook", "MouseArrow");
+    _gui_system->setDefaultTooltip("TaharezLook/Tooltip");
+
+    CEGUI::String font_name("DejaVuSans-10");
+    CEGUI::Font* font;
+
+    if (!CEGUI::FontManager::getSingleton().isFontPresent(font_name)) {
+        font = CEGUI::FontManager::getSingleton().createFont(font_name + ".font");
+    } else {
+        font = CEGUI::FontManager::getSingleton().getFont(font_name);
+    }
+
+    //font->setProperty("PointSize", "10");
+    CEGUI::System::getSingleton().setDefaultFont(font);
+}
+
+bool comp_factorys(GUI::TabFactory* f1, GUI::TabFactory* f2)
+{
+    return f1->get_order() < f2->get_order();
+}
+
+void GUI::register_tab_factory(TabFactory& factory)
+{
+    TabFactorys::iterator iter = _tab_factorys.begin();
+
+    for (; iter != _tab_factorys.end(); iter++) {
+        if ((*iter) == &factory) {
+            return;
+        }
+    }
+
+    _tab_factorys.push_back(&factory);
+    _tab_factorys.sort(comp_factorys);
+}
+
+void GUI::unregister_tab_factory(TabFactory& factory)
+{
+    TabFactorys::iterator iter = _tab_factorys.begin();
+
+    for (; iter != _tab_factorys.end(); iter++) {
+        if ((*iter) == &factory) {
+            _tab_factorys.erase(iter);
+            return;
+        }
+    }
+}
+
+void GUI::detach()
+{
+    if (!screen()) {
+        return;
+    }
+    clear_area();
+    screen()->detach_layer(*this);
+    set_dialog(NULL);
+}
+
+void GUI::conditional_update()
+{
+    if (_gui_system->isRedrawRequested()) {
+        invalidate();
+    }
+}
+
+void GUI::update_layer_area()
+{
+    if (!_dialog || !screen()) {
+        clear_area();
+        return;
+    }
+    Point screen_size = screen()->get_size();
+
+    int dx = (screen_size.x - MAIN_GUI_WIDTH) / 2;
+    int dy = (screen_size.y - MAIN_GUI_HEIGHT) / 2;
+
+    DBG(0, "screen_size.x = %d screen_size.y = %d", screen_size.x, screen_size.y);
+
+    _pixmap->set_origin(-dx, -dy);
+    CEGUI::Window& root = _dialog->root_window();
+    QRegion regin;
+    region_init(&regin);
+
+    for (unsigned int i = 0; i < root.getChildCount(); i++) {
+
+        CEGUI::Window* child = root.getChildAtIdx(i);
+        if (!child->isVisible()) {
+            continue;
+        }
+
+        CEGUI::Rect area = child->getPixelRect();
+        Rect r;
+        r.left = (int)area.d_left + dx;
+        r.right = (int)area.d_right + dx;
+        r.top = (int)area.d_top + dy;
+        r.bottom = (int)area.d_bottom + dy;
+        region_add(&regin, &r);
+
+    }
+    set_area(regin);
+    region_destroy(&regin);
+}
+
+void GUI::copy_pixels(const QRegion& dest_region, RedDrawable& dest)
+{
+    if (region_is_empty(&dest_region)) {
+        return;
+    }
+
+    for (int i = 0; i < (int)dest_region.num_rects; i++) {
+        Rect* r = &dest_region.rects[i];
+        _pixmap->copy_pixels(dest, r->left, r->top, *r);
+    }
+
+    _gui_system->renderGUI();
+    for (int i = 0; i < (int)dest_region.num_rects; i++) {
+        Rect* r = &dest_region.rects[i];
+        dest.copy_pixels(*_pixmap, r->left, r->top, *r);
+    }
+}
+
+void GUI::on_size_changed()
+{
+    DBG(0, "");
+    update_layer_area();
+}
+
+void GUI::set_dialog(Dialog* dialog)
+{
+    if (_dialog) {
+        _dialog->pre_destroy();
+        delete _dialog;
+        _dialog = NULL;
+    }
+
+    if (!dialog) {
+        return;
+    }
+
+    _dialog = dialog;
+    gui_system().setGUISheet(&_dialog->root_window());
+    update_layer_area();
+}
+
+void GUI::create_dialog()
+{
+    switch (_state) {
+    case Application::DISCONNECTED:
+        set_dialog(new LoginDialog(*this));
+        break;
+    case Application::VISIBILITY:
+        set_dialog(new SettingsDialog(*this));
+        break;
+    case Application::CONNECTING:
+        set_dialog(new ConnectingDialog(*this));
+        break;
+    case Application::CONNECTED:
+        break;
+    case Application::DISCONECTING:
+        set_dialog(NULL);
+        break;
+    }
+}
+
+void GUI::set_state(Application::State state)
+{
+    if (_state == state) {
+        return;
+    }
+    _state = state;
+    create_dialog();
+}
+
+bool GUI::prepare_dialog()
+{
+    if (!_dialog) {
+        create_dialog();
+    }
+
+    return !!_dialog;
+}
+
+void GUI::set_screen(RedScreen* in_screen)
+{
+    detach();
+    if (!in_screen) {
+        _app.remove_key_handler(*this);
+        return;
+    }
+    ASSERT(!screen());
+    in_screen->attach_layer(*this);
+    CEGUI::MouseCursor::getSingleton().hide();
+    update_layer_area();
+    _app.set_key_handler(*this);
+}
+
+void GUI::on_pointer_enter(int x, int y, unsigned int buttons_state)
+{
+    CEGUI::MouseCursor::getSingleton().show();
+    screen()->hide_cursor();
+    _app.set_key_handler(*this);
+    on_pointer_motion(x, y, buttons_state);
+}
+
+void GUI::on_pointer_motion(int x, int y, unsigned int buttons_state)
+{
+    _gui_system->injectMousePosition(float(x + _pixmap->get_origin().x),
+                                     float(y + _pixmap->get_origin().y));
+    invalidate();
+}
+
+void GUI::on_mouse_button_press(int button, int buttons_state)
+{
+    _app.set_key_handler(*this);
+    switch (button) {
+    case REDC_MOUSE_LBUTTON:
+        _gui_system->injectMouseButtonDown(CEGUI::LeftButton);
+        break;
+    case REDC_MOUSE_MBUTTON:
+        _gui_system->injectMouseButtonDown(CEGUI::MiddleButton);
+        break;
+    case REDC_MOUSE_RBUTTON:
+        _gui_system->injectMouseButtonDown(CEGUI::RightButton);
+        break;
+    case REDC_MOUSE_UBUTTON:
+        _gui_system->injectMouseWheelChange(-1);
+        break;
+    case REDC_MOUSE_DBUTTON:
+        _gui_system->injectMouseWheelChange(1);
+        break;
+    default:
+        THROW("invalid RedButton %d", button);
+    }
+    conditional_update();
+}
+
+void GUI::on_mouse_button_release(int button, int buttons_state)
+{
+    switch (button) {
+    case REDC_MOUSE_LBUTTON:
+        _gui_system->injectMouseButtonUp(CEGUI::LeftButton);
+        break;
+    case REDC_MOUSE_MBUTTON:
+        _gui_system->injectMouseButtonUp(CEGUI::MiddleButton);
+        break;
+    case REDC_MOUSE_RBUTTON:
+        _gui_system->injectMouseButtonUp(CEGUI::RightButton);
+        break;
+    case REDC_MOUSE_UBUTTON:
+    case REDC_MOUSE_DBUTTON:
+        break;
+    default:
+        THROW("invalid RedButton %d", button);
+    }
+    conditional_update();
+}
+
+void GUI::on_pointer_leave()
+{
+    CEGUI::MouseCursor::getSingleton().hide();
+    invalidate();
+}
+
+#define KEY_CASE(a, b)          \
+    case a:                     \
+        return  CEGUI::Key::b
+
+static inline CEGUI::Key::Scan red_ket_cegui_scan(RedKey key)
+{
+    switch (key) {
+    KEY_CASE(REDKEY_ESCAPE, Escape);
+    KEY_CASE(REDKEY_1, One);
+    KEY_CASE(REDKEY_2, Two);
+    KEY_CASE(REDKEY_3, Three);
+    KEY_CASE(REDKEY_4, Four);
+    KEY_CASE(REDKEY_5, Five);
+    KEY_CASE(REDKEY_6, Six);
+    KEY_CASE(REDKEY_7, Seven);
+    KEY_CASE(REDKEY_8, Eight);
+    KEY_CASE(REDKEY_9, Nine);
+    KEY_CASE(REDKEY_0, Zero);
+    KEY_CASE(REDKEY_MINUS, Minus);
+    KEY_CASE(REDKEY_EQUALS, Equals);
+    KEY_CASE(REDKEY_BACKSPACE, Backspace);
+    KEY_CASE(REDKEY_TAB, Tab);
+    KEY_CASE(REDKEY_Q, Q);
+    KEY_CASE(REDKEY_W, W);
+    KEY_CASE(REDKEY_E, E);
+    KEY_CASE(REDKEY_R, R);
+    KEY_CASE(REDKEY_T, T);
+    KEY_CASE(REDKEY_Y, Y);
+    KEY_CASE(REDKEY_U, U);
+    KEY_CASE(REDKEY_I, I);
+    KEY_CASE(REDKEY_O, O);
+    KEY_CASE(REDKEY_P, P);
+    KEY_CASE(REDKEY_L_BRACKET, LeftBracket);
+    KEY_CASE(REDKEY_R_BRACKET, RightBracket);
+    KEY_CASE(REDKEY_ENTER, Return);
+    KEY_CASE(REDKEY_L_CTRL, LeftControl);
+    KEY_CASE(REDKEY_A, A);
+    KEY_CASE(REDKEY_S, S);
+    KEY_CASE(REDKEY_D, D);
+    KEY_CASE(REDKEY_F, F);
+    KEY_CASE(REDKEY_G, G);
+    KEY_CASE(REDKEY_H, H);
+    KEY_CASE(REDKEY_J, J);
+    KEY_CASE(REDKEY_K, K);
+    KEY_CASE(REDKEY_L, L);
+    KEY_CASE(REDKEY_SEMICOLON, Semicolon);
+    KEY_CASE(REDKEY_QUOTE, Apostrophe);
+
+    KEY_CASE(REDKEY_BACK_QUOTE, Grave);
+    KEY_CASE(REDKEY_L_SHIFT, LeftShift);
+    KEY_CASE(REDKEY_BACK_SLASH, Backslash);
+    KEY_CASE(REDKEY_Z, Z);
+    KEY_CASE(REDKEY_X, X);
+    KEY_CASE(REDKEY_C, C);
+    KEY_CASE(REDKEY_V, V);
+    KEY_CASE(REDKEY_B, B);
+    KEY_CASE(REDKEY_N, N);
+    KEY_CASE(REDKEY_M, M);
+    KEY_CASE(REDKEY_COMMA, Comma);
+    KEY_CASE(REDKEY_PERIOD, Period);
+    KEY_CASE(REDKEY_SLASH, Slash);
+    KEY_CASE(REDKEY_R_SHIFT, RightShift);
+    KEY_CASE(REDKEY_PAD_MULTIPLY, Multiply);
+    KEY_CASE(REDKEY_L_ALT, LeftAlt);
+    KEY_CASE(REDKEY_SPACE, Space);
+    KEY_CASE(REDKEY_CAPS_LOCK, Capital);
+    KEY_CASE(REDKEY_F1, F1);
+    KEY_CASE(REDKEY_F2, F2);
+    KEY_CASE(REDKEY_F3, F3);
+    KEY_CASE(REDKEY_F4, F4);
+    KEY_CASE(REDKEY_F5, F5);
+    KEY_CASE(REDKEY_F6, F6);
+    KEY_CASE(REDKEY_F7, F7);
+    KEY_CASE(REDKEY_F8, F8);
+    KEY_CASE(REDKEY_F9, F9);
+    KEY_CASE(REDKEY_F10, F10);
+    KEY_CASE(REDKEY_NUM_LOCK, NumLock);
+    KEY_CASE(REDKEY_SCROLL_LOCK, ScrollLock);
+    KEY_CASE(REDKEY_PAD_7, Numpad7);
+    KEY_CASE(REDKEY_PAD_8, Numpad8);
+    KEY_CASE(REDKEY_PAD_9, Numpad9);
+    KEY_CASE(REDKEY_PAD_MINUS, Subtract);
+    KEY_CASE(REDKEY_PAD_4, Numpad4);
+    KEY_CASE(REDKEY_PAD_5, Numpad5);
+    KEY_CASE(REDKEY_PAD_6, Numpad6);
+    KEY_CASE(REDKEY_PAD_PLUS, Add);
+    KEY_CASE(REDKEY_PAD_1, Numpad1);
+    KEY_CASE(REDKEY_PAD_2, Numpad2);
+    KEY_CASE(REDKEY_PAD_3, Numpad3);
+    KEY_CASE(REDKEY_PAD_0, Numpad0);
+    KEY_CASE(REDKEY_PAD_POINT, Decimal);
+
+    KEY_CASE(REDKEY_EUROPEAN, OEM_102);
+    KEY_CASE(REDKEY_F11, F11);
+    KEY_CASE(REDKEY_F12, F12);
+
+    KEY_CASE(REDKEY_JAPANESE_HIRAGANA_KATAKANA, Kana);
+    KEY_CASE(REDKEY_JAPANESE_BACKSLASH, ABNT_C1);
+    KEY_CASE(REDKEY_JAPANESE_HENKAN, Convert);
+    KEY_CASE(REDKEY_JAPANESE_MUHENKAN, NoConvert);
+    KEY_CASE(REDKEY_JAPANESE_YEN, Yen);
+
+    //KEY_CASE(REDKEY_KOREAN_HANGUL_HANJA,
+    //KEY_CASE(REDKEY_KOREAN_HANGUL,
+
+    KEY_CASE(REDKEY_PAD_ENTER, NumpadEnter);
+    KEY_CASE(REDKEY_R_CTRL, RightControl);
+    KEY_CASE(REDKEY_FAKE_L_SHIFT, LeftShift);
+    KEY_CASE(REDKEY_PAD_DIVIDE, Divide);
+    KEY_CASE(REDKEY_FAKE_R_SHIFT, RightShift);
+    KEY_CASE(REDKEY_CTRL_PRINT_SCREEN, SysRq);
+    KEY_CASE(REDKEY_R_ALT, RightAlt);
+    //KEY_CASE(REDKEY_CTRL_BREAK
+    KEY_CASE(REDKEY_HOME, Home);
+    KEY_CASE(REDKEY_UP, ArrowUp);
+    KEY_CASE(REDKEY_PAGEUP, PageUp);
+    KEY_CASE(REDKEY_LEFT, ArrowLeft);
+    KEY_CASE(REDKEY_RIGHT, ArrowRight);
+    KEY_CASE(REDKEY_END, End);
+    KEY_CASE(REDKEY_DOWN, ArrowDown);
+    KEY_CASE(REDKEY_PAGEDOWN, PageDown);
+    KEY_CASE(REDKEY_INSERT, Insert);
+    KEY_CASE(REDKEY_DELETE, Delete);
+    KEY_CASE(REDKEY_LEFT_CMD, LeftWindows);
+    KEY_CASE(REDKEY_RIGHT_CMD, RightWindows);
+    KEY_CASE(REDKEY_MENU, AppMenu);
+    KEY_CASE(REDKEY_PAUSE, Pause);
+    default:
+        return (CEGUI::Key::Scan)0;
+    };
+}
+
+void GUI::on_key_down(RedKey key)
+{
+    CEGUI::Key::Scan scan = red_ket_cegui_scan(key);
+
+    if (scan == (CEGUI::Key::Scan)0) {
+        return;
+    }
+
+    _gui_system->injectKeyDown(scan);
+    conditional_update();
+}
+
+void GUI::on_key_up(RedKey key)
+{
+    CEGUI::Key::Scan scan = red_ket_cegui_scan(key);
+
+    if (scan == (CEGUI::Key::Scan)0) {
+        return;
+    }
+
+    _gui_system->injectKeyUp(scan);
+    conditional_update();
+}
+
+void GUI::on_char(uint32_t ch)
+{
+    _gui_system->injectChar(ch);
+    conditional_update();
+}
+
+void GUI::idle()
+{
+    uint64_t now = Platform::get_monolithic_time();
+    _gui_system->injectTimePulse(float(double(now) - double(_prev_time)) / (1000 * 1000 * 1000));
+    _prev_time = now;
+    conditional_update();
+}
+
+bool GUI::message_box(MessageType type, const char *text, const ButtonsList& buttons,
+                          BoxResponse* _response_handler)
+{
+    if (!_dialog) {
+        set_dialog(new MessageDialog(*this));
+    }
+    return _dialog->message_box(type, text, buttons, _response_handler);
+}
+
diff --git a/client/gui/gui.h b/client/gui/gui.h
new file mode 100644
index 00000000..2e505b02
--- /dev/null
+++ b/client/gui/gui.h
@@ -0,0 +1,120 @@
+#ifndef _H_GUI
+#define _H_GUI
+
+#include "softrenderer.h"
+#include "screen_layer.h"
+#include "inputs_handler.h"
+#include "application.h"
+
+class RedPixmapCairo;
+
+class GUI : public ScreenLayer, public KeyHandler {
+public:
+    class Dialog;
+    class Tab;
+    class TabFactory;
+
+    typedef std::list<TabFactory*> TabFactorys;
+
+    GUI(Application& app, Application::State state);
+    virtual ~GUI();
+
+    void set_screen(RedScreen* screen); //show and hide
+
+    Application& get_application() { return _app;}
+    CEGUI::System& gui_system() { return *_gui_system;}
+
+    void set_state(Application::State state);
+    bool is_visible() { return !!_dialog;}
+    bool prepare_dialog();
+    bool is_disconnect_allowed() { return _app.is_disconnect_allowed();}
+
+    virtual bool pointer_test(int x, int y) { return contains_point(x, y);}
+    virtual void on_pointer_enter(int x, int y, unsigned int buttons_state);
+    virtual void on_pointer_leave();
+    virtual void on_pointer_motion(int x, int y, unsigned int buttons_state);
+    virtual void on_mouse_button_press(int button, int buttons_state);
+    virtual void on_mouse_button_release(int button, int buttons_state);
+
+    virtual void on_key_down(RedKey key);
+    virtual void on_key_up(RedKey key);
+    virtual void on_char(uint32_t ch);
+    virtual bool permit_focus_loss() { return false;}
+
+    void idle();
+
+    virtual void copy_pixels(const QRegion& dest_region, RedDrawable& dest_dc);
+    virtual void on_size_changed();
+
+    void register_tab_factory(TabFactory& factory);
+    void unregister_tab_factory(TabFactory& factory);
+
+    class BoxResponse {
+    public:
+        virtual ~BoxResponse() {}
+        virtual void response(int response) = 0;
+        virtual void aborted() = 0;
+    };
+
+    enum MessageType {
+        QUESTION,
+        INFO,
+        WARNINNG,
+        ERROR,
+    };
+
+    struct ButtonInfo {
+        int id;
+        const char *text;
+    };
+
+    typedef std::vector<ButtonInfo> ButtonsList;
+    bool message_box(MessageType type, const char *text, const ButtonsList& buttons,
+                     BoxResponse* _response_handler);
+
+private:
+    TabFactorys& get_factoris() { return _tab_factorys;}
+
+    void create_dialog();
+    void detach();
+    void update_layer_area();
+    void init_cegui();
+    void conditional_update();
+    void set_dialog(Dialog* dialog);
+
+private:
+    Application& _app;
+    Application::State _state;
+    RedPixmapCairo* _pixmap;
+    CEGUI::SoftRenderer* _renderer;
+    CEGUI::System* _gui_system;
+    Dialog* _dialog;
+    uint64_t _prev_time;
+    TabFactorys _tab_factorys;
+
+    friend class Dialog;
+};
+
+class GUI::Tab {
+public:
+    virtual ~Tab() {}
+
+    virtual CEGUI::Window& get_root_window() = 0;
+    virtual const std::string& get_name() = 0;
+};
+
+class GUI::TabFactory {
+public:
+    TabFactory() : _order (-1) {}
+    TabFactory(int order) : _order (order) {}
+
+    virtual ~TabFactory() {}
+    virtual Tab* create_tab(bool connected, int width, int hight) = 0;
+    int get_order() { return _order;}
+
+private:
+    int _order;
+};
+
+#endif
+
diff --git a/client/gui/resource_provider.cpp b/client/gui/resource_provider.cpp
new file mode 100644
index 00000000..47f86a43
--- /dev/null
+++ b/client/gui/resource_provider.cpp
@@ -0,0 +1,128 @@
+#include "common.h"
+
+#include "resource_provider.h"
+#include "debug.h"
+#include "utils.h"
+
+#include "CEGUIExceptions.h"
+
+#include "taharez_look.scheme.c"
+#include "taharez_look.imageset.c"
+#include "taharez_look.tga.c"
+#include "commonwealth-10.font.c"
+#include "commonv2c.ttf.c"
+#include "taharez_look.looknfeel.c"
+#include "dejavu_sans-10.font.c"
+#include "dejavu_sans.ttf.c"
+
+//(echo "const unsigned char <struct name>[] =
+//{"; od -txC -v <in file name> | sed -e "s/^[0-9]*//" -e s"/ \([0-9a-f][0-9a-f]\)/0x\1,/g" -e"\$d"
+//| sed -e"\$s/,$/};/") > <out file name>.c
+
+void CEGUIResourceProvider::loadRawDataContainer(const CEGUI::String &filename,
+                                              CEGUI::RawDataContainer &output,
+                                              const CEGUI::String &resourceGroup)
+{
+    DBG(0, "%s", filename.c_str());
+    if (strcmp(filename.c_str(), "TaharezLook.scheme") == 0) {
+        DBG(0, "size %d", sizeof(taharez_look_schem));
+         output.setData((CEGUI::uint8*)taharez_look_schem);
+         output.setSize(sizeof(taharez_look_schem));
+         return;
+    }
+
+    if (strcmp(filename.c_str(), "TaharezLook.imageset") == 0) {
+        DBG(0, "size %d", sizeof(taharez_look_imageset));
+        output.setData((CEGUI::uint8*)taharez_look_imageset);
+        output.setSize(sizeof(taharez_look_imageset));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "TaharezLook.tga") == 0) {
+        DBG(0, "size %d", sizeof(taharez_look_tga));
+        output.setData((CEGUI::uint8*)taharez_look_tga);
+        output.setSize(sizeof(taharez_look_tga));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "Commonwealth-10.font") == 0) {
+        DBG(0, "size %d", sizeof(commonwealth_10_font));
+        output.setData((CEGUI::uint8*)commonwealth_10_font);
+        output.setSize(sizeof(commonwealth_10_font));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "Commonv2c.ttf") == 0) {
+        DBG(0, "size %d", sizeof(commonv2c_ttf));
+        output.setData((CEGUI::uint8*)commonv2c_ttf);
+        output.setSize(sizeof(commonv2c_ttf));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "TaharezLook.looknfeel") == 0) {
+        DBG(0, "size %d", sizeof(taharez_look_looknfeel));
+        output.setData((CEGUI::uint8*)taharez_look_looknfeel);
+        output.setSize(sizeof(taharez_look_looknfeel));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "DejaVuSans-10.font") == 0) {
+        DBG(0, "size %d", sizeof(dejavu_sans_10_font));
+        output.setData((CEGUI::uint8*)dejavu_sans_10_font);
+        output.setSize(sizeof(dejavu_sans_10_font));
+        return;
+    }
+
+    if (strcmp(filename.c_str(), "DejaVuSans.ttf") == 0) {
+        DBG(0, "size %d", sizeof(dejavu_sans_ttf));
+        output.setData((CEGUI::uint8*)dejavu_sans_ttf);
+        output.setSize(sizeof(dejavu_sans_ttf));
+        return;
+    }
+
+    throw CEGUI::GenericException("failed");
+}
+
+void CEGUIResourceProvider::unloadRawDataContainer(CEGUI::RawDataContainer& data)
+{
+    data.setData(NULL);
+    data.setSize(0);
+}
+
+struct ResString{
+    int id;
+    const char* str;
+} res_strings[] = {
+    {STR_MESG_MISSING_HOST_NAME, "Missing host name"},
+    {STR_MESG_INVALID_PORT, "Invalid port"},
+    {STR_MESG_INVALID_SPORT, "Invalid sport"},
+    {STR_MESG_MISSING_PORT, "Missing port"},
+    {STR_MESG_CONNECTING, "Connecting to"},
+    {STR_BUTTON_OK, "OK"},
+    {STR_BUTTON_CANCEL, "Cancel"},
+    {STR_BUTTON_CONNECT, "Connect"},
+    {STR_BUTTON_QUIT, "Quit"},
+    {STR_BUTTON_CLOSE, "Close"},
+    {STR_BUTTON_DISCONNECT, "Disconnect"},
+    {STR_BUTTON_OPTIONS, "Options"},
+    {STR_BUTTON_BACK, "Back"},
+    {STR_LABEL_HOST, "Host"},
+    {STR_LABEL_PORT, "Port"},
+    {STR_LABEL_SPORT, "Secore port"},
+    {STR_LABEL_PASSWORD, "Password"},
+    {0, NULL},
+};
+
+const char* res_get_string(int id)
+{
+    ResString *string;
+
+    for (string = res_strings; string->str; string++) {
+        if (string->id == id) {
+            return string->str;
+        }
+    }
+
+    return NULL;
+}
+
diff --git a/client/gui/resource_provider.h b/client/gui/resource_provider.h
new file mode 100644
index 00000000..1443abe4
--- /dev/null
+++ b/client/gui/resource_provider.h
@@ -0,0 +1,40 @@
+#ifndef _H_RESOURCE_PROVIDER
+#define _H_RESOURCE_PROVIDER
+
+#include "CEGUIDefaultResourceProvider.h"
+
+class CEGUIResourceProvider: public CEGUI::ResourceProvider {
+public:
+    virtual void loadRawDataContainer(const CEGUI::String &filename,
+                                      CEGUI::RawDataContainer &output,
+                                      const CEGUI::String &resourceGroup);
+
+    virtual void unloadRawDataContainer(CEGUI::RawDataContainer& data);
+};
+
+enum {
+    STR_INVALID,
+    STR_MESG_MISSING_HOST_NAME,
+    STR_MESG_INVALID_PORT,
+    STR_MESG_INVALID_SPORT,
+    STR_MESG_MISSING_PORT,
+    STR_MESG_CONNECTING,
+    STR_BUTTON_OK,
+    STR_BUTTON_CANCEL,
+    STR_BUTTON_CONNECT,
+    STR_BUTTON_QUIT,
+    STR_BUTTON_CLOSE,
+    STR_BUTTON_DISCONNECT,
+    STR_BUTTON_OPTIONS,
+    STR_BUTTON_BACK,
+    STR_LABEL_HOST,
+    STR_LABEL_PORT,
+    STR_LABEL_SPORT,
+    STR_LABEL_PASSWORD,
+};
+
+//todo: move to x11/res.cpp and make x11/res.cpp cross-platform
+const char* res_get_string(int id);
+
+#endif
+
diff --git a/client/gui/softrenderer.cpp b/client/gui/softrenderer.cpp
index 9e08f7a5..87fffb8b 100644
--- a/client/gui/softrenderer.cpp
+++ b/client/gui/softrenderer.cpp
@@ -64,19 +64,23 @@ void SoftRenderer::setupImageCodec()
 #else
     String _default_codec_name(STRINGIZE(TGAImageCodec/*CEGUI_DEFAULT_IMAGE_CODEC*/));
     DynamicModule* module = NULL;
+
     try {
         DynamicModule* module = new DynamicModule(String("CEGUI") + _default_codec_name);
 
         _destroy_image_codec = (void(*)(ImageCodec*))module->getSymbolAddress("destroyImageCodec");
+
         if (!_destroy_image_codec) {
             throw GenericException("Missing destroyImageCodec symbol");
         }
 
         ImageCodec* (*create_f)(void);
         create_f = (ImageCodec* (*)(void))module->getSymbolAddress("createImageCodec");
+
         if (!create_f) {
             throw GenericException("Missing createImageCodec symbol");
         }
+
         _image_codec = create_f();
     } catch (...) {
         delete module;
@@ -86,14 +90,12 @@ void SoftRenderer::setupImageCodec()
 #endif
 }
 
-
 void SoftRenderer::cleanupImageCodec()
 {
     _destroy_image_codec(_image_codec);
     delete _image_codec_module;
 }
 
-
 static inline uint8_t calac_pixel(uint64_t c1, uint64_t c2, uint64_t c3, uint64_t a_mul)
 {
     //(c' * c" * a' * a" + c"' * 255 ^ 3 - c"' * a' * a" * 255) / 255^4
@@ -369,4 +371,3 @@ uint SoftRenderer::getVertScreenDPI() const
 
 }
 
-
diff --git a/client/gui/softrenderer.h b/client/gui/softrenderer.h
index 939eb38b..9fc1a29e 100644
--- a/client/gui/softrenderer.h
+++ b/client/gui/softrenderer.h
@@ -128,4 +128,3 @@ namespace CEGUI
 
 #endif
 
-