mirror of
https://github.com/reactos/reactos.git
synced 2024-11-19 13:33:42 +00:00
1322 lines
41 KiB
C
1322 lines
41 KiB
C
/*
|
|
* PROJECT: ReactOS Build Tools [Keyboard Layout Compiler]
|
|
* LICENSE: BSD - See COPYING.BSD in the top level directory
|
|
* FILE: tools/kbdtool/output.c
|
|
* PURPOSE: Output Logic (Source Builder)
|
|
* PROGRAMMERS: ReactOS Foundation
|
|
*/
|
|
|
|
/* INCLUDES *******************************************************************/
|
|
|
|
#include "kbdtool.h"
|
|
|
|
/* GLOBALS ********************************************************************/
|
|
|
|
ULONG gStringIdForDescriptions = 1000;
|
|
ULONG gStringIdForLanguageNames = 1100;
|
|
ULONG gStringIdForLocaleName = 1200;
|
|
time_t Clock;
|
|
struct tm *Now;
|
|
CHAR gCharName[32];
|
|
|
|
/* FUNCTIONS ******************************************************************/
|
|
|
|
PCHAR
|
|
WChName(IN ULONG Char,
|
|
IN BOOLEAN AddZero)
|
|
{
|
|
PCHAR p;
|
|
|
|
/* Check for invalid character */
|
|
if (Char == -1)
|
|
{
|
|
/* No name */
|
|
strcpy(gCharName, "WCH_NONE");
|
|
}
|
|
else if ((Char > 31) && (Char < 128))
|
|
{
|
|
/* Use our global buffer */
|
|
p = gCharName;
|
|
|
|
/* Add the first quote unless this was a zero-string */
|
|
if (!AddZero) *p++ = '\'';
|
|
|
|
/* Now replace any other quote or comment character with a slash */
|
|
if ((Char == '\"') || (Char == '\'') || (Char == '\\')) *p++ = '\\';
|
|
|
|
/* Now plug in the character */
|
|
*p++ = Char;
|
|
|
|
/* And add the terminating quote, unless this was a zero-string */
|
|
if (!AddZero) *p++ = '\'';
|
|
|
|
/* Terminate the buffer */
|
|
*p = '\0';
|
|
}
|
|
else
|
|
{
|
|
/* Handle special cases */
|
|
if (Char == '\b')
|
|
{
|
|
/* Bell */
|
|
strcpy(gCharName, "'\\b'");
|
|
}
|
|
else if (Char == '\n')
|
|
{
|
|
/* New line */
|
|
strcpy(gCharName, "'\\n'");
|
|
}
|
|
else if (Char == '\r')
|
|
{
|
|
/* Return */
|
|
strcpy(gCharName, "'\\r'");
|
|
}
|
|
else if (!AddZero)
|
|
{
|
|
/* Char value, in hex */
|
|
sprintf(gCharName, "0x%04x", Char);
|
|
}
|
|
else
|
|
{
|
|
/* Char value, C-style */
|
|
sprintf(gCharName, "\\x%04x", Char);
|
|
}
|
|
}
|
|
|
|
/* Return the name */
|
|
return gCharName;
|
|
}
|
|
|
|
VOID
|
|
PrintNameTable(FILE* FileHandle,
|
|
PKEYNAME KeyName,
|
|
BOOL DeadKey)
|
|
{
|
|
CHAR CharBuffer[255];
|
|
PKEYNAME NextName;
|
|
PCHAR Name, Buffer;
|
|
ULONG i;
|
|
|
|
/* Loop all key names */
|
|
while (KeyName)
|
|
{
|
|
/* Go to the next key name */
|
|
NextName = KeyName->Next;
|
|
|
|
/* Remember the name and our buffer address */
|
|
Name = KeyName->Name;
|
|
Buffer = CharBuffer;
|
|
|
|
/* Check if it's an IDS name */
|
|
if (strncmp(Name, "IDS_", 4))
|
|
{
|
|
/* No, so start parsing it. First, handle initial quote */
|
|
if (*Name != '\"') *Buffer++ = '\"';
|
|
|
|
/* Next, parse the name */
|
|
while (*Name)
|
|
{
|
|
/* Check if this is a C-style hex string */
|
|
if ((*Name != '\\') || ((*(Name + 1) != 'x') && (*(Name + 1) != 'X')))
|
|
{
|
|
/* It's not, so just copy straight into our buffer */
|
|
*Buffer++ = *Name++;
|
|
}
|
|
else
|
|
{
|
|
/* Continue scanning as long as this is a C-style hex string */
|
|
while ((*Name == '\\') && ((*(Name + 1) == 'x') || (*(Name + 1) == 'X')))
|
|
{
|
|
/* Copy 6 characters */
|
|
for (i = 0; (*Name) && (i < 6); i++) *Buffer++ = *Name++;
|
|
}
|
|
|
|
/* Check if we still have something at the end */
|
|
if (*Name)
|
|
{
|
|
/* Terminate our buffer */
|
|
*Buffer++ = '\"';
|
|
*Buffer++ = ' ';
|
|
*Buffer++ = 'L';
|
|
*Buffer++ = '\"';
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Check for terminating quote */
|
|
if (*(Buffer - 1) != '\"') *Buffer++ = '\"';
|
|
|
|
/* Terminate the buffer */
|
|
*Buffer++ = '\0';
|
|
}
|
|
else
|
|
{
|
|
/* Not yet supported */
|
|
printf("IDS Entries not yet handled!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Is this a dead key? */
|
|
if (DeadKey)
|
|
{
|
|
/* Not yet handled */
|
|
printf("Dead keys not yet handled\n");
|
|
exit(1);
|
|
}
|
|
else
|
|
{
|
|
/* Print the entry */
|
|
fprintf(FileHandle, " 0x%02x, L%s,\n", KeyName->Code, CharBuffer);
|
|
}
|
|
|
|
/* Cleanup allocation */
|
|
free(KeyName->Name);
|
|
free(KeyName);
|
|
|
|
/* Move on */
|
|
KeyName = NextName;
|
|
}
|
|
|
|
/* Is this a dead key? */
|
|
if (DeadKey)
|
|
{
|
|
/* Not yet handled */
|
|
printf("Dead keys not yet handled\n");
|
|
exit(1);
|
|
}
|
|
else
|
|
{
|
|
/* Terminate the table */
|
|
fprintf(FileHandle, " 0 , NULL\n");
|
|
}
|
|
}
|
|
|
|
BOOLEAN
|
|
kbd_h(IN PLAYOUT Layout)
|
|
{
|
|
CHAR OutputFile[13];
|
|
FILE *FileHandle;
|
|
ULONG i;
|
|
CHAR UndefChar;
|
|
USHORT SubCode;
|
|
|
|
/* Build the keyboard name */
|
|
strcpy(OutputFile, gKBDName);
|
|
strcat(OutputFile, ".H");
|
|
|
|
/* Open it */
|
|
FileHandle = fopen(OutputFile, "wt");
|
|
if (!FileHandle)
|
|
{
|
|
/* Fail */
|
|
printf(" %12s : can't open for write.\n", OutputFile);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Print the module header */
|
|
fprintf(FileHandle,
|
|
"/****************************** Module Header ******************************\\\n"
|
|
"* Module Name: %s\n*\n* keyboard layout header\n"
|
|
"*\n"
|
|
"* Copyright (c) 2009, ReactOS Foundation\n"
|
|
"*\n"
|
|
"* Various defines for use by keyboard input code.\n*\n* History:\n"
|
|
"*\n"
|
|
"* created by KBDTOOL v%d.%02d %s*\n"
|
|
"\\***************************************************************************/\n\n",
|
|
OutputFile,
|
|
gVersion,
|
|
gSubVersion,
|
|
asctime(Now));
|
|
|
|
/* Print out the includes and defines */
|
|
fprintf(FileHandle,
|
|
"/*\n"
|
|
" * kbd type should be controlled by cl command-line argument\n"
|
|
" *\\n"
|
|
"#define KBD_TYPE 4\n\n"
|
|
"/*\n"
|
|
"* Include the basis of all keyboard table values\n"
|
|
"*/\n"
|
|
"#include \"kbd.h\"\n");
|
|
|
|
/* Now print out the virtual key conversion table */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* The table below defines the virtual keys for various keyboard types where\n"
|
|
"* the keyboard differ from the US keyboard.\n"
|
|
"*\n"
|
|
"* _EQ() : all keyboard types have the same virtual key for this scancode\n"
|
|
"* _NE() : different virtual keys for this scancode, depending on kbd type\n"
|
|
"*\n"
|
|
"* +------+ +----------+----------+----------+----------+----------+----------+\n"
|
|
"* | Scan | | kbd | kbd | kbd | kbd | kbd | kbd |\n"
|
|
"* | code | | type 1 | type 2 | type 3 | type 4 | type 5 | type 6 |\n"
|
|
"\\****+-------+_+----------+----------+----------+----------+----------+----------+*/\n\n");
|
|
|
|
/* Loop all keys */
|
|
for (i = 0; i < 110; i++)
|
|
{
|
|
/* Check if we processed this key */
|
|
if (Layout->Entry[i].Processed)
|
|
{
|
|
/* Check if it redefined a virtual key */
|
|
if (Layout->Entry[i].VirtualKey != Layout->Entry[i].OriginalVirtualKey)
|
|
{
|
|
/* Do we have a subcode? */
|
|
SubCode = Layout->Entry[i].ScanCode & 0xFF00;
|
|
if (SubCode)
|
|
{
|
|
/* Which kind is it? */
|
|
if (SubCode == 0xE000)
|
|
{
|
|
/* Extended 0 */
|
|
UndefChar = 'X';
|
|
}
|
|
else
|
|
{
|
|
/* Illegal */
|
|
if (SubCode != 0xE100)
|
|
{
|
|
/* Unrecognized */
|
|
printf("Weird scancode value %04x: expected xx, E0xx, or E1xx\n", SubCode);
|
|
exit(1);
|
|
}
|
|
|
|
/* Extended 1 */
|
|
UndefChar = 'Y';
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Normal key */
|
|
UndefChar = 'T';
|
|
}
|
|
|
|
/* Print out the virtual key redefinition */
|
|
fprintf(FileHandle,
|
|
"#undef %c%02X\n#define %c%02X _EQ(%43s%23s\n",
|
|
UndefChar,
|
|
Layout->Entry[i].ScanCode,
|
|
UndefChar,
|
|
Layout->Entry[i].ScanCode,
|
|
getVKName(Layout->Entry[i].VirtualKey, 0),
|
|
")");
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Cleanup and close */
|
|
fprintf(FileHandle,"\n");
|
|
fclose(FileHandle);
|
|
|
|
/* We made it */
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
kbd_rc(IN PKEYNAME DescriptionData,
|
|
IN PKEYNAME LanguageData)
|
|
{
|
|
CHAR OutputFile[13];
|
|
CHAR InternalName[13];
|
|
CHAR TimeBuffer[5];
|
|
FILE *FileHandle;
|
|
ULONG Length;
|
|
PCHAR p;
|
|
PKEYNAME NextDescription, NextLanguage;
|
|
|
|
/* Build the keyboard name and internal name */
|
|
strcpy(OutputFile, gKBDName);
|
|
strcat(OutputFile, ".RC");
|
|
strcpy(InternalName, gKBDName);
|
|
for (p = InternalName; *p; p++) *p = tolower(*p);
|
|
|
|
/* Open it */
|
|
FileHandle = fopen(OutputFile, "wb");
|
|
if (!FileHandle)
|
|
{
|
|
/* Fail */
|
|
printf(" %12s : can't open for write.\n", OutputFile);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Check if we have copyright */
|
|
Length = strlen(gCopyright);
|
|
if (!Length)
|
|
{
|
|
/* Set time string */
|
|
strftime(TimeBuffer, 5, "%Y", Now);
|
|
|
|
/* Add copyright character */
|
|
strcpy(gCopyright, "(C)");
|
|
|
|
/* Add the year */
|
|
strcat(gCopyright, TimeBuffer);
|
|
|
|
/* Add blank company */
|
|
strcat(gCopyright, " ");
|
|
}
|
|
|
|
/* Write the resource file header */
|
|
fprintf(FileHandle,
|
|
"#include \"winver.h\"\r\n"
|
|
"1 VERSIONINFO\r\n"
|
|
" FILEVERSION 1,0,%d,%d\r\n"
|
|
" PRODUCTVERSION 1,0,%d,%d\r\n"
|
|
" FILEFLAGSMASK 0x3fL\r\n"
|
|
" FILEFLAGS 0x0L\r\n"
|
|
"FILEOS 0x40004L\r\n"
|
|
" FILETYPE VFT_DLL\r\n"
|
|
" FILESUBTYPE VFT2_DRV_KEYBOARD\r\n"
|
|
"BEGIN\r\n"
|
|
" BLOCK \"StringFileInfo\"\r\n"
|
|
" BEGIN\r\n"
|
|
" BLOCK \"000004B0\"\r\n"
|
|
" BEGIN\r\n"
|
|
" VALUE \"CompanyName\", \"%s\\0\"\r\n"
|
|
" VALUE \"FileDescription\", \"%s Keyboard Layout\\0\"\r\n"
|
|
" VALUE \"FileVersion\", \"1, 0, %d, %d\\0\"\r\n",
|
|
gVersion,
|
|
gSubVersion,
|
|
gVersion,
|
|
gSubVersion,
|
|
gCompany,
|
|
gDescription,
|
|
gVersion,
|
|
gSubVersion);
|
|
|
|
/* Continue writing it */
|
|
fprintf(FileHandle,
|
|
" VALUE \"InternalName\", \"%s (%d.%d)\\0\"\r\n"
|
|
" VALUE \"ProductName\",\"%s\\0\"\r\n"
|
|
" VALUE \"Release Information\",\"%s\\0\"\r\n"
|
|
" VALUE \"LegalCopyright\", \"%s\\0\"\r\n"
|
|
" VALUE \"OriginalFilename\",\"%s\\0\"\r\n"
|
|
" VALUE \"ProductVersion\", \"1, 0, %d, %d\\0\"\r\n"
|
|
" END\r\n"
|
|
" END\r\n"
|
|
" BLOCK \"VarFileInfo\"\r\n"
|
|
" BEGIN\r\n"
|
|
" VALUE \"Translation\", 0x0000, 0x04B0\r\n"
|
|
" END\r\n"
|
|
"END\r\n",
|
|
InternalName,
|
|
gVersion,
|
|
gSubVersion,
|
|
"Created by ReactOS KbdTool",
|
|
"Created by ReactOS KbdTool",
|
|
gCopyright,
|
|
InternalName,
|
|
gVersion,
|
|
gSubVersion);
|
|
|
|
/* Now check if we have a locale name */
|
|
Length = strlen(gLocaleName);
|
|
if (Length)
|
|
{
|
|
/* Write the stringtable header */
|
|
fprintf(FileHandle,
|
|
"\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
|
|
9,
|
|
1);
|
|
fprintf(FileHandle, "BEGIN\r\n");
|
|
|
|
/* Language or locale? */
|
|
if (strchr(gLocaleName, '\"'))
|
|
{
|
|
/* Write the language name */
|
|
fprintf(FileHandle, " %d %s\r\n", gStringIdForLanguageNames, gLocaleName);
|
|
}
|
|
else
|
|
{
|
|
/* Write the locale name */
|
|
fprintf(FileHandle, " %d \"%s\"\r\n", gStringIdForLocaleName, gLocaleName);
|
|
}
|
|
|
|
/* Terminate the entry */
|
|
fprintf(FileHandle, "END\r\n\r\n");
|
|
}
|
|
|
|
/* Check for description information */
|
|
while (DescriptionData)
|
|
{
|
|
/* Remember the next pointer */
|
|
NextDescription = DescriptionData->Next;
|
|
|
|
/* Write the header */
|
|
fprintf(FileHandle,
|
|
"\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
|
|
DescriptionData->Code & 0x3FF,
|
|
DescriptionData->Code >> 10);
|
|
fprintf(FileHandle, "BEGIN\r\n");
|
|
|
|
/* Quoted string or not? */
|
|
if (strchr(DescriptionData->Name, '\"'))
|
|
{
|
|
/* Write the description name */
|
|
fprintf(FileHandle, " %d %s\r\n", gStringIdForDescriptions, DescriptionData->Name);
|
|
}
|
|
else
|
|
{
|
|
/* Write the description name */
|
|
fprintf(FileHandle, " %d \"%s\"\r\n", gStringIdForDescriptions, DescriptionData->Name);
|
|
}
|
|
|
|
/* Terminate the entry */
|
|
fprintf(FileHandle, "END\r\n\r\n");
|
|
|
|
/* Free the allocation */
|
|
free(DescriptionData->Name);
|
|
free(DescriptionData);
|
|
|
|
/* Move to the next entry */
|
|
DescriptionData = NextDescription;
|
|
}
|
|
|
|
/* Check for language information */
|
|
while (LanguageData)
|
|
{
|
|
/* Remember the next pointer */
|
|
NextLanguage = LanguageData->Next;
|
|
|
|
/* Write the header */
|
|
fprintf(FileHandle,
|
|
"\r\nSTRINGTABLE DISCARDABLE\r\nLANGUAGE %d, %d\r\n",
|
|
LanguageData->Code & 0x3FF,
|
|
LanguageData->Code >> 10);
|
|
fprintf(FileHandle, "BEGIN\r\n");
|
|
|
|
/* Quoted string or not? */
|
|
if (strchr(LanguageData->Name, '\"'))
|
|
{
|
|
/* Write the language name */
|
|
fprintf(FileHandle, " %d %s\r\n", gStringIdForLanguageNames, LanguageData->Name);
|
|
}
|
|
else
|
|
{
|
|
/* Write the language name */
|
|
fprintf(FileHandle, " %d \"%s\"\r\n", gStringIdForLanguageNames, LanguageData->Name);
|
|
}
|
|
|
|
/* Terminate the entry */
|
|
fprintf(FileHandle, "END\r\n\r\n");
|
|
|
|
/* Free the allocation */
|
|
free(LanguageData->Name);
|
|
free(LanguageData);
|
|
|
|
/* Move to the next entry */
|
|
LanguageData = NextLanguage;
|
|
}
|
|
|
|
/* We're done! */
|
|
fclose(FileHandle);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
kbd_def(VOID)
|
|
{
|
|
CHAR OutputFile[13];
|
|
FILE *FileHandle;
|
|
|
|
/* Build the keyboard name and internal name */
|
|
strcpy(OutputFile, gKBDName);
|
|
strcat(OutputFile, ".DEF");
|
|
|
|
/* Open it */
|
|
FileHandle = fopen(OutputFile, "wt");
|
|
if (!FileHandle)
|
|
{
|
|
/* Fail */
|
|
printf(" %12s : can't open for write.\n", OutputFile);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Write the file exports */
|
|
fprintf(FileHandle,
|
|
"LIBRARY %s\n\n"
|
|
"EXPORTS\n"
|
|
" KbdLayerDescriptor @1\n",
|
|
gKBDName);
|
|
|
|
/* Clean up */
|
|
fclose(FileHandle);
|
|
return TRUE;
|
|
}
|
|
|
|
BOOLEAN
|
|
kbd_c(IN ULONG StateCount,
|
|
IN PULONG ShiftStates,
|
|
IN PVOID AttributeData,
|
|
IN PLAYOUT Layout,
|
|
IN PVOID DeadKeyData,
|
|
IN PVOID LigatureData,
|
|
IN PKEYNAME KeyNameData,
|
|
IN PKEYNAME KeyNameExtData,
|
|
IN PKEYNAME KeyNameDeadData)
|
|
{
|
|
CHAR OutputFile[13];
|
|
CHAR KeyNameBuffer[50];
|
|
CHAR LineBuffer[256];
|
|
BOOLEAN NeedPlus;
|
|
FILE *FileHandle;
|
|
ULONG States[8];
|
|
ULONG i, j, k;
|
|
ULONG HighestState;
|
|
PVKNAME Entry;
|
|
PCHAR p;
|
|
|
|
/* Build the keyboard name and internal name */
|
|
strcpy(OutputFile, gKBDName);
|
|
strcat(OutputFile, ".C");
|
|
|
|
/* Open it */
|
|
FileHandle = fopen(OutputFile, "wt");
|
|
if (!FileHandle)
|
|
{
|
|
/* Fail */
|
|
printf(" %12s : can't open for write.\n", OutputFile);
|
|
return FALSE;
|
|
}
|
|
|
|
/* Print the header */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* Module Name: %s\n*\n* keyboard layout\n"
|
|
"*\n"
|
|
"* Copyright (c) 2009, ReactOS Foundation\n"
|
|
"*\n"
|
|
"* History:\n"
|
|
"* KBDTOOL v%d.%02d - Created %s"
|
|
"\\***************************************************************************/\n\n",
|
|
OutputFile,
|
|
gVersion,
|
|
gSubVersion,
|
|
asctime(Now));
|
|
|
|
/* What kind of driver is this? */
|
|
if (FallbackDriver)
|
|
{
|
|
/* Fallback only */
|
|
fprintf(FileHandle, "#include \"precomp.h\"\n");
|
|
}
|
|
else
|
|
{
|
|
/* Add the includes */
|
|
fprintf(FileHandle,
|
|
"#include <windows.h>\n"
|
|
"#include \"kbd.h\"\n"
|
|
"#include \"%s.h\"\n\n",
|
|
gKBDName);
|
|
}
|
|
|
|
/* What kind of driver is this? */
|
|
if (FallbackDriver)
|
|
{
|
|
/* Only one section */
|
|
fprintf(FileHandle,
|
|
"#pragma data_seg(\"%s\")\n#define ALLOC_SECTION_LDATA\n\n",
|
|
".kbdfallback");
|
|
}
|
|
else
|
|
{
|
|
/* Section and attributes depend on architecture */
|
|
fprintf(FileHandle,
|
|
"#if defined(_M_IA64)\n"
|
|
"#pragma section(\"%s\")\n"
|
|
"#define ALLOC_SECTION_LDATA __declspec(allocate(\"%s\"))\n"
|
|
"#else\n"
|
|
"#pragma data_seg(\"%s\")\n"
|
|
"#define ALLOC_SECTION_LDATA\n"
|
|
"#endif\n\n",
|
|
".data",
|
|
".data",
|
|
".data");
|
|
}
|
|
|
|
/* Scan code to virtual key conversion table header */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* ausVK[] - Virtual Scan Code to Virtual Key conversion table\n"
|
|
"\\***************************************************************************/\n\n");
|
|
|
|
/* Table begin */
|
|
fprintf(FileHandle,
|
|
"static ALLOC_SECTION_LDATA USHORT ausVK[] = {\n"
|
|
" T00, T01, T02, T03, T04, T05, T06, T07,\n"
|
|
" T08, T09, T0A, T0B, T0C, T0D, T0E, T0F,\n"
|
|
" T10, T11, T12, T13, T14, T15, T16, T17,\n"
|
|
" T18, T19, T1A, T1B, T1C, T1D, T1E, T1F,\n"
|
|
" T20, T21, T22, T23, T24, T25, T26, T27,\n"
|
|
" T28, T29, T2A, T2B, T2C, T2D, T2E, T2F,\n"
|
|
" T30, T31, T32, T33, T34, T35,\n\n");
|
|
|
|
/* Table continue */
|
|
fprintf(FileHandle,
|
|
" /*\n"
|
|
" * Right-hand Shift key must have KBDEXT bit set.\n"
|
|
" */\n"
|
|
" T36 | KBDEXT,\n\n"
|
|
" T37 | KBDMULTIVK, // numpad_* + Shift/Alt -> SnapShot\n\n"
|
|
" T38, T39, T3A, T3B, T3C, T3D, T3E,\n"
|
|
" T3F, T40, T41, T42, T43, T44,\n\n");
|
|
|
|
/* Table continue */
|
|
fprintf(FileHandle,
|
|
" /*\n"
|
|
" * NumLock Key:\n"
|
|
" * KBDEXT - VK_NUMLOCK is an Extended key\n"
|
|
" * KBDMULTIVK - VK_NUMLOCK or VK_PAUSE (without or with CTRL)\n"
|
|
" */\n"
|
|
" T45 | KBDEXT | KBDMULTIVK,\n\n"
|
|
" T46 | KBDMULTIVK,\n\n");
|
|
|
|
/* Numpad table */
|
|
fprintf(FileHandle,
|
|
" /*\n"
|
|
" * Number Pad keys:\n"
|
|
" * KBDNUMPAD - digits 0-9 and decimal point.\n"
|
|
" * KBDSPECIAL - require special processing by Windows\n"
|
|
" */\n"
|
|
" T47 | KBDNUMPAD | KBDSPECIAL, // Numpad 7 (Home)\n"
|
|
" T48 | KBDNUMPAD | KBDSPECIAL, // Numpad 8 (Up),\n"
|
|
" T49 | KBDNUMPAD | KBDSPECIAL, // Numpad 9 (PgUp),\n"
|
|
" T4A,\n"
|
|
" T4B | KBDNUMPAD | KBDSPECIAL, // Numpad 4 (Left),\n"
|
|
" T4C | KBDNUMPAD | KBDSPECIAL, // Numpad 5 (Clear),\n"
|
|
" T4D | KBDNUMPAD | KBDSPECIAL, // Numpad 6 (Right),\n"
|
|
" T4E,\n"
|
|
" T4F | KBDNUMPAD | KBDSPECIAL, // Numpad 1 (End),\n"
|
|
" T50 | KBDNUMPAD | KBDSPECIAL, // Numpad 2 (Down),\n"
|
|
" T51 | KBDNUMPAD | KBDSPECIAL, // Numpad 3 (PgDn),\n"
|
|
" T52 | KBDNUMPAD | KBDSPECIAL, // Numpad 0 (Ins),\n"
|
|
" T53 | KBDNUMPAD | KBDSPECIAL, // Numpad . (Del),\n\n");
|
|
|
|
/* Table finish */
|
|
fprintf(FileHandle,
|
|
" T54, T55, T56, T57, T58, T59, T5A, T5B,\n"
|
|
" T5C, T5D, T5E, T5F, T60, T61, T62, T63,\n"
|
|
" T64, T65, T66, T67, T68, T69, T6A, T6B,\n"
|
|
" T6C, T6D, T6E, T6F, T70, T71, T72, T73,\n"
|
|
" T74, T75, T76, T77, T78, T79, T7A, T7B,\n"
|
|
" T7C, T7D, T7E\n\n"
|
|
"};\n\n");
|
|
|
|
/* Key name table header */
|
|
fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_VK aE0VscToVk[] = {\n");
|
|
|
|
/* Loop 110-key table */
|
|
for (i = 0; i < 110; i++)
|
|
{
|
|
/* Check for non-extended keys */
|
|
if ((Layout->Entry[i].ScanCode & 0xFF00) == 0xE000)
|
|
{
|
|
/* Which are valid */
|
|
if (Layout->Entry[i].ScanCode != 0xFF)
|
|
{
|
|
/* And mapped */
|
|
if (Layout->Entry[i].VirtualKey != 0xFF)
|
|
{
|
|
/* Output them */
|
|
fprintf(FileHandle,
|
|
" { 0x%02X, X%02X | KBDEXT }, // %s\n",
|
|
Layout->Entry[i].ScanCode,
|
|
Layout->Entry[i].ScanCode,
|
|
Layout->Entry[i].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Key name table finish */
|
|
fprintf(FileHandle, " { 0, 0 }\n};\n\n");
|
|
|
|
/* Extended key name table header */
|
|
fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_VK aE1VscToVk[] = {\n");
|
|
|
|
/* Loop 110-key table */
|
|
for (i = 0; i < 110; i++)
|
|
{
|
|
/* Check for extended keys */
|
|
if ((Layout->Entry[i].ScanCode & 0xFF00) == 0xE100)
|
|
{
|
|
/* Which are valid */
|
|
if (Layout->Entry[i].ScanCode != 0xFF)
|
|
{
|
|
/* And mapped */
|
|
if (Layout->Entry[i].VirtualKey != 0xFF)
|
|
{
|
|
/* Output them */
|
|
fprintf(FileHandle,
|
|
" { 0x%02X, Y%02X | KBDEXT }, // %s\n",
|
|
Layout->Entry[i].ScanCode,
|
|
Layout->Entry[i].ScanCode,
|
|
Layout->Entry[i].Name);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Extended key name table finish */
|
|
fprintf(FileHandle,
|
|
" { 0x1D, Y1D }, // Pause\n"
|
|
" { 0 , 0 }\n};\n\n");
|
|
|
|
/* Modifier table description */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* aVkToBits[] - map Virtual Keys to Modifier Bits\n"
|
|
"*\n"
|
|
"* See kbd.h for a full description.\n"
|
|
"*\n"
|
|
"* The keyboard has only three shifter keys:\n"
|
|
"* SHIFT (L & R) affects alphabnumeric keys,\n"
|
|
"* CTRL (L & R) is used to generate control characters\n"
|
|
"* ALT (L & R) used for generating characters by number with numpad\n"
|
|
"\\***************************************************************************/\n");
|
|
|
|
/* Modifier table header */
|
|
fprintf(FileHandle, "static ALLOC_SECTION_LDATA VK_TO_BIT aVkToBits[] = {\n");
|
|
|
|
/* Loop modifier table */
|
|
i = 0;
|
|
Entry = &Modifiers[0];
|
|
while (Entry->VirtualKey)
|
|
{
|
|
/* Print out entry */
|
|
fprintf(FileHandle,
|
|
" { %-12s, %-12s },\n",
|
|
getVKName(Entry->VirtualKey, 1),
|
|
Entry->Name);
|
|
|
|
/* Move to the next one */
|
|
Entry = &Modifiers[++i];
|
|
}
|
|
|
|
/* Modifier table finish */
|
|
fprintf(FileHandle, " { 0, 0 }\n};\n\n");
|
|
|
|
/* Modifier conversion table description */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* aModification[] - map character modifier bits to modification number\n"
|
|
"*\n"
|
|
"* See kbd.h for a full description.\n"
|
|
"*\n"
|
|
"\\***************************************************************************/\n\n");
|
|
|
|
/* Zero out local state data */
|
|
for (i = 0; i < 8; i++) States[i] = -1;
|
|
|
|
/* Find the highest set state */
|
|
for (HighestState = 1, i = 0; (i < 8) && (ShiftStates[i] != -1); i++)
|
|
{
|
|
/* Save all state values */
|
|
States[ShiftStates[i]] = i;
|
|
if (ShiftStates[i] > HighestState) HighestState = ShiftStates[i];
|
|
}
|
|
|
|
/* Modifier conversion table header */
|
|
fprintf(FileHandle,
|
|
"static ALLOC_SECTION_LDATA MODIFIERS CharModifiers = {\n"
|
|
" &aVkToBits[0],\n"
|
|
" %d,\n"
|
|
" {\n"
|
|
" // Modification# // Keys Pressed\n"
|
|
" // ============= // =============\n",
|
|
HighestState);
|
|
|
|
/* Loop states */
|
|
for (i = 0; i <= HighestState; i++)
|
|
{
|
|
/* Check for invalid state */
|
|
if (States[i] == -1)
|
|
{
|
|
/* Invalid state header */
|
|
fprintf(FileHandle, " SHFT_INVALID, // ");
|
|
}
|
|
else
|
|
{
|
|
/* Is this the last one? */
|
|
if (i == HighestState)
|
|
{
|
|
/* Last state header */
|
|
fprintf(FileHandle, " %d // ", States[i]);
|
|
}
|
|
else
|
|
{
|
|
/* Normal state header */
|
|
fprintf(FileHandle, " %d, // ", States[i]);
|
|
}
|
|
|
|
/* State 1 or higher? */
|
|
if (i >= 1)
|
|
{
|
|
/* J is the loop variable, K is the double */
|
|
for (NeedPlus = 0, j = 0, k = 1; (1 << j) <= i; j++, k = (1 << j))
|
|
{
|
|
/* Do we need to add a plus? */
|
|
if (NeedPlus)
|
|
{
|
|
/* Add it */
|
|
fprintf(FileHandle, "+");
|
|
NeedPlus = FALSE;
|
|
}
|
|
|
|
/* Check if it's time to add a modifier */
|
|
if (i & k)
|
|
{
|
|
/* Get the key state name and copy it into our buffer */
|
|
strcpy(KeyNameBuffer, getVKName(Modifiers[j].VirtualKey, 1));
|
|
|
|
/* Go go the 4th char (past the "KBD") and lower name */
|
|
for (p = &KeyNameBuffer[4]; *p; p++) *p = tolower(*p);
|
|
|
|
/* Print it */
|
|
fprintf(FileHandle, "%s", &KeyNameBuffer[3]);
|
|
|
|
/* We'll need a plus sign next */
|
|
NeedPlus = TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Terminate the entry */
|
|
fprintf(FileHandle, "\n");
|
|
}
|
|
}
|
|
|
|
|
|
/* Modifier conversion table end */
|
|
fprintf(FileHandle," }\n" "};\n\n");
|
|
|
|
/* Shift state translation table description */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"*\n"
|
|
"* aVkToWch2[] - Virtual Key to WCHAR translation for 2 shift states\n"
|
|
"* aVkToWch3[] - Virtual Key to WCHAR translation for 3 shift states\n"
|
|
"* aVkToWch4[] - Virtual Key to WCHAR translation for 4 shift states\n");
|
|
|
|
/* Check if there's exta shift states */
|
|
for (i = 5; i < HighestState; i++)
|
|
{
|
|
/* Print out extra information */
|
|
fprintf(FileHandle,
|
|
"* aVkToWch%d[] - Virtual Key to WCHAR translation for %d shift states\n",
|
|
i,
|
|
i);
|
|
}
|
|
|
|
/* Shift state translation table description continue */
|
|
fprintf(FileHandle,
|
|
"*\n"
|
|
"* Table attributes: Unordered Scan, null-terminated\n"
|
|
"*\n"
|
|
"* Search this table for an entry with a matching Virtual Key to find the\n"
|
|
"* corresponding unshifted and shifted WCHAR characters.\n"
|
|
"*\n"
|
|
"* Special values for VirtualKey (column 1)\n"
|
|
"* 0xff - dead chars for the previous entry\n"
|
|
"* 0 - terminate the list\n"
|
|
"*\n"
|
|
"* Special values for Attributes (column 2)\n"
|
|
"* CAPLOK bit - CAPS-LOCK affect this key like SHIFT\n"
|
|
"*\n"
|
|
"* Special values for wch[*] (column 3 & 4)\n"
|
|
"* WCH_NONE - No character\n"
|
|
"* WCH_DEAD - Dead Key (diaresis) or invalid (US keyboard has none)\n"
|
|
"* WCH_LGTR - Ligature (generates multiple characters)\n"
|
|
"*\n"
|
|
"\\***************************************************************************/\n\n");
|
|
|
|
/* Loop all the states */
|
|
for (i = 2; i <= StateCount; i++)
|
|
{
|
|
/* Check if this something else than state 2 */
|
|
if (i != 2)
|
|
{
|
|
/* Loop all the scan codes */
|
|
for (j = 0; j < 110; j++)
|
|
{
|
|
/* Check if this is the state for the entry */
|
|
if (i == Layout->Entry[j].StateCount) break;
|
|
}
|
|
}
|
|
|
|
/* Print the table header */
|
|
fprintf(FileHandle,
|
|
"static ALLOC_SECTION_LDATA VK_TO_WCHARS%d aVkToWch%d[] = {\n"
|
|
"// | | Shift |",
|
|
i,
|
|
i);
|
|
|
|
/* Print the correct state label */
|
|
for (k = 2; k < i; k++) fprintf(FileHandle, "%-9.9s|",
|
|
StateLabel[ShiftStates[k]]);
|
|
|
|
/* Print the next separator */
|
|
fprintf(FileHandle, "\n// |=========|=========|");
|
|
|
|
/* Check for extra states and print their separators too */
|
|
for (k = 2; k < i; k++) fprintf(FileHandle, "=========|");
|
|
|
|
/* Finalize the separator header */
|
|
fprintf(FileHandle, "\n");
|
|
|
|
/* Loop all the scan codes */
|
|
for (j = 0; j < 110; j++)
|
|
{
|
|
/* Check if this is the state for the entry */
|
|
if (i != Layout->Entry[j].StateCount) continue;
|
|
|
|
/* Print out the entry for this key */
|
|
fprintf(FileHandle,
|
|
" {%-13s,%-7s",
|
|
getVKName(Layout->Entry[j].VirtualKey, 1),
|
|
CapState[Layout->Entry[j].Cap]);
|
|
|
|
/* Initialize the buffer for this line */
|
|
*LineBuffer = '\0';
|
|
|
|
/* Loop states */
|
|
for (k = 0; k < i; k++)
|
|
{
|
|
/* Check for dead key data */
|
|
if (DeadKeyData)
|
|
{
|
|
/* Not yet supported */
|
|
printf("Dead key data not supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Check if it's a ligature key */
|
|
if (Layout->Entry[j].LigatureCharData[k])
|
|
{
|
|
/* Not yet supported */
|
|
printf("Ligature key data not supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Print out the WCH_ name */
|
|
fprintf(FileHandle,
|
|
",%-9s",
|
|
WChName(Layout->Entry[j].CharData[k], 0));
|
|
|
|
/* If we have something on the line buffer by now, add WCH_NONE */
|
|
if (*LineBuffer != '\0') strcpy(LineBuffer, "WCH_NONE ");
|
|
}
|
|
|
|
/* Finish the line */
|
|
fprintf(FileHandle, "},\n");
|
|
|
|
/* Do we have any data at all? */
|
|
if (*LineBuffer != '\0')
|
|
{
|
|
/* Print it, we're done */
|
|
fprintf(FileHandle, "%s},\n", LineBuffer);
|
|
continue;
|
|
}
|
|
|
|
/* Otherwise, we're done, unless this requires SGCAP data */
|
|
if (Layout->Entry[j].Cap != 2) continue;
|
|
|
|
/* Not yet supported */
|
|
printf("SGCAP not yet supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Did we only have two states? */
|
|
if (i == 2)
|
|
{
|
|
/* Print out the built-in table */
|
|
fprintf(FileHandle,
|
|
" {VK_TAB ,0 ,'\\t' ,'\\t' },\n"
|
|
" {VK_ADD ,0 ,'+' ,'+' },\n"
|
|
" {VK_DIVIDE ,0 ,'/' ,'/' },\n"
|
|
" {VK_MULTIPLY ,0 ,'*' ,'*' },\n"
|
|
" {VK_SUBTRACT ,0 ,'-' ,'-' },\n");
|
|
}
|
|
|
|
/* Terminate the table */
|
|
fprintf(FileHandle, " {0 ,0 ");
|
|
for (k = 0; k < i; k++) fprintf(FileHandle, ",0 ");
|
|
|
|
/* Terminate the structure */
|
|
fprintf(FileHandle, "}\n" "};\n\n");
|
|
}
|
|
|
|
/* Numpad translation table */
|
|
fprintf(FileHandle,
|
|
"// Put this last so that VkKeyScan interprets number characters\n"
|
|
"// as coming from the main section of the kbd (aVkToWch2 and\n"
|
|
"// aVkToWch5) before considering the numpad (aVkToWch1).\n\n"
|
|
"static ALLOC_SECTION_LDATA VK_TO_WCHARS1 aVkToWch1[] = {\n"
|
|
" { VK_NUMPAD0 , 0 , '0' },\n"
|
|
" { VK_NUMPAD1 , 0 , '1' },\n"
|
|
" { VK_NUMPAD2 , 0 , '2' },\n"
|
|
" { VK_NUMPAD3 , 0 , '3' },\n"
|
|
" { VK_NUMPAD4 , 0 , '4' },\n"
|
|
" { VK_NUMPAD5 , 0 , '5' },\n"
|
|
" { VK_NUMPAD6 , 0 , '6' },\n"
|
|
" { VK_NUMPAD7 , 0 , '7' },\n"
|
|
" { VK_NUMPAD8 , 0 , '8' },\n"
|
|
" { VK_NUMPAD9 , 0 , '9' },\n"
|
|
" { 0 , 0 , '\\0' }\n"
|
|
"};\n\n");
|
|
|
|
/* Translation tables header */
|
|
fprintf(FileHandle,"static ALLOC_SECTION_LDATA VK_TO_WCHAR_TABLE aVkToWcharTable[] = {\n");
|
|
|
|
/* Loop states higher than 3 */
|
|
for (i = 3; i <= StateCount; i++)
|
|
{
|
|
/* Print out the extra tables */
|
|
fprintf(FileHandle,
|
|
" { (PVK_TO_WCHARS1)aVkToWch%d, %d, sizeof(aVkToWch%d[0]) },\n",
|
|
i,
|
|
i,
|
|
i);
|
|
}
|
|
|
|
/* Array of translation tables */
|
|
fprintf(FileHandle,
|
|
" { (PVK_TO_WCHARS1)aVkToWch2, 2, sizeof(aVkToWch2[0]) },\n"
|
|
" { (PVK_TO_WCHARS1)aVkToWch1, 1, sizeof(aVkToWch1[0]) },\n"
|
|
" { NULL, 0, 0 },\n"
|
|
"};\n\n");
|
|
|
|
/* Scan code to key name conversion table description */
|
|
fprintf(FileHandle,
|
|
"/***************************************************************************\\\n"
|
|
"* aKeyNames[], aKeyNamesExt[] - Virtual Scancode to Key Name tables\n"
|
|
"*\n"
|
|
"* Table attributes: Ordered Scan (by scancode), null-terminated\n"
|
|
"*\n"
|
|
"* Only the names of Extended, NumPad, Dead and Non-Printable keys are here.\n"
|
|
"* (Keys producing printable characters are named by that character)\n"
|
|
"\\***************************************************************************/\n\n");
|
|
|
|
/* Check for key name data */
|
|
if (KeyNameData)
|
|
{
|
|
/* Table header */
|
|
fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNames[] = {\n");
|
|
|
|
/* Print table */
|
|
PrintNameTable(FileHandle, KeyNameData, FALSE);
|
|
|
|
/* Table end */
|
|
fprintf(FileHandle, "};\n\n");
|
|
}
|
|
|
|
/* Check for extended key name data */
|
|
if (KeyNameExtData)
|
|
{
|
|
/* Table header */
|
|
fprintf(FileHandle, "static ALLOC_SECTION_LDATA VSC_LPWSTR aKeyNamesExt[] = {\n");
|
|
|
|
/* Print table */
|
|
PrintNameTable(FileHandle, KeyNameExtData, FALSE);
|
|
|
|
/* Table end */
|
|
fprintf(FileHandle, "};\n\n");
|
|
}
|
|
|
|
/* Check for dead key name data */
|
|
if (KeyNameDeadData)
|
|
{
|
|
/* Not yet supported */
|
|
printf("Dead key name data not supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Check for dead key data */
|
|
if (DeadKeyData)
|
|
{
|
|
/* Not yet supported */
|
|
printf("Dead key data not supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Check for ligature data */
|
|
if (LigatureData)
|
|
{
|
|
/* Not yet supported */
|
|
printf("Ligature key data not supported!\n");
|
|
exit(1);
|
|
}
|
|
|
|
/* Main keyboard table descriptor type */
|
|
fprintf(FileHandle, "static ");
|
|
|
|
/* FIXME? */
|
|
|
|
/* Main keyboard table descriptor header */
|
|
fprintf(FileHandle,
|
|
"ALLOC_SECTION_LDATA KBDTABLES KbdTables%s = {\n"
|
|
" /*\n"
|
|
" * Modifier keys\n"
|
|
" */\n"
|
|
" &CharModifiers,\n\n"
|
|
" /*\n"
|
|
" * Characters tables\n"
|
|
" */\n"
|
|
" aVkToWcharTable,\n\n"
|
|
" /*\n"
|
|
" * Diacritics\n"
|
|
" */\n",
|
|
FallbackDriver ? "Fallback" : "" );
|
|
|
|
/* Descriptor dead key data section */
|
|
if (DeadKeyData)
|
|
{
|
|
fprintf(FileHandle, " aDeadKey,\n\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FileHandle, " NULL,\n\n");
|
|
}
|
|
|
|
/* Descriptor key name comment */
|
|
fprintf(FileHandle,
|
|
" /*\n"
|
|
" * Names of Keys\n"
|
|
" */\n");
|
|
|
|
/* Descriptor key name section */
|
|
if (KeyNameData)
|
|
{
|
|
fprintf(FileHandle, " aKeyNames,\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FileHandle, " NULL,\n");
|
|
}
|
|
|
|
/* Descriptor extended key name section */
|
|
if (KeyNameExtData)
|
|
{
|
|
fprintf(FileHandle, " aKeyNamesExt,\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FileHandle, " NULL,\n");
|
|
}
|
|
|
|
/* Descriptor dead key name section */
|
|
if ((DeadKeyData) && (KeyNameDeadData))
|
|
{
|
|
fprintf(FileHandle, " aKeyNamesDead,\n\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FileHandle, " NULL,\n\n");
|
|
}
|
|
|
|
/* Descriptor conversion table section */
|
|
fprintf(FileHandle,
|
|
" /*\n"
|
|
" * Scan codes to Virtual Keys\n"
|
|
" */\n"
|
|
" ausVK,\n"
|
|
" sizeof(ausVK) / sizeof(ausVK[0]),\n"
|
|
" aE0VscToVk,\n"
|
|
" aE1VscToVk,\n\n"
|
|
" /*\n"
|
|
" * Locale-specific special processing\n"
|
|
" */\n");
|
|
|
|
/* FIXME: AttributeData and KLLF_ALTGR stuff */
|
|
|
|
/* Descriptor locale-specific section */
|
|
fprintf(FileHandle, " MAKELONG(%s, KBD_VERSION),\n\n", "0"); /* FIXME */
|
|
|
|
/* Descriptor ligature data comment */
|
|
fprintf(FileHandle, " /*\n * Ligatures\n */\n %d,\n", 0); /* FIXME */
|
|
|
|
/* Descriptor ligature data section */
|
|
if (!LigatureData)
|
|
{
|
|
fprintf(FileHandle, " 0,\n");
|
|
fprintf(FileHandle, " NULL\n");
|
|
}
|
|
else
|
|
{
|
|
fprintf(FileHandle, " sizeof(aLigature[0]),\n");
|
|
fprintf(FileHandle, " (PLIGATURE1)aLigature\n");
|
|
}
|
|
|
|
/* Descriptor finish */
|
|
fprintf(FileHandle, "};\n\n");
|
|
|
|
/* Keyboard layout callback function */
|
|
if (!FallbackDriver) fprintf(FileHandle,
|
|
"PKBDTABLES KbdLayerDescriptor(VOID)\n"
|
|
"{\n"
|
|
" return &KbdTables;\n"
|
|
"}\n");
|
|
|
|
/* Clean up */
|
|
fclose(FileHandle);
|
|
return TRUE;
|
|
}
|
|
|
|
ULONG
|
|
DoOutput(IN ULONG StateCount,
|
|
IN PULONG ShiftStates,
|
|
IN PKEYNAME DescriptionData,
|
|
IN PKEYNAME LanguageData,
|
|
IN PVOID AttributeData,
|
|
IN PVOID DeadKeyData,
|
|
IN PVOID LigatureData,
|
|
IN PKEYNAME KeyNameData,
|
|
IN PKEYNAME KeyNameExtData,
|
|
IN PKEYNAME KeyNameDeadData)
|
|
{
|
|
ULONG FailureCode = 0;
|
|
|
|
/* Take the time */
|
|
time(&Clock);
|
|
Now = localtime(&Clock);
|
|
|
|
/* Check if this just a fallback driver*/
|
|
if (!FallbackDriver)
|
|
{
|
|
/* It's not, create header file */
|
|
if (!kbd_h(&g_Layout)) FailureCode = 1;
|
|
|
|
/* Create the resource file */
|
|
if (!kbd_rc(DescriptionData, LanguageData)) FailureCode = 2;
|
|
}
|
|
|
|
/* Create the C file */
|
|
if (!kbd_c(StateCount,
|
|
ShiftStates,
|
|
AttributeData,
|
|
&g_Layout,
|
|
DeadKeyData,
|
|
LigatureData,
|
|
KeyNameData,
|
|
KeyNameExtData,
|
|
KeyNameDeadData))
|
|
{
|
|
/* Failed in C file generation */
|
|
FailureCode = 3;
|
|
}
|
|
|
|
/* Check if this just a fallback driver*/
|
|
if (!FallbackDriver)
|
|
{
|
|
/* Generate the definition file */
|
|
if (!kbd_def()) FailureCode = 4;
|
|
}
|
|
|
|
/* Done */
|
|
return FailureCode;
|
|
}
|
|
|
|
|
|
/* EOF */
|