#include "clientignorelistmanager.h"
#include "clientuserinputhandler.h"
#include "coreaccountmodel.h"
+#include "coreconnection.h"
#include "ircchannel.h"
#include "ircuser.h"
#include "message.h"
#include <stdlib.h>
QPointer<Client> Client::instanceptr = 0;
-AccountId Client::_currentCoreAccount = 0;
/*** Initialization/destruction ***/
_messageModel(0),
_messageProcessor(0),
_coreAccountModel(new CoreAccountModel(this)),
- _connectedToCore(false),
- _syncedToCore(false),
- _internalCore(false),
+ _coreConnection(new CoreConnection(_coreAccountModel, this)),
_debugLog(&_debugLogBuffer)
{
_signalProxy->synchronize(_ircListHelper);
}
void Client::init() {
- _currentCoreAccount = 0;
_networkModel = new NetworkModel(this);
connect(this, SIGNAL(networkRemoved(NetworkId)),
_messageModel = mainUi()->createMessageModel(this);
_messageProcessor = mainUi()->createMessageProcessor(this);
_inputHandler = new ClientUserInputHandler(this);
- _coreAccountModel->load();
SignalProxy *p = signalProxy();
p->attachSlot(SIGNAL(networkCreated(NetworkId)), this, SLOT(coreNetworkCreated(NetworkId)));
p->attachSlot(SIGNAL(networkRemoved(NetworkId)), this, SLOT(coreNetworkRemoved(NetworkId)));
- connect(p, SIGNAL(disconnected()), this, SLOT(disconnectedFromCore()));
-
//connect(mainUi(), SIGNAL(connectToCore(const QVariantMap &)), this, SLOT(connectToCore(const QVariantMap &)));
connect(mainUi(), SIGNAL(disconnectFromCore()), this, SLOT(disconnectFromCore()));
connect(this, SIGNAL(connected()), mainUi(), SLOT(connectedToCore()));
// attach backlog manager
p->synchronize(backlogManager());
connect(backlogManager(), SIGNAL(messagesReceived(BufferId, int)), _messageModel, SLOT(messagesReceived(BufferId, int)));
+
+ coreAccountModel()->load();
+
+ connect(coreConnection(), SIGNAL(stateChanged(CoreConnection::ConnectionState)), SLOT(connectionStateChanged(CoreConnection::ConnectionState)));
+ coreConnection()->init();
}
/*** public static methods ***/
return instance()->_mainUi;
}
-AccountId Client::currentCoreAccount() {
- return _currentCoreAccount;
-}
-
-void Client::setCurrentCoreAccount(const AccountId &id) {
- _currentCoreAccount = id;
-}
-
bool Client::isConnected() {
- return instance()->_connectedToCore;
+ return coreConnection()->state() >= CoreConnection::Connected;
}
bool Client::isSynced() {
- return instance()->_syncedToCore;
+ return coreConnection()->state() == CoreConnection::Synchronized;
+}
+
+bool Client::internalCore() {
+ return currentCoreAccount().isInternal();
}
/*** Network handling ***/
/*** core connection stuff ***/
-void Client::setConnectedToCore(AccountId id, QIODevice *socket) {
- if(socket) { // external core
- // if the socket is an orphan, the signalProxy adopts it.
- // -> we don't need to care about it anymore
- socket->setParent(0);
- signalProxy()->addPeer(socket);
+void Client::connectionStateChanged(CoreConnection::ConnectionState state) {
+ switch(state) {
+ case CoreConnection::Disconnected:
+ setDisconnectedFromCore();
+ break;
+ case CoreConnection::Synchronized:
+ setSyncedToCore();
+ break;
+ default:
+ break;
}
- _internalCore = !socket;
- _connectedToCore = true;
- setCurrentCoreAccount(id);
}
void Client::setSyncedToCore() {
// trigger backlog request once all active bufferviews are initialized
connect(bufferViewOverlay(), SIGNAL(initDone()), this, SLOT(requestInitialBacklog()));
- _syncedToCore = true;
emit connected();
emit coreConnectionStateChanged(true);
}
}
void Client::disconnectFromCore() {
- if(!isConnected())
+ if(!coreConnection()->isConnected())
return;
- signalProxy()->removeAllPeers();
+ coreConnection()->disconnectFromCore();
}
-void Client::disconnectedFromCore() {
- _connectedToCore = false;
- _syncedToCore = false;
+void Client::setDisconnectedFromCore() {
emit disconnected();
emit coreConnectionStateChanged(false);
messageProcessor()->reset();
// Clear internal data. Hopefully nothing relies on it at this point.
- setCurrentCoreAccount(0);
if(_bufferSyncer) {
_bufferSyncer->deleteLater();
#include <QPointer>
#include "bufferinfo.h"
+#include "coreconnection.h"
#include "types.h"
class Message;
class ClientBufferViewManager;
class ClientIgnoreListManager;
class ClientIrcListHelper;
-class ClientSyncer;
class ClientUserInputHandler;
class CoreAccountModel;
+class CoreConnection;
class IrcUser;
class IrcChannel;
class NetworkConfig;
static inline ClientIgnoreListManager *ignoreListManager() { return instance()->_ignoreListManager; }
static inline CoreAccountModel *coreAccountModel() { return instance()->_coreAccountModel; }
- static AccountId currentCoreAccount();
+ static inline CoreConnection *coreConnection() { return instance()->_coreConnection; }
+ static inline CoreAccount currentCoreAccount() { return coreConnection()->currentAccount(); }
static bool isConnected();
static bool isSynced();
- static inline bool internalCore() { return instance()->_internalCore; }
+ static bool internalCore();
static void userInput(const BufferInfo &bufferInfo, const QString &message);
static void logMessage(QtMsgType type, const char *msg);
static inline const QString &debugLog() { return instance()->_debugLogBuffer; }
- static inline void registerClientSyncer(ClientSyncer *syncer) { emit instance()->newClientSyncer(syncer); }
-
signals:
void requestNetworkStates();
void requestCreateNetwork(const NetworkInfo &info, const QStringList &persistentChannels = QStringList());
void requestRemoveNetwork(NetworkId);
- void newClientSyncer(ClientSyncer *);
-
void logUpdated(const QString &msg);
public slots:
void buffersPermanentlyMerged(BufferId bufferId1, BufferId bufferId2);
private slots:
- void disconnectedFromCore();
+ void setSyncedToCore();
+ void setDisconnectedFromCore();
+ void connectionStateChanged(CoreConnection::ConnectionState);
void recvMessage(const Message &message);
void recvStatusMsg(QString network, QString message);
void coreNetworkCreated(NetworkId);
void coreNetworkRemoved(NetworkId);
- void setConnectedToCore(AccountId id, QIODevice *socket = 0);
- void setSyncedToCore();
void requestInitialBacklog();
void createDefaultBufferView();
void init();
static void addNetwork(Network *);
- static void setCurrentCoreAccount(const AccountId &);
static inline BufferSyncer *bufferSyncer() { return instance()->_bufferSyncer; }
static QPointer<Client> instanceptr;
AbstractMessageProcessor *_messageProcessor;
CoreAccountModel *_coreAccountModel;
+ CoreConnection *_coreConnection;
ClientMode clientMode;
- bool _connectedToCore, _syncedToCore;
- bool _internalCore;
-
QHash<NetworkId, Network *> _networks;
QHash<IdentityId, Identity *> _identities;
- static AccountId _currentCoreAccount;
-
QString _debugLogBuffer;
QTextStream _debugLog;
QList<QPair<BufferInfo, QString> > _userInputBuffer;
- friend class ClientSyncer;
+ friend class CoreConnection;
};
#endif
}
void CoreAccountSettings::notify(const QString &key, QObject *receiver, const char *slot) {
- ClientSettings::notify(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), receiver, slot);
+ ClientSettings::notify(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), receiver, slot);
}
QList<AccountId> CoreAccountSettings::knownAccounts() {
void CoreAccountSettings::setAccountValue(const QString &key, const QVariant &value) {
if(!Client::currentCoreAccount().isValid())
return;
- setLocalValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), value);
+ setLocalValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), value);
}
QVariant CoreAccountSettings::accountValue(const QString &key, const QVariant &def) {
if(!Client::currentCoreAccount().isValid())
return QVariant();
- return localValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().toInt()).arg(_subgroup).arg(key), def);
+ return localValue(QString("%1/%2/%3").arg(Client::currentCoreAccount().accountId().toInt()).arg(_subgroup).arg(key), def);
}
void CoreAccountSettings::setJumpKeyMap(const QHash<int, BufferId> &keyMap) {
#include "chatmonitorview.h"
#include "chatview.h"
#include "client.h"
-#include "clientsyncer.h"
#include "clientbacklogmanager.h"
#include "clientbufferviewconfig.h"
#include "clientbufferviewmanager.h"
#include "clientignorelistmanager.h"
+#include "coreconnection.h"
#include "coreinfodlg.h"
#include "contextmenuactionprovider.h"
#include "debugbufferviewoverlay.h"
} else {
startInternalCore();
}
+ Client::coreConnection()->start();
}
MainWin::~MainWin() {
connect(showStatusbar, SIGNAL(toggled(bool)), statusBar(), SLOT(setVisible(bool)));
connect(showStatusbar, SIGNAL(toggled(bool)), this, SLOT(saveStatusBarStatus(bool)));
+
+ connect(Client::coreConnection(), SIGNAL(connectionMsg(QString)), statusBar(), SLOT(showMessage(QString)));
}
void MainWin::setupHotList() {
void MainWin::loadLayout() {
QtUiSettings s;
- int accountId = Client::currentCoreAccount().toInt();
+ int accountId = Client::currentCoreAccount().accountId().toInt();
QByteArray state = s.value(QString("MainWinState-%1").arg(accountId)).toByteArray();
if(state.isEmpty()) {
// Make sure that the default bufferview is shown
void MainWin::saveLayout() {
QtUiSettings s;
- int accountId = Client::currentCoreAccount().toInt();
+ int accountId = Client::currentCoreAccount().accountId().toInt();
if(accountId > 0) s.setValue(QString("MainWinState-%1").arg(accountId) , saveState(accountId));
}
void QtUiApplication::saveState(QSessionManager & manager) {
//qDebug() << QString("saving session state to id %1").arg(manager.sessionId());
- AccountId activeCore = Client::currentCoreAccount(); // FIXME store this!
+ AccountId activeCore = Client::currentCoreAccount().accountId(); // FIXME store this!
SessionSettings s(manager.sessionId());
s.setSessionAge(0);
QtUi::mainWindow()->saveStateToSettings(s);