Example #1
0
void Gomoku::save(int id) {
    QSettings settings;
    QString date = QDateTime().currentDateTime().toString();
    settings.setValue(QString("time") + QString::number(id), date);
    settings.setValue(QString((ui->gameboard->playerColor == Qt::white)? "whiteTime": "blackTime") + QString::number(id), playerTime);
    settings.setValue(QString((ui->gameboard->playerColor == Qt::white)? "blackTime": "whiteTime") + QString::number(id), enemyTime);

    QString color = ((ui->gameboard->playerColor == Qt::white)? "white": "black") + QString::number(id);
    settings.beginWriteArray(color);
    const auto &pchess = ui->gameboard->getPlayerChesses();

    for (size_t i = 0; i < pchess.size(); i++) {
        settings.setArrayIndex(i);
        settings.setValue("row", pchess[i].row);
        settings.setValue("col", pchess[i].col);
    }

    settings.endArray();

    color = (ui->gameboard->playerColor == Qt::black)? "white": "black";
    settings.beginWriteArray(color);
    const auto &echess = ui->gameboard->getEnemyChesses();

    for (size_t i = 0; i < echess.size(); i++) {
        settings.setArrayIndex(i);
        settings.setValue("row", echess[i].row);
        settings.setValue("col", echess[i].col);
    }

    settings.endArray();
}
Example #2
0
void
MainWindow::addRecentFiles( QSettings& settings
                            , const QString& group, const QString& pfx, const QString& value, const QString& key )
{
    std::vector< QString > list;
    getRecentFiles( settings, group, pfx, list, key );

    boost::filesystem::path path = boost::filesystem::path( value.toStdWString() ).generic_wstring();
    auto it = std::remove_if( list.begin(), list.end(), [path] ( const QString& a ){ return path == a.toStdWString(); } );
    if ( it != list.end() )
        list.erase( it, list.end() );

    settings.beginGroup( group );

    settings.beginWriteArray( pfx );
    settings.setArrayIndex( 0 );
    settings.setValue( key, QString::fromStdWString( path.generic_wstring() ) );
    for ( size_t i = 0; i < list.size() && i < 7; ++i ) {
        settings.setArrayIndex( int(i + 1) );
        settings.setValue( key, list[ i ] );
    }
    settings.endArray();

    settings.endGroup();
}
Example #3
0
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();
}
Example #4
0
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;
}
Example #5
0
void ProjectManager::storeProjectState()
{
    QSettings s;

    s.remove("LoadedProjects");


    s.beginGroup("LoadedProjects");

    s.beginWriteArray("Projects");

    for(int p=0; p<rootNode->childrenCount(); p++)
    {
        ProjectNode * projNode =  dynamic_cast<ProjectNode*>(rootNode->child(p));

        s.setArrayIndex(p);
        s.setValue("Name",projNode->getName());

        SgProject * sgProj =  projNode->getSgProject();

        s.beginWriteArray("files");
        for(int i=0; i < sgProj->numberOfFiles(); i++)
        {
            QString name = (*sgProj)[i]->getFileName().c_str();
            s.setArrayIndex(i);
            s.setValue("name",name);
        }
        s.endArray();
    }

    s.endArray(); //Projects


    s.endGroup();
}
Example #6
0
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();
}
Example #7
0
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);
	}
Example #8
0
	void Core::saveSingleSession ()
	{
		BrowserWidget *source = qobject_cast<BrowserWidget*> (sender ());
		if (!source)
		{
			qWarning () << Q_FUNC_INFO
				<< "sender is not a BrowserWidget*"
				<< sender ();
			return;
		}

		QSettings settings (QCoreApplication::organizationName (),
				QCoreApplication::applicationName () + "_Poshuku");
		settings.beginWriteArray ("Saved session");
		for (int i = 0, size = Widgets_.size (); i < size; ++i)
			if (Widgets_.at (i) == source)
			{
				settings.setArrayIndex (i);
				settings.setValue ("Title", source->GetView ()->title ());
				settings.setValue ("URL", source->GetView ()->url ().toString ());
				settings.setValue ("Settings",
						QVariant::fromValue<BrowserWidgetSettings> (source->GetWidgetSettings ()));
				break;
			}

		// It looks like QSettings determines array size by last used index
		// no matter what was passed to QSettings::beginWriteArray (). Forcing correct size
		settings.setArrayIndex (Widgets_.size () - 1);
		settings.endArray ();
		settings.sync ();
	}
Example #9
0
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();
}
Example #10
0
/*
void UILogin::on_btnRemove_clicked()
{
	//int index	= comboName->currentIndex();
	comboName->removeItem( comboName->currentIndex() );
	on_comboName_activated( comboName->currentIndex() );
}
*/
void UILogin::on_btnLogin_clicked()
{
	djDebug() << "login button clicked";
	
	m_useName	= comboName->currentText().trimmed();
	m_password	= lePassword->text();
	
	if ( m_useName.isEmpty() )
		reject();
	int index	= comboName->findText( m_useName );
	if ( -1 == index ) {
		//new user name
		if ( cbSaveName->isChecked() ) {
			//save username
			if ( cbSavePassword->isChecked() )
				comboName->insertItem( 0, m_useName, m_password );
			else {
				comboName->insertItem( 0, m_useName, QString() );
			}
		}else {
			//don't save username
			accept();
		}
	}else {
		//exsting user name
		if ( cbSaveName->isChecked() ) {
			//save username
			if ( cbSavePassword->isChecked() )
				comboName->setItemData( index, m_password );
			else {
				comboName->setItemData( index, QString() );
			}
		}else {
			//don't save username
			comboName->removeItem( index );
		}
	}
	
	QSettings loginsSettings;
	loginsSettings.beginGroup( KEY_HALL );
	
	loginsSettings.beginWriteArray( KEY_LOGINS );
	index	= 1;
	for ( int i = 0; i < comboName->count(); i++ ) {
		QString userName	= comboName->itemText( i );
		QString password	= comboName->itemData( i ).toString();
		if ( userName == comboName->currentText() )
			loginsSettings.setArrayIndex(0);
		else
			loginsSettings.setArrayIndex(index++);
   		loginsSettings.setValue( KEY_USERNAME, userName );
       	loginsSettings.setValue( KEY_PASSWORD, crypt(password.toUtf8()) );
	}
	loginsSettings.endArray();
	loginsSettings.endGroup();
		
	accept();
}
/*!
    Save project settings related to signal generation. The settings are
    stored in \a project.
*/
void UiGeneratorArea::saveProject(QSettings &project)
{
    GeneratorDevice* device = DeviceManager::instance()
            .activeDevice()->generatorDevice();

    project.remove("digitalGenerator");
    project.remove("analogGenerator");
    if (device != NULL) {

        if (device->maxNumDigitalSignals() > 0) {

            bool digEnabled = (subWindowList().indexOf(mDigitalWin) != -1);

            project.beginGroup("digitalGenerator");

            project.setValue("enabled", digEnabled);
            project.setValue("rate", mDigitalGenerator->rate());

            project.beginWriteArray("signals");

            QList<DigitalSignal*> digitalList = device->digitalSignals();
            for (int i = 0; i < digitalList.size(); i++) {
                DigitalSignal* s = digitalList.at(i);
                project.setArrayIndex(i);
                project.setValue("meta", s->toSettingsString());
            }

            project.endArray();

            project.endGroup();
        }

        if (device->maxNumAnalogSignals() > 0) {

            bool anEnabled  = (subWindowList().indexOf(mAnalogWin) != -1);

            project.beginGroup("analogGenerator");
            project.setValue("enabled", anEnabled);

            project.beginWriteArray("signals");

            QList<AnalogSignal*> analogList = device->analogSignals();
            for (int i = 0; i < analogList.size(); i++) {
                AnalogSignal* s = analogList.at(i);
                project.setArrayIndex(i);
                project.setValue("meta", s->toSettingsString());
            }

            project.endArray();

            project.endGroup();
        }

    }
}
Example #12
0
void ccColorScalesManager::toPersistentSettings() const
{
	QSettings settings;
	//remove all existing info
	settings.remove(c_csm_groupName);
	//create new set
	settings.beginGroup(c_csm_groupName);

	//add each scale
	for (ScalesMap::const_iterator it = m_scales.begin(); it != m_scales.end(); ++it)
	{
		if (!(*it)->isLocked()) //locked scales are pre-defined ones!
		{
			settings.beginGroup((*it)->getUuid());

			settings.setValue(c_csm_scaleName,(*it)->getName());
			settings.setValue(c_csm_relative,(*it)->isRelative());
			if (!(*it)->isRelative())
			{
				double minVal,maxVal;
				(*it)->getAbsoluteBoundaries(minVal,maxVal);
				settings.setValue(c_csm_minVal,minVal);
				settings.setValue(c_csm_maxVal,maxVal);
			}

			settings.beginWriteArray(c_csm_stepsList);
			{
				for (int i=0; i<(*it)->stepCount();++i)
				{
					 settings.setArrayIndex(i);
					 settings.setValue(c_csm_stepRelativePos, (*it)->step(i).getRelativePos());
					 int rgb = static_cast<int>((*it)->step(i).getColor().rgb());
					 settings.setValue(c_csm_stepColor, rgb);
				}
			}
			settings.endArray();

			settings.beginWriteArray(c_csm_customLabels);
			{
				int i=0;
				for (ccColorScale::LabelSet::const_iterator itL=(*it)->customLabels().begin(); itL!=(*it)->customLabels().end(); ++itL, ++i)
				{
					 settings.setArrayIndex(i);
					 settings.setValue(c_csm_customLabelValue, *itL);
				}
			}
			settings.endArray();
			

			settings.endGroup();
		}
	}

	settings.endGroup();
}
Example #13
0
void NetworkConnection::savefriendswatches(void)
{
	QSettings settings;
	int index;
	if(!supportsFriendList())
	{
		settings.beginWriteArray("FRIENDEDLIST");
		std::vector<FriendWatchListing * >::iterator i;
		index = 0;
		for (i = friendedList.begin(); i != friendedList.end(); i++) 
		{
			settings.setArrayIndex(index);
			settings.setValue("name", (*i)->name);
			settings.setValue("notify", (*i)->notify);
			delete (*i);
			index++;
		}
		settings.endArray();
	}
	if(!supportsWatchList())
	{
		settings.beginWriteArray("WATCHEDLIST");
		std::vector<FriendWatchListing * >::iterator i;
		index = 0;
		for (i = watchedList.begin(); i != watchedList.end(); i++) 
		{
			settings.setArrayIndex(index);
			settings.setValue("name", (*i)->name);
			settings.setValue("notify", (*i)->notify);
			delete (*i);
			index++;
		}
		settings.endArray();	
	}
	if(!supportsBlockList())
	{
		settings.beginWriteArray("BLOCKEDLIST");
		std::vector<FriendWatchListing * >::iterator i;
		index = 0;
		for (i = blockedList.begin(); i != blockedList.end(); i++) 
		{
			settings.setArrayIndex(index);
			settings.setValue("name", (*i)->name);
			delete (*i);
			index++;
		}
		settings.endArray();
	}
}
Example #14
0
void Controls::addRecentFiles(const QString &fileName)
{
    QMenu *rf = m_ui->menuRecent_Models;
    QStringList files;
    {
        QSettings settings;
        settings.beginGroup("General");
        int numFiles = settings.beginReadArray("RecentFiles");
        for (int i = 0; i < numFiles; ++i)
        {
            settings.setArrayIndex(i);
            QByteArray coded = settings.value("file").toByteArray();
            files.append(QUrl::fromPercentEncoding(coded));
        }
    }
    files.removeAll(fileName);
    files.push_front(fileName);
    if (files.size() > 10)
        files.pop_back();
    QAction *act;
    while (rf->actions().count() > 0)
    {
        act = rf->actions().at(0);
        rf->removeAction(act);
        delete act;
    }
    for (int i = 0; i < files.count(); ++i)
    {
        act = new QAction(files.at(i), this);
        connect(act, SIGNAL(triggered()),
                this, SLOT(load()));
        rf->addAction(act);
    }
    {
        QSettings settings;
        settings.beginGroup("General");
        settings.beginWriteArray("RecentFiles", files.count());
        for (int i = 0; i < files.count(); ++i)
        {
            settings.setArrayIndex(i);
            QByteArray coded = QUrl::toPercentEncoding(files.at(i));
            settings.setValue("file", coded);
        }
        settings.endArray();
        settings.endGroup();
        settings.sync();
    }
}
Example #15
0
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;
}
Example #16
0
void MainWindow::writeSettings() {
  ui->allWorks->writeSettings();

  QSettings settings;

  /*
  settings.beginGroup("MainWindow");
  settings.setValue("geometry", saveGeometry());
  settings.endGroup();
  */

  settings.beginGroup("WorkFilterModelCollection");

  int valid_index = 0;
  settings.beginWriteArray("filters");
  for (int i = 0; i < ui->workViews->count(); i++) {
    //make sure it is not the all view and the expression isn't empty
    QWidget * widget = ui->workViews->widget(i);
    WorkFilterView * view = dynamic_cast<WorkFilterView *>(widget);
    if (!view)
      continue;
    QString expression = view->filterExpression();
    if (expression.isEmpty())
      continue;

    settings.setArrayIndex(valid_index);
    valid_index++;
    settings.setValue("expression", expression);
    settings.setValue("label", ui->workViews->tabText(ui->workViews->indexOf(view)));
  }
  settings.endArray();

  settings.endGroup();
}
Example #17
0
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));
}
void ALEXHistogramsWidget::storeSettings(QSettings &settings, const QString &prefix) const
{
    settings.setValue(prefix+"doubleSpinBoxBackgroundDemDex",ui->doubleSpinBoxBackgroundDemDex->value());
    settings.setValue(prefix+"doubleSpinBoxBackgroundDemAex",ui->doubleSpinBoxBackgroundDemAex->value());
    settings.setValue(prefix+"doubleSpinBoxBackgroundAemDex",ui->doubleSpinBoxBackgroundAemDex->value());
    settings.setValue(prefix+"doubleSpinBoxBackgroundAemAex",ui->doubleSpinBoxBackgroundAemAex->value());
    settings.setValue(prefix+"doubleSpinBoxCrosstalk",ui->doubleSpinBoxCrosstalk->value());
    settings.setValue(prefix+"doubleSpinBoxDirectExc",ui->doubleSpinBoxDirectExc->value());
    settings.setValue(prefix+"doubleSpinBoxScale",ui->doubleSpinBoxScale->value());
    settings.setValue(prefix+"spinBoxBins",ui->spinBoxBins->value());
    settings.setValue(prefix+"plotRangeContour.minP",plotRangeContour.minP);
    settings.setValue(prefix+"plotRangeContour.maxP",plotRangeContour.maxP);
    settings.setValue(prefix+"plotRangeContour.minS",plotRangeContour.minS);
    settings.setValue(prefix+"plotRangeContour.maxS",plotRangeContour.maxS);
    settings.setValue(prefix+"comboBoxPalette",ui->comboBoxPalette->currentIndex());
    settings.setValue(prefix+"comboBoxPlot",ui->comboBoxPlot->currentIndex());
    settings.setValue(prefix+"comboBoxModel",ui->comboBoxModel->currentIndex());
    settings.beginWriteArray(prefix+"contourLevels");
    for (int i = 0; i < contourLevels.size(); ++i) {
        settings.setArrayIndex(i);
        settings.setValue("contourLevel", contourLevels.at(i));
    }
    settings.endArray();
    settings.setValue(prefix+"splitterGeometry",ui->splitter->saveState());
    settings.setValue(prefix+"splitterGeometry2",ui->splitter_2->saveState());
    settings.setValue(prefix+"splitterGeometry3",ui->splitter_3->saveState());
    settings.setValue(prefix+"splitterGeometry4",ui->splitter_4->saveState());
}
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());

}
Example #20
0
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;
}
Example #21
0
void ConfigureDlg::okButtonClick()
{
	QSettings *settings = SyntroUtils::getSettings();

	settings->beginWriteArray(SYNTROEXEC_PARAMS_COMPONENTS);
	settings->setArrayIndex(m_index);

	settings->setValue(SYNTROEXEC_PARAMS_APP_NAME, m_appName->text());
	settings->setValue(SYNTROEXEC_PARAMS_EXECUTABLE_DIRECTORY, m_executableDirectory->text());
	settings->setValue(SYNTROEXEC_PARAMS_WORKING_DIRECTORY, m_workingDirectory->text());

	if (m_adaptor->currentText() == "<any>")
		settings->setValue(SYNTROEXEC_PARAMS_ADAPTOR, "");
	else
		settings->setValue(SYNTROEXEC_PARAMS_ADAPTOR, m_adaptor->currentText());
	
	settings->setValue(SYNTROEXEC_PARAMS_INI_PATH, m_iniPath->text());

	settings->setValue(SYNTROEXEC_PARAMS_CONSOLE_MODE, 
		m_consoleMode->checkState() == Qt::Checked ? SYNTRO_PARAMS_TRUE : SYNTRO_PARAMS_FALSE);

	settings->endArray();
	
	delete settings;
	
	accept();
}
Example #22
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);
		}
	}
Example #23
0
void MidiTimelineNode::saveSettings( QSettings &pSettings ) const
{
	pSettings.beginGroup( "timeline" );

	mTimelineControl->cfgSave( pSettings );

	pSettings.endGroup();

	pSettings.beginGroup( "time" );

	mKF->cfgSave( pSettings );

	pSettings.endGroup();

	pSettings.beginWriteArray( "events", mEvents.size() );

	for( int i = 0 ; i < mEvents.size() ; i++ )
	{
		pSettings.setArrayIndex( i );

		pSettings.setValue( "t", mEvents[ i ].timestamp );
		pSettings.setValue( "m", mEvents[ i ].message );
	}

	pSettings.endArray();
}
Example #24
0
bool CustCmdDlg::saveSettings ()
{
    saveToItem (ui->treeWidget->currentItem ());

    QSettings stg;
    bool b_ret = false;
    for (;;) {

        int i_max = ui->treeWidget->topLevelItemCount ();
        stg.beginWriteArray (STG_CUSTOM_COMMANDS, i_max);
        int array_index = 0;
        for (int i = 0; i < i_max; ++i) {
            QTreeWidgetItem *current =
                    ui->treeWidget->topLevelItem (i);
            if (!isNewCommandItem (current)) {
                stg.setArrayIndex (array_index++);
                stg.setValue (STG_CUSTOM_CM_NAME, current->text (0));
                stg.setValue (STG_CUSTOM_CM_PROG, current->text (1));
                stg.setValue (STG_CUSTOM_CM_ARGS, current->text (2));
                stg.setValue (STG_CUSTOM_CM_CRTDIR, current->text (3));
            }
        }
        stg.endArray ();
        b_ret = true;
        break;
    }
    return b_ret;
}
Example #25
0
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;
}
Example #26
0
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();
}
Example #27
0
	void Core::saveSession ()
	{
		if (IsShuttingDown_ || !Initialized_)
			return;

		QList<QString> titles;
		QList<QString> urls;
		QList<BrowserWidgetSettings> bwsettings;
		for (widgets_t::const_iterator i = Widgets_.begin (),
				end = Widgets_.end (); i != end; ++i)
		{
			titles << (*i)->GetView ()->title ();
			urls << (*i)->GetView ()->url ().toString ();
			bwsettings << (*i)->GetWidgetSettings ();
		}

		QSettings settings (QCoreApplication::organizationName (),
				QCoreApplication::applicationName () + "_Poshuku");
		settings.beginWriteArray ("Saved session");
		settings.remove ("");
		for (int i = 0; i < titles.size (); ++i)
		{
			settings.setArrayIndex (i);
			settings.setValue ("Title", titles.at (i));
			settings.setValue ("URL", urls.at (i));
			settings.setValue ("Settings", QVariant::fromValue<BrowserWidgetSettings> (bwsettings.at (i)));
		}
		settings.endArray ();
		settings.sync ();
	}
Example #28
0
Main::~Main()
{
    clear();
    QSettings settings;
    int pos = 0;

    settings.setValue("size", size());

    if(casefilter)
        settings.setValue("case", true);
    else
        settings.setValue("case", false);

    if(CoastalView::sensitive())
        settings.setValue("text", true);
    else
        settings.setValue("text", false);

    if(!types) {
        settings.setValue("filter", ui.filterTypes->text());

        settings.beginWriteArray("paths");
        while(pos < history.size()) {
            settings.setArrayIndex(pos);
            settings.setValue("path", history[pos++]);
        }
        settings.endArray();
    }
}
Example #29
0
	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 ();
	}
Example #30
0
void Gui::writeOptions()
{
	QSettings* settings = *gWebyInstance->settings;
	if (settings == NULL) return;
	settings->setValue("weby/firefox", booksFirefox->isChecked());
	settings->setValue("weby/ie", booksIE->isChecked());

	settings->beginWriteArray("weby/sites");
	for(int i = 0; i < table->rowCount(); ++i) {
		if (table->item(i,0) == NULL || table->item(i,1) == NULL) continue;
		if (table->item(i,0)->text() == "" || table->item(i,1)->text() == "") continue;
		settings->setArrayIndex(i);
		settings->setValue("name", table->item(i, 0)->text());
		settings->setValue("base", table->item(i, 1)->text());
		if (table->item(i,2) == NULL)
			settings->setValue("query", "");
		else
			settings->setValue("query", table->item(i, 2)->text());		
		if (table->item(i,0)->text() == defaultName)
		    settings->setValue("default", true);
		else
		    settings->setValue("default", false);
		
	}
	settings->endArray();
}