chatcore.cpp

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

  UserProfile* profile = m_profiles[old_name];

  if(profile)
  {
    profile->rename(new_name);
    m_profiles.erase(m_profiles.find(old_name));
    m_profiles.insert(new_name, profile);
  }
}

void ChatCore::slot_deleteProfile(const QString & name)
{
  m_profiles.erase(m_profiles.find(name));

  delete m_currentProfile->info();
  delete m_currentProfile->prefs();
  delete m_currentProfile;

  slot_loadProfile(m_profiles.begin().key());
}

void ChatCore::processSmiles(QString msg) // TODO perepisat'
{
  Smile*        smile;
  QList<Smile*> smiles;
  QString       sm_str;
  QString msg_ = msg;
  int idx_end = 0;
  QString str;

  smile   = 0;
  sm_str  = ChatTextWgt::nextSmile(msg, &smile);
  idx_end = msg.indexOf(sm_str);

  for(; idx_end != -1 && !sm_str.isEmpty();)
  {
    if(smile)
    {
      if(sm_str != smile->smiles[0])
      {
        msg_.replace(sm_str, smile->smiles[0]);
        sm_str = smile->smiles[0];
      }

      if(!smiles.contains(smile))
      {
        smiles.append(smile);
        m_smilesParam.append(sm_str.toUtf8());
        m_smilesParam.append((char)0);
      }
    }

    str = msg.left(idx_end);
    msg = msg.right(msg.size() - idx_end - sm_str.size());

    sm_str   = ChatTextWgt::nextSmile(msg, &smile);
    if(sm_str.isEmpty())
      break;

    idx_end = msg.indexOf(smile->smiles[0]);
  }

  addParametr("Smiles", m_smilesParam);

  QList<Smile*>::const_iterator i;

  for (i = smiles.constBegin(); i != smiles.constEnd(); ++i)
  {
    str = QChatSettings::settings()->smilesThemePath() + (*i)->name;
    if(QFile(str).exists())
      addParametr(QString("Smile") + (*i)->smiles[0], str);
    else if(QFile(str + ".png").exists())
      addParametr(QString("Smile") + (*i)->smiles[0], str + ".png");
    else if(QFile(str + ".gif").exists())
      addParametr(QString("Smile") + (*i)->smiles[0], str + ".gif");
    else if(QFile(str + ".jpg").exists())
      addParametr(QString("Smile") + (*i)->smiles[0], str + ".jpg");
  }
}

void ChatCore::slot_msgsHistoryAnswer(const QString & ch_name_id, quint64 uid, const QByteArray & msgs, AbstractChatCore::ChannelType ch_type)
{
  addParametr("Channel"    , ch_name_id.toUtf8());
  addParametr("MsgsHistory", msgs);

  prepareDatagramWrapper(AbstractChatCore::MSGS_HISTORY_ANSWER, uid, QString(""), ch_type);

  sendData(uid);
}

void ChatCore::slot_msgsNumAnswer(const QString & ch_name_id, quint64 uid, quint32 msgs_num, AbstractChatCore::ChannelType type)
{
  addParametr("Channel", ch_name_id.toUtf8());
  addParametr("MsgsNum", QString().setNum(msgs_num).toUtf8());

  prepareDatagramWrapper(AbstractChatCore::MSGS_NUM_ANSWER, uid, QString(""), type);

  sendData(uid);
}

void ChatCore::slot_sendMessage(const QString & ch_name_id, quint64 uid, AbstractChatCore::ChannelType ch_type, QTextDocument* doc)
{
  QString fname;
  QString smname;
  int sm_num = 0;
  QTextCursor cur(doc);
  QMap<QString, int> smiles;


  m_smilesParam.clear();

  for(QTextBlock it = doc->begin(); it != doc->end(); it = it.next())
  {
    cur = QTextCursor(it);

    QTextBlock::iterator i = cur.block().begin();
    for (; i != cur.block().end(); i++)
    {
      QTextFormat fmt = i.fragment().charFormat();
      if(fmt.isImageFormat())
      {
        fname = fmt.stringProperty(QTextFormat::ImageName);

        if(!smiles.contains(fname))
        {
          smname = QString().setNum(sm_num) + QString(QChar(0xFFFC + 1));

          m_smilesParam.append(smname.toUtf8());
          m_smilesParam.append((char)0);

          smiles.insert(fname, sm_num);

          sm_num++;

          addParametr("Smile" + smname, fname);
        }
        else
          smname = QString().setNum(smiles.value(fname)) + QString(QChar(0xFFFC + 1));

        cur.beginEditBlock();

        cur.clearSelection();
        cur.setPosition(i.fragment().position());
        cur.deleteChar();
        cur.insertText(smname);

        cur.endEditBlock();

        i = cur.block().begin();
      }
    }
  }

  if(protocolVersion() >= 4)
    slot_prepareAndSend(ch_name_id, uid, AbstractChatCore::MESSAGE, doc->toHtml(), ch_type, NULL);
  else
    slot_prepareAndSend(ch_name_id, uid, AbstractChatCore::MESSAGE, doc->toPlainText(), ch_type, NULL);

  doc->deleteLater();
}

void ChatCore::slot_avatarAnswer(const QString & ch_name_id, quint64 uid, AbstractChatCore::ChannelType channel_type)
{
  if(m_myInfo->status(ch_name_id) == Globals::INVISIBLE)
    return;

  QByteArray data;
  QBuffer    buffer;
  const QImage* icon = m_myInfo->newIconImg();

  buffer.setBuffer(&data);

  if(icon)
  {
    icon->save(&buffer, "PNG", 100);
    delete icon;
  }

  addParametr("Channel", ch_name_id.toUtf8());
  addParametr("Icon", data);
  addParametr("IconHash", UserInfo::myInfo()->avatarHash());

  prepareDatagramWrapper(AbstractChatCore::AVATAR_ANSWER,
                  uid,
                  QString(""),
                  channel_type);

  sendData(uid);
}

void ChatCore::sendPluginData(const QString & plugin_id , const QMap<QString, QByteArray> & parametrs,
                              quint64 uid               , AbstractChatCore::DataType data_type,
                              const QString & channel_id, uint ch_type, const QString & msg)
{
  foreach(QString name, parametrs.keys())
    addParametr(name, parametrs[name]);

  addParametr("PluginId", plugin_id.toUtf8());

  slot_prepareAndSend(channel_id, uid, data_type, msg, (AbstractChatCore::ChannelType)ch_type);
}

void ChatCore::prepareDatagramWrapper(AbstractChatCore::DataType dtgrm_type, quint64 dest_uid, const QString & msg, AbstractChatCore::ChannelType chnnl_type, quint64 dtgrm_id, quint64 dtgrm_num)
{
  // FIXME krivovato sdelano..
  //*****
  quint64 src_ip;
  quint64 dest_ip = dest_uid;

  // in serverless mode we using IP addresses but in Server - UIDs
  if(m_mode == Serverless)
    src_ip  = m_settings->hostAddressOption("IP").toIPv4Address();
  else
    src_ip  = m_uid;
  //*****
  prepareDatagram(dtgrm_type,
                  dest_ip,

                  m_myInfo->nickname(),
                  m_myInfo->compName(),
                  src_ip,

                  msg,
                  chnnl_type,
                  dtgrm_id,
                  dtgrm_num);
}

void ChatCore::initMode(Mode mode_, bool first)
{
  m_settings->setMode((QChatSettings::Mode)mode_);
  m_mode = mode_;

  if(!first)
  {
    disconnect(m_receiver , SIGNAL(dataReceived    (char *, quint16)),
                      this, SLOT  (slot_processData(char *, quint16)));

    disconnect(m_receiver , SIGNAL(largeDataReceived    (LargeDatagram*)),
                      this, SLOT  (slot_processLargeData(LargeDatagram*)));

    disconnect(m_receiver , SIGNAL(wantFragments        (char*, quint32, quint32, quint64)),
                      this, SLOT  (slot_requestFragments(char*, quint32, quint32, quint64)));

    disconnect(m_receiver , SIGNAL(     fragmentsRequest(char*, quint32)),
                 m_sender , SLOT  (slot_fragmentsRequest(char*, quint32)));

    disconnect(m_receiver , SIGNAL(     receivingAccepted(quint16)),
                 m_sender , SLOT  (slot_acceptSending    (quint16)));

    disconnect(m_receiver , SIGNAL(openSocketError(quint16)),
                     this , SLOT  (slot_openSocketError(quint16)));

    disconnect(m_receiver , SIGNAL(dtgrmFinished  (quint16)),
               m_sender   , SLOT  (slot_cancelTask(quint16)));

    disconnect(this       , SIGNAL(wantChangeInputPort(quint16)),
               m_receiver , SLOT  (changePort         (quint16)));
  }
  else
  {
    connect(this         , SIGNAL(wantLogin(const QString&, const QHostAddress&, uint, const QString&)),
            m_tcpReceiver, SLOT  (login    (const QString&, const QHostAddress&, uint, const QString&)));
//     connect(m_tcpReceiver, SIGNAL(loginFinished(int, const QString&)),
//             this         , SIGNAL(loginFinished(int, const QString&)));

  }

  switch(mode_)
  {
    case Server :
      changeProtocolVersion(4);
      m_receiver = m_tcpReceiver;
      m_sender->useTcp(m_tcpReceiver->socket());
      break;

    case Serverless :
      m_receiver = m_udpReceiver;
      m_sender->useUdp();
      break;

    default:
      m_receiver = m_udpReceiver;
      m_sender->useUdp();
  }

  createReceiverConnections();

  emit wantChangeInputPort(m_settings->intOption("InputPort"));
}

void ChatCore::createReceiverConnections()
{
  connect(m_receiver , SIGNAL(dataReceived    (char *, quint16)),
                 this, SLOT  (slot_processData(char *, quint16)));

  connect(m_receiver , SIGNAL(largeDataReceived    (LargeDatagram*)),
                 this, SLOT  (slot_processLargeData(LargeDatagram*)));

  connect(m_receiver , SIGNAL(wantFragments        (char*, quint32, quint32, quint64)),
                 this, SLOT  (slot_requestFragments(char*, quint32, quint32, quint64)));

  connect(m_receiver , SIGNAL(     fragmentsRequest(char*, quint32)),
            m_sender , SLOT  (slot_fragmentsRequest(char*, quint32)));

  connect(m_receiver , SIGNAL(     receivingAccepted(quint16)),
            m_sender , SLOT  (slot_acceptSending    (quint16)));

  connect(m_receiver , SIGNAL(openSocketError(quint16)),
                this , SLOT  (slot_openSocketError(quint16)));

  connect(m_receiver , SIGNAL(dtgrmFinished  (quint16)),
          m_sender   , SLOT  (slot_cancelTask(quint16)));

  connect(this       , SIGNAL(wantChangeInputPort(quint16)),
          m_receiver , SLOT  (changePort         (quint16)));

}

void ChatCore::slot_setMode() // Server or Serverless
{

}

void ChatCore::slot_login(const QHostAddress & addr, const QString & nick)
{
  // FIXME !!!
  emit wantLogin(nick, addr, 61100, "");
}

void ChatCore::disconnectFromServer()
{
  m_tcpReceiver->socket()->disconnectFromHost();
  m_loggedIn = false;
}

void ChatCore::changeLogin(const QString & newLogin)
{
  prepareDatagram(AbstractChatCore::CHANGE_LOGIN, 1, newLogin, UserInfo::myInfo()->compName(), UserInfo::myInfo()->uid(), "");

  sendData(1);
}

void ChatCore::initPlugins()
{
  m_pluginManager->getPlugins();

      connect(m_pluginManager,
              SIGNAL(sendData(const QString &, const QMap<QString, QByteArray> &, quint64,
                              AbstractChatCore::DataType, const QString &, uint, const QString &)),
              this,
              SLOT  (sendPluginData(const QString &, const QMap<QString, QByteArray> &, quint64,
                              AbstractChatCore::DataType, const QString &, uint, const QString &)));
}

UserInfo* ChatCore::getUserInfo(quint64 uid)
{
  UserWgt* user;

  foreach(ChannelWgt* cw, m_chatWgt->channels())
    if(cw->name() == "Main")
      if((user = cw->findUser(uid)))
        return user->info();

  return NULL;
}

void ChatCore::changeProtocolVersion(uint ver)
{
  m_settings->setOption("ProtocolVersion", ver);
  setProtocolVersion(ver);
}

bool ChatCore::loggedIn()
{
  return (m_mode == Server && m_loggedIn);
}

void ChatCore::slot_disconnectedFromServer()
{
  m_loggedIn = false;
  emit disconnectedFromServer();
}

#include "chatcore_settings.cpp"