#include <X11/extensions/XKB.h>
typedef uint32_t xkb_keycode_t;
+typedef uint32_t xkb_keysym_t;
#define XKB_KEYCODE_MAX (0xffffffff - 1)
#define xkb_keycode_is_legal_ext(kc) (kc <= XKB_KEYCODE_MAX)
};
struct xkb_sym_interpret {
- uint32_t sym;
+ xkb_keysym_t sym;
unsigned char flags;
unsigned char match;
uint8_t mods; /* XXX real or virt? */
uint32_t size_syms;
uint32_t num_syms;
- uint32_t *syms;
+ xkb_keysym_t *syms;
struct xkb_sym_map * key_sym_map;
unsigned char *modmap;
* client and server (no, really).
*/
_X_EXPORT extern void
-xkb_keysym_to_string(uint32_t ks, char *buffer, size_t size);
+xkb_keysym_to_string(xkb_keysym_t ks, char *buffer, size_t size);
/*
* See xkb_keysym_to_string comments: this function will accept any string
* from that function.
*/
-_X_EXPORT extern uint32_t
+_X_EXPORT extern xkb_keysym_t
xkb_string_to_keysym(const char *s);
_XFUNCPROTOEND
#include "ks_tables.h"
void
-xkb_keysym_to_string(uint32_t ks, char *buffer, size_t size)
+xkb_keysym_to_string(xkb_keysym_t ks, char *buffer, size_t size)
{
int i, n, h, idx;
const unsigned char *entry;
snprintf(buffer, size, "0x%08x", ks);
}
-uint32_t
+xkb_keysym_t
xkb_string_to_keysym(const char *s)
{
int i, n, h, c, idx;
const char *p = s;
const unsigned char *entry;
unsigned char sig1, sig2;
- uint32_t val;
+ xkb_keysym_t val;
while ((c = *p++))
sig = (sig << 1) + c;
* no separating underscore, while some XF86* syms in the latter did.
* As a last ditch effort, try without. */
if (strncmp(s, "XF86_", 5) == 0) {
- uint32_t ret;
+ xkb_keysym_t ret;
char *tmp = strdup(s);
if (!tmp)
return NoSymbol;
if (!map->syms) {
map->size_syms = (nKeys * 15) / 10;
- map->syms = _XkbTypedCalloc(map->size_syms, uint32_t);
+ map->syms = _XkbTypedCalloc(map->size_syms, xkb_keysym_t);
if (!map->syms) {
map->size_syms = 0;
return BadAlloc;
return Success;
}
-uint32_t *
+xkb_keysym_t *
XkbcResizeKeySyms(struct xkb_desc * xkb, xkb_keycode_t key,
unsigned int needed)
{
uint32_t i, nSyms, nKeySyms;
uint32_t nOldSyms;
- uint32_t *newSyms;
+ xkb_keysym_t *newSyms;
if (needed == 0) {
xkb->map->key_sym_map[key].offset = 0;
if (xkb->map->size_syms - xkb->map->num_syms >= needed) {
if (nOldSyms > 0)
memcpy(&xkb->map->syms[xkb->map->num_syms],
- XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(uint32_t));
+ XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(xkb_keysym_t));
if ((needed - nOldSyms) > 0)
memset(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],
- 0, (needed - nOldSyms) * sizeof(uint32_t));
+ 0, (needed - nOldSyms) * sizeof(xkb_keysym_t));
xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
xkb->map->num_syms += needed;
}
xkb->map->size_syms += (needed > 32 ? needed : 32);
- newSyms = _XkbTypedCalloc(xkb->map->size_syms, uint32_t);
+ newSyms = _XkbTypedCalloc(xkb->map->size_syms, xkb_keysym_t);
if (!newSyms)
return NULL;
nKeySyms = needed;
if (nCopy != 0)
memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
- nCopy * sizeof(uint32_t));
+ nCopy * sizeof(xkb_keysym_t));
if (nKeySyms > nCopy)
memset(&newSyms[nSyms + nCopy], 0,
- (nKeySyms - nCopy) * sizeof(uint32_t));
+ (nKeySyms - nCopy) * sizeof(xkb_keysym_t));
xkb->map->key_sym_map[i].offset = nSyms;
nSyms += nKeySyms;
}
unsigned
-_XkbcKSCheckCase(uint32_t ks)
+_XkbcKSCheckCase(xkb_keysym_t ks)
{
unsigned set = (ks & (~0xff)) >> 8;
unsigned rtrn = 0;
}
const char *
-XkbcKeysymText(uint32_t sym)
+XkbcKeysymText(xkb_keysym_t sym)
{
static char buffer[16];
extern int
XkbcCopyKeyType(struct xkb_key_type * from, struct xkb_key_type *into);
-extern uint32_t *
+extern xkb_keysym_t *
XkbcResizeKeySyms(struct xkb_desc * xkb, xkb_keycode_t key, uint32_t needed);
extern union xkb_action *
ExprResult * val_rtrn)
{
int ok = 0;
- uint32_t sym;
+ xkb_keysym_t sym;
if (expr->op == ExprIdent)
{
}
int
-LookupKeysym(char *str, uint32_t * sym_rtrn)
+LookupKeysym(char *str, xkb_keysym_t * sym_rtrn)
{
- uint32_t sym;
+ xkb_keysym_t sym;
if ((!str) || (uStrCaseCmp(str, "any") == 0)
|| (uStrCaseCmp(str, "nosymbol") == 0))
);
extern int LookupKeysym(char * /* str */ ,
- uint32_t * /* sym_rtrn */
+ xkb_keysym_t * /* sym_rtrn */
);
extern IncludeStmt *IncludeCreate(char * /* str */ ,
unsigned char symsDefined;
unsigned char actsDefined;
short numLevels[XkbNumKbdGroups];
- uint32_t *syms[XkbNumKbdGroups];
+ xkb_keysym_t *syms[XkbNumKbdGroups];
union xkb_action *acts[XkbNumKbdGroups];
uint32_t types[XkbNumKbdGroups];
unsigned repeat;
width = new->numLevels[i];
if (old->syms[i] != NULL)
{
- new->syms[i] = uTypedCalloc(width, uint32_t);
+ new->syms[i] = uTypedCalloc(width, xkb_keysym_t);
if (!new->syms[i])
{
new->syms[i] = NULL;
new->numLevels[i] = 0;
return False;
}
- memcpy(new->syms[i], old->syms[i], width * sizeof(uint32_t));
+ memcpy(new->syms[i], old->syms[i], width * sizeof(xkb_keysym_t));
}
if (old->acts[i] != NULL)
{
union
{
unsigned long keyName;
- uint32_t keySym;
+ xkb_keysym_t keySym;
} u;
} ModMapEntry;
{
key->syms[group] = uTypedRecalloc(key->syms[group],
key->numLevels[group], newWidth,
- uint32_t);
+ xkb_keysym_t);
if (!key->syms[group])
return False;
}
MergeKeyGroups(SymbolsInfo * info,
KeyInfo * into, KeyInfo * from, unsigned group)
{
- uint32_t *resultSyms;
+ xkb_keysym_t *resultSyms;
union xkb_action *resultActs;
int resultWidth;
int i;
}
if (resultSyms == NULL)
{
- resultSyms = uTypedCalloc(resultWidth, uint32_t);
+ resultSyms = uTypedCalloc(resultWidth, xkb_keysym_t);
if (!resultSyms)
{
WSGO("Could not allocate symbols for group merge\n");
}
for (i = 0; i < resultWidth; i++)
{
- uint32_t fromSym, toSym;
+ xkb_keysym_t fromSym, toSym;
if (from->syms[group] && (i < from->numLevels[group]))
fromSym = from->syms[group][i];
else
resultSyms[i] = fromSym;
else
{
- uint32_t use, ignore;
+ xkb_keysym_t use, ignore;
if (clobber)
{
use = fromSym;
}
static Bool
-FindKeyForSymbol(struct xkb_desc * xkb, uint32_t sym, xkb_keycode_t *kc_rtrn)
+FindKeyForSymbol(struct xkb_desc * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn)
{
int i, j;
Bool gotOne;
* @returns True if a type could be found, False otherwise.
*/
static Bool
-FindAutomaticType(int width, uint32_t * syms, uint32_t * typeNameRtrn,
+FindAutomaticType(int width, xkb_keysym_t * syms, xkb_atom_t * typeNameRtrn,
Bool * autoType)
{
*autoType = False;
}
if ((key->symsDefined & 1) && key->syms[0])
{
- key->syms[i] = uTypedCalloc(width, uint32_t);
+ key->syms[i] = uTypedCalloc(width, xkb_keysym_t);
if (key->syms[i] == NULL)
continue;
- memcpy(key->syms[i], key->syms[0], width * sizeof(uint32_t));
+ memcpy(key->syms[i], key->syms[0], width * sizeof(xkb_keysym_t));
key->symsDefined |= 1 << i;
}
if (defined & 1)
if ((key->syms[i] != key->syms[0]) &&
(key->syms[i] == NULL || key->syms[0] == NULL ||
memcmp(key->syms[i], key->syms[0],
- sizeof(uint32_t) * key->numLevels[0])))
+ sizeof(xkb_keysym_t) * key->numLevels[0])))
{
identical = False;
break;
unsigned width, tmp, nGroups;
struct xkb_key_type * type;
Bool haveActions, autoType, useAlias;
- uint32_t *outSyms;
+ xkb_keysym_t *outSyms;
union xkb_action *outActs;
unsigned types[XkbNumKbdGroups];
XkbcEnsureSafeMapName(char *name);
extern unsigned
-_XkbcKSCheckCase(uint32_t sym);
+_XkbcKSCheckCase(xkb_keysym_t sym);
#define _XkbKSLower (1 << 0)
#define _XkbKSUpper (1 << 1)
XkbcActionTypeText(unsigned type);
extern const char *
-XkbcKeysymText(uint32_t sym);
+XkbcKeysymText(xkb_keysym_t sym);
extern const char *
XkbcKeyNameText(char *name);