chatwgt.cpp

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

    if(QChatSettings::settings()->mode() == QChatSettings::Serverless)
      uid  = QChatSettings::settings()->hostAddressOption("IP").toIPv4Address();
    else
      uid  = UserInfo::myInfo()->uid();

    if(Hdr->src_ip == uid || Hdr->src_ip == 0x7f000001 || Hdr->src_ip == 1)
      chnnl = findChannel(QString().fromUtf8(ChatCore::getParametr("Channel", Hdr->parametrs)));
    else
      chnnl = findChannel(Hdr->src_ip, 1);
  }
  else
    chnnl = findChannel(QString().fromUtf8(ChatCore::getParametr("Channel", Hdr->parametrs)));

  if(chnnl)
  {
    chnnl->processData(Hdr);

    if(Hdr->type == AbstractChatCore::INFO_ANSWER       &&  m_userInfoDlg->readOnly() &&
       m_userInfoDlg->userUid() == Hdr->src_ip && !m_userInfoDlg->isHidden())
      {
        UserWgt* user = chnnl->findUser(Hdr->src_ip);
        if(user)
          m_userInfoDlg->slot_loadInfo(user->info());
      }
  }

  delete Hdr;
}

void ChatWgt::activity()
{

}

void ChatWgt::closeEvent(QCloseEvent * ev)
{
  int res;
  MessageWithCheckBox* mes;
  QMessageBox* mbox;

  if(QChatSettings::settings()->boolOption("WarningAboutHidingInTray"))
  {
    mbox = new QMessageBox;
    mbox->setIcon(QMessageBox::Information);
    mes = new MessageWithCheckBox(tr("Hiding in tray"),
                                  tr("Now QChat will be available from system tray.\n"
                                     "If you want to quit from QChat - use Exit action from menu Chat."),
                                  tr("Don't show this message again"), &res, this);
    mes->setIcon(mbox->iconPixmap());
    mes->exec();
    QChatSettings::settings()->setOption("WarningAboutHidingInTray", res);

    delete mes;
    delete mbox;
  }

  ev->accept();
}

void ChatWgt::slot_showSingleMessagesHistory()
{
  m_smhView->setHidden(!m_smhView->isHidden());
}

void ChatWgt::showSingleMessage(const QModelIndex & idx)
{
  SingleMessage* msg = NULL;
  MessageTreeItem *item = static_cast<MessageTreeItem*>(idx.internalPointer());

  if(item)
    msg = item->message();

  if(msg && !msg->activate())
  {
    SingleMessageWgt* smw = new SingleMessageWgt(msg, msg->isIncoming());
    connect(smw , SIGNAL(singleMessage   (const QString &, quint64, bool)),
            this, SIGNAL(singleMessageOut(const QString &, quint64, bool)));

    smw->show();
  }

}

void ChatWgt::showPlugins()
{
  m_widgetsStack->setCurrentIndex(!m_widgetsStack->currentIndex());
}

QChatWidgetPlugin* ChatWgt::isPLugin(QWidget* wgt)
{
  QTabWidget* tab;
  QChatWidgetPlugin* plugin = NULL;

  tab = qobject_cast<QTabWidget*>(wgt);

  if(tab)
  {
    wgt = tab->currentWidget();
    while(wgt)
    {
      plugin = qobject_cast<QChatWidgetPlugin*>(wgt);
      if(plugin)
        return plugin;

      wgt = wgt->parentWidget();
    }
  }


  while(wgt)
  {
    plugin = qobject_cast<QChatWidgetPlugin*>(wgt);
    if(plugin)
      return plugin;

    wgt = wgt->parentWidget();
  }

  return plugin;
}

void ChatWgt::setupPluginToolBar(QWidget* wgt)
{
  QChatWidgetPlugin* plug = qobject_cast<QChatWidgetPlugin*>(wgt);
  m_pluginsToolBar->clear();

  if(plug)
    plug->setupToolBar(m_pluginsToolBar);
}

void ChatWgt::pluginSwitched()
{
    setupPluginToolBar(mw_tabs->currentWidget());
//   setupPluginToolBar(m_pluginsTabs->currentWidget());
}

void ChatWgt::connect2server()
{
  QStringList m_lastServers = QChatSettings::settings()->strOption("LastServers").split("\n", QString::SkipEmptyParts);
  QStringList m_lastLogins  = QChatSettings::settings()->strOption("LastLogins").split("\n", QString::SkipEmptyParts);

  QString server = !m_lastServers.count() ? QString("127.0.0.1") : m_lastServers[0];

  Login2ServerDlg* dlg = new Login2ServerDlg(&m_lastServers, &m_lastLogins, this, server, UserInfo::myInfo()->nickname());
  bool res;

  dlg->setModal(true);

  connect(dlg       , SIGNAL(wantLogin(QHostAddress, QString)), m_chatCore, SLOT(slot_login(QHostAddress, QString)));
  connect(m_chatCore, SIGNAL(loginFinished(int, QString))     , dlg       , SLOT(loginFinished(int, QString)));
  connect(dlg       , SIGNAL(loginSuccessful())               , this      , SLOT(swapConnectDisconnectAct()));

  res = dlg->exec();

  delete dlg;
}

void ChatWgt::disconnectFromServer()
{
  statusBar()->showMessage(tr("Disconnecting from server..."));
  m_chatCore->disconnectFromServer();
}

void ChatWgt::disconnectedFromServer()
{
  m_disconnectFromServerAct->setVisible(0);
  m_connectToServerAct->setVisible(1);

  statusBar()->showMessage(tr("Disconnected from server"));
  m_setServerlessModeAct->trigger();
}

void ChatWgt::chvisConnectToServerAct()
{
  QAction* act = qobject_cast<QAction*>(sender());
  bool conn;

  if(act)
  {
    switch(act->data().toInt())
    {
      case ChatCore::Server :
        conn = (m_chatCore->tcpReceiver()->state() == QAbstractSocket::ConnectedState);
        m_connectToServerAct->setVisible(!conn);
        m_disconnectFromServerAct->setVisible(conn);
        break;

      case ChatCore::Serverless :
        m_connectToServerAct->setVisible(false);
        m_disconnectFromServerAct->setVisible(false);
    }

    foreach(ChannelWgt* cw, channels())
      cw->slot_refreshUL();
  }
}

UserInfo* ChatWgt::findUser(quint64 uid)
{
  UserWgt* usr;

  foreach(ChannelWgt* cw, mw_channels)
    if((usr = cw->findUser(uid)))
      return usr->info();

  return NULL;
}

void ChatWgt::setIcons()
{
  m_showSettingsAct   ->setIcon(QChatIcon::icon("personal"));
  m_showPreferencesAct->setIcon(QChatIcon::icon("configure"));
  m_exitAct           ->setIcon(QChatIcon::icon("application-exit"));
  m_showSmilesAct     ->setIcon(QChatIcon::icon("emotes"));
  m_addChannelAct     ->setIcon(QChatIcon::icon("tab-new"));
  m_delChannelAct     ->setIcon(QChatIcon::icon("tab-close"));
  m_aboutAct          ->setIcon(QChatIcon::icon("help-about"));
  m_aboutQtAct        ->setIcon(QChatIcon::icon("help-about"));
  m_licenseAct        ->setIcon(QChatIcon::icon("help-about"));
  m_writeSettingsAct  ->setIcon(QChatIcon::icon("write-settings"));
  m_addProfileAct     ->setIcon(QChatIcon::icon("add-profile"));
  m_deleteProfileAct  ->setIcon(QChatIcon::icon("remove-profile"));
  m_renameProfileAct  ->setIcon(QChatIcon::icon("edit-rename"));
}

void ChatWgt::setToolbarsIconsSize()
{
  QAction* act = qobject_cast<QAction*>(sender());

  if(act)
  {
    int sz = act->data().toInt();

    if(!sz)
      sz = QStyle::PM_ToolBarIconSize;

    foreach(QToolBar* tb, m_toolbars)
      tb->setIconSize(QSize(sz, sz));

    QChatSettings::settings()->setToolbarIconsSize(sz);
  }
}

void ChatWgt::setToolButtonsStyle()
{
  QAction* act = qobject_cast<QAction*>(sender());

  if(act)
  {
    Qt::ToolButtonStyle style = (Qt::ToolButtonStyle)(act->data().toInt());

    foreach(QToolBar* tb, m_toolbars)
      tb->setToolButtonStyle(style);
  }
}

void ChatWgt::addToolbar(QToolBar* tb)
{
  m_toolbars.append(tb);
  addToolBar(tb);
}

void ChatWgt::changeIconFormat(const UserListIconFormat & fmt)
{
  *(QChatSettings::settings()->iconFormat()) = fmt;

  foreach(ChannelWgt* ch, channels())
    ch->redrawIcons();
}

void ChatWgt::showConfigureShortcuts()
{
  ShortcutsEditor* dlg = new ShortcutsEditor(0);

  dlg->resize(800, 600);
  dlg->exec();

  delete dlg;

  updateShortcuts();

  m_chatCore->saveSettings(true);
}

void ChatWgt::updateShortcuts()
{
  QChatSettings* prefs = QChatSettings::settings();

  m_showSingleMessagesAct->setShortcut(prefs->shortcut("SingleMessagesHistory"));
  m_showSettingsAct      ->setShortcut(prefs->shortcut("EditUserDetails"));
  m_showPreferencesAct   ->setShortcut(prefs->shortcut("ConfigureQChat"));
  m_exitAct              ->setShortcut(prefs->shortcut("Quit"));
  m_showSmilesAct        ->setShortcut(prefs->shortcut("ShowSmiles"));

  m_addChannelAct        ->setShortcut(prefs->shortcut("AddChannel"));
  m_delChannelAct        ->setShortcut(prefs->shortcut("DelChannel"));

  m_addProfileAct        ->setShortcut(prefs->shortcut("AddProfile"));
  m_deleteProfileAct     ->setShortcut(prefs->shortcut("DelProfile"));
  m_renameProfileAct     ->setShortcut(prefs->shortcut("RenameProfile"));
  m_broadcastMessageAct  ->setShortcut(prefs->shortcut("BroadcastMessage"));

  m_smhView->updateShortcuts();
}

void ChatWgt::sendBroadcastMessage()
{
  SingleMessageWgt* smw = new SingleMessageWgt(tr("Broadcast Message"),
                                               "",
                                               QChatSettings::settings()->broadcast().toIPv4Address(),
                                               QHostAddress("255.255.255.255")
                                               );

  connect(smw , SIGNAL(singleMessage    (QString, quint64, bool)),
          this, SIGNAL(singleMessage    (QString, quint64, bool)));

  smw->show();
}

void ChatWgt::loadPlugin(const QString & path)
{
  qDebug("![ChatWgt::loadPlugin]: loading '%s'\n", path.toAscii().data());

  m_chatCore->pluginManager()->load(path);

  Plugin* loader = m_chatCore->pluginManager()->getPluginByPath(path);

  QChatWidgetPlugin* pluginWgt = NULL;
  QChatBasicPlugin*  plugin = NULL;

  if(loader)
  {
    pluginWgt = loader->instanceWgt();

    if(!pluginWgt)
      plugin = loader->instanceBasic();
    else
      plugin = pluginWgt;

    if(loader->isLoaded() && plugin)
    {
      plugin->setPath(loader->path());
      m_allPlugins.append(loader->instance());
      m_preferencesDlg->addSection(plugin->settingsPage(), plugin->name());

      if(pluginWgt)
      {
//         m_pluginsTabs->addTab(pluginWgt->widget(), pluginWgt->name());
        mw_tabs->addTab(pluginWgt->widget(), pluginWgt->name());
        setupPluginToolBar(m_pluginsTabs->currentWidget());
      }
    }
  }
}

void ChatWgt::unloadPlugin(const QString & path)
{
  qDebug("![ChatWgt::unloadPlugin]: unloading '%s'\n", path.toAscii().data());
  setupPluginToolBar(NULL);

  QChatBasicPlugin* plugin;

  Plugin* loader = m_chatCore->pluginManager()->getPluginByPath(path);

  if(loader)
  {
    plugin = loader->instanceBasic();
    if(plugin)
      m_preferencesDlg->removeSection(plugin->settingsPage());
  }

  m_chatCore->pluginManager()->unload(path);

  setupPluginToolBar(m_pluginsTabs->currentWidget());
}

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



  QWidget::keyPressEvent(ev);
}

void ChatWgt::setAnimationsRunning(bool b)
{
  foreach(ChannelWgt* cw, mw_channels)
    cw->setAnimationsRunning(b);
}

void ChatWgt::setMode()
{
  QAction* act = qobject_cast<QAction*>(sender());

  if(act)
    m_chatCore->initMode((ChatCore::Mode)act->data().toInt());

  if((ChatCore::Mode)act->data().toInt() == ChatCore::Server && !m_chatCore->loggedIn())
    connect2server();
}