GlobalOptions.cc

/*===========================================================================*\
*                                                                            *
*                              OpenFlipper                                   *
 *           Copyright (c) 2001-2015, RWTH-Aachen University                 *
 *           Department of Computer Graphics and Multimedia                  *
 *                          All rights reserved.                             *
 *                            www.openflipper.org                            *
 *                                                                           *
 *---------------------------------------------------------------------------*
 * This file is part of OpenFlipper.                                         *
 *---------------------------------------------------------------------------*
 *                                                                           *
 * Redistribution and use in source and binary forms, with or without        *
 * modification, are permitted provided that the following conditions        *
 * are met:                                                                  *
 *                                                                           *
 * 1. Redistributions of source code must retain the above copyright notice, *
 *    this list of conditions and the following disclaimer.                  *
 *                                                                           *
 * 2. Redistributions in binary form must reproduce the above copyright      *
 *    notice, this list of conditions and the following disclaimer in the    *
 *    documentation and/or other materials provided with the distribution.   *
 *                                                                           *
 * 3. Neither the name of the copyright holder nor the names of its          *
 *    contributors may be used to endorse or promote products derived from   *
 *    this software without specific prior written permission.               *
 *                                                                           *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS       *
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A           *
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,  *
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,       *
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR        *
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF    *
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING      *
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS        *
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.              *
*                                                                            *
\*===========================================================================*/
 
 
//=============================================================================
//
//  Options used throughout the System
//
//=============================================================================
 
#include <QDir>
 
#include "GlobalOptions.hh"
#include <iostream>
#include <ACG/GL/ShaderGenerator.hh>
#include <OpenFlipper/BasePlugin/PluginFunctionsViewControls.hh>
#include <QCoreApplication>
 
namespace OpenFlipper {
namespace Options {
 
static QString compilerInfo_ = "";
  
static OpenFlipperQSettings* settings_ = 0;  
 
static QDir applicationDir_;
 
static QDir configDir_;
 
static QDir pluginDir_;
 
static QDir shaderDir_;
 
static QDir textureDir_;
 
static QDir licenseDir_;
 
static QDir scriptDir_;
 
static QDir iconDir_;
 
static QIcon* OpenFlipperIcon_ = 0;
 
static QDir translationsDir_;
 
static QDir fontsDir_;
 
static QDir helpDir_;
 
static QDir dataDir_;
 
static QDir currentDir_;
 
static QDir currentScriptDir_;
 
static QDir currentTextureDir_;
 
static bool startup_ = false;
 
static bool deleteIniFile_ = false;
 
static bool nogui_ = false;
 
static bool stereo_ = true;
 
static bool coreProfile_ = false;
static bool profileOverride_ = false;
 
static QPair<int,int> version_ {4,6};
static bool versionOverride_ = false;
 
static int samples_ = 4;
static bool samplesOverride_ = false;
 
static bool glStereo_ = true;
static bool overrideGLStereo_ = false;
static bool requestedGLStereo = false;
static bool GLStereoSet = false;
 
static StereoMode stereoMode_ = OpenGL;
 
static std::vector<float> anaglyphLeftEyeColors_ = std::vector<float> (9, 0.0);
static std::vector<float> anaglyphRightEyeColors_ = std::vector<float> (9, 0.0);
 
static bool synchronization_ = false;
 
static std::vector<ACG::SceneGraph::DrawModes::DrawMode> defaultDrawMode_ = std::vector<ACG::SceneGraph::DrawModes::DrawMode> (4, ACG::SceneGraph::DrawModes::SOLID_SMOOTH_SHADED);
 
static int defaultViewerLayout_ = 0;
 
static int redrawDisabled_ = 0;
 
static bool drawModesInContextMenu_ = true;
 
static QString currentViewMode_ = "";
 
static QString title_ = TOSTRING(PRODUCT_NAME)" v?";
 
static QColor defaultColor_ = QColor("white");
 
static bool randomDefaultColor_ = false;
 
static bool scripting_ = false;
 
static bool logToConsole_ = false;
 
static bool debug_ = false;
 
static bool doSlotDebugging_ = false;
 
static QString lastDataType_ = "Triangle Mesh";
 
static bool enableBackup_ = true;
 
static int sceneGraphUpdatesBlocked_ = 0;
 
static bool loadingRecentFile_ = false;
 
static bool savingSettings_ = false;
 
static int* argc_;
 
static char *** argv_;
 
static bool remoteControl_ = false;
 
static int remoteControlPort_ = 2000;
 
# if __WORDSIZE == 64
  const bool is64 = true;
#else
  const bool is64 = false;
#endif
 
#if defined(WIN32)
  const bool linux_ = false;
  const bool windows_ = true;
  const bool darwin_ = false;
#elif defined(ARCH_DARWIN)
  const bool darwin_ = true;
  const bool linux_ = false;
  const bool windows_ = false;
#else
  const bool darwin_ = false;
  const bool linux_ = true;
  const bool windows_ = false;
#endif
 
bool is64bit() { return is64; };
bool is32bit() { return !is64; };
 
bool isLinux() {
  return linux_;
}
 
bool isWindows() {
  return windows_;
}
 
bool isDarwin() {
 return darwin_;
}
 
 
QString lang() {
  QString lang = getenv( "LANG" ) ;
  return lang;
}
 
QString dirSeparator() {
//   if (windows_)
//     return QString("\\");
//   if (linux_)
//     return QString("/");
 
  return QString("/");
}
 
QDir applicationDir()   { return applicationDir_; }
QDir configDir()        { return configDir_;  }
QDir pluginDir()        { return pluginDir_;  }
QDir shaderDir()        { return shaderDir_;  }
QDir textureDir()       { return textureDir_; }
QDir licenseDir()       { return licenseDir_; }
QDir scriptDir()        { return scriptDir_; }
QDir iconDir()          { return iconDir_;    }
QDir translationsDir()  { return translationsDir_;   }
QDir fontsDir()         { return fontsDir_;   }
QDir helpDir()          { return helpDir_;    }
QDir dataDir()          { return dataDir_;    }
QDir currentDir()       { return currentDir_; }
QDir currentScriptDir() { return currentScriptDir_; }
QDir currentTextureDir(){ return currentTextureDir_; }
 
QString applicationDirStr()    { return applicationDir_.absolutePath();    }
QString configDirStr()         { return configDir_.absolutePath();         }
QString pluginDirStr()         { return pluginDir_.absolutePath();         }
QString shaderDirStr()         { return shaderDir_.absolutePath();         }
QString textureDirStr()        { return textureDir_.absolutePath();        }
QString licenseDirStr()        { return licenseDir_.absolutePath();        }
QString scriptDirStr()         { return scriptDir_.absolutePath();         }
QString iconDirStr()           { return iconDir_.absolutePath();           }
QString translationsDirStr()   { return translationsDir_.absolutePath();   }
QString fontsDirStr()          { return fontsDir_.absolutePath();          }
QString helpDirStr()           { return helpDir_.absolutePath();           }
QString dataDirStr()           { return dataDir_.absolutePath();           }
QString currentDirStr()        { return currentDir_.absolutePath();        }
QString currentScriptDirStr()  { return currentScriptDir_.absolutePath();  }
QString currentTextureDirStr() { return currentTextureDir_.absolutePath(); }
 
 
QString getGlobalIniFullPath()
{
  return OpenFlipper::Options::applicationDir().absolutePath() + OpenFlipper::Options::dirSeparator() + "OpenFlipper.ini";
}
 
QString getLocalIniFullPath()
{
  return OpenFlipper::Options::configDirStr() + OpenFlipper::Options::dirSeparator() + "OpenFlipper.ini";
}
 
QStringList optionFiles()
{
  QStringList names;
  for (const auto &filename: {getGlobalIniFullPath(), getLocalIniFullPath()}) {
      if (QFile(filename).exists()) {
          names.push_back(filename);
      }
  }
  return names;
}
 
bool startup() { return startup_; };
 
void finishedStartup() { startup_ = false;};
 
QIcon& OpenFlipperIcon() {
 
  if (OpenFlipperIcon_ == 0){
    OpenFlipperIcon_ = new QIcon( iconDirStr() + dirSeparator() + "OpenFlipper_Icon_128x128x32.png");
    OpenFlipperIcon_->addFile( iconDirStr() + dirSeparator() + "OpenFlipper_Icon_48x48x32.png", QSize(48,48) );
    OpenFlipperIcon_->addFile( iconDirStr() + dirSeparator() + "OpenFlipper_Icon_32x32x32.png", QSize(32,32) );
    OpenFlipperIcon_->addFile( iconDirStr() + dirSeparator() + "OpenFlipper_Icon_16x16x32.png", QSize(16,16) );
  }
 
  return *OpenFlipperIcon_;
}
 
void currentDir(QDir      _dir) {
  currentDir_ = _dir;
}
 
bool currentDir(QString      _dir) {
  QDir tmp(_dir);
  if (tmp.exists()) {
    currentDir_     = tmp;
    return true;
  }
  return false;
}
 
 
bool currentScriptDir(QString _dir) {
  QDir tmp(_dir);
  if (tmp.exists()) {
    currentScriptDir_     = tmp;
    return true;
  }
  return false;
}
 
bool currentTextureDir(QString _dir) {
  QDir tmp(_dir);
  if (tmp.exists()) {
    currentTextureDir_ = tmp;
    return true;
  }
  return false;
}
 
void deleteIniFile(bool _delete) {
    deleteIniFile_ = _delete;
}
 
bool deleteIniFile() {
    return deleteIniFile_;
}
 
void nogui( bool _nogui ) {
  nogui_ = _nogui;
}
 
bool nogui( ) {
  return nogui_;
}
 
bool gui( ) {
  return !nogui_;
}
 
void stereo( bool _stereo ) {
  stereo_ = _stereo;
}
 
bool stereo( ) {
  return stereo_;
}
 
void coreProfile( bool _enableCoreProfile, bool _temporary ) {
  if(_temporary)
  {
    profileOverride_ = true;
    coreProfile_ = _enableCoreProfile;
  }
  else
    OpenFlipperSettings().setValue("Core/OpenGL/CoreProfile",_enableCoreProfile);
}
 
bool coreProfile( ) {
  if(profileOverride_)
    return coreProfile_;
  else
    return OpenFlipperSettings().value("Core/OpenGL/CoreProfile", false).toBool();
}
 
QPair<int,int> glVersion(){
  if(versionOverride_)
    return version_;
  else
  {
    // unfortunately QVariant cant store QPair directly, we could try std::pair but its good for now
    int major = OpenFlipperSettings().value("Core/OpenGL/VersionMajor", 1).value<int>();
    int minor = OpenFlipperSettings().value("Core/OpenGL/VersionMinor", 0).value<int>();
    return QPair<int, int>(major,minor);
  }
}
 
void glVersion(const QPair<int,int> & _version, bool _temporary)
{
  //possible enhancement: check for validity
  if(_temporary)
  {
    version_ = _version;
    versionOverride_ = true;
  }
  else
  {
    OpenFlipperSettings().setValue("Core/OpenGL/VersionMajor",_version.first);
    OpenFlipperSettings().setValue("Core/OpenGL/VersionMinor",_version.second);
  }
}
void samples(int _samples, bool _temporary) {
  if(_temporary)
  {
    samples_ = _samples;
    samplesOverride_ = true;
  }
  else    
    OpenFlipperSettings().setValue("Core/OpenGL/Samples",_samples);
}
 
int samples() {
  if(samplesOverride_)
    return samples_;
  else    
    return OpenFlipperSettings().value("Core/OpenGL/Samples",4).toInt();
}
 
void glStereo( bool _glStereo, bool _temporary ) {
  if(!GLStereoSet)  // store the first set value because it is used to create the context
  {                 // so we can display it properly later on in options
    requestedGLStereo = _glStereo;
    GLStereoSet = true;
  }
  if(_temporary)
  {
    glStereo_ = _glStereo;
    overrideGLStereo_ = true;
  }
  else
    OpenFlipperSettings().setValue("Core/OpenGL/Stereo",_glStereo);
}
 
bool glStereo( ) {
  if(overrideGLStereo_)
    return glStereo_;
  else
    return OpenFlipperSettings().value("Core/OpenGL/Stereo",false).toBool();
}
 
bool glStereoRequested( ) {
  return requestedGLStereo;
}
 
void stereoMode( StereoMode _mode ) {
  stereoMode_ = _mode;
}
 
StereoMode stereoMode( ) {
  return stereoMode_;
}
 
void eyeDistance( double _eye ) {
  settings_->setValue("Core/Stereo/EyeDistance",_eye);
}
 
double eyeDistance( )
{
  return settings_->value("Core/Stereo/EyeDistance",0.07f).toDouble();
}
 
void focalDistance( float _focal )
{
  settings_->setValue("Core/Stereo/FocalDistance",_focal);
}
 
float focalDistance( )
{
  return settings_->value("Core/Stereo/FocalDistance",0.5f).toDouble();
}
 
void anaglyphLeftEyeColorMatrix( std::vector<float> _mat )
{
  for (int i = 0; i < 9; i++)
    anaglyphLeftEyeColors_[i] = _mat[i];
}
 
std::vector<float> anaglyphLeftEyeColorMatrix( )
{
  return anaglyphLeftEyeColors_;
}
 
void anaglyphRightEyeColorMatrix( std::vector<float> _mat )
{
  for (int i = 0; i < 9; i++)
    anaglyphRightEyeColors_[i] = _mat[i];
}
 
std::vector<float> anaglyphRightEyeColorMatrix( )
{
  return anaglyphRightEyeColors_;
}
 
void synchronization( bool _synchronization ) {
  synchronization_ = _synchronization;
}
 
bool synchronization( ) {
  return synchronization_;
}
 
void defaultDrawMode( ACG::SceneGraph::DrawModes::DrawMode _mode, int _viewer){
  defaultDrawMode_[_viewer] = _mode;
}
 
ACG::SceneGraph::DrawModes::DrawMode defaultDrawMode(int _viewer){
  return defaultDrawMode_[_viewer];
}
 
void defaultPerspectiveProjectionMode( bool _mode, int _viewer){
 
  // Core/Gui/glViewer<viewer> Orthogonal = false,Perspective = true (bool)\n
 
  QString entry = "Viewer" + QString::number(_viewer) + "/perspectiveProjection";
  OpenFlipperSettings().setValue(entry,_mode);
 
}
 
bool defaultPerspectiveProjectionMode(int _viewer){
 
  QString entry = "Viewer" + QString::number(_viewer) + "/perspectiveProjection";
 
  switch (_viewer) {
    case 0:
      return OpenFlipperSettings().value(entry,true).toBool();
    case 1:
      return OpenFlipperSettings().value(entry,false).toBool();
    case 2:
      return OpenFlipperSettings().value(entry,false).toBool();
    case 3:
      return OpenFlipperSettings().value(entry,false).toBool();
    default:
      std::cerr << "defaultProjectionMode: illegal viewer id: " << _viewer << std::endl;
      break;
  }
 
  return true;
}
 
void defaultViewingDirection( int _mode, int _viewer){
  QString entry = "Viewer" + QString::number(_viewer) + "/defaultViewingDirection";
  OpenFlipperSettings().setValue(entry,_mode);
}
 
int defaultViewingDirection(int _viewer){
 
  QString entry = "Viewer" + QString::number(_viewer) + "/defaultViewingDirection";
 
  switch (_viewer) {
    case 0:
      return OpenFlipperSettings().value(entry,PluginFunctions::VIEW_FREE).toInt();
    case 1:
      return OpenFlipperSettings().value(entry,PluginFunctions::VIEW_FRONT).toInt();
    case 2:
      return OpenFlipperSettings().value(entry,PluginFunctions::VIEW_RIGHT).toInt();
    case 3:
      return OpenFlipperSettings().value(entry,PluginFunctions::VIEW_TOP).toInt();
    default:
      std::cerr << "defaultViewingDirection: illegal viewer id: " << _viewer << std::endl;
      break;
  }
 
  return PluginFunctions::VIEW_FREE;
}
 
void defaultLockRotation( bool _lock, int _viewer ) {
  QString entry = "Viewer" + QString::number(_viewer) + "/defaultLockRotation";
  OpenFlipperSettings().setValue(entry,_lock);
}
 
bool defaultLockRotation( int _viewer ) {
 
  QString entry = "Viewer" + QString::number(_viewer) + "/defaultLockRotation";
 
  switch (_viewer) {
    case 0:
      return OpenFlipperSettings().value(entry,false).toBool();
    case 1:
      return OpenFlipperSettings().value(entry,true).toBool();
    case 2:
      return OpenFlipperSettings().value(entry,true).toBool();
    case 3:
      return OpenFlipperSettings().value(entry,true).toBool();
    default:
      std::cerr << "defaultViewingDirection: illegal viewer id: " << _viewer << std::endl;
      break;
  }
 
  return false;
}
 
 
void defaultViewerLayout( int _layout ){
  defaultViewerLayout_ = _layout;
}
 
int defaultViewerLayout(){
  return defaultViewerLayout_;
}
 
void redrawDisabled( bool disable ){
  if ( disable )
    redrawDisabled_++;
  else
    if ( redrawDisabled_ == 0 )
      std::cerr << "Mismatch of redraw enable/disable!!" << std::endl;
    else
      redrawDisabled_--;
}
 
bool redrawDisabled( ){
  return (redrawDisabled_ > 0);
}
 
bool drawModesInContextMenu() {
  return drawModesInContextMenu_;
}
 
void drawModesInContextMenu(bool _show) {
  drawModesInContextMenu_ = _show;
}
 
unsigned int examinerWidgets() {
  if ( OpenFlipperSettings().value("Core/Gui/glViewer/useMultipleViewers",true).toBool() )
    return 4;
  else
    return 1;
}
 
void loggerState( LoggerState _state) {
  OpenFlipperSettings().setValue("Core/Gui/LogWindow/LogWindowMode",_state);
}
 
LoggerState loggerState( ) {  
  LoggerState state = static_cast<OpenFlipper::Options::LoggerState> (OpenFlipperSettings().value("Core/Gui/LogWindow/LogWindowMode",0).toInt() );
  // workaround for windows issue with drawing logger in scene using coreProfile (thank you Qt)
#ifdef WIN32
  if(coreProfile_ && state == LoggerState::InScene)
    return LoggerState::Normal;
#endif
  return state;
}
 
QString currentViewMode( ) {
  return currentViewMode_;
}
 
void currentViewMode( QString _mode ) {
  currentViewMode_ = _mode;
}
 
 
QString windowTitle( ) {
  return title_;
}
 
void windowTitle( QString _titel ) {
  title_ = _titel;
}
 
void defaultColor( QColor _color ) {
  defaultColor_ = _color;
}
 
QColor defaultColor() {
  return defaultColor_;
}
 
void randomDefaultColor(bool _random) {
  randomDefaultColor_ = _random;
}
 
bool randomDefaultColor() {
  return randomDefaultColor_;
}
 
QString lastDataType(){
  return lastDataType_;
}
 
void lastDataType(QString _type){
   lastDataType_ = _type;
}
 
bool scripting( ) {
  return scripting_;
}
 
void scripting(bool _status ) {
  scripting_ = _status;
}
 
bool logToConsole( ) {
  return logToConsole_;
}
 
void logToConsole(bool _logToConsole ) {
  logToConsole_ = _logToConsole;
}
 
bool debug() {
  return debug_;
}
 
void debug(bool _debug ) {
  debug_ = _debug;
}
 
bool backupEnabled( ) {
  return enableBackup_;
}
 
void enableBackup(bool _enableBackup ) {
  enableBackup_ = _enableBackup;
}
 
void blockSceneGraphUpdates( ) {
  ++sceneGraphUpdatesBlocked_;
}
 
void unblockSceneGraphUpdates() {
  if ( sceneGraphUpdatesBlocked_ <= 0)
      std::cerr << "Error: More unblocks than blocks! Ignoring this request" << std::endl;
  else
    --sceneGraphUpdatesBlocked_;
}
 
bool sceneGraphUpdatesBlocked( ) {
  if ( sceneGraphUpdatesBlocked_ < 0)
    std::cerr << "Error: updates blocked < 0 ... more unblocks than blocks" << std::endl;
 
  return (sceneGraphUpdatesBlocked_ > 0);
}
 
bool savingSettings( ) {
  return savingSettings_;
}
 
void savingSettings(bool _savingSettings ) {
  savingSettings_ = _savingSettings;
}
 
bool loadingRecentFile( ) {
  return loadingRecentFile_;
}
 
void loadingRecentFile(bool _loadingRecentFile ) {
  loadingRecentFile_ = _loadingRecentFile;
}
 
int* argc() {
  return argc_;
}
 
char *** argv() {
  return argv_;
}
 
void  argc( int* _argc ) {
  argc_ = _argc;
}
 
void argv( char*** _argv) {
  argv_ = _argv;
}
 
bool remoteControl(){
  return remoteControl_;
}
 
void remoteControl(bool _remote){
  remoteControl_ = _remote;
}
 
int remoteControlPort(){
  return remoteControlPort_;
}
 
void remoteControlPort(int _remotePort){
  remoteControlPort_ = _remotePort;
}
 
void doSlotDebugging( bool _debugging ) {
  doSlotDebugging_ = _debugging;
}
 
bool doSlotDebugging( ) {
  return doSlotDebugging_;
}
 
QString coreVersion() {
  #ifndef CORE_VERSION
    #define CORE_VERSION "5.1.0"
  #endif
  return QString(CORE_VERSION);
}
 
static const char * const CONFIG_DIR = "." TOSTRING(PRODUCT_STRING);
 
bool initializeSettings() {
        if (OpenFlipper::Options::settings_ == nullptr)
        {
 
#if defined(__INTEL_COMPILER)
                compilerInfo_ = "Intel: " + QString(TOSTRING(__INTEL_COMPILER)) + "." + QString(TOSTRING(__GNUC_MINOR__));
#if defined(__INTEL_COMPILER_BUILD_DATE)
                compilerInfo_ += " BuildDate " + QString(TOSTRING(__INTEL_COMPILER_BUILD_DATE));
#endif
#elif defined(__GNUC__)
                compilerInfo_ = "Gnu CC: " + QString(TOSTRING(__GNUC__)) + "." + QString(TOSTRING(__GNUC_MINOR__));
#if defined(__GNUC_PATCHLEVEL__)
                compilerInfo_ += "." + QString(TOSTRING(__GNUC_PATCHLEVEL__));
#endif
#elif defined (_MSC_FULL_VER)
                compilerInfo_ = "MSVC: " + QString(TOSTRING(_MSC_FULL_VER));
#else
                compilerInfo_ = "Unknown Compiler";
#endif
 
 
                //==================================================================================================
                // Get the Main config dir in the home directory and possibly create it
                //==================================================================================================
#if  defined(ARCH_DARWIN)
                configDir_ = QDir::home();
 
                if (!configDir_.cd("Library"))
                        configDir_.mkdir("Library");
 
                if (!configDir_.cd("Application Support"))
                        configDir_.mkdir("Application Support");
 
                if (!configDir_.cd("de.rwth-aachen.graphics.openflipper")) {
                        configDir_.mkdir("de.rwth-aachen.graphics.openflipper");
                        if (!configDir_.cd("de.rwth-aachen.graphics.openflipper")) {
                                std::cerr << "Unable to create config dir ~/Library/de.rwth-aachen.graphics.openflipper" << std::endl;
                                return false;
                        }
                }
#else
                configDir_ = QDir::home();
                if (!configDir_.cd(CONFIG_DIR)) {
                        std::cerr << "Creating config Dir ~/" << CONFIG_DIR << std::endl;;
                        configDir_.mkdir(CONFIG_DIR);
                        if (!configDir_.cd(CONFIG_DIR)) {
                                std::cerr << "Unable to create config dir ~/" << CONFIG_DIR << std::endl;
                                return false;
                        }
                }
 
#endif
 
 
                //==================================================================================================
                // Setup settings. 
                //==================================================================================================
                // This has to be done as early as possible to set the program options right
 
                // Force ini format on all platforms
                QSettings::setDefaultFormat(QSettings::IniFormat);
 
                // Force settings to be stored in the OpenFlipper config directory
                QSettings::setPath(QSettings::IniFormat, QSettings::UserScope, configDir_.absolutePath());
 
                // Finally attach the settings object.
                settings_ = new OpenFlipperQSettings(QSettings::IniFormat, QSettings::UserScope, "VCI", "OpenFlipper");
 
                //==================================================================================================
                // Now create special directories in th OpenFlipper config dir
                //==================================================================================================
 
                // Create a personal Icon cache dir to save for example user added icons
                if (!configDir_.exists("Icons")) {
                        configDir_.mkdir("Icons");
                        std::cerr << "Creating Icon Cache Dir ~/" << CONFIG_DIR << "/Icons" << std::endl;
                }
 
                //==================================================================================================
                // Setup main application dir
                //==================================================================================================
 
                // Remember the main application directory (assumed to be one above executable Path)
                applicationDir_.setPath( QCoreApplication::applicationDirPath() );
 
                // When using cmake, we get the absolute path to the Application directory via a define
                applicationDir_.cd(OPENFLIPPER_APPDIR);
 
                //==================================================================================================
                // Setup directory containing plugins
                //==================================================================================================
 
                // start at application directory 
                pluginDir_ = applicationDir_;
 
                // cmake style: Path is directly given from define!
                pluginDir_.cd(OPENFLIPPER_PLUGINDIR);
 
                dataDir_ = OpenFlipper::Options::applicationDir();
 
#ifdef OPENFLIPPER_DATADIR
                dataDir_.cd(OPENFLIPPER_DATADIR);
#else
                dataDir_ = OpenFlipper::Options::applicationDir();
#endif
 
                // Set the Path to the Shaders
                shaderDir_ = dataDir_;
                shaderDir_.cd("Shaders");
                ACG::ShaderProgGenerator::setShaderDir(OpenFlipper::Options::shaderDirStr());
 
                // Set the Path to the textures
                textureDir_ = dataDir_;
                textureDir_.cd("Textures");
 
                // Set the Path to the Scripts
                scriptDir_ = dataDir_;
                scriptDir_.cd("Scripts");
 
 
                // Set the Path to the Icons
                iconDir_ = dataDir_;
                iconDir_.cd("Icons");
 
                // Set the Path to the translations
                translationsDir_ = dataDir_;
                translationsDir_.cd("Translations");
 
                // Set the Path to the Fonts
                fontsDir_ = dataDir_;
                fontsDir_.cd("Fonts");
 
                // Set the Path to the License files
                licenseDir_ = dataDir_;
                licenseDir_.cd("Licenses");
 
                // Set the Path to the Help
                helpDir_ = dataDir_;
                helpDir_.cd("Help");
 
                //==================================================================================================
                // Initialize with default values if not already set
                //==================================================================================================  
 
                // User Interface Settings
                if (!settings_->contains("Core/Gui/glViewer/defaultBackgroundColor"))
                        settings_->setValue("Core/Gui/glViewer/defaultBackgroundColor", QColor("black"));
 
                if (!settings_->contains("Core/Gui/glViewer/showControlWheels"))
                        settings_->setValue("Core/Gui/glViewer/showControlWheels", false);
 
 
                // Mouse Controls
                if (!settings_->contains("Core/Mouse/Wheel/ZoomFactor"))
                        settings_->setValue("Core/Mouse/Wheel/ZoomFactor", 1.0);
 
                if (!settings_->contains("Core/Mouse/Wheel/ZoomFactorShift"))
                        settings_->setValue("Core/Mouse/Wheel/ZoomFactorShift", 0.2);
 
                if (!settings_->contains("Core/Mouse/Wheel/Invert"))
                        settings_->setValue("Core/Mouse/Wheel/Invert", false);
 
                // General Stereo Settings
                if (!settings_->contains("Core/Stereo/FocalLength"))
                        settings_->setValue("Core/Stereo/FocalLength", 0.5);
 
                if (!settings_->contains("Core/Stereo/EyeDistance"))
                        settings_->setValue("Core/Stereo/EyeDistance", 0.07);
 
                return true;
        }
    return true;
}
 
void closeSettings() {
  
  // Delete the settings object. This will flush all data to the disk.
  delete settings_;
}
 
QString compilerInfo() {
  return compilerInfo_;
}
 
}
}
 
OpenFlipperQSettings& OpenFlipperSettings() {
  // Empty standard settings object if the right settings are not available!
  static OpenFlipperQSettings emptySettings;
  
  if ( OpenFlipper::Options::settings_ != nullptr )
    return *OpenFlipper::Options::settings_;
  else
    return emptySettings;
}
 
 
 
//=============================================================================