char* GetCurrentDirC(void)
{
    static char dir[1024];
    memcpy(dir, GetCurrentDir().c_str(), GetCurrentDir().length() + 1);

    return dir;
}

SelectFileScreen::SelectFileScreen()
{
	char cCurrentPath[FILENAME_MAX];
	GetCurrentDir(cCurrentPath, sizeof(cCurrentPath));

	m_DirString = Stringc(cCurrentPath);

	char forwardSlash = '\\';
	m_DirString.change_from_to(forwardSlash, '/');

	int dirSize = m_DirString.get_length();
	if ( m_DirString[dirSize-1] != '/' )
		m_DirString.concatenate("/");

	m_FilterString = Stringc("*.*");

	selectFileUI = new SelectFileUI();
	selectFileUI->UIWindow->position( 30, 30 );
	selectFileUI->fileBrowser->type(FL_SELECT_BROWSER);
	selectFileUI->fileBrowser->callback( staticScreenCB, this );
	selectFileUI->dirInput->callback( staticScreenCB, this );
	selectFileUI->dirInput->when(FL_WHEN_CHANGED);

	selectFileUI->fileInput->callback( staticScreenCB, this );
	selectFileUI->acceptButton->callback( staticScreenCB, this );
	selectFileUI->cancelButton->callback( staticScreenCB, this );

	selectFileUI->favsMenuButton->callback( staticScreenCB, this );

	LoadFavsMenu();
}

std::string empathy::getBase()
{
    char cCurrentPath[FILENAME_MAX];

    if(__base==""){

        if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
        {
            __base= "";

            std::cout<<"Error setting base Directory!"<<std::endl;
        }else{
            cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */

            __base=join_path(std::string(cCurrentPath),"empathy");

            std::cout<<"Base changed to "<<__base<<std::endl;
        }




    }


    return __base;
}

std::string getPath()
{
    std::string fullpath;
    // ----------------------------------------------------------------------------
    // This makes relative paths work in C++ in Xcode by changing directory to the Resources folder inside the .app bundle
#ifdef __APPLE__
    CFBundleRef mainBundle = CFBundleGetMainBundle();
    CFURLRef resourcesURL = CFBundleCopyResourcesDirectoryURL(mainBundle);
    char path[PATH_MAX];
    if (!CFURLGetFileSystemRepresentation(resourcesURL, TRUE, (UInt8 *)path, PATH_MAX))
    {
        // error!
    }
    CFRelease(resourcesURL);
    chdir(path);
    fullpath = path;
#else
	 char cCurrentPath[1024];
	 if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
		 return "";

	cCurrentPath[sizeof(cCurrentPath) - 1] = '\0';
	fullpath = cCurrentPath;

#endif    
    return fullpath;
}

//---------------------------------------------------------------------------
void __fastcall CTerminalRobotTyper::RestoreKeyInterval(){
   	TIniFile *ini = new TIniFile(GetCurrentDir() + "\\app.ini");
	int keyInterval = ini->ReadInteger(terminal->xmlConfig->TerminalID , "KeyboardInterval", terminal->panel->TrackBarKey->Position);
    delete ini;
	terminal->panel->TrackBarKey->Position =keyInterval;
    keyIntervalRestored =true;
}

ULONG DosWowSetDefaultDrive(UCHAR Drive)
{
    PCDS pCDS;

    if (NULL != (pCDS = GetCDSFromDrv (Drive))) {

        if (GetCurrentDir (pCDS, Drive)) {

            if (*(PUCHAR)DosWowData.lpCurDrv != Drive) {

                // The upper bit in the TDB_Drive byte is used to indicate
                // that the current drive and directory information in the
                // TDB is stale. Turn it off here.
                PTDB pTDB;
                if (*pCurTDB) {
                    pTDB = (PTDB)SEGPTR(*pCurTDB,0);
                    if (TDB_SIGNATURE == pTDB->TDB_sig) {
                        pTDB->TDB_Drive &= ~TDB_DIR_VALID;
                    }
                }

                *(PUCHAR)DosWowData.lpCurDrv = Drive;
            }

        }
    }

    return (*(PUCHAR)DosWowData.lpCurDrv);

}

	unsigned int LoadTexture(const std::string& dataPath)
	{
		glEnable(GL_TEXTURE_2D);

		std::string fPath = GetCurrentDir(); // Get current directory, SOIL doesn't seem to work from executable directory

		fPath.append("img\\" + dataPath);

		unsigned int tex_2d = SOIL_load_OGL_texture
			(
			fPath.c_str(),
			SOIL_LOAD_AUTO,
			SOIL_CREATE_NEW_ID,
			SOIL_FLAG_MIPMAPS | SOIL_FLAG_INVERT_Y | SOIL_FLAG_NTSC_SAFE_RGB | SOIL_FLAG_COMPRESS_TO_DXT
			);

		if (tex_2d == 0)
		{
			std::string s = "\n\n---- SOIL ERROR ----\nFilename: " + fPath;
			s.append("\nSOIL Message: ");
			s.append(SOIL_last_result());
			s.append("\n\n");

			Log::Write(s.c_str(), ENGINE_LOG);
		}

		glBindTexture(GL_TEXTURE_2D, tex_2d);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
		glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
		glBindTexture(GL_TEXTURE_2D, 0);

		glDisable(GL_TEXTURE_2D);

		return tex_2d;
	}

int main(int argc, char* argv[]){

	int exitCode = psm::StatusNoError;

	char cCurrentPath[FILENAME_MAX];

	cCurrentPath[sizeof(cCurrentPath)-1] = '\0'; /* not really required */

	if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
	{
		return errno;
	}

	printf("The current working directory is %s", cCurrentPath);

	psm::IApp * app = new(std::nothrow) PSMAPP();

	app->processArguments(argc, argv);

	exitCode = app->run();

	delete app;

	app = nullptr;

	return exitCode;
}

int main()
{
     FILE * f;
     char fname[FILENAME_MAX] = "log_testClassPoint.txt";
     char cCurrentPath[FILENAME_MAX];
     f = fopen(fname, "w");
     if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath))) {
          return EXIT_FAILURE;
     }
     cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */

     fprintf (f, "The current working directory is %s\n\n", cCurrentPath);

     int res = 0, ntests = 0;

     res += testNorm(f);
     ntests++;
     res += testNormalized(f);
     ntests++;
     res += testScalarP(f);
     ntests++;
     res += testDet(f);
     ntests++;
     res += testCoordTransToEllipse(f);
     ntests++;
     res += testCoordTransToCart(f);
     ntests++;
     res += testRotate(f);
     ntests++;

     fclose(f);
     return (res==ntests)?EXIT_SUCCESS:EXIT_FAILURE;
}

//get_working_dir
std::string get_working_dir()
{
	char buff[FILENAME_MAX];
	GetCurrentDir(buff, FILENAME_MAX);
	std::string current_working_dir(buff);
	return current_working_dir;
}

// On success, currdir_relative_to_root will be a canonical path.
Res FindRoot(string* absolute_root,
             string* currdir_relative_to_root) {
  string currdir = GetCurrentDir();

  // Look for root dir.  Root dir is marked by the presence of a
  // "root.dmb" file.
  string root = currdir;
  for (;;) {
    if (FileExists(PathJoin(root, "root.dmb"))) {
      break;
    }
    if (HasParentDir(root)) {
      root = ParentDir(root);
    } else {
      return Res(ERR, "Can't find root.dmb in ancestor directories");
    }
  }
  *absolute_root = root;

  const char* remainder = currdir.c_str() + root.length();
  if (remainder[0] == '/') {
    remainder++;
  }
  *currdir_relative_to_root = remainder;
  assert(currdir_relative_to_root->size() == 0 ||
         (*currdir_relative_to_root)[currdir_relative_to_root->length() - 1]
         != '/');

  return Res(OK);
}

 // remove any . or .. and make absolute if necessary
 Path& Path::normalize() {
   size_t i = 0;
   bool wasMadeAbsolute = isAbsolute();
   while (i < mPaths.size()) {
     if (mPaths[i] == ".") {
       mPaths.erase(mPaths.begin()+i);
     } else if (mPaths[i] == "..") {
       if (i == 0) {
         if (wasMadeAbsolute) {
           // invalid path
           mPaths.clear();
           break;
         }
         Path cwd = GetCurrentDir();
         cwd.pop();
         size_t sz = cwd.mPaths.size();
         mPaths.erase(mPaths.begin()+i);
         mPaths.insert(mPaths.begin(), cwd.mPaths.begin(), cwd.mPaths.end());
         i = sz;
         wasMadeAbsolute = true;
       } else {
         mPaths.erase(mPaths.begin()+i);
         mPaths.erase(mPaths.begin()+i-1);
         --i;
       }
     } else {
       ++i;
     }
   }
   mFullName = fullname(DIR_SEP);
   return *this;
 }

//----------------
//
void WriteDatFile( TYPE_File *writeFile )
{
    char* currentDir;
     
    appendToLogfile("WriteDatFile: Started.", INFO);
    appendToLogfile("WriteDatFile: GetCurrentDir called.", WARNING);
    currentDir = GetCurrentDir();  // Store the current  directory.

    appendStringToLogfile("WriteDatFile: GetCurrentDir returned=%s.",currentDir, WARNING);
    appendStringToLogfile("WriteDatFile: Moving to=%s.",TAPIniDir, WARNING);
    GotoPath(TAPIniDir);           // Go to the Project Directory.
    
	if ( TAP_Hdd_Exist( PLAYDATA_FILENAME ) ) TAP_Hdd_Delete( PLAYDATA_FILENAME );	// Just delete any old copies

    appendToLogfile("WriteDatFile: Creating DATA file.", ERR);
	TAP_Hdd_Create( PLAYDATA_FILENAME, ATTR_PROGRAM );						// Create the file

    appendToLogfile("WriteDatFile: Opening DATA file.", ERR);
	writeFile = TAP_Hdd_Fopen( PLAYDATA_FILENAME );
	if ( writeFile == NULL ) return; 										// Check we can open it

    appendToLogfile("WriteDatFile: Writing to DATA file.", ERR);
	TAP_Hdd_Fwrite( playDataBuffer_ini, PLAYBACKDATA_BUFFER_SIZE_ini, 1, writeFile );	// dump the whole buffer in one hit

    appendToLogfile("WriteDatFile: Closing DATA file.", ERR);
	TAP_Hdd_Fclose( writeFile );

    appendStringToLogfile("WriteDatFile: Returning to=%s.",currentDir, WARNING);
	GotoPath(currentDir);            // Return to the original directory.

    TAP_MemFree( currentDir );   // Free allocated memory.
    
    appendToLogfile("WriteDatFile: Finished.", INFO);
}

std::string getCurrentDir() {
    char cCurrentPath[FILENAME_MAX];
    if (!GetCurrentDir(cCurrentPath, sizeof (cCurrentPath))) {
        return std::string(itoa(errno));
    }
    cCurrentPath[sizeof (cCurrentPath) - 1] = '\0'; /* not really required */
    return std::string(cCurrentPath);
}

HRESULT CZZExcel2Word::InitExportSettings()
{
	std::wstring curdir = GetCurrentDir();
	std::wstring initFilePath;
	m_stringWordTemplatePath = curdir + Template_FILE_NAME;
	initFilePath = curdir+INI_FILE_NAME;
	return InitExportSettings(initFilePath.c_str());
}

/*  --------------------------------------------------------  */
void Menu::saveAs_activate_cb()
{
    if(!this->saveAsFile)
        Log::LogWarn(LEVEL_LOG_INFO, "Unable to load open window", __FILE__, __LINE__);

    this->saveAsFile->set_current_folder(GetCurrentDir());
    this->saveAsFile->run();
}

 // if path is relative, prepend current directory
 Path& Path::makeAbsolute() {
   if (!isAbsolute()) {
     Path cwd = GetCurrentDir();
     mPaths.insert(mPaths.begin(), cwd.mPaths.begin(), cwd.mPaths.end());
     mFullName = fullname(DIR_SEP);
   }
   return *this;
 }

//---------------------------------------------------------------------------
void __fastcall TForm1::FormCreate(TObject *Sender)
{
 start=1;
 mode=0;
 Dir_for_file=GetCurrentDir();
 start_form_ini(Form1);
 start=0;
}

std::string GetCurrentWorkingDir(void) {
  char buff[FILENAME_MAX];
  auto result = GetCurrentDir(buff, FILENAME_MAX);
  if (result) {
    std::string current_working_dir(buff);
    return current_working_dir;
  }
  return "";
}

std::string GetWorkingDirectory()
{
  if (!GetCurrentDir(cCurrentPath, sizeof(cCurrentPath)))
  {
    return "";
  }
  cCurrentPath[sizeof(cCurrentPath) - 1] = '\0'; /* not really required */
  return cCurrentPath;
}