+class ProcessMessagesEvent : public QEvent
+{
+public:
+ ProcessMessagesEvent() : QEvent(QEvent::User) {}
+};
+
+
+CoreSession::CoreSession(UserId uid, bool restoreState, QObject *parent)
+ : QObject(parent),
+ _user(uid),
+ _signalProxy(new SignalProxy(SignalProxy::Server, this)),
+ _aliasManager(this),
+ _bufferSyncer(new CoreBufferSyncer(this)),
+ _backlogManager(new CoreBacklogManager(this)),
+ _bufferViewManager(new CoreBufferViewManager(_signalProxy, this)),
+ _ircListHelper(new CoreIrcListHelper(this)),
+ _networkConfig(new CoreNetworkConfig("GlobalNetworkConfig", this)),
+ _coreInfo(this),
+ _transferManager(new CoreTransferManager(this)),
+ _eventManager(new CoreEventManager(this)),
+ _eventStringifier(new EventStringifier(this)),
+ _sessionEventProcessor(new CoreSessionEventProcessor(this)),
+ _ctcpParser(new CtcpParser(this)),
+ _ircParser(new IrcParser(this)),
+ scriptEngine(new QScriptEngine(this)),
+ _processMessages(false),
+ _ignoreListManager(this)
+{
+ SignalProxy *p = signalProxy();
+ p->setHeartBeatInterval(30);
+ p->setMaxHeartBeatCount(60); // 30 mins until we throw a dead socket out
+
+ connect(p, SIGNAL(peerRemoved(Peer*)), SLOT(removeClient(Peer*)));
+
+ connect(p, SIGNAL(connected()), SLOT(clientsConnected()));
+ connect(p, SIGNAL(disconnected()), SLOT(clientsDisconnected()));
+
+ p->attachSlot(SIGNAL(sendInput(BufferInfo, QString)), this, SLOT(msgFromClient(BufferInfo, QString)));
+ p->attachSignal(this, SIGNAL(displayMsg(Message)));
+ p->attachSignal(this, SIGNAL(displayStatusMsg(QString, QString)));
+
+ p->attachSignal(this, SIGNAL(identityCreated(const Identity &)));
+ p->attachSignal(this, SIGNAL(identityRemoved(IdentityId)));
+ p->attachSlot(SIGNAL(createIdentity(const Identity &, const QVariantMap &)), this, SLOT(createIdentity(const Identity &, const QVariantMap &)));
+ p->attachSlot(SIGNAL(removeIdentity(IdentityId)), this, SLOT(removeIdentity(IdentityId)));
+
+ p->attachSignal(this, SIGNAL(networkCreated(NetworkId)));
+ p->attachSignal(this, SIGNAL(networkRemoved(NetworkId)));
+ p->attachSlot(SIGNAL(createNetwork(const NetworkInfo &, const QStringList &)), this, SLOT(createNetwork(const NetworkInfo &, const QStringList &)));
+ p->attachSlot(SIGNAL(removeNetwork(NetworkId)), this, SLOT(removeNetwork(NetworkId)));
+
+ p->attachSlot(SIGNAL(changePassword(PeerPtr,QString,QString,QString)), this, SLOT(changePassword(PeerPtr,QString,QString,QString)));
+ p->attachSignal(this, SIGNAL(passwordChanged(PeerPtr,bool)));
+
+ loadSettings();
+ initScriptEngine();
+
+ eventManager()->registerObject(ircParser(), EventManager::NormalPriority);
+ eventManager()->registerObject(sessionEventProcessor(), EventManager::HighPriority); // needs to process events *before* the stringifier!
+ eventManager()->registerObject(ctcpParser(), EventManager::NormalPriority);
+ eventManager()->registerObject(eventStringifier(), EventManager::NormalPriority);
+ eventManager()->registerObject(this, EventManager::LowPriority); // for sending MessageEvents to the client
+ // some events need to be handled after msg generation
+ eventManager()->registerObject(sessionEventProcessor(), EventManager::LowPriority, "lateProcess");
+ eventManager()->registerObject(ctcpParser(), EventManager::LowPriority, "send");
+
+ // periodically save our session state
+ connect(&(Core::instance()->syncTimer()), SIGNAL(timeout()), this, SLOT(saveSessionState()));
+
+ p->synchronize(_bufferSyncer);
+ p->synchronize(&aliasManager());
+ p->synchronize(_backlogManager);
+ p->synchronize(ircListHelper());
+ p->synchronize(networkConfig());
+ p->synchronize(&_coreInfo);
+ p->synchronize(&_ignoreListManager);
+ p->synchronize(transferManager());
+ // Restore session state
+ if (restoreState)
+ restoreSessionState();
+
+ emit initialized();
+}
+
+
+CoreSession::~CoreSession()
+{
+ saveSessionState();
+ foreach(CoreNetwork *net, _networks.values()) {
+ delete net;
+ }
+}
+
+
+CoreNetwork *CoreSession::network(NetworkId id) const
+{
+ if (_networks.contains(id)) return _networks[id];
+ return 0;
+}
+
+
+CoreIdentity *CoreSession::identity(IdentityId id) const
+{
+ if (_identities.contains(id)) return _identities[id];
+ return 0;
+}
+
+
+void CoreSession::loadSettings()
+{
+ CoreUserSettings s(user());
+
+ // migrate to db
+ QList<IdentityId> ids = s.identityIds();
+ QList<NetworkInfo> networkInfos = Core::networks(user());
+ foreach(IdentityId id, ids) {
+ CoreIdentity identity(s.identity(id));
+ IdentityId newId = Core::createIdentity(user(), identity);
+ QList<NetworkInfo>::iterator networkIter = networkInfos.begin();
+ while (networkIter != networkInfos.end()) {
+ if (networkIter->identity == id) {
+ networkIter->identity = newId;
+ Core::updateNetwork(user(), *networkIter);
+ networkIter = networkInfos.erase(networkIter);
+ }
+ else {
+ networkIter++;
+ }
+ }
+ s.removeIdentity(id);
+ }
+ // end of migration
+
+ foreach(CoreIdentity identity, Core::identities(user())) {
+ createIdentity(identity);
+ }
+
+ foreach(NetworkInfo info, Core::networks(user())) {
+ createNetwork(info);
+ }
+}
+
+
+void CoreSession::saveSessionState() const
+{
+ _bufferSyncer->storeDirtyIds();
+ _bufferViewManager->saveBufferViews();
+ _networkConfig->save();
+}