channelwgt.cpp

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

{
  qDebug("\n[ChannelWgt::slot_finMsgsHistoryReq]: num = %d\n", m_msgsReqNum);

  ChatCore::addParametr("MaxMsgsHistorySize", QString().setNum(QChatSettings::settings()->nHistoryMsgs()).toUtf8(), m_parametrs);

  // FIXME !!!
  if(m_msgsReqNum > 0)
    emit sendSomeData(m_name, m_msgsReqAddr.toIPv4Address(), AbstractChatCore::MSGS_HISTORY_REQUEST, "", m_type, &m_parametrs);
}

void ChannelWgt::msgsNumAnswer(QC_DatagramHeader* Hdr)
{
  uint num = QString(ChatCore::getParametr("MsgsNum", Hdr->parametrs)).toULongLong();

  if(num > m_msgsReqNum && (QChatSettings::settings()->nHistoryMsgs() < 0 || (int)m_msgsReqNum < QChatSettings::settings()->nHistoryMsgs()))
  {
    m_msgsReqNum      = num;
    m_msgsReqAddr     = QHostAddress(Hdr->src_ip);
    m_msgsReqReceived = QTime::currentTime();
  }
}

void ChannelWgt::retranslate()
{
  m_sendBtn            ->setText(tr("Send"));
  m_refreshUlBtn       ->setText(tr("Refresh"));
  m_sysMessagesChbx    ->setText(tr("Hide System Messages"));
}

void ChannelWgt::emitSomeData(AbstractChatCore::DataType data_type, const QString & msg, quint64 uid) const
{
  if(m_type == 1)
  {
    emit sendSomeData (m_name, m_destUid, data_type, msg, m_type, &m_parametrs);
    emit sendSomeData (m_name, Globals::localhost(), data_type, msg, m_type, &m_parametrs);
  }
  else if(uid == 0)
    // FIXME !!!
    emit sendSomeData (m_name, QChatSettings::settings()->broadcast().toIPv4Address(), data_type, msg, m_type, &m_parametrs);
  else
    emit sendSomeData (m_name, uid, data_type, msg, m_type, &m_parametrs);
}

void ChannelWgt::slot_changeUlRefreshInterval(uint erval)
{
  if(erval == 0)
    m_refreshTimer->stop();
  else
    m_refreshTimer->start(erval * 1000);
}

void ChannelWgt::slot_changeUlDeepRefreshInterval(uint /*erval*/)
{

}

void ChannelWgt::slot_controlSplitter(int idx, int /*pos*/)
{
  if((double)idx / (double)width() <= 0.5)
  {
    mw_usersStack->setCurrentIndex(1);
    m_usersModel->resort();
    updateUsersView();
  }
  else
    mw_usersStack->setCurrentIndex(0);
}

void ChannelWgt::updateUsersView()
{
  m_usersModel->resetModel();
  mw_usersStatistics->reset();
  mw_usersStatistics->setModel(m_usersModel);
}

void ChannelWgt::slot_deepRefreshUL()
{
  if(!m_requestsRest)
  {
    QTimer* t = new QTimer;

    m_requestsRest = 3;

    connect(t, SIGNAL(timeout()), this, SLOT(nextStatusRequest()));

    t->start(1000);

    slot_statusRequest();
  }
  else
    slot_statusRequest();
}

QByteArray ChannelWgt::saveState() const
{
  // Format:
  // 2 bytes - splittersStatesSize
  // 3x:
  // 2 bytes - splitter[i] State Size(SSS)
  // SSS bytes - splitter[i] state , i = (1, 3)
  //
  // from splittersStatesSize to state.size(); - usersstatisticswgt state

  QByteArray state, tmp;
  char sz[2];

  for(int i = 0; i < m_splitters.size(); i++)
  {
    tmp = m_splitters[i]->saveState();
    catUS2str(sz, tmp.size());

    state.append(sz[0]);
    state.append(sz[1]);
    state.append(tmp);
  }

  catUS2str(sz, state.size());
  state.prepend(sz[1]);
  state.prepend(sz[0]);

  state.append(mw_usersStatistics->saveState());

  return state;
}

void ChannelWgt::restoreState(const QByteArray & state)
{
  QByteArray tmp;
  char sz2[2];
  uint sz;
  uint state_sz;

  if(state.size() < 2)
    return;

  sz2[0] = state.at(0);
  sz2[1] = state.at(1);

  state_sz = str2US(sz2) + 2;

  if((uint)state.size() < state_sz)
    return;

  for(uint i = 0, j = 2; i < (uint)m_splitters.size(); i++)
  {
    if(j + 2 > state_sz)
      break;

    sz2[0] = state.at(j++);
    sz2[1] = state.at(j++);
    sz     = str2US(sz2);

    if(j + sz > state_sz)
      break;

    tmp = state.mid(j, sz);
    m_splitters[i]->restoreState(tmp);

    j += sz;
  }

  mw_usersStatistics->restoreState(state.mid(state_sz, state.size() - state_sz));

  if((double)m_splitters[2]->sizes()[1] / (double)width() >= 0.5)
  {
    mw_usersStack->setCurrentIndex(1);
    m_usersModel->resort();
    updateUsersView();
  }
  else
    mw_usersStack->setCurrentIndex(0);

  updateUsersView();
}

void ChannelWgt::nextStatusRequest()
{
  slot_statusRequest();
  m_requestsRest--;

  if(!m_requestsRest)
    if(qobject_cast<QTimer*>(sender()))
      delete sender();
}

void ChannelWgt::addAvatar(QC_DatagramHeader * Hdr)
{
  UserWgt*   usr;
  QByteArray buf;
  QPixmap* icon, *tmp;

  usr = m_users->findUser(Hdr->src_ip);
  if(!usr)
    m_users->findHidden(Hdr->src_ip);

  if(!usr)
    return;

  buf = ChatCore::getParametr("Icon", Hdr->parametrs);

  if(!buf.isNull())
  {
    icon = new QPixmap();

    if(!buf.isEmpty())
      icon->loadFromData(buf);

    tmp = drawUsersIcon(icon, usr->info());
    usr->setIcon(QIcon(*tmp));

    delete usr->info()->avatar();
    usr->info()->setAvatar(icon);

    delete tmp;
  }

  buf = ChatCore::getParametr("IconHash", Hdr->parametrs);
  usr->info()->setAvatarHash(buf);

  updateUsersView();
}

QPixmap* ChannelWgt::drawUsersIcon(const QPixmap* avatar_icon, UserInfo* info)
{
  QPixmap* status_pix = NULL;
  QPixmap* gender_pix = NULL;
  QPixmap* result_pix;
  QPixmap  tmp_icon;
  QPainter painter;
  bool     disabled = true;
  QString  icon_name;

  UserListIconFormat fmt = *(QChatSettings::settings()->iconFormat());

  int status_wd = fmt.statusWidth();
  int status_he = fmt.statusHeight();
  int gender_wd = fmt.genderWidth();
  int gender_he = fmt.genderHeight();
  int avatar_wd = fmt.avatarWidth();;
  int avatar_he = fmt.avatarHeight();
  int total_wd  = fmt.totalWidth();
  int total_he  = fmt.totalHeight();

  bool draw_gender = gender_wd > 0 && gender_he > 0;
  bool draw_status = status_wd > 0 && status_he > 0;

//   avatar_wd = total_wd - status_wd - gender_wd;

  assert(NULL != info);

  switch(info->status())
  {
    case Globals::READY4CHAT :
      icon_name = "status/user-ready-for-chat";
      disabled = false;
      break;

    case Globals::FREE :
      icon_name = "status/user-online";
      disabled = false;
      break;

    case Globals::BUSY :
      icon_name = "status/user-busy";
      break;

    case Globals::DND :
      icon_name = "status/user-dnd";
      break;

    case Globals::INACTIVE :
      icon_name = "status/user-away";
      break;

    case Globals::AWAY :
      icon_name = "status/user-away-extended";
      break;
  }

  if(avatar_icon)
  {
    if(disabled)
//       tmp_icon = QIcon(*avatar_icon).pixmap(avatar_wd, avatar_he, QIcon::Disabled);
      tmp_icon = QIcon(*avatar_icon).pixmap(avatar_wd, avatar_he, QIcon::Disabled);
    else
      tmp_icon = QIcon(*avatar_icon).pixmap(avatar_wd, avatar_he);//*avatar_icon;
  }

  if(draw_gender)
    switch(info->gender())
    {
      case 'm' : gender_pix = QChatIcon::newPixmap("user-male"  , gender_wd, gender_he); break;
      case 'f' : gender_pix = QChatIcon::newPixmap("user-female", gender_wd, gender_he); break;
      default  : gender_pix = QChatIcon::newPixmap("unknown"    , gender_wd, gender_he);
    }

  result_pix = new QPixmap(total_wd, total_he);

  QPixmap tmp(total_wd, total_he);

  tmp.fill(Qt::black);
  result_pix->setAlphaChannel(tmp);

  if(draw_status)
  {
    status_pix = QChatIcon::newPixmap(icon_name, status_wd, status_he);

    tmp = QPixmap(status_pix->width(), status_pix->height());
    tmp.fill(QColor(200, 200, 200));

    status_pix->setAlphaChannel(tmp);
  }

  int g_wd = (gender_wd + fmt.genderXoffset()) * draw_gender;
  int s_wd = (status_wd + fmt.statusXoffset()) * draw_status;

  painter.begin(result_pix);

  if(draw_gender)
    painter.drawPixmap(fmt.genderXoffset(), fmt.genderYoffset(), *gender_pix);

  if(draw_status)
    painter.drawPixmap(fmt.statusXoffset(), fmt.statusYoffset(), *status_pix);

  painter.drawPixmap((s_wd > g_wd ? s_wd : g_wd) + fmt.avatarXoffset(),
                     (total_he - tmp_icon.height()) / 2 /*fmt.avatarYoffset()*/, tmp_icon);
  painter.drawLine(fmt.totalWidth(), 0, fmt.totalWidth(), fmt.totalHeight());

  painter.end();

  delete status_pix;
  delete gender_pix;

  return result_pix;
}

void ChannelWgt::redrawIcons()
{
  UserListIconFormat* fmt = QChatSettings::settings()->iconFormat();

  mw_usersList->setIconSize(QSize(fmt->totalWidth(), fmt->totalHeight()));

  for(uint i = 0; i < m_users->num(); i++)
  {
    UserWgt* usr = m_users->user(i);
    if(usr)
    {
      usr->setSizeHint(QSize(1, fmt->totalHeight()));
      usr->setIcon(QIcon(*drawUsersIcon(usr->info()->avatar(), usr->info())));
    }
  }
}

void ChannelWgt::keyPressEvent(QKeyEvent* ev)
{
  QKeySequence seq = ev->key() + ev->modifiers();

  if(QChatSettings::settings()->shortcuts("RefreshUsersList").contains(seq))
    slot_refreshUL();
}

void ChannelWgt::setAnimationsRunning(bool b)
{
  mw_clearChatText->playPauseAnimations(b);
  mw_chatText     ->playPauseAnimations(b);
}

void ChannelWgt::logMessage(QC_DatagramHeader* Hdr)
{
  if(m_logFile)
  {
    Message   msg(Hdr);
    QDateTime date_time;
    QTextDocument doc;

    doc.setHtml(msg.msg());

    QString msg_str(QChatSettings::settings()->strOption("DisplayMessagesFormat"));
    QString tm_fmt = msg_str.section(QString("%time%"), 1, 1);

    date_time.setTime_t(msg.receiveTime());

    msg_str.replace(QRegExp("%time%([^<]*)%time%"), date_time.toString(tm_fmt));
    msg_str.replace("%user", msg.userName());
    msg_str.replace("%comp", msg.compName());

    if(msg.requested())
      msg_str.prepend(">");

     msg_str.append(doc.toPlainText() + "\n");

    m_logFile->write(msg_str.toUtf8());
  }
}