bool FolderBrowserDialog::SetBufFromDir(const wchar_t * src, wchar_t* buf, int blen)
{
DWORD retlen = GetFullPathNameW(src, blen, buf, NULL);
if (retlen && retlen < MAX_WPATH && PathIsDirectoryW(buf))
return true;
return false;
}
static void create_target_directory(LPWSTR Target)
{
WCHAR dir[MAX_PATH];
int res;
strcpyW(dir, Target);
*PathFindFileNameW(dir) = 0; /* Truncate file name */
if(!PathIsDirectoryW(dir))
{
res = SHCreateDirectoryExW(NULL, dir, NULL);
if(res != ERROR_SUCCESS && res != ERROR_ALREADY_EXISTS)
WINE_ERR("Can't create directory: %s\n", wine_dbgstr_w(dir));
}
}
///
/// @brief 파일 첨부 DLG 제어
///
BOOL WINAPI GetOpenFileNameWCallback(
_Inout_ LPOPENFILENAMEW lpofn
)
{
_TRACE(L"");
CString strURL = GetURL();
BOOL bRet = FALSE;
/// 파일 첨부 차단
if(TRUE == pRule->IsBlockAttachFile())
{
/// 파일 첨부 허가 URL 검사
if(TRUE == SearchStringFromFile(ALLOW_ATTACH_FILE_URL_TXT, strURL))
bRet = GetOpenFileNameWNext(lpofn);
else
{
AfxMessageBox(L"Mini-DLP에 의해 파일 첨부가 차단됩니다.");
return FALSE;
}
}
else
bRet = GetOpenFileNameWNext(lpofn);
/// 첨부 파일 로그를 남김
if(TRUE == pRule->IsLoggingMail() && TRUE == pRule->IsLoggingAttachFile())
{
if(NULL != *lpofn->lpstrFile)
{
if(FALSE == PathIsDirectoryW(lpofn->lpstrFile))
MakeLogFile(LOG_WEB_FILE, lpofn->lpstrFile);
else
{
CStringArray strArr;
/// 포인터 연산을 위해 저장
LPCWSTR lpTemp = lpofn->lpstrFile;
while(TRUE)
{
lpTemp += wcslen(lpTemp) + 1;
if(NULL != *lpTemp)
MakeLogFile(LOG_WEB_FILE,(CString)lpofn->lpstrFile + L"\\" + lpTemp);
else
break;
}
}
}
}
return bRet;
};
void ContextMenuExt::UpdateSelectionFlags(std::wstring currentPath)
{
// ONE: number of files
m_selectionOnlyOne = (m_files.size() == 1);
// FOLDER: if folder flag not set, check whether last path is a folder
bool isFolder = PathIsDirectoryW(currentPath.c_str()) != false;
if (!m_selectionHasFolders && isFolder){
m_selectionHasFolders = true;
}
// FILE: if file flag not set, check whether last path is a file
if (!m_selectionHasFiles && !isFolder) {
m_selectionHasFiles = true;
}
}
static HRESULT Folder_Constructor(VARIANT *dir, Folder **ppsdf)
{
FolderImpl *This;
HRESULT ret;
*ppsdf = NULL;
switch (V_VT(dir))
{
case VT_I4:
/* FIXME: add some checks */
break;
case VT_BSTR:
if (PathIsDirectoryW(V_BSTR(dir)) &&
!PathIsRelativeW(V_BSTR(dir)) &&
PathFileExistsW(V_BSTR(dir)))
break;
default:
return S_FALSE;
}
This = HeapAlloc(GetProcessHeap(), 0, sizeof(FolderImpl));
if (!This) return E_OUTOFMEMORY;
This->Folder_iface.lpVtbl = &FolderImpl_Vtbl;
This->ref = 1;
ret = load_type_info(&IID_Folder3, &This->iTypeInfo);
if (FAILED(ret))
{
HeapFree(GetProcessHeap(), 0, This);
return ret;
}
VariantInit(&This->dir);
ret = VariantCopy(&This->dir, dir);
if (FAILED(ret))
{
ITypeInfo_Release(This->iTypeInfo);
HeapFree(GetProcessHeap(), 0, This);
return E_OUTOFMEMORY;
}
*ppsdf = (Folder*)This;
return ret;
}
int WINAPI wWinMain(HINSTANCE hinstance,
HINSTANCE previnstance,
LPWSTR cmdline,
int cmdshow)
{
parameters_struct parameters;
HRESULT hres;
MSG msg;
IShellFolder *folder;
INITCOMMONCONTROLSEX init_info;
memset(¶meters,0,sizeof(parameters));
explorer_hInstance = hinstance;
parse_command_line(cmdline,¶meters);
hres = OleInitialize(NULL);
if(FAILED(hres))
{
WINE_ERR("Could not initialize COM\n");
ExitProcess(EXIT_FAILURE);
}
if(parameters.root[0] && !PathIsDirectoryW(parameters.root))
if(ShellExecuteW(NULL,NULL,parameters.root,NULL,NULL,SW_SHOWDEFAULT) > (HINSTANCE)32)
ExitProcess(EXIT_SUCCESS);
init_info.dwSize = sizeof(INITCOMMONCONTROLSEX);
init_info.dwICC = ICC_USEREX_CLASSES | ICC_BAR_CLASSES | ICC_COOL_CLASSES;
if(!InitCommonControlsEx(&init_info))
{
WINE_ERR("Could not initialize Comctl\n");
ExitProcess(EXIT_FAILURE);
}
register_explorer_window_class();
folder = get_starting_shell_folder(¶meters);
make_explorer_window(folder);
IShellFolder_Release(folder);
while(GetMessageW( &msg, NULL, 0, 0 ) != 0)
{
TranslateMessage(&msg);
DispatchMessageW(&msg);
}
return 0;
}
static UINT
LoadPropSheetHandlers(LPCWSTR pwszPath, PROPSHEETHEADERW *pHeader, UINT cMaxPages, HPSXA *phpsxa, IDataObject *pDataObj)
{
WCHAR wszBuf[MAX_PATH];
UINT cPages = 0, i = 0;
LPWSTR pwszFilename = PathFindFileNameW(pwszPath);
BOOL bDir = PathIsDirectoryW(pwszPath);
if (bDir)
{
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Folder", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"Directory", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
else
{
/* Load property sheet handlers from ext key */
LPWSTR pwszExt = PathFindExtensionW(pwszFilename);
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, pwszExt, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
/* Load property sheet handlers from prog id key */
DWORD cbBuf = sizeof(wszBuf);
if (RegGetValueW(HKEY_CLASSES_ROOT, pwszExt, L"", RRF_RT_REG_SZ, NULL, wszBuf, &cbBuf) == ERROR_SUCCESS)
{
TRACE("EnumPropSheetExt wszBuf %s, pwszExt %s\n", debugstr_w(wszBuf), debugstr_w(pwszExt));
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, wszBuf, cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
/* Add property sheet handlers from "*" key */
phpsxa[i] = SHCreatePropSheetExtArrayEx(HKEY_CLASSES_ROOT, L"*", cMaxPages - cPages, pDataObj);
cPages += SHAddFromPropSheetExtArray(phpsxa[i++], AddPropSheetPageCallback, (LPARAM)pHeader);
}
return cPages;
}
HRESULT CPPTXFile::put_TempDirectory(std::wstring newVal)
{
std::wstring TempStr(newVal);
#if defined(_WIN32) || defined (_WIN64)
if(PathIsDirectoryW(TempStr.c_str()))
{
if(TempStr.substr(TempStr.length() - 2, 1) != L"\\")
TempStr += L"\\";
m_strTempDir = TempStr;
return S_OK;
}
#else
if(NSDirectory::PathIsDirectory(TempStr))
{
if(TempStr[TempStr.length() - 1] != L'/')
TempStr += L"/";
m_strTempDir = TempStr;
}
#endif
return S_FALSE;
}
HRESULT WINAPI
CFileDefExt::Initialize(LPCITEMIDLIST pidlFolder, IDataObject *pDataObj, HKEY hkeyProgID)
{
FORMATETC format;
STGMEDIUM stgm;
HRESULT hr;
TRACE("%p %p %p %p\n", this, pidlFolder, pDataObj, hkeyProgID);
if (!pDataObj)
return E_FAIL;
format.cfFormat = CF_HDROP;
format.ptd = NULL;
format.dwAspect = DVASPECT_CONTENT;
format.lindex = -1;
format.tymed = TYMED_HGLOBAL;
hr = pDataObj->GetData(&format, &stgm);
if (FAILED(hr))
return hr;
if (!DragQueryFileW((HDROP)stgm.hGlobal, 0, m_wszPath, _countof(m_wszPath)))
{
ERR("DragQueryFileW failed\n");
ReleaseStgMedium(&stgm);
return E_FAIL;
}
ReleaseStgMedium(&stgm);
TRACE("File properties %ls\n", m_wszPath);
m_bDir = PathIsDirectoryW(m_wszPath) ? TRUE : FALSE;
if (!m_bDir)
m_VerInfo.Load(m_wszPath);
return S_OK;
}
static void copy_file(LPCWSTR source, LPCWSTR destination)
{
WCHAR destfile[MAX_PATH];
/* append source filename if destination is a directory */
if (PathIsDirectoryW(destination))
{
PathCombineW(destfile, destination, PathFindFileNameW(source));
destination = destfile;
}
if (PathFileExistsW(destination) && !force_mode)
{
static const WCHAR overwriteMsg[] = {'O','v','e','r','w','r','i','t','e',' ','"','%','s','"','?',0};
static const WCHAR titleMsg[] = {'E','x','t','r','a','c','t',0};
WCHAR msg[MAX_PATH+100];
snprintfW(msg, sizeof(msg)/sizeof(msg[0]), overwriteMsg, destination);
if (MessageBoxW(NULL, msg, titleMsg, MB_YESNO | MB_ICONWARNING) != IDYES)
return;
}
WINE_TRACE("copying %s to %s\n", wine_dbgstr_w(source), wine_dbgstr_w(destination));
CopyFileW(source, destination, FALSE);
}
bool
GetFileCount(
const LPCWSTR& in_lpszPathW,
DWORD& io_iCount,
std::vector<std::wstring>& io_VecFiles,
std::list<std::wstring>& in_SkippedExtensions,
const bool in_bDontRecurse = false)
{
_ASSERT(in_lpszPathW);
std::wstring strPathW(in_lpszPathW);
_ASSERT( strPathW.length() );
if(!PathIsDirectoryW(in_lpszPathW)) return false;
if( strPathW.length())
{
if( strPathW[ strPathW.length() - 1 ] == L'\\' )
{
strPathW += L"*.*";
}
else
{
strPathW += L"\\*.*";
}
}
TRACEW2(L"Doing a findfile on [%s] count is [%d]\n", strPathW.c_str(), io_iCount);
WIN32_FIND_DATAW fileData={0};
//The first handle returns a valid file handle which is not the case with CFileFind::FindFile()
HANDLE hFind = FindFirstFileW(strPathW.c_str(), &fileData);
if(hFind != INVALID_HANDLE_VALUE)
{
BOOL bWorking = true;
std::wstring filePath = ExtractDirectoryW(strPathW);
while(bWorking)
{
const std::wstring fileName(fileData.cFileName);
if( ( (fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) && IsDots(fileName) ) || (fileData.dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT))
{
bWorking = FindNextFileW(hFind, &fileData);
continue;
}
if(fileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
{
if(!in_bDontRecurse)
{
TRACEW2(L"Doing a recursive GetFileCount on [%s] count is [%d]\n", fileData.cFileName, io_iCount);
GetFileCount( (filePath + fileName).c_str(), io_iCount, io_VecFiles, in_SkippedExtensions);
}
else
{
TRACE0("Not doing a recurse, in_bDontRecurse is true");
}
}
else
{
if(in_SkippedExtensions.size())
{
// There's something in the list
// Look for the current extension in the list, if it's there do not increment the counter
const std::wstring extension (getExtensionW(fileName).c_str());
TRACEW2(L"Gonna look for extension [%s] of file [%s] in the list of excluded extension\n", extension.c_str(), fileName.c_str());
std::list<std::wstring>::const_iterator i = std::find(in_SkippedExtensions.begin(), in_SkippedExtensions.end(), extension);
if(i == in_SkippedExtensions.end()) // extension not in list
{
io_VecFiles.push_back(filePath + fileName);
++io_iCount;
}
else
{
TRACEW1(L"Skipped file [%s], it matched a skipped extension\n", fileName.c_str());
}
}
else
{
io_VecFiles.push_back(filePath + fileName);
++io_iCount;
}
}
bWorking = FindNextFileW(hFind,&fileData);
}
FindClose(hFind);
}
return true;
}
int WsCreate(wchar_t *CartName)
{
int Checksum, i, j;
FILE* fp;
BYTE buf[16];
wchar_t* p;
for (i = 0; i < 256; i++)
{
ROMMap[i] = MemDummy;
RAMMap[i] = MemDummy;
}
memset(IRAM, 0, sizeof(IRAM));
memset(MemDummy, 0xA0, sizeof(MemDummy));
memset(IO, 0, sizeof(IO));
if (CartName == NULL)
{
return WsSetPdata();
}
if ((fp = _wfopen(CartName, L"rb")) == NULL)
{
ErrorMsg(ERR_FOPEN);
return -1;
}
fseek(fp, -10, 2);
if (fread(buf, 1, 10, fp) != 10)
{
ErrorMsg(ERR_FREAD_ROMINFO);
return -1;
}
switch (buf[4])
{
case 1:
ROMBanks = 4;
break;
case 2:
ROMBanks = 8;
break;
case 3:
ROMBanks = 16;
break;
case 4:
ROMBanks = 32;
break;
case 5:
ROMBanks = 48;
break;
case 6:
ROMBanks = 64;
break;
case 7:
ROMBanks = 96;
break;
case 8:
ROMBanks = 128;
break;
case 9:
ROMBanks = 256;
break;
default:
ROMBanks = 0;
break;
}
if (ROMBanks == 0)
{
ErrorMsg(ERR_ILLEGAL_ROMSIZE);
return -1;
}
switch (buf[5])
{
case 0x01:
RAMBanks = 1;
RAMSize = 0x2000;
CartKind = 0;
break;
case 0x02:
RAMBanks = 1;
RAMSize = 0x8000;
CartKind = 0;
break;
case 0x03:
RAMBanks = 2;
RAMSize = 0x20000;
CartKind = 0;
break;
case 0x04:
RAMBanks = 4;
RAMSize = 0x40000;
CartKind = 0;
break;
case 0x10:
RAMBanks = 1;
RAMSize = 0x80;
CartKind = CK_EEP;
break;
case 0x20:
RAMBanks = 1;
RAMSize = 0x800;
CartKind = CK_EEP;
break;
case 0x50:
RAMBanks = 1;
RAMSize = 0x400;
CartKind = CK_EEP;
break;
default:
RAMBanks = 0;
RAMSize = 0;
CartKind = 0;
break;
}
WsRomPatch(buf);
Checksum = (int)((buf[9] << 8) + buf[8]);
Checksum += (int)(buf[9] + buf[8]);
for (i = ROMBanks - 1; i >= 0; i--)
{
fseek(fp, (ROMBanks - i) * -0x10000, 2);
if ((ROMMap[0x100 - ROMBanks + i] = (BYTE*)malloc(0x10000)) != NULL)
{
if (fread(ROMMap[0x100 - ROMBanks + i], 1, 0x10000, fp) == 0x10000)
{
for (j = 0; j < 0x10000; j++)
{
Checksum -= ROMMap[0x100 - ROMBanks + i][j];
}
}
else
{
ErrorMsg(ERR_FREAD_ROM);
break;
}
}
else
{
ErrorMsg(ERR_MALLOC);
break;
}
}
fclose(fp);
if (i >= 0)
{
return -1;
}
if (Checksum & 0xFFFF)
{
//ErrorMsg(ERR_CHECKSUM);
}
if (RAMBanks)
{
for (i = 0; i < RAMBanks; i++)
{
if ((RAMMap[i] = (BYTE*)malloc(0x10000)) != NULL)
{
memset(RAMMap[i], 0x00, 0x10000);
}
else
{
ErrorMsg(ERR_MALLOC);
return -1;
}
}
}
if (RAMSize)
{
wcscpy (SaveName, CurDir);
p = wcsrchr(CartName, L'\\');
if (p)
{
wcscat(SaveName, SaveDir);
if (PathIsDirectoryW(SaveName) == FALSE)
{
CreateDirectoryW(SaveName, NULL);
}
wcscat(SaveName, p);
p = wcsrchr(SaveName, L'.');
if (p)
{
*p = 0;
}
wcscat(SaveName, L".sav");
}
else
{
SaveName[0] = 0;
}
if ((fp = _wfopen(SaveName, L"rb")) != NULL)
{
for (i = 0; i < RAMBanks; i++)
{
if (RAMSize < 0x10000)
{
if (fread(RAMMap[i], 1, RAMSize, fp) != (size_t)RAMSize)
{
ErrorMsg(ERR_FREAD_SAVE);
break;
}
}
else
{
if (fread(RAMMap[i], 1, 0x10000, fp) != 0x10000)
{
ErrorMsg(ERR_FREAD_SAVE);
break;
}
}
}
fclose(fp);
}
}
else
{
SaveName[0] = 0;
}
wcscpy (StateName, CurDir);
p = wcsrchr(CartName, L'\\');
if (p)
{
wcscat(StateName, StateDir);
if (PathIsDirectoryW(StateName) == FALSE)
{
CreateDirectoryW(StateName, NULL);
}
wcscat(StateName, p);
p = wcsrchr(StateName, L'.');
if (p)
{
*p = 0;
}
}
WsReset();
SetDrawMode(buf[6] & 1); // 0:横 1:縦
return 0;
}
/*************************************************************************
* PathIsDirectory [SHELL32.159]
*/
BOOL WINAPI PathIsDirectoryAW (LPCVOID lpszPath)
{
if (SHELL_OsIsUnicode())
return PathIsDirectoryW (lpszPath);
return PathIsDirectoryA (lpszPath);
}
