channelwgt.cpp

用qt4 编写的局域网聊天工具

/***************************************************************************
 *   Copyright (C) 2007 by Anistratov Oleg                                 *
 *   [e-mail]                                            *
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License version 2        *
 *   as published by the Free Software Foundation;                         *
 *                                                                         *
 *   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.                          *
 *                                                                         *
 ***************************************************************************/
#include "channelwgt.h"

#include <QList>
#include <QProcess>
#include <QColor>
#include <QCoreApplication>
#include <QIcon>
#include <QScrollBar>
#include <QPainter>
#include <QCryptographicHash>
#include <QBitmap>
#include <QDir>
#include <QShortcut>
#include <QDateTime>

#include <assert.h>

#include "chatwgt.h"
#include "chatcore.h"
#include "msghistory.h"
#include "userslist.h"
#include "userslistwgt.h"
#include "message.h"
#include "statuseditwgt.h"
#include "chattextwgt.h"
#include "inputrichtextwgt.h"
#include "userwgt.h"
#include "userinfo.h"
#include "usersstatisticswgt.h"
#include "usersstatisticsmodel.h"
#include "userstatistics.h"

#include "textformattingwgt.h"
#include "formattingtoolbar.h"

#include "qchaticon.h"

#include "userlisticonconfigurewgt.h"
#include "userlisticonformat.h"

ChannelWgt::ChannelWgt(QString name_, QWidget *parent, AbstractChatCore::ChannelType type, quint64 dest_uid)
 : QWidget(parent),
  m_logFile         (NULL),
  m_type            (type),
  m_destUid         (dest_uid),
  m_name            (name_),
  m_usersNum        (0),
  m_passwordSize    (0),
  m_messageSize     (0),
  m_displayInfoMsgs (true),
  m_soundOnMessageIn(true),
  m_requestsRest    (0)
{
  m_parent = (ChatWgt*)parentWidget();

  QSplitter* lv_split;
  QSplitter* rv_split;
  QSplitter* h_split;

  m_smilesFromSender   = new QList<Smile>;

  m_chatMsgs           = new MsgHistory;
  m_users              = new UsersList;

  m_statusWgt          = new StatusEditWgt(this);
  m_file               = new QFile();
  mw_grid              = new QGridLayout(this);
  mw_chatTextStack     = new QStackedWidget(this);
  mw_usersStack        = new QStackedWidget(this);
  lv_split             = new QSplitter(Qt::Vertical);
  rv_split             = new QSplitter(Qt::Vertical);
  h_split              = new QSplitter(Qt::Horizontal);
  mw_chatText          = new ChatTextWgt(this);
  mw_clearChatText     = new ChatTextWgt(this);
  mw_inputText         = new InputRichTextWgt(this);
  mw_usersList         = new UsersListWgt(this);
  mw_usersStatistics   = new UsersStatisticsWgt(this);
  m_sendBtn            = new QPushButton(this);
  m_refreshUlBtn       = new QPushButton(this);
  m_sysMessagesChbx    = new QCheckBox(this);
  m_refreshTimer       = new QTimer(this);
  m_statusChangedTimer = new QTimer(this);
  m_initTimer          = new QTimer(this);
  m_usersModel         = new UsersStatisticsModel(this);

  m_splitters.append(lv_split);
  m_splitters.append(rv_split);
  m_splitters.append(h_split);

  m_usersModel->setUsers(m_users);
  mw_usersStatistics->setModel(m_usersModel);
  mw_usersStatistics->setSortingEnabled(true);

  mw_clearChatText->setSmilesFromSender(m_smilesFromSender);
  mw_chatText     ->setSmilesFromSender(m_smilesFromSender);

  m_status           = m_statusWgt->status();
  m_oldStatus          = m_statusWgt->status();
  m_statusDescription  = m_statusWgt->description();

  mw_clearChatText->hide();

  mw_chatTextStack->addWidget(mw_chatText);
  mw_chatTextStack->addWidget(mw_clearChatText);

  mw_usersStack->addWidget(mw_usersList);
  mw_usersStack->addWidget(mw_usersStatistics);

  mw_grid->setMargin(1);

  lv_split->addWidget(m_sysMessagesChbx);
  lv_split->addWidget(mw_chatTextStack);
  lv_split->addWidget(mw_inputText);
  lv_split->addWidget(m_sendBtn);

  rv_split->addWidget(m_statusWgt);
  rv_split->addWidget(mw_usersStack);
  rv_split->addWidget(m_refreshUlBtn);

  h_split ->addWidget(lv_split);
  h_split ->addWidget(rv_split);

  resize(800, 370);

  QList<int> tmplst;
  tmplst.append(590);
  tmplst.append(210);

  h_split ->setSizes(tmplst);

  tmplst.clear();
  tmplst.append(25);
  tmplst.append(300);
  tmplst.append(70);
  tmplst.append(25);

  lv_split->setSizes(tmplst);

  tmplst.clear();
  tmplst.append(25);
  tmplst.append(370);
  tmplst.append(25);

  rv_split->setSizes(tmplst);

  mw_grid->addWidget(h_split    , 0, 0);

  m_refreshUlBtn   ->setMaximumHeight(25);
  m_sendBtn        ->setMaximumHeight(25);
  m_sysMessagesChbx->setMaximumHeight(24);
  mw_inputText     ->setMinimumHeight(30);

  connect(m_statusChangedTimer, SIGNAL(timeout()), this        , SLOT(slot_statusChanged()));
  connect(m_refreshTimer      , SIGNAL(timeout()), this        , SLOT(slot_statusRequest()));
  connect(m_sendBtn           , SIGNAL(clicked()), mw_inputText, SLOT(sendMsg()));
  connect(m_sendBtn           , SIGNAL(clicked()), mw_inputText, SLOT(setFocus()));
  connect(m_refreshUlBtn      , SIGNAL(clicked()), this        , SLOT(slot_refreshUL()));
  connect(m_sysMessagesChbx   , SIGNAL(clicked()), this        , SLOT(slot_chbxInfChgd()));
  connect(mw_inputText        , SIGNAL(wantSend()), this, SLOT(slot_msgOut   ()));

  connect(mw_usersList        , SIGNAL(itemDoubleClicked(UserWgt*)),
          m_parent            , SLOT  (slot_showUserInfo(UserWgt*)));

  connect(mw_usersList        , SIGNAL(itemDoubleClicked(UserWgt*)),
          this                , SLOT  (slot_infoRequest (UserWgt*)));

  connect(m_statusWgt         , SIGNAL(statusChanged()),
          this                , SLOT  (slot_startStatusChangedTimer()));

  connect(m_statusWgt         , SIGNAL(editing()),  m_statusChangedTimer, SLOT(stop()));

  connect(h_split, SIGNAL(splitterMoved(int, int)),this, SLOT(slot_controlSplitter(int, int)));

  connect((QObject*)mw_usersStatistics->horizontalHeader(), SIGNAL(sectionClicked(int)),
          mw_usersStatistics                    , SLOT(sortByColumn(int)));

  connect(mw_usersStatistics, SIGNAL(sorted()),
          this              , SLOT  (updateUsersView()));

  if(m_parent)
  {
    connect(mw_usersList  , SIGNAL(singleMessage   (const QString &, quint64, bool)),
            m_parent      , SIGNAL(singleMessage   (const QString &, quint64, bool)));
    connect(mw_usersList  , SIGNAL(wantPrivateChat (const QString &, quint64)),
            m_parent      , SLOT  (slot_privateChat(const QString &, quint64)));
    connect(mw_usersList  , SIGNAL(wantSendFile    (quint64)),
            m_parent      , SLOT  (slot_sendFile   (quint64)));
  }

  FormattingToolBar* obj = m_parent->formattingToolBar();

  connect(obj, SIGNAL(wantSetBold     (bool)), mw_inputText, SLOT(setBold(bool)));
  connect(obj, SIGNAL(wantSetItalic   (bool)), mw_inputText, SLOT(setItalic(bool)));
  connect(obj, SIGNAL(wantSetUnderline(bool)), mw_inputText, SLOT(setUnderline(bool)));

  connect(obj, SIGNAL(wantSetColor     (const QColor&)) , mw_inputText, SLOT(setColor(const QColor&)));
  connect(obj, SIGNAL(wantSetFontFamily(const QString&)), mw_inputText, SLOT(setFontFamily(const QString&)));
  connect(obj, SIGNAL(wantSetFontSize  (const QString&)), mw_inputText, SLOT(setFontSize(const QString&)));
  connect(obj, SIGNAL(wantSetTextStyle (int))           , mw_inputText, SLOT(setTextStyle(int)));
  connect(obj, SIGNAL(wantCreateTable  (uint, uint))    , mw_inputText, SLOT(createTable(uint, uint)));

  connect(mw_inputText, SIGNAL(currentCharFormatChanged(const QTextCharFormat&)),
          obj         , SLOT  (currentCharFormatChanged(const QTextCharFormat&)));

  mw_clearChatText->text()->verticalScrollBar()->setValue(mw_clearChatText->text()->verticalScrollBar()->maximum());
  mw_chatText     ->text()->verticalScrollBar()->setValue(mw_chatText     ->text()->verticalScrollBar()->maximum());

  m_refreshTimer->start(QChatSettings::settings()->usersListRefreshInterval() * 1000);

  if(!QChatSettings::loggingDir().isEmpty())
  {
    QString filename = QChatSettings::loggingDir() + "/" + m_name + "_" + QDateTime::currentDateTime().toString("hh:mm:ss_dd.MM.yy") + ".log";

    m_logFile = new QFile(filename);

    if(!m_logFile->open(QIODevice::WriteOnly | QIODevice::Unbuffered))
    {
      qWarning("[ChannelWgt::ChannelWgt]: Couldn't open log file(%s) for writing. Disabling logging for channel %s", filename.toLocal8Bit().data(), m_name.toLocal8Bit().data());

      delete m_logFile;

      m_logFile = NULL;
    }
  }

  retranslate();
}
//\*****************************************************************************
ChannelWgt::~ChannelWgt()
{
  qDebug("[~ChannelWgt '%s']", m_name.toLocal8Bit().data());
  emit wantSaveState(m_name, saveState());
  slot_disconnected();

  delete m_logFile;
}
//\*****************************************************************************
UserWgt* ChannelWgt::findUser(quint64 uid) const
{
  return m_users->findUser(uid);
}
//\*****************************************************************************
void ChannelWgt::setFocus2InputText()
{
  mw_inputText->setFocus();
}
//\*****************************************************************************
void ChannelWgt::processData(QC_DatagramHeader* Hdr)
{
  qDebug("[ChannelWgt::processData]");

  switch(Hdr->type)
  {
    case AbstractChatCore::MESSAGE        :
      qDebug("[ChannelWgt::processData]: Message");
      emit wantActivate();
      getSmilesFromData(Hdr);
      addMsg(Hdr);
      break;

    case AbstractChatCore::STATUS_REQUEST :
      qDebug("[ChannelWgt::processData]: StatusRequest");
      sendStatusAnswer(Hdr->src_ip, 0, Hdr->programVersion < 14);
      break;

    case AbstractChatCore::STATUS_ANSWER  :
      qDebug("[ChannelWgt::processData]: StatusAnswer");
      addUser(Hdr);
      break;

    case AbstractChatCore::CONNECTED  :
      qDebug("[ChannelWgt::processData]: Connected");
      addUser(Hdr);
      addInfoMsg(Hdr);
      break;

    case AbstractChatCore::DISCONNECTED  :
      qDebug("[ChannelWgt::processData]: Disconnected");
      addInfoMsg(Hdr);
      hideUser(Hdr);
      break;

    case AbstractChatCore::INF_STATUS_CHNGD :
      qDebug("[ChannelWgt::processData]: StatusChanged");
      addUser(Hdr);
      addInfoMsg(Hdr);
      break;

    case AbstractChatCore::INFO_REQUEST  :
      qDebug("[ChannelWgt::processData]: UserInfoRequest");
      sendInfoAnswer(Hdr);
      break;

    case AbstractChatCore::INFO_ANSWER  :
      qDebug("[ChannelWgt::processData]: UserInfoAnswer");
      addUserInfo(Hdr);
      addUser(Hdr);
      break;

    case AbstractChatCore::MSGS_HISTORY_REQUEST :
      qDebug("[ChannelWgt::processData]: Msgs Request");
      qDebug("[ChannelWgt::processData]: par.size = %d", ChatCore::getParametr("MaxMsgsHistorySize", Hdr->parametrs).size());

      emit sendMsgsHistory(m_name, Hdr->src_ip, m_chatMsgs->toByteArray(ChatCore::getParametr("MaxMsgsHistorySize", Hdr->parametrs).toLongLong()), m_type);
      break;

    case AbstractChatCore::MSGS_HISTORY_ANSWER :
    {
      qDebug("[ChannelWgt::processData]: Msgs Answer");

      int diff_time = time(NULL) - Hdr->tm;
      m_chatMsgs->fromByteArray(ChatCore::getParametr("MsgsHistory", Hdr->parametrs));

      for(uint i = 0; i < m_chatMsgs->size(); i++)
      {
        m_chatMsgs->msg(i)->setReceiveTime(m_chatMsgs->msg(i)->receiveTime() + diff_time);
        m_chatMsgs->msg(i)->setIsHtml(Hdr->protocolVersion >= 4);
      }

      rebuildChatText();
      break;
    }
    case AbstractChatCore::MSGS_NUM_REQUEST :
      qDebug("[ChannelWgt::processData]: Msgs Num Request");
      emit sendMsgsNum(m_name, Hdr->src_ip, m_chatMsgs->size(), m_type);
      break;

    case AbstractChatCore::MSGS_NUM_ANSWER :
      qDebug("[ChannelWgt::processData]: Msgs Num Answer");
      msgsNumAnswer(Hdr);
      break;

    case AbstractChatCore::AVATAR_REQUEST :
    {
      qDebug("[ChannelWgt::processData]: Avatar Request");
      QByteArray ba = ChatCore::getParametr("IconHash", Hdr->parametrs);

      if(ba.isEmpty() || UserInfo::myInfo()->avatarHash() != ba)
        emit avatarAnswer(m_name, Hdr->src_ip, m_type);
      break;
    }

    case AbstractChatCore::AVATAR_ANSWER :
      qDebug("[ChannelWgt::processData]: Avatar Answer");
      addAvatar(Hdr);
      break;
  }
}
//\*****************************************************************************
void ChannelWgt::slot_msgOut()
{
  if(!mw_inputText->toPlainText().isEmpty())
  {
    if(m_type == 1)
    {
      emit sendMessage(m_name, m_destUid, m_type, mw_inputText->document()->clone());
      emit sendMessage(m_name, Globals::localhost(), m_type, mw_inputText->document()->clone());
    }
    else
      emit sendMessage(m_name, QChatSettings::settings()->broadcast().toIPv4Address(), m_type, mw_inputText->document()->clone());

    mw_inputText->clear();
  }
}
//\*****************************************************************************
void ChannelWgt::addInfoMsg(QC_DatagramHeader* Hdr)
{
  Message* msg = new Message(Hdr);

  logMessage(Hdr);

  m_chatMsgs->addMsg(msg);
  mw_chatText->addMsg(msg);
}
//\*****************************************************************************
void ChannelWgt::addMsg(QC_DatagramHeader* Hdr)
{
  if(QChatSettings::settings()->boolOption("IsExecuteCommandOnIncomingMessage") && !QChatSettings::settings()->executeCommandOnIncomingMsg().isEmpty())
  {
    QProcess pr;
    pr.startDetached(QChatSettings::settings()->executeCommandOnIncomingMsg());
  }