[WIN32K] Fix 64 bit issues (#420)
[reactos.git] / win32ss / user / ntuser / kbdlayout.c
1 /*
2 * PROJECT: ReactOS Win32k subsystem
3 * LICENSE: GPL - See COPYING in the top level directory
4 * FILE: win32ss/user/ntuser/kbdlayout.c
5 * PURPOSE: Keyboard layout management
6 * COPYRIGHT: Copyright 2007 Saveliy Tretiakov
7 * Copyright 2008 Colin Finck
8 * Copyright 2011 Rafal Harabien
9 */
10
11 #include <win32k.h>
12
13 #include <winnls.h>
14
15 DBG_DEFAULT_CHANNEL(UserKbdLayout);
16
17 PKL gspklBaseLayout = NULL;
18 PKBDFILE gpkfList = NULL;
19 DWORD gSystemFS = 0;
20 UINT gSystemCPCharSet = 0;
21
22 typedef PVOID (*PFN_KBDLAYERDESCRIPTOR)(VOID);
23
24
25 /* PRIVATE FUNCTIONS ******************************************************/
26
27 /*
28 * UserLoadKbdDll
29 *
30 * Loads keyboard layout DLL and gets address to KbdTables
31 */
32 static BOOL
33 UserLoadKbdDll(WCHAR *pwszLayoutPath,
34 HANDLE *phModule,
35 PKBDTABLES *pKbdTables)
36 {
37 PFN_KBDLAYERDESCRIPTOR pfnKbdLayerDescriptor;
38
39 /* Load keyboard layout DLL */
40 TRACE("Loading Keyboard DLL %ws\n", pwszLayoutPath);
41 *phModule = EngLoadImage(pwszLayoutPath);
42 if (!(*phModule))
43 {
44 ERR("Failed to load dll %ws\n", pwszLayoutPath);
45 return FALSE;
46 }
47
48 /* Find KbdLayerDescriptor function and get layout tables */
49 TRACE("Loaded %ws\n", pwszLayoutPath);
50 pfnKbdLayerDescriptor = EngFindImageProcAddress(*phModule, "KbdLayerDescriptor");
51
52 /* FIXME: Windows reads file instead of executing!
53 It's not safe to kbdlayout DLL in kernel mode! */
54
55 if (pfnKbdLayerDescriptor)
56 *pKbdTables = pfnKbdLayerDescriptor();
57 else
58 ERR("Error: %ws has no KbdLayerDescriptor()\n", pwszLayoutPath);
59
60 if (!pfnKbdLayerDescriptor || !*pKbdTables)
61 {
62 ERR("Failed to load the keyboard layout.\n");
63 EngUnloadImage(*phModule);
64 return FALSE;
65 }
66
67 #if 0 /* Dump keyboard layout */
68 {
69 unsigned i;
70 PVK_TO_BIT pVkToBit = (*pKbdTables)->pCharModifiers->pVkToBit;
71 PVK_TO_WCHAR_TABLE pVkToWchTbl = (*pKbdTables)->pVkToWcharTable;
72 PVSC_VK pVscVk = (*pKbdTables)->pVSCtoVK_E0;
73 DbgPrint("Kbd layout: fLocaleFlags %x bMaxVSCtoVK %x\n", (*pKbdTables)->fLocaleFlags, (*pKbdTables)->bMaxVSCtoVK);
74 DbgPrint("wMaxModBits %x\n", (*pKbdTables)->pCharModifiers->wMaxModBits);
75 while (pVkToBit->Vk)
76 {
77 DbgPrint("VkToBit %x -> %x\n", pVkToBit->Vk, pVkToBit->ModBits);
78 ++pVkToBit;
79 }
80 for (i = 0; i <= (*pKbdTables)->pCharModifiers->wMaxModBits; ++i)
81 DbgPrint("ModNumber %x -> %x\n", i, (*pKbdTables)->pCharModifiers->ModNumber[i]);
82 while (pVkToWchTbl->pVkToWchars)
83 {
84 PVK_TO_WCHARS1 pVkToWch = pVkToWchTbl->pVkToWchars;
85 DbgPrint("pVkToWchTbl nModifications %x cbSize %x\n", pVkToWchTbl->nModifications, pVkToWchTbl->cbSize);
86 while (pVkToWch->VirtualKey)
87 {
88 DbgPrint("pVkToWch VirtualKey %x Attributes %x wc { ", pVkToWch->VirtualKey, pVkToWch->Attributes);
89 for (i = 0; i < pVkToWchTbl->nModifications; ++i)
90 DbgPrint("%x ", pVkToWch->wch[i]);
91 DbgPrint("}\n");
92 pVkToWch = (PVK_TO_WCHARS1)(((PBYTE)pVkToWch) + pVkToWchTbl->cbSize);
93 }
94 ++pVkToWchTbl;
95 }
96 DbgPrint("pusVSCtoVK: { ");
97 for (i = 0; i < (*pKbdTables)->bMaxVSCtoVK; ++i)
98 DbgPrint("%x -> %x, ", i, (*pKbdTables)->pusVSCtoVK[i]);
99 DbgPrint("}\n");
100 DbgPrint("pVSCtoVK_E0: { ");
101 while (pVscVk->Vsc)
102 {
103 DbgPrint("%x -> %x, ", pVscVk->Vsc, pVscVk->Vk);
104 ++pVscVk;
105 }
106 DbgPrint("}\n");
107 pVscVk = (*pKbdTables)->pVSCtoVK_E1;
108 DbgPrint("pVSCtoVK_E1: { ");
109 while (pVscVk->Vsc)
110 {
111 DbgPrint("%x -> %x, ", pVscVk->Vsc, pVscVk->Vk);
112 ++pVscVk;
113 }
114 DbgPrint("}\n");
115 DbgBreakPoint();
116 }
117 #endif
118
119 return TRUE;
120 }
121
122 /*
123 * UserLoadKbdFile
124 *
125 * Loads keyboard layout DLL and creates KBDFILE object
126 */
127 static PKBDFILE
128 UserLoadKbdFile(PUNICODE_STRING pwszKLID)
129 {
130 PKBDFILE pkf, pRet = NULL;
131 NTSTATUS Status;
132 ULONG cbSize;
133 HKEY hKey = NULL;
134 WCHAR wszLayoutPath[MAX_PATH] = L"\\SystemRoot\\System32\\";
135 WCHAR wszLayoutRegKey[256] = L"\\REGISTRY\\Machine\\SYSTEM\\CurrentControlSet\\"
136 L"Control\\Keyboard Layouts\\";
137
138 /* Create keyboard layout file object */
139 pkf = UserCreateObject(gHandleTable, NULL, NULL, NULL, TYPE_KBDFILE, sizeof(KBDFILE));
140 if (!pkf)
141 {
142 ERR("Failed to create object!\n");
143 return NULL;
144 }
145
146 /* Set keyboard layout name */
147 swprintf(pkf->awchKF, L"%wZ", pwszKLID);
148
149 /* Open layout registry key */
150 RtlStringCbCatW(wszLayoutRegKey, sizeof(wszLayoutRegKey), pkf->awchKF);
151 Status = RegOpenKey(wszLayoutRegKey, &hKey);
152 if (!NT_SUCCESS(Status))
153 {
154 ERR("Failed to open keyboard layouts registry key %ws (%lx)\n", wszLayoutRegKey, Status);
155 goto cleanup;
156 }
157
158 /* Read filename of layout DLL */
159 cbSize = (ULONG)(sizeof(wszLayoutPath) - wcslen(wszLayoutPath)*sizeof(WCHAR));
160 Status = RegQueryValue(hKey,
161 L"Layout File",
162 REG_SZ,
163 wszLayoutPath + wcslen(wszLayoutPath),
164 &cbSize);
165
166 if (!NT_SUCCESS(Status))
167 {
168 ERR("Can't get layout filename for %wZ (%lx)\n", pwszKLID, Status);
169 goto cleanup;
170 }
171
172 /* Load keyboard file now */
173 if (!UserLoadKbdDll(wszLayoutPath, &pkf->hBase, &pkf->pKbdTbl))
174 {
175 ERR("Failed to load %ws dll!\n", wszLayoutPath);
176 goto cleanup;
177 }
178
179 /* Update next field */
180 pkf->pkfNext = gpkfList;
181 gpkfList = pkf;
182
183 /* Return keyboard file */
184 pRet = pkf;
185
186 cleanup:
187 if (hKey)
188 ZwClose(hKey);
189 if (pkf)
190 UserDereferenceObject(pkf); // we dont need ptr anymore
191 if (!pRet)
192 {
193 /* We have failed - destroy created object */
194 if (pkf)
195 UserDeleteObject(pkf->head.h, TYPE_KBDFILE);
196 }
197
198 return pRet;
199 }
200
201 /*
202 * UserLoadKbdLayout
203 *
204 * Loads keyboard layout and creates KL object
205 */
206 static PKL
207 UserLoadKbdLayout(PUNICODE_STRING pustrKLID, HKL hKL)
208 {
209 LCID lCid;
210 CHARSETINFO cs;
211 PKL pKl;
212
213 /* Create keyboard layout object */
214 pKl = UserCreateObject(gHandleTable, NULL, NULL, NULL, TYPE_KBDLAYOUT, sizeof(KL));
215 if (!pKl)
216 {
217 ERR("Failed to create object!\n");
218 return NULL;
219 }
220
221 pKl->hkl = hKL;
222 pKl->spkf = UserLoadKbdFile(pustrKLID);
223
224 /* Dereference keyboard layout */
225 UserDereferenceObject(pKl);
226
227 /* If we failed, remove KL object */
228 if (!pKl->spkf)
229 {
230 ERR("UserLoadKbdFile(%wZ) failed!\n", pustrKLID);
231 UserDeleteObject(pKl->head.h, TYPE_KBDLAYOUT);
232 return NULL;
233 }
234
235 // Up to Language Identifiers..
236 if (!NT_SUCCESS(RtlUnicodeStringToInteger(pustrKLID, 16, (PULONG)&lCid)))
237 {
238 ERR("RtlUnicodeStringToInteger failed for '%wZ'\n", pustrKLID);
239 UserDeleteObject(pKl->head.h, TYPE_KBDLAYOUT);
240 return NULL;
241 }
242
243 TRACE("Language Identifiers %wZ LCID 0x%x\n", pustrKLID, lCid);
244 if (co_IntGetCharsetInfo(lCid, &cs))
245 {
246 pKl->iBaseCharset = cs.ciCharset;
247 pKl->dwFontSigs = cs.fs.fsCsb[0];
248 pKl->CodePage = (USHORT)cs.ciACP;
249 TRACE("Charset %u Font Sig %lu CodePage %u\n",
250 pKl->iBaseCharset, pKl->dwFontSigs, pKl->CodePage);
251 }
252 else
253 {
254 pKl->iBaseCharset = ANSI_CHARSET;
255 pKl->dwFontSigs = FS_LATIN1;
256 pKl->CodePage = CP_ACP;
257 }
258
259 // Set initial system character set and font signature.
260 if (gSystemFS == 0)
261 {
262 gSystemCPCharSet = pKl->iBaseCharset;
263 gSystemFS = pKl->dwFontSigs;
264 }
265
266 return pKl;
267 }
268
269 /*
270 * UnloadKbdFile
271 *
272 * Destroys specified Keyboard File object
273 */
274 static
275 VOID
276 UnloadKbdFile(_In_ PKBDFILE pkf)
277 {
278 PKBDFILE *ppkfLink = &gpkfList;
279 NT_ASSERT(pkf != NULL);
280
281 /* Find previous object */
282 while (*ppkfLink)
283 {
284 if (*ppkfLink == pkf)
285 break;
286
287 ppkfLink = &(*ppkfLink)->pkfNext;
288 }
289
290 if (*ppkfLink == pkf)
291 *ppkfLink = pkf->pkfNext;
292
293 EngUnloadImage(pkf->hBase);
294 UserDeleteObject(pkf->head.h, TYPE_KBDFILE);
295 }
296
297 /*
298 * UserUnloadKbl
299 *
300 * Unloads specified Keyboard Layout if possible
301 */
302 BOOL
303 UserUnloadKbl(PKL pKl)
304 {
305 /* According to msdn, UnloadKeyboardLayout can fail
306 if the keyboard layout identifier was preloaded. */
307 if (pKl == gspklBaseLayout)
308 {
309 if (pKl->pklNext == pKl->pklPrev)
310 {
311 /* There is only one layout */
312 return FALSE;
313 }
314
315 /* Set next layout as default */
316 gspklBaseLayout = pKl->pklNext;
317 }
318
319 if (pKl->head.cLockObj > 1)
320 {
321 /* Layout is used by other threads */
322 pKl->dwKL_Flags |= KLF_UNLOAD;
323 return FALSE;
324 }
325
326 /* Unload the layout */
327 pKl->pklPrev->pklNext = pKl->pklNext;
328 pKl->pklNext->pklPrev = pKl->pklPrev;
329 UnloadKbdFile(pKl->spkf);
330 UserDeleteObject(pKl->head.h, TYPE_KBDLAYOUT);
331 return TRUE;
332 }
333
334 /*
335 * W32kGetDefaultKeyLayout
336 *
337 * Returns default layout for new threads
338 */
339 PKL
340 W32kGetDefaultKeyLayout(VOID)
341 {
342 PKL pKl = gspklBaseLayout;
343
344 if (!pKl)
345 return NULL;
346
347 /* Return not unloaded layout */
348 do
349 {
350 if (!(pKl->dwKL_Flags & KLF_UNLOAD))
351 return pKl;
352
353 pKl = pKl->pklPrev; /* Confirmed on Win2k */
354 } while(pKl != gspklBaseLayout);
355
356 /* We have not found proper KL */
357 return NULL;
358 }
359
360 /*
361 * UserHklToKbl
362 *
363 * Gets KL object from hkl value
364 */
365 PKL
366 NTAPI
367 UserHklToKbl(HKL hKl)
368 {
369 PKL pKl = gspklBaseLayout;
370
371 if (!gspklBaseLayout)
372 return NULL;
373
374 do
375 {
376 if (pKl->hkl == hKl)
377 return pKl;
378
379 pKl = pKl->pklNext;
380 } while (pKl != gspklBaseLayout);
381
382 return NULL;
383 }
384
385 /*
386 * UserSetDefaultInputLang
387 *
388 * Sets default kyboard layout for system. Called from UserSystemParametersInfo.
389 */
390 BOOL
391 NTAPI
392 UserSetDefaultInputLang(HKL hKl)
393 {
394 PKL pKl;
395
396 pKl = UserHklToKbl(hKl);
397 if (!pKl)
398 return FALSE;
399
400 gspklBaseLayout = pKl;
401 return TRUE;
402 }
403
404 /*
405 * co_UserActivateKbl
406 *
407 * Activates given layout in specified thread
408 */
409 static PKL
410 co_UserActivateKbl(PTHREADINFO pti, PKL pKl, UINT Flags)
411 {
412 PKL pklPrev;
413 PWND pWnd;
414
415 pklPrev = pti->KeyboardLayout;
416 if (pklPrev)
417 UserDereferenceObject(pklPrev);
418
419 pti->KeyboardLayout = pKl;
420 pti->pClientInfo->hKL = pKl->hkl;
421 UserReferenceObject(pKl);
422
423 if (Flags & KLF_SETFORPROCESS)
424 {
425 // FIXME
426 }
427
428 if (!(pWnd = pti->MessageQueue->spwndFocus))
429 {
430 pWnd = pti->MessageQueue->spwndActive;
431 }
432
433 // Send WM_INPUTLANGCHANGE to thread's focus window
434 co_IntSendMessage( pWnd ? UserHMGetHandle(pWnd) : 0,
435 WM_INPUTLANGCHANGE,
436 (WPARAM)pKl->iBaseCharset, // FIXME: How to set it?
437 (LPARAM)pKl->hkl); // hkl
438
439 return pklPrev;
440 }
441
442 /* EXPORTS *******************************************************************/
443
444 /*
445 * UserGetKeyboardLayout
446 *
447 * Returns hkl of given thread keyboard layout
448 */
449 HKL FASTCALL
450 UserGetKeyboardLayout(
451 DWORD dwThreadId)
452 {
453 PTHREADINFO pti;
454 PLIST_ENTRY ListEntry;
455 PKL pKl;
456
457 pti = PsGetCurrentThreadWin32Thread();
458
459 if (!dwThreadId)
460 {
461 pKl = pti->KeyboardLayout;
462 return pKl ? pKl->hkl : NULL;
463 }
464
465 ListEntry = pti->rpdesk->PtiList.Flink;
466
467 //
468 // Search the Desktop Thread list for related Desktop active Threads.
469 //
470 while(ListEntry != &pti->rpdesk->PtiList)
471 {
472 pti = CONTAINING_RECORD(ListEntry, THREADINFO, PtiLink);
473
474 if (PsGetThreadId(pti->pEThread) == UlongToHandle(dwThreadId))
475 {
476 pKl = pti->KeyboardLayout;
477 return pKl ? pKl->hkl : NULL;
478 }
479
480 ListEntry = ListEntry->Flink;
481 }
482
483 return NULL;
484 }
485
486 /*
487 * NtUserGetKeyboardLayoutList
488 *
489 * Returns list of loaded keyboard layouts in system
490 */
491 UINT
492 APIENTRY
493 NtUserGetKeyboardLayoutList(
494 ULONG nBuff,
495 HKL *pHklBuff)
496 {
497 UINT uRet = 0;
498 PKL pKl;
499
500 if (!pHklBuff)
501 nBuff = 0;
502
503 UserEnterShared();
504
505 if (!gspklBaseLayout)
506 {
507 UserLeave();
508 return 0;
509 }
510 pKl = gspklBaseLayout;
511
512 if (nBuff == 0)
513 {
514 do
515 {
516 uRet++;
517 pKl = pKl->pklNext;
518 } while (pKl != gspklBaseLayout);
519 }
520 else
521 {
522 _SEH2_TRY
523 {
524 ProbeForWrite(pHklBuff, nBuff*sizeof(HKL), 4);
525
526 while (uRet < nBuff)
527 {
528 pHklBuff[uRet] = pKl->hkl;
529 uRet++;
530 pKl = pKl->pklNext;
531 if (pKl == gspklBaseLayout)
532 break;
533 }
534 }
535 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
536 {
537 SetLastNtError(_SEH2_GetExceptionCode());
538 uRet = 0;
539 }
540 _SEH2_END;
541 }
542
543 UserLeave();
544 return uRet;
545 }
546
547 /*
548 * NtUserGetKeyboardLayoutName
549 *
550 * Returns KLID of current thread keyboard layout
551 */
552 BOOL
553 APIENTRY
554 NtUserGetKeyboardLayoutName(
555 LPWSTR pwszName)
556 {
557 BOOL bRet = FALSE;
558 PKL pKl;
559 PTHREADINFO pti;
560
561 UserEnterShared();
562
563 pti = PsGetCurrentThreadWin32Thread();
564 pKl = pti->KeyboardLayout;
565
566 if (!pKl)
567 goto cleanup;
568
569 _SEH2_TRY
570 {
571 ProbeForWrite(pwszName, KL_NAMELENGTH*sizeof(WCHAR), 1);
572 wcscpy(pwszName, pKl->spkf->awchKF);
573 bRet = TRUE;
574 }
575 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
576 {
577 SetLastNtError(_SEH2_GetExceptionCode());
578 }
579 _SEH2_END;
580
581 cleanup:
582 UserLeave();
583 return bRet;
584 }
585
586 /*
587 * NtUserLoadKeyboardLayoutEx
588 *
589 * Loads keyboard layout with given locale id
590 */
591 HKL
592 APIENTRY
593 NtUserLoadKeyboardLayoutEx(
594 IN HANDLE Handle, // hFile (See downloads.securityfocus.com/vulnerabilities/exploits/43774.c)
595 IN DWORD offTable, // Offset to KbdTables
596 IN PUNICODE_STRING puszKeyboardName, // Not used?
597 IN HKL hklUnload,
598 IN PUNICODE_STRING pustrKLID,
599 IN DWORD hkl,
600 IN UINT Flags)
601 {
602 HKL hklRet = NULL;
603 PKL pKl = NULL, pklLast;
604 WCHAR Buffer[9];
605 UNICODE_STRING ustrSafeKLID;
606
607 if (Flags & ~(KLF_ACTIVATE|KLF_NOTELLSHELL|KLF_REORDER|KLF_REPLACELANG|
608 KLF_SUBSTITUTE_OK|KLF_SETFORPROCESS|KLF_UNLOADPREVIOUS|
609 KLF_RESET|KLF_SHIFTLOCK))
610 {
611 ERR("Invalid flags: %x\n", Flags);
612 EngSetLastError(ERROR_INVALID_FLAGS);
613 return NULL;
614 }
615
616 /* FIXME: It seems KLF_RESET is only supported for WINLOGON */
617
618 RtlInitEmptyUnicodeString(&ustrSafeKLID, Buffer, sizeof(Buffer));
619 _SEH2_TRY
620 {
621 ProbeForRead(pustrKLID, sizeof(*pustrKLID), 1);
622 ProbeForRead(pustrKLID->Buffer, sizeof(pustrKLID->Length), 1);
623 RtlCopyUnicodeString(&ustrSafeKLID, pustrKLID);
624 }
625 _SEH2_EXCEPT(EXCEPTION_EXECUTE_HANDLER)
626 {
627 SetLastNtError(_SEH2_GetExceptionCode());
628 _SEH2_YIELD(return NULL);
629 }
630 _SEH2_END;
631
632 UserEnterExclusive();
633
634 /* If hklUnload is specified, unload it and load new layput as default */
635 if (hklUnload && (hklUnload != UlongToHandle(hkl)))
636 {
637 pKl = UserHklToKbl(hklUnload);
638 if (pKl)
639 UserUnloadKbl(pKl);
640 }
641
642 /* Let's see if layout was already loaded. */
643 pKl = UserHklToKbl(UlongToHandle(hkl));
644 if (!pKl)
645 {
646 /* It wasn't, so load it. */
647 pKl = UserLoadKbdLayout(&ustrSafeKLID, UlongToHandle(hkl));
648 if (!pKl)
649 goto cleanup;
650
651 if (gspklBaseLayout)
652 {
653 /* Find last not unloaded layout */
654 pklLast = gspklBaseLayout->pklPrev;
655 while (pklLast != gspklBaseLayout && pklLast->dwKL_Flags & KLF_UNLOAD)
656 pklLast = pklLast->pklPrev;
657
658 /* Add new layout to the list */
659 pKl->pklNext = pklLast->pklNext;
660 pKl->pklPrev = pklLast;
661 pKl->pklNext->pklPrev = pKl;
662 pKl->pklPrev->pklNext = pKl;
663 }
664 else
665 {
666 /* This is the first layout */
667 pKl->pklNext = pKl;
668 pKl->pklPrev = pKl;
669 gspklBaseLayout = pKl;
670 }
671 }
672
673 /* If this layout was prepared to unload, undo it */
674 pKl->dwKL_Flags &= ~KLF_UNLOAD;
675
676 /* Activate this layout in current thread */
677 if (Flags & KLF_ACTIVATE)
678 co_UserActivateKbl(PsGetCurrentThreadWin32Thread(), pKl, Flags);
679
680 /* Send shell message */
681 if (!(Flags & KLF_NOTELLSHELL))
682 co_IntShellHookNotify(HSHELL_LANGUAGE, 0, (LPARAM)hkl);
683
684 /* Return hkl on success */
685 hklRet = UlongToHandle(hkl);
686
687 /* FIXME: KLF_REPLACELANG
688 KLF_REORDER */
689
690 cleanup:
691 UserLeave();
692 return hklRet;
693 }
694
695 /*
696 * NtUserActivateKeyboardLayout
697 *
698 * Activates specified layout for thread or process
699 */
700 HKL
701 APIENTRY
702 NtUserActivateKeyboardLayout(
703 HKL hKl,
704 ULONG Flags)
705 {
706 PKL pKl = NULL;
707 HKL hkl = NULL;
708 PTHREADINFO pti;
709
710 UserEnterExclusive();
711
712 pti = PsGetCurrentThreadWin32Thread();
713
714 /* hKl can have special value HKL_NEXT or HKL_PREV */
715 if (hKl == (HKL)HKL_NEXT)
716 {
717 /* Get next keyboard layout starting with current */
718 if (pti->KeyboardLayout)
719 pKl = pti->KeyboardLayout->pklNext;
720 }
721 else if (hKl == (HKL)HKL_PREV)
722 {
723 /* Get previous keyboard layout starting with current */
724 if (pti->KeyboardLayout)
725 pKl = pti->KeyboardLayout->pklPrev;
726 }
727 else
728 pKl = UserHklToKbl(hKl);
729
730 if (!pKl)
731 {
732 ERR("Invalid HKL %p!\n", hKl);
733 goto cleanup;
734 }
735
736 hkl = pKl->hkl;
737
738 /* FIXME: KLF_RESET
739 KLF_SHIFTLOCK */
740
741 if (Flags & KLF_REORDER)
742 gspklBaseLayout = pKl;
743
744 if (pKl != pti->KeyboardLayout)
745 {
746 /* Activate layout for current thread */
747 pKl = co_UserActivateKbl(pti, pKl, Flags);
748
749 /* Send shell message */
750 if (!(Flags & KLF_NOTELLSHELL))
751 co_IntShellHookNotify(HSHELL_LANGUAGE, 0, (LPARAM)hkl);
752 }
753
754 cleanup:
755 UserLeave();
756 return hkl;
757 }
758
759 /*
760 * NtUserUnloadKeyboardLayout
761 *
762 * Unloads keyboard layout with specified hkl value
763 */
764 BOOL
765 APIENTRY
766 NtUserUnloadKeyboardLayout(
767 HKL hKl)
768 {
769 PKL pKl;
770 BOOL bRet = FALSE;
771
772 UserEnterExclusive();
773
774 pKl = UserHklToKbl(hKl);
775 if (pKl)
776 bRet = UserUnloadKbl(pKl);
777 else
778 ERR("Invalid HKL %p!\n", hKl);
779
780 UserLeave();
781 return bRet;
782 }
783
784 /* EOF */