ircdocktabcontents.cpp

//------------------------------------------------------------------------------
// ircdocktabcontents.cpp
//------------------------------------------------------------------------------
//
// 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.
//
//------------------------------------------------------------------------------
// Copyright (C) 2010 "Zalewa" <zalewapl@gmail.com>
//------------------------------------------------------------------------------
#include "ircdocktabcontents.h"
#include "ui_ircdocktabcontents.h"
#include "gui/irc/ircignoresmanager.h"
#include "gui/irc/ircsounds.h"
#include "gui/irc/ircuserlistmodel.h"
#include "gui/commongui.h"
#include "irc/configuration/chatlogscfg.h"
#include "irc/configuration/ircconfig.h"
#include "irc/entities/ircnetworkentity.h"
#include "irc/ops/ircdelayedoperationignore.h"
#include "irc/chatlogrotate.h"
#include "irc/chatlogs.h"
#include "irc/ircchanneladapter.h"
#include "irc/ircdock.h"
#include "irc/ircglobal.h"
#include "irc/ircmessageclass.h"
#include "irc/ircnetworkadapter.h"
#include "irc/ircnicknamecompleter.h"
#include "irc/ircuserinfo.h"
#include "irc/ircuserlist.h"
#include "application.h"
#include "log.h"
#include <QDateTime>
#include <QFile>
#include <QKeyEvent>
#include <QMenu>
#include <QScrollBar>
#include <QStandardItemModel>
#include <QTimer>
#include <cassert>


const int IRCDockTabContents::BLINK_TIMER_DELAY_MS = 650;

DClass<IRCDockTabContents> : public Ui::IRCDockTabContents
{
public:
        QFile log;
        QDateTime lastMessageDate;

        bool bBlinkTitle;
        bool bIsDestroying;

        QTimer blinkTimer;

        IRCMessageClass* lastMessageClass;
        IRCNicknameCompleter *nicknameCompleter;
        QStringList textOutputContents;
        ::IRCDockTabContents::UserListMenu* userListContextMenu;
};

DPointeredNoCopy(IRCDockTabContents)

class IRCDockTabContents::UserListMenu : public QMenu
{
        public:
                UserListMenu();

                QAction* ban;
                QAction *whois;
                QAction *ctcpTime;
                QAction *ctcpPing;
                QAction *ctcpVersion;
                QAction* dehalfOp;
                QAction* deop;
                QAction* devoice;
                QAction* halfOp;
                QAction* kick;
                QAction *ignore;
                QAction* op;
                QAction* openChatWindow;
                QAction* voice;

        private:
                bool bIsOperator;

};

IRCDockTabContents::IRCDockTabContents(IRCDock* pParentIRCDock)
{
        d->setupUi(this);
        d->lastMessageDate = QDateTime::currentDateTime();

        d->bBlinkTitle = false;
        d->bIsDestroying = false;
        d->lastMessageClass = NULL;
        d->userListContextMenu = NULL;
        this->pIrcAdapter = NULL;

        this->pParentIRCDock = pParentIRCDock;
        d->nicknameCompleter = new IRCNicknameCompleter();

        d->txtOutputWidget->setContextMenuPolicy(Qt::CustomContextMenu);
        setupNewUserListModel();

        // There is only one case in which we want this to be visible:
        // if we are in a channel.
        d->lvUserList->setVisible(false);

        this->connect(d->btnSend, SIGNAL(clicked()), SLOT(sendMessage()));
        this->connect(d->leCommandLine, SIGNAL(returnPressed()), SLOT(sendMessage()));
        this->connect(gApp, SIGNAL(focusChanged(QWidget*, QWidget*)),
                SLOT(onFocusChanged(QWidget*, QWidget*)));

        applyAppearanceSettings();

        d->blinkTimer.setSingleShot(false);
        this->connect(&d->blinkTimer, SIGNAL( timeout() ),
                SLOT( blinkTimerSlot() ) );

        // Performance check line, keep commented for non-testing builds:
        //receiveMessage(Strings::createRandomAlphaNumericStringWithNewLines(80, 5000));
}

IRCDockTabContents::~IRCDockTabContents()
{
        d->bIsDestroying = true;

        if (d->lastMessageClass != NULL)
        {
                delete d->lastMessageClass;
        }

        if (d->userListContextMenu != NULL)
        {
                delete d->userListContextMenu;
        }

        if (pIrcAdapter != NULL)
        {
                disconnect(pIrcAdapter, 0, 0, 0);
                IRCAdapterBase* pTmpAdapter = pIrcAdapter;
                pIrcAdapter = NULL;
                delete pTmpAdapter;
        }
}

void IRCDockTabContents::adapterFocusRequest()
{
        emit focusRequest(this);
}

void IRCDockTabContents::adapterTerminating()
{
        if (pIrcAdapter != NULL && !d->bIsDestroying)
        {
                // Disconnect the adapter from this tab.
                disconnect(pIrcAdapter, 0, 0, 0);
                pIrcAdapter = NULL;

                emit chatWindowCloseRequest(this);
        }
}

void IRCDockTabContents::alertIfConfigured()
{
        if (gIRCConfig.appearance.windowAlertOnImportantChatEvent)
        {
                QApplication::alert(gApp->mainWindowAsQWidget());
        }
}

void IRCDockTabContents::applyAppearanceSettings()
{
        const static QString STYLE_SHEET_BASE_TEMPLATE =
                "QListView, QTextEdit, QLineEdit { background: %1; color: %2; } ";

        const IRCConfig::AppearanceCfg& appearance = gIRCConfig.appearance;

        QString qtStyleSheet = STYLE_SHEET_BASE_TEMPLATE
                .arg(appearance.backgroundColor)
                .arg(appearance.defaultTextColor);

        QColor colorSelectedText(appearance.userListSelectedTextColor);
        QColor colorSelectedBackground(appearance.userListSelectedBackgroundColor);
        qtStyleSheet += QString("QListView::item:selected { color: %1; background: %2; } ").arg(colorSelectedText.name(), colorSelectedBackground.name());

        QColor colorHoverText = colorSelectedText.lighter();
        QColor colorHoverBackground = colorSelectedBackground.lighter();
        qtStyleSheet += QString("QListView::item:hover  { color: %1; background: %2; } ").arg(colorHoverText.name(), colorHoverBackground.name());

        QString channelActionClassName = IRCMessageClass::toStyleSheetClassName(IRCMessageClass::ChannelAction);
        QString ctcpClassName = IRCMessageClass::toStyleSheetClassName(IRCMessageClass::Ctcp);
        QString errorClassName = IRCMessageClass::toStyleSheetClassName(IRCMessageClass::Error);
        QString networkActionClassName = IRCMessageClass::toStyleSheetClassName(IRCMessageClass::NetworkAction);

        QString htmlStyleSheetMessageArea = "";
        htmlStyleSheetMessageArea += "span { white-space: pre; }";
        htmlStyleSheetMessageArea += QString("a { color: %1; white-space: pre; } ").arg(appearance.urlColor);
        htmlStyleSheetMessageArea += QString("." + channelActionClassName + " { color: %1; } ").arg(appearance.channelActionColor);
        htmlStyleSheetMessageArea += QString("." + ctcpClassName + " { color: %1; } ").arg(appearance.ctcpColor);
        htmlStyleSheetMessageArea += QString("." + errorClassName + " { color: %1; } ").arg(appearance.errorColor);
        htmlStyleSheetMessageArea += QString("." + networkActionClassName + " { color: %1; } ").arg(appearance.networkActionColor);

        d->lvUserList->setStyleSheet(qtStyleSheet);
        d->lvUserList->setFont(appearance.userListFont);

        d->leCommandLine->installEventFilter(this);
        d->leCommandLine->setStyleSheet(qtStyleSheet);
        d->leCommandLine->setFont(appearance.mainFont);

        d->txtOutputWidget->setStyleSheet(qtStyleSheet);
        d->txtOutputWidget->setFont(appearance.mainFont);

        d->txtOutputWidget->document()->setDefaultStyleSheet(htmlStyleSheetMessageArea);
        d->txtOutputWidget->clear();
        d->txtOutputWidget->insertHtml(d->textOutputContents.join(""));
        d->txtOutputWidget->moveCursor(QTextCursor::End);
}

void IRCDockTabContents::blinkTimerSlot()
{
        setBlinkTitle(!d->bBlinkTitle);
}

void IRCDockTabContents::completeNickname()
{
        IRCCompletionResult result;
        if (d->nicknameCompleter->isReset())
        {
                result = d->nicknameCompleter->complete(d->leCommandLine->text(), d->leCommandLine->cursorPosition());
        }
        else
        {
                result = d->nicknameCompleter->cycleNext();
        }
        if (result.isValid())
        {
                // Prevent reset due to cursor position change.
                d->leCommandLine->blockSignals(true);
                d->leCommandLine->setText(result.textLine);
                d->leCommandLine->setCursorPosition(result.cursorPos);
                d->leCommandLine->blockSignals(false);
        }
}

bool IRCDockTabContents::eventFilter(QObject *watched, QEvent *event)
{
        if (watched == d->leCommandLine && event->type() == QEvent::KeyPress)
        {
                QKeyEvent *keyEvent = static_cast<QKeyEvent*>(event);
                if (keyEvent->key() == Qt::Key_Tab)
                {
                        completeNickname();
                        return true;
                }
        }
        return false;
}

QStandardItem* IRCDockTabContents::findUserListItem(const QString& nickname)
{
        QStandardItemModel* pModel = (QStandardItemModel*)d->lvUserList->model();
        IRCUserInfo userInfo(nickname, network());

        for (int i = 0; i < pModel->rowCount(); ++i)
        {
                QStandardItem* pItem = pModel->item(i);
                if (userInfo == IRCUserInfo(pItem->text(), network()))
                {
                        return pItem;
                }
        }

        return NULL;
}

IRCDockTabContents::UserListMenu& IRCDockTabContents::getUserListContextMenu()
{
        if (d->userListContextMenu == NULL)
        {
                d->userListContextMenu = new UserListMenu();
        }

        return *d->userListContextMenu;
}

void IRCDockTabContents::grabFocus()
{
        // Make sure the tab title is not "d->blinkTimered out" anymore.
        d->blinkTimer.stop();
        setBlinkTitle(false);

        d->leCommandLine->setFocus();
}

bool IRCDockTabContents::hasTabFocus() const
{
        return this->pParentIRCDock->hasTabFocus(this);
}

QIcon IRCDockTabContents::icon() const
{
        if (pIrcAdapter == NULL)
        {
                return QIcon();
        }

        switch (pIrcAdapter->adapterType())
        {
                case IRCAdapterBase::ChannelAdapter:
                        return QIcon(":/icons/irc_channel.png");

                case IRCAdapterBase::NetworkAdapter:
                        return QIcon(":/flags/lan-small");

                case IRCAdapterBase::PrivAdapter:
                        return QIcon(":/icons/person.png");

                default:
                        return QIcon();
        }
}

void IRCDockTabContents::insertMessage(const IRCMessageClass& messageClass, const QString& htmlString)
{
        if (d->lastMessageClass == NULL)
        {
                d->lastMessageClass = new IRCMessageClass();
        }
        *d->lastMessageClass = messageClass;

        d->textOutputContents << htmlString;

        // Text insertion must be done this way to allow proper
        // handling of "Pause" button. Note that the cursor
        // in the widget is not affected as textCursor() creates a copy
        // of cursor object.
        QTextCursor cursor = d->txtOutputWidget->textCursor();
        cursor.movePosition(QTextCursor::End);
        cursor.insertHtml(htmlString);

        if (!d->btnPauseTextArea->isChecked())
        {
                d->txtOutputWidget->moveCursor(QTextCursor::End);
        }

        emit newMessagePrinted();
}

void IRCDockTabContents::markDate()
{
        QDateTime previousMessageDate = d->lastMessageDate;
        QDateTime nowDate = QDateTime::currentDateTime();
        d->lastMessageDate = nowDate;
        if (previousMessageDate.daysTo(nowDate) != 0)
        {
                receiveMessageWithClass(tr("<<<DATE>>> Date on this computer changes to %1").arg(
                        nowDate.toString()), IRCMessageClass::NetworkAction);
        }
}

void IRCDockTabContents::myNicknameUsedSlot()
{
        alertIfConfigured();
        pParentIRCDock->sounds().playIfAvailable(IRCSounds::NicknameUsed);
        if (!hasTabFocus())
        {
                d->blinkTimer.start(BLINK_TIMER_DELAY_MS);
        }
}

void IRCDockTabContents::nameAdded(const IRCUserInfo& userInfo)
{
        QStandardItemModel* pModel = (QStandardItemModel*)d->lvUserList->model();
        QStandardItem* pItem = new QStandardItem(userInfo.prefixedName());
        pItem->setData(userInfo.cleanNickname(), IRCUserListModel::RoleCleanNickname);

        // Try to append the nickname at the proper place in the list.
        for (int i = 0; i < pModel->rowCount(); ++i)
        {
                QStandardItem* pExistingItem = pModel->item(i);
                QString existingNickname = pExistingItem->text();

                if (userInfo <= IRCUserInfo(existingNickname, network()))
                {
                        pModel->insertRow(i, pItem);
                        return;
                }
        }

        // If above code didn't return then
        // this nickname should be appended to the end of the list.
        pModel->appendRow(pItem);
}

void IRCDockTabContents::nameListUpdated(const IRCUserList& userList)
{
        setupNewUserListModel();

        for (unsigned i = 0; i < userList.size(); ++i)
        {
                nameAdded(*userList[i]);
        }
}

void IRCDockTabContents::nameRemoved(const IRCUserInfo& userInfo)
{
        QStandardItemModel* pModel = (QStandardItemModel*)d->lvUserList->model();
        for (int i = 0; i < pModel->rowCount(); ++i)
        {
                QStandardItem* pItem = pModel->item(i);
                if (userInfo.isSameNickname(pItem->text()))
                {
                        pModel->removeRow(i);
                        break;
                }
        }
}

void IRCDockTabContents::nameUpdated(const IRCUserInfo& userInfo)
{
        nameRemoved(userInfo);
        nameAdded(userInfo);
}

IRCNetworkAdapter* IRCDockTabContents::network()
{
        return ircAdapter()->network();
}

const IRCNetworkEntity &IRCDockTabContents::networkEntity() const
{
        return ircAdapter()->networkEntity();
}

void IRCDockTabContents::newChatWindowIsOpened(IRCChatAdapter* pAdapter)
{
        // Once a new chat adapter is opened we need to add it to the master
        // dock widget.
        pParentIRCDock->addIRCAdapter(pAdapter);
}

void IRCDockTabContents::onFocusChanged(QWidget *old, QWidget *now)
{
        if (old == d->lvUserList && now != d->userListContextMenu)
        {
                d->lvUserList->clearSelection();
        }
}

bool IRCDockTabContents::openLog()
{
        rotateOldLog();
        ChatLogs logs;
        if (!logs.mkLogDir(networkEntity()))
        {
                receiveMessageWithClass(tr("Failed to create chat log directory:\n'%1'").arg(
                        logs.networkDirPath(networkEntity())), IRCMessageClass::Error);
                return false;
        }
        d->log.setFileName(ChatLogs().logFilePath(networkEntity(), recipient()));
        d->log.open(QIODevice::WriteOnly | QIODevice::Append | QIODevice::Text);
        d->log.write(tr("<<<DATE>>> Chat log started on %1\n\n").arg(QDateTime::currentDateTime().toString()).toUtf8());
        return true;
}

void IRCDockTabContents::rotateOldLog()
{
        assert(!d->log.isOpen());
        ChatLogsCfg cfg;

        ChatLogRotate logRotate;
        logRotate.setRemovalAgeDaysThreshold(
                cfg.isRestoreChatFromLogs() ? cfg.oldLogsRemovalDaysThreshold() : -1);
        logRotate.rotate(networkEntity(), recipient());
}

void IRCDockTabContents::printToSendersNetworksCurrentChatBox(const QString &text, const IRCMessageClass &msgClass)
{
        IRCAdapterBase *adapter = static_cast<IRCAdapterBase*>(sender());
        IRCDockTabContents *tab = pParentIRCDock->tabWithFocus();
        if (tab != NULL && tab->ircAdapter()->network()->isAdapterRelated(adapter))
        {
                tab->ircAdapter()->emitMessageWithClass(text, msgClass);
        }
        else
        {
                adapter->emitMessageWithClass(text, msgClass);
        }
}

void IRCDockTabContents::receiveError(const QString& error)
{
        receiveMessageWithClass(tr("Error: %1").arg(error), IRCMessageClass::Error);
}

void IRCDockTabContents::receiveMessage(const QString& message)
{
        receiveMessageWithClass(message, IRCMessageClass::Normal);
}

void IRCDockTabContents::receiveMessageWithClass(const QString& message, const IRCMessageClass& messageClass)
{
        markDate();

        QString messageHtmlEscaped = message;

        if (gIRCConfig.appearance.timestamps)
        {
                QString timestamp = Strings::timestamp("[hh:mm:ss] ") ;

                messageHtmlEscaped = timestamp + messageHtmlEscaped;

                // It is also required to replace all '\n' characters with timestamp
                // markers to ensure that timestamp is in every line of text.
                messageHtmlEscaped = messageHtmlEscaped.replace("\n", "\n" + timestamp);
        }

        // As the new-line character is stripped by the lower levels we should
        // assume that each message ends with a new-line char, as specified
        // by RFC 1459.
        messageHtmlEscaped += "\n";

        writeLog(messageHtmlEscaped);

        messageHtmlEscaped = wrapTextWithMetaTags(messageHtmlEscaped, messageClass);

        // Play sound if this is Priv adapter.
        if (pIrcAdapter->adapterType() == IRCAdapterBase::PrivAdapter)
        {
                alertIfConfigured();
                pParentIRCDock->sounds().playIfAvailable(IRCSounds::PrivateMessageReceived);

                // If this tab doesn't have focus, also start d->blinkTimering the title.
                if (!hasTabFocus())
                {
                        d->blinkTimer.start(BLINK_TIMER_DELAY_MS);
                }
        }

        this->insertMessage(messageClass, messageHtmlEscaped);
}

QString IRCDockTabContents::recipient() const
{
        return pIrcAdapter->recipient();
}

void IRCDockTabContents::resetNicknameCompletion()
{
        d->nicknameCompleter->reset();
}

bool IRCDockTabContents::restoreLog()
{
        ChatLogs logs;
        QFile file(logs.logFilePath(networkEntity(), recipient()));
        if (file.open(QIODevice::ReadOnly | QIODevice::Text))
        {
                QByteArray contents = file.readAll();
                QStringList lines = QString::fromUtf8(contents, contents.size()).split("\n");
                int line = lines.size() - 1000;
                lines = lines.mid((line > 0) ? line : 0);

                insertMessage(IRCMessageClass::Normal,
                        wrapTextWithMetaTags(lines.join("\n"), IRCMessageClass::Normal));

                receiveMessageWithClass(tr("---- All lines above were loaded from log ----"),
                        IRCMessageClass::NetworkAction);
                return true;
        }
        return false;
}

QString IRCDockTabContents::selectedNickname()
{
        QModelIndexList selectedIndexes = d->lvUserList->selectionModel()->selectedRows();
        // There can be only one.
        if (!selectedIndexes.isEmpty())
        {
                int row = selectedIndexes[0].row();
                QStandardItemModel* pModel = (QStandardItemModel*)d->lvUserList->model();
                QStandardItem* pItem = pModel->item(row);

                return pItem->text();
        }

        return "";
}

void IRCDockTabContents::sendCtcpPing(const QString &nickname)
{
        network()->sendCtcp(nickname, QString("PING %1").arg(QDateTime::currentMSecsSinceEpoch()));
}

void IRCDockTabContents::sendCtcpTime(const QString &nickname)
{
        network()->sendCtcp(nickname, QString("TIME"));
}

void IRCDockTabContents::sendCtcpVersion(const QString &nickname)
{
        network()->sendCtcp(nickname, QString("VERSION"));
}

void IRCDockTabContents::sendMessage()
{
        QString message = d->leCommandLine->text();
        d->leCommandLine->setText("");

        if (!message.trimmed().isEmpty())
        {
                pIrcAdapter->sendMessage(message);
        }
}

void IRCDockTabContents::sendWhois(const QString &nickname)
{
        network()->sendMessage(QString("/WHOIS %1").arg(nickname));
}

void IRCDockTabContents::setBlinkTitle(bool b)
{
        bool bEmit = false;
        if (d->bBlinkTitle != b)
        {
                // Delay signal emit until after we change the variable.
                bEmit = true;
        }

        d->bBlinkTitle = b;

        if (bEmit)
        {
                emit titleBlinkRequested();
        }
}

void IRCDockTabContents::setIRCAdapter(IRCAdapterBase* pAdapter)
{
        assert(pIrcAdapter == NULL);
        pIrcAdapter = pAdapter;

        ChatLogsCfg cfg;
        if (cfg.isRestoreChatFromLogs())
        {
                restoreLog();
        }
        if (cfg.isStoreLogs())
        {
                openLog();
        }

        connect(pIrcAdapter, SIGNAL( error(const QString&) ), SLOT( receiveError(const QString& ) ));
        connect(pIrcAdapter, SIGNAL( focusRequest() ), SLOT( adapterFocusRequest() ));
        connect(pIrcAdapter, SIGNAL( message(const QString&) ), SLOT( receiveMessage(const QString& ) ));
        connect(pIrcAdapter, SIGNAL( messageWithClass(const QString&, const IRCMessageClass&) ), SLOT( receiveMessageWithClass(const QString&, const IRCMessageClass&) ));
        connect(pIrcAdapter, SIGNAL( terminating() ), SLOT( adapterTerminating() ) );
        connect(pIrcAdapter, SIGNAL( titleChange() ), SLOT( adapterTitleChange() ) );
        connect(pIrcAdapter, SIGNAL( messageToNetworksCurrentChatBox(QString, IRCMessageClass) ),
                SLOT( printToSendersNetworksCurrentChatBox(QString, IRCMessageClass) ) );

        switch (pIrcAdapter->adapterType())
        {
                case IRCAdapterBase::NetworkAdapter:
                {
                        IRCNetworkAdapter* pNetworkAdapter = (IRCNetworkAdapter*)pAdapter;
                        connect(pNetworkAdapter, SIGNAL( newChatWindowIsOpened(IRCChatAdapter*) ), SLOT( newChatWindowIsOpened(IRCChatAdapter*) ) );
                        break;
                }

                case IRCAdapterBase::ChannelAdapter:
                {
                        IRCChannelAdapter* pChannelAdapter = (IRCChannelAdapter*)pAdapter;
                        connect(pChannelAdapter, SIGNAL( myNicknameUsed() ), SLOT( myNicknameUsedSlot() ) );
                        connect(pChannelAdapter, SIGNAL( nameAdded(const IRCUserInfo&) ), SLOT( nameAdded(const IRCUserInfo&) ) );
                        connect(pChannelAdapter, SIGNAL( nameListUpdated(const IRCUserList&) ), SLOT( nameListUpdated(const IRCUserList&) ) );
                        connect(pChannelAdapter, SIGNAL( nameRemoved(const IRCUserInfo&) ), SLOT( nameRemoved(const IRCUserInfo&) ) );
                        connect(pChannelAdapter, SIGNAL( nameUpdated(const IRCUserInfo&) ), SLOT( nameUpdated(const IRCUserInfo&) ) );

                        d->lvUserList->setVisible(true);
                        connect(d->lvUserList, SIGNAL( customContextMenuRequested(const QPoint&) ),
                                SLOT( userListCustomContextMenuRequested(const QPoint&) ) );

                        connect(d->lvUserList, SIGNAL( doubleClicked(const QModelIndex&) ),
                                SLOT( userListDoubleClicked(const QModelIndex&) ) );

                        d->lvUserList->setContextMenuPolicy(Qt::CustomContextMenu);

                        break;
                }

                case IRCAdapterBase::PrivAdapter:
                {
                        break;
                }

                default:
                {
                        receiveError("Doomseeker error: Unknown IRCAdapterBase*");
                        break;
                }
        }
}

void IRCDockTabContents::setupNewUserListModel()
{
        d->lvUserList->setModel(new QStandardItemModel(d->lvUserList));
        d->nicknameCompleter->setModel(d->lvUserList->model());
}

void IRCDockTabContents::showChatContextMenu(const QPoint &pos)
{
        QMenu *menu = d->txtOutputWidget->createStandardContextMenu(pos);
        if (ircAdapter()->adapterType() == IRCAdapterBase::PrivAdapter)
        {
                menu->addSeparator();
                appendPrivChatContextMenuOptions(menu);
        }
        menu->addSeparator();
        appendGeneralChatContextMenuOptions(menu);
        menu->exec(d->txtOutputWidget->mapToGlobal(pos));
        delete menu;
}

void IRCDockTabContents::appendGeneralChatContextMenuOptions(QMenu *menu)
{
        QAction *manageIgnores = menu->addAction(tr("Manage ignores"));
        this->connect(manageIgnores, SIGNAL(triggered()), SLOT(showIgnoresManager()));
}

void IRCDockTabContents::appendPrivChatContextMenuOptions(QMenu *menu)
{
        appendPrivChatContextMenuAction(menu, tr("Whois"), PrivWhois);
        appendPrivChatContextMenuAction(menu, tr("CTCP Ping"), PrivCtcpPing);
        appendPrivChatContextMenuAction(menu, tr("CTCP Time"), PrivCtcpTime);
        appendPrivChatContextMenuAction(menu, tr("CTCP Version"), PrivCtcpVersion);
        appendPrivChatContextMenuAction(menu, tr("Ignore"), PrivIgnore);
}

void IRCDockTabContents::appendPrivChatContextMenuAction(QMenu *menu,
        const QString &text, PrivChatMenu type)
{
        QAction *action = menu->addAction(text);
        action->setData(type);
        this->connect(action, SIGNAL(triggered()), SLOT(onPrivChatActionTriggered()));
}

void IRCDockTabContents::onPrivChatActionTriggered()
{
        QString nickname = ircAdapter()->recipient();
        QString cleanNickname = IRCUserInfo(nickname, network()).cleanNickname();
        QAction *action = static_cast<QAction*>(sender());
        switch (action->data().toInt())
        {
        case PrivWhois:
                sendWhois(cleanNickname);
                break;
        case PrivCtcpPing:
                sendCtcpPing(cleanNickname);
                break;
        case PrivCtcpTime:
                sendCtcpTime(cleanNickname);
                break;
        case PrivCtcpVersion:
                sendCtcpVersion(cleanNickname);
                break;
        case PrivIgnore:
                startIgnoreOperation(cleanNickname);
                break;
        default:
                assert(0 && "Unsupported priv chat action");
                qDebug() << "Unsupported priv chat action: " << action->data();
                break;
        }
}

void IRCDockTabContents::showIgnoresManager()
{
        IRCIgnoresManager *dialog = new IRCIgnoresManager(this, networkEntity().description());
        connect(dialog, SIGNAL(accepted()), network(), SLOT(reloadNetworkEntityFromConfig()));
        dialog->setAttribute(Qt::WA_DeleteOnClose);
        dialog->show();
}

void IRCDockTabContents::startIgnoreOperation(const QString &nickname)
{
        IRCDelayedOperationIgnore *op = new IRCDelayedOperationIgnore(this, network(), nickname);
        op->setShowPatternPopup(true);
        op->start();
}

QString IRCDockTabContents::title() const
{
        return pIrcAdapter->title();
}

QString IRCDockTabContents::titleColor() const
{
        if (d->lastMessageClass != NULL && !this->hasTabFocus())
        {
                QString color;

                if (*d->lastMessageClass == IRCMessageClass::Normal)
                {
                        color = "#ff0000";
                }
                else
                {
                        color = d->lastMessageClass->colorFromConfig();
                }

                if (d->bBlinkTitle)
                {
                        QColor c(color);

                        int rInverted = 0xff - c.red();
                        int gInverted = 0xff - c.green();
                        int bInverted = 0xff - c.blue();

                        QColor inverted(rInverted, gInverted, bInverted);

                        return inverted.name();
                }
                else
                {
                        return color;
                }
        }

        return "";
}

void IRCDockTabContents::userListCustomContextMenuRequested(const QPoint& pos)
{
        if (this->pIrcAdapter->adapterType() != IRCAdapterBase::ChannelAdapter)
        {
                // Prevent illegal calls.
                return;
        }

        QString nickname = this->selectedNickname();
        if (nickname.isEmpty())
        {
                // Prevent calls if there is no one selected.
                return;
        }
        QString cleanNickname = IRCUserInfo(nickname, network()).cleanNickname();

        IRCChannelAdapter* pAdapter = (IRCChannelAdapter*) this->pIrcAdapter;
        const QString& channel = pAdapter->recipient();

        UserListMenu& menu = this->getUserListContextMenu();
        QPoint posGlobal = d->lvUserList->mapToGlobal(pos);

        QAction* pAction = menu.exec(posGlobal);

        if (pAction == NULL)
        {
                return;
        }

        if (pAction == menu.ban)
        {
                bool bOk = false;

                QString reason = CommonGUI::askString(tr("Ban user"), tr("Input reason for banning user %1 from channel %2").arg(nickname, channel), &bOk);
                if (bOk)
                {
                        pAdapter->banUser(cleanNickname, reason);
                }
        }
        else if (pAction == menu.ctcpTime)
        {
                sendCtcpTime(cleanNickname);
        }
        else if (pAction == menu.ctcpPing)
        {
                sendCtcpPing(cleanNickname);
        }
        else if (pAction == menu.ctcpVersion)
        {
                sendCtcpVersion(cleanNickname);
        }
        else if (pAction == menu.deop)
        {
                pAdapter->setOp(cleanNickname, false);
        }
        else if (pAction == menu.dehalfOp)
        {
                pAdapter->setHalfOp(cleanNickname, false);
        }
        else if (pAction == menu.devoice)
        {
                pAdapter->setVoiced(cleanNickname, false);
        }
        else if (pAction == menu.halfOp)
        {
                pAdapter->setHalfOp(cleanNickname, true);
        }
        else if (pAction == menu.ignore)
        {
                startIgnoreOperation(cleanNickname);
        }
        else if (pAction == menu.kick)
        {
                bool bOk = false;

                QString reason = CommonGUI::askString(tr("Kick user"), tr("Input reason for kicking user %1 from channel %2").arg(nickname, channel), &bOk);
                if (bOk)
                {
                        pAdapter->kickUser(cleanNickname, reason);
                }
        }
        else if (pAction == menu.op)
        {
                pAdapter->setOp(cleanNickname, true);
        }
        else if (pAction == menu.openChatWindow)
        {
                pAdapter->network()->openNewAdapter(cleanNickname);
        }
        else if (pAction == menu.voice)
        {
                pAdapter->setVoiced(cleanNickname, true);
        }
        else if (pAction == menu.whois)
        {
                sendWhois(cleanNickname);
        }
}

void IRCDockTabContents::userListDoubleClicked(const QModelIndex& index)
{
        if (this->pIrcAdapter->adapterType() != IRCAdapterBase::ChannelAdapter)
        {
                // Prevent illegal calls.
                return;
        }

        QString nickname = this->selectedNickname();
        if (nickname.isEmpty())
        {
                // Prevent calls if there is no one selected.
                return;
        }
        QString cleanNickname = IRCUserInfo(nickname, network()).cleanNickname();

        this->pIrcAdapter->network()->openNewAdapter(cleanNickname);
}

QString IRCDockTabContents::wrapTextWithMetaTags(const QString &text,
        const IRCMessageClass &messageClass) const
{
        QString result = text;
        result.replace("<", "&lt;").replace(">", "&gt;");
        result = Strings::wrapUrlsWithHtmlATags(result);

        QString className = messageClass.toStyleSheetClassName();
        if (className.isEmpty())
        {
                result = "<span>" + result + "</span>";
        }
        else
        {
                result = ("<span class='" + className + "'>" + result + "</span>");
        }
        return result;
}

bool IRCDockTabContents::writeLog(const QString &text)
{
        ChatLogsCfg cfg;
        if (d->log.isOpen() && cfg.isStoreLogs())
        {
                d->log.write(text.toUtf8());
                d->log.flush();
                return true;
        }
        return false;
}

IRCDockTabContents::UserListMenu::UserListMenu()
{
        this->openChatWindow = this->addAction(tr("Open chat window"));
        this->addSeparator();
        this->whois = this->addAction(tr("Whois"));
        this->ctcpTime = this->addAction(tr("CTCP Time"));
        this->ctcpPing = this->addAction(tr("CTCP Ping"));
        this->ctcpVersion = this->addAction(tr("CTCP Version"));
        this->addSeparator();
        this->op = this->addAction(tr("Op"));
        this->deop = this->addAction(tr("Deop"));
        this->halfOp = this->addAction(tr("Half op"));
        this->dehalfOp = this->addAction(tr("De half op"));
        this->voice = this->addAction(tr("Voice"));
        this->devoice = this->addAction(tr("Devoice"));
        this->addSeparator();
        this->ignore = this->addAction(tr("Ignore"));
        this->kick = this->addAction(tr("Kick"));
        this->ban = this->addAction(tr("Ban"));

        this->bIsOperator = false;
}