Example #1
0
//----------------------------------------------------------------------------------------------------------------------
void SettingsDialog::setCalibrationData(const CalibrationData& calibrationData)
{
#ifdef TEST_ONLY
    QSettings settingsFile("tokenTest_Settings.ini", QSettings::IniFormat);
#else
    QSettings settingsFile("tokenGraver_Settings.ini", QSettings::IniFormat);
#endif
    for (int i = 0; i < calibrationData.size(); ++i) {
        settingsFile.setValue(QString("calibrationData") + QString::number(i), calibrationData[i]);
    }
}
Example #2
0
bool AppPathManager::isPortable()
{
    if(_settingsPath.isNull())
        _settingsPath = ApplicationPath;
    if(!QFile(settingsFile()).exists()) return false;
    bool forcePortable=false;
    QSettings checkForPort(settingsFile(), QSettings::IniFormat);
    checkForPort.beginGroup("Main");
        forcePortable= checkForPort.value("force-portable", false).toBool();
    checkForPort.endGroup();

    return forcePortable;
}
Example #3
0
//-------------------------------------------------------------------------------------------------
bool ExportFile( const QString& filepath, quint32 serialNumber )
{
    //TODO: should probably recombine this with the original code

    tFile file( filepath );
    if ( !file.open( QIODevice::WriteOnly ) )
    {
        //DbgPrintf( QString("Failed to open output file %1").arg( filepath ) );
        return false;
    }

    QDataStream out( &file );
    // we must set the version to 4.4 so newer builds with greater versions can build export files for older products.  
    // even if we are sending in the 4.8 version a 4.4 build doesn't know what to do with it.
    out.setVersion( QDataStream::Qt_4_4 );
    out.setByteOrder( QDataStream::LittleEndian ); // To match the user data file

    out << (qint32)SettingsFileVersion;
    out << (qint32)out.version();   // Qt QDataStream version

    QString titleString("Mercury exported settings file"); 
    qint32 titleStringLength = titleString.length();
    out << titleStringLength;
    out.writeRawData( titleString.toAscii(), titleStringLength );

    QDateTime currentDateTime = QDateTime::currentDateTime();
    QString dateString = currentDateTime.toString( tSystemSettings::Instance()->DateFormatString() );
    qint32 dateStringLength = dateString.length();
    out << dateStringLength;
    out.writeRawData( dateString.toAscii(), dateStringLength );
    
    out << currentDateTime;
    out << serialNumber;

    tFile settingsFile( tPath::SettingsIniFile() );
    if (settingsFile.open( QIODevice::ReadOnly | QIODevice::Text ) == false)
    {
        //DbgPrintf( "Failed to open Settings.ini file" );
        return false;
    }

    QTextStream settingsFileStream( &settingsFile );
    QString line;
    int length;
    while ( !settingsFileStream.atEnd() )
    {
        line = settingsFileStream.readLine();
        line.append("\n");
        length = line.length();
        out.writeRawData( line.toAscii(), length );
    }

    settingsFile.close();
    file.close();

    QFileInfo fileInfo( filepath );
    tFile::syncdir( fileInfo.absolutePath() );

    return true;
}
Example #4
0
status_t
TouchpadPref::SaveSettings()
{
	BPath path;
	status_t status = GetSettingsPath(path);
	if (status != B_OK)
		return status;

	BFile settingsFile(path.Path(), B_READ_WRITE | B_CREATE_FILE);
	status = settingsFile.InitCheck();
	if (status != B_OK)
		return status;

	if (settingsFile.Write(&fSettings, sizeof(touchpad_settings))
			!= sizeof(touchpad_settings)) {
		LOG("can't save settings\n");
		return B_ERROR;
	}

	if (settingsFile.Write(&fWindowPosition, sizeof(BPoint))
			!= sizeof(BPoint)) {
		LOG("can't save window position\n");
		return B_ERROR;
	}

	return B_OK;
}
Example #5
0
void
DrishtiImport::saveSettings()
{
  QString str;
  QDomDocument doc("Drishti_Import_v1.0");

  QDomElement topElement = doc.createElement("DrishtiImportSettings");
  doc.appendChild(topElement);

  {
    QDomElement de0 = doc.createElement("previousdirectory");
    QDomText tn0;
    tn0 = doc.createTextNode(Global::previousDirectory());
    de0.appendChild(tn0);
    topElement.appendChild(de0);
  }

  QString homePath = QDir::homePath();
  QFileInfo settingsFile(homePath, ".drishti.import");
  QString flnm = settingsFile.absoluteFilePath();  

  QFile f(flnm.toAscii().data());
  if (f.open(QIODevice::WriteOnly))
    {
      QTextStream out(&f);
      doc.save(out, 2);
      f.close();
    }
  else
    QMessageBox::information(0, "Cannot save ", flnm.toAscii().data());
}
Example #6
0
void
DrishtiImport::loadSettings()
{
  QString homePath = QDir::homePath();
  QFileInfo settingsFile(homePath, ".drishti.import");
  QString flnm = settingsFile.absoluteFilePath();  

  if (! settingsFile.exists())
    return;

  QDomDocument document;
  QFile f(flnm.toAscii().data());
  if (f.open(QIODevice::ReadOnly))
    {
      document.setContent(&f);
      f.close();
    }

  QDomElement main = document.documentElement();
  QDomNodeList dlist = main.childNodes();
  for(uint i=0; i<dlist.count(); i++)
    {
      if (dlist.at(i).nodeName() == "previousdirectory")
	{
	  QString str = dlist.at(i).toElement().text();
	  Global::setPreviousDirectory(str);
	}
    }
}
Example #7
0
status_t
TouchpadPref::LoadSettings()
{
	BPath path;
	status_t status = GetSettingsPath(path);
	if (status != B_OK)
		return status;

	BFile settingsFile(path.Path(), B_READ_ONLY);
	status = settingsFile.InitCheck();
	if (status != B_OK)
		return status;

	if (settingsFile.Read(&fSettings, sizeof(touchpad_settings))
			!= sizeof(touchpad_settings)) {
		LOG("failed to load settings\n");
		return B_ERROR;
	}

	if (settingsFile.Read(&fWindowPosition, sizeof(BPoint))
			!= sizeof(BPoint)) {
		LOG("failed to load settings\n");
		return B_ERROR;
	}

	return B_OK;
}
bool OSMRendererClient::load()
{
	if ( m_advancedSettings == NULL )
		m_advancedSettings = new OSMRSettingsDialog();
	advancedSettingsChanged();
	network = new QNetworkAccessManager( this );
	diskCache = new QNetworkDiskCache( this );
	QString cacheDir = QDesktopServices::storageLocation( QDesktopServices::CacheLocation );
	if ( cacheDir == "" ) {
		cacheDir = QDesktopServices::storageLocation( QDesktopServices::TempLocation );
		QDir dir( cacheDir );
		dir.mkdir( "osmrenderer" );
		dir.cd( "osmrenderer" );
		cacheDir = dir.path();
	}
	qDebug() << "set disk cache to: " << cacheDir;
	diskCache->setCacheDirectory( cacheDir );
	network->setCache( diskCache );
	connect( network, SIGNAL(finished(QNetworkReply*)), this, SLOT(finished(QNetworkReply*)) );
	tileSize = 256;

	QFile settingsFile( fileInDirectory( m_directory, "OSM Renderer" ) + "_settings" );
	if ( !openQFile( &settingsFile, QIODevice::ReadOnly ) )
		return false;

	while ( true ) {
		int zoomLevel;
		if ( settingsFile.read( ( char* ) &zoomLevel, sizeof( zoomLevel ) ) != sizeof( zoomLevel ) )
			break;
		m_zoomLevels.push_back( zoomLevel );
	}

	return true;
}
Example #9
0
void UPnPServerSettings::loadFromFile()
{
    ifstream settingsFile(m_SettingsFile.c_str());
    if (!settingsFile.is_open())
    {
        log::info("No config file present, relying on default values");
        return;
    }

    string line;
    while (getline(settingsFile, line))
    {
        if (line.empty())
        {
            continue;
        }

        std::vector<std::string> items = stringops::tokenize(line, "=");
        if (items.size() != 4)
        {
            log::warn("Warning: ignoring malformed line in config file: %s", line);
            continue;
        }

        upnp::Service service;
        service.m_ControlURL      = stringops::trim(items[3].c_str());
        
        auto server = std::make_shared<upnp::Device>();
        server->m_UserDefinedName    = stringops::trim(items[0].c_str());
        server->m_UDN                = stringops::trim(items[1].c_str());
        server->m_ContainerId        = stringops::trim(items[2].c_str());
        server->m_Services[upnp::ServiceType::ContentDirectory] = service;
        m_Servers.push_back(server);
    }
}
Example #10
0
void MainTray::readSettings()
{
    QDir configDir(QStandardPaths::writableLocation(QStandardPaths::ConfigLocation));
    if (!configDir.exists()) {
        if (!configDir.mkpath(configDir.absolutePath()))
            return;
    }
    QFile settingsFile(configDir.absolutePath() + '/' + ConfigFileName);
    if (settingsFile.open(QIODevice::ReadOnly)) {
        QDataStream settingsReader(&settingsFile);
        settingsReader.setVersion(QDataStream::Qt_5_4);
        QTime tempTime;
        settingsReader >> tempTime;
        updateInterval(tempTime);
        quint64 currentID;
        qint32 sizeSkip;
        while(!settingsReader.atEnd()){
            settingsReader >> currentID;
            for (auto i = m_taskList.begin(); i != m_taskList.end(); ++i) {
                if((*i)->getTaskID()==currentID){
                    settingsReader.device()->seek(settingsReader.device()->pos() - sizeof(quint64));
                    (*i)->readSettings(settingsReader);
                    break;
                }
                if (i == m_taskList.end()-1){
                    // task not found, skip it
                    settingsReader >> sizeSkip;
                    settingsReader.skipRawData(sizeSkip);
                }

            }
        }
void DomainServerSettingsManager::persistToFile() {
    QFile settingsFile(QCoreApplication::applicationDirPath() + SETTINGS_CONFIG_FILE_RELATIVE_PATH);
    
    if (settingsFile.open(QIODevice::WriteOnly)) {
        settingsFile.write(getJSONSettingsMap());
    } else {
        qCritical("Could not write to JSON settings file. Unable to persist settings.");
    }
}
Example #12
0
Result InitComponent::saveConfig()
{
	AudioDeviceManager::AudioDeviceSetup	audioDeviceSetup;

	deviceManager.getAudioDeviceSetup(audioDeviceSetup);

	ScopedPointer<XmlElement> audioDeviceState ( deviceManager.createStateXml() );

	/* create audioDeviceState when no changes were applied to the device settings */
	if (audioDeviceState == NULL)
	{
		audioDeviceState = createXmlSettings(deviceManager);
	}

	/* Check if audioDeviceState is complete */
	String attrString;

	attrString = "audioDeviceRate";
	if ( !audioDeviceState->hasAttribute( attrString ) )
		audioDeviceState->setAttribute(attrString, audioDeviceSetup.sampleRate );
	
	attrString = "audioDeviceBufferSize";
	if ( !audioDeviceState->hasAttribute(attrString ) )
		audioDeviceState->setAttribute( attrString, audioDeviceSetup.bufferSize );

	attrString = "audioDeviceInChans";
	if ( !audioDeviceState->hasAttribute( attrString ) )
		audioDeviceState->setAttribute( attrString,  audioDeviceSetup.inputChannels.toString(2, 1) );

	attrString = "audioDeviceOutChans";
	if ( !audioDeviceState->hasAttribute( attrString ) )
		audioDeviceState->setAttribute( attrString,  audioDeviceSetup.outputChannels.toString(2, 1) );

	/* add more attributes to audioDeviceState */
	XmlElement*	mchaSettings = new XmlElement( "MCHASETTINGS" ); // this will be deleted automatically by the parent
	mchaSettings->setAttribute( "loggingLevel", mchaSettingsComponent->getLogLevel() );
	mchaSettings->setAttribute( "memoryMode", mchaSettingsComponent->getMemoryMode() );
	audioDeviceState->addChildElement(mchaSettings);


	File	settingsFile( settingsFileName );
	if (settingsFile == File::nonexistent)
	{
		return Result::fail( L"Settings file is absent" );;	
	}

	DBG( L"mchaInit:\n   Settings file created:\t" + settingsFile.getFileName() );

	if	( !audioDeviceState->writeToFile ( settingsFile, String::empty ) )
	{
		return Result::fail( L"Unable to save settings" );
	}

	deviceManager.closeAudioDevice();

	return Result::ok();
}
void QgsUserProfileManager::setRootLocation( const QString &rootProfileLocation )
{
  mRootProfilePath = rootProfileLocation;

  //updates (or removes) profile file watcher for new root location
  setNewProfileNotificationEnabled( mWatchProfiles );

  mSettings.reset( new QSettings( settingsFile(), QSettings::IniFormat ) );
}
Example #14
0
EditorConfig::EditorConfig() : _file_watcher(new QFileSystemWatcher())
{
	//Make sure the file exists so that mupuf's horrible file watcher doesn't bug
	QFile settingsFile(QSettings().fileName());
	settingsFile.open(QFile::Append);
	settingsFile.close();

	//Watch for settings updates from other instances
//	_file_watcher->addPath(QSettings().fileName());
//	connect(_file_watcher, SIGNAL(fileChanged(QString)), this, SIGNAL(updated()));
}
Example #15
0
// Parse contents of specified file as JSON and set any settings contained in 
// the JSON to their specified values
bool Settings::SetFromFile(const std::string& filename)
{
    std::stringstream buffer;
    std::ifstream settingsFile(filename.c_str());
   
    // check if file exists
    if (!settingsFile.is_open()) 
        return false;    
    
    buffer << settingsFile.rdbuf();
    
    return SetFromJSONString(buffer.str());
}
// If the print data contains the specified file, read contents into specified 
// string and return true.  Otherwise, return false.
bool PrintDataDirectory::GetFileContents(const std::string& fileName, 
                                         std::string& contents)
{
    std::string path = _directoryPath + "/" + fileName;
    std::ifstream settingsFile(path.c_str());
    if (settingsFile.good())
    {
        std::stringstream buffer;
        buffer << settingsFile.rdbuf();
        contents = buffer.str();
        return true;
    }
    else
        return false;
}
Example #17
0
bool eraseSettings()
{
  QString homePath = QDir::homePath();
  QString settingsFilePath = QDir(homePath).filePath(".config/MapMap/MapMap.conf");
  QFile settingsFile(settingsFilePath);
  if (! settingsFile.exists())
  {
    return false;
  }
  else
  {
    qDebug() << "Erase MapMap settings.";
    settingsFile.close();
    return settingsFile.remove();
  }
}
Example #18
0
JobManager::JobManager(QObject *parent) :
    QObject(parent)
{   
    QDir temp = QDir(QDir::tempPath());

    m_monavSettings = QFileInfo(temp, "monav_settings.ini");
    QFile settingsFile(m_monavSettings.absoluteFilePath());
    settingsFile.open(QFile::WriteOnly | QFile::Truncate);
    QTextStream settingsStream(&settingsFile);

    settingsStream << "[General]\npackaging=false\ndictionarySize=16384\nblockSize=16384\n";
    settingsStream << "importer=OpenStreetMap Importer\nrouter=Contraction Hierarchies";
    settingsStream << "renderer=Mapnik Renderer\ngpsLookup=GPS Grid\naddressLookup=Unicode Tournament Trie\n\n";
    settingsStream << "[OSM%20Importer]\nlanguages=name\nspeedProfile=:/speed profiles/motorcar.spp\n\n";
    settingsStream << "[ContractionHierarchies]\nblockSize=12\n";
    settingsFile.close();
}
Example #19
0
Dispatcher::Dispatcher(char *port, char *settings_file) {
    this->port = port;
    cluster_nodes = new std::vector<struct Host*>;

    std::ifstream settingsFile(settings_file);
    if (!settingsFile.is_open()) {
        log_err("Could not find settings file.");
        throw "Could not find settings file.";
    }
    
    Json::Reader r = Json::Reader();
    Json::Value v;
    debug("Parse settings");
    if (!r.parse(settingsFile, v, false)) {
        log_err("Could not parse settings file! No valid JSON.");
        throw "Could not parse settings file! No valid JSON.";
    }

    Json::Value jsonHosts = v.get("hosts", "");

    for (auto host: jsonHosts) {
        std::string url = host.get("url", "").asString();
        int port = host.get("port", "0").asInt();
        if (url != "" and port != 0) {
            const char *url_c = url.c_str();
            add_host(url_c, port);
        }
    }

    if (cluster_nodes->size() == 0) {
        debug("Settings file does not contain any valid hosts.");
    }

    thread_pool_size = v.get("threads", 1).asInt();

    std::string dispatch_algorithm = v.get("algorithm", "RoundRobin").asString();

    if (dispatch_algorithm == "Stream") {
        distributor = new StreamDistributor(cluster_nodes);
        debug("Used dispatching algorithm: Stream");
    } else {
        //SimpleRoundRobinDipatcher is the standard algorithm
        distributor = new RoundRobinDistributor(cluster_nodes);
        debug("Used dispatching algorithm: RoundRobin");
    }
}
bool Settings::read(QString fname)
{
    QFile settingsFile(fname);
    if (!settingsFile.open(QIODevice::ReadOnly))
        return false;
    QJsonParseError errors;
    QJsonDocument json = QJsonDocument::fromJson(settingsFile.readAll(), &errors);
    if (errors.error != QJsonParseError::NoError)
        return false;
    if (!json.isObject())
        return false;

    auto rootObj = json.object();
    auto workingDir = Files::absPath(rootObj["workingDir"].toString(this->workingDir().path));
    auto downloadsDir = Files::absPath(rootObj["downloadsDir"].toString(this->downloadsDir().path));
    vcVersion = rootObj["vcVersion"].toString();
    if (vcVersion != MSVC_VERSION) {
        vcVarsPath = extractVCVarsPath();
        vcVersion = MSVC_VERSION;
    } else {
        vcVarsPath = rootObj["vcVarsPath"].toString(extractVCVarsPath());
    }
    outputPath = Files::absPath(rootObj["outputPath"].toString(outputPath));
    isFirstUsage = rootObj["isFirstUsage"].toBool(false);
    selfUpdateSourceUrl = rootObj["selfUpdateSourceUrl"].toString(selfUpdateSourceUrl);

    auto librarySourcesArray = rootObj["librarySources"].toArray();
    librarySources.clear();
    librarySources.append(LibrarySource{
        LibrarySource::WorkingDirectory, workingDir, SourceStatus::Unknown });
    librarySources.append(LibrarySource{
        LibrarySource::DownloadsDirectory, downloadsDir, SourceStatus::Unknown });
    foreach (auto sourceValue, librarySourcesArray) {
        auto sourceObj = sourceValue.toObject();
        LibrarySource::Type type = LibrarySource::Directory;
        auto typeStr = sourceObj["type"].toString("directory");
        if (typeStr == "server")
            type = LibrarySource::Server;
        auto path = sourceObj["path"].toString();
        if (path.isEmpty())
            continue;
        if (type != LibrarySource::Server)
            path = Files::absPath(path);
        librarySources.append(LibrarySource{ type, path, SourceStatus::Unknown });
    }
Example #21
0
  /**
   * Clumsily define the defaults application-wide in this constructor.
   * Is there a way to do this in bulk using C++11 uniform initialisation?
   */
  ConfigManager::ConfigManager() {
    configRoot[ "fps_overview" ] = 30;
    configRoot[ "vsync_limiter_overview" ] = false;
    configRoot[ "min_log_level" ] = 0;
    configRoot[ "logfile_path" ] = "bluebear.log";
    configRoot[ "logger_mode" ] = 0;
    configRoot[ "viewport_x" ] = 1024;
    configRoot[ "viewport_y" ] = 768;
    configRoot[ "current_locale" ] = "en_US";
    configRoot[ "key_switch_perspective" ] = sf::Keyboard::P;
    configRoot[ "key_move_up" ] = sf::Keyboard::Up;
    configRoot[ "key_move_down" ] = sf::Keyboard::Down;
    configRoot[ "key_move_left" ] = sf::Keyboard::Left;
    configRoot[ "key_move_right" ] = sf::Keyboard::Right;
    configRoot[ "key_terminal" ] = sf::Keyboard::Tilde;
    configRoot[ "key_pause" ] = sf::Keyboard::Num1;
    configRoot[ "key_play" ] = sf::Keyboard::Num2;
    configRoot[ "key_play_fast" ] = sf::Keyboard::Num3;
    configRoot[ "key_rotate_right" ] = sf::Keyboard::E;
    configRoot[ "key_rotate_left" ] = sf::Keyboard::Q;
    configRoot[ "key_zoom_in" ] = sf::Keyboard::Add;
    configRoot[ "key_zoom_out" ] = sf::Keyboard::Subtract;
    configRoot[ "disable_image_cache" ] = false;
    configRoot[ "disable_texture_cache" ] = false;
    configRoot[ "ui_theme" ] = "system/ui/default.theme";
    configRoot[ "max_ingame_terminal_scrollback" ] = 100; 

    // Load settings.json from file
    std::ifstream settingsFile( SETTINGS_PATH );
    Json::Value settingsJSON;
    Json::Reader reader;

    if( reader.parse( settingsFile, settingsJSON ) ) {
      // Override defaults
      // iterators - barf
      for( Json::Value::iterator jsonIterator = settingsJSON.begin(); jsonIterator != settingsJSON.end(); ++jsonIterator ) {
        // BARF
        Json::Value key = jsonIterator.key();
        Json::Value value = *jsonIterator;

        // Store every value as a string because strong typing is a PITA
        configRoot[ key.asString() ] = value;
      }
    }
  }
Example #22
0
void Conf::init(std::string filename) {

    std::ifstream settingsFile(filename.c_str());
    std::string key;

    while (settingsFile >> key) {

        if (key.compare("#")) {
            std::getline (std::cin,key);
            continue;
        }
        if (key.compare("GyroAcceleration")) {
            settingsFile >> GyroAcceleration;
            continue;
        }
        if (key.compare("GyroForce")) {
            settingsFile >> GyroForce;
            continue;
        }
bool JSONStorage::loadSettings()
{
    //open the json settings file
    QString fullPath = buildFullPath(Settings);
    QFile settingsFile(fullPath);
    if (!settingsFile.open(QIODevice::ReadOnly)) {
        qWarning("Couldn't open save file.");
        return false;
    }

    //read the contents into a bytearray
    QByteArray settingsData = settingsFile.readAll();
    settingsFile.close();

    //store content as a local json structure
    _settingsJson.fromJson(settingsData);

    return true;
}
Example #24
0
void ProtocolHandler::LoadPasswords()
{
	//find settings dir
	BPath passwordPath;
	find_directory(B_USER_SETTINGS_DIRECTORY, &passwordPath);
	//append Bme path and Cache path
	passwordPath.Append(K_BME_SETTINGS_PATH);
	passwordPath.Append(K_CACHE_PATH);
	//loop through Bme Cache path and find all login names with saved passwords
	BDirectory cacheDir(passwordPath.Path());
		
	int32 entryNum = cacheDir.CountEntries();
	//compose list of loginNames with passwords
	for (int32 i = 0; i < entryNum;i++)
	{
		BEntry entry;
		cacheDir.GetNextEntry(&entry);
		//only open if it is a file!!!
		if (entry.IsFile())
		{
			BFile settingsFile(&entry, B_READ_ONLY);
			//data is stored as BMessages
			BMessage message;
			message.Unflatten(&settingsFile);
			//see if password is stored in message
			BString password;
			BMessage userMessage;
			if (message.FindMessage("user",&userMessage) == B_OK)
			{				
				if (userMessage.FindString("User::password",&password) == B_OK)
				{					
					BString loginName;
					if (userMessage.FindString("Contact::passport" ,&loginName) == B_OK)
					{						
						Login login = {loginName,password};
						m_passwords.push_back(login);
					}
				}
			}
		}
	}
}
Example #25
0
bool JurisdictionMap::readFromFile(const char* filename) {
    QString     settingsFile(filename);
    QSettings   settings(settingsFile, QSettings::IniFormat);
    QString     rootCode = settings.value("root","00").toString();
    qDebug() << "rootCode=" << rootCode << "\n";

    _rootOctalCode = hexStringToOctalCode(rootCode);
    printOctalCode(_rootOctalCode);

    settings.beginGroup("endNodes");
    const QStringList childKeys = settings.childKeys();
    QHash<QString, QString> values;
    foreach (const QString &childKey, childKeys) {
        QString childValue = settings.value(childKey).toString();
        values.insert(childKey, childValue);
        qDebug() << childKey << "=" << childValue << "\n";

        unsigned char* octcode = hexStringToOctalCode(childValue);
        printOctalCode(octcode);
        
        _endNodes.push_back(octcode);
    }
Example #26
0
void SettingsDialog::accept()
{
    m_saveSignalCount = 0;

    Q_FOREACH(ConfigurationWidgetInterface *page, pages) {
        if (!page->checkValidity()) {
            stack->setCurrentWidget(page->asWidget());
            return;
        }
        connect(page->asWidget(), SIGNAL(saved()), this, SLOT(slotAccept()));
        ++m_saveSignalCount;
    }

#ifndef Q_OS_WIN
    // Try to wour around QSettings' inability to set umask for its file access. We don't want to set umask globally.
    QFile settingsFile(m_settings->fileName());
    settingsFile.setPermissions(QFile::ReadUser | QFile::WriteUser);
#endif

    buttons->setEnabled(false);
    Q_FOREACH(ConfigurationWidgetInterface *page, pages) {
        page->asWidget()->setEnabled(false);
    }
Example #27
0
PadBlocker::PadBlocker()
{
	_lastKeyUp = 0;
	_threshold = 300; //~one third of a second?

	#if Z_DEBUG
	BeDC dc("PadBlocker");
	#endif

	//load settings file

	BPath settingsPath;
	if (find_directory(B_USER_SETTINGS_DIRECTORY, &settingsPath) == B_OK)
	{
		settingsPath.Append("PadBlocker_settings");
		BEntry settingsEntry(settingsPath.Path());
		
		//does the settings file exist?
		if (!settingsEntry.Exists())
		{
			#if Z_DEBUG
			dc.SendMessage("Settings file does not exist. Creating new one.");
			#endif

		
			BFile defaultSettingsFile(&settingsEntry, B_CREATE_FILE | B_READ_WRITE);

			if (defaultSettingsFile.IsWritable())
			{
				//write in default settings
				char buf[64];
				sprintf(buf, "%ld #delay in 1/1000 secs", (int32)_threshold);
				defaultSettingsFile.WriteAt(0, (void *)buf, strlen(buf));
				defaultSettingsFile.Unset();
			}
				
		}
		else
		{
			#if Z_DEBUG
			dc.SendMessage("Settings file Exists");
			#endif
		
			BFile settingsFile(&settingsEntry, B_READ_WRITE);
		
			if (settingsFile.IsReadable())
			{
				char buf[256];
				uint32 amt_read = settingsFile.ReadAt(0, (void *)buf, 256);
				buf[amt_read] = '\0';
				_threshold = atoi(buf);
			}
		}
	}
		
	_threshold *= 1000; //I'd rather keep the number in the file in thousandths
	
	#ifdef Z_DEBUG
	dc.SendInt(_threshold, "Touchpad threshold.");
	#endif
}
void Gdc2005Demo::optionUpdate()
{
	const hkVector4 UP(0,1,0);

	// Handle load save

	//Set capsule size.
	{
		const hkReal totalHeight = m_options.m_Proxy.m_height;
		const hkReal radius = m_options.m_Proxy.m_radius;
		const hkReal capsulePoint = totalHeight*0.5f - radius;

		updateProxyDisplay(m_options.m_Proxy.m_radius, m_options.m_Proxy.m_height);

		hkVector4 vertexA(0, capsulePoint * 2 + radius, 0);
		hkVector4 vertexB(0, radius, 0);
		hkpCapsuleShape* capsule = static_cast<hkpCapsuleShape*>( const_cast<hkpShape*>(m_characterProxy->getShapePhantom()->getCollidable()->getShape() ));
		capsule->setRadius( radius );
		capsule->setVertex(0, vertexA);
		capsule->setVertex(1, vertexB);
	}

	// Set gravity
	hkVector4 gravity;
	gravity.setMul4( -m_options.m_Physics.m_gravity, UP);
	m_world->setGravity( gravity );

	// Ragdoll bodies (green)
	if (m_options.m_Display.m_ragdoll != m_ragdollDisplayBodiesVisible )
	{
		toggleRagdollVisibility();
	}

	if (m_options.m_Display.m_proxy != m_proxyVisible)
	{
		toggleProxyVisibility();
	}

	// Graphics
	hkDefaultDemo::forceShadowState( m_options.m_Display.m_shadows );

	if (m_lightmapDisplay)
	{
		if (m_options.m_Display.m_lightmaps)
		{
			int vertsIn = m_env->m_displayWorld->findDisplayObject( m_vertexColorDisplay );
			if (vertsIn >= 0 )
			{
				m_env->m_displayWorld->removeDisplayObject( vertsIn );
				m_vertexColorDisplay->release(); // already have a ref anyway
				m_env->m_displayWorld->addDisplayObject( m_lightmapDisplay );
			}
		}
		else
		{
			int lmIn = m_env->m_displayWorld->findDisplayObject( m_lightmapDisplay );
			if (lmIn >= 0 )
			{
				m_env->m_displayWorld->removeDisplayObject( lmIn );
				m_lightmapDisplay->release(); // already have a ref anyway
				m_env->m_displayWorld->addDisplayObject( m_vertexColorDisplay );
			}
		}
	}

	hkReal w = hkMath::max2(
		  m_animatedSkeleton->getAnimationControl(GDC_DEATH_CONTROL)->getWeight(),
		  m_animatedSkeleton->getAnimationControl(GDC_DYING_CONTROL)->getWeight());

	setMotors(m_ragdollInstance,
		m_options.m_Matching.m_force * w,
		m_options.m_Matching.m_tau,
		m_options.m_Matching.m_proportinalRecovery,
		m_options.m_Matching.m_constantRecovery);

	// Do rebuild walls, save and load from XML, etc., when we have finished tweaking
	if (m_tweaking == false)
	{

		switch (m_options.m_Misc.m_settings)
		{
			case hkGdcMiscOptions::SAVE:
				{
					hkBinaryPackfileWriter pw;
					pw.setContents(&m_options, Gdc2005DemoOptionsClass);

					hkOfstream settingsFile("GdcDemoSettings.bin");
					if (settingsFile.isOk())
					{
						hkPackfileWriter::Options o;
						pw.save( settingsFile.getStreamWriter(), o );
					}
				}
				break;
			case hkGdcMiscOptions::LOAD:
				{
					hkBinaryPackfileReader pw;

					hkIfstream settingsFile("GdcDemoSettings.bin");
					if (settingsFile.isOk())
					{
						pw.loadEntireFile( settingsFile.getStreamReader() );
						Gdc2005DemoOptions* options = (Gdc2005DemoOptions*)pw.getContents(Gdc2005DemoOptionsClass.getName());
						m_options = *options;
					}
				}
				break;
			case hkGdcMiscOptions::DEFAULT:
				{
					// Copy from defaults
					m_options = Gdc2005DemoOptions();
					m_selected = "/";
				}
				break;
			case hkGdcMiscOptions::NONE:
				break;
		}
		m_options.m_Misc.m_settings = hkGdcMiscOptions::NONE;

		if (m_options.m_Physics.m_rebuildWall)
		{
			rebuildBrickWall();
			m_options.m_Physics.m_rebuildWall = false; // reset
		}
	}
}
Example #29
0
SettingsDialog::SettingsDialog(QWidget* parent) :
    QDialog(parent)
#else
SettingsDialog::SettingsDialog(const QString& graverFileFilter, QWidget* parent) :
    QDialog(parent), graverFileFilter(graverFileFilter)
#endif
{
    ui.setupUi(this);
    setWindowFlags(Qt::MSWindowsFixedSizeDialogHint);
#ifdef TEST_ONLY
    QSettings settingsFile("tokenTest_Settings.ini", QSettings::IniFormat);
#else
    QSettings settingsFile("tokenGraver_Settings.ini", QSettings::IniFormat);
#endif
    settings.testingType    = static_cast<TestingType>(settingsFile.value("testingType").toUInt());
    settings.fullTestInterval       = settingsFile.value("interval").toUInt();
    settings.fileName       = settingsFile.value("fileName").toString();
    settings.currentTestingCounter        = settingsFile.value("counter").toUInt();
    settings.connectionType = static_cast<ConnectionType>(settingsFile.value("connectionType").toUInt());
//    int i = 0;
//    while (true) {
//        QString portChain = settingsFile.value("calibrationData" + QString::number(i)).toString();
//        if (portChain.isEmpty())
//            break;
//        else {
//            if (i >= settings.calibrationData.size())
//                settings.calibrationData.resize(i + 1);
//            settings.calibrationData[i] = portChain;
//        }
//        ++i;
//    }
#ifdef TEST_ONLY
    ui.fileEdit->setVisible(false);
    ui.fileButton->setVisible(false);
    ui.fileLabel->setVisible(false);
#else
    ui.connectionTypeComboBox->removeItem(2);
    ui.connectionTypeComboBox->removeItem(1);
#endif
    applySettings();
}

//----------------------------------------------------------------------------------------------------------------------
void SettingsDialog::saveSettings()
{
    TestingType testingType;
    if (ui.quickTestButton->isChecked())
        testingType = TT_QUICK;
    else if (ui.autoTestButton->isChecked())
        testingType = TT_AUTO;
    else if (ui.fullTestButton->isChecked())
        testingType = TT_FULL;
    else
        assert(false);
    settings.testingType = testingType;
    settings.fullTestInterval = ui.nSpinBox->value();
    settings.fileName = ui.fileEdit->text();
    settings.connectionType = static_cast<ConnectionType>(ui.connectionTypeComboBox->currentIndex());

#ifdef TEST_ONLY
    QSettings settingsFile("tokenTest_Settings.ini", QSettings::IniFormat);
#else
    QSettings settingsFile("tokenGraver_Settings.ini", QSettings::IniFormat);
#endif

    settingsFile.setValue("testingType", settings.testingType);
    settingsFile.setValue("interval", settings.fullTestInterval);
    settingsFile.setValue("fileName", settings.fileName);
    settingsFile.setValue("counter", settings.currentTestingCounter);
    settingsFile.setValue("connectionType", settings.connectionType);

//    if (settings.connectionType == CT_SEVEN_TWO_COLUMNS) {
//        settings.calibrationData.resize(7);
//        for (int i = 0; i < 7; ++i)
//            settings.calibrationData[i] = QString::number(i + 1);
//    } else if (settings.connectionType == CT_SEVEN_ONE_ROW) {
//        settings.calibrationData.clear();
//        int i = 0;
//        while (true) {
//            QString portChain = settingsFile.value("calibrationData" + QString::number(i)).toString();
//            if (portChain.isEmpty())
//                break;
//            else {
//                if (i >= settings.calibrationData.size())
//                    settings.calibrationData.resize(i + 1);
//                settings.calibrationData[i] = portChain;
//            }
//            ++i;
//        }
//    }
}
Example #30
0
void CrashHandler::handleCrash(CrashHandler::Action action) {
    if (action != CrashHandler::DELETE_INTERFACE_INI && action != CrashHandler::RETAIN_IMPORTANT_INFO) {
        // CrashHandler::DO_NOTHING or unexpected value
        return;
    }

    QSettings settings;
    const QString ADDRESS_MANAGER_GROUP = "AddressManager";
    const QString ADDRESS_KEY = "address";
    const QString AVATAR_GROUP = "Avatar";
    const QString DISPLAY_NAME_KEY = "displayName";
    const QString FULL_AVATAR_URL_KEY = "fullAvatarURL";
    const QString FULL_AVATAR_MODEL_NAME_KEY = "fullAvatarModelName";
    const QString TUTORIAL_COMPLETE_FLAG_KEY = "tutorialComplete";

    QString displayName;
    QUrl fullAvatarURL;
    QString fullAvatarModelName;
    QUrl address;
    bool tutorialComplete = false;

    if (action == CrashHandler::RETAIN_IMPORTANT_INFO) {
        // Read avatar info

        // Location and orientation
        settings.beginGroup(ADDRESS_MANAGER_GROUP);
        address = settings.value(ADDRESS_KEY).toUrl();
        settings.endGroup();

        // Display name and avatar
        settings.beginGroup(AVATAR_GROUP);
        displayName = settings.value(DISPLAY_NAME_KEY).toString();
        fullAvatarURL = settings.value(FULL_AVATAR_URL_KEY).toUrl();
        fullAvatarModelName = settings.value(FULL_AVATAR_MODEL_NAME_KEY).toString();
        settings.endGroup();

        // Tutorial complete
        tutorialComplete = settings.value(TUTORIAL_COMPLETE_FLAG_KEY).toBool();
    }

    // Delete Interface.ini
    QFile settingsFile(settings.fileName());
    if (settingsFile.exists()) {
        settingsFile.remove();
    }

    if (action == CrashHandler::RETAIN_IMPORTANT_INFO) {
        // Write avatar info

        // Location and orientation
        settings.beginGroup(ADDRESS_MANAGER_GROUP);
        settings.setValue(ADDRESS_KEY, address);
        settings.endGroup();

        // Display name and avatar
        settings.beginGroup(AVATAR_GROUP);
        settings.setValue(DISPLAY_NAME_KEY, displayName);
        settings.setValue(FULL_AVATAR_URL_KEY, fullAvatarURL);
        settings.setValue(FULL_AVATAR_MODEL_NAME_KEY, fullAvatarModelName);
        settings.endGroup();

        // Tutorial complete
        settings.setValue(TUTORIAL_COMPLETE_FLAG_KEY, tutorialComplete);
    }
}