std::string NormalizePath(std::string sPath)
{
std::string sFolder=sPath;
std::string sFileName=GetFileName(sPath);
std::deque<std::string> sFolders;
std::string sFolderName;
int nToSkip=0;
while((sFolderName=GetFileName(sFolder))!="")
{
if(sFolder=="."){break;}
if(sFolderName==".."){nToSkip++;}
else if(sFolderName!="."){if(nToSkip){nToSkip--;}else{sFolders.push_back(sFolderName);}}
sFolder=GetFileFolder(sFolder);
}
// Aqui sFolder contiene / en Linux y C:\ en windows
std::string sNormalized=sFolder;
std::deque<std::string>::reverse_iterator i;
for(i=sFolders.rbegin();i!=sFolders.rend();i++)
{
sNormalized=AppendPathSeparator(sNormalized);
sNormalized+=(*i);
}
if(FileIsDirectory(sNormalized.c_str())){sNormalized=AppendPathSeparator(sNormalized);}
return sNormalized;
}
bool FindFiles(const char *psPattern, EFindFilesMode eMode,std::set<std::string> *psFiles)
{
char sFolder[MAX_PATH];
GetFileFolder(psPattern,sFolder);
WIN32_FIND_DATA FileData;
HANDLE hFind = FindFirstFile(psPattern, &FileData);
if(hFind != INVALID_HANDLE_VALUE)
{
do
{
if(strcmp(FileData.cFileName,".")!=0)
{
std::string sFile=AppendPathSeparator(sFolder)+FileData.cFileName;
bool bDirectory=((GetFileAttributes(sFile.c_str())&FILE_ATTRIBUTE_DIRECTORY)!=0);
std::string sFileName=GetFileName(sFile);
if(bDirectory){sFile=AppendPathSeparator(sFile);}
switch(eMode)
{
case eFindFilesMode_OnlyFiles: if(!bDirectory){psFiles->insert(sFile);};break;
case eFindFilesMode_OnlyDirs: if(bDirectory){psFiles->insert(sFile);}break;
case eFindFilesMode_DirsAndFiles:psFiles->insert(sFile);break;
}
}
}
while(FindNextFile(hFind, &FileData));
FindClose(hFind);
hFind=INVALID_HANDLE_VALUE;
}
return true;
}
void DetermineBasePaths(const char *exe)
{
char tmp[MAX_PATH];
TCHAR path[MAX_PATH];
#ifdef WITH_PERSONAL_DIR
if (SUCCEEDED(OTTDSHGetFolderPath(NULL, CSIDL_PERSONAL, NULL, SHGFP_TYPE_CURRENT, path))) {
strecpy(tmp, FS2OTTD(path), lastof(tmp));
AppendPathSeparator(tmp, lastof(tmp));
strecat(tmp, PERSONAL_DIR, lastof(tmp));
AppendPathSeparator(tmp, lastof(tmp));
_searchpaths[SP_PERSONAL_DIR] = stredup(tmp);
} else {
_searchpaths[SP_PERSONAL_DIR] = NULL;
}
if (SUCCEEDED(OTTDSHGetFolderPath(NULL, CSIDL_COMMON_DOCUMENTS, NULL, SHGFP_TYPE_CURRENT, path))) {
strecpy(tmp, FS2OTTD(path), lastof(tmp));
AppendPathSeparator(tmp, lastof(tmp));
strecat(tmp, PERSONAL_DIR, lastof(tmp));
AppendPathSeparator(tmp, lastof(tmp));
_searchpaths[SP_SHARED_DIR] = stredup(tmp);
} else {
_searchpaths[SP_SHARED_DIR] = NULL;
}
#else
_searchpaths[SP_PERSONAL_DIR] = NULL;
_searchpaths[SP_SHARED_DIR] = NULL;
#endif
/* Get the path to working directory of OpenTTD */
getcwd(tmp, lengthof(tmp));
AppendPathSeparator(tmp, lastof(tmp));
_searchpaths[SP_WORKING_DIR] = stredup(tmp);
if (!GetModuleFileName(NULL, path, lengthof(path))) {
DEBUG(misc, 0, "GetModuleFileName failed (%lu)\n", GetLastError());
_searchpaths[SP_BINARY_DIR] = NULL;
} else {
TCHAR exec_dir[MAX_PATH];
_tcsncpy(path, convert_to_fs(exe, path, lengthof(path)), lengthof(path));
if (!GetFullPathName(path, lengthof(exec_dir), exec_dir, NULL)) {
DEBUG(misc, 0, "GetFullPathName failed (%lu)\n", GetLastError());
_searchpaths[SP_BINARY_DIR] = NULL;
} else {
strecpy(tmp, convert_from_fs(exec_dir, tmp, lengthof(tmp)), lastof(tmp));
char *s = strrchr(tmp, PATHSEPCHAR);
*(s + 1) = '\0';
_searchpaths[SP_BINARY_DIR] = stredup(tmp);
}
}
_searchpaths[SP_INSTALLATION_DIR] = NULL;
_searchpaths[SP_APPLICATION_BUNDLE_DIR] = NULL;
}
/**
* Scan for files with the given extention in the given search path.
* @param extension the extension of files to search for.
* @param directory the sub directory to search in.
* @param recursive whether to search recursively
* @return the number of found files, i.e. the number of times that
* AddFile returned true.
*/
uint FileScanner::Scan(const char *extension, const char *directory, bool recursive)
{
char path[MAX_PATH];
strecpy(path, directory, lastof(path));
if (!AppendPathSeparator(path, lengthof(path))) return 0;
return ScanPath(this, extension, path, strlen(path), recursive);
}
void SharePage::addDirectory(const tstring& aPath)
{
tstring path = aPath;
AppendPathSeparator(path);
//if (path.length()) //[+]PPA
// if (path[ path.length() - 1 ] != _T('\\'))
// path += _T('\\');
try
{
LineDlg virt;
virt.title = TSTRING(VIRTUAL_NAME);
virt.description = TSTRING(VIRTUAL_NAME_LONG);
virt.line = Text::toT(ShareManager::validateVirtual(
Util::getLastDir(Text::fromT(path))));
if (virt.DoModal(m_hWnd) == IDOK)
{
CWaitCursor l_cursor_wait; //-V808
ShareManager::getInstance()->addDirectory(Text::fromT(path), Text::fromT(virt.line), true);
int i = ctrlDirectories.insert(ctrlDirectories.GetItemCount(), virt.line);
ctrlDirectories.SetItemText(i, 1, path.c_str());
ctrlDirectories.SetItemText(i, 2, Util::formatBytesW(ShareManager::getShareSize(Text::fromT(path))).c_str());
ctrlTotal.SetWindowText(ShareManager::getShareSizeformatBytesW().c_str());
}
}
catch (const ShareException& e)
{
MessageBox(Text::toT(e.getError()).c_str(), T_APPNAME_WITH_VERSION, MB_ICONSTOP | MB_OK);
}
}
void SettingsAutoUpdate::_StartFileUpdateThisThread(const string& localPath, const string& urlPath)
{
fly_fire1(SettingsAutoUpdateListener::UpdateStarted(), localPath);
string tempPath = Util::getTempPath();
AppendPathSeparator(tempPath);
tempPath += Util::getFileName(localPath);
try
{
File temp(tempPath, File::WRITE, File::CREATE | File::TRUNCATE);
if (Util::getDataFromInet(true, urlPath, temp))
{
if (temp.isOpen())
temp.close();
try
{
File::renameFile(tempPath, localPath);
fly_fire1(SettingsAutoUpdateListener::UpdateFinished(), localPath);
}
catch (FileException& ex)
{
fail(ex.getError());
}
}
if (File::isExist(tempPath))
File::deleteFile(tempPath);
}
catch (const Exception& e)
{
fail(e.getError());
}
}
/**
* Allocates and files a variable with the full path
* based on the given directory.
* @param dir the directory to base the path on
* @return the malloced full path
*/
char *BuildWithFullPath(const char *dir)
{
char *dest = MallocT<char>(MAX_PATH);
ttd_strlcpy(dest, dir, MAX_PATH);
/* Check if absolute or relative path */
const char *s = strchr(dest, PATHSEPCHAR);
/* Add absolute path */
if (s == NULL || dest != s) {
if (getcwd(dest, MAX_PATH) == NULL) *dest = '\0';
AppendPathSeparator(dest, MAX_PATH);
ttd_strlcat(dest, dir, MAX_PATH);
}
AppendPathSeparator(dest, MAX_PATH);
return dest;
}
LRESULT DownloadPage::onClickedBrowseTempDir(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
tstring dir = Text::toT(SETTING(TEMP_DOWNLOAD_DIRECTORY));
if (WinUtil::browseDirectory(dir, m_hWnd))
{
AppendPathSeparator(dir);
SetDlgItemText(IDC_TEMP_DOWNLOAD_DIRECTORY, dir.c_str());
}
return 0;
}
void CGameGUIFileDialog::OnInitDialog()
{
CGameDialogBase::OnInitDialog();
if(m_sFile==""){m_sFile=AppendPathSeparator(GetWorkingFolder());}
if(m_piSTTitle){m_piSTTitle->SetText(m_sTitle);}
if(m_piEDPath)
{
m_piEDPath->SetText(m_sFile);
m_piEDPath->SetCursor(m_sFile.length());
m_piGUIManager->SetFocus(m_piEDPath);
}
UpdateFiles();
}
OP_STATUS UnixOpDesktopResources::Normalize(OpString& path)
{
if (path[0] != '/')
{
OpString relative;
relative.TakeOver(path);
RETURN_IF_ERROR(path.Set(m_folder.base));
if (relative[0] == '.' && relative[1] == '/')
RETURN_IF_ERROR(path.Append(relative.CStr() + 2));
else
RETURN_IF_ERROR(path.Append(relative));
}
RETURN_IF_ERROR(AppendPathSeparator(path));
return OpStatus::OK;
}
/**
* Whether we should scan the working directory.
* It should not be scanned if it's the root or
* the home directory as in both cases a big data
* directory can cause huge amounts of unrelated
* files scanned. Furthermore there are nearly no
* use cases for the home/root directory to have
* OpenTTD directories.
* @return true if it should be scanned.
*/
bool DoScanWorkingDirectory()
{
/* No working directory, so nothing to do. */
if (_searchpaths[SP_WORKING_DIR] == NULL) return false;
/* Working directory is root, so do nothing. */
if (strcmp(_searchpaths[SP_WORKING_DIR], PATHSEP) == 0) return false;
/* No personal/home directory, so the working directory won't be that. */
if (_searchpaths[SP_PERSONAL_DIR] == NULL) return true;
char tmp[MAX_PATH];
snprintf(tmp, lengthof(tmp), "%s%s", _searchpaths[SP_WORKING_DIR], PERSONAL_DIR);
AppendPathSeparator(tmp, MAX_PATH);
return strcmp(tmp, _searchpaths[SP_PERSONAL_DIR]) != 0;
}
/**
* Scan a single directory (and recursively its children) and add
* any graphics sets that are found.
* @param fs the file scanner to add the files to
* @param extension the extension of files to search for.
* @param path full path we're currently at
* @param basepath_length from where in the path are we 'based' on the search path
* @param recursive whether to recursively search the sub directories
*/
static uint ScanPath(FileScanner *fs, const char *extension, const char *path, size_t basepath_length, bool recursive)
{
extern bool FiosIsValidFile(const char *path, const struct dirent *ent, struct stat *sb);
uint num = 0;
struct stat sb;
struct dirent *dirent;
DIR *dir;
if (path == NULL || (dir = ttd_opendir(path)) == NULL) return 0;
while ((dirent = readdir(dir)) != NULL) {
const char *d_name = FS2OTTD(dirent->d_name);
char filename[MAX_PATH];
if (!FiosIsValidFile(path, dirent, &sb)) continue;
snprintf(filename, lengthof(filename), "%s%s", path, d_name);
if (S_ISDIR(sb.st_mode)) {
/* Directory */
if (!recursive) continue;
if (strcmp(d_name, ".") == 0 || strcmp(d_name, "..") == 0) continue;
if (!AppendPathSeparator(filename, lengthof(filename))) continue;
num += ScanPath(fs, extension, filename, basepath_length, recursive);
} else if (S_ISREG(sb.st_mode)) {
/* File */
if (extension != NULL) {
char *ext = strrchr(filename, '.');
/* If no extension or extension isn't .grf, skip the file */
if (ext == NULL) continue;
if (strcasecmp(ext, extension) != 0) continue;
}
if (fs->AddFile(filename, basepath_length)) num++;
}
}
closedir(dir);
return num;
}
/**
* Determine the base (personal dir and game data dir) paths
* @param exe the path to the executable
*/
void DetermineBasePaths(const char *exe)
{
char tmp[MAX_PATH];
#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS) || defined(OS2) || !defined(WITH_PERSONAL_DIR)
_searchpaths[SP_PERSONAL_DIR] = NULL;
#else
#ifdef __HAIKU__
BPath path;
find_directory(B_USER_SETTINGS_DIRECTORY, &path);
const char *homedir = path.Path();
#else
const char *homedir = getenv("HOME");
if (homedir == NULL) {
const struct passwd *pw = getpwuid(getuid());
homedir = (pw == NULL) ? "" : pw->pw_dir;
}
#endif
snprintf(tmp, MAX_PATH, "%s" PATHSEP "%s", homedir, PERSONAL_DIR);
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_PERSONAL_DIR] = strdup(tmp);
#endif
#if defined(WITH_SHARED_DIR)
snprintf(tmp, MAX_PATH, "%s", SHARED_DIR);
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_SHARED_DIR] = strdup(tmp);
#else
_searchpaths[SP_SHARED_DIR] = NULL;
#endif
#if defined(__MORPHOS__) || defined(__AMIGA__)
_searchpaths[SP_WORKING_DIR] = NULL;
#else
if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_WORKING_DIR] = strdup(tmp);
#endif
_do_scan_working_directory = DoScanWorkingDirectory();
/* Change the working directory to that one of the executable */
if (ChangeWorkingDirectoryToExecutable(exe)) {
if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_BINARY_DIR] = strdup(tmp);
} else {
_searchpaths[SP_BINARY_DIR] = NULL;
}
if (_searchpaths[SP_WORKING_DIR] != NULL) {
/* Go back to the current working directory. */
if (chdir(_searchpaths[SP_WORKING_DIR]) != 0) {
DEBUG(misc, 0, "Failed to return to working directory!");
}
}
#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS) || defined(OS2)
_searchpaths[SP_INSTALLATION_DIR] = NULL;
#else
snprintf(tmp, MAX_PATH, "%s", GLOBAL_DATA_DIR);
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_INSTALLATION_DIR] = strdup(tmp);
#endif
#ifdef WITH_COCOA
extern void cocoaSetApplicationBundleDir();
cocoaSetApplicationBundleDir();
#else
_searchpaths[SP_APPLICATION_BUNDLE_DIR] = NULL;
#endif
}
/**
* Determine the base (personal dir and game data dir) paths
* @param exe the path to the executable
*/
void DetermineBasePaths(const char *exe)
{
char tmp[MAX_PATH];
#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS) || defined(OS2) || !defined(WITH_PERSONAL_DIR)
_searchpaths[SP_PERSONAL_DIR] = NULL;
#else
#if !defined(__APPLE__) && !defined(__arm__)
const char *homedir = getenv("HOME");
if (homedir == NULL) {
const struct passwd *pw = getpwuid(getuid());
homedir = (pw == NULL) ? "" : pw->pw_dir;
}
snprintf(tmp, MAX_PATH, "%s" PATHSEP "%s", homedir, PERSONAL_DIR);
#else
snprintf(tmp, MAX_PATH, "%s", PERSONAL_DIR);
#endif
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_PERSONAL_DIR] = strdup(tmp);
#endif
#if defined(WITH_SHARED_DIR)
snprintf(tmp, MAX_PATH, "%s", SHARED_DIR);
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_SHARED_DIR] = strdup(tmp);
#else
_searchpaths[SP_SHARED_DIR] = NULL;
#endif
#if defined(__MORPHOS__) || defined(__AMIGA__)
_searchpaths[SP_WORKING_DIR] = NULL;
#else
if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_WORKING_DIR] = strdup(tmp);
#endif
/* Change the working directory to that one of the executable */
ChangeWorkingDirectory(exe);
if (getcwd(tmp, MAX_PATH) == NULL) *tmp = '\0';
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_BINARY_DIR] = strdup(tmp);
if (_searchpaths[SP_WORKING_DIR] != NULL) {
/* Go back to the current working directory. */
ChangeWorkingDirectory(_searchpaths[SP_WORKING_DIR]);
}
#if defined(__MORPHOS__) || defined(__AMIGA__) || defined(DOS) || defined(OS2)
_searchpaths[SP_INSTALLATION_DIR] = NULL;
#else
snprintf(tmp, MAX_PATH, "%s", GLOBAL_DATA_DIR);
AppendPathSeparator(tmp, MAX_PATH);
_searchpaths[SP_INSTALLATION_DIR] = strdup(tmp);
#endif
#ifdef WITH_COCOA
extern void cocoaSetApplicationBundleDir();
cocoaSetApplicationBundleDir();
#else
_searchpaths[SP_APPLICATION_BUNDLE_DIR] = NULL;
#endif
}
