src/core/sessionthread.cpp

   1 /***************************************************************************
   2  *   Copyright (C) 2005-09 by the Quassel Project                          *
   3  *   devel@quassel-irc.org                                                 *
   4  *                                                                         *
   5  *   This program is free software; you can redistribute it and/or modify  *
   6  *   it under the terms of the GNU General Public License as published by  *
   7  *   the Free Software Foundation; either version 2 of the License, or     *
   8  *   (at your option) version 3.                                           *
   9  *                                                                         *
  10  *   This program is distributed in the hope that it will be useful,       *
  11  *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
  12  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the         *
  13  *   GNU General Public License for more details.                          *
  14  *                                                                         *
  15  *   You should have received a copy of the GNU General Public License     *
  16  *   along with this program; if not, write to the                         *
  17  *   Free Software Foundation, Inc.,                                       *
  18  *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.             *
  19  ***************************************************************************/
  20
  21 #include <QMutexLocker>
  22
  23 #include "sessionthread.h"
  24 #include "signalproxy.h"
  25 #include "coresession.h"
  26 #include "core.h"
  27
  28 SessionThread::SessionThread(UserId uid, bool restoreState, QObject *parent)
  29   : QThread(parent),
  30     _session(0),
  31     _user(uid),
  32     _sessionInitialized(false),
  33     _restoreState(restoreState)
  34 {
  35   connect(this, SIGNAL(initialized()), this, SLOT(setSessionInitialized()));
  36 }
  37
  38 SessionThread::~SessionThread() {
  39   if(_session) {
  40     _session->setParent(0);
  41     _session->moveToThread(thread());
  42     _session->deleteLater();
  43     _session = 0;
  44   }
  45 }
  46
  47 CoreSession *SessionThread::session() {
  48   return _session;
  49 }
  50
  51 UserId SessionThread::user() {
  52   return _user;
  53 }
  54
  55 bool SessionThread::isSessionInitialized() {
  56   return _sessionInitialized;
  57 }
  58
  59 void SessionThread::setSessionInitialized() {
  60   _sessionInitialized = true;
  61   foreach(QObject *peer, clientQueue) {
  62     addClientToSession(peer);
  63   }
  64   clientQueue.clear();
  65 }
  66
  67 void SessionThread::addClient(QObject *peer) {
  68   if(isSessionInitialized()) {
  69     addClientToSession(peer);
  70   } else {
  71     clientQueue.append(peer);
  72   }
  73 }
  74
  75 void SessionThread::addClientToSession(QObject *peer) {
  76   QIODevice *socket = qobject_cast<QIODevice *>(peer);
  77   if(socket) {
  78     addRemoteClientToSession(socket);
  79     return;
  80   }
  81
  82   SignalProxy *proxy = qobject_cast<SignalProxy *>(peer);
  83   if(proxy) {
  84     addInternalClientToSession(proxy);
  85     return;
  86   }
  87
  88   qWarning() << "SessionThread::addClient() received neither QIODevice nor SignalProxy as peer!" << peer;
  89 }
  90
  91 void SessionThread::addRemoteClientToSession(QIODevice *socket) {
  92   socket->setParent(0);
  93   socket->moveToThread(session()->thread());
  94   emit addRemoteClient(socket);
  95 }
  96
  97 void SessionThread::addInternalClientToSession(SignalProxy *proxy) {
  98   emit addInternalClient(proxy);
  99 }
 100
 101 void SessionThread::run() {
 102   _session = new CoreSession(user(), _restoreState);
 103   connect(this, SIGNAL(addRemoteClient(QIODevice *)), _session, SLOT(addClient(QIODevice *)));
 104   connect(this, SIGNAL(addInternalClient(SignalProxy *)), _session, SLOT(addClient(SignalProxy *)));
 105   connect(_session, SIGNAL(sessionState(const QVariant &)), Core::instance(), SIGNAL(sessionState(const QVariant &)));
 106   emit initialized();
 107   exec();
 108   delete _session;
 109   _session = 0;
 110 }
 111
 112 void SessionThread::stopSession() {
 113   if(_session) {
 114     connect(_session, SIGNAL(destroyed()), this, SLOT(quit()));
 115     _session->deleteLater();
 116     _session = 0;
 117   }
 118 }