Multiuser chat

[Anders Olofsson]

I would really like to have better support for multiuser chats in Licq
and have thought a bit on how to make that happen.

I was thinking to start simple by just getting support for named chat
rooms and only for Jabber protocol. (Because this is what I personally
need most right now.)
When we have something working, this can be extended to other protocols,
unnamed/dynamic chatrooms, history, etc.

For the core I'm hoping it will be enough to just forward signals and
events between the UI and protocol plugin. Should be pretty easy at this
stage.

For the Qt4-Gui I'm thinking of making a new chat window for this.
(Actually I later want to replace the existing event window and handle
2-way chats with the new chat window as well. I think the current way of
sending files/URLs/etc from within the message-dialog makes it overly
complicated and separate dialogs (like the authorization dialog) would
be better.)

For the Jabber protocol, I've looked a bit at the API documentation and
there is a (very) simple example included in gloox but I don't feel this
is enough for me to start from.
The first step I want to do is to list or search for existing chats. I
also could not find how to receive an invitation to join a chat group.
Any help here would be appreciated.


For the "full solution" I'm currently seeing the following problems that
I'm not sure how to solve (mostly has to do with how to log history).
The first parts above should be limited to avoid these problems for now.

- How should the history be saved? Our current format only allows two
parts in a log so a new format is needed. For chats I also think it
would be relevant to log joins, leaves, mode changes, etc. Also a file
structure and naming is needed that can handle unnamed chats.

- How should the history be made available for old chats? (This applies
both from the core to the plugins and from the UI to the user.)

- MSN basically has no direct messages (at least not with our current
protocol version) and uses multiuser chats for everything. I think we
should still keep the feeling of simple messaging until a third person
enters, so how do we handle the transition from direct messaging to
multiuser chat? The GUI window could probably morph, but how should the
core know when to log to the user history instead of the chat history?
And should the illusion of simple messaging only happen in the UI or
should the core (and possible also the protocol plugin) be part of
pretending to send simpl messages?

- I want to be able to close a chat window without leaving the group. (I
think Pidgin can do this by adding chats to the contact list.) But when
the window is reopened, it would be nice if the previous log is still
there. Should this cache of the chat happen in the GUI even though the
window is closed or should the core add logic to cache the conversation?
Or should the UI just re-request entries from the history file every
time the window is opened?


/Anders