KviChannelWindow.h

Go to the documentation of this file.

#ifndef _KVI_CHANNEL_H_
#define _KVI_CHANNEL_H_
//=============================================================================
//
//   File : KviChannelWindow.h
//   Creation date : Tue Aug  1 2000 01:42:00 by Szymon Stefanek
//
//   This file is part of the KVIrc IRC client distribution
//   Copyright (C) 2000-2011 Szymon Stefanek (pragma at kvirc dot net)
//
//   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.
//
//   This program 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 this program. If not, write to the Free Software Foundation,
//   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================

#include "kvi_settings.h"
#include "KviConsoleWindow.h"
#include "KviWindow.h"
#include "KviCString.h"
#include "KviIrcUserDataBase.h"
#include "KviPixmap.h"
#include "KviUserListView.h"
#include "KviTimeUtils.h"
#include "KviModeWidget.h"
#include "KviPointerHashTable.h"

#include <QList>
#include <QDateTime>
#include <QStringList>
#include <QToolButton>

class KviConsoleWindow;
class KviTopicWidget;
class KviIrcMask;
class KviThemedLabel;
class KviTalHBox;
class KviMaskEditor;
class KviModeEditor;

#ifdef COMPILE_ON_WINDOWS
// windows compiler wants this instead of the forward decl
#include "KviMaskEditor.h"
#else
typedef struct _KviMaskEntry KviMaskEntry; // KviMaskEditor.h
#endif

#define KVI_CHANNEL_ACTION_HISTORY_MAX_COUNT 40
#define KVI_CHANNEL_ACTION_HISTORY_MAX_TIMESPAN 600

#ifndef KVI_CHANNEL_AVERAGE_USERS
#define KVI_CHANNEL_AVERAGE_USERS 101
#endif

typedef struct _KviChannelAction
{
        QString szNick;           // action source nick
        unsigned int uActionType; // type of the action
        kvi_time_t tTime;         // time of the action
        int iTemperature;         // temperature of the action
} KviChannelAction;

typedef struct _KviChannelActivityStats
{
        unsigned int uActionCount;            // number of actions in the history
        bool bStatsInaccurate;                // the stats are inaccurate because we have just joined the chan
        unsigned int uLastActionTimeSpan;     // the timespan between the last action and now
        unsigned int uFirstActionTimeSpan;    // the time span between the first and the last action
        double dActionsPerMinute;             // average number of actions per minute in the lastActionTimeSpan
        unsigned int uActionsInTheLastMinute; // number of actions in the last minute
        int iAverageActionTemperature;        // the average chan temperature
        unsigned int uHotActionCount;
        unsigned int uHotActionPercent;
        QStringList lTalkingUsers; // users that seem to be talking NOW
        QStringList lWereTalkingUsers;
} KviChannelActivityStats;

class KVIRC_API KviChannelWindow : public KviWindow
{
        Q_OBJECT
public:
        enum StateFlag
        {
                HaveAllNames = 1,             
                HaveWhoList = (1 << 2),       
                DeadChan = (1 << 3),          
                SentWhoRequest = (1 << 4),    
                SentPart = (1 << 5),          
                Synchronized = (1 << 6),      
                NoCloseOnPart = (1 << 7),     
                SentSyncWhoRequest = (1 << 8) 
        };

        enum ActivityLimit
        {
                Ice = 5,        
                VeryCold = 10,  
                Cold = 20,      
                Undefined = 30, 
                Hot = 50,       
                VeryHot = 70    
        };

        KviChannelWindow(KviConsoleWindow * lpConsole, const QString & szName);

        ~KviChannelWindow();

protected:
        KviTalSplitter * m_pTopSplitter;
        KviTalSplitter * m_pVertSplitter;
        QToolButton * m_pDoubleViewButton;
        KviWindowToolPageButton * m_pListViewButton;
        KviWindowToolPageButton * m_pModeEditorButton;
        QMap<char, KviWindowToolPageButton *> m_pListEditorButtons;
        QMap<char, KviMaskEditor *> m_pListEditors;
        KviModeEditor * m_pModeEditor;
        KviIrcView * m_pMessageView;
        KviTopicWidget * m_pTopicWidget;
        KviUserListView * m_pUserListView;
        KviModeWidget * m_pModeWidget;
        int m_iStateFlags;
        QString m_szSentModeRequests;
        QString m_szChannelMode;
        QMap<char, QString> m_szChannelParameterModes;
        QMap<char, KviPointerList<KviMaskEntry> *> m_pModeLists;
        KviPixmap m_privateBackground;
        QDateTime m_joinTime;
        QString m_szNameWithUserFlag;
        QStringList * m_pTmpHighLighted;
        unsigned int m_uActionHistoryHotActionCount;
        KviPointerList<KviChannelAction> * m_pActionHistory;
        kvi_time_t m_tLastReceivedWhoReply;
        QList<int> m_VertSplitterSizesList;
        QList<int> m_SplitterSizesList;
        KviTalHBox * m_pButtonContainer;

public:
        KviUserListView * userListView() { return m_pUserListView; };

        KviTopicWidget * topicWidget() { return m_pTopicWidget; };

        KviIrcView * messageView() const { return m_pMessageView; };

        QFrame * buttonContainer() { return (QFrame *)m_pButtonContainer; };

        inline KviPointerList<KviMaskEntry> * modeMasks(char cMode)
        {
                if(m_pModeLists.contains(cMode))
                        return m_pModeLists.value(cMode);
                return 0;
        };

        QString * firstSelectedNickname() { return m_pUserListView->firstSelectedNickname(); };

        QString * nextSelectedNickname() { return m_pUserListView->nextSelectedNickname(); };

        virtual const QString & target() { return windowName(); };

        const QString & nameWithUserFlag() { return m_szNameWithUserFlag; };

        void getChannelActivityStats(KviChannelActivityStats * pStats);

        int selectedCount() { return m_pUserListView->selectedCount(); };

        int chanOwnerCount() { return m_pUserListView->chanOwnerCount(); };

        int chanAdminCount() { return m_pUserListView->chanAdminCount(); };

        int opCount() { return m_pUserListView->opCount(); };

        int halfOpCount() { return m_pUserListView->halfOpCount(); };

        int voiceCount() { return m_pUserListView->voiceCount(); };

        int userOpCount() { return m_pUserListView->userOpCount(); };

        unsigned int count() { return m_pUserListView->count(); };

        unsigned int maskCount(char cMode)
        {
                if(m_pModeLists.contains(cMode))
                        return m_pModeLists.value(cMode)->count();
                return 0;
        };

        void setModeInList(char cMode, const QString & szMask, bool bAdd, const QString & szSetBy, unsigned int uSetAt, QString szChangeMask = QString());

        kvi_time_t lastReceivedWhoReply() { return m_tLastReceivedWhoReply; };

        void setLastReceivedWhoReply(kvi_time_t tTime) { m_tLastReceivedWhoReply = tTime; };

        bool sentSyncWhoRequest() { return (m_iStateFlags & SentSyncWhoRequest); };

        void setSentSyncWhoRequest() { m_iStateFlags |= SentSyncWhoRequest; };

        void clearSentSyncWhoRequest() { m_iStateFlags ^= SentSyncWhoRequest; };

        bool sentWhoRequest() { return (m_iStateFlags & SentWhoRequest); };

        void setSentWhoRequest() { m_iStateFlags |= SentWhoRequest; };

        bool sentListRequest(char cMode) { return m_szSentModeRequests.contains(cMode); };

        void setSentListRequest(char cMode) { m_szSentModeRequests.append(cMode); };

        void setListRequestDone(char cMode)
        {
                m_szSentModeRequests.remove(cMode);
                checkChannelSync();
        };

        bool hasAllNames() { return (m_iStateFlags & HaveAllNames); };

        void setHasAllNames()
        {
                m_iStateFlags |= HaveAllNames;
                checkChannelSync();
        };

        bool hasInviteList() { return m_pModeLists.contains('I'); };

        bool hasWhoList() { return (m_iStateFlags & HaveWhoList); };

        void setHasWhoList()
        {
                m_iStateFlags |= HaveWhoList;
                checkChannelSync();
        };

        bool hasBanList() { return m_pModeLists.contains('b'); };

        bool hasBanExceptionList() { return m_pModeLists.contains('e'); };

        bool hasQuietBanList() { return m_pModeLists.contains('q'); };

        bool closeOnPart() { return !(m_iStateFlags & NoCloseOnPart); };

        void partMessageSent(bool bCloseOnPart = true, bool bShowMessage = true);

        virtual bool activityMeter(unsigned int * puActivityValue, unsigned int * puActivityTemperature);

        void setDeadChan();

        bool isDeadChan() { return (m_iStateFlags & DeadChan); };

        void setAliveChan();

        void prependUserFlag(const QString & szNick, QString & szBuffer) { m_pUserListView->prependUserFlag(szNick, szBuffer); };

        char getUserFlag(const QString & szNick) { return m_pUserListView->getUserFlag(szNick); };

        virtual QSize sizeHint() const;

        void enableUserListUpdates(bool bEnable) { m_pUserListView->enableUpdates(bEnable); };

        KviUserListEntry * join(const QString & szNick, const QString & szUser = QString(), const QString & szHost = QString(), int iFlags = 0) { return m_pUserListView->join(szNick, szUser, szHost, iFlags); };

        bool avatarChanged(const QString & szNick) { return m_pUserListView->avatarChanged(szNick); };

        bool setChanOwner(const QString & szNick, bool bChanOwner) { return m_pUserListView->setChanOwner(szNick, bChanOwner); };

        bool setChanAdmin(const QString & szNick, bool bChanAdmin) { return m_pUserListView->setChanAdmin(szNick, bChanAdmin); };

        bool setOp(const QString & szNick, bool bOp, bool bIsMe);

        bool setHalfOp(const QString & szNick, bool bHalfOp, bool) { return m_pUserListView->setHalfOp(szNick, bHalfOp); };

        bool setVoice(const QString & szNick, bool bVoice, bool) { return m_pUserListView->setVoice(szNick, bVoice); };

        bool setUserOp(const QString & szNick, bool bUserOp, bool) { return m_pUserListView->setUserOp(szNick, bUserOp); };

        bool isChanOwner(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isChanOwner(szNick, bAtLeast); };

        bool isChanAdmin(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isChanAdmin(szNick, bAtLeast); };

        bool isOp(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isOp(szNick, bAtLeast); };

        bool isHalfOp(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isHalfOp(szNick, bAtLeast); };

        bool isVoice(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isVoice(szNick, bAtLeast); };

        bool isUserOp(const QString & szNick, bool bAtLeast = false) { return m_pUserListView->isUserOp(szNick, bAtLeast); };

        bool isMeIrcOp(bool bAtLeast = false);

        bool isMeChanOwner(bool bAtLeast = false);

        bool isMeChanAdmin(bool bAtLeast = false);

        bool isMeOp(bool bAtLeast = false);

        bool isMeHalfOp(bool bAtLeast = false);

        bool isMeVoice(bool bAtLeast = false);

        bool isMeUserOp(bool bAtLeast = false);

        void userAction(KviIrcMask * user, unsigned int uActionType);

        void userAction(const QString & szNick, unsigned int uActionType);

        void userAction(const QString & szNick, const QString & szUser, const QString & szHost, unsigned int uActionType);

        void channelAction(const QString & szNick, unsigned int uActionType, int iTemperature);

        bool nickChange(const QString & szOldNick, const QString & szNewNick);

        bool part(const QString & szNick);

        bool isOn(const QString & szNick) { return (m_pUserListView->findEntry(szNick) != 0); };

        KviUserListEntry * findEntry(const QString & szNick) { return m_pUserListView->findEntry(szNick); };

        int myFlags();

        void updateModeLabel();

        virtual void outputMessage(int iMsgType, const QString & szMsg, const QDateTime & datetime = QDateTime());

        void ownMessage(const QString & szBuffer, bool bUserFeedback = true);

        void ownAction(const QString & szBuffer);

        void setChannelMode(char cMode, bool bAdd);

        QString plainChannelMode() { return m_szChannelMode; };

        void getChannelModeString(QString & szBuffer);

        void getChannelModeStringWithEmbeddedParams(QString & szBuffer);

        void setChannelModeWithParam(char cMode, QString & szParam);

        bool hasChannelMode(char cMode) { return m_szChannelParameterModes.contains(cMode); };

        QString channelModeParam(char cMode) const { return m_szChannelParameterModes.value(cMode); };

        void addHighlightedUser(const QString & szNick);

        void removeHighlightedUser(const QString & szNick);

        bool isHighlightedUser(const QString & szNick) { return m_pTmpHighLighted->contains(szNick, Qt::CaseInsensitive); };

        virtual void lostUserFocus();

        virtual void getWindowListTipText(QString & szBuffer);

        void unhighlight();

        void pasteLastLog();

        QByteArray loadLogFile(const QString & szFileName, bool bGzip);

        KviIrcConnectionServerInfo * serverInfo();

        void checkChannelSync();

protected:
        bool eventFilter(QObject * pObject, QEvent * pEvent);

        virtual QPixmap * myIconPtr();

        virtual void fillCaptionBuffers();

        virtual void getConfigGroupName(QString & szBuffer);

        virtual void saveProperties(KviConfigurationFile * pCfg);

        virtual void loadProperties(KviConfigurationFile * pCfg);

        virtual void applyOptions();

        virtual void getBaseLogFileName(QString & szBuffer);

        virtual void triggerCreationEvents();

        void internalMask(const QString & szMask, bool bAdd, const QString & szSetBy, unsigned int uSetAt, KviPointerList<KviMaskEntry> * l, KviMaskEditor ** ppEd, QString & szChangeMask);

        void showDoubleView(bool bShow);

        void fixActionHistory();

        void getTalkingUsersStats(QString & szBuffer, QStringList & list, bool bPast);

        virtual void preprocessMessage(QString & szMessage);

        virtual void resizeEvent(QResizeEvent *);
        virtual void closeEvent(QCloseEvent * pEvent);
private slots:
        void toggleDoubleView();

        void toggleListView();

        void toggleListModeEditor();

        void toggleModeEditor();

        void modeSelectorDone();

        void topicSelected(const QString & szTopic);

        void setMode(QString & szMode);

        void textViewRightClicked();

        void removeMasks(KviMaskEditor * pEd, KviPointerList<KviMaskEntry> * pList);

        void toggleToolButtons();

signals:
        void opStatusChanged();
};

#endif //_KVI_CHANNEL_H_