void ProjectManager::loadProjectState( int argc, char **argv )
{
QSettings s;
s.beginGroup("LoadedProjects");
int projCount = s.beginReadArray("Projects");
for(int p =0; p < projCount; p++)
{
s.setArrayIndex(p);
QString projName = s.value("Name").toString();
ProjectNode * projNode = new ProjectNode(projName);
rootNode->addChild(projNode);
QStringList l;
for( int i( 0 ); i < argc; ++i )
l << argv[i];
projNode->setCommandLine( l );
int size = s.beginReadArray("files");
for(int i=0; i < size; i++)
{
s.setArrayIndex(i);
QString file( s.value("name").toString() );
projNode->addFile( file );
}
s.endArray();
}
s.endArray();
s.endGroup();
}
void mos_config_load(QMap<QString, color_range> &ranges, QMap<QString, QList<QRgb> > &palettes)
{
QSettings s;
const int nranges = s.beginReadArray("color_ranges");
for(int i = 0; i < nranges; ++i) {
s.setArrayIndex(i);
const color_range r(
s.value("avg").toUInt(),
s.value("max").toUInt(),
s.value("min").toUInt());
ranges.insert(s.value("id").toString(), r);
}
s.endArray();
const int npals = s.beginReadArray("palettes");
for(int i = 0; i < npals; ++i) {
s.setArrayIndex(i);
const QStringList vals = s.value("values").toString().split(",", QString::SkipEmptyParts);
QList<QRgb> rgblist;
foreach(const QString& v, vals) {
rgblist.push_back(v.toUInt());
}
palettes.insert(s.value("id").toString(), rgblist);
}
void RadioManagerOld::readParameterConfig( int frequencySection, int * pRssi, int * pSnr )
{
QSettings *ConfigIni = new QSettings(RADIO_CONFIG_FILE_PATHNAME,QSettings::IniFormat,0);
if ( NULL == ConfigIni )
{
return;
}
int size = 0;
int ret = 0;
if ( RM_FREQ_SECTION_FM == frequencySection )
{
size = ConfigIni->beginReadArray("fm_config");
}
else
{
size = ConfigIni->beginReadArray("am_config");
}
ret = ConfigIni->value("rssi", 0 ).toInt();
if ( 0 != ret )
{
*pRssi = ret;
}
ret = ConfigIni->value("snr", 0 ).toInt();
if ( 0 != ret )
{
*pSnr = ret;
}
ConfigIni->endArray();
}
Settings::Settings() {
QSettings settings;
this->setFontSize(settings.value(SETTINGS_FONT_SIZE, FONT_SIZE_DEFAULT).toInt());
this->setFontFamily(settings.value(SETTINGS_FONT_FAMILY, QFontDatabase().families()[0]).toString());
this->setShouldDisplayLongerWordsLonger(settings.value(SETTINGS_DISPLAY_LONGER_WORDS_LONGER, DISPLAY_LONGER_WORDS_LONGER_DEFAULT).toBool());
this->setWordLength(settings.value(SETTINGS_WORD_LENGTH, WORD_LENGTH_DEFAULT).toInt());
this->setShouldGroupNumbers(settings.value(SETTINGS_NUMBER_GROUPING, NUMER_GROUPING_DEFAULT).toBool());
this->setShouldStallAtIndentions(settings.value(SETTINGS_STALL_AT_INDENTIONS, STALL_AT_INDENTIONS_DEFAULT).toBool());
this->setNumberOfWords(settings.value(SETTINGS_NUMBER_OF_WORDS, NUMBER_OF_WORDS).toInt());
this->setWordsPerMinute(settings.value(SETTINGS_WORDS_PER_MINUTE, WORDS_PER_MINUTE).toInt());
this->setTextBackgroundColor(settings.value(SETTINGS_TEXT_BACKGROUND_COLOR, TEXT_BACKGROUND_COLOR_DEFAULT).value<QColor>());
this->setTextColor(settings.value(SETTINGS_TEXT_COLOR, TEXT_COLOR_DEFAULT).value<QColor>());
this->setLinesColor(settings.value(SETTINGS_LINES_COLOR, LINES_COLOR_DEFAULT).value<QColor>());
mHTTPNetworkProxy.setType(QNetworkProxy::HttpProxy);
mHTTPNetworkProxy.setHostName(settings.value(SETTINGS_HTTP_NETWORK_PROXY_SERVER, HTTP_NETWORK_PROXY_SERVER_DEFAULT).value<QString>());
mHTTPNetworkProxy.setPort(settings.value(SETTINGS_HTTP_NETWORK_PROXY_PORT, HTTP_NETWORK_PROXY_PORT_DEFAULT).value<quint16>());
this->setHTTPNetworkProxyType(settings.value(SETTINGS_HTTP_NETWORK_PROXY_TYPE, HTTP_NETWORK_PROXY_TYPE_DEFAULT).value<int>());
this->setRSSRefreshRate(settings.value(SETTINGS_RSS_REFRESH_RATE, RSS_REFRESH_RATE_DEFAULT).value<int>());
mAutoUpdate = settings.value(SETTINGS_AUTO_UPDATE, 1).value<int>();
mMainWindowGeometry = settings.value(SETTINGS_MAIN_WINDOW_GEOMETRY, QByteArray()).value<QByteArray>();
mRSSWebViewDialogGeometry = settings.value(SETTINGS_RSS_WEB_VIEW_DIALOG_GEOMETRY, QByteArray()).value<QByteArray>();
int size = settings.beginReadArray(SETTINGS_WORDS);
for (int i = 0; i < size; i++) {
settings.setArrayIndex(i);
Word word;
word.word = settings.value(SETTINGS_VALUE).toString();
word.stopWord = settings.value(SETTINGS_STOP_WORD).toBool();
word.breakWord = settings.value(SETTINGS_BREAK_WORD).toBool();
word.delayWord = qMax(0, settings.value(SETTINGS_DELAY_WORD, 0).toInt());
this->appendWord(word);
}
settings.endArray();
size = settings.beginReadArray(SETTINGS_RSS_SITES);
for (int i = 0; i < size; i++) {
settings.setArrayIndex(i);
QUrl url = settings.value(SETTINGS_RSS_SITE).value<QUrl>();
if (url.isValid() && !mRSSSites.contains(url)) mRSSSites.append(url);
}
settings.endArray();
mChangedRSSRefreshRate = mChangedHTTPNetworkProxy = true;
}
void MainWindow::reconfigure() {
QSettings settings;
try{
ChaosMetadataServiceClient::getInstance()->clearServerList();
settings.beginGroup(PREFERENCE_NETWORK_GROUP_NAME);
const QString current_setting = settings.value("active_configuration").toString();
if(settings.childGroups().contains(current_setting)) {
settings.beginGroup(current_setting);
int mds_address_size = settings.beginReadArray("mds_address");
for (int i = 0; i < mds_address_size; ++i) {
settings.setArrayIndex(i);
ChaosMetadataServiceClient::getInstance()->addServerAddress(settings.value("address").toString().toStdString());
}
settings.endArray();
settings.endGroup();
//check if monitoring is started
if(mds_address_size &&
!ChaosMetadataServiceClient::getInstance()->monitoringIsStarted()) {
//try to start it
on_actionEnable_Monitoring_triggered();
}
ChaosMetadataServiceClient::getInstance()->reconfigureMonitor();
} else {
//mds are not configured so we need to configure it
on_actionPreferences_triggered();
}
}catch(...) {
}
}
void MainWindow::endGame()
{
isSetUp = false;
emit updateNeeded();
boardUi->endGame();
emit gameEvent(tr("Game ended."));
QSettings settings;
settings.beginGroup("games");
int size = settings.beginReadArray("game");
settings.endArray();
settings.beginWriteArray("game");
settings.setArrayIndex(size-1);
settings.beginWriteArray("result");
int playerCount = game->getPlayerCount();
for (int i = 0; i < playerCount; ++i)
{
settings.setArrayIndex(i);
settings.setValue("score", game->getPlayerScore(i));
}
settings.endArray();
settings.endArray();
settings.endGroup();
}
bool CustCmdDlg::loadSettings ()
{
bool b_ret = false;
for (;;) {
QSettings stg;
int array_index = 0;
int i_max = stg.beginReadArray (STG_CUSTOM_COMMANDS);
for (int i = 0; i < i_max; ++i) {
stg.setArrayIndex (array_index++);
QStringList sl;
sl << stg.value (STG_CUSTOM_CM_NAME).toString ()
<< stg.value (STG_CUSTOM_CM_PROG).toString ()
<< stg.value (STG_CUSTOM_CM_ARGS).toString ()
<< stg.value (STG_CUSTOM_CM_CRTDIR).toString ();
QTreeWidgetItem *current = new QTreeWidgetItem (sl);
current->setData (0, Qt::UserRole + 5, true);
ui->treeWidget->insertTopLevelItem (i, current);
}
stg.endArray ();
b_ret = true;
break;
}
return b_ret;
}
void AccountManager::load()
{
QSettings settings;
int size = settings.beginReadArray("accounts/list/");
for(int i=0; i<size; ++i) {
settings.setArrayIndex(i);
QString type = settings.value("type").toString();
ProtocolPlugin *plugin = m_app->protocolPlugin(type);
Account *account = plugin->createAccount();
account->setId(settings.value("id").toString());
account->load();
account->initAccount();
addAccount(account);
}
settings.endArray();
}
void
PitchBendSequenceDialog::restorePreset(int preset)
{
/* A preset is stored in one element in an array. There is a
different array for each controller or pitchbend. */
QSettings settings;
settings.beginGroup(PitchBendSequenceConfigGroup);
settings.beginReadArray(m_control.getName().data());
settings.setArrayIndex(preset);
m_prebendValue->setValue(settings.value("pre_bend_value", 0).toFloat());
m_prebendDuration->setValue(settings.value("pre_bend_duration_value", 0).toFloat());
m_sequenceRampDuration->setValue(settings.value("sequence_ramp_duration", 100).toFloat());
m_sequenceEndValue->setValue(settings.value("sequence_ramp_end_value", 0).toFloat());
m_vibratoStartAmplitude->setValue(settings.value("vibrato_start_amplitude", 0).toFloat());
m_vibratoEndAmplitude->setValue(settings.value("vibrato_end_amplitude", 0).toFloat());
m_vibratoFrequency->setValue(settings.value("vibrato_frequency", 10).toFloat());
m_resolution->setValue(settings.value("step_count", 40).toInt());
m_stepSize->setValue(settings.value("step_size", 2.0).toFloat());
setRampMode
(RampMode
(settings.value("ramp_mode", Logarithmic).toInt()));
setStepSizeCalculation
(StepSizeCalculation
(settings.value("step_size_calculation", StepSizeDirect).toInt()));
settings.endArray();
settings.endGroup();
}
NodeNameDialog::NodeNameDialog(QWidget *parent) :
QDialog(parent),
ui(new Ui::NodeNameDialog)
{
ui->setupUi(this);
mNodeList.clear();
QSettings Settings;
int HistoryCount = Settings.beginReadArray( "node-history" );
for( int i = 0 ; i < qMin( NODE_HISTORY_COUNT, HistoryCount ) ; i++ )
{
Settings.setArrayIndex( i );
QUuid NodeUuid = fugio::utils::string2uuid( Settings.value( "uuid" ).toString() );
mNodeList << NodeUuid;
}
Settings.endArray();
while( mNodeList.size() < NODE_HISTORY_COUNT )
{
mNodeList << QUuid();
}
setListHistory();
}
void StoreStreamDlg::loadCurrentValues()
{
QSettings *settings = SyntroUtils::getSettings();
settings->beginReadArray(SYNTRODB_PARAMS_STREAM_SOURCES);
settings->setArrayIndex(m_index);
m_streamName->setText(settings->value(SYNTRODB_PARAMS_STREAM_SOURCE).toString());
if (settings->value(SYNTRODB_PARAMS_FORMAT, SYNTRO_RECORD_STORE_FORMAT_RAW).toString() == SYNTRO_RECORD_STORE_FORMAT_RAW)
m_formatCombo->setCurrentIndex(1);
else // if (settings->value(SYNTRODB_PARAMS_FORMAT) == SYNTRO_RECORD_STORE_FORMAT_SRF)
m_formatCombo->setCurrentIndex(0);
if (settings->value(SYNTRODB_PARAMS_CREATE_SUBFOLDER) == SYNTRO_PARAMS_TRUE)
m_subFolderCheck->setCheckState(Qt::Checked);
else
m_subFolderCheck->setCheckState(Qt::Unchecked);
// Rotation policy
QString rotate = settings->value(SYNTRODB_PARAMS_ROTATION_POLICY).toString();
if (rotate == SYNTRODB_PARAMS_ROTATION_POLICY_TIME)
m_rotationPolicy->setCurrentIndex(0);
else if (rotate == SYNTRODB_PARAMS_ROTATION_POLICY_SIZE)
m_rotationPolicy->setCurrentIndex(1);
else
m_rotationPolicy->setCurrentIndex(2);
m_rotationTimeUnits->setCurrentIndex(0);
if (settings->value(SYNTRODB_PARAMS_ROTATION_TIME_UNITS).toString() == SYNTRODB_PARAMS_ROTATION_TIME_UNITS_HOURS)
m_rotationTimeUnits->setCurrentIndex(1);
if (settings->value(SYNTRODB_PARAMS_ROTATION_TIME_UNITS).toString() == SYNTRODB_PARAMS_ROTATION_TIME_UNITS_DAYS)
m_rotationTimeUnits->setCurrentIndex(2);
m_rotationTime->setText(settings->value(SYNTRODB_PARAMS_ROTATION_TIME).toString());
m_rotationSize->setText(settings->value(SYNTRODB_PARAMS_ROTATION_SIZE).toString());
// Deletion policy
QString deletion = settings->value(SYNTRODB_PARAMS_DELETION_POLICY).toString();
if (deletion == SYNTRODB_PARAMS_DELETION_POLICY_TIME)
m_deletionPolicy->setCurrentIndex(0);
else if (deletion == SYNTRODB_PARAMS_DELETION_POLICY_COUNT)
m_deletionPolicy->setCurrentIndex(1);
else
m_deletionPolicy->setCurrentIndex(2);
if (settings->value(SYNTRODB_PARAMS_DELETION_TIME_UNITS).toString() == SYNTRODB_PARAMS_DELETION_TIME_UNITS_HOURS)
m_deletionTimeUnits->setCurrentIndex(1);
else
m_deletionTimeUnits->setCurrentIndex(0);
m_deletionTime->setText(settings->value(SYNTRODB_PARAMS_DELETION_TIME).toString());
m_deletionSize->setText(settings->value(SYNTRODB_PARAMS_DELETION_COUNT).toString());
settings->endArray();
delete settings;
}
void PlotZoomer::loadSettings(QSettings &settings)
{
settings.beginGroup("zoom");
int zoomMode = settings.value("mode", int(PlotZoomer::ZoomBoth)).toInt();
setZoomMode(PlotZoomer::ZoomMode(zoomMode));
int zoomIndex = settings.value("index", -1).toInt();
int stackSize = settings.beginReadArray("stack");
QStack<QRectF> stack;
stack.resize(stackSize);
for (int i = 0; i < stackSize; ++i)
{
settings.setArrayIndex(i);
read(settings, stack[i]);
}
settings.endArray();
setZoomStack(stack, zoomIndex);
if (stackSize <= 1)
{
zoomToFit(true);
}
settings.endGroup();
}
void LJBloggingPlatform::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () +
"_Blogique_Metida_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("SerializedData").toByteArray ();
LJAccount *acc = LJAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "unserializable acount"
<< i;
continue;
}
LJAccounts_ << acc;
emit accountAdded (acc);
acc->Init ();
Core::Instance ().GetLocalStorage ()->AddAccount (acc->GetAccountID ());
}
settings.endArray ();
}
void IrcProtocol::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Azoth_Acetamide_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("SerializedData").toByteArray ();
IrcAccount *acc = IrcAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "unserializable acount"
<< i;
continue;
}
connect (acc,
SIGNAL (accountSettingsChanged ()),
this,
SLOT (saveAccounts ()));
if (acc->GetAccountName () == "DefaultIrcAccount")
Core::Instance ().SetDefaultIrcAcoount (acc);
else
Accounts_ << acc;
emit accountAdded (acc);
}
}
void LocalBloggingPlatform::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () +
"_Blogique_Hestia_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings.value ("SerializedData").toByteArray ();
LocalBlogAccount *acc = LocalBlogAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "unserializable acount"
<< i;
continue;
}
Accounts_ << acc;
if (!acc->IsValid ())
Core::Instance ().SendEntity (Util::MakeNotification ("Blogique",
tr ("You have invalid account data."),
PWarning_));
emit accountAdded (acc);
acc->Init ();
}
settings.endArray ();
}
void SessionInfo::retrieveFromStorage( QSettings& settings )
{
LOG(logDEBUG) << "SessionInfo::retrieveFromStorage";
geometry_ = settings.value("geometry").toByteArray();
if ( settings.contains( "OpenFiles/version" ) ) {
openFiles_.clear();
// Unserialise the "new style" stored history
settings.beginGroup( "OpenFiles" );
if ( settings.value( "version" ) == OPENFILES_VERSION ) {
int size = settings.beginReadArray( "openFiles" );
LOG(logDEBUG) << "SessionInfo: " << size << " files.";
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
QString file_name =
settings.value( "fileName" ).toString();
uint64_t top_line = settings.value( "topLine" ).toInt();
QString view_context =
settings.value( "viewContext" ).toString();
openFiles_.emplace_back( file_name, top_line, view_context );
}
settings.endArray();
}
else {
LOG(logERROR) << "Unknown version of OpenFiles, ignoring it...";
}
settings.endGroup();
}
}
void SenderIdentitiesModel::loadFromSettings(QSettings &s)
{
beginResetModel();
m_identities.clear();
int num = s.beginReadArray(Common::SettingsNames::identitiesKey);
if (num == 0) {
s.endArray();
// Load from the older format where only one identity was supported
QString realName = s.value(Common::SettingsNames::obsRealNameKey).toString();
QString email = s.value(Common::SettingsNames::obsAddressKey).toString();
if (!realName.isEmpty() || !email.isEmpty()) {
// Don't add empty identities
m_identities << ItemSenderIdentity(realName, email,
// Old format had no support for signatures/organizations
QString(), QString());
}
// Thrash the old settings, replace with the new format
saveToSettings(s);
} else {
// The new format with multiple identities
for (int i = 0; i < num; ++i) {
s.setArrayIndex(i);
m_identities << ItemSenderIdentity(
s.value(Common::SettingsNames::realNameKey).toString(),
s.value(Common::SettingsNames::addressKey).toString(),
s.value(Common::SettingsNames::organisationKey).toString(),
s.value(Common::SettingsNames::signatureKey).toString());
}
s.endArray();
}
endResetModel();
}
QSettings *loadSettings(QStringList arglist)
{
QSettings *settings = loadStandardSettings("MotionSensorViewer", arglist);
if (!settings->contains(ZIGBEE_MULTICAST_SERVICE))
settings->setValue(ZIGBEE_MULTICAST_SERVICE, "zbmc");
if (!settings->contains(ZIGBEE_E2E_SERVICE))
settings->setValue(ZIGBEE_E2E_SERVICE, "zbe2e");
int count = settings->beginReadArray(MOTION_SENSORS);
settings->endArray();
if (count == 0) {
// setup some examples
settings->beginWriteArray(MOTION_SENSORS);
settings->setArrayIndex(0);
settings->setValue(SENSOR_ZB_ADDRESS, "0x0013a200409879e4");
settings->setValue(SENSOR_LOCATION, "Garage");
settings->setArrayIndex(1);
settings->setValue(SENSOR_ZB_ADDRESS, "0x0013a200408d4b96");
settings->setValue(SENSOR_LOCATION, "Office");
settings->setArrayIndex(2);
settings->setValue(SENSOR_ZB_ADDRESS, "0x0013a2004081abe3");
settings->setValue(SENSOR_LOCATION, "Back Deck");
settings->endArray();
}
return settings;
}
void Configuration::_readPresenceRuleList(QSettings &s, QList<PresenceRule *> &rules)
{
int size = s.beginReadArray("presenceRules");
for (int row = 0; row < size; row++) {
s.setArrayIndex(row);
if (!s.value("accountId").canConvert<Accounts::AccountId>()
|| !s.value("action").canConvert<int>()) {
qWarning() << "Skipping invalid configuration entry.";
continue;
}
Accounts::AccountId accountId
= s.value("accountId").value<Accounts::AccountId>();
QString serviceName
= s.value("serviceName").toString();
PresenceRule::Action action
= (PresenceRule::Action) s.value("action").toInt();
QString statusMessage
= s.value("statusMessage").toString();
rules.append(new PresenceRule(accountId, serviceName, action, statusMessage));
}
s.endArray();
}
bool RecentFiles::empty() {
QSettings settings;
const int count = settings.beginReadArray(recentFilesKey());
settings.endArray();
return count > 0;
}
void DeliciousService::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () +
"_Poshuku_OnlineBookmarks_Delicious_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
QByteArray data = settings
.value ("SerializedData").toByteArray ();
DeliciousAccount *acc = DeliciousAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "undeserializable account"
<< i;
continue;
}
Accounts_ << acc;
}
if (!Accounts_.isEmpty ())
{
QObjectList list;
Q_FOREACH (DeliciousAccount *acc, Accounts_)
list << acc->GetQObject ();
emit accountAdded (list);
}
}
void MRIMProtocol::RestoreAccounts ()
{
QSettings settings (QSettings::IniFormat, QSettings::UserScope,
QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Azoth_Vader_Accounts");
int size = settings.beginReadArray ("Accounts");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
const QByteArray& data = settings.value ("SerializedData").toByteArray ();
MRIMAccount *acc = MRIMAccount::Deserialize (data, this);
if (!acc)
{
qWarning () << Q_FUNC_INFO
<< "undeserializable acount"
<< i;
continue;
}
connect (acc,
SIGNAL (accountSettingsChanged ()),
this,
SLOT (saveAccounts ()));
Accounts_ << acc;
emit accountAdded (acc);
}
settings.endArray ();
}
void ShowConfigDialog::reloadSettings ()
{
QSettings settings (QCoreApplication::organizationName (),
QCoreApplication::applicationName () + "_Sidebar");
settings.beginGroup (Context_);
const int size = settings.beginReadArray ("Actions");
for (int i = 0; i < size; ++i)
{
settings.setArrayIndex (i);
const auto& icon = settings.value ("Icon").value<QIcon> ();
QStandardItem *item = new QStandardItem (icon,
settings.value ("Text").toString ());
item->setCheckState (settings.value ("Enabled").toBool () ?
Qt::Checked :
Qt::Unchecked);
item->setToolTip (settings.value ("Tooltip").toString ());
item->setData (settings.value ("ID"), Roles::ActionID);
item->setCheckable (true);
item->setEditable (false);
Model_->appendRow (item);
}
settings.endArray ();
settings.endGroup ();
}
UILogin::UILogin(QWidget *parent)
:QDialog( parent )
{
setupUi(this);
vboxLayout->setSpacing(20);
vboxLayout->setSpacing(20);
labelName->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
labelPassword->setAlignment(Qt::AlignVCenter | Qt::AlignRight);
QSettings loginsSettings;
loginsSettings.beginGroup( KEY_HALL );
int size = loginsSettings.beginReadArray( KEY_LOGINS );
djDebug() << "UILogin constructor" << "size = " << size;
for ( int i = 0; i < size; ++i ) {
loginsSettings.setArrayIndex(i);
QString userName = loginsSettings.value( KEY_USERNAME ).toString();
QString password = QString::fromUtf8( crypt(loginsSettings.value( KEY_PASSWORD ).toByteArray()) );
comboName->addItem( userName, password );
}
loginsSettings.endArray();
loginsSettings.endGroup();
comboName->setCurrentIndex( 0 );
//set attribute
on_comboName_activated(0);
//exclusive check
on_cbSaveName_clicked( cbSaveName->isChecked() );
}
void Controller::loadShares () {
{
SF_SCHNEE_LOCK;
QSettings settings;
settings.beginGroup("share");
int count = settings.beginReadArray("shares");
for (int i = 0; i < count; i++) {
settings.setArrayIndex(i);
// do not read everything...
sf::String shareName = sfString (settings.value("shareName").toString());
sf::String fileName = sfString (settings.value("fileName").toString());
bool forAll = settings.value("forAll").toBool();
sf::UserSet whom = toUserSet (settings.value("whom"));
sf::Error e = mModel->fileSharing()->editShare(shareName, fileName, forAll, whom);
if (e) {
onError (err::CouldNotRestoreShare,
QObject::tr ("Could not restore share"),
QObject::tr ("Could not restore share %1, reason: %2")
.arg (qtString(shareName)).arg (toString(e)));
}
}
settings.endArray();
settings.endGroup();
}
mGUI->call (boost::bind (&ShareList::update, mShareList));
}
QFakeMail::QFakeMail() : QMainWindow(0), email("([a-z0-9._%+-]+@[a-z0-9-]+\\.[a-z0-9.-]+)", Qt::CaseInsensitive)
{
setupUi(this);
connect(server, SIGNAL(textEdited(const QString&)), SLOT(change()));
connect(isfrom, SIGNAL(toggled(bool)), SLOT(change()));
connect(from, SIGNAL(textEdited(const QString&)), SLOT(change()));
connect(to, SIGNAL(textEdited(const QString&)), SLOT(change()));
connect(files, SIGNAL(itemSelectionChanged()), SLOT(filesSelected()));
connect(removefile, SIGNAL(clicked()), SLOT(removeFile()));
connect(addfile, SIGNAL(clicked()), SLOT(addFile()));
connect(send, SIGNAL(clicked()), SLOT(sendSlot()));
connect(actionAbout, SIGNAL(triggered()), SLOT(about()));
connect(&sock, SIGNAL(error(QAbstractSocket::SocketError)), SLOT(gotErrorSlot()));
connect(&sock, SIGNAL(disconnected()), SLOT(disconnected()));
connect(&sock, SIGNAL(connected()), SLOT(connected()));
connect(&sock, SIGNAL(readyRead()), SLOT(readed()));
QSettings settings;
int size = settings.beginReadArray("recents");
for (int i = 0; i < size; i++) {
settings.setArrayIndex(i);
recents << settings.value("server").toString();
}
settings.endArray();
server->setCompleter(new QCompleter(recents, server));
}
void ALEXHistogramsWidget::loadSettings(QSettings &settings, const QString &prefix)
{
ui->splitter->restoreState(settings.value(prefix+"splitterGeometry").toByteArray());
ui->splitter_2->restoreState(settings.value(prefix+"splitterGeometry2").toByteArray());
ui->splitter_3->restoreState(settings.value(prefix+"splitterGeometry3").toByteArray());
ui->splitter_4->restoreState(settings.value(prefix+"splitterGeometry4").toByteArray());
ui->doubleSpinBoxBackgroundDemDex->setValue(settings.value(prefix+"doubleSpinBoxBackgroundDemDex",ui->doubleSpinBoxBackgroundDemDex->value()).toDouble());
ui->doubleSpinBoxBackgroundDemAex->setValue(settings.value(prefix+"doubleSpinBoxBackgroundDemAex",ui->doubleSpinBoxBackgroundDemAex->value()).toDouble());
ui->doubleSpinBoxBackgroundAemDex->setValue(settings.value(prefix+"doubleSpinBoxBackgroundAemDex",ui->doubleSpinBoxBackgroundAemDex->value()).toDouble());
ui->doubleSpinBoxBackgroundAemAex->setValue(settings.value(prefix+"doubleSpinBoxBackgroundAemAex",ui->doubleSpinBoxBackgroundAemAex->value()).toDouble());
ui->doubleSpinBoxCrosstalk->setValue(settings.value(prefix+"doubleSpinBoxCrosstalk",ui->doubleSpinBoxCrosstalk->value()).toDouble());
ui->doubleSpinBoxDirectExc->setValue(settings.value(prefix+"doubleSpinBoxDirectExc",ui->doubleSpinBoxDirectExc->value()).toDouble());
ui->doubleSpinBoxScale->setValue(settings.value(prefix+"doubleSpinBoxScale",ui->doubleSpinBoxScale->value()).toDouble());
ui->spinBoxBins->setValue(settings.value(prefix+"spinBoxBins",ui->spinBoxBins->value()).toInt());
plotRangeContour.minP=settings.value(prefix+"plotRangeContour.minP",-0.1).toDouble();
plotRangeContour.maxP=settings.value(prefix+"plotRangeContour.maxP",+1.1).toDouble();
plotRangeContour.minS=settings.value(prefix+"plotRangeContour.minS",-0.1).toDouble();
plotRangeContour.maxS=settings.value(prefix+"plotRangeContour.maxS",+1.1).toDouble();
plotRangeContour.check();
int size = settings.beginReadArray(prefix+"contourLevels");
contourLevels.clear();
for (int i = 0; i < size; ++i) {
settings.setArrayIndex(i);
contourLevels.append(settings.value("contourLevel").toDouble());
}
settings.endArray();
ui->comboBoxPlot->setCurrentIndex(settings.value(prefix+"comboBoxPlot",0).toInt());
ui->comboBoxPalette->setCurrentIndex(settings.value(prefix+"comboBoxPalette",0).toInt());
ui->comboBoxModel->setCurrentIndex(settings.value(prefix+"comboBoxModel",0).toInt());
}
void ConfigureDlg::loadCurrentValues()
{
QSettings *settings = SyntroUtils::getSettings();
settings->beginReadArray(SYNTROEXEC_PARAMS_COMPONENTS);
settings->setArrayIndex(m_index);
m_appName->setText(settings->value(SYNTROEXEC_PARAMS_APP_NAME).toString());
m_executableDirectory->setText(settings->value(SYNTROEXEC_PARAMS_EXECUTABLE_DIRECTORY).toString());
m_workingDirectory->setText(settings->value(SYNTROEXEC_PARAMS_WORKING_DIRECTORY).toString());
m_iniPath->setText(settings->value(SYNTROEXEC_PARAMS_INI_PATH).toString());
m_consoleMode->setCheckState(settings->value(SYNTROEXEC_PARAMS_CONSOLE_MODE).toString() ==
SYNTRO_PARAMS_TRUE ? Qt::Checked : Qt::Unchecked);
int findIndex = m_adaptor->findText(settings->value(SYNTROEXEC_PARAMS_ADAPTOR).toString());
if (findIndex != -1)
m_adaptor->setCurrentIndex(findIndex);
else
m_adaptor->setCurrentIndex(0);
settings->endArray();
delete settings;
}
void PropertiesManager::createStateAssignmentProperties(StateAssignmentTextItem *sa)
{
//move up down
root->actionMove_Up->setEnabled(true);
root->actionMove_Down->setEnabled(true);
root->actionDeleteItems->setEnabled(true);
QLabel *label = new QLabel("<b>Edit State Assigment</b>");
addRow(label);
QComboBox *var = new QComboBox();
for (int i=0; i< root->al->StateVariableList.size(); i++)
{
var->addItem(root->al->StateVariableList[i]->getName());
if (sa->getVariable() != NULL){
if (root->al->StateVariableList[i]->getName().compare(sa->getVariable()->getName()) == 0)
var->setCurrentIndex(i);
}
else
var->setCurrentIndex(-1);
}
connect(var, SIGNAL(currentIndexChanged(QString)), sa, SLOT(setVariable(QString)));
addRow(tr("&Variable:"),var);
QLineEdit *maths = new QLineEdit();
maths->installEventFilter(&eventFilterObject);
maths->setText(sa->getMaths()->equation);
connect(maths, SIGNAL(textEdited(QString)), sa, SLOT(setMaths(QString)));
addRow(tr("&Maths:"),maths);
addWidget(new QLabel(tr("<i>in physiological units</i>")));
QStringList errs;
sa->getMaths()->validateMathInLine(root->al.data(), &errs);
// sort out errors
QSettings settings;
int num_errs = settings.beginReadArray("warnings");
settings.endArray();
if (num_errs != 0) {
// show errors by changing lineedit colour
QPalette p = maths->palette();
p.setColor( QPalette::Normal, QPalette::Base, QColor(255, 200, 200) );
maths->setPalette(p);
// clear errors
settings.remove("warnings");
}
if (num_errs == 0) {
// show no errors by changing lineedit colour
QPalette p = maths->palette();
p.setColor( QPalette::Normal, QPalette::Base, QColor(255, 255, 255) );
maths->setPalette(p);
// clear errors
settings.remove("warnings");
}
}
void MainWindow::newGame(int player, const Game * game)
{
gameStartTimestamp = QDateTime::currentMSecsSinceEpoch();
if (player < 0)
{
qDebug("New game started with players:");
for (Player const * p : game->getPlayers())
qDebug() << p->getTypeName();
qDebug();
}
boardUi->newGame(player, game);
if (isSetUp)
return;
isSetUp = true;
qDeleteAll(playerInfos);
playerInfos.clear();
for (uint i = 0; i < game->getPlayerCount(); ++i)
{
PlayerInfoView * pi = new PlayerInfoView(i, game, &imgFactory);
ui->playerInfoLayout->insertWidget(i, pi);
connect(this, SIGNAL(updateNeeded()), pi, SLOT(updateView()));
connect(this, SIGNAL(tileDrawn(int,int)), pi, SLOT(displayTile(int,int)));
playerInfos.push_back(pi);
}
emit gameEvent(tr("New game started"));
ui->remainingTiles->setUp(game, &imgFactory);
connect(this, SIGNAL(updateNeeded()), ui->remainingTiles, SLOT(updateView()));
QSettings settings;
settings.beginGroup("games");
int size = settings.beginReadArray("game");
settings.endArray();
settings.beginWriteArray("game");
settings.setArrayIndex(size);
settings.setValue("appRevision", APP_REVISION_STR);
settings.setValue("qtCompileVersion", QT_VERSION_STR);
settings.setValue("qtRuntimeVersionn", qVersion());
settings.setValue("timestamp", gameStartTimestamp);
settings.beginWriteArray("players");
auto const & players = game->getPlayers();
for (size_t i = 0; i < players.size(); ++i)
{
settings.setArrayIndex((int)i);
settings.setValue("type", players[i]->getTypeName());
}
settings.endArray();
settings.endArray();
settings.endGroup();
}
