removeLocalKey(QString("%1").arg(id.toInt()));
}
+void CoreAccountSettings::clearAccounts() {
+ foreach(const QString &key, localChildGroups())
+ removeLocalKey(key);
+}
/***********************************************************************************************/
// NotificationSettings:
bool autoConnectToFixedAccount();
void setAutoConnectToFixedAccount(bool);
+ void clearAccounts();
+
void storeAccountData(AccountId id, const QVariantMap &data);
QVariantMap retrieveAccountData(AccountId);
void removeAccount(AccountId);
// Make sure we have an internal account in monolithic mode
CoreAccount intAcc;
intAcc.setInternal(true);
- insertAccount(intAcc);
+ intAcc.setAccountName(tr("Internal Core"));
+ _internalAccount = createOrUpdateAccount(intAcc);
}
}
void CoreAccountModel::save() {
CoreAccountSettings s;
+ s.clearAccounts();
foreach(const CoreAccount &acc, accounts()) {
- if(acc.isInternal())
- continue; // FIXME don't save internal for now - but make sure to handle this correctly once mono can do remotes!
- // we'll have to ensure that autoConnectAccount works with internal as well then
- QVariantMap map = acc.toVariantMap(true); // TODO Hook into kwallet/password saving stuff
+ QVariantMap map = acc.toVariantMap(false); // TODO Hook into kwallet/password saving stuff
s.storeAccountData(acc.accountId(), map);
}
}
void CoreAccountModel::insertAccount(const CoreAccount &acc) {
if(acc.isInternal()) {
- if(Quassel::runMode() == Quassel::Monolithic)
- return;
if(internalAccount().isValid()) {
qWarning() << "Trying to insert a second internal account in CoreAccountModel, ignoring";
return;
_netsToSync.clear();
_numNetsToSync = 0;
- _state = Disconnected;
setProgressMaximum(-1); // disable
+ setState(Disconnected);
emit connectionMsg(tr("Disconnected from core."));
}
if(state != _state) {
_state = state;
emit stateChanged(state);
+ if(state == Disconnected)
+ emit disconnected();
}
}
}
void CoreConnection::coreSocketDisconnected() {
- setState(Disconnected);
emit disconnected();
resetConnection();
// FIXME handle disconnects gracefully
CoreAccountSettings s;
- if(!accId.isValid()) {
- // check our settings and figure out what to do
- if(!s.autoConnectOnStartup())
- return false;
- if(s.autoConnectToFixedAccount())
- accId = s.autoConnectAccount();
- else
- accId = s.lastAccount();
- if(!accId.isValid())
+ // FIXME: Don't force connection to internal core in mono client
+ if(Quassel::runMode() == Quassel::Monolithic) {
+ _account = accountModel()->account(accountModel()->internalAccount());
+ Q_ASSERT(_account.isValid());
+ } else {
+ if(!accId.isValid()) {
+ // check our settings and figure out what to do
+ if(!s.autoConnectOnStartup())
+ return false;
+ if(s.autoConnectToFixedAccount())
+ accId = s.autoConnectAccount();
+ else
+ accId = s.lastAccount();
+ if(!accId.isValid())
+ return false;
+ }
+ _account = accountModel()->account(accId);
+ if(!_account.accountId().isValid()) {
return false;
- }
- _account = accountModel()->account(accId);
- if(!_account.accountId().isValid()) {
- return false;
+ }
+ if(Quassel::runMode() != Quassel::Monolithic) {
+ if(_account.isInternal())
+ return false;
+ }
}
s.setLastAccount(accId);
void CoreConnection::connectToCurrentAccount() {
resetConnection();
+ if(currentAccount().isInternal()) {
+ if(Quassel::runMode() != Quassel::Monolithic) {
+ qWarning() << "Cannot connect to internal core in client-only mode!";
+ return;
+ }
+ emit startInternalCore();
+ emit connectToInternalCore(Client::instance()->signalProxy());
+ return;
+ }
+
Q_ASSERT(!_socket);
#ifdef HAVE_SSL
QSslSocket *sock = new QSslSocket(Client::instance());
disconnect(_socket, SIGNAL(readyRead()), this, 0);
disconnect(_socket, SIGNAL(connected()), this, 0);
- //Client::instance()->setConnectedToCore(currentAccount().accountId(), _socket);
syncToCore(state);
}
+void CoreConnection::internalSessionStateReceived(const QVariant &packedState) {
+ updateProgress(100, 100);
+
+ setState(Synchronizing);
+ syncToCore(packedState.toMap());
+}
+
void CoreConnection::syncToCore(const QVariantMap &sessionState) {
setProgressText(tr("Receiving network states"));
updateProgress(0, 100);
class CoreAccountModel;
class Network;
+class SignalProxy;
class CoreConnection : public QObject {
Q_OBJECT
void progressTextChanged(const QString &);
void startCoreSetup(const QVariantList &);
+ void startInternalCore();
+ void connectToInternalCore(SignalProxy *proxy);
// This signal MUST be handled synchronously!
void userAuthenticationRequired(CoreAccount *, bool *valid, const QString &errorMessage = QString());
void checkSyncState();
void syncToCore(const QVariantMap &sessionState);
- //void internalSessionStateReceived(const QVariant &packedState);
+ void internalSessionStateReceived(const QVariant &packedState);
void sessionStateReceived(const QVariantMap &state);
void setWarningsHandler(const char *slot);
if(!Quassel::init()) // parse args
return false;
+ connect(Client::coreConnection(), SIGNAL(startInternalCore()), SLOT(startInternalCore()));
+
if(isOptionSet("port")) {
- _internal->init();
- _internalInitDone = true;
+ startInternalCore();
}
return QtUiApplication::init();
_internalInitDone = true;
}
Core *core = Core::instance();
- //connect(syncer, SIGNAL(connectToInternalCore(SignalProxy *)), core, SLOT(setupInternalClientSession(SignalProxy *)));
- //connect(core, SIGNAL(sessionState(const QVariant &)), syncer, SLOT(internalSessionStateReceived(const QVariant &)));
+ CoreConnection *connection = Client::coreConnection();
+ connect(connection, SIGNAL(connectToInternalCore(SignalProxy *)), core, SLOT(setupInternalClientSession(SignalProxy *)));
+ connect(core, SIGNAL(sessionState(const QVariant &)), connection, SLOT(internalSessionStateReceived(const QVariant &)));
}
void CoreAccountSettingsPage::load() {
_model->update(Client::coreAccountModel());
-
SettingsPage::load();
+
+ CoreAccountSettings s;
+
+ if(Quassel::runMode() != Quassel::Monolithic) {
+ // make sure we don't have selected the internal account as autoconnect account
+
+ if(s.autoConnectOnStartup() && s.autoConnectToFixedAccount()) {
+ CoreAccount acc = _model->account(s.autoConnectAccount());
+ if(acc.isInternal())
+ ui.autoConnectOnStartup->setChecked(false);
+ }
+ }
ui.accountView->setCurrentIndex(model()->index(0, 0));
ui.accountView->selectionModel()->select(model()->index(0, 0), QItemSelectionModel::Select);
+
+ QModelIndex idx = model()->accountIndex(s.autoConnectAccount());
+ ui.autoConnectAccount->setCurrentIndex(idx.isValid() ? idx.row() : 0);
setWidgetStates();
}
AccountId id = s.autoConnectAccount();
if(!id.isValid())
return QVariant();
- ui.autoConnectAccount->setCurrentIndex(model()->accountIndex(id).row());
return id.toInt();
}
return SettingsPage::loadAutoWidgetValue(widgetName);
}
void CoreAccountSettingsPage::setWidgetStates() {
- bool selected = ui.accountView->selectionModel()->selectedIndexes().count();
+ AccountId accId = selectedAccount();
+ bool editable = accId.isValid() && accId != model()->internalAccount();
- ui.editAccountButton->setEnabled(selected);
- ui.deleteAccountButton->setEnabled(selected);
+ ui.editAccountButton->setEnabled(editable);
+ ui.deleteAccountButton->setEnabled(editable);
}
void CoreAccountSettingsPage::widgetHasChanged() {