Buffer *Client::buffer(BufferInfo id) {
Buffer *buff = buffer(id.uid());
-
+
if(!buff) {
Client *client = Client::instance();
- Buffer *buff = new Buffer(id, client);
+ buff = new Buffer(id, client);
connect(buff, SIGNAL(userInput(BufferInfo, QString)),
client, SLOT(userInput(BufferInfo, QString)));
connect(buff, SIGNAL(bufferUpdated(Buffer *)),
client, SIGNAL(bufferUpdated(Buffer *)));
- connect(buff, SIGNAL(bufferDestroyed(Buffer *)),
- client, SIGNAL(bufferDestroyed(Buffer *)));
- connect(buff, SIGNAL(bufferDestroyed(Buffer *)),
- client, SLOT(removeBuffer(Buffer *)));
-
+ connect(buff, SIGNAL(destroyed()),
+ client, SLOT(bufferDestroyed()));
client->_buffers[id.uid()] = buff;
emit client->bufferUpdated(buff);
}
-
+ Q_ASSERT(buff);
return buff;
}
Client::Client(QObject *parent)
: QObject(parent),
socket(0),
- _signalProxy(new SignalProxy(SignalProxy::Client, 0, this)),
+ _signalProxy(new SignalProxy(SignalProxy::Client, this)),
mainUi(0),
_bufferModel(0),
connectedToCore(false)
}
Client::~Client() {
-// since we're now the parent of buffers this should be no longer needed
-
-// foreach(Buffer *buf, buffers.values()) delete buf; // this is done by disconnectFromCore()! FIXME?
-// Q_ASSERT(!buffers.count());
}
void Client::init() {
return instance()->connectedToCore;
}
+void Client::fakeInput(uint bufferUid, QString message) {
+ Buffer *buff = buffer(bufferUid);
+ if(!buff)
+ qWarning() << "No Buffer with uid" << bufferUid << "can't send Input" << message;
+ else
+ emit instance()->sendInput(buff->bufferInfo(), message);
+}
+
+void Client::fakeInput(BufferInfo bufferInfo, QString message) {
+ fakeInput(bufferInfo, message);
+}
+
void Client::connectToCore(const QVariantMap &conn) {
// TODO implement SSL
coreConnectionInfo = conn;
-
if(isConnected()) {
emit coreConnectionError(tr("Already connected to Core!"));
return;
connect(sock, SIGNAL(readyRead()), this, SLOT(coreHasData()));
connect(sock, SIGNAL(connected()), this, SLOT(coreSocketConnected()));
connect(sock, SIGNAL(disconnected()), this, SLOT(coreSocketDisconnected()));
- connect(signalProxy(), SIGNAL(peerDisconnected()), this, SLOT(coreSocketDisconnected()));
+ connect(signalProxy(), SIGNAL(disconnected()), this, SLOT(coreSocketDisconnected()));
//connect(sock, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(coreSocketStateChanged(QAbstractSocket::SocketState)));
connect(sock, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(coreSocketError(QAbstractSocket::SocketError)));
sock->connectToHost(conn["Host"].toString(), conn["Port"].toUInt());
}
void Client::disconnectFromCore() {
- if(clientMode == RemoteCore) {
- socket->close();
- //QAbstractSocket *sock = qobject_cast<QAbstractSocket*>(socket);
- //Q_ASSERT(sock);
- //sock->disconnectFromHost();
- } else {
- socket->close();
- //disconnectFromLocalCore();
+ socket->close();
+ if(clientMode == LocalCore) {
coreSocketDisconnected();
}
}
+void Client::setCoreConfiguration(const QVariantMap &settings) {
+ writeDataToDevice(socket, settings);
+}
+
void Client::coreSocketConnected() {
connect(this, SIGNAL(recvPartialItem(uint, uint)), this, SIGNAL(coreConnectionProgress(uint, uint)));
emit coreConnectionMsg(tr("Synchronizing to core..."));
/* Clear internal data. Hopefully nothing relies on it at this point. */
_bufferModel->clear();
- // Buffers, if deleted, send a signal that causes their removal from buffers and bufferInfos.
- // So we cannot simply go through the array in a loop (or use qDeleteAll) for deletion...
- while(!_buffers.empty()) {
- delete _buffers.take(_buffers.keys()[0]);
+ foreach(Buffer *buffer, _buffers.values()) {
+ buffer->deleteLater();
}
- Q_ASSERT(_buffers.empty());
+ _buffers.clear();
- while(!_networkInfo.empty()) {
- delete _networkInfo.take(_networkInfo.keys()[0]);
+ foreach(NetworkInfo *networkinfo, _networkInfo.values()) {
+ networkinfo->deleteLater();
}
-
+ _networkInfo.clear();
+
coreConnectionInfo.clear();
sessionData.clear();
layoutQueue.clear();
instance()->connectedToCore = true;
updateCoreConnectionProgress();
+
+ emit connected(); // FIXME EgS: moved here from updateCoreConnectionProgress
}
void Client::updateCoreConnectionProgress() {
int numChannelsWaiting = 0;
foreach(NetworkInfo *net, networkInfos()) {
- if(not net->initialized())
+ if(! net->initialized())
numNetsWaiting++;
numIrcUsers += net->ircUsers().count();
foreach(IrcUser *user, net->ircUsers()) {
- if(not user->initialized())
+ if(! user->initialized())
numIrcUsersWaiting++;
}
numChannels += net->ircChannels().count();
foreach(IrcChannel *channel, net->ircChannels()) {
- if(not channel->initialized())
+ if(! channel->initialized())
numChannelsWaiting++;
}
-
}
if(numNetsWaiting > 0) {
}
emit coreConnectionProgress(1,1);
- emit connected();
+ //emit connected(); // FIXME EgS: This caused the double backlog... but... we shouldn't be calling this whole function all the time...
+
+ foreach(NetworkInfo *net, networkInfos()) {
+ disconnect(net, 0, this, SLOT(updateCoreConnectionProgress()));
+ }
+
+ // signalProxy()->dumpProxyStats();
}
void Client::recvSessionData(const QString &key, const QVariant &data) {
QVariant item;
if(readDataFromDevice(socket, blockSize, item)) {
emit recvPartialItem(1,1);
- recvCoreState(item);
+ QVariantMap msg = item.toMap();
+ if (!msg["StartWizard"].toBool()) {
+ recvCoreState(msg["Reply"]);
+ } else {
+ qWarning("Core not configured!");
+ qDebug() << "Available storage providers: " << msg["StorageProviders"].toStringList();
+ emit showConfigWizard(msg);
+ }
blockSize = 0;
return;
}
//Buffer *b = buffer(id);
//b->setActive(true);
+ // FIXME EgS: do we really need to call updateCoreConnectionProgress whenever a new network is connected?
NetworkInfo *netinfo = new NetworkInfo(netid, signalProxy(), this);
connect(netinfo, SIGNAL(initDone()), this, SLOT(updateCoreConnectionProgress()));
connect(netinfo, SIGNAL(ircUserInitDone()), this, SLOT(updateCoreConnectionProgress()));
connect(netinfo, SIGNAL(ircChannelInitDone()), this, SLOT(updateCoreConnectionProgress()));
+ connect(netinfo, SIGNAL(destroyed()), this, SLOT(networkInfoDestroyed()));
_networkInfo[netid] = netinfo;
}
buffer(id)->updateBufferInfo(id);
}
+void Client::bufferDestroyed() {
+ Buffer *buffer = static_cast<Buffer *>(sender());
+ uint bufferUid = buffer->uid();
+ if(_buffers.contains(bufferUid))
+ _buffers.remove(bufferUid);
+}
-void Client::removeBuffer(Buffer *b) {
- _buffers.remove(b->bufferInfo().uid());
+void Client::networkInfoDestroyed() {
+ NetworkInfo *netinfo = static_cast<NetworkInfo *>(sender());
+ uint networkId = netinfo->networkId();
+ if(_networkInfo.contains(networkId))
+ _networkInfo.remove(networkId);
}
void Client::recvMessage(const Message &msg) {
projects / quassel.git / blobdiff