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 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 #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
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();
}
/*!
    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 #6
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 #7
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 #8
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;
}
/*! \brief Save the positions of Peer Widgets
 *
 * Save the positions of all Peer Widgets to the settings.
 */
void XletSwitchBoard::savePositions() const
{
    // qDebug() << Q_FUNC_INFO << m_peerhash.count();
    QSettings * settings = b_engine->getSettings();
    settings->beginGroup("layout");
    QHashIterator<QString, PeerItem *> it(m_peerhash);
    while (it.hasNext()) {
        it.next();
        const QString userid = it.key();
        PeerItem *peeritem = it.value();
        if (peeritem->getWidget()) {
            settings->setValue(userid,
                               m_layout->getItemPosition(peeritem->getWidget()));
        } else {
            settings->remove(userid);
        }
    }

    settings->beginWriteArray("externalphone");
    int i, index = 0;
    for (i=0;i<m_layout->count();i++) {
        QLayoutItem *item = m_layout->itemAt(i);
        if ((item) && (item->widget()) &&
            ((item->widget()->inherits("ExternalPhonePeerWidget")) ||
             (item->widget()->inherits("DetailedExternalPhonePeerWidget")))) {
            BasePeerWidget *w = static_cast<BasePeerWidget *>(item->widget());
            settings->setArrayIndex(index++);
            settings->setValue("position", m_layout->getItemPosition(w));
            settings->setValue("name", w->name());
            settings->setValue("number", w->number());
        }
    }
    settings->endArray();
    settings->endGroup();
}
Example #10
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 #11
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 #12
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 #13
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 #14
0
void DeviceSerial::deviceCfgSave( QSettings &pDataStream )
{
	pDataStream.beginGroup( "serial" );

	pDataStream.beginWriteArray( "devices", mDeviceList.size() );

	for( int i = 0 ; i < mDeviceList.size() ; i++ )
	{
		pDataStream.setArrayIndex( i );

		DeviceSerial *DevCur = mDeviceList[ i ];

		DevCur->cfgSave( pDataStream );

		pDataStream.setValue( "name", DevCur->name() );

		pDataStream.setValue( "uuid", DevCur->uuid() );

		pDataStream.setValue( "enabled", DevCur->isEnabled() );
	}

	pDataStream.endArray();

	pDataStream.endGroup();
}
Example #15
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 #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();
}
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());
}
Example #18
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 #19
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 #20
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();
}
Example #21
0
void SyntroDB::boxClicked(bool state, int boxId)
{
	if (m_startingUp)
		return;												// avoids thrashing when loading config

	QSettings *settings = SyntroUtils::getSettings();
	
	settings->beginWriteArray(SYNTRODB_PARAMS_STREAM_SOURCES);
	settings->setArrayIndex(boxId);

	if (m_useBox[boxId]->checkState() == Qt::Checked)
		settings->setValue(SYNTRODB_PARAMS_INUSE, SYNTRO_PARAMS_TRUE);
	else
		settings->setValue(SYNTRODB_PARAMS_INUSE, SYNTRO_PARAMS_FALSE);
	settings->endArray();

	delete settings;

	if (!state) {											// disabled so zero stats
		m_rxStreamTable->item(boxId, SYNTRODB_COL_TOTALRECS)->setText("");
		m_rxStreamTable->item(boxId, SYNTRODB_COL_TOTALBYTES)->setText("");
		m_rxStreamTable->item(boxId, SYNTRODB_COL_FILERECS)->setText("");
		m_rxStreamTable->item(boxId, SYNTRODB_COL_FILEBYTES)->setText("");
		m_rxStreamTable->item(boxId, SYNTRODB_COL_FILE)->setText("");
	}
	emit refreshStreamSource(boxId);
}
Example #22
0
void WorksTabView::write_settings() {
  mAllView->write_settings();
  QSettings settings;
  settings.beginGroup("WorksTabView");

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

    FilteredDBView * view = static_cast<FilteredDBView *>(widget);
    QString expression = view->filter_expression();
    if (expression.isEmpty())
      continue;

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

  settings.endGroup();
}
Example #23
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();
}
Example #24
0
 static void write(QSettings &r, const QList<T> &values, const QString &key) {
     r.setValue(key % _L("_exists"), true);
     r.beginWriteArray(key, values.size());
     for (int i=0; i<values.size(); ++i) {
         r.setArrayIndex(i);
         One::write(r, values[i], "data");
     }
     r.endArray();
 }
Example #25
0
static void writeRecentFiles(const QStringList &files, QSettings &settings) {
  const int count = files.size();
  settings.beginWriteArray(recentFilesKey());
  for (int i = 0; i < count; ++i) {
    settings.setArrayIndex(i);
    settings.setValue(fileKey(), files.at(i));
  }
  settings.endArray();
}
Example #26
0
void Settings::synchronize() {
    QSettings settings;

    settings.setValue(SETTINGS_TEXT_COLOR, mTextColor);
    settings.setValue(SETTINGS_TEXT_BACKGROUND_COLOR, mTextBackgroundColor);
    settings.setValue(SETTINGS_LINES_COLOR, mLinesColor);
    settings.setValue(SETTINGS_FONT_FAMILY, mFontFamily);
    settings.setValue(SETTINGS_FONT_SIZE, mFontSize);
    settings.setValue(SETTINGS_DISPLAY_LONGER_WORDS_LONGER, mDisplayLongerWordsLonger);
    settings.setValue(SETTINGS_WORD_LENGTH, mWordLength);
    settings.setValue(SETTINGS_NUMBER_OF_WORDS, mNumberOfWords);
    settings.setValue(SETTINGS_WORDS_PER_MINUTE, mWordsPerMinute);
    settings.setValue(SETTINGS_NUMBER_GROUPING, mNumberGrouping);
    settings.setValue(SETTINGS_HTTP_NETWORK_PROXY_TYPE, mHTTPNetworkProxyType);
    settings.setValue(SETTINGS_HTTP_NETWORK_PROXY_SERVER, mHTTPNetworkProxy.hostName());
    settings.setValue(SETTINGS_HTTP_NETWORK_PROXY_PORT, mHTTPNetworkProxy.port());
    settings.setValue(SETTINGS_RSS_REFRESH_RATE, mRSSRefreshRate);

    settings.beginWriteArray(SETTINGS_WORDS);
    settings.remove("");

    for (int i = 0; i < mWords.count(); i++) {
        settings.setArrayIndex(i);
        settings.setValue(SETTINGS_VALUE, mWords.at(i).word);
        settings.setValue(SETTINGS_STOP_WORD, mWords.at(i).stopWord);
        settings.setValue(SETTINGS_BREAK_WORD, mWords.at(i).breakWord);
        settings.setValue(SETTINGS_DELAY_WORD, mWords.at(i).delayWord);
    }

    settings.endArray();

    settings.beginWriteArray(SETTINGS_RSS_SITES);
    settings.remove("");

    for (int i = 0; i < mRSSSites.count(); i++) {
        settings.setArrayIndex(i);
        settings.setValue(SETTINGS_RSS_SITE, mRSSSites.at(i));
    }

    settings.endArray();
    settings.sync();

    emit updatedSettings();
}
void eVisGenericEventBrowserGui::accept()
{
  QSettings myQSettings;

  if ( chkboxSaveEventImagePathData->isChecked() )
  {
    myQSettings.setValue( "/eVis/eventimagepathfield", cboxEventImagePathField->currentText() );
    myQSettings.setValue( "/eVis/eventimagepathrelative", chkboxEventImagePathRelative->isChecked() );
  }

  if ( chkboxSaveCompassBearingData->isChecked() )
  {
    myQSettings.setValue( "/eVis/compassbearingfield", cboxCompassBearingField->currentText() );
    myQSettings.setValue( "/eVis/displaycompassbearing", chkboxDisplayCompassBearing->isChecked() );
  }

  if ( chkboxSaveCompassOffsetData->isChecked() )
  {
    myQSettings.setValue( "/eVis/manualcompassoffset", rbtnManualCompassOffset->isChecked() );
    myQSettings.setValue( "/eVis/compassoffset", dsboxCompassOffset->value() );
    myQSettings.setValue( "/eVis/attributecompassoffset", rbtnAttributeCompassOffset->isChecked() );
    myQSettings.setValue( "/eVis/compassoffsetfield", cboxCompassOffsetField->currentText() );
  }

  if ( chkboxSaveBasePathData->isChecked() )
  {
    myQSettings.setValue( "/eVis/basepath", leBasePath->text() );
  }

  if ( chkboxSaveUseOnlyFilenameData->isChecked() )
  {
    myQSettings.setValue( "/eVis/useonlyfilename", chkboxUseOnlyFilename->isChecked() );
  }

  if ( chkboxSaveApplyPathRulesToDocs->isChecked() )
  {
    myQSettings.setValue( "/eVis/applypathrulestodocs", chkboxApplyPathRulesToDocs->isChecked() );
  }

  myQSettings.remove( "/eVis/filetypeassociations" );
  myQSettings.beginWriteArray( "/eVis/filetypeassociations" );
  int myIterator = 0;
  int myIndex = 0;
  while ( myIterator < tableFileTypeAssociations->rowCount() )
  {
    myQSettings.setArrayIndex( myIndex );
    if ( tableFileTypeAssociations->item( myIterator, 0 ) && tableFileTypeAssociations->item( myIterator, 1 ) )
    {
      myQSettings.setValue( "extension", tableFileTypeAssociations->item( myIterator, 0 )->text() );
      myQSettings.setValue( "application", tableFileTypeAssociations->item( myIterator, 1 )->text() );
      myIndex++;
    }
    myIterator++;
  }
  myQSettings.endArray();
}
Example #28
0
void FavoriteTagsModel::saveToSettings(QSettings &s) const
{
    s.beginWriteArray(Common::SettingsNames::favoriteTagsKey);
    for (int i = 0; i < m_tags.size(); ++i) {
        s.setArrayIndex(i);
        s.setValue(Common::SettingsNames::tagNameKey, m_tags[i].name);
        s.setValue(Common::SettingsNames::tagColorKey, m_tags[i].color);
    }
    s.endArray();
}
Example #29
0
void Rekall::syncSettings() {
    QSettings settings;
    settings.beginWriteArray("projects");
    quint16 projectIndex = 0;
    foreach(ProjectInterface *project, Global::projects) {
        settings.setArrayIndex(projectIndex++);
        settings.setValue("name", project->name);
        settings.setValue("friendlyName", project->friendlyName);
        settings.setValue("path", project->path.absoluteFilePath());
    }
Example #30
0
void KeySequence::saveSettings(QSettings& settings) const
{
    settings.beginWriteArray("keys");
    for (int i = 0; i < sequence().size(); i++)
    {
        settings.setArrayIndex(i);
        settings.setValue("key", sequence()[i]);
    }
    settings.endArray();
}