Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.

BUG:215923


git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdenetwork@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da

1 files changed, 350 insertions, 0 deletions

diff --git a/kopete/protocols/meanwhile/meanwhilesession.h b/kopete/protocols/meanwhile/meanwhilesession.h
new file mode 100644
index 00000000..0e2a3558
--- /dev/null
+++ b/kopete/protocols/meanwhile/meanwhilesession.h
@@ -0,0 +1,350 @@
+/*
+    meanwhilesession.h - interface to the 'C' meanwhile session
+
+    Copyright (c) 2005      by Jeremy Kerr <[email protected]>
+
+    *************************************************************************
+    *                                                                       *
+    * This program 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; either version 2 of the License, or     *
+    * (at your option) any later version.                                   *
+    *                                                                       *
+    *************************************************************************
+*/
+#ifndef MEANWHILESESSION_H
+#define MEANWHILESESSION_H
+
+#include "meanwhileaccount.h"
+#include "meanwhilecontact.h"
+#include <kextendedsocket.h>
+
+#include <mw_session.h>
+#include <mw_service.h>
+#include <mw_srvc_aware.h>
+#include <mw_srvc_im.h>
+#include <mw_srvc_resolve.h>
+
+struct MeanwhileClientID {
+    int		id;
+    const char *name;
+};
+
+/**
+ * A class to handle libmeanwhile session management.
+ */
+class MeanwhileSession : public QObject
+{
+    Q_OBJECT
+
+public:
+    /**
+     * Create a session. By default, the session is not connected - you will
+     * need to call login() to initiate the connection process.
+     * @param account The account that the connection is for
+     */
+    MeanwhileSession(MeanwhileAccount *account);
+
+    /**
+     * Destroy the session
+     */
+    ~MeanwhileSession();
+
+    /**
+     * Connect to the server. This will open a socket and start login. Note that
+     * the connection process is ascychronous - a loginDone() signal will be
+     * emitted when sucessfully logged in.
+     */
+    void connect(QString password);
+
+    /**
+     * Disconnect from the server.
+     */
+    void disconnect();
+
+    /**
+     * Set our (the local contact's) online status. The internalStatus of the
+     * state argument will be used to define the state message we send - it
+     * should be one of the Status enum fields (and not Offline)
+     * @param state the new state of the local user
+     * @param msg a custom message to use, if required
+     */
+    void setStatus(Kopete::OnlineStatus status,
+            const QString msg = QString::null);
+
+    /**
+     * Add a single contact to be registered for status updates
+     * @param contact The contact to register
+     */
+    void addContact(const Kopete::Contact *contact);
+
+    /**
+     * Add a list of contacts to be registered for status updates
+     * @param contact The list of contacts to register
+     */
+    void addContacts(const QDict<Kopete::Contact>& contacts);
+
+    /**
+     * Send a message (with recipient specified).
+     * @param message The message to send
+     * @return non-zero if  the message could be sent
+     */
+    int sendMessage(Kopete::Message &message);
+
+    /**
+     * Send a typing notification to a contact
+     * @param contact  The contact to notify
+     * @param isTyping If true, the typing notification is set
+     */
+    void sendTyping(MeanwhileContact *contact, bool isTyping);
+
+    /**
+     * Determine if the session is connected to the server
+     * @return true if the session is connected
+     */
+    bool isConnected();
+
+    /**
+     * Determine if the session is in the process of connecting to the server
+     * @return true if the session is connecting
+     */
+    bool isConnecting();
+
+    static const struct MeanwhileClientID *getClientIDs();
+
+    static void getDefaultClientIDParams(int *clientID,
+	    int *verMajor, int *verMinor);
+signals:
+    /**
+     * Emitted when the status of the connection changes
+     * @param status The new status of the session
+     */
+    void sessionStateChange(Kopete::OnlineStatus status);
+
+    /**
+     * Emitted when a notification is received from the server, or other
+     * out-of-band data (eg, the password is incorrect).
+     * @param mesgString A description of the notification
+     */
+    void serverNotification(const QString &mesgString);
+
+private:
+    /** Main libmeanwhile session object */
+    struct mwSession *session;
+
+    /** Session handler */
+    struct mwSessionHandler sessionHandler;
+
+    /** Aware service */
+    struct mwServiceAware *awareService;
+
+    /** Aware handler */
+    struct mwAwareHandler awareHandler;
+
+    /** Aware List Handler */
+    struct mwAwareListHandler awareListHandler;
+
+    /** The aware list */
+    struct mwAwareList *awareList;
+
+    /** Aware service */
+    struct mwServiceIm *imService;
+
+    /** Aware handler */
+    struct mwImHandler imHandler;
+
+    /** Resolve service */
+    struct mwServiceResolve *resolveService;
+
+    /** Storage service, for contact list */
+    struct mwServiceStorage *storageService;
+
+    /** Last recorded meanwhile state */
+    enum mwSessionState state;
+
+    /** The kopete account that this library is for */
+    MeanwhileAccount *account;
+
+    /** socket to the server */
+    KExtendedSocket *socket;
+
+    /* These structures are stored in the libmeanwhile 'ClientData' fields */
+
+    /** Stored in the mwConversation struct */
+    struct ConversationData {
+        MeanwhileContact *contact;
+        Kopete::ChatSession *chat;
+        QValueList<Kopete::Message> *queue;
+    };
+
+    /** (To be) stored in the mwConference struct */
+    struct ConferenceData {
+        Kopete::ChatSession *chatsession;
+    };
+
+    /**
+     * Initialise the conversation data struct for a conversation, and store it 
+     * in the meanwhile conversation object
+     * @param conv        the meanwhile conversation object
+     * @param contact     the contact that the conversation is with
+     * @param createQueue whether a message queue is required for this
+     *                    conversation
+     * @return The created conversation data struct
+     */
+    struct ConversationData *createConversationData(
+            struct mwConversation *conv, MeanwhileContact *contact,
+            bool createQueue = false);
+
+    /**
+     * Get the contact for a conversation
+     * @param conv the meanwhile conversation
+     * @return the contact that this conversation is held with
+     */
+    MeanwhileContact *conversationContact(struct mwConversation *conv);
+
+    /**
+     * Convert a libmeanwhile-type status into one of the MeanwhileProtocol
+     * statuses
+     * @param mstatus The internal status to convert
+     * @return The Meanwhile status
+     */
+    Kopete::OnlineStatus convertStatus(int mstatus);
+
+    /**
+     * Parse the nickname of a libmeanwhile contact. From what I've seen,
+     * usernames are in the format:
+     *  <userid> - <name>/<domain>/<domain>
+     * @param name the extened username to parse
+     * @return just the name part of the username info
+     */
+    QString getNickName(QString name);
+
+    /**
+     * Convenience method to call the above from a mwLoginInfo struct. All is
+     * checked for null.
+     * @param logininfo the login info for a contact
+     * @return just the name part of the login info data
+     */
+    QString getNickName(struct mwLoginInfo *logininfo);
+
+    /**
+     * Resolve a contact to find (and set) the display name. This requires the
+     * session to be connected to use the meanwhile resolve service.
+     * @param contact The contact to resolve
+     */
+     void resolveContactNickname(MeanwhileContact *contact);
+
+public:
+    void syncContactsToServer();
+    void syncContactsFromServer();
+
+private slots:
+
+    /** Notify the library that data is available on the socket */
+    void slotSocketDataAvailable();
+
+    /**
+     * Notify the library that the socket has been closed
+     * @param reason the reason for closing
+     */
+    void slotSocketClosed(int reason);
+
+private:
+    /* ugly callbacks for libmeanwhile interface. These declare a static method
+     * to proxy the callback from libmeanwhile to a call to the MeanwhileSession
+     */
+
+#define declare_session_handler_type(type, func, args, ...)                    \
+    static type _handleSession ## func (                                       \
+            struct mwSession *mwsession, __VA_ARGS__) {                        \
+        MeanwhileSession *session =                                            \
+            (MeanwhileSession *)mwSession_getClientData(mwsession);            \
+        return session->handleSession ## func args;                            \
+    };                                                                         \
+    type handleSession ## func(__VA_ARGS__)
+#define declare_session_handler(func, args, ...)                               \
+    static void _handleSession ## func (                                       \
+            struct mwSession *mwsession, ## __VA_ARGS__) {                     \
+        MeanwhileSession *session =                                            \
+            (MeanwhileSession *)mwSession_getClientData(mwsession);            \
+        session->handleSession ## func args;                                   \
+    };                                                                         \
+    void handleSession ## func(__VA_ARGS__)
+
+    declare_session_handler_type(int, IOWrite, (buf, len),
+            const guchar *buf, gsize len);
+    declare_session_handler(IOClose,());
+    declare_session_handler(Clear,());
+    declare_session_handler(StateChange, (state, info),
+            enum mwSessionState state, gpointer info);
+    declare_session_handler(SetPrivacyInfo,());
+    declare_session_handler(SetUserStatus,());
+    declare_session_handler(Admin, (text), const char *text);
+    declare_session_handler(Announce, (from, may_reply, text),
+            struct mwLoginInfo *from, gboolean may_reply, const char *text);
+
+#define declare_aware_handler(func, args, ...)                                 \
+    static void _handleAware ## func (                                         \
+            struct mwServiceAware *srvc, ## __VA_ARGS__) {                     \
+        MeanwhileSession *session = (MeanwhileSession *)                       \
+            mwService_getClientData((struct mwService *)srvc);                 \
+        return session->handleAware ## func args;                              \
+    }; \
+    void handleAware ## func(__VA_ARGS__)
+
+    declare_aware_handler(Attrib, (attrib), struct mwAwareAttribute *attrib);
+    declare_aware_handler(Clear,());
+
+#define declare_aware_list_handler(func, args, ...)                            \
+    static void _handleAwareList ## func (                                     \
+            struct mwAwareList *list, ## __VA_ARGS__){                         \
+        MeanwhileSession *session = (MeanwhileSession *)                       \
+            mwAwareList_getClientData(list);                                   \
+        return session->handleAwareList ## func args;                          \
+    }; \
+    void handleAwareList ## func(__VA_ARGS__)
+
+    declare_aware_list_handler(Aware, (snapshot),
+            struct mwAwareSnapshot *snapshot);
+    declare_aware_list_handler(Attrib, (id, attrib),
+            struct mwAwareIdBlock *id, struct mwAwareAttribute *attrib);
+    declare_aware_list_handler(Clear,());
+
+#define declare_im_handler(func, args, ...)                                    \
+    static void _handleIm ## func (                                            \
+            struct mwConversation *conv, ## __VA_ARGS__) {                     \
+        MeanwhileSession *session = (MeanwhileSession *)                       \
+            mwService_getClientData(                                           \
+                (struct mwService *)mwConversation_getService(conv));          \
+        return session->handleIm ## func args;                                 \
+    }; \
+    void handleIm ## func (struct mwConversation *conv, ## __VA_ARGS__)
+
+    declare_im_handler(ConvOpened, (conv));
+    declare_im_handler(ConvClosed, (conv, err), guint32 err);
+    declare_im_handler(ConvReceived, (conv, type, msg),
+            enum mwImSendType type, gconstpointer msg);
+
+    /* resolve service */
+    static void _handleResolveLookupResults(struct mwServiceResolve *srvc,
+            guint32 id, guint32 code, GList *results, gpointer data) {
+        MeanwhileSession *session = (MeanwhileSession *)
+            mwService_getClientData(MW_SERVICE(srvc));
+        session->handleResolveLookupResults(srvc, id, code, results, data);
+    };
+    void handleResolveLookupResults(struct mwServiceResolve *srvc, guint32 id,
+            guint32 code, GList *results, gpointer data);
+
+    /* storage service */
+    static void _handleStorageLoad(struct mwServiceStorage *srvc,
+            guint32 result, struct mwStorageUnit *item, gpointer data) {
+        MeanwhileSession *session = (MeanwhileSession *)
+            mwService_getClientData(MW_SERVICE(srvc));
+        session->handleStorageLoad(srvc, result, item, data);
+    };
+    void handleStorageLoad(struct mwServiceStorage *srvc,
+            guint32 result, struct mwStorageUnit *item, gpointer data);
+};
+
+#endif
+