chrono::milliseconds ConfigFile::forceSyncInterval(const QString &connection) const
{
    auto pollInterval = remotePollInterval(connection);

    QString con(connection);
    if (connection.isEmpty())
        con = defaultConnection();
    QSettings settings(configFile(), QSettings::IniFormat);
    settings.beginGroup(con);

    auto defaultInterval = chrono::hours(2);
    auto interval = millisecondsValue(settings, forceSyncIntervalC, defaultInterval);
    if (interval < pollInterval) {
        qCWarning(lcConfigFile) << "Force sync interval is less than the remote poll inteval, reverting to" << pollInterval.count();
        interval = pollInterval;
    }
    return interval;
}

chrono::milliseconds ConfigFile::updateCheckInterval(const QString &connection) const
{
    QString con(connection);
    if (connection.isEmpty())
        con = defaultConnection();
    QSettings settings(configFile(), QSettings::IniFormat);
    settings.beginGroup(con);

    auto defaultInterval = chrono::hours(10);
    auto interval = millisecondsValue(settings, updateCheckIntervalC, defaultInterval);

    auto minInterval = chrono::minutes(5);
    if (interval < minInterval) {
        qCWarning(lcConfigFile) << "Update check interval less than five minutes, resetting to 5 minutes";
        interval = minInterval;
    }
    return interval;
}

void MirallConfigFile::setProxyType(int proxyType,
                  const QString& host,
                  int port,
                  const QString& user,
                  const QString& pass)
{
    QSettings settings( configFile(), QSettings::IniFormat );
    settings.setIniCodec( "UTF-8" );
    settings.beginGroup(QLatin1String("proxy"));

    settings.setValue(QLatin1String("type"), proxyType);
    settings.setValue(QLatin1String("host"), host);
    settings.setValue(QLatin1String("port"), port);
    settings.setValue(QLatin1String("user"), user);
    settings.setValue(QLatin1String("pass"), pass);

    settings.sync();
}

void initialiseCmdLineArgs( KCmdLineOptions& options )
{
   QString configFileName = KStandardDirs().findResource("config","kdiff3rc");
   QFile configFile( configFileName );
   QString ignorableOptionsLine = "-u;-query;-html;-abort";
   if ( configFile.open( QIODevice::ReadOnly ) )
   {
      QTextStream ts( &configFile );
      while(!ts.atEnd())
      {
         QString line = ts.readLine();
         if ( line.startsWith("IgnorableCmdLineOptions=") )
         {
            int pos = line.indexOf('=');
            if (pos>=0)
            {
               ignorableOptionsLine = line.mid(pos+1);
            }
            break;
         }
      }
   }

#ifdef KREPLACEMENTS_H
   QStringList sl = ignorableOptionsLine.split( '|' );
#else
   QStringList sl = ignorableOptionsLine.split( ',' );
#endif
   if (!sl.isEmpty())
   {
      QStringList ignorableOptions = sl.front().split( ';' );
      for (QStringList::iterator i=ignorableOptions.begin(); i!=ignorableOptions.end(); ++i)
      {
         (*i).remove('-');
         if (!(*i).isEmpty())
         {
            if ( i->length()==1 )
               options.add( i->toLatin1() ).add("ignore", ki18n("Ignored. (User defined.)") );
            else
               options.add( i->toLatin1(), ki18n("Ignored. (User defined.)") );
         }
      }
   }
}

void loadConfigs() {
    std::ifstream configFile("Inspect.config");
    if (configFile.is_open()) {
        std::string line;
        
        //1st config line: Modelsim Path
        std::getline(configFile, line);
        vsimDir = split(line, '=')[1];
        
        //2nd config line: Modelsim Path
        std::getline(configFile, line);
        legUpDir = split(line, '=')[1];           
        
        //3rd config line: Example Path
        std::getline(configFile, line);
        workDir = split(line, '=')[1];
		
        //4th config line: Example File
        std::getline(configFile, line);
        fileName = split(line, '=')[1];
        
        //5th config line: DB host
        std::getline(configFile, line);
        dbHost = split(line, '=')[1];
        
        //6th config line: DB user
        std::getline(configFile, line);
        dbUser = split(line, '=')[1];
        
        //7th config line: DB pass
        std::getline(configFile, line);
        dbPass = split(line, '=')[1];
        
        //8th config line: DB name
        std::getline(configFile, line);
        dbName = split(line, '=')[1];
        
        configFile.close();
        
    } else {
        std::cout << "config file not found. Program is exiting." << std::endl;
        exit(1);
    }
}

void RoboyControlConfiguration::readConfig() {
    m_listControllerConfig.clear();
    m_mapModelConfig.clear();

    QString roboyControlHome = QProcessEnvironment::systemEnvironment().value("ROBOY_CONTROL_HOME");
    if (roboyControlHome == "") {
        CONFIG_DBG << " - ERROR: Environment Variable not set.";
        CONFIG_DBG << "Set the environment variable ROBOY_CONTROL_HOME to the installation"
                "directory of RoboyControl. Add the line\n"
                "\texport ROBOY_CONTROL_HOME=<path_to_roboy_control>"
                "to your ~/.bash_rc file.";
        exit(0);
    }

    QString filename = roboyControlHome + "/etc/" + CONFIG_FILE_NAME;
    QFile configFile(filename);

    if( !configFile.open(QFile::ReadOnly | QFile::Text) ) {
        CONFIG_DBG << " - ERROR opening file: " << filename;
        CONFIG_DBG << "Make sure your environment is set up correctly and the configuration file"
                "is placed in /etc of your <roboy_control_install_dir>.";
    }

    CONFIG_DBG << "INFO open successful: " << filename;

    m_xmlReader.setDevice(&configFile);

    m_xmlReader.readNextStartElement();
    if (m_xmlReader.name() == "RoboyControlConfiguration") {
        while(m_xmlReader.readNextStartElement()) {
            if (m_xmlReader.name() == "DataModel") {
                CONFIG_DBG << "Read Model Config";
                readModelConfig();
            } else if (m_xmlReader.name() == "Controllers") {
                CONFIG_DBG << "Read Controllers Config";
                readControllersConfig();
            } else {
                m_xmlReader.skipCurrentElement();
            }
        }
    } else {
        CONFIG_DBG << " - ERROR found invalid config file.";
    }
}

bool MirallConfigFile::writePassword( const QString& passwd, const QString& connection )
{
    const QString file = configFile();
    QString pwd( passwd );
    QString con( defaultConnection() );
    if( !connection.isEmpty() )
        con = connection;

    QSettings settings( file, QSettings::IniFormat);
    settings.setIniCodec( "UTF-8" );

    // store password into settings file.
    settings.beginGroup( con );
    QByteArray pwdba = pwd.toUtf8();
    settings.setValue( QLatin1String("passwd"), QVariant(pwdba.toBase64()) );
    settings.sync();

    return true;
}

bool AppearanceGTK2::loadSettings(const QString& path)
{
    QFile configFile(path);
    
    bool canRead = configFile.open(QIODevice::ReadOnly | QIODevice::Text);
    
    if(canRead) {
//         qDebug() << "The gtk2 config file exists...";
        const QMap<QString, QString> foundSettings = readSettingsTuples(&configFile);
        m_settings = QMap<QString, QString> {
            {"toolbar_style", "GTK_TOOLBAR_ICONS"},
            {"show_icons_buttons", "0"},
            {"show_icons_menus", "0"},
            {"primary_button_warps_slider", "false"}
        };

        for(auto it = foundSettings.constBegin(), itEnd = foundSettings.constEnd(); it!=itEnd; ++it) {
            if (it.key() == "gtk-theme-name")
                m_settings["theme"] = *it;
            else if (it.key() == "gtk-icon-theme-name")
                m_settings["icon"] = *it;
            else if (it.key() == "gtk-fallback-icon-theme")
                m_settings["icon_fallback"] = *it;
            else if (it.key() == "gtk-cursor-theme-name")
                m_settings["cursor"] = *it;
            else if (it.key() == "gtk-font-name")
                m_settings["font"] = *it;
            else if (it.key() == "gtk-toolbar-style")
                m_settings["toolbar_style"] = *it;
            else if (it.key() == "gtk-button-images")
                m_settings["show_icons_buttons"] = *it;
            else if(it.key() == "gtk-menu-images")
                m_settings["show_icons_menus"] = *it;
            else if (it.key() == "gtk-primary-button-warps-slider")
                m_settings["primary_button_warps_slider"] = *it;
            else
                qWarning() << "unknown field" << it.key();
        }

    }
    
    return canRead;
}

/*
 * returns the configured owncloud url if its already configured, otherwise an empty
 * string.
 * The returned url always has a trailing hash.
 * If webdav is true, the webdav-server url is returned.
 */
QString MirallConfigFile::ownCloudUrl( const QString& connection, bool webdav ) const
{
    QString con( connection );
    if( connection.isEmpty() ) con = defaultConnection();

    QSettings settings( configFile(), QSettings::IniFormat );
    settings.setIniCodec( "UTF-8" );
    settings.beginGroup( con );

    QString url = settings.value( QLatin1String("url") ).toString();
    if( ! url.isEmpty() ) {
        if( ! url.endsWith(QLatin1Char('/'))) url.append(QLatin1String("/"));
        if( webdav ) url.append( QLatin1String("remote.php/webdav/") );
    }

    qDebug() << "Returning configured owncloud url: " << url;

  return url;
}

bool GPSGridClient::LoadData()
{
	UnloadData();
	QString filename = fileInDirectory( directory, "GPSGrid" );
	QFile configFile( filename + "_config" );
	if ( !openQFile( &configFile, QIODevice::ReadOnly ) )
		return false;

	index = new gg::Index( filename + "_index" );
	index->SetCacheSize( 1024 * 1024 * cacheSize / 4 );

	gridFile = new QFile( filename + "_grid" );
	if ( !gridFile->open( QIODevice::ReadOnly ) ) {
		qCritical() << "failed to open file: " << gridFile->fileName();
		return false;
	}

	return true;
}

void ConfigFile::setProxyType(int proxyType,
    const QString &host,
    int port, bool needsAuth,
    const QString &user,
    const QString &pass)
{
    QSettings settings(configFile(), QSettings::IniFormat);

    settings.setValue(QLatin1String(proxyTypeC), proxyType);

    if (proxyType == QNetworkProxy::HttpProxy || proxyType == QNetworkProxy::Socks5Proxy) {
        settings.setValue(QLatin1String(proxyHostC), host);
        settings.setValue(QLatin1String(proxyPortC), port);
        settings.setValue(QLatin1String(proxyNeedsAuthC), needsAuth);
        settings.setValue(QLatin1String(proxyUserC), user);
        settings.setValue(QLatin1String(proxyPassC), pass.toUtf8().toBase64());
    }
    settings.sync();
}

DomainServerSettingsManager::DomainServerSettingsManager() :
    _descriptionObject(),
    _settingsMap()
{
    // load the description object from the settings description
    QFile descriptionFile(QCoreApplication::applicationDirPath() + SETTINGS_DESCRIPTION_RELATIVE_PATH);
    descriptionFile.open(QIODevice::ReadOnly);
    
    _descriptionObject = QJsonDocument::fromJson(descriptionFile.readAll()).object();
    
    // load the existing config file to get the current values
    QFile configFile(QCoreApplication::applicationDirPath() + SETTINGS_CONFIG_FILE_RELATIVE_PATH);
    
    if (configFile.exists()) {
        configFile.open(QIODevice::ReadOnly);
        
        _settingsMap = QJsonDocument::fromJson(configFile.readAll()).toVariant().toMap();
    }
}

void ConfigUI::onPushbuttonSaveClicked()
{
    QFile configFile("config.ini");
    if(!configFile.open(QIODevice::WriteOnly | QIODevice::Text))
        return;
    QTextStream out(&configFile);
    out << "DBname ";
    out << lineEdit_DBname->text() << "\n";
    out << "DBuser ";
    out << lineEdit_DBuser->text() << "\n";
    out << "DBpassword ";
    out << lineEdit_DBpw->text() << "\n";
    out << "port ";
    out << lineEdit_port->text() << "\n";
    configFile.close();

    QMessageBox::about(this,"ConfigMSG",QStringLiteral("保存成功"));

}

void FileSettingsHash::loadSettingsFor(QString filename, MediaSettings & mset)
{
    qDebug("FileSettings::loadSettingsFor: '%s'", filename.toUtf8().constData());

    QString config_file = configFile(filename);

    qDebug("FileSettingsHash::loadSettingsFor: config_file: '%s'", config_file.toUtf8().constData());

    mset.reset();

    if ((!config_file.isEmpty()) && (QFile::exists(config_file)))
    {
        QSettings settings(config_file, QSettings::IniFormat);

        settings.beginGroup("file_settings");
        mset.load(&settings);
        settings.endGroup();
    }
}

int main(int argc, char *argv[])
{
    if ( argc != 2 )
    {
        /* display usage on error stream */
        fprintf(stderr, "usage: znm-project project_name\n\n");
        exit(1);  /* exit status of the program : non-zero for errors */
    }

    if ( QString("--help") == argv[1] )
    {
        printf ("usage: znm-project project_name\nCreates a zenom project.\n\n");
        exit(0);  /* exit status of the program : non-zero for errors */
    }

    QDir projectDir;
    if ( projectDir.exists( argv[1] ) )
    {
        fprintf(stderr, "The project cannot be created because '%s' folder already exists.\n", argv[1]);
        exit(1);  /* exit status of the program : non-zero for errors */
    }

    projectDir.mkpath( argv[1] );
    projectDir.cd( argv[1] );

    QFileInfo programFileInfo( getexepath() );
    QString projectName( QFileInfo(argv[1]).fileName() );

    createFile( programFileInfo.dir().filePath("znm-project-main.template"), projectDir.filePath("main.cpp"), projectName );
    createFile( programFileInfo.dir().filePath("znm-project-makefile.template"), projectDir.filePath("Makefile"), projectName );

    // Open project file to write
    QFile configFile( projectDir.filePath(QString("%1.znm").arg(projectName)) );
    if ( !configFile.open(QFile::WriteOnly | QFile::Text) )
    {
        fprintf(stderr, "The project cannot be created because the file '%s' could not be opened.\n", configFile.fileName().toAscii().data());
        exit(1);  /* exit status of the program : non-zero for errors */
    }
    configFile.close();

    return 0;
}

int MirallConfigFile::localPollInterval( const QString& connection ) const
{
  QString con( connection );
  if( connection.isEmpty() ) con = defaultConnection();

  QSettings settings( configFile(), QSettings::IniFormat );
  settings.setIniCodec( "UTF-8" );
  settings.beginGroup( con );

  int remoteInterval = settings.value( QLatin1String("remotePollInterval"), DEFAULT_REMOTE_POLL_INTERVAL ).toInt();
  int localInterval  = settings.value(QLatin1String("localPollInterval"), DEFAULT_LOCAL_POLL_INTERVAL ).toInt();
  if( remoteInterval < 2*localInterval ) {
    qDebug() << "WARN: remote poll Interval should at least be twice as local poll interval!";
  }
  if( localInterval < 2500 || remoteInterval < localInterval ) {
    qDebug() << "Remote Interval is smaller than local Interval";
    localInterval = DEFAULT_LOCAL_POLL_INTERVAL;
  }
  return localInterval;
}

int
MyApp::OnExit()
{
    // Save config file
    wxFileName configFile(GetConfigFile());
    if (! configFile.DirExists())
        configFile.Mkdir(0777, wxPATH_MKDIR_FULL);

    wxFileConfig * config = dynamic_cast<wxFileConfig*>(wxFileConfig::Get());
    wxASSERT(config != NULL);

    wxFileOutputStream fileStream(configFile.GetFullPath());
    config->Save(fileStream);

    // Clean up printing stuff.
    delete g_printData;
    delete g_pageSetupData;

    return wxApp::OnExit();
}

int main(int argc, char* argv[])
{
    orbManager = new ORBManager(argc, argv);

    string configFilename = "iviScope.ini"; //default

    ConfigFile configFile(configFilename);

    string logicalName = "IVI Scope";
    if (!(configFile.getParameter("logicalName", logicalName)))
        cout << "Could not find logical name in config file." << endl;

    IVIScopeDevice scope1(orbManager, logicalName, configFilename);

    scope1.setSaveAttributesToFile(true);

    orbManager->run();

    return 0;
}

    virtual void SetUp() {
        runtime_ = CommonAPI::Runtime::get();
        ASSERT_TRUE((bool)runtime_);

#ifdef WIN32
        configFileName_ = _pgmptr;
#else
        char cCurrentPath[FILENAME_MAX];
        if(getcwd(cCurrentPath, sizeof(cCurrentPath)) == NULL) {
            std::perror("DBusProxyFactoryTest::SetUp");
        }
        configFileName_ = cCurrentPath;
#endif

        configFileName_ += DBUS_CONFIG_SUFFIX;
        std::ofstream configFile(configFileName_);
        ASSERT_TRUE(configFile.is_open());
        configFile << fileString;
        configFile.close();
    }

void CConfig::SaveToFile()
{
    QFile configFile(CFG_FILE);
    if(!configFile.open(QIODevice::WriteOnly))return;

    QTextStream outStream(&configFile);

    outStream<<_config.strCamUrl_GV.data()<<"\n";
    outStream<<_config.strCamUrl_GV_ir.data()<<"\n";
    outStream<<QString::number(_config.trkWidth)<<"\n";
    outStream<<QString::number(_config.trkHeight)<<"\n";
    outStream<<QString::number(_config.frmPosX)<<"\n";
    outStream<<QString::number(_config.frmPosY)<<"\n";
    outStream<<QString::number(_config.frmWidth)<<"\n";
    outStream<<QString::number(_config.frmHeight)<<"\n";
    outStream<<QString::number(_config.fps)<<"\n";
    outStream<<QString::number(_config.ipCam)<<"\n";
    //Close the file
    configFile.close();
}