From 7fd6153720746edff4af900dc9c3579d3cde6e32 Mon Sep 17 00:00:00 2001
From: "louiz@4325f9fc-e183-4c21-96ce-0ab188b42d13"
 <louiz@4325f9fc-e183-4c21-96ce-0ab188b42d13>
Date: Tue, 9 Nov 2010 20:37:39 +0000
Subject: fix some little issues. Rename gui to core, use logging lib instead
 of the custom debug option. Add a -d option

---
 launch.sh            |    2 +-
 src/common.py        |   10 -
 src/config.py        |   11 +-
 src/connection.py    |    3 +
 src/core.py          | 1398 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/gui.py           | 1393 -------------------------------------------------
 src/multiuserchat.py |    7 +-
 src/poezio.py        |   54 +-
 src/tab.py           |   97 ++--
 9 files changed, 1487 insertions(+), 1488 deletions(-)
 create mode 100644 src/core.py
 delete mode 100644 src/gui.py

diff --git a/launch.sh b/launch.sh
index b4b2384f..99b6708d 100644
--- a/launch.sh
+++ b/launch.sh
@@ -1,4 +1,4 @@
 #!/usr/bin/env sh
 
-cd src/ && python3 poezio.py "$@"
+python3 src/poezio.py "$@"
 
diff --git a/src/common.py b/src/common.py
index 53318e19..384fd28f 100644
--- a/src/common.py
+++ b/src/common.py
@@ -51,16 +51,6 @@ ROOM_STATE_PRIVATE = 15
 ROOM_STATE_MESSAGE = 12
 ROOM_STATE_HL = 13
 
-def debug(string):
-    """
-    Print a string in a file.
-    Useful since debuging cannot be displayed on screen because it's
-    a CLI software
-    """
-    fdes = open("/tmp/debug", 'a')
-    fdes.write(string)
-    fdes.close()
-
 def get_base64_from_file(path):
     """
     Convert the content of a file to base64
diff --git a/src/config.py b/src/config.py
index 287c47ec..a3f03849 100644
--- a/src/config.py
+++ b/src/config.py
@@ -137,13 +137,8 @@ if not path.isfile(CONFIG_PATH+'poezio.cfg'):
 
 parser = OptionParser()
 parser.add_option("-f", "--file", dest="filename", default=CONFIG_PATH+'poezio.cfg',
-                  help="the config file you want to use", metavar="CONFIG_FILE")
+                  help="The config file you want to use", metavar="CONFIG_FILE")
+parser.add_option("-d", "--debug", dest="debug",
+                  help="The file where debug will be written", metavar="DEBUG_FILE")
 (options, args) = parser.parse_args()
 config = Config(options.filename)
-
-if __name__ == '__main__':
-    # tests
-    import sys
-    (dummy, filename, section, option, value) = sys.argv
-    conf = Config(sys.argv[1])
-    conf.write_in_file(section, option, value)
diff --git a/src/connection.py b/src/connection.py
index 2e74e4e1..2f016901 100644
--- a/src/connection.py
+++ b/src/connection.py
@@ -58,3 +58,6 @@ class Connection(sleekxmpp.ClientXMPP):
         else:
             self.connect()
         self.process(threaded=True)
+
+# Global connection object
+connection = Connection()
diff --git a/src/core.py b/src/core.py
new file mode 100644
index 00000000..23bc3ed4
--- /dev/null
+++ b/src/core.py
@@ -0,0 +1,1398 @@
+# Copyright 2010 Le Coz Florent <louiz@louiz.org>
+#
+# This file is part of Poezio.
+#
+# Poezio is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, version 3 of the License.
+#
+# Poezio is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with Poezio.  If not, see <http://www.gnu.org/licenses/>.
+
+from gettext import (bindtextdomain, textdomain, bind_textdomain_codeset,
+                     gettext as _)
+from os.path import isfile
+
+from time import sleep
+
+import os
+import re
+import sys
+import shlex
+import curses
+import threading
+import webbrowser
+
+from datetime import datetime
+
+import common
+import theme
+
+import multiuserchat as muc
+from connection import connection
+from handler import Handler
+from config import config
+from tab import MucTab, InfoTab, PrivateTab, RosterInfoTab, ConversationTab
+from user import User
+from room import Room
+from roster import Roster, RosterGroup, roster
+from contact import Contact, Resource
+from message import Message
+from text_buffer import TextBuffer
+from keyboard import read_char
+from common import jid_get_domain, is_jid
+
+# http://xmpp.org/extensions/xep-0045.html#errorstatus
+ERROR_AND_STATUS_CODES = {
+    '401': _('A password is required'),
+    '403': _('You are banned from the room'),
+    '404': _('The room does\'nt exist'),
+    '405': _('Your are not allowed to create a new room'),
+    '406': _('A reserved nick must be used'),
+    '407': _('You are not in the member list'),
+    '409': _('This nickname is already in use or has been reserved'),
+    '503': _('The maximum number of users has been reached'),
+    }
+
+SHOW_NAME = {
+    'dnd': _('busy'),
+    'away': _('away'),
+    'xa': _('not available'),
+    'chat': _('chatty'),
+    '': _('available')
+    }
+
+resize_lock = threading.Lock()
+
+class Core(object):
+    """
+    User interface using ncurses
+    """
+    def __init__(self, xmpp):
+        self.running = True
+        self.stdscr = curses.initscr()
+        self.init_curses(self.stdscr)
+        self.xmpp = xmpp
+        default_tab = InfoTab(self.stdscr, self, "Info") if self.xmpp.anon\
+            else RosterInfoTab(self.stdscr, self)
+        default_tab.on_gain_focus()
+        self.tabs = [default_tab]
+        # self.roster = Roster()
+        # a unique buffer used to store global informations
+        # that are displayed in almost all tabs, in an
+        # information window.
+        self.information_buffer = TextBuffer()
+        self.information_win_size = 2 # Todo, get this from config
+        self.ignores = {}
+        self.resize_timer = None
+        self.previous_tab_nb = 0
+
+        self.commands = {
+            'help': (self.command_help, '\_o< KOIN KOIN KOIN'),
+            'join': (self.command_join, _("Usage: /join [room_name][@server][/nick] [password]\nJoin: Join the specified room. You can specify a nickname after a slash (/). If no nickname is specified, you will use the default_nick in the configuration file. You can omit the room name: you will then join the room you\'re looking at (useful if you were kicked). You can also provide a room_name without specifying a server, the server of the room you're currently in will be used. You can also provide a password to join the room.\nExamples:\n/join room@server.tld\n/join room@server.tld/John\n/join room2\n/join /me_again\n/join\n/join room@server.tld/my_nick password\n/join / password")),
+            'quit': (self.command_quit, _("Usage: /quit\nQuit: Just disconnect from the server and exit poezio.")),
+            'exit': (self.command_quit, _("Usage: /exit\nExit: Just disconnect from the server and exit poezio.")),
+            'next': (self.rotate_rooms_right, _("Usage: /next\nNext: Go to the next room.")),
+            'n': (self.rotate_rooms_right, _("Usage: /n\nN: Go to the next room.")),
+            'prev': (self.rotate_rooms_left, _("Usage: /prev\nPrev: Go to the previous room.")),
+            'p': (self.rotate_rooms_left, _("Usage: /p\nP: Go to the previous room.")),
+            'win': (self.command_win, _("Usage: /win <number>\nWin: Go to the specified room.")),
+            'w': (self.command_win, _("Usage: /w <number>\nW: Go to the specified room.")),
+            'ignore': (self.command_ignore, _("Usage: /ignore <nickname> \nIgnore: Ignore a specified nickname.")),
+            'unignore': (self.command_unignore, _("Usage: /unignore <nickname>\nUnignore: Remove the specified nickname from the ignore list.")),
+            'part': (self.command_part, _("Usage: /part [message]\n Part: disconnect from a room. You can specify an optional message.")),
+            'show': (self.command_show, _("Usage: /show <availability> [status]\nShow: Change your availability and (optionaly) your status. The <availability> argument is one of \"avail, available, ok, here, chat, away, afk, dnd, busy, xa\" and the optional [status] argument will be your status message")),
+            'away': (self.command_away, _("Usage: /away [message]\nAway: Sets your availability to away and (optional) sets your status message. This is equivalent to '/show away [message]'")),
+            'busy': (self.command_busy, _("Usage: /busy [message]\nBusy: Sets your availability to busy and (optional) sets your status message. This is equivalent to '/show busy [message]'")),
+            'avail': (self.command_avail, _("Usage: /avail [message]\nAvail: Sets your availability to available and (optional) sets your status message. This is equivalent to '/show available [message]'")),
+            'available': (self.command_avail, _("Usage: /available [message]\nAvailable: Sets your availability to available and (optional) sets your status message. This is equivalent to '/show available [message]'")),
+           'bookmark': (self.command_bookmark, _("Usage: /bookmark [roomname][/nick]\nBookmark: Bookmark the specified room (you will then auto-join it on each poezio start). This commands uses the same syntaxe as /join. Type /help join for syntaxe examples. Note that when typing \"/bookmark\" on its own, the room will be bookmarked with the nickname you\'re currently using in this room (instead of default_nick)")),
+            'unquery': (self.command_unquery, _("Usage: /unquery\nClose the private conversation window")),
+            'set': (self.command_set, _("Usage: /set <option> [value]\nSet: Sets the value to the option in your configuration file. You can, for example, change your default nickname by doing `/set default_nick toto` or your resource with `/set resource blabla`. You can also set an empty value (nothing) by providing no [value] after <option>.")),
+            'kick': (self.command_kick, _("Usage: /kick <nick> [reason]\nKick: Kick the user with the specified nickname. You also can give an optional reason.")),
+            'topic': (self.command_topic, _("Usage: /topic <subject> \nTopic: Change the subject of the room")),
+            'link': (self.command_link, _("Usage: /link [option] [number]\nLink: Interact with a link in the conversation. Available options are 'open', 'copy'. Open just opens the link in the browser if it's http://, Copy just copy the link in the clipboard. An optional number can be provided, it indicates which link to interact with.")),
+            'query': (self.command_query, _('Usage: /query <nick> [message]\nQuery: Open a private conversation with <nick>. This nick has to be present in the room you\'re currently in. If you specified a message after the nickname, it will immediately be sent to this user')),
+            'nick': (self.command_nick, _("Usage: /nick <nickname>\nNick: Change your nickname in the current room")),
+            'say': (self.command_say, _('Usage: /say <message>\nSay: Just send the message. Useful if you want your message to begin with a "/"')),
+            'whois': (self.command_whois, _('Usage: /whois <nickname>\nWhois: Request many informations about the user.')),
+            'theme': (self.command_theme, _('Usage: /theme\nTheme: Reload the theme defined in the config file.')),
+            'recolor': (self.command_recolor, _('Usage: /recolor\nRecolor: Re-assign a color to all participants of the current room, based on the last time they talked. Use this if the participants currently talking have too many identical colors.')),
+            }
+
+        self.key_func = {
+            "KEY_PPAGE": self.scroll_page_up,
+            "KEY_NPAGE": self.scroll_page_down,
+            "KEY_F(5)": self.rotate_rooms_left,
+            "^P": self.rotate_rooms_left,
+            "KEY_F(6)": self.rotate_rooms_right,
+            "KEY_F(7)": self.shrink_information_win,
+            "KEY_F(8)": self.grow_information_win,
+            "^N": self.rotate_rooms_right,
+            "KEY_RESIZE": self.call_for_resize,
+            'M-e': self.go_to_important_room,
+            'M-r': self.go_to_roster,
+            'M-z': self.go_to_previous_tab,
+            'M-v': self.move_separator,
+            }
+
+        # Add handlers
+        self.xmpp.add_event_handler("session_start", self.on_connected)
+        self.xmpp.add_event_handler("groupchat_presence", self.on_groupchat_presence)
+        self.xmpp.add_event_handler("groupchat_message", self.on_groupchat_message)
+        self.xmpp.add_event_handler("message", self.on_message)
+        self.xmpp.add_event_handler("got_online" , self.on_got_online)
+        self.xmpp.add_event_handler("got_offline" , self.on_got_offline)
+        self.xmpp.add_event_handler("roster_update", self.on_roster_update)
+        self.xmpp.add_event_handler("changed_status", self.on_presence)
+
+        # self.__debug_fill_roster()
+
+    def grow_information_win(self):
+        """
+        """
+        if self.information_win_size == 14:
+            return
+        self.information_win_size += 1
+        for tab in self.tabs:
+            tab.on_info_win_size_changed(self.stdscr)
+        self.refresh_window()
+
+    def shrink_information_win(self):
+        """
+        """
+        if self.information_win_size == 0:
+            return
+        self.information_win_size -= 1
+        for tab in self.tabs:
+            tab.on_info_win_size_changed(self.stdscr)
+        self.refresh_window()
+
+    def on_got_offline(self, presence):
+        jid = presence['from']
+        contact = roster.get_contact_by_jid(jid.bare)
+        if not contact:
+            return
+        resource = contact.get_resource_by_fulljid(jid.full)
+        assert resource
+        self.information('%s is offline' % (resource.get_jid()), "Roster")
+        contact.remove_resource(resource)
+        if isinstance(self.current_tab(), RosterInfoTab):
+            self.refresh_window()
+
+    def on_got_online(self, presence):
+        jid = presence['from']
+        contact = roster.get_contact_by_jid(jid.bare)
+        if not contact:
+            # Todo, handle presence comming from contacts not in roster
+            return
+        resource = contact.get_resource_by_fulljid(jid.full)
+        assert not resource
+        resource = Resource(jid.full)
+        status = presence['type']
+        priority = presence.getPriority() or 0
+        resource.set_presence(status)
+        resource.set_priority(priority)
+        contact.add_resource(resource)
+        self.information("%s is online (%s)" % (resource.get_jid().full, status), "Roster")
+
+    def on_connected(self, event):
+        """
+        Called when we are connected and authenticated
+        """
+        self.information(_("Welcome on Poezio \o/!"))
+        self.information(_("Your JID is %s") % self.xmpp.boundjid.full)
+
+        if not self.xmpp.anon:
+            # request the roster
+            self.xmpp.getRoster()
+            # send initial presence
+            self.xmpp.makePresence(pfrom=self.xmpp.boundjid.bare).send()
+        rooms = config.get('rooms', '')
+        if rooms == '' or not isinstance(rooms, str):
+            return
+        rooms = rooms.split(':')
+        for room in rooms:
+            args = room.split('/')
+            if args[0] == '':
+                return
+            roomname = args[0]
+            if len(args) == 2:
+                nick = args[1]
+            else:
+                default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
+                nick = config.get('default_nick', '')
+                if nick == '':
+                    nick = default
+            self.open_new_room(roomname, nick, False)
+            muc.join_groupchat(self.xmpp, roomname, nick)
+        # if not self.xmpp.anon:
+        # Todo: SEND VCARD
+        return
+        if config.get('jid', '') == '': # Don't send the vcard if we're not anonymous
+            self.vcard_sender.start()   # because the user ALREADY has one on the server
+
+    def on_groupchat_presence(self, presence):
+        """
+        Triggered whenever a presence stanza is received from a user in a multi-user chat room.
+        Display the presence on the room window and update the
+        presence information of the concerned user
+        """
+        from_nick = presence['from'].resource
+        from_room = presence['from'].bare
+        room = self.get_room_by_name(from_room)
+        code = presence.find('{jabber:client}status')
+        status_codes = set([s.attrib['code'] for s in presence.findall('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}status')])
+        # Check if it's not an error presence.
+        if presence['type'] == 'error':
+            return self.room_error(presence, from_room)
+        if not room:
+            return
+        msg = None
+        affiliation = presence['muc']['affiliation']
+        show = presence['show']
+        status = presence['status']
+        role = presence['muc']['role']
+        jid = presence['muc']['jid']
+        typ = presence['type']
+        if not room.joined:     # user in the room BEFORE us.
+            # ignore redondant presence message, see bug #1509
+            if from_nick not in [user.nick for user in room.users]:
+                new_user = User(from_nick, affiliation, show, status, role)
+                room.users.append(new_user)
+                if from_nick == room.own_nick:
+                    room.joined = True
+                    new_user.color = theme.COLOR_OWN_NICK
+                    self.add_message_to_text_buffer(room, _("Your nickname is %s") % (from_nick))
+                    if '170' in status_codes:
+                        self.add_message_to_text_buffer(room, 'Warning: this room is publicly logged')
+        else:
+            change_nick = '303' in status_codes
+            kick = '307' in status_codes and typ == 'unavailable'
+            user = room.get_user_by_name(from_nick)
+            # New user
+            if not user:
+                self.on_user_join(room, from_nick, affiliation, show, status, role, jid)
+            # nick change
+            elif change_nick:
+                self.on_user_nick_change(room, presence, user, from_nick, from_room)
+            # kick
+            elif kick:
+                self.on_user_kicked(room, presence, user, from_nick)
+            # user quit
+            elif typ == 'unavailable':
+                self.on_user_leave_groupchat(room, user, jid, status, from_nick, from_room)
+            # status change
+            else:
+                self.on_user_change_status(room, user, from_nick, from_room, affiliation, role, show, status)
+        self.refresh_window()
+        self.doupdate()
+
+    def on_user_join(self, room, from_nick, affiliation, show, status, role, jid):
+        """
+        When a new user joins a groupchat
+        """
+        room.users.append(User(from_nick, affiliation,
+                               show, status, role))
+        hide_exit_join = config.get('hide_exit_join', -1)
+        if hide_exit_join != 0:
+            if not jid.full:
+                self.add_message_to_text_buffer(room, _('%(spec)s "[%(nick)s]" joined the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_JOIN.replace('"', '\\"')}, colorized=True)
+            else:
+                self.add_message_to_text_buffer(room, _('%(spec)s "[%(nick)s]" "(%(jid)s)" joined the room') % {'spec':theme.CHAR_JOIN.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'jid':jid.full}, colorized=True)
+
+    def on_user_nick_change(self, room, presence, user, from_nick, from_room):
+        new_nick = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item').attrib['nick']
+        if user.nick == room.own_nick:
+            room.own_nick = new_nick
+            # also change our nick in all private discussion of this room
+            for _tab in self.tabs:
+                if isinstance(_tab, PrivateTab) and _tab.get_name().split('/', 1)[0] == room.name:
+                    _tab.get_room().own_nick = new_nick
+        user.change_nick(new_nick)
+        self.add_message_to_text_buffer(room, _('"[%(old)s]" is now known as "[%(new)s]"') % {'old':from_nick.replace('"', '\\"'), 'new':new_nick.replace('"', '\\"')}, colorized=True)
+        # rename the private tabs if needed
+        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
+        if private_room:
+            self.add_message_to_text_buffer(private_room, _('"[%(old_nick)s]" is now known as "[%(new_nick)s]"') % {'old_nick':from_nick.replace('"', '\\"'), 'new_nick':new_nick.replace('"', '\\"')}, colorized=True)
+            new_jid = private_room.name.split('/', 1)[0]+'/'+new_nick
+            private_room.name = new_jid
+
+    def on_user_kicked(self, room, presence, user, from_nick):
+        """
+        When someone is kicked
+        """
+        room.users.remove(user)
+        by = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item/{http://jabber.org/protocol/muc#user}actor')
+        reason = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item/{http://jabber.org/protocol/muc#user}reason')
+        by = by.attrib['jid'] if by is not None else None
+        reason = reason.text if reason else ''
+        if from_nick == room.own_nick: # we are kicked
+            room.disconnect()
+            if by:
+                kick_msg = _('%(spec)s [You] have been kicked by "[%(by)s]"') % {'spec': theme.CHAR_KICK.replace('"', '\\"'), 'by':by}
+            else:
+                kick_msg = _('%(spec)s [You] have been kicked.') % {'spec':theme.CHAR_KICK.replace('"', '\\"')}
+            # try to auto-rejoin
+            if config.get('autorejoin', 'false') == 'true':
+                muc.join_groupchat(self.xmpp, room.name, room.own_nick)
+        else:
+            if by:
+                kick_msg = _('%(spec)s "[%(nick)s]" has been kicked by "[%(by)s]"') % {'spec':theme.CHAR_KICK.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'by':by.replace('"', '\\"')}
+            else:
+                kick_msg = _('%(spec)s "[%(nick)s]" has been kicked') % {'spec':theme.CHAR_KICK, 'nick':from_nick.replace('"', '\\"')}
+        if reason:
+            kick_msg += _(' Reason: %(reason)s') % {'reason': reason}
+        self.add_message_to_text_buffer(room, kick_msg, colorized=True)
+
+    def on_user_leave_groupchat(self, room, user, jid, status, from_nick, from_room):
+        """
+        When an user leaves a groupchat
+        """
+        room.users.remove(user)
+        if room.own_nick == user.nick:
+            # We are now out of the room. Happens with some buggy (? not sure) servers
+            room.disconnect()
+        hide_exit_join = config.get('hide_exit_join', -1) if config.get('hide_exit_join', -1) >= -1 else -1
+        if hide_exit_join == -1 or user.has_talked_since(hide_exit_join):
+            if not jid.full:
+                leave_msg = _('%(spec)s "[%(nick)s]" has left the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT.replace('"', '\\"')}
+            else:
+                leave_msg = _('%(spec)s "[%(nick)s]" "(%(jid)s)" has left the room') % {'spec':theme.CHAR_QUIT.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'jid':jid.full.replace('"', '\\"')}
+            if status:
+                leave_msg += ' (%s)' % status
+            self.add_message_to_text_buffer(room, leave_msg, colorized=True)
+        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
+        if private_room:
+            if not status:
+                self.add_message_to_text_buffer(private_room, _('%(spec)s "[%(nick)s]" has left the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT.replace('"', '\\"')}, colorized=True)
+            else:
+                self.add_message_to_text_buffer(private_room, _('%(spec)s "[%(nick)s]" has left the room "(%(status)s)"') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT, 'status': status.replace('"', '\\"')}, colorized=True)
+
+    def on_user_change_status(self, room, user, from_nick, from_room, affiliation, role, show, status):
+        """
+        When an user changes her status
+        """
+        # build the message
+        display_message = False # flag to know if something significant enough
+        # to be displayed has changed
+        msg = _('"%s" changed: ')% from_nick.replace('"', '\\"')
+        if affiliation != user.affiliation:
+            msg += _('affiliation: %s, ') % affiliation
+            display_message = True
+        if role != user.role:
+            msg += _('role: %s, ') % role
+            display_message = True
+        if show != user.show and show in list(SHOW_NAME.keys()):
+            msg += _('show: %s, ') % SHOW_NAME[show]
+            display_message = True
+        if status and status != user.status:
+            msg += _('status: %s, ') % status
+            display_message = True
+        if not display_message:
+            return
+        msg = msg[:-2] # remove the last ", "
+        hide_status_change = config.get('hide_status_change', -1) if config.get('hide_status_change', -1) >= -1 else -1
+        if (hide_status_change == -1 or \
+                user.has_talked_since(hide_status_change) or\
+                user.nick == room.own_nick)\
+                and\
+                (affiliation != user.affiliation or\
+                    role != user.role or\
+                    show != user.show or\
+                    status != user.status):
+            # display the message in the room
+            self.add_message_to_text_buffer(room, msg, colorized=True)
+        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
+        if private_room: # display the message in private
+            self.add_message_to_text_buffer(private_room, msg, colorized=True)
+        # finally, effectively change the user status
+        user.update(affiliation, show, status, role)
+
+    def on_message(self, message):
+        """
+        When receiving private message from a muc OR a normal message
+        (from one of our contacts)
+        """
+        if message['type'] == 'groupchat':
+            return None
+        # Differentiate both type of messages, and call the appropriate handler.
+        jid_from = message['from']
+        for tab in self.tabs:
+            if isinstance(tab, MucTab) and tab.get_name() == jid_from.bare: # check all the MUC we are in
+                if message['type'] == 'error':
+                    return self.room_error(message, tab.get_room().name)
+                else:
+                    return self.on_groupchat_private_message(message)
+        return self.on_normal_message(message)
+
+    def on_groupchat_private_message(self, message):
+        """
+        We received a Private Message (from someone in a Muc)
+        """
+        jid = message['from']
+        nick_from = jid.resource
+        room_from = jid.bare
+        room = self.get_room_by_name(jid.full) # get the tab with the private conversation
+        if not room: # It's the first message we receive: create the tab
+            room = self.open_private_window(room_from, nick_from, False)
+            if not room:
+                return
+        body = message['body']
+        self.add_message_to_text_buffer(room, body, None, nick_from)
+        self.refresh_window()
+        self.doupdate()
+
+    def focus_tab_named(self, tab_name):
+        for tab in self.tabs:
+            if tab.get_name() == tab_name:
+                self.command_win('%s' % (tab.nb,))
+
+    def on_normal_message(self, message):
+        """
+        When receiving "normal" messages (from someone in our roster)
+        """
+        jid = message['from'].bare
+        room = self.get_conversation_by_jid(jid)
+        body = message['body']
+        if not body:
+            return
+        if not room:
+            room = self.open_conversation_window(jid, False)
+            if not room:
+                return
+        self.add_message_to_text_buffer(room, body, None, jid)
+        self.refresh_window()
+        return
+
+    def on_presence(self, presence):
+        """
+        """
+        jid = presence['from']
+        contact = roster.get_contact_by_jid(jid.bare)
+        if not contact:
+            return
+        resource = contact.get_resource_by_fulljid(jid.full)
+        if not resource:
+            return
+        status = presence['type']
+        priority = presence.getPriority() or 0
+        resource.set_presence(status)
+        resource.set_priority(priority)
+        if isinstance(self.current_tab(), RosterInfoTab):
+            self.refresh_window()
+
+    def __debug_fill_roster(self):
+        for i in range(10):
+            jid = 'contact%s@fion%s.org'%(i,i)
+            contact = Contact(jid)
+            contact.set_ask('wat')
+            contact.set_subscription('both')
+            roster.add_contact(contact, jid)
+            contact.set_name('%s %s fion'%(i,i))
+            roster.edit_groups_of_contact(contact, ['hello'])
+        for i in range(10):
+            jid = 'test%s@bernard%s.org'%(i,i)
+            contact = Contact(jid)
+            contact.set_ask('wat')
+            contact.set_subscription('both')
+            roster.add_contact(contact, jid)
+            contact.set_name('%s test'%(i))
+            roster.edit_groups_of_contact(contact, ['hello'])
+        for i in range(10):
+            jid = 'pouet@top%s.org'%(i)
+            contact = Contact(jid)
+            contact.set_ask('wat')
+            contact.set_subscription('both')
+            roster.add_contact(contact, jid)
+            contact.set_name('%s oula'%(i))
+            roster.edit_groups_of_contact(contact, ['hello'])
+        if isinstance(self.current_tab(), RosterInfoTab):
+            self.refresh_window()
+
+    def on_roster_update(self, iq):
+        """
+        A subscription changed, or we received a roster item
+        after a roster request, etc
+        """
+        for item in iq.findall('{jabber:iq:roster}query/{jabber:iq:roster}item'):
+            jid = item.attrib['jid']
+            contact = roster.get_contact_by_jid(jid)
+            if not contact:
+                contact = Contact(jid)
+                roster.add_contact(contact, jid)
+            if 'ask' in item.attrib:
+                contact.set_ask(item.attrib['ask'])
+            else:
+                contact.set_ask(None)
+            if 'name' in item.attrib:
+                contact.set_name(item.attrib['name'])
+            else:
+                contact.set_name(None)
+            if item.attrib['subscription']:
+                contact.set_subscription(item.attrib['subscription'])
+            groups = item.findall('{jabber:iq:roster}group')
+            roster.edit_groups_of_contact(contact, [group.text for group in groups])
+        if isinstance(self.current_tab(), RosterInfoTab):
+            self.refresh_window()
+
+    def call_for_resize(self):
+        """
+        Starts a very short timer. If no other terminal resize
+        occured in this delay then poezio is REALLY resize.
+        This is to avoid multiple unnecessary software resizes (this
+        can be heavy on resource on slow computers or networks)
+        """
+        # with resize_lock:
+            # if self.resize_timer:
+            #     # a recent terminal resize occured.
+            #     # Cancel the programmed software resize
+            #     self.resize_timer.cancel()
+            # # add the new timer
+            # self.resize_timer = threading.Timer(0.15, self.resize_window)
+            # self.resize_timer.start()
+        self.resize_window()
+
+    def resize_window(self):
+        """
+        Resize the whole screen
+        """
+        with resize_lock:
+           # self.resize_timer = None
+            for tab in self.tabs:
+                tab.resize(self.stdscr)
+            self.refresh_window()
+
+    def main_loop(self):
+        """
+        main loop waiting for the user to press a key
+        """
+        self.refresh_window()
+        while self.running:
+            self.doupdate()
+            char=read_char(self.stdscr)
+            # search for keyboard shortcut
+            if char in list(self.key_func.keys()):
+                self.key_func[char]()
+            else:
+                self.do_command(char)
+
+    def current_tab(self):
+        """
+        returns the current room, the one we are viewing
+        """
+        return self.tabs[0]
+
+    def get_conversation_by_jid(self, jid):
+        """
+        Return the room of the ConversationTab with the given jid
+        """
+        for tab in self.tabs:
+            if isinstance(tab, ConversationTab):
+                if tab.get_name() == jid:
+                    return tab.get_room()
+        return None
+
+    def get_room_by_name(self, name):
+        """
+        returns the room that has this name
+        """
+        for tab in self.tabs:
+            if (isinstance(tab, MucTab) or
+                isinstance(tab, PrivateTab)) and tab.get_name() == name:
+                return tab.get_room()
+        return None
+
+    def init_curses(self, stdscr):
+        """
+        ncurses initialization
+        """
+        curses.curs_set(1)
+        curses.noecho()
+        # curses.raw()
+        theme.init_colors()
+        stdscr.keypad(True)
+
+    def reset_curses(self):
+        """
+        Reset terminal capabilities to what they were before ncurses
+        init
+        """
+        curses.echo()
+        curses.nocbreak()
+        curses.endwin()
+
+    def refresh_window(self):
+        """
+        Refresh everything
+        """
+        self.current_tab().set_color_state(theme.COLOR_TAB_CURRENT)
+        self.current_tab().refresh(self.tabs, self.information_buffer, roster)
+        self.doupdate()
+
+    def open_new_room(self, room, nick, focus=True):
+        """
+        Open a new MucTab containing a muc Room, using the specified nick
+        """
+        r = Room(room, nick)
+        new_tab = MucTab(self.stdscr, self, r)
+        if self.current_tab().nb == 0:
+            self.tabs.append(new_tab)
+        else:
+            for ta in self.tabs:
+                if ta.nb == 0:
+                    self.tabs.insert(self.tabs.index(ta), new_tab)
+                    break
+        if focus:
+            self.command_win("%s" % new_tab.nb)
+        self.refresh_window()
+
+    def go_to_roster(self):
+        self.command_win('0')
+
+    def go_to_previous_tab(self):
+        self.command_win('%s' % (self.previous_tab_nb,))
+
+    def go_to_important_room(self):
+        """
+        Go to the next room with activity, in this order:
+        - A personal conversation with a new message
+        - A Muc with an highlight
+        - A Muc with any new message
+        """
+        for tab in self.tabs:
+            if tab.get_color_state() == theme.COLOR_TAB_PRIVATE:
+                self.command_win('%s' % tab.nb)
+                return
+        for tab in self.tabs:
+            if tab.get_color_state() == theme.COLOR_TAB_HIGHLIGHT:
+                self.command_win('%s' % tab.nb)
+                return
+        for tab in self.tabs:
+            if tab.get_color_state() == theme.COLOR_TAB_NEW_MESSAGE:
+                self.command_win('%s' % tab.nb)
+                return
+
+    def rotate_rooms_right(self, args=None):
+        """
+        rotate the rooms list to the right
+        """
+        self.current_tab().on_lose_focus()
+        self.tabs.append(self.tabs.pop(0))
+        self.current_tab().on_gain_focus()
+        self.refresh_window()
+
+    def rotate_rooms_left(self, args=None):
+        """
+        rotate the rooms list to the right
+        """
+        self.current_tab().on_lose_focus()
+        self.tabs.insert(0, self.tabs.pop())
+        self.current_tab().on_gain_focus()
+        self.refresh_window()
+
+    def scroll_page_down(self, args=None):
+        self.current_tab().on_scroll_down()
+        self.refresh_window()
+
+    def scroll_page_up(self, args=None):
+        self.current_tab().on_scroll_up()
+        self.refresh_window()
+
+    def room_error(self, error, room_name):
+        """
+        Display the error on the room window
+        """
+        room = self.get_room_by_name(room_name)
+        msg = error['error']['type']
+        condition = error['error']['condition']
+        code = error['error']['code']
+        body = error['error']['text']
+        if not body:
+            if code in list(ERROR_AND_STATUS_CODES.keys()):
+                body = ERROR_AND_STATUS_CODES[code]
+            else:
+                body = condition or _('Unknown error')
+        if code:
+            msg = _('Error: %(code)s - %(msg)s: %(body)s') % {'msg':msg, 'body':body, 'code':code}
+            self.add_message_to_text_buffer(room, msg)
+        else:
+            msg = _('Error: %(msg)s: %(body)s') % {'msg':msg, 'body':body}
+            self.add_message_to_text_buffer(room, msg)
+        if code == '401':
+            msg = _('To provide a password in order to join the room, type "/join / password" (replace "password" by the real password)')
+            self.add_message_to_text_buffer(room, msg)
+        if code == '409':
+            if config.get('alternative_nickname', '') != '':
+                self.command_join('%s/%s'% (room.name, room.own_nick+config.get('alternative_nickname', '')))
+            else:
+                self.add_message_to_text_buffer(room, _('You can join the room with an other nick, by typing "/join /other_nick"'))
+        self.refresh_window()
+
+    def open_conversation_window(self, room_name, focus=True):
+        """
+        open a new conversation tab and focus it if needed
+        """
+        r = Room(room_name, self.xmpp.boundjid.full)
+        new_tab = ConversationTab(self.stdscr, self, r)
+        # insert it in the rooms
+        if self.current_tab().nb == 0:
+            self.tabs.append(new_tab)
+        else:
+            for ta in self.tabs:
+                if ta.nb == 0:
+                    self.tabs.insert(self.tabs.index(ta), new_tab)
+                    break
+        if focus:               # focus the room if needed
+            self.command_win('%s' % (new_tab.nb))
+        # self.window.new_room(r)
+        self.refresh_window()
+        return r
+
+    def open_private_window(self, room_name, user_nick, focus=True):
+        complete_jid = room_name+'/'+user_nick
+        for tab in self.tabs: # if the room exists, focus it and return
+            if isinstance(tab, PrivateTab):
+                if tab.get_name() == complete_jid:
+                    self.command_win('%s' % tab.nb)
+                    return
+        # create the new tab
+        room = self.get_room_by_name(room_name)
+        if not room:
+            return None
+        own_nick = room.own_nick
+        r = Room(complete_jid, own_nick) # PrivateRoom here
+        new_tab = PrivateTab(self.stdscr, self, r)
+        # insert it in the tabs
+        if self.current_tab().nb == 0:
+            self.tabs.append(new_tab)
+        else:
+            for ta in self.tabs:
+                if ta.nb == 0:
+                    self.tabs.insert(self.tabs.index(ta), new_tab)
+                    break
+        if focus:               # focus the room if needed
+            self.command_win('%s' % (new_tab.nb))
+        # self.window.new_room(r)
+        self.refresh_window()
+        return r
+
+    def on_groupchat_message(self, message):
+        """
+        Triggered whenever a message is received from a multi-user chat room.
+        """
+        delay_tag = message.find('{urn:xmpp:delay}delay')
+        if delay_tag is not None:
+            delayed = True
+            date = common.datetime_tuple(delay_tag.attrib['stamp'])
+        else:
+            # We support the OLD and deprecated XEP: http://xmpp.org/extensions/xep-0091.html
+            # But it sucks, please, Jabber servers, don't do this :(
+            delay_tag = message.find('{jabber:x:delay}x')
+            if delay_tag is not None:
+                delayed = True
+                date = common.datetime_tuple(delay_tag.attrib['stamp'])
+            else:
+                delayed = False
+                date = None
+        nick_from = message['mucnick']
+        room_from = message.getMucroom()
+        if message['type'] == 'error': # Check if it's an error
+            return self.room_error(message, from_room)
+        if nick_from == room_from:
+            nick_from = None
+        room = self.get_room_by_name(room_from)
+        if (room_from in self.ignores) and (nick_from in self.ignores[room_from]):
+            return
+        room = self.get_room_by_name(room_from)
+        if not room:
+            self.information(_("message received for a non-existing room: %s") % (room_from))
+            return
+        body = message['body']
+        subject = message['subject']
+        if subject:
+            if nick_from:
+                self.add_message_to_text_buffer(room, _("%(nick)s changed the subject to: %(subject)s") % {'nick':nick_from, 'subject':subject}, time=date)
+            else:
+                self.add_message_to_text_buffer(room, _("The subject is: %(subject)s") % {'subject':subject}, time=date)
+            room.topic = subject.replace('\n', '|')
+        elif body:
+            date = date if delayed == True else None
+            self.add_message_to_text_buffer(room, body, date, nick_from)
+        self.refresh_window()
+        self.doupdate()
+
+    def add_message_to_text_buffer(self, room, txt, time=None, nickname=None, colorized=False):
+        """
+        Add the message to the room if possible, else, add it to the Info window
+        (in the Info tab of the info window in the RosterTab)
+        """
+        if not room:
+            self.information('Error, trying to add a message in no room: %s' % txt)
+        else:
+            room.add_message(txt, time, nickname, colorized)
+        self.refresh_window()
+
+    def command_help(self, arg):
+        """
+        /help <command_name>
+        """
+        args = arg.split()
+        if len(args) == 0:
+            msg = _('Available commands are: ')
+            for command in list(self.commands.keys()):
+                msg += "%s " % command
+            msg += _("\nType /help <command_name> to know what each command does")
+        if len(args) >= 1:
+            if args[0] in list(self.commands.keys()):
+                msg = self.commands[args[0]][1]
+            else:
+                msg = _('Unknown command: %s') % args[0]
+        self.information(msg)
+
+    def command_whois(self, arg):
+        """
+        /whois <nickname>
+        """
+        # TODO
+        return
+        # check shlex here
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        room = self.current_room()
+        if len(args) != 1:
+            self.add_message_to_text_buffer(room, _('whois command takes exactly one argument'))
+            return
+        # check if current room is a MUC
+        if room.jid or room.name == 'Info':
+            return
+        nickname = args[0]
+        self.muc.request_vcard(room.name, nickname)
+
+    def command_theme(self, arg):
+        """
+        """
+        theme.reload_theme()
+        self.resize_window()
+
+    def command_recolor(self, arg):
+        """
+        Re-assign color to the participants of the room
+        """
+        tab = self.current_tab()
+        if not isinstance(tab, MucTab):
+            return
+        room = tab.get_room()
+        i = 0
+        compare_users = lambda x: x.last_talked
+        users = list(room.users)
+        # search our own user, to remove it from the room
+        for user in users:
+            if user.nick == room.own_nick:
+                users.remove(user)
+        nb_color = len(theme.LIST_COLOR_NICKNAMES)
+        for user in sorted(users, key=compare_users, reverse=True):
+            user.color = theme.LIST_COLOR_NICKNAMES[i % nb_color]
+            i+= 1
+        self.refresh_window()
+
+    def command_win(self, arg):
+        """
+        /win <number>
+        """
+        args = arg.split()
+        if len(args) != 1:
+            self.command_help('win')
+            return
+        try:
+            nb = int(args[0])
+        except ValueError:
+            self.command_help('win')
+            return
+        if self.current_tab().nb == nb:
+            return
+        self.previous_tab_nb = self.current_tab().nb
+        self.current_tab().on_lose_focus()
+        start = self.current_tab()
+        self.tabs.append(self.tabs.pop(0))
+        while self.current_tab().nb != nb:
+            self.tabs.append(self.tabs.pop(0))
+            if self.current_tab() == start:
+                self.current_tab().set_color_state(theme.COLOR_TAB_CURRENT)
+                self.refresh_window()
+                return
+        self.current_tab().on_gain_focus()
+        self.refresh_window()
+
+    def command_kick(self, arg):
+        """
+        /kick <nick> [reason]
+        """
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        if len(args) < 1:
+            self.command_help('kick')
+            return
+        nick = args[0]
+        if len(args) >= 2:
+            reason = ' '.join(args[1:])
+        else:
+            reason = ''
+        if not isinstance(self.current_tab(), MucTab) or not self.current_tab().get_room().joined:
+            return
+        roomname = self.current_tab().get_name()
+        res = muc.eject_user(self.xmpp, roomname, nick, reason)
+        if res['type'] == 'error':
+            self.room_error(res, roomname)
+
+    def command_join(self, arg):
+        """
+        /join [room][/nick] [password]
+        """
+        args = arg.split()
+        password = None
+        if len(args) == 0:
+            t = self.current_tab()
+            if not isinstance(t, MucTab) and not isinstance(t, PrivateTab):
+                return
+            room = t.get_name()
+            nick = t.get_room().own_nick
+        else:
+            info = args[0].split('/')
+            if len(info) == 1:
+                default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
+                nick = config.get('default_nick', '')
+                if nick == '':
+                    nick = default
+            else:
+                nick = info[1]
+            if info[0] == '':   # happens with /join /nickname, which is OK
+                t = self.current_tab()
+                if not isinstance(t, MucTab):
+                    return
+                room = t.get_name()
+                if nick == '':
+                    nick = t.get_room().own_nick
+            else:
+                room = info[0]
+            if not is_jid(room): # no server is provided, like "/join hello"
+                # use the server of the current room if available
+                # check if the current room's name has a server
+                if isinstance(self.current_tab(), MucTab) and\
+                        is_jid(self.current_tab().get_name()):
+                    room += '@%s' % jid_get_domain(self.current_tab().get_name())
+                else:           # no server could be found, print a message and return
+                    self.information(_("You didn't specify a server for the room you want to join"), 'Error')
+                    return
+        r = self.get_room_by_name(room)
+        if len(args) == 2:       # a password is provided
+            password = args[1]
+        if r and r.joined:       # if we are already in the room
+            self.focus_tab_named(r.name)
+            return
+        room = room.lower()
+        if r and not r.joined:
+            muc.join_groupchat(self.xmpp, room, nick, password)
+        if not r:   # if the room window exists, we don't recreate it.
+            self.open_new_room(room, nick)
+            muc.join_groupchat(self.xmpp, room, nick, password)
+        else:
+            r.own_nick = nick
+            r.users = []
+
+    def command_bookmark(self, arg):
+        """
+        /bookmark [room][/nick]
+        """
+        args = arg.split()
+        nick = None
+        if not isinstance(self.current_tab(), MucTab):
+            return
+        if len(args) == 0:
+            room = self.current_tab().get_room()
+            roomname = self.current_tab().get_name()
+            if room.joined:
+                nick = room.own_nick
+        else:
+            info = args[0].split('/')
+            if len(info) == 2:
+                nick = info[1]
+            roomname = info[0]
+            if roomname == '':
+                roomname = self.current_tab().get_name()
+        if nick:
+            res = roomname+'/'+nick
+        else:
+            res = roomname
+        bookmarked = config.get('rooms', '')
+        # check if the room is already bookmarked.
+        # if yes, replace it (i.e., update the associated nick)
+        bookmarked = bookmarked.split(':')
+        for room in bookmarked:
+            if room.split('/')[0] == roomname:
+                bookmarked.remove(room)
+                break
+        bookmarked = ':'.join(bookmarked)
+        if bookmarked:
+            bookmarks = bookmarked+':'+res
+        else:
+            bookmarks = res
+        config.set_and_save('rooms', bookmarks)
+        self.information(_('Your bookmarks are now: %s') % bookmarks)
+
+    def command_set(self, arg):
+        """
+        /set <option> [value]
+        """
+        args = arg.split()
+        if len(args) != 2 and len(args) != 1:
+            self.command_help('set')
+            return
+        option = args[0]
+        if len(args) == 2:
+            value = args[1]
+        else:
+            value = ''
+        config.set_and_save(option, value)
+        msg = "%s=%s" % (option, value)
+        self.information(msg)
+
+    def command_show(self, arg):
+        """
+        /show <status> [msg]
+        """
+        args = arg.split()
+        possible_show = {'avail':None,
+                         'available':None,
+                         'ok':None,
+                         'here':None,
+                         'chat':'chat',
+                         'away':'away',
+                         'afk':'away',
+                         'dnd':'dnd',
+                         'busy':'dnd',
+                         'xa':'xa'
+                         }
+        if len(args) < 1:
+            return
+        if not args[0] in list(possible_show.keys()):
+            self.command_help('show')
+            return
+        show = possible_show[args[0]]
+        if len(args) > 1:
+            msg = ' '.join(args[1:])
+        else:
+            msg = None
+        for tab in self.tabs:
+            if isinstance(tab, MucTab) and tab.get_room().joined:
+                muc.change_show(self.xmpp, tab.get_room().name, tab.get_room().own_nick, show, msg)
+
+    def command_ignore(self, arg):
+        """
+        /ignore <nick>
+        """
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        if len(args) != 1:
+            self.command_help('ignore')
+            return
+        if not isinstance(self.current_tab(), MucTab):
+            return
+        roomname = self.current_tab().get_name()
+        nick = args[0]
+        if roomname not in self.ignores:
+            self.ignores[roomname] = set() # no need for any order
+        if nick not in self.ignores[roomname]:
+            self.ignores[roomname].add(nick)
+            self.information(_("%s is now ignored") % nick, 'info')
+        else:
+            self.information(_("%s is alread ignored") % nick, 'info')
+
+    def command_unignore(self, arg):
+        """
+        /unignore <nick>
+        """
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        if len(args) != 1:
+            self.command_help('unignore')
+            return
+        if not isinstance(self.current_tab(), MucTab):
+            return
+        roomname = self.current_tab().get_name()
+        nick = args[0]
+        if roomname not in self.ignores or (nick not in self.ignores[roomname]):
+            self.information(_("%s was not ignored") % nick, info)
+            return
+        self.ignores[roomname].remove(nick)
+        if not self.ignores[roomname]:
+            del self.ignores[roomname]
+        self.information(_("%s is now unignored") % nick, 'info')
+
+    def command_away(self, arg):
+        """
+        /away [msg]
+        """
+        self.command_show("away "+arg)
+
+    def command_busy(self, arg):
+        """
+        /busy [msg]
+        """
+        self.command_show("busy "+arg)
+
+    def command_avail(self, arg):
+        """
+        /avail [msg]
+        """
+        self.command_show("available "+arg)
+
+    def command_part(self, arg):
+        """
+        /part [msg]
+        """
+        args = arg.split()
+        reason = None
+        if not isinstance(self.current_tab(), MucTab) and\
+                not isinstance(self.current_tab(), PrivateTab):
+            return
+        room = self.current_tab().get_room()
+        if len(args):
+            msg = ' '.join(args)
+        else:
+            msg = None
+        if isinstance(self.current_tab(), MucTab) and\
+                self.current_tab().get_room().joined:
+            muc.leave_groupchat(self.xmpp, room.name, room.own_nick, arg)
+        self.tabs.remove(self.current_tab())
+        self.refresh_window()
+
+    def command_unquery(self, arg):
+        """
+        /unquery
+        """
+        tab = self.current_tab()
+        if isinstance(tab, PrivateTab):
+            self.tabs.remove(tab)
+            self.refresh_window()
+
+    def command_query(self, arg):
+        """
+        /query <nick> [message]
+        """
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        if len(args) < 1 or not isinstance(self.current_tab(), MucTab):
+            return
+        nick = args[0]
+        room = self.current_tab().get_room()
+        r = None
+        for user in room.users:
+            if user.nick == nick:
+                r = self.open_private_window(room.name, user.nick)
+        if r and len(args) > 1:
+            msg = arg[len(nick)+1:]
+            muc.send_private_message(self.xmpp, r.name, msg)
+            self.add_message_to_text_buffer(r, msg, None, r.own_nick)
+
+    def command_topic(self, arg):
+        """
+        /topic [new topic]
+        """
+        if not isinstance(self.current_tab(), MucTab):
+            return
+        room = self.current_tab().get_room()
+        if not arg.strip():
+            self.add_message_to_text_buffer(room, _("The subject of the room is: %s") % room.topic)
+            return
+        subject = arg
+        muc.change_subject(self.xmpp, room.name, subject)
+
+    def command_link(self, arg):
+        """
+        /link <option> <nb>
+        Opens the link in a browser, or join the room, or add the JID, or
+        copy it in the clipboard
+        """
+        if not isinstance(self.current_tab(), MucTab) and\
+                not isinstance(self.current_tab(), PrivateTab):
+            return
+        args = arg.split()
+        if len(args) > 2:
+            # INFO
+            # self.add_message_to_text_buffer(self.current_room(),
+            #                          _("Link: This command takes at most 2 arguments"))
+            return
+        # set the default parameters
+        option = "open"
+        nb = 0
+        # check the provided parameters
+        if len(args) >= 1:
+            try:  # check if the argument is the number
+                nb = int(args[0])
+            except ValueError:  # nope, it's the option
+                option = args[0]
+        if len(args) == 2:
+            try:
+                nb = int(args[0])
+            except ValueError:
+                # INFO
+                # self.add_message_to_text_buffer(self.current_room(),
+                #                          _("Link: 2nd parameter should be a number"))
+                return
+        # find the nb-th link in the current buffer
+        i = 0
+        link = None
+        for msg in self.current_tab().get_room().messages[:-200:-1]:
+            if not msg:
+                continue
+            matches = re.findall('"((ftp|http|https|gopher|mailto|news|nntp|telnet|wais|file|prospero|aim|webcal):(([A-Za-z0-9$_.+!*(),;/?:@&~=-])|%[A-Fa-f0-9]{2}){2,}(#([a-zA-Z0-9][a-zA-Z0-9$_.+!*(),;/?:@&~=%-]*))?([A-Za-z0-9$_+!*();/?:~-]))"', msg.txt)
+            for m in matches:
+                if i == nb:
+                    url = m[0]
+                    self.link_open(url)
+                    return
+
+    def url_open(self, url):
+        """
+        Use webbrowser to open the provided link
+        """
+        webbrowser.open(url)
+
+    def move_separator(self):
+        """
+        Move the new-messages separator at the bottom on the current
+        text.
+        """
+        try:
+            room = self.current_tab().get_room()
+        except:
+            return
+        room.remove_line_separator()
+        room.add_line_separator()
+        self.refresh_window()
+
+    def command_nick(self, arg):
+        """
+        /nick <nickname>
+        """
+        try:
+            args = shlex.split(arg)
+        except ValueError as error:
+            return self.information(str(error), _("Error"))
+        if not isinstance(self.current_tab(), MucTab):
+            return
+        if len(args) != 1:
+            return
+        nick = args[0]
+        room = self.current_tab().get_room()
+        if not room.joined or room.name == "Info":
+            return
+        muc.change_nick(self.xmpp, room.name, nick)
+
+    def information(self, msg, typ=''):
+        """
+        Displays an informational message in the "Info" room window
+        """
+        self.information_buffer.add_message(msg, nickname=typ)
+        self.refresh_window()
+
+    def command_quit(self, arg):
+        """
+        /quit
+        """
+        if len(arg.strip()) != 0:
+            msg = arg
+        else:
+            msg = None
+        for tab in self.tabs:
+            if isinstance(tab, MucTab):
+                muc.leave_groupchat(self.xmpp, tab.get_room().name, tab.get_room().own_nick, msg)
+        self.xmpp.disconnect()
+        self.running = False
+        self.reset_curses()
+
+    def do_command(self, key):
+        if not key:
+            return
+        res = self.current_tab().on_input(key)
+        if not res:
+            return
+        if key in ('^J', '\n') and isinstance(res, str):
+            self.execute(res)
+        else :
+            # we did "enter" with an empty input in the roster
+            self.on_roster_enter_key(res)
+
+    def on_roster_enter_key(self, roster_row):
+        """
+        when enter is pressed on the roster window
+        """
+        if isinstance(roster_row, Contact):
+            # roster_row.toggle_folded()
+            if not self.get_conversation_by_jid(roster_row.get_bare_jid()):
+                self.open_conversation_window(roster_row.get_bare_jid())
+            else:
+                self.focus_tab_named(roster_row.get_bare_jid())
+        if isinstance(roster_row, Resource):
+            if not self.get_conversation_by_jid(roster_row.get_jid().full):
+                self.open_conversation_window(roster_row.get_jid().full)
+            else:
+                self.focus_tab_named(roster_row.get_jid().full)
+        self.refresh_window()
+
+    def execute(self,line):
+        """
+        Execute the /command or just send the line on the current room
+        """
+        if line == "":
+            return
+        if line.startswith('//'):
+            self.command_say(line[1:])
+        elif line.startswith('/') and not line.startswith('/me '):
+            command = line.strip()[:].split()[0][1:]
+            arg = line[2+len(command):] # jump the '/' and the ' '
+            # example. on "/link 0 open", command = "link" and arg = "0 open"
+            if command in list(self.commands.keys()):
+                func = self.commands[command][0]
+                func(arg)
+                return
+            else:
+                self.information(_("unknown command (%s)") % (command), _('Error'))
+        else:
+            self.command_say(line)
+
+    def command_say(self, line):
+        if isinstance(self.current_tab(), PrivateTab):
+            muc.send_private_message(self.xmpp, self.current_tab().get_name(), line)
+        elif isinstance(self.current_tab(), ConversationTab): # todo, special case
+            muc.send_private_message(self.xmpp, self.current_tab().get_name(), line)
+        if isinstance(self.current_tab(), PrivateTab) or\
+                isinstance(self.current_tab(), ConversationTab):
+            self.add_message_to_text_buffer(self.current_tab().get_room(), line, None, self.current_tab().get_room().own_nick)
+        elif isinstance(self.current_tab(), MucTab):
+            muc.send_groupchat_message(self.xmpp, self.current_tab().get_name(), line)
+        self.doupdate()
+
+    def doupdate(self):
+        self.current_tab().just_before_refresh()
+        curses.doupdate()
+
+# # global core object
+core = Core(connection)
+
diff --git a/src/gui.py b/src/gui.py
deleted file mode 100644
index 01fa38c8..00000000
--- a/src/gui.py
+++ /dev/null
@@ -1,1393 +0,0 @@
-# Copyright 2010 Le Coz Florent <louiz@louiz.org>
-#
-# This file is part of Poezio.
-#
-# Poezio is free software: you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation, version 3 of the License.
-#
-# Poezio is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with Poezio.  If not, see <http://www.gnu.org/licenses/>.
-
-from gettext import (bindtextdomain, textdomain, bind_textdomain_codeset,
-                     gettext as _)
-from os.path import isfile
-
-from time import sleep
-
-import os
-import re
-import sys
-import shlex
-import curses
-import threading
-import webbrowser
-
-from datetime import datetime
-
-import common
-import theme
-
-import multiuserchat as muc
-from handler import Handler
-from config import config
-from tab import MucTab, InfoTab, PrivateTab, RosterInfoTab, ConversationTab
-from user import User
-from room import Room
-from roster import Roster, RosterGroup, roster
-from contact import Contact, Resource
-from message import Message
-from text_buffer import TextBuffer
-from keyboard import read_char
-from common import jid_get_domain, is_jid
-
-# http://xmpp.org/extensions/xep-0045.html#errorstatus
-ERROR_AND_STATUS_CODES = {
-    '401': _('A password is required'),
-    '403': _('You are banned from the room'),
-    '404': _('The room does\'nt exist'),
-    '405': _('Your are not allowed to create a new room'),
-    '406': _('A reserved nick must be used'),
-    '407': _('You are not in the member list'),
-    '409': _('This nickname is already in use or has been reserved'),
-    '503': _('The maximum number of users has been reached'),
-    }
-
-SHOW_NAME = {
-    'dnd': _('busy'),
-    'away': _('away'),
-    'xa': _('not available'),
-    'chat': _('chatty'),
-    '': _('available')
-    }
-
-resize_lock = threading.Lock()
-
-class Gui(object):
-    """
-    User interface using ncurses
-    """
-    def __init__(self, xmpp):
-        self.running = True
-        self.stdscr = curses.initscr()
-        self.init_curses(self.stdscr)
-        self.xmpp = xmpp
-        default_tab = InfoTab(self.stdscr, "Info") if self.xmpp.anon\
-            else RosterInfoTab(self.stdscr)
-        default_tab.on_gain_focus()
-        self.tabs = [default_tab]
-        # self.roster = Roster()
-        # a unique buffer used to store global informations
-        # that are displayed in almost all tabs, in an
-        # information window.
-        self.information_buffer = TextBuffer()
-        self.information_win_size = 2 # Todo, get this from config
-        self.ignores = {}
-        self.resize_timer = None
-        self.previous_tab_nb = 0
-
-        self.commands = {
-            'help': (self.command_help, '\_o< KOIN KOIN KOIN'),
-            'join': (self.command_join, _("Usage: /join [room_name][@server][/nick] [password]\nJoin: Join the specified room. You can specify a nickname after a slash (/). If no nickname is specified, you will use the default_nick in the configuration file. You can omit the room name: you will then join the room you\'re looking at (useful if you were kicked). You can also provide a room_name without specifying a server, the server of the room you're currently in will be used. You can also provide a password to join the room.\nExamples:\n/join room@server.tld\n/join room@server.tld/John\n/join room2\n/join /me_again\n/join\n/join room@server.tld/my_nick password\n/join / password")),
-            'quit': (self.command_quit, _("Usage: /quit\nQuit: Just disconnect from the server and exit poezio.")),
-            'exit': (self.command_quit, _("Usage: /exit\nExit: Just disconnect from the server and exit poezio.")),
-            'next': (self.rotate_rooms_right, _("Usage: /next\nNext: Go to the next room.")),
-            'n': (self.rotate_rooms_right, _("Usage: /n\nN: Go to the next room.")),
-            'prev': (self.rotate_rooms_left, _("Usage: /prev\nPrev: Go to the previous room.")),
-            'p': (self.rotate_rooms_left, _("Usage: /p\nP: Go to the previous room.")),
-            'win': (self.command_win, _("Usage: /win <number>\nWin: Go to the specified room.")),
-            'w': (self.command_win, _("Usage: /w <number>\nW: Go to the specified room.")),
-            'ignore': (self.command_ignore, _("Usage: /ignore <nickname> \nIgnore: Ignore a specified nickname.")),
-            'unignore': (self.command_unignore, _("Usage: /unignore <nickname>\nUnignore: Remove the specified nickname from the ignore list.")),
-            'part': (self.command_part, _("Usage: /part [message]\n Part: disconnect from a room. You can specify an optional message.")),
-            'show': (self.command_show, _("Usage: /show <availability> [status]\nShow: Change your availability and (optionaly) your status. The <availability> argument is one of \"avail, available, ok, here, chat, away, afk, dnd, busy, xa\" and the optional [status] argument will be your status message")),
-            'away': (self.command_away, _("Usage: /away [message]\nAway: Sets your availability to away and (optional) sets your status message. This is equivalent to '/show away [message]'")),
-            'busy': (self.command_busy, _("Usage: /busy [message]\nBusy: Sets your availability to busy and (optional) sets your status message. This is equivalent to '/show busy [message]'")),
-            'avail': (self.command_avail, _("Usage: /avail [message]\nAvail: Sets your availability to available and (optional) sets your status message. This is equivalent to '/show available [message]'")),
-            'available': (self.command_avail, _("Usage: /available [message]\nAvailable: Sets your availability to available and (optional) sets your status message. This is equivalent to '/show available [message]'")),
-           'bookmark': (self.command_bookmark, _("Usage: /bookmark [roomname][/nick]\nBookmark: Bookmark the specified room (you will then auto-join it on each poezio start). This commands uses the same syntaxe as /join. Type /help join for syntaxe examples. Note that when typing \"/bookmark\" on its own, the room will be bookmarked with the nickname you\'re currently using in this room (instead of default_nick)")),
-            'unquery': (self.command_unquery, _("Usage: /unquery\nClose the private conversation window")),
-            'set': (self.command_set, _("Usage: /set <option> [value]\nSet: Sets the value to the option in your configuration file. You can, for example, change your default nickname by doing `/set default_nick toto` or your resource with `/set resource blabla`. You can also set an empty value (nothing) by providing no [value] after <option>.")),
-            'kick': (self.command_kick, _("Usage: /kick <nick> [reason]\nKick: Kick the user with the specified nickname. You also can give an optional reason.")),
-            'topic': (self.command_topic, _("Usage: /topic <subject> \nTopic: Change the subject of the room")),
-            'link': (self.command_link, _("Usage: /link [option] [number]\nLink: Interact with a link in the conversation. Available options are 'open', 'copy'. Open just opens the link in the browser if it's http://, Copy just copy the link in the clipboard. An optional number can be provided, it indicates which link to interact with.")),
-            'query': (self.command_query, _('Usage: /query <nick> [message]\nQuery: Open a private conversation with <nick>. This nick has to be present in the room you\'re currently in. If you specified a message after the nickname, it will immediately be sent to this user')),
-            'nick': (self.command_nick, _("Usage: /nick <nickname>\nNick: Change your nickname in the current room")),
-            'say': (self.command_say, _('Usage: /say <message>\nSay: Just send the message. Useful if you want your message to begin with a "/"')),
-            'whois': (self.command_whois, _('Usage: /whois <nickname>\nWhois: Request many informations about the user.')),
-            'theme': (self.command_theme, _('Usage: /theme\nTheme: Reload the theme defined in the config file.')),
-            'recolor': (self.command_recolor, _('Usage: /recolor\nRecolor: Re-assign a color to all participants of the current room, based on the last time they talked. Use this if the participants currently talking have too many identical colors.')),
-            }
-
-        self.key_func = {
-            "KEY_PPAGE": self.scroll_page_up,
-            "KEY_NPAGE": self.scroll_page_down,
-            "KEY_F(5)": self.rotate_rooms_left,
-            "^P": self.rotate_rooms_left,
-            "KEY_F(6)": self.rotate_rooms_right,
-            "KEY_F(7)": self.shrink_information_win,
-            "KEY_F(8)": self.grow_information_win,
-            "^N": self.rotate_rooms_right,
-            "KEY_RESIZE": self.call_for_resize,
-            'M-e': self.go_to_important_room,
-            'M-r': self.go_to_roster,
-            'M-z': self.go_to_previous_tab,
-            'M-v': self.move_separator,
-            }
-
-        # Add handlers
-        self.xmpp.add_event_handler("session_start", self.on_connected)
-        self.xmpp.add_event_handler("groupchat_presence", self.on_groupchat_presence)
-        self.xmpp.add_event_handler("groupchat_message", self.on_groupchat_message)
-        self.xmpp.add_event_handler("message", self.on_message)
-        self.xmpp.add_event_handler("got_online" , self.on_got_online)
-        self.xmpp.add_event_handler("got_offline" , self.on_got_offline)
-        self.xmpp.add_event_handler("roster_update", self.on_roster_update)
-        self.xmpp.add_event_handler("changed_status", self.on_presence)
-
-        # self.__debug_fill_roster()
-
-    def grow_information_win(self):
-        """
-        """
-        if self.information_win_size == 14:
-            return
-        self.information_win_size += 1
-        for tab in self.tabs:
-            tab.on_info_win_size_changed(self.information_win_size, self.stdscr)
-        self.refresh_window()
-
-    def shrink_information_win(self):
-        """
-        """
-        if self.information_win_size == 0:
-            return
-        self.information_win_size -= 1
-        for tab in self.tabs:
-            tab.on_info_win_size_changed(self.information_win_size, self.stdscr)
-        self.refresh_window()
-
-    def on_got_offline(self, presence):
-        jid = presence['from']
-        contact = roster.get_contact_by_jid(jid.bare)
-        if not contact:
-            return
-        resource = contact.get_resource_by_fulljid(jid.full)
-        assert resource
-        self.information('%s is offline' % (resource.get_jid()), "Roster")
-        contact.remove_resource(resource)
-        if isinstance(self.current_tab(), RosterInfoTab):
-            self.refresh_window()
-
-    def on_got_online(self, presence):
-        jid = presence['from']
-        contact = roster.get_contact_by_jid(jid.bare)
-        if not contact:
-            # Todo, handle presence comming from contacts not in roster
-            return
-        resource = contact.get_resource_by_fulljid(jid.full)
-        assert not resource
-        resource = Resource(jid.full)
-        status = presence['type']
-        priority = presence.getPriority() or 0
-        resource.set_presence(status)
-        resource.set_priority(priority)
-        contact.add_resource(resource)
-        self.information("%s is online (%s)" % (resource.get_jid().full, status), "Roster")
-
-    def on_connected(self, event):
-        """
-        Called when we are connected and authenticated
-        """
-        self.information(_("Welcome on Poezio \o/!"))
-        self.information(_("Your JID is %s") % self.xmpp.boundjid.full)
-
-        if not self.xmpp.anon:
-            # request the roster
-            self.xmpp.getRoster()
-            # send initial presence
-            self.xmpp.makePresence(pfrom=self.xmpp.boundjid.bare).send()
-        rooms = config.get('rooms', '')
-        if rooms == '' or not isinstance(rooms, str):
-            return
-        rooms = rooms.split(':')
-        for room in rooms:
-            args = room.split('/')
-            if args[0] == '':
-                return
-            roomname = args[0]
-            if len(args) == 2:
-                nick = args[1]
-            else:
-                default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
-                nick = config.get('default_nick', '')
-                if nick == '':
-                    nick = default
-            self.open_new_room(roomname, nick, False)
-            muc.join_groupchat(self.xmpp, roomname, nick)
-        # if not self.xmpp.anon:
-        # Todo: SEND VCARD
-        return
-        if config.get('jid', '') == '': # Don't send the vcard if we're not anonymous
-            self.vcard_sender.start()   # because the user ALREADY has one on the server
-
-    def on_groupchat_presence(self, presence):
-        """
-        Triggered whenever a presence stanza is received from a user in a multi-user chat room.
-        Display the presence on the room window and update the
-        presence information of the concerned user
-        """
-        from_nick = presence['from'].resource
-        from_room = presence['from'].bare
-        room = self.get_room_by_name(from_room)
-        code = presence.find('{jabber:client}status')
-        status_codes = set([s.attrib['code'] for s in presence.findall('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}status')])
-        # Check if it's not an error presence.
-        if presence['type'] == 'error':
-            return self.room_error(presence, from_room)
-        if not room:
-            return
-        msg = None
-        affiliation = presence['muc']['affiliation']
-        show = presence['show']
-        status = presence['status']
-        role = presence['muc']['role']
-        jid = presence['muc']['jid']
-        typ = presence['type']
-        if not room.joined:     # user in the room BEFORE us.
-            # ignore redondant presence message, see bug #1509
-            if from_nick not in [user.nick for user in room.users]:
-                new_user = User(from_nick, affiliation, show, status, role)
-                room.users.append(new_user)
-                if from_nick == room.own_nick:
-                    room.joined = True
-                    new_user.color = theme.COLOR_OWN_NICK
-                    self.add_message_to_text_buffer(room, _("Your nickname is %s") % (from_nick))
-                    if '170' in status_codes:
-                        self.add_message_to_text_buffer(room, 'Warning: this room is publicly logged')
-        else:
-            change_nick = '303' in status_codes
-            kick = '307' in status_codes and typ == 'unavailable'
-            user = room.get_user_by_name(from_nick)
-            # New user
-            if not user:
-                self.on_user_join(room, from_nick, affiliation, show, status, role, jid)
-            # nick change
-            elif change_nick:
-                self.on_user_nick_change(room, presence, user, from_nick, from_room)
-            # kick
-            elif kick:
-                self.on_user_kicked(room, presence, user, from_nick)
-            # user quit
-            elif typ == 'unavailable':
-                self.on_user_leave_groupchat(room, user, jid, status, from_nick, from_room)
-            # status change
-            else:
-                self.on_user_change_status(room, user, from_nick, from_room, affiliation, role, show, status)
-        self.refresh_window()
-        self.doupdate()
-
-    def on_user_join(self, room, from_nick, affiliation, show, status, role, jid):
-        """
-        When a new user joins a groupchat
-        """
-        room.users.append(User(from_nick, affiliation,
-                               show, status, role))
-        hide_exit_join = config.get('hide_exit_join', -1)
-        if hide_exit_join != 0:
-            if not jid.full:
-                self.add_message_to_text_buffer(room, _('%(spec)s "[%(nick)s]" joined the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_JOIN.replace('"', '\\"')}, colorized=True)
-            else:
-                self.add_message_to_text_buffer(room, _('%(spec)s "[%(nick)s]" "(%(jid)s)" joined the room') % {'spec':theme.CHAR_JOIN.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'jid':jid.full}, colorized=True)
-
-    def on_user_nick_change(self, room, presence, user, from_nick, from_room):
-        new_nick = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item').attrib['nick']
-        if user.nick == room.own_nick:
-            room.own_nick = new_nick
-            # also change our nick in all private discussion of this room
-            for _tab in self.tabs:
-                if isinstance(_tab, PrivateTab) and _tab.get_name().split('/', 1)[0] == room.name:
-                    _tab.get_room().own_nick = new_nick
-        user.change_nick(new_nick)
-        self.add_message_to_text_buffer(room, _('"[%(old)s]" is now known as "[%(new)s]"') % {'old':from_nick.replace('"', '\\"'), 'new':new_nick.replace('"', '\\"')}, colorized=True)
-        # rename the private tabs if needed
-        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
-        if private_room:
-            self.add_message_to_text_buffer(private_room, _('"[%(old_nick)s]" is now known as "[%(new_nick)s]"') % {'old_nick':from_nick.replace('"', '\\"'), 'new_nick':new_nick.replace('"', '\\"')}, colorized=True)
-            new_jid = private_room.name.split('/', 1)[0]+'/'+new_nick
-            private_room.name = new_jid
-
-    def on_user_kicked(self, room, presence, user, from_nick):
-        """
-        When someone is kicked
-        """
-        room.users.remove(user)
-        by = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item/{http://jabber.org/protocol/muc#user}actor')
-        reason = presence.find('{http://jabber.org/protocol/muc#user}x/{http://jabber.org/protocol/muc#user}item/{http://jabber.org/protocol/muc#user}reason')
-        by = by.attrib['jid'] if by is not None else None
-        reason = reason.text if reason else ''
-        if from_nick == room.own_nick: # we are kicked
-            room.disconnect()
-            if by:
-                kick_msg = _('%(spec)s [You] have been kicked by "[%(by)s]"') % {'spec': theme.CHAR_KICK.replace('"', '\\"'), 'by':by}
-            else:
-                kick_msg = _('%(spec)s [You] have been kicked.') % {'spec':theme.CHAR_KICK.replace('"', '\\"')}
-            # try to auto-rejoin
-            if config.get('autorejoin', 'false') == 'true':
-                muc.join_groupchat(self.xmpp, room.name, room.own_nick)
-        else:
-            if by:
-                kick_msg = _('%(spec)s "[%(nick)s]" has been kicked by "[%(by)s]"') % {'spec':theme.CHAR_KICK.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'by':by.replace('"', '\\"')}
-            else:
-                kick_msg = _('%(spec)s "[%(nick)s]" has been kicked') % {'spec':theme.CHAR_KICK, 'nick':from_nick.replace('"', '\\"')}
-        if reason:
-            kick_msg += _(' Reason: %(reason)s') % {'reason': reason}
-        self.add_message_to_text_buffer(room, kick_msg, colorized=True)
-
-    def on_user_leave_groupchat(self, room, user, jid, status, from_nick, from_room):
-        """
-        When an user leaves a groupchat
-        """
-        room.users.remove(user)
-        if room.own_nick == user.nick:
-            # We are now out of the room. Happens with some buggy (? not sure) servers
-            room.disconnect()
-        hide_exit_join = config.get('hide_exit_join', -1) if config.get('hide_exit_join', -1) >= -1 else -1
-        if hide_exit_join == -1 or user.has_talked_since(hide_exit_join):
-            if not jid.full:
-                leave_msg = _('%(spec)s "[%(nick)s]" has left the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT.replace('"', '\\"')}
-            else:
-                leave_msg = _('%(spec)s "[%(nick)s]" "(%(jid)s)" has left the room') % {'spec':theme.CHAR_QUIT.replace('"', '\\"'), 'nick':from_nick.replace('"', '\\"'), 'jid':jid.full.replace('"', '\\"')}
-            if status:
-                leave_msg += ' (%s)' % status
-            self.add_message_to_text_buffer(room, leave_msg, colorized=True)
-        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
-        if private_room:
-            if not status:
-                self.add_message_to_text_buffer(private_room, _('%(spec)s "[%(nick)s]" has left the room') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT.replace('"', '\\"')}, colorized=True)
-            else:
-                self.add_message_to_text_buffer(private_room, _('%(spec)s "[%(nick)s]" has left the room "(%(status)s)"') % {'nick':from_nick.replace('"', '\\"'), 'spec':theme.CHAR_QUIT, 'status': status.replace('"', '\\"')}, colorized=True)
-
-    def on_user_change_status(self, room, user, from_nick, from_room, affiliation, role, show, status):
-        """
-        When an user changes her status
-        """
-        # build the message
-        display_message = False # flag to know if something significant enough
-        # to be displayed has changed
-        msg = _('"%s" changed: ')% from_nick.replace('"', '\\"')
-        if affiliation != user.affiliation:
-            msg += _('affiliation: %s, ') % affiliation
-            display_message = True
-        if role != user.role:
-            msg += _('role: %s, ') % role
-            display_message = True
-        if show != user.show and show in list(SHOW_NAME.keys()):
-            msg += _('show: %s, ') % SHOW_NAME[show]
-            display_message = True
-        if status and status != user.status:
-            msg += _('status: %s, ') % status
-            display_message = True
-        if not display_message:
-            return
-        msg = msg[:-2] # remove the last ", "
-        hide_status_change = config.get('hide_status_change', -1) if config.get('hide_status_change', -1) >= -1 else -1
-        if (hide_status_change == -1 or \
-                user.has_talked_since(hide_status_change) or\
-                user.nick == room.own_nick)\
-                and\
-                (affiliation != user.affiliation or\
-                    role != user.role or\
-                    show != user.show or\
-                    status != user.status):
-            # display the message in the room
-            self.add_message_to_text_buffer(room, msg, colorized=True)
-        private_room = self.get_room_by_name('%s/%s' % (from_room, from_nick))
-        if private_room: # display the message in private
-            self.add_message_to_text_buffer(private_room, msg, colorized=True)
-        # finally, effectively change the user status
-        user.update(affiliation, show, status, role)
-
-    def on_message(self, message):
-        """
-        When receiving private message from a muc OR a normal message
-        (from one of our contacts)
-        """
-        if message['type'] == 'groupchat':
-            return None
-        # Differentiate both type of messages, and call the appropriate handler.
-        jid_from = message['from']
-        for tab in self.tabs:
-            if isinstance(tab, MucTab) and tab.get_name() == jid_from.bare: # check all the MUC we are in
-                if message['type'] == 'error':
-                    return self.room_error(message, tab.get_room().name)
-                else:
-                    return self.on_groupchat_private_message(message)
-        return self.on_normal_message(message)
-
-    def on_groupchat_private_message(self, message):
-        """
-        We received a Private Message (from someone in a Muc)
-        """
-        jid = message['from']
-        nick_from = jid.resource
-        room_from = jid.bare
-        room = self.get_room_by_name(jid.full) # get the tab with the private conversation
-        if not room: # It's the first message we receive: create the tab
-            room = self.open_private_window(room_from, nick_from, False)
-            if not room:
-                return
-        body = message['body']
-        self.add_message_to_text_buffer(room, body, None, nick_from)
-        self.refresh_window()
-        self.doupdate()
-
-    def focus_tab_named(self, tab_name):
-        for tab in self.tabs:
-            if tab.get_name() == tab_name:
-                self.command_win('%s' % (tab.nb,))
-
-    def on_normal_message(self, message):
-        """
-        When receiving "normal" messages (from someone in our roster)
-        """
-        jid = message['from'].bare
-        room = self.get_conversation_by_jid(jid)
-        body = message['body']
-        if not body:
-            return
-        if not room:
-            room = self.open_conversation_window(jid, False)
-            if not room:
-                return
-        self.add_message_to_text_buffer(room, body, None, jid)
-        self.refresh_window()
-        return
-
-    def on_presence(self, presence):
-        """
-        """
-        jid = presence['from']
-        contact = roster.get_contact_by_jid(jid.bare)
-        if not contact:
-            return
-        resource = contact.get_resource_by_fulljid(jid.full)
-        if not resource:
-            return
-        status = presence['type']
-        priority = presence.getPriority() or 0
-        resource.set_presence(status)
-        resource.set_priority(priority)
-        if isinstance(self.current_tab(), RosterInfoTab):
-            self.refresh_window()
-
-    def __debug_fill_roster(self):
-        for i in range(10):
-            jid = 'contact%s@fion%s.org'%(i,i)
-            contact = Contact(jid)
-            contact.set_ask('wat')
-            contact.set_subscription('both')
-            roster.add_contact(contact, jid)
-            contact.set_name('%s %s fion'%(i,i))
-            roster.edit_groups_of_contact(contact, ['hello'])
-        for i in range(10):
-            jid = 'test%s@bernard%s.org'%(i,i)
-            contact = Contact(jid)
-            contact.set_ask('wat')
-            contact.set_subscription('both')
-            roster.add_contact(contact, jid)
-            contact.set_name('%s test'%(i))
-            roster.edit_groups_of_contact(contact, ['hello'])
-        for i in range(10):
-            jid = 'pouet@top%s.org'%(i)
-            contact = Contact(jid)
-            contact.set_ask('wat')
-            contact.set_subscription('both')
-            roster.add_contact(contact, jid)
-            contact.set_name('%s oula'%(i))
-            roster.edit_groups_of_contact(contact, ['hello'])
-        if isinstance(self.current_tab(), RosterInfoTab):
-            self.refresh_window()
-
-    def on_roster_update(self, iq):
-        """
-        A subscription changed, or we received a roster item
-        after a roster request, etc
-        """
-        for item in iq.findall('{jabber:iq:roster}query/{jabber:iq:roster}item'):
-            jid = item.attrib['jid']
-            contact = roster.get_contact_by_jid(jid)
-            if not contact:
-                contact = Contact(jid)
-                roster.add_contact(contact, jid)
-            if 'ask' in item.attrib:
-                contact.set_ask(item.attrib['ask'])
-            else:
-                contact.set_ask(None)
-            if 'name' in item.attrib:
-                contact.set_name(item.attrib['name'])
-            else:
-                contact.set_name(None)
-            if item.attrib['subscription']:
-                contact.set_subscription(item.attrib['subscription'])
-            groups = item.findall('{jabber:iq:roster}group')
-            roster.edit_groups_of_contact(contact, [group.text for group in groups])
-        if isinstance(self.current_tab(), RosterInfoTab):
-            self.refresh_window()
-
-    def call_for_resize(self):
-        """
-        Starts a very short timer. If no other terminal resize
-        occured in this delay then poezio is REALLY resize.
-        This is to avoid multiple unnecessary software resizes (this
-        can be heavy on resource on slow computers or networks)
-        """
-        # with resize_lock:
-            # if self.resize_timer:
-            #     # a recent terminal resize occured.
-            #     # Cancel the programmed software resize
-            #     self.resize_timer.cancel()
-            # # add the new timer
-            # self.resize_timer = threading.Timer(0.15, self.resize_window)
-            # self.resize_timer.start()
-        self.resize_window()
-
-    def resize_window(self):
-        """
-        Resize the whole screen
-        """
-        with resize_lock:
-           # self.resize_timer = None
-            for tab in self.tabs:
-                tab.resize(self.stdscr)
-            self.refresh_window()
-
-    def main_loop(self):
-        """
-        main loop waiting for the user to press a key
-        """
-        self.refresh_window()
-        while self.running:
-            self.doupdate()
-            char=read_char(self.stdscr)
-            # search for keyboard shortcut
-            if char in list(self.key_func.keys()):
-                self.key_func[char]()
-            else:
-                self.do_command(char)
-
-    def current_tab(self):
-        """
-        returns the current room, the one we are viewing
-        """
-        return self.tabs[0]
-
-    def get_conversation_by_jid(self, jid):
-        """
-        Return the room of the ConversationTab with the given jid
-        """
-        for tab in self.tabs:
-            if isinstance(tab, ConversationTab):
-                if tab.get_name() == jid:
-                    return tab.get_room()
-        return None
-
-    def get_room_by_name(self, name):
-        """
-        returns the room that has this name
-        """
-        for tab in self.tabs:
-            if (isinstance(tab, MucTab) or
-                isinstance(tab, PrivateTab)) and tab.get_name() == name:
-                return tab.get_room()
-        return None
-
-    def init_curses(self, stdscr):
-        """
-        ncurses initialization
-        """
-        curses.curs_set(1)
-        curses.noecho()
-        # curses.raw()
-        theme.init_colors()
-        stdscr.keypad(True)
-
-    def reset_curses(self):
-        """
-        Reset terminal capabilities to what they were before ncurses
-        init
-        """
-        curses.echo()
-        curses.nocbreak()
-        curses.endwin()
-
-    def refresh_window(self):
-        """
-        Refresh everything
-        """
-        self.current_tab().set_color_state(theme.COLOR_TAB_CURRENT)
-        self.current_tab().refresh(self.tabs, self.information_buffer, roster)
-        self.doupdate()
-
-    def open_new_room(self, room, nick, focus=True):
-        """
-        Open a new MucTab containing a muc Room, using the specified nick
-        """
-        r = Room(room, nick)
-        new_tab = MucTab(self.stdscr, r, self.information_win_size)
-        if self.current_tab().nb == 0:
-            self.tabs.append(new_tab)
-        else:
-            for ta in self.tabs:
-                if ta.nb == 0:
-                    self.tabs.insert(self.tabs.index(ta), new_tab)
-                    break
-        if focus:
-            self.command_win("%s" % new_tab.nb)
-        self.refresh_window()
-
-    def go_to_roster(self):
-        self.command_win('0')
-
-    def go_to_previous_tab(self):
-        self.command_win('%s' % (self.previous_tab_nb,))
-
-    def go_to_important_room(self):
-        """
-        Go to the next room with activity, in this order:
-        - A personal conversation with a new message
-        - A Muc with an highlight
-        - A Muc with any new message
-        """
-        for tab in self.tabs:
-            if tab.get_color_state() == theme.COLOR_TAB_PRIVATE:
-                self.command_win('%s' % tab.nb)
-                return
-        for tab in self.tabs:
-            if tab.get_color_state() == theme.COLOR_TAB_HIGHLIGHT:
-                self.command_win('%s' % tab.nb)
-                return
-        for tab in self.tabs:
-            if tab.get_color_state() == theme.COLOR_TAB_NEW_MESSAGE:
-                self.command_win('%s' % tab.nb)
-                return
-
-    def rotate_rooms_right(self, args=None):
-        """
-        rotate the rooms list to the right
-        """
-        self.current_tab().on_lose_focus()
-        self.tabs.append(self.tabs.pop(0))
-        self.current_tab().on_gain_focus()
-        self.refresh_window()
-
-    def rotate_rooms_left(self, args=None):
-        """
-        rotate the rooms list to the right
-        """
-        self.current_tab().on_lose_focus()
-        self.tabs.insert(0, self.tabs.pop())
-        self.current_tab().on_gain_focus()
-        self.refresh_window()
-
-    def scroll_page_down(self, args=None):
-        self.current_tab().on_scroll_down()
-        self.refresh_window()
-
-    def scroll_page_up(self, args=None):
-        self.current_tab().on_scroll_up()
-        self.refresh_window()
-
-    def room_error(self, error, room_name):
-        """
-        Display the error on the room window
-        """
-        room = self.get_room_by_name(room_name)
-        msg = error['error']['type']
-        condition = error['error']['condition']
-        code = error['error']['code']
-        body = error['error']['text']
-        if not body:
-            if code in list(ERROR_AND_STATUS_CODES.keys()):
-                body = ERROR_AND_STATUS_CODES[code]
-            else:
-                body = condition or _('Unknown error')
-        if code:
-            msg = _('Error: %(code)s - %(msg)s: %(body)s') % {'msg':msg, 'body':body, 'code':code}
-            self.add_message_to_text_buffer(room, msg)
-        else:
-            msg = _('Error: %(msg)s: %(body)s') % {'msg':msg, 'body':body}
-            self.add_message_to_text_buffer(room, msg)
-        if code == '401':
-            msg = _('To provide a password in order to join the room, type "/join / password" (replace "password" by the real password)')
-            self.add_message_to_text_buffer(room, msg)
-        if code == '409':
-            if config.get('alternative_nickname', '') != '':
-                self.command_join('%s/%s'% (room.name, room.own_nick+config.get('alternative_nickname', '')))
-            else:
-                self.add_message_to_text_buffer(room, _('You can join the room with an other nick, by typing "/join /other_nick"'))
-        self.refresh_window()
-
-    def open_conversation_window(self, room_name, focus=True):
-        """
-        open a new conversation tab and focus it if needed
-        """
-        r = Room(room_name, self.xmpp.boundjid.full)
-        new_tab = ConversationTab(self.stdscr, r, self.information_win_size)
-        # insert it in the rooms
-        if self.current_tab().nb == 0:
-            self.tabs.append(new_tab)
-        else:
-            for ta in self.tabs:
-                if ta.nb == 0:
-                    self.tabs.insert(self.tabs.index(ta), new_tab)
-                    break
-        if focus:               # focus the room if needed
-            self.command_win('%s' % (new_tab.nb))
-        # self.window.new_room(r)
-        self.refresh_window()
-        return r
-
-    def open_private_window(self, room_name, user_nick, focus=True):
-        complete_jid = room_name+'/'+user_nick
-        for tab in self.tabs: # if the room exists, focus it and return
-            if isinstance(tab, PrivateTab):
-                if tab.get_name() == complete_jid:
-                    self.command_win('%s' % tab.nb)
-                    return
-        # create the new tab
-        room = self.get_room_by_name(room_name)
-        if not room:
-            return None
-        own_nick = room.own_nick
-        r = Room(complete_jid, own_nick) # PrivateRoom here
-        new_tab = PrivateTab(self.stdscr, r, self.information_win_size)
-        # insert it in the tabs
-        if self.current_tab().nb == 0:
-            self.tabs.append(new_tab)
-        else:
-            for ta in self.tabs:
-                if ta.nb == 0:
-                    self.tabs.insert(self.tabs.index(ta), new_tab)
-                    break
-        if focus:               # focus the room if needed
-            self.command_win('%s' % (new_tab.nb))
-        # self.window.new_room(r)
-        self.refresh_window()
-        return r
-
-    def on_groupchat_message(self, message):
-        """
-        Triggered whenever a message is received from a multi-user chat room.
-        """
-        delay_tag = message.find('{urn:xmpp:delay}delay')
-        if delay_tag is not None:
-            delayed = True
-            date = common.datetime_tuple(delay_tag.attrib['stamp'])
-        else:
-            # We support the OLD and deprecated XEP: http://xmpp.org/extensions/xep-0091.html
-            # But it sucks, please, Jabber servers, don't do this :(
-            delay_tag = message.find('{jabber:x:delay}x')
-            if delay_tag is not None:
-                delayed = True
-                date = common.datetime_tuple(delay_tag.attrib['stamp'])
-            else:
-                delayed = False
-                date = None
-        nick_from = message['mucnick']
-        room_from = message.getMucroom()
-        if message['type'] == 'error': # Check if it's an error
-            return self.room_error(message, from_room)
-        if nick_from == room_from:
-            nick_from = None
-        room = self.get_room_by_name(room_from)
-        if (room_from in self.ignores) and (nick_from in self.ignores[room_from]):
-            return
-        room = self.get_room_by_name(room_from)
-        if not room:
-            self.information(_("message received for a non-existing room: %s") % (room_from))
-            return
-        body = message['body']
-        subject = message['subject']
-        if subject:
-            if nick_from:
-                self.add_message_to_text_buffer(room, _("%(nick)s changed the subject to: %(subject)s") % {'nick':nick_from, 'subject':subject}, time=date)
-            else:
-                self.add_message_to_text_buffer(room, _("The subject is: %(subject)s") % {'subject':subject}, time=date)
-            room.topic = subject.replace('\n', '|')
-        elif body:
-            date = date if delayed == True else None
-            self.add_message_to_text_buffer(room, body, date, nick_from)
-        self.refresh_window()
-        self.doupdate()
-
-    def add_message_to_text_buffer(self, room, txt, time=None, nickname=None, colorized=False):
-        """
-        Add the message to the room if possible, else, add it to the Info window
-        (in the Info tab of the info window in the RosterTab)
-        """
-        if not room:
-            self.information('Error, trying to add a message in no room: %s' % txt)
-        else:
-            room.add_message(txt, time, nickname, colorized)
-        self.refresh_window()
-
-    def command_help(self, arg):
-        """
-        /help <command_name>
-        """
-        args = arg.split()
-        if len(args) == 0:
-            msg = _('Available commands are: ')
-            for command in list(self.commands.keys()):
-                msg += "%s " % command
-            msg += _("\nType /help <command_name> to know what each command does")
-        if len(args) >= 1:
-            if args[0] in list(self.commands.keys()):
-                msg = self.commands[args[0]][1]
-            else:
-                msg = _('Unknown command: %s') % args[0]
-        self.information(msg)
-
-    def command_whois(self, arg):
-        """
-        /whois <nickname>
-        """
-        # TODO
-        return
-        # check shlex here
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        room = self.current_room()
-        if len(args) != 1:
-            self.add_message_to_text_buffer(room, _('whois command takes exactly one argument'))
-            return
-        # check if current room is a MUC
-        if room.jid or room.name == 'Info':
-            return
-        nickname = args[0]
-        self.muc.request_vcard(room.name, nickname)
-
-    def command_theme(self, arg):
-        """
-        """
-        theme.reload_theme()
-        self.resize_window()
-
-    def command_recolor(self, arg):
-        """
-        Re-assign color to the participants of the room
-        """
-        tab = self.current_tab()
-        if not isinstance(tab, MucTab):
-            return
-        room = tab.get_room()
-        i = 0
-        compare_users = lambda x: x.last_talked
-        users = list(room.users)
-        # search our own user, to remove it from the room
-        for user in users:
-            if user.nick == room.own_nick:
-                users.remove(user)
-        nb_color = len(theme.LIST_COLOR_NICKNAMES)
-        for user in sorted(users, key=compare_users, reverse=True):
-            user.color = theme.LIST_COLOR_NICKNAMES[i % nb_color]
-            i+= 1
-        self.refresh_window()
-
-    def command_win(self, arg):
-        """
-        /win <number>
-        """
-        args = arg.split()
-        if len(args) != 1:
-            self.command_help('win')
-            return
-        try:
-            nb = int(args[0])
-        except ValueError:
-            self.command_help('win')
-            return
-        if self.current_tab().nb == nb:
-            return
-        self.previous_tab_nb = self.current_tab().nb
-        self.current_tab().on_lose_focus()
-        start = self.current_tab()
-        self.tabs.append(self.tabs.pop(0))
-        while self.current_tab().nb != nb:
-            self.tabs.append(self.tabs.pop(0))
-            if self.current_tab() == start:
-                self.current_tab().set_color_state(theme.COLOR_TAB_CURRENT)
-                self.refresh_window()
-                return
-        self.current_tab().on_gain_focus()
-        self.refresh_window()
-
-    def command_kick(self, arg):
-        """
-        /kick <nick> [reason]
-        """
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        if len(args) < 1:
-            self.command_help('kick')
-            return
-        nick = args[0]
-        if len(args) >= 2:
-            reason = ' '.join(args[1:])
-        else:
-            reason = ''
-        if not isinstance(self.current_tab(), MucTab) or not self.current_tab().get_room().joined:
-            return
-        roomname = self.current_tab().get_name()
-        res = muc.eject_user(self.xmpp, roomname, nick, reason)
-        if res['type'] == 'error':
-            self.room_error(res, roomname)
-
-    def command_join(self, arg):
-        """
-        /join [room][/nick] [password]
-        """
-        args = arg.split()
-        password = None
-        if len(args) == 0:
-            t = self.current_tab()
-            if not isinstance(t, MucTab) and not isinstance(t, PrivateTab):
-                return
-            room = t.get_name()
-            nick = t.get_room().own_nick
-        else:
-            info = args[0].split('/')
-            if len(info) == 1:
-                default = os.environ.get('USER') if os.environ.get('USER') else 'poezio'
-                nick = config.get('default_nick', '')
-                if nick == '':
-                    nick = default
-            else:
-                nick = info[1]
-            if info[0] == '':   # happens with /join /nickname, which is OK
-                t = self.current_tab()
-                if not isinstance(t, MucTab):
-                    return
-                room = t.get_name()
-                if nick == '':
-                    nick = t.get_room().own_nick
-            else:
-                room = info[0]
-            if not is_jid(room): # no server is provided, like "/join hello"
-                # use the server of the current room if available
-                # check if the current room's name has a server
-                if isinstance(self.current_tab(), MucTab) and\
-                        is_jid(self.current_tab().get_name()):
-                    room += '@%s' % jid_get_domain(self.current_tab().get_name())
-                else:           # no server could be found, print a message and return
-                    self.information(_("You didn't specify a server for the room you want to join"), 'Error')
-                    return
-        r = self.get_room_by_name(room)
-        if len(args) == 2:       # a password is provided
-            password = args[1]
-        if r and r.joined:       # if we are already in the room
-            self.focus_tab_named(r.name)
-            return
-        room = room.lower()
-        if r and not r.joined:
-            muc.join_groupchat(self.xmpp, room, nick, password)
-        if not r:   # if the room window exists, we don't recreate it.
-            self.open_new_room(room, nick)
-            muc.join_groupchat(self.xmpp, room, nick, password)
-        else:
-            r.own_nick = nick
-            r.users = []
-
-    def command_bookmark(self, arg):
-        """
-        /bookmark [room][/nick]
-        """
-        args = arg.split()
-        nick = None
-        if not isinstance(self.current_tab(), MucTab):
-            return
-        if len(args) == 0:
-            room = self.current_tab().get_room()
-            roomname = self.current_tab().get_name()
-            if room.joined:
-                nick = room.own_nick
-        else:
-            info = args[0].split('/')
-            if len(info) == 2:
-                nick = info[1]
-            roomname = info[0]
-            if roomname == '':
-                roomname = self.current_tab().get_name()
-        if nick:
-            res = roomname+'/'+nick
-        else:
-            res = roomname
-        bookmarked = config.get('rooms', '')
-        # check if the room is already bookmarked.
-        # if yes, replace it (i.e., update the associated nick)
-        bookmarked = bookmarked.split(':')
-        for room in bookmarked:
-            if room.split('/')[0] == roomname:
-                bookmarked.remove(room)
-                break
-        bookmarked = ':'.join(bookmarked)
-        if bookmarked:
-            bookmarks = bookmarked+':'+res
-        else:
-            bookmarks = res
-        config.set_and_save('rooms', bookmarks)
-        self.information(_('Your bookmarks are now: %s') % bookmarks)
-
-    def command_set(self, arg):
-        """
-        /set <option> [value]
-        """
-        args = arg.split()
-        if len(args) != 2 and len(args) != 1:
-            self.command_help('set')
-            return
-        option = args[0]
-        if len(args) == 2:
-            value = args[1]
-        else:
-            value = ''
-        config.set_and_save(option, value)
-        msg = "%s=%s" % (option, value)
-        self.information(msg)
-
-    def command_show(self, arg):
-        """
-        /show <status> [msg]
-        """
-        args = arg.split()
-        possible_show = {'avail':None,
-                         'available':None,
-                         'ok':None,
-                         'here':None,
-                         'chat':'chat',
-                         'away':'away',
-                         'afk':'away',
-                         'dnd':'dnd',
-                         'busy':'dnd',
-                         'xa':'xa'
-                         }
-        if len(args) < 1:
-            return
-        if not args[0] in list(possible_show.keys()):
-            self.command_help('show')
-            return
-        show = possible_show[args[0]]
-        if len(args) > 1:
-            msg = ' '.join(args[1:])
-        else:
-            msg = None
-        for tab in self.tabs:
-            if isinstance(tab, MucTab) and tab.get_room().joined:
-                muc.change_show(self.xmpp, tab.get_room().name, tab.get_room().own_nick, show, msg)
-
-    def command_ignore(self, arg):
-        """
-        /ignore <nick>
-        """
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        if len(args) != 1:
-            self.command_help('ignore')
-            return
-        if not isinstance(self.current_tab(), MucTab):
-            return
-        roomname = self.current_tab().get_name()
-        nick = args[0]
-        if roomname not in self.ignores:
-            self.ignores[roomname] = set() # no need for any order
-        if nick not in self.ignores[roomname]:
-            self.ignores[roomname].add(nick)
-            self.information(_("%s is now ignored") % nick, 'info')
-        else:
-            self.information(_("%s is alread ignored") % nick, 'info')
-
-    def command_unignore(self, arg):
-        """
-        /unignore <nick>
-        """
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        if len(args) != 1:
-            self.command_help('unignore')
-            return
-        if not isinstance(self.current_tab(), MucTab):
-            return
-        roomname = self.current_tab().get_name()
-        nick = args[0]
-        if roomname not in self.ignores or (nick not in self.ignores[roomname]):
-            self.information(_("%s was not ignored") % nick, info)
-            return
-        self.ignores[roomname].remove(nick)
-        if not self.ignores[roomname]:
-            del self.ignores[roomname]
-        self.information(_("%s is now unignored") % nick, 'info')
-
-    def command_away(self, arg):
-        """
-        /away [msg]
-        """
-        self.command_show("away "+arg)
-
-    def command_busy(self, arg):
-        """
-        /busy [msg]
-        """
-        self.command_show("busy "+arg)
-
-    def command_avail(self, arg):
-        """
-        /avail [msg]
-        """
-        self.command_show("available "+arg)
-
-    def command_part(self, arg):
-        """
-        /part [msg]
-        """
-        args = arg.split()
-        reason = None
-        if not isinstance(self.current_tab(), MucTab) and\
-                not isinstance(self.current_tab(), PrivateTab):
-            return
-        room = self.current_tab().get_room()
-        if len(args):
-            msg = ' '.join(args)
-        else:
-            msg = None
-        if isinstance(self.current_tab(), MucTab) and\
-                self.current_tab().get_room().joined:
-            muc.leave_groupchat(self.xmpp, room.name, room.own_nick, arg)
-        self.tabs.remove(self.current_tab())
-        self.refresh_window()
-
-    def command_unquery(self, arg):
-        """
-        /unquery
-        """
-        tab = self.current_tab()
-        if isinstance(tab, PrivateTab):
-            self.tabs.remove(tab)
-            self.refresh_window()
-
-    def command_query(self, arg):
-        """
-        /query <nick> [message]
-        """
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        if len(args) < 1 or not isinstance(self.current_tab(), MucTab):
-            return
-        nick = args[0]
-        room = self.current_tab().get_room()
-        r = None
-        for user in room.users:
-            if user.nick == nick:
-                r = self.open_private_window(room.name, user.nick)
-        if r and len(args) > 1:
-            msg = arg[len(nick)+1:]
-            muc.send_private_message(self.xmpp, r.name, msg)
-            self.add_message_to_text_buffer(r, msg, None, r.own_nick)
-
-    def command_topic(self, arg):
-        """
-        /topic [new topic]
-        """
-        if not isinstance(self.current_tab(), MucTab):
-            return
-        room = self.current_tab().get_room()
-        if not arg.strip():
-            self.add_message_to_text_buffer(room, _("The subject of the room is: %s") % room.topic)
-            return
-        subject = arg
-        muc.change_subject(self.xmpp, room.name, subject)
-
-    def command_link(self, arg):
-        """
-        /link <option> <nb>
-        Opens the link in a browser, or join the room, or add the JID, or
-        copy it in the clipboard
-        """
-        if not isinstance(self.current_tab(), MucTab) and\
-                not isinstance(self.current_tab(), PrivateTab):
-            return
-        args = arg.split()
-        if len(args) > 2:
-            # INFO
-            # self.add_message_to_text_buffer(self.current_room(),
-            #                          _("Link: This command takes at most 2 arguments"))
-            return
-        # set the default parameters
-        option = "open"
-        nb = 0
-        # check the provided parameters
-        if len(args) >= 1:
-            try:  # check if the argument is the number
-                nb = int(args[0])
-            except ValueError:  # nope, it's the option
-                option = args[0]
-        if len(args) == 2:
-            try:
-                nb = int(args[0])
-            except ValueError:
-                # INFO
-                # self.add_message_to_text_buffer(self.current_room(),
-                #                          _("Link: 2nd parameter should be a number"))
-                return
-        # find the nb-th link in the current buffer
-        i = 0
-        link = None
-        for msg in self.current_tab().get_room().messages[:-200:-1]:
-            if not msg:
-                continue
-            matches = re.findall('"((ftp|http|https|gopher|mailto|news|nntp|telnet|wais|file|prospero|aim|webcal):(([A-Za-z0-9$_.+!*(),;/?:@&~=-])|%[A-Fa-f0-9]{2}){2,}(#([a-zA-Z0-9][a-zA-Z0-9$_.+!*(),;/?:@&~=%-]*))?([A-Za-z0-9$_+!*();/?:~-]))"', msg.txt)
-            for m in matches:
-                if i == nb:
-                    url = m[0]
-                    self.link_open(url)
-                    return
-
-    def url_open(self, url):
-        """
-        Use webbrowser to open the provided link
-        """
-        webbrowser.open(url)
-
-    def move_separator(self):
-        """
-        Move the new-messages separator at the bottom on the current
-        text.
-        """
-        try:
-            room = self.current_tab().get_room()
-        except:
-            return
-        room.remove_line_separator()
-        room.add_line_separator()
-        self.refresh_window()
-
-    def command_nick(self, arg):
-        """
-        /nick <nickname>
-        """
-        try:
-            args = shlex.split(arg)
-        except ValueError as error:
-            return self.information(str(error), _("Error"))
-        if not isinstance(self.current_tab(), MucTab):
-            return
-        if len(args) != 1:
-            return
-        nick = args[0]
-        room = self.current_tab().get_room()
-        if not room.joined or room.name == "Info":
-            return
-        muc.change_nick(self.xmpp, room.name, nick)
-
-    def information(self, msg, typ=''):
-        """
-        Displays an informational message in the "Info" room window
-        """
-        self.information_buffer.add_message(msg, nickname=typ)
-        self.refresh_window()
-
-    def command_quit(self, arg):
-        """
-        /quit
-        """
-        if len(arg.strip()) != 0:
-            msg = arg
-        else:
-            msg = None
-        for tab in self.tabs:
-            if isinstance(tab, MucTab):
-                muc.leave_groupchat(self.xmpp, tab.get_room().name, tab.get_room().own_nick, msg)
-        self.xmpp.disconnect()
-        self.running = False
-        self.reset_curses()
-
-    def do_command(self, key):
-        if not key:
-            return
-        res = self.current_tab().on_input(key)
-        if not res:
-            return
-        if key in ('^J', '\n') and isinstance(res, str):
-            self.execute(res)
-        else :
-            # we did "enter" with an empty input in the roster
-            self.on_roster_enter_key(res)
-
-    def on_roster_enter_key(self, roster_row):
-        """
-        when enter is pressed on the roster window
-        """
-        if isinstance(roster_row, Contact):
-            # roster_row.toggle_folded()
-            if not self.get_conversation_by_jid(roster_row.get_bare_jid()):
-                self.open_conversation_window(roster_row.get_bare_jid())
-            else:
-                self.focus_tab_named(roster_row.get_bare_jid())
-        if isinstance(roster_row, Resource):
-            if not self.get_conversation_by_jid(roster_row.get_jid().full):
-                self.open_conversation_window(roster_row.get_jid().full)
-            else:
-                self.focus_tab_named(roster_row.get_jid().full)
-        self.refresh_window()
-
-    def execute(self,line):
-        """
-        Execute the /command or just send the line on the current room
-        """
-        if line == "":
-            return
-        if line.startswith('//'):
-            self.command_say(line[1:])
-        elif line.startswith('/') and not line.startswith('/me '):
-            command = line.strip()[:].split()[0][1:]
-            arg = line[2+len(command):] # jump the '/' and the ' '
-            # example. on "/link 0 open", command = "link" and arg = "0 open"
-            if command in list(self.commands.keys()):
-                func = self.commands[command][0]
-                func(arg)
-                return
-            else:
-                self.information(_("unknown command (%s)") % (command), _('Error'))
-        else:
-            self.command_say(line)
-
-    def command_say(self, line):
-        if isinstance(self.current_tab(), PrivateTab):
-            muc.send_private_message(self.xmpp, self.current_tab().get_name(), line)
-        elif isinstance(self.current_tab(), ConversationTab): # todo, special case
-            muc.send_private_message(self.xmpp, self.current_tab().get_name(), line)
-        if isinstance(self.current_tab(), PrivateTab) or\
-                isinstance(self.current_tab(), ConversationTab):
-            self.add_message_to_text_buffer(self.current_tab().get_room(), line, None, self.current_tab().get_room().own_nick)
-        elif isinstance(self.current_tab(), MucTab):
-            muc.send_groupchat_message(self.xmpp, self.current_tab().get_name(), line)
-        self.doupdate()
-
-    def doupdate(self):
-        self.current_tab().just_before_refresh()
-        curses.doupdate()
diff --git a/src/multiuserchat.py b/src/multiuserchat.py
index 311bce87..3927fc38 100644
--- a/src/multiuserchat.py
+++ b/src/multiuserchat.py
@@ -45,8 +45,7 @@ def change_show(xmpp, jid, own_nick, show, status):
     """
     Change our 'Show'
     """
-    pres = xmpp.makePresence(pto='%s/%s' % (jid, own_nick),
-                             pfrom=xmpp.boundjid.full)
+    pres = xmpp.makePresence(pto='%s/%s' % (jid, own_nick))
     if show: # if show is None, don't put a <show /> tag. It means "online"
         pres['type'] = show
     if status:
@@ -60,15 +59,13 @@ def change_subject(xmpp, jid, subject):
     msg = xmpp.makeMessage(jid)
     msg['type'] = 'groupchat'
     msg['subject'] = subject
-    msg['from'] = xmpp.boundjid.bare
     msg.send()
 
 def change_nick(xmpp, jid, nick):
     """
     Change our own nick in a room
     """
-    xmpp.makePresence(pto='%s/%s' % (jid, nick),
-                            pfrom=xmpp.boundjid.bare).send()
+    xmpp.makePresence(pto='%s/%s' % (jid, nick)).send()
 
 def join_groupchat(xmpp, jid, nick, passwd=''):
     """
diff --git a/src/poezio.py b/src/poezio.py
index a46381f9..03b6d3e6 100644
--- a/src/poezio.py
+++ b/src/poezio.py
@@ -21,14 +21,32 @@ Starting point of poezio. Launches both the Connection and Gui
 """
 
 import os
-# chdir in the source directory, to import the modules
-# also, no need to use a sh script to "cd" in this directoy
-# before launching poezio.
-os.chdir(os.path.dirname(os.path.abspath(__file__)))
-
 import curses
 import sys
 import traceback
+import threading
+
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+def installThreadExcepthook():
+    """
+    Workaround for sys.excepthook thread bug
+    See http://bugs.python.org/issue1230540
+    Python, you made me sad :(
+    """
+    init_old = threading.Thread.__init__
+    def init(self, *args, **kwargs):
+        init_old(self, *args, **kwargs)
+        run_old = self.run
+        def run_with_except_hook(*args, **kw):
+            try:
+                run_old(*args, **kw)
+            except (KeyboardInterrupt, SystemExit):
+                raise
+            except:
+                sys.excepthook(*sys.exc_info())
+        self.run = run_with_except_hook
+    threading.Thread.__init__ = init
 
 class MyStdErr(object):
     def __init__(self, fd):
@@ -67,23 +85,15 @@ def exception_handler(type_, value, trace):
 # sys.excepthook = exception_handler
 
 import signal
+import logging
 
-from connection import Connection
-from config import config
-from gui import Gui
-
-signal.signal(signal.SIGINT, signal.SIG_IGN) # ignore ctrl-c
-
-def main():
-    """
-    The main function consist of the Connection initialization
-    then the gui (ncurses) init, connection handlers and then the
-    connection is "started"
-    """
-    xmpp = Connection()         # Connection init
-    gui = Gui(xmpp)             # Gui init.
-    xmpp.start()                # Connect to remote server
-    gui.main_loop()             # Refresh the screen, wait for user events etc
+from connection import connection
+from config import config, options
+from core import core
 
 if __name__ == '__main__':
-    main()
+    signal.signal(signal.SIGINT, signal.SIG_IGN) # ignore ctrl-c
+    if options.debug:
+        logging.basicConfig(filename=options.debug,level=logging.DEBUG)
+    connection.start()  # Connect to remote server
+    core.main_loop()    # Refresh the screen, wait for user events etc
diff --git a/src/tab.py b/src/tab.py
index e6a8cc41..767ee353 100644
--- a/src/tab.py
+++ b/src/tab.py
@@ -33,11 +33,11 @@ from roster import RosterGroup, roster
 from contact import Contact, Resource
 
 class Tab(object):
-    """
-    """
     number = 0
 
-    def __init__(self, stdscr):
+    def __init__(self, stdscr, core):
+        self.core = core        # a pointer to core, to access its attributes (ugly?)
+        self.tab_type = "Tab"
         self.nb = Tab.number
         Tab.number += 1
         self.size = (self.height, self.width) = stdscr.getmaxyx()
@@ -132,8 +132,9 @@ class InfoTab(Tab):
     The information tab, used to display global informations
     when using a anonymous account
     """
-    def __init__(self, stdscr, name):
-        Tab.__init__(self, stdscr)
+    def __init__(self, stdscr, core, name):
+        Tab.__init__(self, stdscr, core)
+        self.tab_type = "InfoTab"
         self.tab_win = window.GlobalInfoBar(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.text_win = window.TextWin(self.height-2, self.width, 0, 0, stdscr, self.visible)
         self.input = window.Input(1, self.width, self.height-1, 0, stdscr, self.visible)
@@ -187,21 +188,21 @@ class MucTab(Tab):
     The tab containing a multi-user-chat room.
     It contains an userlist, an input, a topic, an information and a chat zone
     """
-    def __init__(self, stdscr, room, info_win_size):
+    def __init__(self, stdscr, core, room):
         """
         room is a Room object
         The stdscr is passed to know the size of the
         terminal
         """
-        Tab.__init__(self, stdscr)
+        Tab.__init__(self, stdscr, core)
+        self.tab_type = "MucTab"
         self._room = room
-        self.info_win_size = info_win_size
         self.topic_win = window.Topic(1, self.width, 0, 0, stdscr, self.visible)
-        self.text_win = window.TextWin(self.height-4-info_win_size, (self.width//10)*9, 1, 0, stdscr, self.visible)
+        self.text_win = window.TextWin(self.height-4-self.core.information_win_size, (self.width//10)*9, 1, 0, stdscr, self.visible)
         self.v_separator = window.VerticalSeparator(self.height-3, 1, 1, 9*(self.width//10), stdscr, self.visible)
         self.user_win = window.UserList(self.height-3, (self.width//10), 1, 9*(self.width//10)+1, stdscr, self.visible)
-        self.info_header = window.MucInfoWin(1, (self.width//10)*9, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win = window.TextWin(info_win_size, (self.width//10)*9, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.info_header = window.MucInfoWin(1, (self.width//10)*9, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win = window.TextWin(self.core.information_win_size, (self.width//10)*9, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win = window.GlobalInfoBar(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input = window.Input(1, self.width, self.height-1, 0, stdscr, self.visible)
 
@@ -212,11 +213,11 @@ class MucTab(Tab):
         Tab.resize(self, stdscr)
         text_width = (self.width//10)*9
         self.topic_win.resize(1, self.width, 0, 0, stdscr, self.visible)
-        self.text_win.resize(self.height-4-self.info_win_size, text_width, 1, 0, stdscr, self.visible)
+        self.text_win.resize(self.height-4-self.core.information_win_size, text_width, 1, 0, stdscr, self.visible)
         self.v_separator.resize(self.height-3, 1, 1, 9*(self.width//10), stdscr, self.visible)
         self.user_win.resize(self.height-3, self.width-text_width-1, 1, text_width+1, stdscr, self.visible)
-        self.info_header.resize(1, (self.width//10)*9, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, (self.width//10)*9, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.info_header.resize(1, (self.width//10)*9, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, (self.width//10)*9, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win.resize(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input.resize(1, self.width, self.height-1, 0, stdscr, self.visible)
 
@@ -297,12 +298,11 @@ class MucTab(Tab):
     def on_scroll_down(self):
         self._room.scroll_down(self.text_win.height-1)
 
-    def on_info_win_size_changed(self, size, stdscr):
-        self.info_win_size = size
+    def on_info_win_size_changed(self, stdscr):
         text_width = (self.width//10)*9
-        self.text_win.resize(self.height-4-self.info_win_size, text_width, 1, 0, stdscr, self.visible)
-        self.info_header.resize(1, (self.width//10)*9, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, (self.width//10)*9, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.text_win.resize(self.height-4-self.core.information_win_size, text_width, 1, 0, stdscr, self.visible)
+        self.info_header.resize(1, (self.width//10)*9, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, (self.width//10)*9, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
 
     def just_before_refresh(self):
         self.input.move_cursor_to_pos()
@@ -311,21 +311,21 @@ class PrivateTab(Tab):
     """
     The tab containg a private conversation (someone from a MUC)
     """
-    def __init__(self, stdscr, room, info_win_size):
-        Tab.__init__(self, stdscr)
-        self.info_win_size = info_win_size
+    def __init__(self, stdscr, core, room):
+        Tab.__init__(self, stdscr, core)
+        self.tab_type = "PrivateTab"
         self._room = room
-        self.text_win = window.TextWin(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header = window.PrivateInfoWin(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win = window.TextWin(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.text_win = window.TextWin(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header = window.PrivateInfoWin(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win = window.TextWin(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win = window.GlobalInfoBar(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input = window.Input(1, self.width, self.height-1, 0, stdscr, self.visible)
 
     def resize(self, stdscr):
         Tab.resize(self, stdscr)
-        self.text_win.resize(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header.resize(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.text_win.resize(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header.resize(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win.resize(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input.resize(1, self.width, self.height-1, 0, stdscr, self.visible)
 
@@ -369,11 +369,10 @@ class PrivateTab(Tab):
     def on_scroll_down(self):
         self._room.scroll_down(self.text_win.height-1)
 
-    def on_info_win_size_changed(self, size, stdscr):
-        self.info_win_size = size
-        self.text_win.resize(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header.resize(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+    def on_info_win_size_changed(self, stdscr):
+        self.text_win.resize(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header.resize(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
 
     def get_room(self):
         return self._room
@@ -385,7 +384,7 @@ class RosterInfoTab(Tab):
     """
     A tab, splitted in two, containing the roster and infos
     """
-    def __init__(self, stdscr):
+    def __init__(self, stdscr, core):
         self.single_key_commands = {
             "^J": self.on_enter,
             "^M": self.on_enter,
@@ -397,7 +396,8 @@ class RosterInfoTab(Tab):
             "o": self.toggle_offline_show,
             "^F": self.start_search,
             }
-        Tab.__init__(self, stdscr)
+        Tab.__init__(self, stdscr, core)
+        self.tab_type = "RosterInfoTab"
         self.name = "Roster"
         roster_width = self.width//2
         info_width = self.width-roster_width-1
@@ -534,21 +534,21 @@ class ConversationTab(Tab):
     """
     The tab containg a normal conversation (someone from our roster)
     """
-    def __init__(self, stdscr, room, info_win_size):
-        Tab.__init__(self, stdscr)
-        self.info_win_size = info_win_size
+    def __init__(self, stdscr, core, room):
+        Tab.__init__(self, stdscr, core)
+        self.tab_type = "ConversationTab"
         self._room = room
-        self.text_win = window.TextWin(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header = window.ConversationInfoWin(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win = window.TextWin(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.text_win = window.TextWin(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header = window.ConversationInfoWin(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win = window.TextWin(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win = window.GlobalInfoBar(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input = window.Input(1, self.width, self.height-1, 0, stdscr, self.visible)
 
     def resize(self, stdscr):
         Tab.resize(self, stdscr)
-        self.text_win.resize(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header.resize(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+        self.text_win.resize(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header.resize(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
         self.tab_win.resize(1, self.width, self.height-2, 0, stdscr, self.visible)
         self.input.resize(1, self.width, self.height-1, 0, stdscr, self.visible)
 
@@ -589,11 +589,10 @@ class ConversationTab(Tab):
     def on_scroll_down(self):
         self._room.scroll_down(self.text_win.height-1)
 
-    def on_info_win_size_changed(self, size, stdscr):
-        self.info_win_size = size
-        self.text_win.resize(self.height-3-self.info_win_size, self.width, 0, 0, stdscr, self.visible)
-        self.info_header.resize(1, self.width, self.height-3-self.info_win_size, 0, stdscr, self.visible)
-        self.info_win.resize(self.info_win_size, self.width, self.height-2-self.info_win_size, 0, stdscr, self.visible)
+    def on_info_win_size_changed(self, stdscr):
+        self.text_win.resize(self.height-3-self.core.information_win_size, self.width, 0, 0, stdscr, self.visible)
+        self.info_header.resize(1, self.width, self.height-3-self.core.information_win_size, 0, stdscr, self.visible)
+        self.info_win.resize(self.core.information_win_size, self.width, self.height-2-self.core.information_win_size, 0, stdscr, self.visible)
 
     def get_room(self):
         return self._room
-- 
cgit v1.2.3