kopete/protocols/irc/ircaccount.cpp

   1 /*
   2     ircaccount.cpp - IRC Account
   3
   4     Copyright (c) 2002      by Nick Betcher <nbetcher@kde.org>
   5     Copyright (c) 2003-2004 by Jason Keirstead <jason@keirstead.org>
   6     Copyright (c) 2003-2007 by Michel Hermier <michel.hermier@gmail.com>
   7
   8     Kopete    (c) 2002-2007 by the Kopete developers <kopete-devel@kde.org>
   9
  10     *************************************************************************
  11     *                                                                       *
  12     * This program is free software; you can redistribute it and/or modify  *
  13     * it under the terms of the GNU General Public License as published by  *
  14     * the Free Software Foundation; either version 2 of the License, or     *
  15     * (at your option) any later version.                                   *
  16     *                                                                       *
  17     *************************************************************************
  18 */
  19
  20 #include "ircaccount.h"
  21
  22 #include "irccontact.h"
  23 #include "ircprotocol.h"
  24
  25 #include "kirccontext.h"
  26 #include "kircclientsocket.h"
  27 #include "kircstdmessages.h"
  28 #include "kircconst.h"
  29 #include "kircevent.h"
  30
  31 #include "kopeteaccountmanager.h"
  32 #include "kopetechatsessionmanager.h"
  33 #include "kopetecommandhandler.h"
  34 #include "kopetecontactlist.h"
  35 #include "kopetemetacontact.h"
  36 #include "kopeteuiglobal.h"
  37 #include "kopeteview.h"
  38 #include "kopetepassword.h"
  39
  40 #include <kactionmenu.h>
  41 #include <kconfig.h>
  42 #include <kcompletionbox.h>
  43 #include <kdebug.h>
  44 #include <kglobal.h>
  45 #include <kinputdialog.h>
  46 //#include <klineedit.h>
  47 //#include <klineeditdlg.h>
  48 #include <klocale.h>
  49 #include <kmenu.h>
  50 #include <kmessagebox.h>
  51
  52
  53
  54 #include <qtextcodec.h>
  55 #include <QTimer>
  56
  57 using namespace IRC;
  58 using namespace Kopete;
  59
  60 class IRCAccount::Private
  61 {
  62 public:
  63         Private()
  64                 : manager(0)
  65                 , client(0)
  66                 , server(0)
  67                 , self(0)
  68                 , commandSource(0)
  69                 , joinChannelAction(0)
  70                 , searchChannelAction(0)
  71         { }
  72
  73         Kopete::ChatSession *manager;
  74         QString autoConnect;
  75
  76         KIrc::Context *clientContext;
  77         KIrc::ClientSocket *client;
  78         IRC::Network network;
  79         int currentHost;
  80
  81         QList<IRCContact *> contacts;
  82         IRCContact *server;
  83         IRCContact *self;
  84
  85         Kopete::OnlineStatus expectedOnlineStatus;
  86         QString expectedReason;
  87
  88         QMap<QString, QString> customCtcp;
  89         Kopete::ChatSession *commandSource;
  90
  91         KAction *joinChannelAction;
  92         KAction *searchChannelAction;
  93
  94         QString motd;
  95 };
  96
  97 IRCAccount::IRCAccount(const QString &accountId, const QString &autoChan, const QString& netName, const QString &nickName)
  98         : PasswordedAccount(IRCProtocol::self(), accountId, true),
  99           d( new Private )
 100 {
 101         d->clientContext = new KIrc::Context(this);
 102         d->client = new KIrc::ClientSocket(d->clientContext);
 103         d->autoConnect = autoChan;
 104         d->currentHost = 0;
 105
 106         QObject::connect(d->client, SIGNAL(connectionStateChanged(KIrc::Socket::ConnectionState)),
 107                          this, SLOT(clientConnectionStateChanged(KIrc::Socket::ConnectionState)));
 108
 109         QObject::connect(d->clientContext,SIGNAL( ircEvent( QEvent* ) ),
 110                          this, SLOT( receivedEvent( QEvent* ) ) );
 111
 112 //      loadProperties();
 113
 114         d->server = new IRCContact(this, d->client->server());
 115         d->self = new IRCContact(this, d->client->owner());
 116         d->contacts.append( d->server );
 117         d->contacts.append( d->self );
 118
 119         setMyself(d->self);
 120
 121         kDebug()<<"accId="<<accountId<<" autoChan="<<autoChan<<" netName="<<netName<<" nickname="<<nickName;
 122
 123         QString networkName=netName;
 124         if(networkName.isEmpty())
 125                 networkName=this->networkName();
 126
 127         if ( networkName.isEmpty() && QRegExp( "[^#+&\\s]+@[\\w-\\.]+:\\d+" ).exactMatch( accountId ) )
 128         {
 129                 kDebug(14120) << "Creating account from " << accountId;
 130
 131 //              mNickName = accountId.section('@',0,0);
 132                 QString serverInfo = accountId.section('@',1);
 133                 QString hostName = serverInfo.section(':',0,0);
 134
 135                 IRC::NetworkList networks = IRC::Networks::self()->networks();
 136                 foreach(const IRC::Network &net, networks)
 137                 {
 138                         foreach(const IRC::Host& host, net.hosts)
 139                         {
 140                                 if( host.host == hostName )
 141                                 {
 142                                         setNetworkByName(net.name);
 143                                         break;
 144                                 }
 145                         }
 146
 147                         if( !networkName.isEmpty() )
 148                                 break;
 149                 }
 150
 151                 if( networkName.isEmpty() )
 152                 {
 153                         // Could not find this host. Add it to the networks structure
 154
 155                         d->network.name = i18n("Temporary Network - %1", hostName );
 156                         d->network.description = i18n("Network imported from previous version of Kopete, or an IRC URI");
 157
 158                         IRC::Host host;
 159                         host.host = hostName;
 160                         host.port = serverInfo.section(':',1).toInt();
 161                         if (!password().cachedValue().isEmpty())
 162                                 host.password = password().cachedValue();
 163                         host.ssl = false;
 164
 165                         d->network.hosts.append( host );
 166 //                      d->protocol->addNetwork( d->network );
 167
 168                         setNetworkByName(networkName);
 169 //                      config->writeEntry(Config::NICKNAME, mNickName);
 170                 }
 171         }
 172         else if( !networkName.isEmpty() )
 173         {
 174                 setNetworkByName(networkName);
 175         }
 176         else
 177         {
 178                 kError() << "No network name defined, and could not import network information from ID" << endl;
 179         }
 180
 181
 182 //      setAccountLabel( QString::fromLatin1("%1@%2").arg(mNickName,networkName) );
 183
 184
 185 #ifdef __GNUC__
 186         #warning spurus slot calls for now
 187 #endif
 188         d->joinChannelAction = new KAction(i18n("Join Channel..."), this);
 189         QObject::connect(d->joinChannelAction, SIGNAL(triggered()), this, SLOT(slotJoinChannel()));
 190         d->searchChannelAction = new KAction(i18n("Search Channels..."), this);
 191         QObject::connect(d->searchChannelAction, SIGNAL(triggered()), this, SLOT(slotSearchChannels()));
 192 }
 193
 194 IRCAccount::~IRCAccount()
 195 {
 196         kDebug(14120) ;
 197 //      KIrc::StdMessage::quit(d->client, i18n("Plugin Unloaded"));
 198
 199         delete d;
 200 }
 201
 202
 203 void IRCAccount::clientSetup()
 204 {
 205         //d->client->setDefaultCodec(codec());
 206 /*
 207         // Build the URL instead
 208         KUrl url;
 209         url.setUser(userName());
 210 //      url.setPass(password());
 211 */
 212 /*
 213         d->client->setNickName(nickName());
 214         url.addQuery(URL_REALNAME, realName());
 215         d->client->setVersionString(IRC::Version);
 216
 217         QMap<QString, QString> replies = customCtcpReplies();
 218         for (QMap<QString, QString>::ConstIterator it = replies.begin(); it != replies.end(); ++it)
 219                 d->client->addCustomCtcp(it.key(), it.data());
 220 */
 221
 222         d->network = IRC::Networks::self()->network(networkName());
 223
 224         // if prefer SSL is set, sort by SSL first
 225         if (configGroup()->readEntry("PreferSSL",false))
 226         {
 227                 QList<IRC::Host> sslFirst;
 228                 QList<IRC::Host> noSSL;
 229
 230                 foreach(const IRC::Host &host,d->network.hosts)
 231                 {
 232                         if ( host.ssl == true )
 233                         {
 234                                 sslFirst.append( host );
 235                         }else
 236                         {
 237                                 noSSL.append( host );
 238                         }
 239                 }
 240                 //Now append the non ssl servers
 241                 foreach(const IRC::Host &host,noSSL)
 242                 {
 243                         sslFirst.append(host);
 244                 }
 245
 246                 d->network.hosts = sslFirst;
 247         }
 248
 249 }
 250
 251 void IRCAccount::clientConnect()
 252 {
 253         kDebug(14120) ;
 254
 255         if (d->network.name.isEmpty())
 256         {
 257                 KMessageBox::queuedMessageBox(
 258                         UI::Global::mainWidget(), KMessageBox::Error,
 259                         i18n("<qt>The network associated with this account has no valid hosts. "
 260                                 "Please ensure that the account has a valid network.</qt>"),
 261                         i18n("Network is Empty"), 0 );
 262         }
 263         else if (d->network.hosts.isEmpty())
 264         {
 265                 KMessageBox::queuedMessageBox(
 266                         UI::Global::mainWidget(), KMessageBox::Error,
 267                         i18n("<qt>The network associated with this account, <b>%1</b>, has no valid hosts. "
 268                                 "Please ensure that the account has a valid network.</qt>", d->network.name),
 269                         i18n("Network is Empty"), 0 );
 270         }
 271         else if( d->currentHost == d->network.hosts.count() )
 272         {
 273                 KMessageBox::queuedMessageBox(
 274                         UI::Global::mainWidget(), KMessageBox::Error,
 275                         i18n("<qt>Kopete could not connect to any of the servers in the network "
 276                                 "associated with this account (<b>%1</b>). Please try again later.</qt>",
 277                                 d->network.name),
 278                         i18n("Network is Unavailable"), 0 );
 279
 280                         d->currentHost = 0;
 281         }
 282         else
 283         {
 284                 const IRC::Host& host = d->network.hosts[ d->currentHost++ ];
 285                 //appendInternalMessage( i18n("Connecting to %1...", host.host ) );
 286
 287                 QString urlString;
 288
 289                 if (host.ssl) {
 290                         //appendInternalMessage( i18n("Using SSL") );
 291                         urlString = "ircs://";
 292                 } else {
 293                         urlString = "irc://";
 294                 }
 295
 296                 urlString += nickName() + '@' + host.host + ':' + QString::number(host.port);
 297
 298                 KUrl url(urlString);
 299                 //TODO use the constants in kircconst.h
 300                 url.addQueryItem("realname",realName());
 301                 url.addQueryItem("nickname",nickName());
 302                 //d->client->connectToServer( host->host, host->port, mNickName, host->ssl );
 303                 d->client->connectToServer(url);
 304         }
 305 }
 306
 307 int IRCAccount::codecMib() const
 308 {
 309         kDebug(14120) ;
 310         return configGroup()->readEntry(Config::CODECMIB, 0);
 311 }
 312
 313 void IRCAccount::setCodecFromMib(int mib)
 314 {
 315         kDebug(14120) ;
 316         configGroup()->writeEntry(Config::CODECMIB, mib);
 317         d->clientContext->setDefaultCodec(QTextCodec::codecForMib(mib));
 318 }
 319
 320 QTextCodec *IRCAccount::codec() const
 321 {
 322         kDebug(14120) ;
 323         return QTextCodec::codecForMib(codecMib());
 324 }
 325
 326 void IRCAccount::setCodec( QTextCodec *codec )
 327 {
 328         kDebug(14120) ;
 329         if (codec)
 330                 setCodecFromMib(codec->mibEnum());
 331         else
 332                 setCodecFromMib(-1); // MIBenum are >= 0  so we inforce an error value
 333 }
 334
 335 const QString IRCAccount::networkName() const
 336 {
 337         return configGroup()->readEntry(Config::NETWORKNAME, QString());
 338 }
 339
 340 void IRCAccount::setNetworkByName(const QString &networkName)
 341 {
 342         configGroup()->writeEntry(Config::NETWORKNAME, networkName);
 343 //      setAccountLabel(network.name);
 344 }
 345 /*
 346 IRCNetwork network() const
 347 {
 348         return d->network;
 349 }
 350 */
 351 const QString IRCAccount::userName() const
 352 {
 353         return configGroup()->readEntry(Config::USERNAME, QString());
 354 }
 355
 356 void IRCAccount::setUserName(const QString &userName)
 357 {
 358         configGroup()->writeEntry(Config::USERNAME, userName);
 359 }
 360
 361 const QString IRCAccount::realName() const
 362 {
 363         return configGroup()->readEntry(Config::REALNAME, QString());
 364 }
 365
 366 void IRCAccount::setRealName( const QString &userName )
 367 {
 368         configGroup()->writeEntry(Config::REALNAME, userName);
 369 }
 370
 371 const QString IRCAccount::nickName() const
 372 {
 373         return configGroup()->readEntry(Config::NICKNAME, QString());
 374 }
 375
 376 void IRCAccount::setNickName(const QString &nickName)
 377 {
 378         configGroup()->writeEntry(Config::NICKNAME, nickName);
 379 //      d->self->setNickName(nickName);
 380 }
 381
 382 const QString IRCAccount::partMessage() const
 383 {
 384         return configGroup()->readEntry(QLatin1String("defaultPart"), QString());
 385 }
 386
 387 void IRCAccount::setPartMessage( const QString &partMessage )
 388 {
 389         configGroup()->writeEntry(QLatin1String("defaultPart"), partMessage);
 390 }
 391
 392 const QString IRCAccount::quitMessage() const
 393 {
 394         return configGroup()->readEntry(QLatin1String("defaultQuit"), QString());
 395 }
 396
 397 void IRCAccount::setQuitMessage(const QString &quitMessage)
 398 {
 399         configGroup()->writeEntry( QLatin1String("defaultQuit"), quitMessage );
 400 }
 401
 402 bool IRCAccount::autoShowServerWindow() const
 403 {
 404         return configGroup()->readEntry(QString::fromLatin1("AutoShowServerWindow"), false);
 405 }
 406
 407 void IRCAccount::setAutoShowServerWindow(bool autoShow)
 408 {
 409         configGroup()->writeEntry(QString::fromLatin1("AutoShowServerWindow"), autoShow);
 410 }
 411
 412 KIrc::ClientSocket *IRCAccount::client() const
 413 {
 414         kDebug(14120) ;
 415         return d->client;
 416 }
 417
 418 void IRCAccount::setCustomCtcpReplies(const QMap<QString, QString> &replies)
 419 {
 420 /*
 421         QStringList val;
 422         for( QMap< QString, QString >::ConstIterator it = replies.begin(); it != replies.end(); ++it )
 423         {
 424                 d->client->addCustomCtcp( it.key(), it.data() );
 425                 val.append( QString::fromLatin1("%1=%2").arg( it.key() ).arg( it.data() ) );
 426         }
 427
 428         configGroup()->writeEntry( "CustomCtcp", val );
 429 */
 430 }
 431
 432 const QMap<QString, QString> IRCAccount::customCtcpReplies() const
 433 {
 434         kDebug(14120) ;
 435         QMap< QString, QString > replies;
 436 /*
 437         QStringList replyList;
 438
 439         replyList = configGroup()->readListEntry( "CustomCtcp" );
 440
 441         for( QStringList::Iterator it = replyList.begin(); it != replyList.end(); ++it )
 442                 replies[ (*it).section('=', 0, 0 ) ] = (*it).section('=', 1 );
 443 */
 444         return replies;
 445 }
 446
 447 void IRCAccount::setConnectCommands( const QStringList &commands ) const
 448 {
 449         configGroup()->writeEntry("ConnectCommands", commands);
 450 }
 451
 452 const QStringList IRCAccount::connectCommands() const
 453 {
 454         return configGroup()->readEntry("ConnectCommands", QStringList());
 455 }
 456
 457 void IRCAccount::fillActionMenu( KActionMenu *actionMenu )
 458 {
 459         kDebug(14120) ;
 460         QString menuTitle = QString::fromLatin1( " %1 <%2> " ).arg( accountId() ).arg( myself()->onlineStatus().description() );
 461
 462         Account::fillActionMenu( actionMenu );
 463
 464         d->joinChannelAction->setEnabled( isConnected() );
 465         d->searchChannelAction->setEnabled( isConnected() );
 466
 467         actionMenu->addSeparator();
 468         actionMenu->addAction(d->joinChannelAction);
 469         actionMenu->addAction(d->searchChannelAction);
 470 /*
 471         actionMenu->insert( new KAction ( i18n("Show Server Window"), QString(), 0, this, SLOT(slotShowServerWindow()), actionMenu ) );
 472
 473 //      if (d->client->isConnected() && d->client->useSSL())
 474         {
 475                 actionMenu->insert( new KAction ( i18n("Show Security Information"), "", 0, d->client,
 476                         SLOT(showInfoDialog()), actionMenu ) );
 477         }
 478 */
 479 }
 480
 481 void IRCAccount::connectWithPassword(const QString &password)
 482 {
 483         //      d->client->setPassword(password);
 484
 485         kDebug(14120) << "Connecting with password.";
 486         clientConnect();
 487 }
 488
 489 void IRCAccount::clientConnectionStateChanged(KIrc::Socket::ConnectionState newstate)
 490 {
 491         kDebug(14120) ;
 492
 493         mySelf()->updateStatus();
 494
 495         switch (newstate)
 496         {
 497         case KIrc::Socket::HostLookup:
 498         case KIrc::Socket::HostFound:
 499         case KIrc::Socket::Connecting:
 500                 // d->expectedOnlineStatus check and use it
 501                 mySelf()->setOnlineStatus(Kopete::OnlineStatus::Connecting);
 502
 503                 if (autoShowServerWindow())
 504                         myServer()->startChat();
 505                 break;
 506
 507         case KIrc::Socket::Authentified:
 508                 mySelf()->setOnlineStatus(Kopete::OnlineStatus::Online);
 509
 510                 //Reset the host so re-connection will start over at first server
 511                 d->currentHost = 0;
 512 //              d->contactManager->addToNotifyList( d->client->nickName() );
 513
 514                 // HACK! See bug #85200 for details. Some servers still cannot accept commands
 515                 // after the 001 is sent, you need to wait until all the init junk is done.
 516                 // Unfortunately, there is no way for us to know when it is done (it could be
 517                 // spewing out any number of replies), so just try delaying it
 518                 QTimer::singleShot( 250, this, SLOT( slotPerformOnConnectCommands() ) );
 519                 break;
 520 /*
 521         case KIrc::Socket::Closing:
 522 //              mySelf()->setOnlineStatus( protocol->m_UserStatusOffline );
 523 //              d->contactManager->removeFromNotifyList( d->client->nickName() );
 524
 525 //              if (d->contactManager && !autoConnect.isNull())
 526 //                      AccountManager::self()->removeAccount( this );
 527                 break;
 528 //      case KIrc::Socket::Timeout:
 529                 //Try next server
 530 //              connect();
 531 //              break;
 532 */
 533         default:
 534                 kDebug(14120) << "Doing nothing on state" << newstate;
 535         }
 536 }
 537 /*
 538 // Put that in error handling
 539 void IRCAccount::slotFailedServerPassword()
 540 {
 541         // JLN
 542         password().setWrong();
 543         connect();
 544 }
 545 */
 546 void IRCAccount::slotPerformOnConnectCommands()
 547 {
 548         kDebug(14120) ;
 549         ChatSession *manager = myServer()->manager(Contact::CanCreate);
 550         if (!manager)
 551                 return;
 552
 553 //      if (!d->autoConnect.isEmpty())
 554 //              CommandHandler::commandHandler()->processMessage( QString::fromLatin1("/join %1").arg(d->autoConnect), manager);
 555
 556         QStringList commands(connectCommands());
 557 //      for (QStringList::Iterator it=commands.begin(); it != commands.end(); ++it)
 558 //              CommandHandler::commandHandler()->processMessage(*it, manager);
 559 }
 560
 561 void IRCAccount::quit( const QString &quitMessage )
 562 {
 563         kDebug(14120) << "Quitting IRC: " << quitMessage;
 564
 565 //      KIrc::StdCommands::quit(d->client, quitMessage.isEmpty() ? defaultQuitMessage() : quitMessage);
 566 }
 567
 568 void IRCAccount::setAway(bool isAway, const QString &awayMessage)
 569 {
 570         kDebug(14120) << isAway << " " << awayMessage;
 571 //      KIrc::StdCommands::away(d->client, awayMessage);
 572 }
 573
 574 void IRCAccount::slotShowServerWindow()
 575 {
 576         d->server->startChat();
 577 }
 578
 579 void IRCAccount::slotJoinChannel()
 580 {
 581         if (!isConnected())
 582                 return;
 583
 584         QStringList chans = configGroup()->readEntry( "Recent Channel list", QStringList() );
 585         //kdDebug(14120) << "Recent channel list from config: " << chans << endl;
 586         QString channelName=KInputDialog::getText( i18n( "Join Channel" ),
 587                         i18n("Please enter the name of the channel you want to join:"),
 588                         QString(), 0,
 589                         Kopete::UI::Global::mainWidget(),
 590                         0, QString(), 0, chans
 591                 );
 592
 593         if ( !channelName.isNull() )
 594         {
 595                 kDebug( 14120 )<<"joining channel"<<channelName;
 596                 chans.prepend( channelName );
 597                 configGroup()->writeEntry( "Recent Channel list", chans );
 598
 599                 KIrc::EntityPtr channel=d->client->joinChannel( channelName.toUtf8() );
 600                 getContact( channel )->startChat();
 601         }
 602 }
 603
 604 void IRCAccount::setOnlineStatus(const OnlineStatus& status , const StatusMessage &messageStatus, const OnlineStatusOptions& options)
 605 {
 606         kDebug(14120) ;
 607         d->expectedOnlineStatus = status;
 608         //d->expectedReason = reason;
 609
 610         OnlineStatus::StatusType current = myself()->onlineStatus().status();
 611         OnlineStatus::StatusType expected = d->expectedOnlineStatus.status();
 612
 613         if ( expected != OnlineStatus::Offline && (current == OnlineStatus::Offline || current == OnlineStatus::Unknown) )
 614         {
 615                 kDebug(14120) << "Connecting.";
 616                 clientSetup();
 617 //              clientConnect();
 618                 connect();
 619         }
 620
 621         if ( expected == OnlineStatus::Offline && current != OnlineStatus::Offline )
 622         {
 623                 kDebug(14120) << "Disconnecting.";
 624                 //quit(reason);
 625         }
 626 }
 627
 628 void IRCAccount::setStatusMessage(const StatusMessage &messageStatus)
 629 {
 630         kDebug(14120) ;
 631 }
 632
 633 bool IRCAccount::createContact(const QString &contactId, MetaContact *metac)
 634 {
 635         kDebug(14120) ;
 636 /*      if (contactId == mNickName)
 637         {
 638                 KMessageBox::error( UI::Global::mainWidget(),
 639                         i18n("\"You are not allowed to add yourself to your contact list."), i18n("IRC Plugin")
 640                 );
 641
 642                 return false;
 643         }
 644         IRCContact *contact = getContact(contactId, metac);
 645
 646         if (contact->metaContact() != metac )
 647         {//This should NEVER happen
 648                 MetaContact *old = contact->metaContact();
 649                 contact->setMetaContact(metac);
 650                 ContactPtrList children = old->contacts();
 651                 if (children.isEmpty())
 652                         ContactList::self()->removeMetaContact( old );
 653         }
 654         else if (contact->metaContact()->isTemporary())
 655                 metac->setTemporary(false);
 656 */
 657         return true;
 658 }
 659
 660 void IRCAccount::setCurrentCommandSource( ChatSession *session )
 661 {
 662         kDebug(14120) ;
 663         d->commandSource = session;
 664 }
 665
 666 ChatSession *IRCAccount::currentCommandSource()
 667 {
 668         kDebug(14120) ;
 669         return d->commandSource;
 670 }
 671
 672 IRCContact *IRCAccount::myServer() const
 673 {
 674         return d->server;
 675 }
 676
 677 IRCContact *IRCAccount::mySelf() const
 678 {
 679         return d->self;
 680 }
 681
 682 IRCContact *IRCAccount::getContact(const QByteArray &name, MetaContact *metac)
 683 {
 684         kDebug(14120) << name;
 685 //      return getContact(d->client->entityManager()->entityByName(name), metac);
 686         return 0;
 687 }
 688
 689 IRCContact *IRCAccount::getContact(const KIrc::EntityPtr &entity, MetaContact *metac)
 690 {
 691         IRCContact *contact = 0;
 692
 693         kDebug( 14120)<<"finding contact for name "<<entity->name();
 694
 695         //TODO: use hash or something to speed up searching?
 696         foreach( IRCContact *tmp, d->contacts )
 697         {
 698                 if ( tmp->entity()==entity )
 699                 {
 700                         contact=tmp;
 701                         break;
 702                 }
 703         }
 704
 705         if (!contact)
 706         {
 707 #ifdef __GNUC__
 708                 #warning Make a temporary meta contact if metac is null
 709 #endif
 710                 contact = new IRCContact(this, entity, metac);
 711                 d->contacts.append(contact);
 712         }
 713
 714         QObject::connect(contact, SIGNAL(destroyed(IRCContact *)), SLOT(destroyed(IRCContact *)));
 715         return contact;
 716 }
 717
 718 QList<Kopete::Contact*> IRCAccount::getContacts( const KIrc::EntityList &entities )
 719 {
 720         QList<Kopete::Contact*> contacts;
 721         foreach( const KIrc::EntityPtr &e, entities )
 722                 contacts<<getContact( e );
 723
 724         return contacts;
 725 }
 726
 727 void IRCAccount::destroyed(IRCContact *contact)
 728 {
 729         kDebug(14120) ;
 730         d->contacts.removeAll(contact);
 731 }
 732
 733 void IRCAccount::receivedEvent(QEvent *event)
 734 {
 735         kDebug(14120)<<"received event";
 736         if ( event->type()==KIrc::TextEvent::Type )
 737         {
 738                 KIrc::TextEvent* txtEvent=static_cast< KIrc::TextEvent* >( event );
 739                 kDebug(14120)<<"type: " << txtEvent->eventId();
 740                 kDebug(14120)<<"from: " << txtEvent->from()->name();
 741                 kDebug(14120)<<"message:" << txtEvent->text();
 742
 743                 IRCContact *from = getContact( txtEvent->from() );
 744                 QList<Kopete::Contact*> to = getContacts( txtEvent->to() );
 745                 Kopete::Message::MessageType msgType = Kopete::Message::TypeNormal;
 746                 Kopete::Message::MessageImportance msgImportance = Kopete::Message::Low;
 747
 748                 if ( txtEvent->eventId()=="PRIVMSG" )
 749                 {
 750 //                      if ( !to->isChannel() )
 751 //                              importance = Kopete::Message::Normal;
 752                 }
 753                 else if ( txtEvent->eventId() == "DCC_ACTION" )
 754                 {
 755                         msgType = Kopete::Message::TypeAction;
 756                 }
 757 #if 0
 758                 else if ( txtEvent->eventId().startWith("ERR_") )
 759                 {
 760                         msgImportance = Kopete::Message::Highlight;
 761                 }
 762 #endif
 763                 appendMessage( from, to, txtEvent->text(), msgType );
 764         }
 765         /*
 766         QList<Kopete::Contact*> to = getContacts(txtEvent->to());
 767         //QList<IRCContact*> cc = getContacts(txtEvent->cc());
 768
 769         Kopete::Message::MessageType msgType;
 770         if ( txtEvent->eventId()=="ServerMessage" )
 771         {
 772                 msgType = Kopete::Message::TypeAction;
 773         }
 774
 775         switch ( type)
 776         {
 777         case KIrc::????: // Action
 778                 msgType = Kopete::Message::TypeAction;
 779                 break;
 780         default:
 781                 msgType = Kopete::Message::????;
 782         }*/
 783
 784         //      make a notification if needed, istead of posting the message to the toContact.
 785         //      toContact may be the wrong contact where to post in case of private user chat
 786
 787         /*
 788         foreach
 789                 postContact->appendMessage(msg);
 790 */
 791 }
 792
 793 void IRCAccount::appendMessage(IRCContact* from, QList<Contact*> to,const QString& text, Kopete::Message::MessageType type)
 794 {
 795         Kopete::Message::MessageDirection msgDirection =
 796                 from == mySelf() ? Kopete::Message::Outbound : Kopete::Message::Inbound;
 797
 798         Kopete::Message msg(from, to);
 799         msg.setDirection( msgDirection );
 800         msg.setPlainBody( text );
 801         msg.setType( type );
 802
 803         foreach( Kopete::Contact* c, to )
 804         {
 805                 if ( c==myself() ) //If we are the target of the message, append it to the chatsession of the origin
 806                         from->appendMessage( msg );
 807                 else
 808                         dynamic_cast<IRCContact*> ( c )->appendMessage( msg );
 809         }
 810 }
 811
 812 /*
 813 void IRCContact::slotUserDisconnected(const QString &user, const QString &reason)
 814 {
 815         if (d->chatSession)
 816         {
 817                 QString nickname = user.section('!', 0, 0);
 818                 Contact *c = locateUser( nickname );
 819                 if ( c )
 820                 {
 821                         d->chatSession->removeContact(c, i18n("Quit: \"%1\" ",reason), Message::RichText);
 822 //                      c->setOnlineStatus(IRCProtocol::self()->m_UserStatusOffline);
 823                 }
 824         }
 825 }
 826
 827 void IRCContact::slotNewNickChange(const QString &oldnickname, const QString &newnickname)
 828 {
 829         IRCAccount *account = ircAccount();
 830
 831         IRCContact *user = static_cast<IRCContact*>( locateUser(oldnickname) );
 832         if( user )
 833         {
 834                 user->setNickName( newnickname );
 835
 836                 //If the user is in our contact list, then change the notify list nickname
 837 //              if (!user->metaContact()->isTemporary())
 838 //              {
 839 //                      account->contactManager()->removeFromNotifyList( oldnickname );
 840 //                      account->contactManager()->addToNotifyList( newnickname );
 841 //              }
 842         }
 843 }
 844
 845 void IRCAccount::successfullyChangedNick(const QString &oldnick, const QString &newnick)
 846 {
 847 //      kDebug(14120) << "Changing nick to " << newnick;
 848 //      mNickName = newnick;
 849 //      mySelf()->setNickName( mNickName );
 850 //      d->contactManager->removeFromNotifyList( oldnick );
 851 //      d->contactManager->addToNotifyList( newnick );
 852 }
 853 */
 854 #include "ircaccount.moc"
 855