XkbcInternAtom(char *name, Bool onlyIfExists);
extern char *
-XkbConfigText(unsigned config);
+XkbcAtomText(Atom atm);
extern char *
-XkbActionTypeText(unsigned type);
+XkbcModMaskText(unsigned mask, Bool cFormat);
+
+extern char *
+XkbcConfigText(unsigned config);
+
+extern char *
+XkbcGeomFPText(int val);
+
+extern char *
+XkbcActionTypeText(unsigned type);
+
+extern char *
+XkbcKeysymText(KeySym sym);
+
+extern char *
+XkbcKeyNameText(char *name);
+
+extern char *
+XkbcSIMatchText(unsigned type);
_XFUNCPROTOEND
#include <config.h>
#endif
#include "X11/extensions/XKBcommon.h"
+#include "XKBcommonint.h"
+#include <X11/extensions/XKM.h>
+#include <stdio.h>
+#include <string.h>
+#include <ctype.h>
+
+#define BUFFER_SIZE 512
+static char textBuffer[BUFFER_SIZE];
+static int tbNext = 0;
+
+static char *
+tbGetBuffer(unsigned size)
+{
+ char *rtrn;
+
+ if (size >= BUFFER_SIZE)
+ return NULL;
+
+ if ((BUFFER_SIZE - tbNext) <= size)
+ tbNext = 0;
+
+ rtrn = &textBuffer[tbNext];
+ tbNext += size;
+
+ return rtrn;
+}
+
+static char *
+XkbStringText(char *str)
+{
+ char *buf, *in, *out;
+ int len;
+ Bool ok;
+
+ if (!str) {
+ buf = tbGetBuffer(2);
+ buf[0] = '\0';
+ return buf;
+ }
+
+ /* Find if there are any non-printable characters */
+ for (ok = True, len = 0, in = str; *in != '\0'; in++, len++) {
+ if (isprint(*in))
+ continue;
+
+ ok = False;
+ switch (*in) {
+ case '\n': case '\t': case '\v':
+ case '\b': case '\r': case '\f':
+ len++;
+ break;
+ default:
+ /* octal: \0ooo */
+ len += 4;
+ break;
+ }
+ }
+
+ if (ok)
+ return str;
+
+ /* Cleanup non-printable characters */
+ buf = tbGetBuffer(len + 1);
+ for (in = str, out = buf; *in != '\0'; in++) {
+ if (isprint(*in)) {
+ *out++ = *in;
+ continue;
+ }
+
+ *out++ = '\\';
+ switch (*in) {
+ case '\n':
+ *out++ = 'n';
+ break;
+ case '\t':
+ *out++ = 't';
+ break;
+ case '\v':
+ *out++ = 'v';
+ break;
+ case '\b':
+ *out++ = 'b';
+ break;
+ case '\r':
+ *out++ = 'r';
+ break;
+ case '\f':
+ *out++ = 'f';
+ break;
+ default:
+ *out++ = '0';
+ snprintf(out, 3, "%o", *in);
+ while (*out != '\0')
+ out++;
+ }
+ }
+
+ *out++ = '\0';
+ return buf;
+}
+
+char *
+XkbcAtomText(Atom atm)
+{
+ char *tmp, *rtrn;
+ int len;
+
+ tmp = XkbcAtomGetString(atm);
+
+ if (!tmp)
+ return "";
+
+ len = strlen(tmp) + 1;
+ if (len >= BUFFER_SIZE)
+ len = BUFFER_SIZE - 2;
+
+ rtrn = tbGetBuffer(len);
+ strncpy(rtrn, tmp, len);
+ rtrn[len] = '\0';
+
+ _XkbFree(tmp);
+
+ return XkbStringText(rtrn);
+}
+
+static char *modNames[XkbNumModifiers] = {
+ "Shift",
+ "Lock",
+ "Control",
+ "Mod1",
+ "Mod2",
+ "Mod3",
+ "Mod4",
+ "Mod5"
+};
char *
-XkbConfigText(unsigned config)
+XkbcModMaskText(unsigned mask, Bool cFormat)
+{
+ int i, rem, bit;
+ char *str, *buf;
+
+ if ((mask & 0xff) == 0xff)
+ return (cFormat ? "0xff" : "all");
+
+ if ((mask & 0xff) == 0)
+ return (cFormat ? "0" : "none");
+
+ rem = 64;
+ buf = tbGetBuffer(rem);
+ str = buf;
+ buf[0] = '\0';
+ for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) {
+ int len;
+
+ if (!(mask & bit))
+ continue;
+
+ len = snprintf(str, rem, "%s%s%s",
+ (str != buf) ? (cFormat ? "|" : "+") : "",
+ modNames[i],
+ cFormat ? "Mask" : "");
+ rem -= len;
+ str += len;
+ }
+
+ return buf;
+}
+
+char *
+XkbcConfigText(unsigned config)
{
switch (config) {
case XkmSemanticsFile:
}
}
+char *
+XkbcGeomFPText(int val)
+{
+ char *buf;
+ int whole, frac;
+
+ buf = tbGetBuffer(12);
+ whole = val / XkbGeomPtsPerMM;
+ frac = val % XkbGeomPtsPerMM;
+
+ if (frac != 0)
+ snprintf(buf, 12, "%d.%d", whole, frac);
+ else
+ snprintf(buf, 12, "%d", whole);
+
+ return buf;
+}
+
static char *actionTypeNames[XkbSA_NumActions]= {
"NoAction", /* XkbSA_NoAction */
"SetMods", /* XkbSA_SetMods */
};
char *
-XkbActionTypeText(unsigned type)
+XkbcActionTypeText(unsigned type)
{
if (type <= XkbSA_LastAction)
return actionTypeNames[type];
return "Private";
}
+
+char *
+XkbcKeysymText(KeySym sym)
+{
+ char *buf;
+
+ if (sym == NoSymbol)
+ return "NoSymbol";
+
+ if ((buf = XkbcKeysymToString(sym)))
+ return buf;
+
+ buf = tbGetBuffer(32);
+ snprintf(buf, 32, "0x%lx", (long)sym);
+ return buf;
+}
+
+char *
+XkbcKeyNameText(char *name)
+{
+ char *buf;
+ int len;
+
+ buf = tbGetBuffer(7);
+ buf[0] = '<';
+ strncpy(&buf[1], name, 4);
+ buf[5] = '\0';
+ len = strlen(buf);
+ buf[len++] = '>';
+ buf[len] = '\0';
+
+ return buf;
+}
+
+static char *siMatchText[5] = {
+ "NoneOf", /* XkbSI_NoneOf */
+ "AnyOfOrNone", /* XkbSI_AnyOfOrNone */
+ "AnyOf", /* XkbSI_AnyOf */
+ "AllOf", /* XkbSI_AllOf */
+ "Exactly" /* XkbSI_Exactly */
+};
+
+char *
+XkbcSIMatchText(unsigned type)
+{
+ char *buf;
+
+ switch (type & XkbSI_OpMask) {
+ case XkbSI_NoneOf:
+ return siMatchText[0];
+ case XkbSI_AnyOfOrNone:
+ return siMatchText[1];
+ case XkbSI_AnyOf:
+ return siMatchText[2];
+ case XkbSI_AllOf:
+ return siMatchText[3];
+ case XkbSI_Exactly:
+ return siMatchText[4];
+ default:
+ buf = tbGetBuffer(40);
+ snprintf(buf, 40, "0x%x", type & XkbSI_OpMask);
+ return buf;
+ }
+}
ReportMismatch(unsigned action, unsigned field, const char *type)
{
ERROR2("Value of %s field must be of type %s\n", fieldText(field), type);
- ACTION1("Action %s definition ignored\n", XkbActionTypeText(action));
+ ACTION1("Action %s definition ignored\n", XkbcActionTypeText(action));
return False;
}
ReportIllegal(unsigned action, unsigned field)
{
ERROR2("Field %s is not defined for an action of type %s\n",
- fieldText(field), XkbActionTypeText(action));
+ fieldText(field), XkbcActionTypeText(action));
ACTION("Action definition ignored\n");
return False;
}
ReportActionNotArray(unsigned action, unsigned field)
{
ERROR2("The %s field in the %s action is not an array\n",
- fieldText(field), XkbActionTypeText(action));
+ fieldText(field), XkbcActionTypeText(action));
ACTION("Action definition ignored\n");
return False;
}
{
ERROR2("%s named %s not found\n", what, bad);
ACTION2("Ignoring the %s field of an %s action\n", fieldText(field),
- XkbActionTypeText(action));
+ XkbcActionTypeText(action));
return False;
}
{
ERROR2("Illegal group %d (must be in the range 1..%d)\n", rtrn.ival,
XkbNumKbdGroups);
- ACTION1("Action %s definition ignored\n", XkbActionTypeText(action));
+ ACTION1("Action %s definition ignored\n", XkbcActionTypeText(action));
return False;
}
if (value->op == OpNegate)
if (!FindNamedKey(xkb, tmp, &t1, True, CreateKeyNames(xkb), 0))
{
return ReportNotFound(action->type, field, "Key",
- XkbKeyNameText(rtrn.keyName.name,
- XkbMessage));
+ XkbcKeyNameText(rtrn.keyName.name));
}
act->new_key = t1;
return True;
(warningLevel > 9))
{
WARN2("Alias of %s for %s declared more than once\n",
- XkbKeyNameText(new->alias, XkbMessage),
- XkbKeyNameText(new->real, XkbMessage));
+ XkbcKeyNameText(new->alias), XkbcKeyNameText(new->real));
ACTION("First definition ignored\n");
}
}
(warningLevel > 9))
{
WARN1("Multiple definitions for alias %s\n",
- XkbKeyNameText(old->alias, XkbMessage));
+ XkbcKeyNameText(old->alias));
ACTION2("Using %s, ignoring %s\n",
- XkbKeyNameText(use, XkbMessage),
- XkbKeyNameText(ignore, XkbMessage));
+ XkbcKeyNameText(use), XkbcKeyNameText(ignore));
}
if (use != old->real)
memcpy(old->real, use, XkbKeyNameLength);
if (warningLevel > 4)
{
WARN2("Attempt to alias %s to non-existent key %s\n",
- XkbKeyNameText(info->alias, XkbMessage),
- XkbKeyNameText(info->real, XkbMessage));
+ XkbcKeyNameText(info->alias), XkbcKeyNameText(info->real));
ACTION("Ignored\n");
}
info->alias[0] = '\0';
{
WARN("Attempt to create alias with the name of a real key\n");
ACTION2("Alias \"%s = %s\" ignored\n",
- XkbKeyNameText(info->alias, XkbMessage),
- XkbKeyNameText(info->real, XkbMessage));
+ XkbcKeyNameText(info->alias),
+ XkbcKeyNameText(info->real));
}
info->alias[0] = '\0';
continue;
}
else
{
- snprintf(buf, sizeof(buf), "%s+%s(%s)",
- XkbKeysymText(si->interp.sym, XkbMessage),
- XkbSIMatchText(si->interp.match, XkbMessage),
- XkbModMaskText(si->interp.mods, XkbMessage));
+ snprintf(buf, sizeof(buf), "%s+%s(%s)",
+ XkbcKeysymText(si->interp.sym),
+ XkbcSIMatchText(si->interp.match),
+ XkbcModMaskText(si->interp.mods, False));
}
return buf;
}
*pred_rtrn = XkbSI_Exactly;
if (expr->op == ExprActionDecl)
{
- char *pred_txt =
- XkbAtomText(NULL, expr->value.action.name, XkbMessage);
+ char *pred_txt = XkbcAtomText(expr->value.action.name);
if (uStrCaseCmp(pred_txt, "noneof") == 0)
*pred_rtrn = XkbSI_NoneOf;
else if (uStrCaseCmp(pred_txt, "anyofornone") == 0)
}
else if (expr->op == ExprIdent)
{
- char *pred_txt = XkbAtomText(NULL, expr->value.str, XkbMessage);
+ char *pred_txt = XkbcAtomText(expr->value.str);
if ((pred_txt) && (uStrCaseCmp(pred_txt, "any") == 0))
{
*pred_rtrn = XkbSI_AnyOf;
}
if (!ok)
ERROR1("Cannot determine modifier index for \"%s\"\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
break;
case ExprFieldRef:
bogus = "field reference";
}
if (!ok)
ERROR1("Identifier \"%s\" of type int is unknown\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Default \"%s.%s\" of type boolean is unknown\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case OpInvert:
case OpNot:
}
if (!ok)
ERROR1("Numeric identifier \"%s\" unknown\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Numeric default \"%s.%s\" unknown\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case OpAdd:
case OpSubtract:
}
if (!ok)
ERROR1("Identifier \"%s\" of type int is unknown\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Default \"%s.%s\" of type int is unknown\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case OpAdd:
case OpSubtract:
}
if (!ok)
ERROR1("Identifier \"%s\" of type string not found\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Default \"%s.%s\" of type string not found\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case OpAdd:
left = expr->value.binary.left;
}
if (!ok)
ERROR1("Identifier \"%s\" of type string not found\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Default \"%s.%s\" of type key name not found\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case OpAdd:
if (bogus == NULL)
{
int nOut = 0;
ERROR1("Illegal identifier %s (expected one of: ",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
while (values && values->name)
{
if (nOut != 0)
}
if (!ok)
ERROR1("Identifier \"%s\" of type int is unknown\n",
- XkbAtomText(NULL, expr->value.str, XkbMessage));
+ XkbcAtomText(expr->value.str));
return ok;
case ExprFieldRef:
if (lookup)
}
if (!ok)
ERROR2("Default \"%s.%s\" of type int is unknown\n",
- XkbAtomText(NULL, expr->value.field.element, XkbMessage),
- XkbAtomText(NULL, expr->value.field.field, XkbMessage));
+ XkbcAtomText(expr->value.field.element),
+ XkbcAtomText(expr->value.field.field));
return ok;
case ExprArrayRef:
bogus = "array reference";
int dfltCornerRadius;
} ShapeInfo;
-#define shText(d,s) \
- ((s)?XkbAtomText((d),(s)->name,XkbMessage):"default shape")
+#define shText(d, s) \
+ ((s) ? XkbcAtomText((s)->name) : "default shape")
#define _GD_Priority (1<<0)
#define _GD_Top (1<<1)
KeyInfo dfltKey;
struct _SectionInfo *section;
} RowInfo;
-#define rowText(d,r) \
- ((r)?XkbAtomText((d),(r)->section->name,XkbMessage):"default")
+#define rowText(d, r) \
+ ((r) ? XkbcAtomText((r)->section->name) : "default")
#define _GOK_UnknownRow -1
typedef struct _OverlayKeyInfo
unsigned short nKeys;
OverlayKeyInfo *keys;
} OverlayInfo;
-#define oiText(d,o) ((o)?XkbAtomText((d),(o)->name,XkbMessage):"default")
+#define oiText(d, o) \
+ ((o) ? XkbcAtomText((o)->name) : "default")
#define _GS_Default (1<<0)
OverlayInfo *overlays;
struct _GeometryInfo *geometry;
} SectionInfo;
-#define scText(d,s) ((s)?XkbAtomText((d),(s)->name,XkbMessage):"default")
+#define scText(d, s) \
+ ((s) ? XkbcAtomText((s)->name) : "default")
typedef struct _GeometryInfo
{
if (di->section)
{
sprintf(buf, "%s in section %s",
- XkbAtomText(dpy, di->name, XkbMessage), scText(dpy,
- di->section));
+ XkbcAtomText(di->name), scText(dpy, di->section));
return buf;
}
- return XkbAtomText(dpy, di->name, XkbMessage);
+ return XkbcAtomText(di->name);
}
/***====================================================================***/
{
old = info->shapes;
WARN3("Unknown shape \"%s\" for %s %s\n",
- XkbAtomText(info->dpy, name, XkbMessage), type, which);
+ XkbcAtomText(name), type, which);
if (old)
{
ACTION1("Using default shape %s instead\n",
&& (warningLevel > 0)) || (warningLevel > 9))
{
WARN1("Multiple doodads named \"%s\"\n",
- XkbAtomText(info->dpy, old->name, XkbMessage));
+ XkbcAtomText(old->name));
ACTION("Using last definition\n");
}
ReplaceDoodad(old, new);
|| (warningLevel > 9))
{
WARN1("Multiple doodads named \"%s\"\n",
- XkbAtomText(info->dpy, old->name, XkbMessage));
+ XkbcAtomText(old->name));
ACTION("Using first definition\n");
}
return True;
{
WARN2
("Multiple overlays named \"%s\" for section \"%s\"\n",
- XkbAtomText(info->dpy, old->name, XkbMessage),
- XkbAtomText(info->dpy, si->name, XkbMessage));
+ XkbcAtomText(old->name), XkbcAtomText(si->name));
ACTION("Using last definition\n");
}
ClearOverlayInfo(old);
|| (warningLevel > 9))
{
WARN2("Multiple doodads named \"%s\" in section \"%s\"\n",
- XkbAtomText(info->dpy, old->name, XkbMessage),
- XkbAtomText(info->dpy, si->name, XkbMessage));
+ XkbcAtomText(old->name), XkbcAtomText(si->name));
ACTION("Using first definition\n");
}
return True;
WSGO("Couldn't allocate a new OverlayInfo\n");
ACTION2
("Overlay \"%s\" in section \"%s\" will be incomplete\n",
- XkbAtomText(info->dpy, old->name, XkbMessage),
- XkbAtomText(info->dpy, si->name, XkbMessage));
+ XkbcAtomText(old->name), XkbcAtomText(si->name));
}
return False;
}
{
WARN("Keyboard width must be positive\n");
ACTION1("Ignoring illegal keyboard width %s\n",
- XkbGeomFPText(tmp.ival, XkbMessage));
+ XkbcGeomFPText(tmp.ival));
return True;
}
if (info->widthMM != 0)
{
WARN("Keyboard width multiply defined\n");
- ACTION1("Using last definition (%s),",
- XkbGeomFPText(tmp.ival, XkbMessage));
- INFO1(" ignoring first (%s)\n",
- XkbGeomFPText(info->widthMM, XkbMessage));
+ ACTION1("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
+ INFO1(" ignoring first (%s)\n", XkbcGeomFPText(info->widthMM));
}
info->widthMM = tmp.ival;
return True;
{
WARN("Keyboard height must be positive\n");
ACTION1("Ignoring illegal keyboard height %s\n",
- XkbGeomFPText(tmp.ival, XkbMessage));
+ XkbcGeomFPText(tmp.ival));
return True;
}
if (info->heightMM != 0)
{
WARN("Keyboard height multiply defined\n");
- ACTION1("Using last definition (%s),",
- XkbGeomFPText(tmp.ival, XkbMessage));
- INFO1(" ignoring first (%s)\n",
- XkbGeomFPText(info->heightMM, XkbMessage));
+ ACTION1("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
+ INFO1(" ignoring first (%s)\n", XkbcGeomFPText(info->heightMM));
}
info->heightMM = tmp.ival;
return True;
}
if (ol->field != None)
{
- char *str = XkbAtomText(NULL, ol->field, XkbMessage);
+ char *str = XkbcAtomText(ol->field);
if ((uStrCaseCmp(str, "approximation") == 0) ||
(uStrCaseCmp(str, "approx") == 0))
{
if ((def->nKeys < 1) && (warningLevel > 3))
{
WARN2("Overlay \"%s\" in section \"%s\" has no keys\n",
- XkbAtomText(NULL, def->name, XkbMessage), scText(info->dpy,
- si));
+ XkbcAtomText(def->name), scText(info->dpy, si));
ACTION("Overlay ignored\n");
return True;
}
{
WARN1("No font size for text doodad %s\n",
ddText(info->dpy, di));
- ACTION1("Using %s point text\n",
- XkbGeomFPText(DFLT_SIZE, XkbMessage));
+ ACTION1("Using %s point text\n", XkbcGeomFPText(DFLT_SIZE));
}
di->fontSize = DFLT_SIZE;
}
WARN1("No height for text doodad %s\n",
ddText(info->dpy, di));
ACTION1("Using calculated height %s millimeters\n",
- XkbGeomFPText(size, XkbMessage));
+ XkbcGeomFPText(size));
}
di->height = size;
}
{
WARN1("No width for text doodad %s\n", ddText(info->dpy, di));
ACTION1("Using calculated width %s millimeters\n",
- XkbGeomFPText(width, XkbMessage));
+ XkbcGeomFPText(width));
}
di->width = width;
}
{
WARN3
("Key %s in section \"%s\" and overlay \"%s\"\n",
- XkbKeyNameText(key->name.name,
- XkbMessage),
- XkbAtomText(info->dpy, section->name,
- XkbMessage),
- XkbAtomText(info->dpy, oi->name, XkbMessage));
+ XkbcKeyNameText(key->name.name),
+ XkbcAtomText(section->name),
+ XkbcAtomText(oi->name));
ACTION("Overlay definition ignored\n");
}
oKey = 0;
{
WARN3
("Key %s not in \"%s\", but has an overlay key in \"%s\"\n",
- XkbKeyNameText(ki->under, XkbMessage),
- XkbAtomText(info->dpy, section->name, XkbMessage),
- XkbAtomText(info->dpy, oi->name, XkbMessage));
+ XkbcKeyNameText(ki->under),
+ XkbcAtomText(section->name),
+ XkbcAtomText(oi->name));
ACTION("Definition ignored\n");
}
}
if (oi->nKeys < 1)
{
ERROR2("Overlay \"%s\" for section \"%s\" has no legal keys\n",
- XkbAtomText(info->dpy, oi->name, XkbMessage),
- XkbAtomText(info->dpy, section->name, XkbMessage));
+ XkbcAtomText(oi->name), XkbcAtomText(section->name));
ACTION("Overlay definition ignored\n");
return False;
}
if (!ol)
{
WSGO2("Couldn't add overlay \"%s\" to section \"%s\"\n",
- XkbAtomText(info->dpy, name, XkbMessage),
- XkbAtomText(info->dpy, section->name, XkbMessage));
+ XkbcAtomText(name), XkbcAtomText(section->name));
return False;
}
for (i = 0; i < oi->nRows; i++)
{
WSGO3
("Can't add row %d to overlay \"%s\" of section \"%s\"\n",
- i, XkbAtomText(info->dpy, name, XkbMessage),
- XkbAtomText(info->dpy, section->name, XkbMessage));
+ i, XkbcAtomText(name), XkbcAtomText(section->name));
return False;
}
}
/***====================================================================***/
-#define ReportIndicatorBadType(d,l,f,w) \
- ReportBadType("indicator map",(f),\
- XkbAtomText((d),(l)->name,XkbMessage),(w))
-#define ReportIndicatorNotArray(d,l,f) \
- ReportNotArray("indicator map",(f),\
- XkbAtomText((d),(l)->name,XkbMessage))
+#define ReportIndicatorBadType(d,l,f,w) \
+ ReportBadType("indicator map", (f), XkbcAtomText((l)->name), (w))
+#define ReportIndicatorNotArray(d,l,f) \
+ ReportNotArray("indicator map", (f), XkbcAtomText((l)->name))
/***====================================================================***/
&& (warningLevel > 0)) || (warningLevel > 9))
{
WARN1("Map for indicator %s redefined\n",
- XkbAtomText(NULL, old->name, XkbMessage));
+ XkbcAtomText(old->name));
ACTION("Earlier definition ignored\n");
}
*old = *new;
if (collide)
{
WARN1("Map for indicator %s redefined\n",
- XkbAtomText(NULL, old->name, XkbMessage));
+ XkbcAtomText(old->name));
ACTION1("Using %s definition for duplicate fields\n",
(new->defs.merge == MergeAugment ? "first" : "last"));
}
{
WSGO("Couldn't allocate indicator map\n");
ACTION1("Map for indicator %s not compiled\n",
- XkbAtomText(NULL, new->name, XkbMessage));
+ XkbcAtomText(new->name));
return NULL;
}
*old = *new;
ERROR2("Illegal indicator index %d (range 1..%d)\n",
rtrn.uval, XkbNumIndicators);
ACTION1("Index definition for %s indicator ignored\n",
- XkbAtomText(NULL, led->name, XkbMessage));
+ XkbcAtomText(led->name));
return False;
}
led->indicator = rtrn.uval;
else
{
ERROR2("Unknown field %s in map for %s indicator\n", field,
- XkbAtomText(NULL, led->name, XkbMessage));
+ XkbcAtomText(led->name));
ACTION("Definition ignored\n");
ok = False;
}
char buf[4];
LongToKeyName(val, buf);
- return XkbKeyNameText(buf, format);
+ return XkbcKeyNameText(buf);
}
/***====================================================================***/
if (((old->defs.fileID == new->defs.fileID) && (warningLevel > 0))
|| (warningLevel > 9))
{
- WARN1("Multiple indicators named %s\n",
- XkbAtomText(NULL, new->name, XkbMessage));
+ WARN1("Multiple indicators named %s\n", XkbcAtomText(new->name));
if (old->ndx == new->ndx)
{
if (old->virtual != new->virtual)
ignoring = new->name;
}
ACTION4("Using %s %s, ignoring %s %s\n",
- oldType, XkbAtomText(NULL, using, XkbMessage),
- newType, XkbAtomText(NULL, ignoring, XkbMessage));
+ oldType, XkbcAtomText(using),
+ newType, XkbcAtomText(ignoring));
}
}
if (replace)
{
LongToKeyName(info.names[i], xkb->names->keys[i].name);
uDEBUG2(2, "key %d = %s\n", i,
- XkbKeyNameText(xkb->names->keys[i].name, XkbMessage));
+ XkbcKeyNameText(xkb->names->keys[i].name));
}
}
else
break;
default:
ERROR1("Cannot compile %s alone into an XKM file\n",
- XkbConfigText(mainType));
+ XkbcConfigText(mainType));
return False;
}
have = 0;
if ((have & (1 << file->type)) != 0)
{
ERROR2("More than one %s section in a %s file\n",
- XkbConfigText(file->type), XkbConfigText(mainType));
+ XkbcConfigText(file->type), XkbcConfigText(mainType));
ACTION("All sections after the first ignored\n");
ok = False;
}
else if ((1 << file->type) & (~legal))
{
ERROR2("Cannot define %s in a %s file\n",
- XkbConfigText(file->type), XkbConfigText(mainType));
+ XkbcConfigText(file->type), XkbcConfigText(mainType));
ok = False;
}
else
case XkmLayoutFile:
case XkmKeymapFile:
WSGO2("Illegal %s configuration in a %s file\n",
- XkbConfigText(file->type), XkbConfigText(mainType));
+ XkbcConfigText(file->type), XkbcConfigText(mainType));
ACTION("Ignored\n");
ok = False;
break;
case XkmVirtualModsIndex:
case XkmIndicatorsIndex:
WSGO1("Found an isolated %s section\n",
- XkbConfigText(file->type));
+ XkbcConfigText(file->type));
break;
default:
WSGO1("Unknown file type %d\n", file->type);
if (missing & bit)
{
ERROR2("Missing %s section in a %s file\n",
- XkbConfigText(i), XkbConfigText(mainType));
+ XkbcConfigText(i), XkbcConfigText(mainType));
missing &= ~bit;
}
}
ACTION1("Description of %s not compiled\n",
- XkbConfigText(mainType));
+ XkbcConfigText(mainType));
ok = False;
}
ok = BindIndicators(xkb, True, unbound, NULL);
XkbVModMaskText((t)->dpy,(x),(p)->indexMods,(p)->indexVMods,XkbMessage)
#define PreserveTxt(t,x,p) \
XkbVModMaskText((t)->dpy,(x),(p)->preMods,(p)->preVMods,XkbMessage)
-#define TypeTxt(t) XkbAtomText((t)->dpy,(t)->name,XkbMessage)
+#define TypeTxt(t) XkbcAtomText((t)->name)
#define TypeMaskTxt(t,x) \
XkbVModMaskText((t)->dpy,(x),(t)->mask,(t)->vmask,XkbMessage)
if (warningLevel > 0)
{
char *old, *new;
- old = XkbAtomText(type->dpy, type->lvlNames[level], XkbMessage);
- new = XkbAtomText(type->dpy, name, XkbMessage);
+ old = XkbcAtomText(type->lvlNames[level]);
+ new = XkbcAtomText(name);
WARN2("Multiple names for level %d of key type %s\n",
level + 1, TypeTxt(type));
if (clobber)
ERROR3("Level name %d out of range (1..%d) in key type %s\n",
rtrn.ival,
XkbMaxShiftLevel + 1,
- XkbAtomText(type->dpy, type->name, XkbMessage));
+ XkbcAtomText(type->name));
ACTION("Ignoring illegal level name definition\n");
return False;
}
if (!ExprResolveString(value, &rtrn, NULL, NULL))
{
ERROR2("Non-string name for level %d in key type %s\n", level + 1,
- XkbAtomText(type->dpy, type->name, XkbMessage));
+ XkbcAtomText(type->name));
ACTION("Ignoring illegal level name definition\n");
return False;
}
if (type->defs.defined & _KT_Mask)
{
WARN1("Multiple modifier mask definitions for key type %s\n",
- XkbAtomText(type->dpy, type->name, XkbMessage));
+ XkbcAtomText(type->name));
ACTION1("Using %s, ", TypeMaskTxt(type, xkb));
INFO1("ignoring %s\n", XkbVModMaskText(type->dpy, xkb, mods,
vmods, XkbMessage));
{
WARN("Couldn't allocate preserve array in CopyDefToKeyType\n");
ACTION1("Preserve setting for type %s lost\n",
- XkbAtomText(def->dpy, def->name, XkbMessage));
+ XkbcAtomText(def->name));
}
else
{
if (!mapToUse)
{
ERROR3("No %s named \"%s\" in the include file \"%s\"\n",
- XkbConfigText(file_type), stmt->map, stmt->file);
+ XkbcConfigText(file_type), stmt->map, stmt->file);
ACTION("Exiting\n");
return False;
}
if (mapToUse->type != file_type)
{
ERROR2("Include file wrong type (expected %s, got %s)\n",
- XkbConfigText(file_type), XkbConfigText(mapToUse->type));
+ XkbcConfigText(file_type), XkbcConfigText(mapToUse->type));
ACTION1("Include file \"%s\" ignored\n", stmt->file);
return False;
}
{
WARN1
("Several keys match pattern for %s\n",
- XkbKeyNameText(name->name, XkbMessage));
+ XkbcKeyNameText(name->name));
ACTION2("Using <U%03d> for key %d\n",
nUnknown, i);
}
("Multiple symbols for level %d/group %d on key %s\n",
i + 1, group + 1, longText(into->name, XkbMessage));
ACTION2("Using %s, ignoring %s\n",
- XkbKeysymText(use, XkbMessage),
- XkbKeysymText(ignore, XkbMessage));
+ XkbcKeysymText(use), XkbcKeysymText(ignore));
}
resultSyms[i] = use;
}
("Multiple actions for level %d/group %d on key %s\n",
i + 1, group + 1, longText(into->name, XkbMessage));
ACTION2("Using %s, ignoring %s\n",
- XkbActionTypeText(use->type),
- XkbActionTypeText(ignore->type));
+ XkbcActionTypeText(use->type),
+ XkbcActionTypeText(ignore->type));
}
resultActs[i] = *use;
}
("Multiple definitions for group %d type of key %s\n",
i, longText(into->name, XkbMessage));
ACTION2("Using %s, ignoring %s\n",
- XkbAtomText(NULL, use, XkbMessage),
- XkbAtomText(NULL, ignore, XkbMessage));
+ XkbcAtomText(use),
+ XkbcAtomText(ignore));
}
if ((from->defs.merge != MergeAugment)
|| (into->types[i] == None))
}
ERROR1
("%s added to symbol map for multiple modifiers\n",
- XkbKeysymText(new->u.keySym, XkbMessage));
+ XkbcKeysymText(new->u.keySym));
ACTION2("Using %s, ignoring %s.\n",
XkbModIndexText(use, XkbMessage),
XkbModIndexText(ignore, XkbMessage));
{
ERROR("Illegal modifier map definition\n");
ACTION1("Ignoring map for non-modifier \"%s\"\n",
- XkbAtomText(NULL, def->modifier, XkbMessage));
+ XkbcAtomText(def->modifier));
return False;
}
ok = True;
{
WARN2("Key %s not found in %s keycodes\n",
longText(key->name, XkbMessage),
- XkbAtomText(NULL, xkb->names->keycodes, XkbMessage));
+ XkbcAtomText(xkb->names->keycodes));
ACTION("Symbols ignored\n");
}
return False;
WARN1("No automatic type for %d symbols\n",
(unsigned int) key->numLevels[i]);
ACTION3("Using %s for the %s key (keycode %d)\n",
- XkbAtomText(NULL, key->types[i],
- XkbMessage),
+ XkbcAtomText(key->types[i]),
longText(key->name, XkbMessage), kc);
}
}
if (warningLevel >= 3)
{
WARN1("Type \"%s\" is not defined\n",
- XkbAtomText(NULL, key->types[i], XkbMessage));
+ XkbcAtomText(key->types[i]));
ACTION2("Using TWO_LEVEL for the %s key (keycode %d)\n",
longText(key->name, XkbMessage), kc);
}
{
WARN4
("Type \"%s\" has %d levels, but %s has %d symbols\n",
- XkbAtomText(NULL, type->name, XkbMessage),
+ XkbcAtomText(type->name),
(unsigned int) type->num_levels,
longText(key->name, XkbMessage),
(unsigned int) key->numLevels[i]);
{
WARN2("Key %s not found in %s keycodes\n",
longText(key->nameForOverlayKey, XkbMessage),
- XkbAtomText(NULL, xkb->names->keycodes, XkbMessage));
+ XkbcAtomText(xkb->names->keycodes));
ACTION1("Not treating %s as an overlay key \n",
longText(key->name, XkbMessage));
}
{
WARN2("Key %s not found in %s keycodes\n",
longText(entry->u.keyName, XkbMessage),
- XkbAtomText(NULL, xkb->names->keycodes, XkbMessage));
+ XkbcAtomText(xkb->names->keycodes));
ACTION1("Modifier map entry for %s not updated\n",
XkbModIndexText(entry->modifier, XkbMessage));
}
if (warningLevel > 5)
{
WARN2("Key \"%s\" not found in %s symbol map\n",
- XkbKeysymText(entry->u.keySym, XkbMessage),
- XkbAtomText(NULL, xkb->names->symbols, XkbMessage));
+ XkbcKeysymText(entry->u.keySym),
+ XkbcAtomText(xkb->names->symbols));
ACTION1("Modifier map entry for %s not updated\n",
XkbModIndexText(entry->modifier, XkbMessage));
}
const char *str2 = "";
if (!ExprResolveModMask(stmt->value, &mod, NULL, NULL))
{
- str1 = XkbAtomText(NULL, stmt->name, XkbMessage);
+ str1 = XkbcAtomText(stmt->name);
ACTION1("Declaration of %s ignored\n", str1);
return False;
}
if (mod.uval == srv->vmods[i])
return True;
- str1 = XkbAtomText(NULL, stmt->name, XkbMessage);
+ str1 = XkbcAtomText(stmt->name);
WARN1("Virtual modifier %s multiply defined\n", str1);
- str1 = XkbModMaskText(srv->vmods[i], XkbCFile);
+ str1 = XkbcModMaskText(srv->vmods[i], True);
if (mergeMode == MergeOverride)
{
str2 = str1;
- str1 = XkbModMaskText(mod.uval, XkbCFile);
+ str1 = XkbcModMaskText(mod.uval, True);
}
ACTION2("Using %s, ignoring %s\n", str1, str2);
if (mergeMode == MergeOverride)
return True;
}
ACTION1("Declaration of %s ignored\n",
- XkbAtomText(NULL, stmt->name, XkbMessage));
+ XkbcAtomText(stmt->name));
return False;
}
projects / profile / ivi / libxkbcommon.git / commitdiff