INT
SheChangeDirW(
register WCHAR *newdir
)
{
WCHAR denvname[ 4 ];
WCHAR newpath[ MAX_PATH ];
WCHAR denvvalue[ MAX_PATH ];
WCHAR c, *s;
DWORD attr;
GetCurrentDirectoryW( MAX_PATH, denvvalue );
c = (WCHAR)(DWORD)CharUpperW((LPTSTR)(DWORD)denvvalue[0]);
denvname[0] = WCHAR_EQUAL;
if (IsCharAlphaW(*newdir) && newdir[1] == WCHAR_COLON) {
denvname[1] = (WCHAR)(DWORD)CharUpperW((LPTSTR)(DWORD)*newdir);
newdir += 2;
} else {
denvname[ 1 ] = c;
}
denvname[ 2 ] = WCHAR_COLON;
denvname[ 3 ] = WCHAR_NULL;
if ((*newdir == WCHAR_BSLASH) || (*newdir == WCHAR_SLASH)) {
newpath[ 0 ] = denvname[ 1 ];
newpath[ 1 ] = denvname[ 2 ];
wcscpy( &newpath[ 2 ], newdir );
} else {
if (NULL != (s = SheGetEnvVarW( denvname ))) {
wcscpy( newpath, s );
} else {
newpath[ 0 ] = denvname[ 1 ];
newpath[ 1 ] = denvname[ 2 ];
newpath[ 2 ] = WCHAR_NULL;
}
s = newpath + wcslen( newpath );
*s++ = WCHAR_BSLASH;
wcscpy( s, newdir );
}
if (!GetFullPathNameW(newpath, MAX_PATH, denvvalue, &s )) {
return( ERROR_ACCESS_DENIED );
}
attr = GetFileAttributesW( denvvalue );
if (attr == -1 || !(attr & FILE_ATTRIBUTE_DIRECTORY)) {
return( ERROR_ACCESS_DENIED );
}
if (SheSetEnvVarW(denvname,denvvalue)) {
return( ERROR_NOT_ENOUGH_MEMORY );
}
SetCurrentDirectoryW( denvvalue );
// this seems wrong... SheGetDir(GD_DEFAULT, CurDrvDirW) ;
wcscpy(CurDrvDirW, denvvalue); // this seems right to me.
return(SUCCESS) ;
}
static inline BSTR str_dup_upper(BSTR str)
{
INT len = (lstrlenW(str) + 1) * sizeof(WCHAR);
BSTR p = SysAllocStringLen(NULL, len);
if (p)
{
memcpy(p, str, len);
CharUpperW(p);
}
return p;
}
wchar_t * MyStringUpper(wchar_t *s)
{
if (s == 0)
return 0;
wchar_t *res = CharUpperW(s);
if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
return res;
AString a = UnicodeStringToMultiByte(s);
a.MakeUpper();
return MyStringCopy(s, (const wchar_t *)MultiByteToUnicodeString(a));
}
uint32_t charUpper(uint32_t param)
{
if (param<128) {
if (param>='a' && param<='z') param += 'A' - 'a';
return param;
}
#ifdef PFC_WINDOWS_DESKTOP_APP
else if (param<0x10000) {
return (unsigned)CharUpperW((WCHAR*)param);
}
#endif
else return param;
}
wchar_t MyCharUpper(wchar_t c)
{
if (c == 0)
return 0;
wchar_t *res = CharUpperW((LPWSTR)(unsigned int)c);
if (res != 0 || ::GetLastError() != ERROR_CALL_NOT_IMPLEMENTED)
return (wchar_t)(unsigned int)res;
const int kBufferSize = 4;
char s[kBufferSize];
int numChars = ::WideCharToMultiByte(CP_ACP, 0, &c, 1, s, kBufferSize, 0, 0);
::CharUpperA(s);
::MultiByteToWideChar(CP_ACP, 0, s, numChars, &c, 1);
return c;
}
INT
SheFullPathW(
register WCHAR *fname,
DWORD sizpath,
WCHAR *buf)
{
DWORD rc = SUCCESS; /* prime with good rc */
DWORD buflen; /* buffer length */
WCHAR *filepart;
if (*fname == WCHAR_NULL) {
SheGetDirW(GD_DEFAULT, buf);
buf += 2; /* Inc past drivespec */
buflen = wcslen(buf); /* Is curdir root only? */
if (buflen >= MAX_PATH-3) { /* If too big then stop */
dwDosErr = ERROR_PATH_NOT_FOUND;
rc = FAILURE;
} else if (buflen != 1) { /* if not root then append */
*(buf+buflen++) = WCHAR_BSLASH; /* ...a pathchar and... */
*(buf+buflen) = WCHAR_NULL ; /* ...a null CHAR... */
} /* */
} else {
if ((wcslen(fname) == 2) &&
(*(fname + 1) == WCHAR_COLON)
// && (!is_dbcsleadchar(*fname))
) {
SheGetDirW((WCHAR)(DWORD)CharUpperW((LPWSTR)(DWORD)*fname) - WCHAR_CAP_A, buf); /* Get curdrvdir */
if ((buflen = wcslen(buf)) > 3) {
*(buf+buflen++) = WCHAR_BSLASH; /* ...a pathchar and... */
*(buf+buflen) = WCHAR_NULL ; /* ...a null CHAR... */
}
} else {
if (!GetFullPathNameW( fname, sizpath, buf, &filepart )) {
dwDosErr = GetLastError();
rc = FAILURE;
}
}
}
return(rc);
}
wchar_t * _wcsupr(wchar_t * pszArg)
{
return CharUpperW(pszArg);
}
static int _glfwTranslateKey( DWORD wParam, DWORD lParam )
{
MSG next_msg;
DWORD msg_time;
DWORD scan_code;
// Check which key was pressed or released
switch( wParam )
{
// The SHIFT keys require special handling
case VK_SHIFT:
// Compare scan code for this key with that of VK_RSHIFT in
// order to determine which shift key was pressed (left or
// right)
scan_code = MapVirtualKey( VK_RSHIFT, 0 );
if( ((lParam & 0x01ff0000) >> 16) == scan_code )
{
return GLFW_KEY_RSHIFT;
}
return GLFW_KEY_LSHIFT;
// The CTRL keys require special handling
case VK_CONTROL:
// Is this an extended key (i.e. right key)?
if( lParam & 0x01000000 )
{
return GLFW_KEY_RCTRL;
}
// Here is a trick: "Alt Gr" sends LCTRL, then RALT. We only
// want the RALT message, so we try to see if the next message
// is a RALT message. In that case, this is a false LCTRL!
msg_time = GetMessageTime();
if( PeekMessage( &next_msg, NULL, 0, 0, PM_NOREMOVE ) )
{
if( next_msg.message == WM_KEYDOWN ||
next_msg.message == WM_SYSKEYDOWN )
{
if( next_msg.wParam == VK_MENU &&
(next_msg.lParam & 0x01000000) &&
next_msg.time == msg_time )
{
// Next message is a RALT down message, which
// means that this is NOT a proper LCTRL message!
return GLFW_KEY_UNKNOWN;
}
}
}
return GLFW_KEY_LCTRL;
// The ALT keys require special handling
case VK_MENU:
// Is this an extended key (i.e. right key)?
if( lParam & 0x01000000 )
{
return GLFW_KEY_RALT;
}
return GLFW_KEY_LALT;
// The ENTER keys require special handling
case VK_RETURN:
// Is this an extended key (i.e. right key)?
if( lParam & 0x01000000 )
{
return GLFW_KEY_KP_ENTER;
}
return GLFW_KEY_ENTER;
// Special keys (non character keys)
case VK_ESCAPE: return GLFW_KEY_ESC;
case VK_TAB: return GLFW_KEY_TAB;
case VK_BACK: return GLFW_KEY_BACKSPACE;
case VK_HOME: return GLFW_KEY_HOME;
case VK_END: return GLFW_KEY_END;
case VK_PRIOR: return GLFW_KEY_PAGEUP;
case VK_NEXT: return GLFW_KEY_PAGEDOWN;
case VK_INSERT: return GLFW_KEY_INSERT;
case VK_DELETE: return GLFW_KEY_DEL;
case VK_LEFT: return GLFW_KEY_LEFT;
case VK_UP: return GLFW_KEY_UP;
case VK_RIGHT: return GLFW_KEY_RIGHT;
case VK_DOWN: return GLFW_KEY_DOWN;
case VK_F1: return GLFW_KEY_F1;
case VK_F2: return GLFW_KEY_F2;
case VK_F3: return GLFW_KEY_F3;
case VK_F4: return GLFW_KEY_F4;
case VK_F5: return GLFW_KEY_F5;
case VK_F6: return GLFW_KEY_F6;
case VK_F7: return GLFW_KEY_F7;
case VK_F8: return GLFW_KEY_F8;
case VK_F9: return GLFW_KEY_F9;
case VK_F10: return GLFW_KEY_F10;
case VK_F11: return GLFW_KEY_F11;
case VK_F12: return GLFW_KEY_F12;
case VK_F13: return GLFW_KEY_F13;
case VK_F14: return GLFW_KEY_F14;
case VK_F15: return GLFW_KEY_F15;
case VK_F16: return GLFW_KEY_F16;
case VK_F17: return GLFW_KEY_F17;
case VK_F18: return GLFW_KEY_F18;
case VK_F19: return GLFW_KEY_F19;
case VK_F20: return GLFW_KEY_F20;
case VK_F21: return GLFW_KEY_F21;
case VK_F22: return GLFW_KEY_F22;
case VK_F23: return GLFW_KEY_F23;
case VK_F24: return GLFW_KEY_F24;
case VK_SPACE: return GLFW_KEY_SPACE;
// Numeric keypad
case VK_NUMPAD0: return GLFW_KEY_KP_0;
case VK_NUMPAD1: return GLFW_KEY_KP_1;
case VK_NUMPAD2: return GLFW_KEY_KP_2;
case VK_NUMPAD3: return GLFW_KEY_KP_3;
case VK_NUMPAD4: return GLFW_KEY_KP_4;
case VK_NUMPAD5: return GLFW_KEY_KP_5;
case VK_NUMPAD6: return GLFW_KEY_KP_6;
case VK_NUMPAD7: return GLFW_KEY_KP_7;
case VK_NUMPAD8: return GLFW_KEY_KP_8;
case VK_NUMPAD9: return GLFW_KEY_KP_9;
case VK_DIVIDE: return GLFW_KEY_KP_DIVIDE;
case VK_MULTIPLY: return GLFW_KEY_KP_MULTIPLY;
case VK_SUBTRACT: return GLFW_KEY_KP_SUBTRACT;
case VK_ADD: return GLFW_KEY_KP_ADD;
case VK_DECIMAL: return GLFW_KEY_KP_DECIMAL;
// The rest (should be printable keys)
default:
// Convert to printable character (ISO-8859-1 or Unicode)
wParam = MapVirtualKey( wParam, 2 ) & 0x0000FFFF;
// Make sure that the character is uppercase
if( _glfwSys.HasUnicode )
{
wParam = (DWORD) CharUpperW( (LPWSTR) wParam );
}
else
{
wParam = (DWORD) CharUpperA( (LPSTR) wParam );
}
// Valid ISO-8859-1 character?
if( (wParam >= 32 && wParam <= 126) ||
(wParam >= 160 && wParam <= 255) )
{
return (int) wParam;
}
return GLFW_KEY_UNKNOWN;
}
}
static void testFmtId(void)
{
WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
'I','n','f','o','r','m','a','t','i','o','n',0 };
WCHAR szDocSummaryInfo[] = { 5,'D','o','c','u','m','e','n','t',
'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',
0 };
WCHAR szIID_IPropSetStg[] = { 5,'0','j','a','a','a','a','a',
'a','A','a','a','a','a','a','d','a','A','a','a','a','a','a','a','a','G',
'c',0 };
WCHAR name[32];
FMTID fmtid;
HRESULT hr;
if (pFmtIdToPropStgName) {
hr = pFmtIdToPropStgName(NULL, name);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, name);
ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
ok(!memcmp(name, szSummaryInfo, (lstrlenW(szSummaryInfo) + 1) *
sizeof(WCHAR)), "Got wrong name for FMTID_SummaryInformation\n");
hr = pFmtIdToPropStgName(&FMTID_DocSummaryInformation, name);
ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
hr = pFmtIdToPropStgName(&FMTID_UserDefinedProperties, name);
ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
hr = pFmtIdToPropStgName(&IID_IPropertySetStorage, name);
ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
ok(!memcmp(name, szIID_IPropSetStg, (lstrlenW(szIID_IPropSetStg) + 1) *
sizeof(WCHAR)), "Got wrong name for IID_IPropertySetStorage\n");
}
if(pPropStgNameToFmtId) {
/* test args first */
hr = pPropStgNameToFmtId(NULL, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
hr = pPropStgNameToFmtId(NULL, &fmtid);
ok(hr == STG_E_INVALIDNAME, "Expected STG_E_INVALIDNAME, got 0x%08x\n",
hr);
hr = pPropStgNameToFmtId(szDocSummaryInfo, NULL);
ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
/* test the known format IDs */
hr = pPropStgNameToFmtId(szSummaryInfo, &fmtid);
ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
ok(!memcmp(&fmtid, &FMTID_SummaryInformation, sizeof(fmtid)),
"Got unexpected FMTID, expected FMTID_SummaryInformation\n");
hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
"Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
/* test another GUID */
hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
"Got unexpected FMTID, expected IID_IPropertySetStorage\n");
/* now check case matching */
CharUpperW(szDocSummaryInfo + 1);
hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
"Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
CharUpperW(szIID_IPropSetStg + 1);
hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
"Got unexpected FMTID, expected IID_IPropertySetStorage\n");
}
}
/*
** Create the mutex and shared memory used for locking in the file
** descriptor pFile
*/
static BOOL winceCreateLock(const char *zFilename, winFile *pFile){
WCHAR *zTok;
WCHAR *zName = utf8ToUnicode(zFilename);
BOOL bInit = TRUE;
/* Initialize the local lockdata */
ZeroMemory(&pFile->local, sizeof(pFile->local));
/* Replace the backslashes from the filename and lowercase it
** to derive a mutex name. */
zTok = CharLowerW(zName);
for (;*zTok;zTok++){
if (*zTok == '\\') *zTok = '_';
}
/* Create/open the named mutex */
pFile->hMutex = CreateMutexW(NULL, FALSE, zName);
if (!pFile->hMutex){
sqliteFree(zName);
return FALSE;
}
/* Acquire the mutex before continuing */
winceMutexAcquire(pFile->hMutex);
/* Since the names of named mutexes, semaphores, file mappings etc are
** case-sensitive, take advantage of that by uppercasing the mutex name
** and using that as the shared filemapping name.
*/
CharUpperW(zName);
pFile->hShared = CreateFileMappingW(INVALID_HANDLE_VALUE, NULL,
PAGE_READWRITE, 0, sizeof(winceLock),
zName);
/* Set a flag that indicates we're the first to create the memory so it
** must be zero-initialized */
if (GetLastError() == ERROR_ALREADY_EXISTS){
bInit = FALSE;
}
sqliteFree(zName);
/* If we succeeded in making the shared memory handle, map it. */
if (pFile->hShared){
pFile->shared = (winceLock*)MapViewOfFile(pFile->hShared,
FILE_MAP_READ|FILE_MAP_WRITE, 0, 0, sizeof(winceLock));
/* If mapping failed, close the shared memory handle and erase it */
if (!pFile->shared){
CloseHandle(pFile->hShared);
pFile->hShared = NULL;
}
}
/* If shared memory could not be created, then close the mutex and fail */
if (pFile->hShared == NULL){
winceMutexRelease(pFile->hMutex);
CloseHandle(pFile->hMutex);
pFile->hMutex = NULL;
return FALSE;
}
/* Initialize the shared memory if we're supposed to */
if (bInit) {
ZeroMemory(pFile->shared, sizeof(winceLock));
}
winceMutexRelease(pFile->hMutex);
return TRUE;
}
WChar String::ToUpperCaseW( WChar ch ) const
{
return (WChar)CharUpperW( (LPWSTR)ch );
}
inline wchar_t MyCharUpper(wchar_t c)
{ return (wchar_t)(unsigned int)(UINT_PTR)CharUpperW((LPWSTR)(UINT_PTR)(unsigned int)c); }
wchar_t * MyStringUpper(wchar_t *s) { return CharUpperW(s); }
static void test_SetTargetComputer(void)
{
WCHAR buffer[MAX_COMPUTERNAME_LENGTH + 3]; /* extra space for two '\' and a zero */
DWORD len = MAX_COMPUTERNAME_LENGTH + 1; /* extra space for a zero */
WCHAR *oldname = NULL;
WCHAR *name = NULL;
HRESULT hres;
buffer[0] = '\\';
buffer[1] = '\\';
if (!GetComputerNameW(buffer + 2, &len))
return;
/* Create TaskScheduler */
hres = CoCreateInstance(&CLSID_CTaskScheduler, NULL, CLSCTX_INPROC_SERVER,
&IID_ITaskScheduler, (void **) &test_task_scheduler);
ok(hres == S_OK, "CTaskScheduler CoCreateInstance failed: %08x\n", hres);
if (hres != S_OK)
{
skip("Failed to create task scheduler. Skipping tests.\n");
return;
}
hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &oldname);
ok(hres == S_OK, "got 0x%x and %s (expected S_OK)\n", hres, wine_dbgstr_w(oldname));
/* NULL is an alias for the local computer */
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, NULL);
ok(hres == S_OK, "got 0x%x (expected S_OK)\n", hres);
hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &name);
ok((hres == S_OK && !lstrcmpiW(name, buffer)),
"got 0x%x with %s (expected S_OK and %s)\n",
hres, wine_dbgstr_w(name), wine_dbgstr_w(buffer));
CoTaskMemFree(name);
/* The name must be valid */
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, does_not_existW);
ok(hres == HRESULT_FROM_WIN32(ERROR_BAD_NETPATH), "got 0x%x (expected 0x80070035)\n", hres);
/* the name of the target computer is unchanged */
hres = ITaskScheduler_GetTargetComputer(test_task_scheduler, &name);
ok((hres == S_OK && !lstrcmpiW(name, buffer)),
"got 0x%x with %s (expected S_OK and %s)\n",
hres, wine_dbgstr_w(name), wine_dbgstr_w(buffer));
CoTaskMemFree(name);
/* the two backslashes are optional */
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, oldname + 2);
ok(hres == S_OK, "got 0x%x (expected S_OK)\n", hres);
/* the case is ignored */
CharUpperW(buffer);
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, buffer);
ok(hres == S_OK, "got 0x%x (expected S_OK)\n", hres);
CharLowerW(buffer);
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, buffer);
ok(hres == S_OK, "got 0x%x (expected S_OK)\n", hres);
/* cleanup */
hres = ITaskScheduler_SetTargetComputer(test_task_scheduler, oldname);
ok(hres == S_OK, "got 0x%x (expected S_OK)\n", hres);
CoTaskMemFree(oldname);
ITaskScheduler_Release(test_task_scheduler);
return;
}
