accel.c File Reference

#include <user32.h>

Include dependency graph for accel.c:

Go to the source code of this file.

Classes
struct	PE_ACCEL
struct	_USER_ACCEL_CACHE_ENTRY

Typedefs
typedef struct PE_ACCEL *	LPPE_ACCEL
typedef struct _USER_ACCEL_CACHE_ENTRY	U32_ACCEL_CACHE_ENTRY

Functions
U32_ACCEL_CACHE_ENTRY **WINAPI	U32AccelCacheFind (HANDLE Object, HGLOBAL Data)
void WINAPI	U32AccelCacheAdd (HACCEL Object, HGLOBAL Data)
HACCEL WINAPI	U32LoadAccelerators (HINSTANCE hInstance, HRSRC hTableRes)
BOOL WINAPI	U32IsValidAccelMessage (UINT uMsg)
BOOL WINAPI	DestroyAcceleratorTable (HACCEL hAccel)
HACCEL WINAPI	LoadAcceleratorsW (HINSTANCE hInstance, LPCWSTR lpTableName)
HACCEL WINAPI	LoadAcceleratorsA (HINSTANCE hInstance, LPCSTR lpTableName)
int WINAPI	TranslateAcceleratorW (HWND hWnd, HACCEL hAccTable, LPMSG lpMsg)
int WINAPI	CopyAcceleratorTableA (HACCEL hAccelSrc, LPACCEL lpAccelDst, int cAccelEntries)
HACCEL WINAPI	CreateAcceleratorTableA (LPACCEL lpaccl, int cEntries)
int WINAPI	TranslateAcceleratorA (HWND hWnd, HACCEL hAccTable, LPMSG lpMsg)

Variables
CRITICAL_SECTION	U32AccelCacheLock
U32_ACCEL_CACHE_ENTRY *	U32AccelCache = NULL

Typedef Documentation

LPPE_ACCEL

typedef struct PE_ACCEL * LPPE_ACCEL

U32_ACCEL_CACHE_ENTRY

typedef struct _USER_ACCEL_CACHE_ENTRY U32_ACCEL_CACHE_ENTRY

Function Documentation

CopyAcceleratorTableA()

int WINAPI CopyAcceleratorTableA	(	HACCEL	hAccelSrc,
		LPACCEL	lpAccelDst,
		int	cAccelEntries
	)

Definition at line 279 of file accel.c.

{
   int i;
 
   cAccelEntries = CopyAcceleratorTableW(hAccelSrc, lpAccelDst, cAccelEntries);
 
   if (lpAccelDst == NULL) return cAccelEntries;
 
   for(i = 0; i < cAccelEntries; ++ i)
   if(!(lpAccelDst[i].fVirt & FVIRTKEY))
   {
      NTSTATUS nErrCode = RtlUnicodeToMultiByteN(
         (PCHAR)&lpAccelDst[i].key,
         sizeof(lpAccelDst[i].key),
         NULL,
         (PWCHAR)&lpAccelDst[i].key,
         sizeof(lpAccelDst[i].key)
         );
 
      if(!NT_SUCCESS(nErrCode)) lpAccelDst[i].key = 0;
   }
 
   return cAccelEntries;
}

CreateAcceleratorTableA()

HACCEL WINAPI CreateAcceleratorTableA	(	LPACCEL	lpaccl,
		int	cEntries
	)

Definition at line 313 of file accel.c.

{
 int i;
 
 if (!cEntries || !lpaccl) return (HACCEL)0;
 
 for(i = 0; i < cEntries; ++ i)
  if(!lpaccl[i].fVirt)
  {
   NTSTATUS nErrCode = RtlMultiByteToUnicodeN
   (
    (PWCHAR)&lpaccl[i].key,
    sizeof(lpaccl[i].key),
    NULL,
    (PCHAR)&lpaccl[i].key,
    sizeof(lpaccl[i].key)
   );
 
   if(!NT_SUCCESS(nErrCode)) lpaccl[i].key = -1;
  }
 
 return CreateAcceleratorTableW(lpaccl, cEntries);
}

DestroyAcceleratorTable()

BOOL WINAPI DestroyAcceleratorTable

(

HACCEL

hAccel

)

Definition at line 191 of file accel.c.

{
 U32_ACCEL_CACHE_ENTRY ** ppEntry;
 ULONG_PTR nUsage = 0;
 
 if (!hAccel)
  return FALSE;
 
 EnterCriticalSection(&U32AccelCacheLock);
 
 /* see if this accelerator table has been cached */
 ppEntry = U32AccelCacheFind(hAccel, NULL);
 
 /* accelerator table cached */
 if(*ppEntry)
 {
  U32_ACCEL_CACHE_ENTRY * pEntry = *ppEntry;
 
  /* decrement the reference count */
  nUsage = pEntry->Usage = pEntry->Usage - 1;
 
  /* reference count now zero: destroy the cache entry */
  if(nUsage == 0)
  {
   /* unlink the cache entry */
   *ppEntry = pEntry->Next;
 
   /* free the cache entry */
   LocalFree(pEntry);
  }
 }
 
 LeaveCriticalSection(&U32AccelCacheLock);
 
 if(nUsage > 0) return FALSE;
 
 /* destroy the object */
 return NtUserDestroyAcceleratorTable(hAccel);
}

LoadAcceleratorsA()

HACCEL WINAPI LoadAcceleratorsA	(	HINSTANCE	hInstance,
		LPCSTR	lpTableName
	)

Definition at line 250 of file accel.c.

{
  HRSRC Accel;
 
  Accel = FindResourceExA(hInstance, (LPCSTR) RT_ACCELERATOR, lpTableName, 0);
  if (NULL == Accel)
    {
      return NULL;
    }
 
  return U32LoadAccelerators(hInstance, Accel);
}

LoadAcceleratorsW()

HACCEL WINAPI LoadAcceleratorsW	(	HINSTANCE	hInstance,
		LPCWSTR	lpTableName
	)

Definition at line 237 of file accel.c.

{
 return U32LoadAccelerators
 (
  hInstance,
  FindResourceExW(hInstance, (LPCWSTR) RT_ACCELERATOR, lpTableName, 0)
 );
}

TranslateAcceleratorA()

int WINAPI TranslateAcceleratorA	(	HWND	hWnd,
		HACCEL	hAccTable,
		LPMSG	lpMsg
	)

Definition at line 341 of file accel.c.

{
    switch (lpMsg->message)
    {
    case WM_KEYDOWN:
    case WM_SYSKEYDOWN:
        return TranslateAcceleratorW( hWnd, hAccTable, lpMsg );
 
    case WM_CHAR:
    case WM_SYSCHAR:
        {
            MSG msgW = *lpMsg;
            char ch = LOWORD(lpMsg->wParam);
            WCHAR wch;
            MultiByteToWideChar(CP_ACP, 0, &ch, 1, &wch, 1);
            msgW.wParam = MAKEWPARAM(wch, HIWORD(lpMsg->wParam));
            return TranslateAcceleratorW( hWnd, hAccTable, &msgW );
        }
 
    default:
        return 0;
    }
}

TranslateAcceleratorW()

int WINAPI TranslateAcceleratorW	(	HWND	hWnd,
		HACCEL	hAccTable,
		LPMSG	lpMsg
	)

Definition at line 268 of file accel.c.

{
 if(!U32IsValidAccelMessage(lpMsg->message)) return 0;
 
 return NtUserTranslateAccelerator(hWnd, hAccTable, lpMsg);
}

Referenced by TranslateAcceleratorA().

U32AccelCacheAdd()

void WINAPI U32AccelCacheAdd	(	HACCEL	Object,
		HGLOBAL	Data
	)

Definition at line 75 of file accel.c.

{
 U32_ACCEL_CACHE_ENTRY * pEntry =
  LocalAlloc(LMEM_FIXED, sizeof(U32_ACCEL_CACHE_ENTRY));
 
 /* failed to allocate an entry - not critical */
 if(pEntry == NULL) return;
 
 /* initialize the entry */
 pEntry->Usage = 1;
 pEntry->Object = Object;
 pEntry->Data = Data;
 
 /* insert the entry into the cache */
 pEntry->Next = U32AccelCache;
 U32AccelCache = pEntry;
}

Referenced by U32LoadAccelerators().

U32AccelCacheFind()

U32_ACCEL_CACHE_ENTRY **WINAPI U32AccelCacheFind	(	HANDLE	Object,
		HGLOBAL	Data
	)

Definition at line 60 of file accel.c.

{
 /*
  to avoid using a double-link list and still allow elements to be removed,
  return a pointer to the list link that points to the desired entry
 */
 U32_ACCEL_CACHE_ENTRY ** ppEntry = &U32AccelCache;
 
 for(; *ppEntry; ppEntry = &((*ppEntry)->Next))
  if((*ppEntry)->Object == Object || (*ppEntry)->Data == Data) break;
 
 return ppEntry;
}

Referenced by DestroyAcceleratorTable(), and U32LoadAccelerators().

U32IsValidAccelMessage()

BOOL WINAPI U32IsValidAccelMessage

(

UINT

uMsg

)

Definition at line 166 of file accel.c.

{
 switch(uMsg)
 {
  case WM_KEYDOWN:
  case WM_KEYUP:
  case WM_CHAR:
  case WM_SYSCHAR:
  case WM_SYSKEYDOWN:
  case WM_SYSKEYUP:
   return TRUE;
 
  default:
   return FALSE;
 }
}

Referenced by TranslateAcceleratorW().

U32LoadAccelerators()

HACCEL WINAPI U32LoadAccelerators	(	HINSTANCE	hInstance,
		HRSRC	hTableRes
	)

Definition at line 94 of file accel.c.

{
 HGLOBAL hAccTableData;
 HACCEL hAccTable = NULL;
 U32_ACCEL_CACHE_ENTRY * pEntry;
 PE_ACCEL * pAccTableResData;
 SIZE_T i = 0;
 SIZE_T j = 0;
 ACCEL * pAccTableData;
 
 /* load the accelerator table */
 hAccTableData = LoadResource(hInstance, hTableRes);
 
 /* failure */
 if(hAccTableData == NULL) return NULL;
 
 EnterCriticalSection(&U32AccelCacheLock);
 
 /* see if this accelerator table has already been loaded */
 pEntry = *U32AccelCacheFind(NULL, hAccTableData);
 
 /* accelerator table already loaded */
 if(pEntry)
 {
  /* increment the reference count */
  ++ pEntry->Usage;
 
  /* return the existing object */
  hAccTable = pEntry->Object;
 
  /* success */
  goto l_Leave;
 }
 
 /* determine the number of entries in the table */
 i = SizeofResource(hInstance, hTableRes) / sizeof(PE_ACCEL);
 
 /* allocate the buffer for the table to be passed to Win32K */
 pAccTableData = LocalAlloc(LMEM_FIXED, i * sizeof(ACCEL));
 
 /* failure */
 if(pAccTableData == NULL) goto l_Leave;
 
 pAccTableResData = (PE_ACCEL *)hAccTableData;
 
 /* copy the table */
 for(j = 0; j < i; ++ j)
 {
  pAccTableData[j].fVirt = pAccTableResData[j].fVirt;
  pAccTableData[j].key = pAccTableResData[j].key;
  pAccTableData[j].cmd = pAccTableResData[j].cmd;
 }
 pAccTableData[i - 1].fVirt |= 0x80;
 
 /* create a new accelerator table object */
 hAccTable = NtUserCreateAcceleratorTable(pAccTableData, i);
 
 /* free the buffer */
 LocalFree(pAccTableData);
 
 /* failure */
 if(hAccTable == NULL) goto l_Leave;
 
 /* success - cache the object */
 U32AccelCacheAdd(hAccTable, pAccTableResData);
 
l_Leave:
 LeaveCriticalSection(&U32AccelCacheLock);
 return hAccTable;
}

Referenced by LoadAcceleratorsA(), and LoadAcceleratorsW().

Variable Documentation

U32AccelCache

U32_ACCEL_CACHE_ENTRY* U32AccelCache = NULL

Definition at line 57 of file accel.c.

Referenced by U32AccelCacheAdd(), and U32AccelCacheFind().

U32AccelCacheLock

CRITICAL_SECTION U32AccelCacheLock

Definition at line 54 of file accel.c.

Referenced by Cleanup(), ClientThreadSetupHelper(), DestroyAcceleratorTable(), and U32LoadAccelerators().