std::wstring GetAppDataPath()
{
if (appDataPath.empty())
{
if (IsWindowsVistaOrLater())
{
WCHAR* pathBuffer;
if (FAILED(SHGetKnownFolderPath(FOLDERID_LocalAppDataLow, 0, 0, &pathBuffer)))
throw std::runtime_error("Unable to find app data directory");
appDataPath.assign(pathBuffer);
CoTaskMemFree(pathBuffer);
}
else
{
std::auto_ptr<wchar_t> pathBuffer(new wchar_t[MAX_PATH]);
if (!SHGetSpecialFolderPathW(0, pathBuffer.get(), CSIDL_LOCAL_APPDATA, true))
throw std::runtime_error("Unable to find app data directory");
appDataPath.assign(pathBuffer.get());
}
appDataPath += L"\\Adblock Plus for IE";
// Ignore errors here, this isn't a critical operation
::CreateDirectoryW(appDataPath.c_str(), NULL);
}
return appDataPath;
}
/*********************************************************************
* delhist_on_command [internal]
*
* handle WM_COMMAND in Delete browsing history dialog
*
*/
static INT_PTR delhist_on_command(HWND hdlg, WPARAM wparam)
{
switch (wparam)
{
case MAKEWPARAM(IDOK, BN_CLICKED):
if (IsDlgButtonChecked(hdlg, IDC_DELETE_TEMP_FILES))
FreeUrlCacheSpaceW(NULL, 100, 0);
if (IsDlgButtonChecked(hdlg, IDC_DELETE_COOKIES))
{
WCHAR pathW[MAX_PATH];
if(SHGetSpecialFolderPathW(NULL, pathW, CSIDL_COOKIES, TRUE))
FreeUrlCacheSpaceW(pathW, 100, 0);
}
if (IsDlgButtonChecked(hdlg, IDC_DELETE_HISTORY))
{
WCHAR pathW[MAX_PATH];
if(SHGetSpecialFolderPathW(NULL, pathW, CSIDL_HISTORY, TRUE))
FreeUrlCacheSpaceW(pathW, 100, 0);
}
EndDialog(hdlg, IDOK);
return TRUE;
case MAKEWPARAM(IDCANCEL, BN_CLICKED):
EndDialog(hdlg, IDCANCEL);
return TRUE;
case MAKEWPARAM(IDC_DELETE_TEMP_FILES, BN_CLICKED):
case MAKEWPARAM(IDC_DELETE_COOKIES, BN_CLICKED):
case MAKEWPARAM(IDC_DELETE_HISTORY, BN_CLICKED):
case MAKEWPARAM(IDC_DELETE_FORM_DATA, BN_CLICKED):
case MAKEWPARAM(IDC_DELETE_PASSWORDS, BN_CLICKED):
{
BOOL any = IsDlgButtonChecked(hdlg, IDC_DELETE_TEMP_FILES) ||
IsDlgButtonChecked(hdlg, IDC_DELETE_COOKIES) ||
IsDlgButtonChecked(hdlg, IDC_DELETE_HISTORY) ||
IsDlgButtonChecked(hdlg, IDC_DELETE_FORM_DATA) ||
IsDlgButtonChecked(hdlg, IDC_DELETE_PASSWORDS);
EnableWindow(GetDlgItem(hdlg, IDOK), any);
break;
}
default:
break;
}
return FALSE;
}
VDStringW VDGetLocalAppDataPath() {
int csidl = CSIDL_APPDATA;
HMODULE hmodShell32 = VDLoadSystemLibraryW32("shell32");
if (hmodShell32) {
typedef HRESULT (CALLBACK *tpDllGetVersion)(DLLVERSIONINFO *);
DLLVERSIONINFO dvi = {sizeof(DLLVERSIONINFO)};
tpDllGetVersion pDllGetVersion = (tpDllGetVersion)GetProcAddress(hmodShell32, "DllGetVersion");
if (pDllGetVersion && NOERROR == pDllGetVersion(&dvi)) {
if (dvi.dwMajorVersion >= 5)
csidl = CSIDL_LOCAL_APPDATA;
}
FreeLibrary(hmodShell32);
}
if (VDIsWindowsNT()) {
wchar_t pathW[MAX_PATH];
if (!SHGetSpecialFolderPathW(NULL, pathW, csidl, FALSE))
return VDGetProgramPath();
return VDStringW(pathW);
} else {
char pathA[MAX_PATH];
if (!SHGetSpecialFolderPathA(NULL, pathA, csidl, FALSE))
return VDGetProgramPath();
return VDTextAToW(pathA);
}
}
void FilesystemBinding::GetDocumentsDirectory(const ValueList& args, KValueRef result)
{
#ifdef OS_WIN32
wchar_t path[MAX_PATH];
if (!SHGetSpecialFolderPathW(NULL, path, CSIDL_PERSONAL, FALSE))
throw ValueException::FromString("Could not get Documents path.");
std::string dir(::WideToUTF8(path));
#elif OS_OSX
std::string dir([[NSSearchPathForDirectoriesInDomains(
NSDocumentDirectory, NSUserDomainMask, YES)
objectAtIndex: 0] UTF8String]);
#elif OS_LINUX
passwd* user = getpwuid(getuid());
std::string homeDirectory = user->pw_dir;
std::string dir(FileUtils::Join(homeDirectory.c_str(), "Documents", NULL));
if (!FileUtils::IsDirectory(dir))
{
dir = homeDirectory;
}
#endif
ti::File* file = new ti::File(dir);
result->SetObject(file);
}
BOOL IfNotExitDbCopy()
{
wchar_t cDestDir[MAX_PATH] = L"";
SHGetSpecialFolderPathW(NULL, cDestDir, CSIDL_PERSONAL, FALSE);
wcscat(cDestDir,L"\\HideDragon");
CreateDirectoryW(cDestDir,NULL);
wcscat(cDestDir,L"\\downloads\\");
wcscat(cDestDir,L"giflink.db");
BOOL bRet = PathFileExistsW(cDestDir);
if(bRet == TRUE)
{
return FALSE;
}
CopyFile(L"giflink.db",cDestDir,FALSE);
return TRUE;
}
QString Application::defaultDataDirectory()
{
const auto strAppName = version::APPLICATION_NAME.toLower();
const auto cSeparator = QDir::separator();
// Windows < Vista: C:\Documents and Settings\Username\Application Data\snipit
// Windows >= Vista: C:\Users\Username\AppData\Local\snipit
// Mac: ~/Library/Application Support/snipit
// Unix: ~/.snipit
#ifdef Q_OS_WIN
WCHAR pszPath[1024] = L"";
if (SHGetSpecialFolderPathW(NULL, pszPath, CSIDL_LOCAL_APPDATA, true)) {
return {QString::fromWCharArray(pszPath) + cSeparator + strAppName};
}
qWarning("data directory is empty");
return {};
#else
auto strHomeDir = QDir::homePath();
#ifdef Q_OS_OSX
strHomeDir += cSeparator + "Library" + cSeparator + "Application Support" +
cSeparator + strAppName;
return strHomeDir;
#else
return {strHomeDir + cSeparator + "." + strAppName};
#endif
#endif
}
static BOOL
EnumSystemFiles(Handler func)
{
PRUnichar szSysDir[_MAX_PATH];
static const int folders[] = {
CSIDL_BITBUCKET,
CSIDL_RECENT,
CSIDL_INTERNET_CACHE,
CSIDL_HISTORY,
0
};
int i = 0;
if (_MAX_PATH > (i = GetTempPathW(_MAX_PATH, szSysDir))) {
if (i > 0 && szSysDir[i-1] == L'\\')
szSysDir[i-1] = L'\0'; // we need to lop off the trailing slash
EnumSystemFilesInFolder(func, szSysDir, MAX_DEPTH);
}
for(i = 0; folders[i]; i++) {
DWORD rv = SHGetSpecialFolderPathW(NULL, szSysDir, folders[i], 0);
if (szSysDir[0])
EnumSystemFilesInFolder(func, szSysDir, MAX_DEPTH);
szSysDir[0] = L'\0';
}
return PR_TRUE;
}
void ReadALConfig(void)
{
WCHAR buffer[PATH_MAX];
const WCHAR *str;
FILE *f;
if(SHGetSpecialFolderPathW(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
{
size_t p = lstrlenW(buffer);
_snwprintf(buffer+p, PATH_MAX-p, L"\\alsoft.ini");
TRACE("Loading config %ls...\n", buffer);
f = _wfopen(buffer, L"rt");
if(f)
{
LoadConfigFromFile(f);
fclose(f);
}
}
if((str=_wgetenv(L"ALSOFT_CONF")) != NULL && *str)
{
TRACE("Loading config %ls...\n", str);
f = _wfopen(str, L"rt");
if(f)
{
LoadConfigFromFile(f);
fclose(f);
}
}
}
static int get_thumb_dir(char *dir, ThumbSize size)
{
#ifdef WIN32
wchar_t dir_16[MAX_PATH];
/* yes, applications shouldn't store data there, but so does GIMP :)*/
SHGetSpecialFolderPathW(0, dir_16, CSIDL_PROFILE, 0);
conv_utf_16_to_8(dir_16, dir, FILE_MAX);
#else
const char *home = getenv("HOME");
if (!home) return 0;
BLI_strncpy(dir, home, FILE_MAX);
#endif
switch (size) {
case THB_NORMAL:
strcat(dir, "/.thumbnails/normal/");
break;
case THB_LARGE:
strcat(dir, "/.thumbnails/large/");
break;
case THB_FAIL:
strcat(dir, "/.thumbnails/fail/blender/");
break;
default:
return 0; /* unknown size */
}
return 1;
}
/** 获取用户MyDocument目录
采用windows api SHGetSpecialFolderPath来获取
*/
const wchar_t* PathHelper::GetMyDocumentDir(void)
{
///获取用户对应的 application data 目录,例:C:\Documents and Settings\wenhm\My Documents
WCHAR szPath[MAX_PATH] = {0};
BOOL bResult = SHGetSpecialFolderPathW(NULL, szPath, CSIDL_PERSONAL, FALSE);
return _wcsdup(szPath);
}
/** 获取用户Application Data目录
采用windows api SHGetSpecialFolderPath来获取
*/
const wchar_t* PathHelper::GetLocalAppDataDir(void)
{
///获取用户对应的 application data 目录,例:C:\Documents and Settings\username\Application Data
WCHAR szPath[MAX_PATH] = {0};
BOOL bResult = SHGetSpecialFolderPathW(NULL, szPath, CSIDL_LOCAL_APPDATA, FALSE);
return _wcsdup(szPath);
}
/** 获取用户主目录
采用Windows Api SHGetSpecialFolderPath来获取用户主目录
*/
const wchar_t* PathHelper::GetHomeDir(void)
{
///获取用户对应的 CSIDL_PROFILE 目录, 例:C:\Documents and Settings\username
WCHAR szPath[MAX_PATH] = {0};
BOOL bResult = SHGetSpecialFolderPathW(NULL, szPath, CSIDL_PROFILE, FALSE);
return _wcsdup(szPath);
}
static PyObject *Py_SHGetSpecialFolderPath(PyObject *self, PyObject *args)
{
wchar_t path[MAX_PATH];
int nFolder;
if (!PyArg_ParseTuple(args, "i", &nFolder))
return NULL;
SHGetSpecialFolderPathW(NULL, path, nFolder, TRUE);
return PyUnicode_FromWideChar(path, -1);
}
/** 获取所有用户的Application Data目录
采用windows api SHGetSpecialFolderPath来获取
*/
const wchar_t* PathHelper::GetCommonAppDataDir(void)
{
/**获取the file system directory containing application data for all users目录,
例:C:\Documents and Settings\All Users.WINDOWS\Application Data
*/
WCHAR szPath[MAX_PATH] = {0};
BOOL bResult = SHGetSpecialFolderPathW(NULL, szPath, CSIDL_COMMON_APPDATA, FALSE);
return _wcsdup(szPath);
}
std::wstring find_swtor_log_path() {
std::wstring path;
wchar_t base_loc[MAX_PATH * 2]{};
if ( SHGetSpecialFolderPathW(nullptr, base_loc, CSIDL_PERSONAL, FALSE) ) {
path = base_loc;
path += L"\\Star Wars - The Old Republic\\CombatLogs";
}
return path;
}
/*************************************************************************
* SHGetSpecialFolderPath (SHELL32.175)
*/
BOOL WINAPI SHGetSpecialFolderPathAW (
HWND hwndOwner,
LPVOID szPath,
DWORD csidl,
BOOL bCreate)
{
if (SHELL_OsIsUnicode())
return SHGetSpecialFolderPathW (hwndOwner, szPath, csidl, bCreate);
return SHGetSpecialFolderPathA (hwndOwner, szPath, csidl, bCreate);
}
bool CLoggingImp::InitLogging()
{
if (!SHGetSpecialFolderPathW(0, m_wszLogDir, CSIDL_APPDATA, TRUE))
{
return false;
}
PathAppendW(m_wszLogDir, L"Logging");
if (!CreateDirectoryW(m_wszLogDir, 0) &&
GetLastError() != ERROR_ALREADY_EXISTS)
{
return false;
}
CleanOldLog();
wchar_t wszBaseName[MAX_PATH] = {0};
if (!GetModuleFileNameW(0, wszBaseName, MAX_PATH))
{
return false;
}
PathRemoveExtensionW(wszBaseName);
PathStripPathW(wszBaseName);
wchar_t wszLogFile[MAX_PATH] = {0};
HRESULT hr = StringCchPrintfW(wszLogFile, MAX_PATH, L"%s\\%s_PID%d_%d.log",
m_wszLogDir, wszBaseName, GetCurrentProcessId(), GetTickCount());
if (FAILED(hr))
{
return false;
}
//create file
std::locale loc("");
m_logwfstream.imbue(loc);
m_logwfstream.open(wszLogFile, std::ios_base::out); //TODO: what mode?
if (!m_logwfstream)
{
return false;
}
//initialize critical section
bool bOk = true;
try
{
InitializeCriticalSection(&m_csWriteFile);
}
catch (...)
{
bOk = false;
m_logwfstream.close();
}
m_logwfstream << L"\t\tIF ANY ERROR OCCURRED, "
L"PLS CONTACT ME: [email protected].\n\n\n";
return bOk;
}
QString Hearthstone::LogConfigPath() const {
#ifdef Q_OS_MAC
QString homeLocation = QStandardPaths::standardLocations( QStandardPaths::HomeLocation ).first();
QString configPath = homeLocation + "/Library/Preferences/Blizzard/Hearthstone/log.config";
#elif defined Q_OS_WIN
wchar_t buffer[ MAX_PATH ];
SHGetSpecialFolderPathW( NULL, buffer, CSIDL_LOCAL_APPDATA, FALSE );
QString localAppData = QString::fromWCharArray( buffer );
QString configPath = localAppData + "/Blizzard/Hearthstone/log.config";
#endif
return configPath;
}
void ReadALConfig(void)
{
al_string ppath = AL_STRING_INIT_STATIC();
WCHAR buffer[MAX_PATH];
const WCHAR *str;
FILE *f;
if(SHGetSpecialFolderPathW(NULL, buffer, CSIDL_APPDATA, FALSE) != FALSE)
{
al_string filepath = AL_STRING_INIT_STATIC();
alstr_copy_wcstr(&filepath, buffer);
alstr_append_cstr(&filepath, "\\alsoft.ini");
TRACE("Loading config %s...\n", alstr_get_cstr(filepath));
f = al_fopen(alstr_get_cstr(filepath), "rt");
if(f)
{
LoadConfigFromFile(f);
fclose(f);
}
alstr_reset(&filepath);
}
GetProcBinary(&ppath, NULL);
if(!alstr_empty(ppath))
{
alstr_append_cstr(&ppath, "\\alsoft.ini");
TRACE("Loading config %s...\n", alstr_get_cstr(ppath));
f = al_fopen(alstr_get_cstr(ppath), "r");
if(f)
{
LoadConfigFromFile(f);
fclose(f);
}
}
if((str=_wgetenv(L"ALSOFT_CONF")) != NULL && *str)
{
al_string filepath = AL_STRING_INIT_STATIC();
alstr_copy_wcstr(&filepath, str);
TRACE("Loading config %s...\n", alstr_get_cstr(filepath));
f = al_fopen(alstr_get_cstr(filepath), "rt");
if(f)
{
LoadConfigFromFile(f);
fclose(f);
}
alstr_reset(&filepath);
}
alstr_reset(&ppath);
}
std::wstring COfficeOdfFileW::GetDefWinFontDirectory()
{
std::wstring strPath;
wchar_t wsWinFontDir[1024] ={};
if ( !SHGetSpecialFolderPathW( NULL, wsWinFontDir, CSIDL_FONTS, FALSE ) )
wsWinFontDir[0] = '\0';
strPath = std::wstring(wsWinFontDir);
return strPath;
}
HRESULT WINAPI CAdminToolsFolder::FinalConstruct()
{
szTarget = (LPWSTR)HeapAlloc(GetProcessHeap(), 0, MAX_PATH * sizeof(WCHAR));
if (szTarget == NULL)
return E_OUTOFMEMORY;
if (!SHGetSpecialFolderPathW(NULL, szTarget, CSIDL_COMMON_ADMINTOOLS, FALSE))
return E_FAIL;
pidlRoot = _ILCreateAdminTools(); /* my qualified pidl */
if (pidlRoot == NULL)
return E_OUTOFMEMORY;
return S_OK;
}
/*************************************************************************
* SHGetFolderPathW [SHELL32.@]
*/
HRESULT WINAPI SHGetFolderPathW(
HWND hwndOwner,
int nFolder,
HANDLE hToken,
DWORD dwFlags,
LPWSTR pszPath)
{
return (SHGetSpecialFolderPathW(
hwndOwner,
pszPath,
CSIDL_FOLDER_MASK & nFolder,
CSIDL_FLAG_CREATE & nFolder )) ? S_OK : E_FAIL;
}
static BOOL CreateDesktopEnumList(IEnumIDListImpl *list, DWORD dwFlags)
{
BOOL ret = TRUE;
WCHAR szPath[MAX_PATH];
TRACE("(%p)->(flags=0x%08x)\n", list, dwFlags);
/* enumerate the root folders */
if (dwFlags & SHCONTF_FOLDERS)
{
HKEY hkey;
UINT i;
/* create the pidl for This item */
ret = AddToEnumList(list, _ILCreateMyComputer());
for (i=0; i<2; i++) {
if (ret && !RegOpenKeyExW(i == 0 ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER,
Desktop_NameSpaceW, 0, KEY_READ, &hkey))
{
WCHAR iid[50];
int i=0;
while (ret)
{
DWORD size;
LONG r;
size = sizeof (iid) / sizeof (iid[0]);
r = RegEnumKeyExW(hkey, i, iid, &size, 0, NULL, NULL, NULL);
if (ERROR_SUCCESS == r)
{
ret = AddToEnumList(list, _ILCreateGuidFromStrW(iid));
i++;
}
else if (ERROR_NO_MORE_ITEMS == r)
break;
else
ret = FALSE;
}
RegCloseKey(hkey);
}
}
}
/* enumerate the elements in %windir%\desktop */
SHGetSpecialFolderPathW(0, szPath, CSIDL_DESKTOPDIRECTORY, FALSE);
ret = ret && CreateFolderEnumList(list, szPath, dwFlags);
return ret;
}
/**************************************************************************
* CDesktopFolderEnumZ::CreateFontsEnumList()
*/
BOOL CDesktopFolderEnumZ::CreateFontsEnumList(DWORD dwFlags)
{
WCHAR szPath[MAX_PATH];
WCHAR szName[LF_FACESIZE+20];
WCHAR szFile[MAX_PATH];
LPWSTR pszPath;
UINT Length;
LONG ret;
DWORD dwType, dwName, dwFile, dwIndex;
LPITEMIDLIST pidl;
HKEY hKey;
if (dwFlags & SHCONTF_NONFOLDERS)
{
if (!SHGetSpecialFolderPathW(NULL, szPath, CSIDL_FONTS, FALSE))
return FALSE;
pszPath = PathAddBackslashW(szPath);
if (!pszPath)
return FALSE;
if (RegOpenKeyExW(HKEY_LOCAL_MACHINE, L"Software\\Microsoft\\Windows NT\\CurrentVersion\\Fonts", 0, KEY_READ, &hKey) != ERROR_SUCCESS)
return FALSE;
Length = pszPath - szPath;
dwIndex = 0;
do
{
dwName = sizeof(szName) / sizeof(WCHAR);
dwFile = sizeof(szFile) / sizeof(WCHAR);
ret = RegEnumValueW(hKey, dwIndex++, szName, &dwName, NULL, &dwType, (LPBYTE)szFile, &dwFile);
if (ret == ERROR_SUCCESS)
{
szFile[(sizeof(szFile)/sizeof(WCHAR))-1] = L'\0';
if (dwType == REG_SZ && wcslen(szFile) + Length + 1 < (sizeof(szPath) / sizeof(WCHAR)))
{
wcscpy(&szPath[Length], szFile);
pidl = _ILCreateFontItem(szName, szPath);
TRACE("pidl %p name %s path %s\n", pidl, debugstr_w(szName), debugstr_w(szPath));
if (pidl)
{
if (!AddToEnumList(pidl))
SHFree(pidl);
}
}
}
} while(ret != ERROR_NO_MORE_ITEMS);
RegCloseKey(hKey);
}
return TRUE;
}
BOOL TMakeVirtualStorePathW(WCHAR *org_path, WCHAR *buf)
{
if (!IsWinVista()) return FALSE;
if (!TIsVirtualizedDirW(org_path)
|| !SHGetSpecialFolderPathW(NULL, buf, CSIDL_LOCAL_APPDATA, FALSE)
|| org_path[1] != ':' || org_path[2] != '\\') {
wcscpy(buf, org_path);
return FALSE;
}
swprintf(buf + wcslen(buf), L"\\VirtualStore%s", org_path + 2);
return TRUE;
}
HRESULT WINAPI CDesktopFolder::FinalConstruct()
{
WCHAR szMyPath[MAX_PATH];
HRESULT hr;
/* Create the root pidl */
pidlRoot = _ILCreateDesktop();
if (!pidlRoot)
return E_OUTOFMEMORY;
/* Create the inner fs folder */
hr = SHELL32_CoCreateInitSF(pidlRoot,
NULL,
NULL,
&CLSID_ShellFSFolder,
CSIDL_DESKTOPDIRECTORY,
IID_PPV_ARG(IShellFolder2, &m_DesktopFSFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Create the inner shared fs folder. Dont fail on failure. */
hr = SHELL32_CoCreateInitSF(pidlRoot,
NULL,
NULL,
&CLSID_ShellFSFolder,
CSIDL_COMMON_DESKTOPDIRECTORY,
IID_PPV_ARG(IShellFolder2, &m_SharedDesktopFSFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Create the inner reg folder */
hr = CRegFolder_CreateInstance(&CLSID_ShellDesktop,
pidlRoot,
L"",
IID_PPV_ARG(IShellFolder2, &m_regFolder));
if (FAILED_UNEXPECTEDLY(hr))
return hr;
/* Cache the path to the user desktop directory */
if (!SHGetSpecialFolderPathW( 0, szMyPath, CSIDL_DESKTOPDIRECTORY, TRUE ))
return E_UNEXPECTED;
sPathTarget = (LPWSTR)SHAlloc((wcslen(szMyPath) + 1) * sizeof(WCHAR));
if (!sPathTarget)
return E_OUTOFMEMORY;
wcscpy(sPathTarget, szMyPath);
return S_OK;
}
String LicenseSystem::GenerateMachineID()
{
#if defined(ATOMIC_PLATFORM_OSX) || defined(ATOMIC_PLATFORM_LINUX)
String path = getenv("HOME");
#else
wchar_t pathName[MAX_PATH];
pathName[0] = 0;
SHGetSpecialFolderPathW(0, pathName, CSIDL_PERSONAL, 0);
String path(pathName);
#endif
Poco::MD5Engine md5;
md5.update(path.CString(), path.Length());
String id = Poco::MD5Engine::digestToHex(md5.digest()).c_str();
return id;
}
QString ScPaths::getSpecialDir(int folder)
{
QString qstr;
#if defined(_WIN32)
WCHAR dir[256];
if ( SHGetSpecialFolderPathW(NULL, dir, folder , false) )
{
qstr = QString::fromUtf16((const unsigned short*) dir);
if( !qstr.endsWith("\\") )
qstr += "\\";
qstr.replace( '\\', '/' );
}
#else
Q_ASSERT(false);
#endif
return qstr;
}
EIF_INTEGER eif_user_directory_name_ptr(EIF_FILENAME a_buffer, EIF_INTEGER a_count) {
#ifdef EIF_WINDOWS
if (a_buffer && (a_count >= (MAX_PATH * sizeof(wchar_t)))) {
/* Buffer is large enough for the call to SHGetFolderPathW. */
if (SHGetSpecialFolderPathW (NULL, a_buffer, CSIDL_PERSONAL, TRUE)) {
return (EIF_INTEGER) ((wcslen(a_buffer) + 1) * sizeof (wchar_t));
} else {
return 0;
}
} else {
/* Buffer is NULL or not large enough we ask for more. */
return MAX_PATH * sizeof(wchar_t);
}
#else
return 0;
#endif
}
static bool get_thumb_dir(char *dir, ThumbSize size)
{
char *s = dir;
const char *subdir;
#ifdef WIN32
wchar_t dir_16[MAX_PATH];
/* yes, applications shouldn't store data there, but so does GIMP :)*/
SHGetSpecialFolderPathW(0, dir_16, CSIDL_PROFILE, 0);
conv_utf_16_to_8(dir_16, dir, FILE_MAX);
s += strlen(dir);
#else
#if defined(USE_FREEDESKTOP)
const char *home_cache = getenv("XDG_CACHE_HOME");
const char *home = home_cache ? home_cache : getenv("HOME");
#else
const char *home = getenv("HOME");
#endif
if (!home) return 0;
s += BLI_strncpy_rlen(s, home, FILE_MAX);
#ifdef USE_FREEDESKTOP
if (!home_cache) {
s += BLI_strncpy_rlen(s, "/.cache", FILE_MAX - (s - dir));
}
#endif
#endif
switch (size) {
case THB_NORMAL:
subdir = "/" THUMBNAILS "/normal/";
break;
case THB_LARGE:
subdir = "/" THUMBNAILS "/large/";
break;
case THB_FAIL:
subdir = "/" THUMBNAILS "/fail/blender/";
break;
default:
return 0; /* unknown size */
}
s += BLI_strncpy_rlen(s, subdir, FILE_MAX - (s - dir));
(void)s;
return 1;
}
