BOOL _RegisterHotKey(
PWND pwnd,
int id,
UINT fsModifiers,
UINT vk)
{
PHOTKEY phk;
BOOL fKeysExist;
PTHREADINFO ptiCurrent;
PWINDOWSTATION pwinsta = _GetProcessWindowStation(NULL);
ptiCurrent = PtiCurrent();
/*
* Blow it off if the caller is not the windowstation init thread
* and doesn't have the proper access rights
*/
if (grpwinstaList && !CheckWinstaWriteAttributesAccess()) {
return FALSE;
}
/*
* Can't register hotkey for a window of another queue.
* Return FALSE in this case.
*/
if ((pwnd != PWND_FOCUS) && (pwnd != PWND_INPUTOWNER)) {
if (GETPTI(pwnd) != ptiCurrent) {
RIPERR0(ERROR_WINDOW_OF_OTHER_THREAD, RIP_VERBOSE, "");
return FALSE;
}
}
phk = FindHotKey(ptiCurrent, pwnd, id, fsModifiers, vk, FALSE, &fKeysExist);
/*
* If the keys have already been registered, return FALSE.
*/
if (fKeysExist) {
RIPERR0(ERROR_HOTKEY_ALREADY_REGISTERED, RIP_VERBOSE, "");
return FALSE;
}
if (phk == NULL) {
/*
* This hotkey doesn't exist yet.
*/
phk = (PHOTKEY)UserAllocPool(sizeof(HOTKEY), TAG_HOTKEY);
/*
* If the allocation failed, bail out.
*/
if (phk == NULL) {
return FALSE;
}
phk->pti = ptiCurrent;
if ((pwnd != PWND_FOCUS) && (pwnd != PWND_INPUTOWNER)) {
phk->spwnd = NULL;
Lock(&phk->spwnd, pwnd);
} else {
phk->spwnd = pwnd;
}
phk->fsModifiers = fsModifiers;
phk->vk = vk;
phk->id = id;
/*
* Link the new hotkey to the front of the list.
*/
phk->phkNext = gphkFirst;
gphkFirst = phk;
} else {
/*
* Hotkey already exists, reset the keys.
*/
phk->fsModifiers = fsModifiers;
phk->vk = vk;
}
return TRUE;
}
HPALETTE CreatePaletteFromBitmap(
HBITMAP hbm)
{
HPALETTE hpal;
LPLOGPALETTE ppal;
HBITMAP hbmT;
DWORD size;
int i;
/*
* Make room for temp logical palette of max size.
*/
size = sizeof(LOGPALETTE) + (MAXPAL * sizeof(PALETTEENTRY));
ppal = (LPLOGPALETTE)UserAllocPool(size, TAG_SYSTEM);
if (!ppal)
return NULL;
/*
* Retrieve the palette from the DIB(Section). The method of calling
* GreGetDIBColorTable() can only be done on sections or REAL-Dibs.
*/
hbmT = GreSelectBitmap(ghdcMem, hbm);
ppal->palVersion = 0x300;
ppal->palNumEntries = (WORD)GreGetDIBColorTable(ghdcMem,
0,
MAXPAL,
(LPRGBQUAD)ppal->palPalEntry);
GreSelectBitmap(ghdcMem, hbmT);
/*
* Create a halftone-palette if their are no entries. Otherwise,
* swap the RGB values to be palentry-compatible and create us a
* palette.
*/
if (ppal->palNumEntries == 0) {
hpal = GreCreateHalftonePalette(gpDispInfo->hdcScreen);
} else {
BYTE tmpR;
/*
* Swap red/blue because a RGBQUAD and PALETTEENTRY dont get along.
*/
for (i=0; i < (int)ppal->palNumEntries; i++) {
tmpR = ppal->palPalEntry[i].peRed;
ppal->palPalEntry[i].peRed = ppal->palPalEntry[i].peBlue;
ppal->palPalEntry[i].peBlue = tmpR;
ppal->palPalEntry[i].peFlags = 0;
}
/*
* If the Bitmap only has VGA colors in it we dont want to
* use a palette. It just causes unessesary palette flashes.
*/
hpal = TestVGAColors(ppal) ? NULL : GreCreatePalette(ppal);
}
UserFreePool(ppal);
/*
* Make this palette public.
*/
if (hpal)
GreSetPaletteOwner(hpal, OBJECT_OWNER_PUBLIC);
return hpal;
}
//
// Insert/remove the specified IME hotkey into/from
// the IME hotkey list (gpImeHotKeyListHeader).
//
BOOL
SetImeHotKey(
DWORD dwHotKeyID,
UINT uModifiers,
UINT uVKey,
HKL hKL,
DWORD dwAction )
{
PIMEHOTKEYOBJ ph;
switch ( dwAction ) {
case ISHK_REMOVE:
ph = FindImeHotKeyByID( gpImeHotKeyListHeader, dwHotKeyID );
if ( ph != NULL ) {
if ( DeleteImeHotKey( &gpImeHotKeyListHeader, ph ) == ph ) {
UserFreePool( ph );
return ( TRUE );
} else {
RIPMSG0( RIP_ERROR, "IME hotkey list is messed up" );
return ( FALSE );
}
} else {
RIPERR0( ERROR_INVALID_PARAMETER,
RIP_WARNING,
"no such IME hotkey registered");
return ( FALSE );
}
break;
case ISHK_INITIALIZE:
ph = gpImeHotKeyListHeader;
while ( ph != NULL ) {
PIMEHOTKEYOBJ phNext;
phNext = ph->pNext;
UserFreePool( ph );
ph = phNext;
}
gpImeHotKeyListHeader = NULL;
return TRUE;
case ISHK_ADD:
ph = FindImeHotKeyByKey( gpImeHotKeyListHeader,
uModifiers & MOD_MODIFY_KEYS,
uModifiers & MOD_BOTH_SIDES,
uVKey );
if ( ph != NULL ) {
if ( ph->hk.dwHotKeyID != dwHotKeyID ) {
RIPERR0( ERROR_HOTKEY_ALREADY_REGISTERED,
RIP_WARNING,
"There is an IME hotkey that has the same vkey/modifiers");
return ( FALSE );
}
// So far we found a hotkey that has the
// same vkey and same ID.
// But because modifiers may be slightly
// different, so go ahead and change it.
} else {
//
// the specified vkey/modifiers combination cound not be found
// in the hotkey list. The caller may want to change the key
// assignment of an existing hotkey or add a new hotkey.
//
ph = FindImeHotKeyByID( gpImeHotKeyListHeader, dwHotKeyID );
}
if ( ph == NULL ) {
//
// adding a new hotkey
//
ph = (PIMEHOTKEYOBJ)UserAllocPool( sizeof(IMEHOTKEY), TAG_IMEHOTKEY );
if ( ph == NULL ) {
RIPERR0( ERROR_OUTOFMEMORY,
RIP_WARNING,
"Memory allocation failed in SetImeHotKey");
return ( FALSE );
}
ph->hk.dwHotKeyID = dwHotKeyID;
ph->hk.uModifiers = uModifiers;
ph->hk.uVKey = uVKey;
ph->hk.hKL = hKL;
ph->pNext = NULL;
AddImeHotKey( &gpImeHotKeyListHeader, ph );
} else {
//
// changing an existing hotkey
//
ph->hk.uModifiers = uModifiers;
ph->hk.uVKey = uVKey;
ph->hk.hKL = hKL;
}
return ( TRUE );
break;
};
}
LPWSTR GetDeskWallpaperName(PUNICODE_STRING pProfileUserName,
LPWSTR lpszFile
)
{
WCHAR wszKey[GDWPN_KEYSIZE];
WCHAR wszNone[GDWPN_KEYSIZE];
LPWSTR lpszBitmap = NULL;
/*
* Load the none-string. This will be used for comparisons later.
*/
ServerLoadString(hModuleWin, STR_NONE, wszNone, ARRAY_SIZE(wszNone));
if ((lpszFile == NULL) ||
(lpszFile == SETWALLPAPER_DEFAULT) ||
(lpszFile == SETWALLPAPER_METRICS)) {
/*
* Allocate a buffer for the wallpaper. We will assume
* a default-size in this case.
*/
lpszBitmap = UserAllocPool(GDWPN_BITSIZE * sizeof(WCHAR), TAG_SYSTEM);
if (lpszBitmap == NULL)
return NULL;
/*
* Get the "Wallpaper" string from WIN.INI's [Desktop] section. The
* section name is not localized, so hard code it. If the string
* returned is Empty, then set it up for a none-wallpaper.
*/
if (!FastGetProfileStringFromIDW(pProfileUserName,
PMAP_DESKTOP,
STR_DTBITMAP,
wszNone,
lpszBitmap,
GDWPN_BITSIZE
)) {
wcscpy(lpszBitmap, wszNone);
}
} else {
UINT uLen;
uLen = wcslen(lpszFile) + 1;
uLen = max(uLen, GDWPN_BITSIZE);
/*
* Allocate enough space to store the name passed in. Returning
* NULL will allow the wallpaper to redraw. As well, if we're
* out of memory, then no need to load a wallpaper anyway.
*/
lpszBitmap = UserAllocPool(uLen * sizeof(WCHAR), TAG_SYSTEM);
if (lpszBitmap == NULL)
return NULL;
wcscpy(lpszBitmap, lpszFile);
}
/*
* No bitmap if NULL passed in or if (NONE) in win.ini entry. We
* return NULL to force the redraw of the wallpaper in the kernel.
*/
if ((*lpszBitmap == (WCHAR)0) || (_wcsicmp(lpszBitmap, wszNone) == 0)) {
UserFreePool(lpszBitmap);
return NULL;
}
/*
* If bitmap name set to (DEFAULT) then set it to the system bitmap.
*/
ServerLoadString(hModuleWin, STR_DEFAULT, wszKey, ARRAY_SIZE(wszKey));
if (_wcsicmp(lpszBitmap, wszKey) == 0) {
GetDefaultWallpaperName(lpszBitmap);
}
return lpszBitmap;
}
UINT DWP_SetHotKey(
PWND pwnd,
DWORD dwKey)
{
PHOTKEYSTRUCT phk;
BOOL fKeyExists = FALSE;
PWND pwndTemp;
/*
* Filter out invalid hotkeys
*/
if (LOBYTE(dwKey) == VK_ESCAPE ||
LOBYTE(dwKey) == VK_SPACE ||
LOBYTE(dwKey) == VK_TAB ||
LOBYTE(dwKey) == VK_PACKET) {
return (UINT)-1;
}
/*
* Don't allow hotkeys for children
*/
if (TestWF(pwnd, WFCHILD))
return 0;
/*
* Check if the hot key exists and is assigned to a different pwnd
*/
if (dwKey != 0) {
pwndTemp = HotKeyToWindow(dwKey);
if ((pwndTemp != NULL) && (pwndTemp != pwnd))
fKeyExists = TRUE;
}
/*
* Get the hotkey assigned to the window, if any
*/
if ((phk = HotKeyHelper(pwnd)) == NULL) {
/*
* Window doesn't exist in the hotkey list and key is being set
* to zero, so just return.
*/
if (dwKey == 0)
return 1;
/*
* Allocate and point to a spot for the new hotkey
*/
if (gcHotKey >= gcHotKeyAlloc) {
if (gcHotKeyAlloc) {
phk = (PHOTKEYSTRUCT)UserReAllocPool(
(HANDLE)gpHotKeyList,
gcHotKeyAlloc * sizeof(HOTKEYSTRUCT),
(gcHotKey + 1) * sizeof(HOTKEYSTRUCT), TAG_HOTKEY);
if (phk != NULL) {
gpHotKeyList = phk;
phk = &gpHotKeyList[gcHotKey++];
gcHotKeyAlloc = gcHotKey;
} else {
return 0;
}
} else {
UserAssert(gpHotKeyList == NULL);
UserAssert(gcHotKey == 0);
phk = (PHOTKEYSTRUCT)UserAllocPool(sizeof(HOTKEYSTRUCT),
TAG_HOTKEY);
if (phk != NULL) {
gpHotKeyList = phk;
gcHotKey = 1;
gcHotKeyAlloc = 1;
} else {
return 0;
}
}
} else {
phk = &gpHotKeyList[gcHotKey++];
}
}
if (dwKey == 0) {
/*
* The hotkey for this window is being deleted. Copy the last item
* on the list on top of the one being deleted.
*/
if (--gcHotKey) {
Lock(&phk->spwnd, gpHotKeyList[gcHotKey].spwnd);
Unlock(&gpHotKeyList[gcHotKey].spwnd);
phk->key = gpHotKeyList[gcHotKey].key;
phk = (PHOTKEYSTRUCT)UserReAllocPool((HANDLE)gpHotKeyList,
gcHotKeyAlloc * sizeof(HOTKEYSTRUCT),
gcHotKey * sizeof(HOTKEYSTRUCT), TAG_HOTKEY);
if (phk != NULL) {
gpHotKeyList = phk;
gcHotKeyAlloc = gcHotKey;
}
} else {
Unlock(&gpHotKeyList[gcHotKey].spwnd);
UserFreePool((HANDLE)gpHotKeyList);
gpHotKeyList = NULL;
gcHotKeyAlloc = 0;
}
} else {
/*
* Add the window and key to the list
*/
phk->spwnd = NULL;
Lock(&phk->spwnd, pwnd);
phk->key = dwKey;
}
return fKeyExists ? 2 : 1;
}
