ircnetworkadapter.h

//------------------------------------------------------------------------------
// ircnetworkadapter.h
//------------------------------------------------------------------------------
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library 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
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
// 02110-1301  USA
//
//------------------------------------------------------------------------------
// Copyright (C) 2010 "Zalewa" <zalewapl@gmail.com>
//------------------------------------------------------------------------------
#ifndef __IRCNETWORKADAPTER_H__
#define __IRCNETWORKADAPTER_H__

#include "irc/ircadapterbase.h"
#include "irc/ircclient.h"
#include "irc/ircnetworkconnectioninfo.h"
#include "irc/ircrequestparser.h"
#include "socketsignalsadapter.h"

#include <QHash>

class IRCChatAdapter;
class IRCISupportParser;
class IRCResponseParser;
class IRCSocketSignalsAdapter;
class IRCUserList;
class IRCUserPrefix;

class IRCNetworkAdapter : public IRCAdapterBase
{
        Q_OBJECT

        friend class IRCSocketSignalsAdapter;

        public:
                IRCNetworkAdapter(IRCNetworkConnectionInfo connectionInfo);
                ~IRCNetworkAdapter();

                AdapterType adapterType() const { return NetworkAdapter; }

                bool amIOperator(const QString& channel) const
                {
                        return this->isOperator(this->myNickname(), channel);
                }

                void banUser(const QString& nickname, const QString& reason, const QString& channel);

                QList<IRCAdapterBase*> childrenAdapters();
                void connect();
                const IRCNetworkConnectionInfo &connection() const
                {
                        return this->connectionInfo;
                }

                void detachChatWindow(const IRCChatAdapter* pAdapter);

                void disconnect(const QString& farewellMessage);

                void doSendMessage(const QString& message, IRCAdapterBase* pOrigin);

                bool hasRecipient(const QString& recipient) const;

                const PatternList &ignoredUsersPatterns() const;

                bool isAdapterRelated(const IRCAdapterBase* pAdapter) const;
                bool isConnected() const { return ircClient.isConnected(); }
                bool isMyNickname(const QString& nickname) const;

                bool isOperator(const QString& nickname, const QString& channel) const;

                void killAllChatWindows();

                const QString& myNickname() const { return connectionInfo.nick; }

                IRCNetworkAdapter* network()
                {
                        return this;
                }

                IRCResponseParser *responseParser()
                {
                        return ircResponseParser;
                }

                void setChannelMode(const QString& channel, const QString& nickname, const QString& flag, bool bSet);

                void sendCtcp(const QString &nickname, const QString &command);

                void setEmitAllIRCMessagesEnabled(bool b)
                {
                        this->bEmitAllIRCMessages = b;
                }

                void setNetworkEntity(const IRCNetworkEntity &network);

                QString title() const;

                const IRCUserPrefix &userPrefixes() const;

        public slots:
                void openNewAdapter(const QString& recipientName);

                void printMsgLiteral(const QString& recipient, const QString& content,
                        const IRCMessageClass& msgClass);
                void print(const QString& printWhat, const QString& printWhere);
                void printWithClass(const QString& printWhat, const QString& printWhere, const IRCMessageClass& msgClass);
                void printToCurrentChatBox(const QString& printWhat, const IRCMessageClass& msgClass);
                void reloadNetworkEntityFromConfig();
                void userPing(const QString &nickname, qint64 ping);

        signals:
                void newChatWindowIsOpened(IRCChatAdapter* pWindow);

        private:
                bool bIsJoining;

                bool bEmitAllIRCMessages;

                QHash<QString, IRCChatAdapter*> chatWindows;
                IRCNetworkConnectionInfo connectionInfo;
                IRCClient ircClient;
                IRCRequestParser ircRequestParser;
                IRCResponseParser* ircResponseParser;
                IRCISupportParser* ircISupportParser;
                IRCSocketSignalsAdapter* pIrcSocketSignalsAdapter;

                IRCChatAdapter* getChatAdapter(const QString& recipient);
                const IRCChatAdapter* getChatAdapter(const QString& recipient) const;

                IRCChatAdapter* getOrCreateNewChatAdapter(const QString& recipient);

                void killChatWindow(const QString& recipient);

        private slots:
                void appendISupportLine(const QString &line);
                void echoPrivmsg(const QString& recipient, const QString& content);
                void helloClient(const QString& nickname);
                void kick(const QString& channel, const QString& byWhom, const QString& whoIsKicked, const QString& reason);
                void kill(const QString& victim, const QString& comment);
                void ircServerResponse(const QString& message);
                void modeInfo(const QString& channel, const QString& whoSetThis, const QString& modeParams);
                void namesListReceived(const QString& channel, const QStringList& names);
                void namesListEndReceived(const QString& channel);
                void nicknameInUse(const QString& nickname);
                void noSuchNickname(const QString& nickname);
                void parseError(const QString& error);

                void privMsgReceived(const QString& recipient, const QString& sender, const QString& content);
                void sendPong(const QString& toWhom);
                void userChangesNickname(const QString& oldNickname, const QString& newNickname);
                void userIdleTime(const QString &nick, int secondsIdle);
                void userJoinsChannel(const QString& channel, const QString& nickname, const QString& fullSignature);
                void userModeChanged(const QString& channel, const QString& nickname,
                        const QList<char> &addedFlags, const QList<char> &removedFlags);
                void userNetworkJoinDateTime(const QString &nick, const QDateTime &timeOfJoin);
                void userPartsChannel(const QString& channel, const QString& nickname, const QString& farewellMessage);
                void userQuitsNetwork(const QString& nickname, const QString& farewellMessage);
                void whoIsUser(const QString& nickname, const QString& user, const QString& hostName, const QString& realName);

};

class IRCSocketSignalsAdapter : public SocketSignalsAdapter
{
        Q_OBJECT

        public:
                IRCNetworkAdapter* pParent;

                IRCSocketSignalsAdapter(IRCNetworkAdapter* pParent)
                {
                        this->pParent = pParent;
                }

        public slots:
                void connected();
                void disconnected();
                void errorReceived(QAbstractSocket::SocketError error);
                void infoMessage(const QString& message);
};

#endif