********************************************************/
#include "xkbcomp.h"
+#include "xkballoc.h"
+#include "xkbgeom.h"
+#include "xkbmisc.h"
#include "tokens.h"
#include "expr.h"
#include "vmod.h"
#include "keycodes.h"
#include "alias.h"
-#include <X11/extensions/XKBgeomcommon.h>
-
#define DFLT_FONT "helvetica"
#define DFLT_SLANT "r"
#define DFLT_WEIGHT "medium"
typedef struct _ShapeInfo
{
CommonInfo defs;
- Atom name;
+ uint32_t name;
short index;
unsigned short nOutlines;
unsigned short szOutlines;
- XkbOutlinePtr outlines;
- XkbOutlinePtr approx;
- XkbOutlinePtr primary;
+ struct xkb_outline * outlines;
+ struct xkb_outline * approx;
+ struct xkb_outline * primary;
int dfltCornerRadius;
} ShapeInfo;
typedef struct _DoodadInfo
{
CommonInfo defs;
- Atom name;
+ uint32_t name;
unsigned char type;
unsigned char priority;
short top;
unsigned short corner;
unsigned short width;
unsigned short height;
- Atom shape;
- Atom color;
- Atom offColor;
- Atom text;
- Atom font;
- Atom fontSlant;
- Atom fontWeight;
- Atom fontSetWidth;
- Atom fontVariant;
+ uint32_t shape;
+ uint32_t color;
+ uint32_t offColor;
+ uint32_t text;
+ uint32_t font;
+ uint32_t fontSlant;
+ uint32_t fontWeight;
+ uint32_t fontSetWidth;
+ uint32_t fontVariant;
unsigned short fontSize;
- Atom fontEncoding;
- Atom fontSpec;
+ uint32_t fontEncoding;
+ uint32_t fontSpec;
char *logoName;
struct _SectionInfo *section;
} DoodadInfo;
char name[8];
short gap;
short index;
- Atom shape;
- Atom color;
+ uint32_t shape;
+ uint32_t color;
struct _RowInfo *row;
} KeyInfo;
#define keyText(k) ((k)&&(k)->name[0]?(k)->name:"default")
typedef struct _OverlayInfo
{
CommonInfo defs;
- Atom name;
+ uint32_t name;
unsigned short nRows;
unsigned short nKeys;
OverlayKeyInfo *keys;
typedef struct _SectionInfo
{
CommonInfo defs;
- Atom name;
+ uint32_t name;
unsigned short top;
unsigned short left;
unsigned short width;
DoodadInfo *doodads;
int widthMM;
int heightMM;
- Atom font;
- Atom fontSlant;
- Atom fontWeight;
- Atom fontSetWidth;
- Atom fontVariant;
+ uint32_t font;
+ uint32_t fontSlant;
+ uint32_t fontWeight;
+ uint32_t fontSetWidth;
+ uint32_t fontVariant;
unsigned fontSize;
- Atom fontEncoding;
- Atom fontSpec;
- Atom baseColor;
- Atom labelColor;
+ uint32_t fontEncoding;
+ uint32_t fontSpec;
+ uint32_t baseColor;
+ uint32_t labelColor;
int dfltCornerRadius;
SectionInfo dfltSection;
DoodadInfo *dfltDoodads;
AliasInfo *aliases;
} GeometryInfo;
-static char *
+static const char *
ddText(DoodadInfo * di)
{
static char buf[64];
for (tmp = pi; tmp != NULL; tmp = next)
{
if (tmp->name)
- uFree(tmp->name);
+ free(tmp->name);
if (tmp->value)
- uFree(tmp->value);
+ free(tmp->value);
tmp->name = tmp->value = NULL;
next = (PropertyInfo *) tmp->defs.next;
- uFree(tmp);
+ free(tmp);
}
return;
}
{
ClearKeyInfo(tmp);
next = (KeyInfo *) tmp->defs.next;
- uFree(tmp);
+ free(tmp);
}
return;
}
{
ClearRowInfo(tmp, info);
next = (RowInfo *) tmp->defs.next;
- uFree(tmp);
+ free(tmp);
}
return;
}
}
static DoodadInfo *
-FindDoodadByName(DoodadInfo * di, Atom name)
+FindDoodadByName(DoodadInfo * di, uint32_t name)
{
while (di)
{
{
next = (DoodadInfo *) tmp->defs.next;
ClearDoodadInfo(tmp);
- uFree(tmp);
+ free(tmp);
}
return;
}
{
*si = info->dfltSection;
si->defs.defined &= ~_GS_Default;
- si->name = XkbcInternAtom("unknown", False);
+ si->name = xkb_intern_atom("unknown");
si->priority = info->nextPriority++;
if (info->nextPriority > XkbGeomMaxPriority)
info->nextPriority = XkbGeomMaxPriority;
si->defs.merge = info->merge;
si->defs.next = NULL;
si->geometry = info;
- si->name = XkbcInternAtom("default", False);
+ si->name = xkb_intern_atom("default");
InitRowInfo(&si->dfltRow, si, info);
}
return;
{
si->defs.defined &= ~_GS_Default;
- si->name = XkbcInternAtom("default", False);
+ si->name = xkb_intern_atom("default");
si->top = si->left = 0;
si->width = si->height = 0;
si->angle = 0;
{
ClearSectionInfo(tmp, info);
next = (SectionInfo *) tmp->defs.next;
- uFree(tmp);
+ free(tmp);
}
return;
}
{
if (tmp->outlines[i].points != NULL)
{
- uFree(tmp->outlines[i].points);
+ free(tmp->outlines[i].points);
tmp->outlines[i].num_points = 0;
tmp->outlines[i].points = NULL;
}
}
- uFree(tmp->outlines);
+ free(tmp->outlines);
tmp->szOutlines = 0;
tmp->nOutlines = 0;
tmp->outlines = NULL;
tmp->primary = tmp->approx = NULL;
}
next = (ShapeInfo *) tmp->defs.next;
- uFree(tmp);
+ free(tmp);
}
return;
}
ClearGeometryInfo(GeometryInfo * info)
{
if (info->name)
- uFree(info->name);
+ free(info->name);
info->name = NULL;
if (info->props)
FreeProperties(info->props, info);
new->value);
}
if (old->value)
- uFree(old->value);
+ free(old->value);
old->value = _XkbDupString(new->value);
return True;
}
}
static ShapeInfo *
-FindShape(GeometryInfo * info, Atom name, const char *type, const char *which)
+FindShape(GeometryInfo * info, uint32_t name, const char *type, const char *which)
{
ShapeInfo *old;
static DoodadInfo *
FindDfltDoodadByTypeName(char *name, SectionInfo * si, GeometryInfo * info)
{
- DoodadInfo *dflt;
+ DoodadInfo *dflt = NULL;
unsigned type;
if (uStrCaseCmp(name, "outline") == 0)
return NULL;
if ((si) && (si->dfltDoodads))
dflt = FindDoodadByType(si->dfltDoodads, type);
- else
- dflt = NULL;
if ((!dflt) && (info->dfltDoodads))
dflt = FindDoodadByType(info->dfltDoodads, type);
if (dflt == NULL)
}
typedef void (*FileHandler) (XkbFile * /* file */ ,
- XkbcDescPtr /* xkb */ ,
+ struct xkb_desc * /* xkb */ ,
unsigned /* merge */ ,
GeometryInfo * /* info */
);
static Bool
-HandleIncludeGeometry(IncludeStmt * stmt, XkbcDescPtr xkb, GeometryInfo * info,
+HandleIncludeGeometry(IncludeStmt * stmt, struct xkb_desc * xkb, GeometryInfo * info,
FileHandler hndlr)
{
unsigned newMerge;
if (stmt->stmt != NULL)
{
if (included.name != NULL)
- uFree(included.name);
+ free(included.name);
included.name = stmt->stmt;
stmt->stmt = NULL;
}
static int
SetShapeField(ShapeInfo * si,
- char *field,
+ const char *field,
ExprDef * arrayNdx, ExprDef * value, GeometryInfo * info)
{
ExprResult tmp;
info->errorCount++;
return ReportBadType(typeName, field, ddText(di), "string");
}
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
di->defs.defined |= _GD_Shape;
return True;
}
char *typeName = "text doodad";
union
{
- Atom *str;
+ uint32_t *str;
short *ival;
unsigned short *uval;
} pField;
return ReportBadType(typeName, field, ddText(di), "string");
}
di->defs.defined |= def;
- *pField.str = XkbcInternAtom(tmp.str, False);
+ *pField.str = xkb_intern_atom(tmp.str);
}
else
{
if (uStrCaseCmp(field, "oncolor") == 0)
{
di->defs.defined |= _GD_Color;
- di->color = XkbcInternAtom(tmp.str, False);
+ di->color = xkb_intern_atom(tmp.str);
}
else if (uStrCaseCmp(field, "offcolor") == 0)
{
di->defs.defined |= _GD_OffColor;
- di->offColor = XkbcInternAtom(tmp.str, False);
+ di->offColor = xkb_intern_atom(tmp.str);
}
else if (uStrCaseCmp(field, "shape") == 0)
{
di->defs.defined |= _GD_Shape;
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
}
return True;
}
info->errorCount++;
return ReportBadType(typeName, field, ddText(di), "string");
}
- di->shape = XkbcInternAtom(tmp.str, False);
+ di->shape = xkb_intern_atom(tmp.str);
di->defs.defined |= _GD_Shape;
return True;
}
return ReportBadType("doodad", field, ddText(di), "string");
}
di->defs.defined |= _GD_Color;
- di->color = XkbcInternAtom(tmp.str, False);
+ di->color = xkb_intern_atom(tmp.str);
+ free(tmp.str);
return True;
}
switch (di->type)
return ReportBadType("key", field, keyText(key), "string");
}
key->defs.defined |= _GK_Shape;
- key->shape = XkbcInternAtom(tmp.str, False);
+ key->shape = xkb_intern_atom(tmp.str);
+ free(tmp.str);
}
else if ((uStrCaseCmp(field, "color") == 0) ||
(uStrCaseCmp(field, "keycolor") == 0))
return ReportBadType("key", field, keyText(key), "string");
}
key->defs.defined |= _GK_Color;
- key->color = XkbcInternAtom(tmp.str, False);
+ key->color = xkb_intern_atom(tmp.str);
+ free(tmp.str);
}
else if ((uStrCaseCmp(field, "name") == 0)
|| (uStrCaseCmp(field, "keyname") == 0))
{
PropertyInfo pi;
ExprResult result;
+ int ret;
InitPropertyInfo(&pi, info);
pi.name = property;
return False;
}
pi.value = result.str;
- return AddProperty(info, &pi);
+ ret = AddProperty(info, &pi);
+ free(pi.value);
+ return ret;
}
static int
-HandleGeometryVar(VarDef * stmt, XkbcDescPtr xkb, GeometryInfo * info)
+HandleGeometryVar(VarDef * stmt, struct xkb_desc * xkb, GeometryInfo * info)
{
ExprResult elem, field, tmp;
ExprDef *ndx;
DoodadInfo *di;
- Atom *pField;
+ uint32_t *pField = NULL;
+ int ret = True; /* default to no error */
if (ExprResolveLhs(stmt->name, &elem, &field, &ndx) == 0)
return 0; /* internal error, already reported */
- if (elem.str && (uStrCaseCmp(elem.str, "shape") == 0))
- return SetShapeField(NULL, field.str, ndx, stmt->value, info);
- if (elem.str && (uStrCaseCmp(elem.str, "key") == 0))
- return SetKeyField(&info->dfltSection.dfltRow.dfltKey,
- field.str, ndx, stmt->value, info);
- if (elem.str && (uStrCaseCmp(elem.str, "row") == 0))
- return SetRowField(&info->dfltSection.dfltRow, field.str, ndx,
- stmt->value, info);
- if (elem.str && (uStrCaseCmp(elem.str, "section") == 0))
- {
- return SetSectionField(&info->dfltSection, field.str, ndx,
+
+ if (elem.str) {
+ if (uStrCaseCmp(elem.str, "shape") == 0)
+ ret = SetShapeField(NULL, field.str, ndx, stmt->value, info);
+ else if (uStrCaseCmp(elem.str, "key") == 0)
+ ret = SetKeyField(&info->dfltSection.dfltRow.dfltKey,
+ field.str, ndx, stmt->value, info);
+ else if (uStrCaseCmp(elem.str, "row") == 0)
+ ret = SetRowField(&info->dfltSection.dfltRow, field.str, ndx,
stmt->value, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "property") == 0))
- {
- if (ndx != NULL)
+ else if (uStrCaseCmp(elem.str, "section") == 0)
+ ret = SetSectionField(&info->dfltSection, field.str, ndx,
+ stmt->value, info);
+ else if (uStrCaseCmp(elem.str, "property") == 0)
{
- info->errorCount++;
- ERROR("The %s geometry property is not an array\n", field.str);
- ACTION("Ignoring illegal property definition\n");
- return False;
+ if (ndx != NULL)
+ {
+ info->errorCount++;
+ ERROR("The %s geometry property is not an array\n", field.str);
+ ACTION("Ignoring illegal property definition\n");
+ ret = False;
+ }
+ else {
+ ret = SetGeometryProperty(info, field.str, stmt->value);
+ }
}
- return SetGeometryProperty(info, field.str, stmt->value);
- }
- if (elem.str
- && ((di = FindDfltDoodadByTypeName(elem.str, NULL, info)) != NULL))
- {
- return SetDoodadField(di, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "solid") == 0))
- {
- DoodadInfo *dflt;
- dflt = FindDoodadByType(info->dfltDoodads, XkbSolidDoodad);
- if (dflt == NULL)
- dflt = NextDfltDoodad(NULL, info);
- return SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "outline") == 0))
- {
- DoodadInfo *dflt;
- dflt = FindDoodadByType(info->dfltDoodads, XkbOutlineDoodad);
- if (dflt == NULL)
- dflt = NextDfltDoodad(NULL, info);
- return SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "text") == 0))
- {
- DoodadInfo *dflt;
- dflt = FindDoodadByType(info->dfltDoodads, XkbTextDoodad);
- if (dflt == NULL)
- dflt = NextDfltDoodad(NULL, info);
- return SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "indicator") == 0))
- {
- DoodadInfo *dflt;
- dflt = FindDoodadByType(info->dfltDoodads, XkbIndicatorDoodad);
- if (dflt == NULL)
- dflt = NextDfltDoodad(NULL, info);
- return SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str && (uStrCaseCmp(elem.str, "logo") == 0))
- {
- DoodadInfo *dflt;
- dflt = FindDoodadByType(info->dfltDoodads, XkbLogoDoodad);
- if (dflt == NULL)
- dflt = NextDfltDoodad(NULL, info);
- return SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
- }
- if (elem.str)
- {
- WARN("Assignment to field of unknown element\n");
- ACTION("No value assigned to %s.%s\n", elem.str, field.str);
- return False;
+ else if ((di = FindDfltDoodadByTypeName(elem.str, NULL, info)) != NULL)
+ ret = SetDoodadField(di, field.str, ndx, stmt->value, NULL, info);
+ else if (uStrCaseCmp(elem.str, "solid") == 0)
+ {
+ DoodadInfo *dflt;
+ dflt = FindDoodadByType(info->dfltDoodads, XkbSolidDoodad);
+ if (dflt == NULL)
+ dflt = NextDfltDoodad(NULL, info);
+ ret = SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
+ }
+ else if (uStrCaseCmp(elem.str, "outline") == 0)
+ {
+ DoodadInfo *dflt;
+ dflt = FindDoodadByType(info->dfltDoodads, XkbOutlineDoodad);
+ if (dflt == NULL)
+ dflt = NextDfltDoodad(NULL, info);
+ ret = SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
+ }
+ else if (uStrCaseCmp(elem.str, "text") == 0)
+ {
+ DoodadInfo *dflt;
+ dflt = FindDoodadByType(info->dfltDoodads, XkbTextDoodad);
+ if (dflt == NULL)
+ dflt = NextDfltDoodad(NULL, info);
+ ret = SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
+ }
+ else if (uStrCaseCmp(elem.str, "indicator") == 0)
+ {
+ DoodadInfo *dflt;
+ dflt = FindDoodadByType(info->dfltDoodads, XkbIndicatorDoodad);
+ if (dflt == NULL)
+ dflt = NextDfltDoodad(NULL, info);
+ ret = SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
+ }
+ else if (uStrCaseCmp(elem.str, "logo") == 0)
+ {
+ DoodadInfo *dflt;
+ dflt = FindDoodadByType(info->dfltDoodads, XkbLogoDoodad);
+ if (dflt == NULL)
+ dflt = NextDfltDoodad(NULL, info);
+ ret = SetDoodadField(dflt, field.str, ndx, stmt->value, NULL, info);
+ }
+ else
+ {
+ WARN("Assignment to field of unknown element\n");
+ ACTION("No value assigned to %s.%s\n", elem.str, field.str);
+ ret = False;
+ }
+ free(elem.str);
+ free(field.str);
+ return ret;
}
if ((uStrCaseCmp(field.str, "width") == 0) ||
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
- if (!ExprResolveFloat(stmt->value, &tmp, NULL, NULL))
+ else if (!ExprResolveFloat(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "number");
+ ret = ReportBadType("keyboard", field.str, "geometry", "number");
}
- if (tmp.ival < 1)
+ else if (tmp.ival < 1)
{
WARN("Keyboard width must be positive\n");
ACTION("Ignoring illegal keyboard width %s\n",
XkbcGeomFPText(tmp.ival));
- return True;
+ ret = True;
}
- if (info->widthMM != 0)
- {
- WARN("Keyboard width multiply defined\n");
- ACTION("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
- INFO(" ignoring first (%s)\n", XkbcGeomFPText(info->widthMM));
+ else {
+ if (info->widthMM != 0)
+ {
+ WARN("Keyboard width multiply defined\n");
+ ACTION("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
+ INFO(" ignoring first (%s)\n", XkbcGeomFPText(info->widthMM));
+ }
+ info->widthMM = tmp.ival;
+ ret = True;
}
- info->widthMM = tmp.ival;
- return True;
+ free(field.str);
+ return ret;
}
else if ((uStrCaseCmp(field.str, "height") == 0) ||
(uStrCaseCmp(field.str, "heightmm") == 0))
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
if (!ExprResolveFloat(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "number");
+ ret = ReportBadType("keyboard", field.str, "geometry", "number");
}
if (tmp.ival < 1)
{
WARN("Keyboard height must be positive\n");
ACTION("Ignoring illegal keyboard height %s\n",
XkbcGeomFPText(tmp.ival));
- return True;
+ ret = True;
}
- if (info->heightMM != 0)
- {
- WARN("Keyboard height multiply defined\n");
- ACTION("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
- INFO(" ignoring first (%s)\n", XkbcGeomFPText(info->heightMM));
+ else {
+ if (info->heightMM != 0)
+ {
+ WARN("Keyboard height multiply defined\n");
+ ACTION("Using last definition (%s),", XkbcGeomFPText(tmp.ival));
+ INFO(" ignoring first (%s)\n", XkbcGeomFPText(info->heightMM));
+ }
+ info->heightMM = tmp.ival;
+ ret = True;
}
- info->heightMM = tmp.ival;
- return True;
- }
- else if (uStrCaseCmp(field.str, "font") == 0)
- {
- pField = &info->font;
- }
- else if ((uStrCaseCmp(field.str, "fontslant") == 0) ||
- (uStrCaseCmp(field.str, "slant") == 0))
- {
- pField = &info->fontSlant;
- }
- else if ((uStrCaseCmp(field.str, "fontweight") == 0) ||
- (uStrCaseCmp(field.str, "weight") == 0))
- {
- pField = &info->fontWeight;
- }
- else if ((uStrCaseCmp(field.str, "fontwidth") == 0) ||
- (uStrCaseCmp(field.str, "setwidth") == 0))
- {
- pField = &info->fontWeight;
- }
- else if ((uStrCaseCmp(field.str, "fontencoding") == 0) ||
- (uStrCaseCmp(field.str, "encoding") == 0))
- {
- pField = &info->fontEncoding;
- }
- else if ((uStrCaseCmp(field.str, "xfont") == 0) ||
- (uStrCaseCmp(field.str, "xfontname") == 0))
- {
- pField = &info->fontSpec;
+ free(field.str);
+ return ret;
}
else if (uStrCaseCmp(field.str, "fontsize") == 0)
{
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
- if (!ExprResolveFloat(stmt->value, &tmp, NULL, NULL))
+ else if (!ExprResolveFloat(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "number");
+ ret = ReportBadType("keyboard", field.str, "geometry", "number");
}
- if ((tmp.ival < 40) || (tmp.ival > 2550))
+ else if ((tmp.ival < 40) || (tmp.ival > 2550))
{
info->errorCount++;
ERROR("Illegal font size %d (must be 4..255)\n", tmp.ival);
ACTION("Ignoring font size in keyboard geometry\n");
- return False;
+ ret = False;
}
- info->fontSize = tmp.ival;
- return True;
+ else {
+ info->fontSize = tmp.ival;
+ ret = True;
+ }
+ free(field.str);
+ return ret;
}
else if ((uStrCaseCmp(field.str, "color") == 0) ||
(uStrCaseCmp(field.str, "basecolor") == 0))
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
if (!ExprResolveString(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "string");
+ ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
- info->baseColor = XkbcInternAtom(tmp.str, False);
- return True;
+ else {
+ info->baseColor = xkb_intern_atom(tmp.str);
+ free(tmp.str);
+ ret = True;
+ }
+ free(field.str);
+ return ret;
}
else if (uStrCaseCmp(field.str, "labelcolor") == 0)
{
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
if (!ExprResolveString(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "string");
+ ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
- info->labelColor = XkbcInternAtom(tmp.str, False);
- return True;
+ else {
+ info->labelColor = xkb_intern_atom(tmp.str);
+ free(tmp.str);
+ ret = True;
+ }
+ free(field.str);
+ return ret;
+ }
+ else if (uStrCaseCmp(field.str, "font") == 0)
+ {
+ pField = &info->font;
+ }
+ else if ((uStrCaseCmp(field.str, "fontslant") == 0) ||
+ (uStrCaseCmp(field.str, "slant") == 0))
+ {
+ pField = &info->fontSlant;
+ }
+ else if ((uStrCaseCmp(field.str, "fontweight") == 0) ||
+ (uStrCaseCmp(field.str, "weight") == 0))
+ {
+ pField = &info->fontWeight;
+ }
+ else if ((uStrCaseCmp(field.str, "fontwidth") == 0) ||
+ (uStrCaseCmp(field.str, "setwidth") == 0))
+ {
+ pField = &info->fontWeight;
+ }
+ else if ((uStrCaseCmp(field.str, "fontencoding") == 0) ||
+ (uStrCaseCmp(field.str, "encoding") == 0))
+ {
+ pField = &info->fontEncoding;
+ }
+ else if ((uStrCaseCmp(field.str, "xfont") == 0) ||
+ (uStrCaseCmp(field.str, "xfontname") == 0))
+ {
+ pField = &info->fontSpec;
}
else
{
- return SetGeometryProperty(info, field.str, stmt->value);
+ ret = SetGeometryProperty(info, field.str, stmt->value);
+ free(field.str);
+ return ret;
}
+ /* fallthrough for the cases that set pField */
if (ndx != NULL)
{
info->errorCount++;
- return ReportNotArray("keyboard", field.str, "geometry");
+ ret = ReportNotArray("keyboard", field.str, "geometry");
}
- if (!ExprResolveString(stmt->value, &tmp, NULL, NULL))
+ else if (!ExprResolveString(stmt->value, &tmp, NULL, NULL))
{
info->errorCount++;
- return ReportBadType("keyboard", field.str, "geometry", "string");
+ ret = ReportBadType("keyboard", field.str, "geometry", "string");
}
- *pField = XkbcInternAtom(tmp.str, False);
- return True;
+ else {
+ *pField = xkb_intern_atom(tmp.str);
+ free(tmp.str);
+ }
+ free(field.str);
+ return ret;
}
/***====================================================================***/
{
OutlineDef *ol;
int nOut, nPt;
- XkbOutlinePtr outline;
+ struct xkb_outline * outline;
ExprDef *pt;
if (def->nOutlines < 1)
return True;
}
si->nOutlines = def->nOutlines;
- si->outlines = uTypedCalloc(def->nOutlines, XkbOutlineRec);
+ si->outlines = uTypedCalloc(def->nOutlines, struct xkb_outline);
if (!si->outlines)
{
ERROR("Couldn't allocate outlines for \"%s\"\n", shText(si));
{
if (ol->nPoints < 1)
{
- SetShapeField(si, XkbcAtomGetString(ol->field), NULL,
- ol->points, info);
+ SetShapeField(si, XkbcAtomText(ol->field), NULL, ol->points, info);
continue;
}
outline = NULL;
outline = &si->outlines[nOut++];
outline->num_points = ol->nPoints;
outline->corner_radius = si->dfltCornerRadius;
- outline->points = uTypedCalloc(ol->nPoints, XkbPointRec);
+ outline->points = uTypedCalloc(ol->nPoints, struct xkb_point);
if (!outline->points)
{
ERROR("Can't allocate points for \"%s\"\n", shText(si));
ACTION("Definition ignored\n");
+ /* XXX leaks */
info->errorCount++;
return False;
}
}
if (ol->field != None)
{
- char *str = XkbcAtomText(ol->field);
+ const char *str = XkbcAtomText(ol->field);
if ((uStrCaseCmp(str, "approximation") == 0) ||
(uStrCaseCmp(str, "approx") == 0))
{
}
static int
-HandleShapeDef(ShapeDef * def, XkbcDescPtr xkb, unsigned merge,
+HandleShapeDef(ShapeDef * def, struct xkb_desc * xkb, unsigned merge,
GeometryInfo * info)
{
ShapeInfo si;
bzero(&si, sizeof(ShapeInfo));
si.defs.merge = merge;
- si.name =
- XkbcInternAtom(XkbcAtomGetString(def->name), False);
+ si.name = def->name;
si.dfltCornerRadius = info->dfltCornerRadius;
if (!HandleShapeBody(def, &si, merge, info))
return False;
def->type = XkbIndicatorDoodad;
}
InitDoodadInfo(&new, def->type, si, info);
- new.name =
- XkbcInternAtom(XkbcAtomGetString(def->name), False);
+ new.name = def->name;
for (var = def->body; var != NULL; var = (VarDef *) var->common.next)
{
if (ExprResolveLhs(var->name, &elem, &field, &ndx) == 0)
WARN("Assignment to field of unknown element in doodad %s\n",
ddText(&new));
ACTION("No value assigned to %s.%s\n", elem.str, field.str);
+ free(elem.str);
}
- else if (!SetDoodadField(&new, field.str, ndx, var->value, si, info))
+ else if (!SetDoodadField(&new, field.str, ndx, var->value, si, info)) {
+ free(field.str);
return False;
+ }
+ free(field.str);
}
if (!AddDoodad(si, info, &new))
return False;
return True;
}
bzero(&ol, sizeof(OverlayInfo));
- ol.name =
- XkbcInternAtom(XkbcAtomGetString(def->name), False);
+ ol.name = def->name;
for (keyDef = def->keys; keyDef;
keyDef = (OverlayKeyDef *) keyDef->common.next)
{
if ((elem.str == NULL) || (uStrCaseCmp(elem.str, "section") == 0))
{
if (!SetSectionField(si, field.str, ndx, var->value, info))
+ {
+ free(field.str);
return False;
+ }
}
else if (uStrCaseCmp(elem.str, "row") == 0)
{
if (!SetRowField
(&si->dfltRow, field.str, ndx, var->value, info))
+ {
+ free(field.str);
return False;
+ }
}
else if (uStrCaseCmp(elem.str, "key") == 0)
{
if (!SetKeyField(&si->dfltRow.dfltKey, field.str, ndx,
var->value, info))
+ {
+ free(field.str);
return False;
+ }
}
else if ((di =
FindDfltDoodadByTypeName(elem.str, si, info)) != NULL)
{
if (!SetDoodadField(di, field.str, ndx, var->value, si, info))
+ {
+ free(field.str);
return False;
+ }
}
else
{
WARN("Assignment to field of unknown element in section\n");
ACTION("No value assigned to %s.%s\n", elem.str, field.str);
}
+ free(field.str);
+ free(elem.str);
}
else if (rowDef->common.stmtType == StmtRowDef)
{
static int
HandleSectionDef(SectionDef * def,
- XkbcDescPtr xkb, unsigned merge, GeometryInfo * info)
+ struct xkb_desc * xkb, unsigned merge, GeometryInfo * info)
{
SectionInfo si;
- char *str;
if (def->merge != MergeDefault)
merge = def->merge;
InitSectionInfo(&si, info);
si.defs.merge = merge;
- str = XkbcAtomGetString(def->name);
- if ((str == NULL) || (strlen(str) < 1))
- {
- ERROR("Section defined without a name\n");
- ACTION("Definition ignored\n");
- return False;
- }
- si.name =
- XkbcInternAtom(XkbcAtomGetString(def->name), False);
+ si.name = def->name;
if (!HandleSectionBody(def, &si, merge, info))
return False;
if (!AddSection(info, &si))
static void
HandleGeometryFile(XkbFile * file,
- XkbcDescPtr xkb, unsigned merge, GeometryInfo * info)
+ struct xkb_desc * xkb, unsigned merge, GeometryInfo * info)
{
ParseCommon *stmt;
char *failWhat;
/***====================================================================***/
static Bool
-CopyShapeDef(XkbGeometryPtr geom, ShapeInfo * si)
+CopyShapeDef(struct xkb_geometry * geom, ShapeInfo * si)
{
register int i, n;
- XkbShapePtr shape;
- XkbOutlinePtr old_outline, outline;
- Atom name;
+ struct xkb_shape * shape;
+ struct xkb_outline *old_outline, *outline;
+ uint32_t name;
si->index = geom->num_shapes;
- name = XkbcInternAtom(XkbcAtomGetString(si->name), False);
+ name = si->name;
shape = XkbcAddGeomShape(geom, name, si->nOutlines);
if (!shape)
{
return False;
}
n = old_outline->num_points;
- memcpy(outline->points, old_outline->points, n * sizeof(XkbPointRec));
+ memcpy(outline->points, old_outline->points, n * sizeof(struct xkb_point));
outline->num_points = old_outline->num_points;
outline->corner_radius = old_outline->corner_radius;
}
WARN("No color for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
break;
case XkbTextDoodad:
WARN("No color specified for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
if ((di->defs.defined & _GD_FontSpec) != 0)
{
WARN("No font specified for doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_FONT);
}
- di->font = XkbcInternAtom(DFLT_FONT, False);
+ di->font = xkb_intern_atom(DFLT_FONT);
}
if ((di->defs.defined & _GD_FontSlant) == 0)
{
WARN("No font slant for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_SLANT);
}
- di->fontSlant = XkbcInternAtom(DFLT_SLANT, False);
+ di->fontSlant = xkb_intern_atom(DFLT_SLANT);
}
if ((di->defs.defined & _GD_FontWeight) == 0)
{
WARN("No font weight for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_WEIGHT);
}
- di->fontWeight = XkbcInternAtom(DFLT_WEIGHT, False);
+ di->fontWeight = xkb_intern_atom(DFLT_WEIGHT);
}
if ((di->defs.defined & _GD_FontSetWidth) == 0)
{
WARN("No font set width for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_SET_WIDTH);
}
- di->fontSetWidth = XkbcInternAtom(DFLT_SET_WIDTH, False);
+ di->fontSetWidth = xkb_intern_atom(DFLT_SET_WIDTH);
}
if ((di->defs.defined & _GD_FontVariant) == 0)
{
WARN("No font variant for text doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_VARIANT);
}
- di->fontVariant = XkbcInternAtom(DFLT_VARIANT, False);
+ di->fontVariant = xkb_intern_atom(DFLT_VARIANT);
}
if ((di->defs.defined & _GD_FontEncoding) == 0)
{
WARN("No font encoding for doodad %s\n", ddText(di));
ACTION("Using \"%s\"\n", DFLT_ENCODING);
}
- di->fontEncoding = XkbcInternAtom(DFLT_ENCODING, False);
+ di->fontEncoding = xkb_intern_atom(DFLT_ENCODING);
}
if ((di->defs.defined & _GD_FontSize) == 0)
{
if ((di->defs.defined & _GD_Height) == 0)
{
unsigned size, nLines;
- char *tmp;
+ const char *tmp;
size = (di->fontSize * 120) / 100;
size = (size * 254) / 720; /* convert to mm/10 */
- for (nLines = 1, tmp = XkbcAtomGetString(di->text); *tmp;
- tmp++)
+ for (nLines = 1, tmp = XkbcAtomText(di->text); *tmp; tmp++)
{
if (*tmp == '\n')
nLines++;
if ((di->defs.defined & _GD_Width) == 0)
{
unsigned width, tmp;
- char *str;
+ const char *str;
width = tmp = 0;
- for (str = XkbcAtomGetString(di->text); *str; str++)
+ for (str = XkbcAtomText(di->text); *str; str++)
{
if (*str != '\n')
tmp++;
ddText(di));
ACTION("Using green\n");
}
- di->color = XkbcInternAtom("green", False);
+ di->color = xkb_intern_atom("green");
}
if ((di->defs.defined & _GD_OffColor) == 0)
{
ddText(di));
ACTION("Using black\n");
}
- di->offColor = XkbcInternAtom("black", False);
+ di->offColor = xkb_intern_atom("black");
}
break;
case XkbLogoDoodad:
WARN("No color for doodad %s\n", ddText(di));
ACTION("Using black\n");
}
- di->color = XkbcInternAtom("black", False);
+ di->color = xkb_intern_atom("black");
}
break;
default:
#define FONT_TEMPLATE "-*-%s-%s-%s-%s-%s-*-%d-*-*-*-*-%s"
static char *
-FontFromParts(Atom fontTok,
- Atom weightTok,
- Atom slantTok,
- Atom setWidthTok, Atom varTok, int size, Atom encodingTok)
+FontFromParts(uint32_t fontTok,
+ uint32_t weightTok,
+ uint32_t slantTok,
+ uint32_t setWidthTok, uint32_t varTok, int size, uint32_t encodingTok)
{
int totalSize;
- char *font, *weight, *slant, *setWidth, *variant, *encoding;
+ const char *font, *weight, *slant, *setWidth, *variant, *encoding;
char *rtrn;
- font = (fontTok != None ? XkbcAtomGetString(fontTok) : DFLT_FONT);
- weight =
- (weightTok != None ? XkbcAtomGetString(weightTok) : DFLT_WEIGHT);
- slant =
- (slantTok != None ? XkbcAtomGetString(slantTok) : DFLT_SLANT);
+ font = (fontTok != None ? XkbcAtomText(fontTok) : DFLT_FONT);
+ weight = (weightTok != None ? XkbcAtomText(weightTok) : DFLT_WEIGHT);
+ slant = (slantTok != None ? XkbcAtomText(slantTok) : DFLT_SLANT);
setWidth =
- (setWidthTok !=
- None ? XkbcAtomGetString(setWidthTok) : DFLT_SET_WIDTH);
- variant =
- (varTok != None ? XkbcAtomGetString(varTok) : DFLT_VARIANT);
+ (setWidthTok != None ? XkbcAtomText(setWidthTok) : DFLT_SET_WIDTH);
+ variant = (varTok != None ? XkbcAtomText(varTok) : DFLT_VARIANT);
encoding =
- (encodingTok !=
- None ? XkbcAtomGetString(encodingTok) : DFLT_ENCODING);
+ (encodingTok != None ? XkbcAtomText(encodingTok) : DFLT_ENCODING);
if (size == 0)
size = DFLT_SIZE;
totalSize =
strlen(FONT_TEMPLATE) + strlen(font) + strlen(weight) + strlen(slant);
totalSize += strlen(setWidth) + strlen(variant) + strlen(encoding);
- rtrn = uCalloc(totalSize, 1);
+ rtrn = calloc(totalSize, 1);
if (rtrn)
- {
sprintf(rtrn, FONT_TEMPLATE, font, weight, slant, setWidth, variant,
size, encoding);
- }
return rtrn;
}
static Bool
-CopyDoodadDef(XkbGeometryPtr geom,
- XkbSectionPtr section, DoodadInfo * di, GeometryInfo * info)
+CopyDoodadDef(struct xkb_geometry * geom,
+ struct xkb_section * section, DoodadInfo * di, GeometryInfo * info)
{
- Atom name;
- XkbDoodadPtr doodad;
- XkbColorPtr color;
- XkbShapePtr shape;
+ uint32_t name;
+ union xkb_doodad * doodad;
+ struct xkb_color * color;
+ struct xkb_shape * shape;
ShapeInfo *si;
if (!VerifyDoodadInfo(di, info))
return False;
- name = XkbcInternAtom(XkbcAtomGetString(di->name), False);
+ name = di->name;
doodad = XkbcAddGeomDoodad(geom, section, name);
if (!doodad)
{
if (!si)
return False;
doodad->shape.angle = di->angle;
- color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
- geom->num_colors);
+ color = XkbcAddGeomColor(geom, XkbcAtomText(di->color),
+ geom->num_colors);
shape = &geom->shapes[si->index];
XkbSetShapeDoodadColor(geom, &doodad->shape, color);
XkbSetShapeDoodadShape(geom, &doodad->shape, shape);
else
doodad->text.font = XkbcAtomGetString(di->fontSpec);
doodad->text.text = XkbcAtomGetString(di->text);
- color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
- geom->num_colors);
+ color = XkbcAddGeomColor(geom, XkbcAtomText(di->color),
+ geom->num_colors);
XkbSetTextDoodadColor(geom, &doodad->text, color);
break;
case XkbIndicatorDoodad:
if (!si)
return False;
shape = &geom->shapes[si->index];
- color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
- geom->num_colors);
+ color = XkbcAddGeomColor(geom, XkbcAtomText(di->color),
+ geom->num_colors);
XkbSetIndicatorDoodadShape(geom, &doodad->indicator, shape);
XkbSetIndicatorDoodadOnColor(geom, &doodad->indicator, color);
- color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(di->offColor),
- geom->num_colors);
+ color = XkbcAddGeomColor(geom, XkbcAtomText(di->offColor),
+ geom->num_colors);
XkbSetIndicatorDoodadOffColor(geom, &doodad->indicator, color);
break;
case XkbLogoDoodad:
if (!si)
return False;
doodad->logo.angle = di->angle;
- color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
- geom->num_colors);
+ color = XkbcAddGeomColor(geom, XkbcAtomText(di->color),
+ geom->num_colors);
shape = &geom->shapes[si->index];
XkbSetLogoDoodadColor(geom, &doodad->logo, color);
XkbSetLogoDoodadShape(geom, &doodad->logo, shape);
/***====================================================================***/
static Bool
-VerifyOverlayInfo(XkbGeometryPtr geom,
- XkbSectionPtr section,
+VerifyOverlayInfo(struct xkb_geometry * geom,
+ struct xkb_section * section,
OverlayInfo * oi,
GeometryInfo * info, short rowMap[256], short rowSize[256])
{
register OverlayKeyInfo *ki, *next;
unsigned long oKey, uKey, sKey;
- XkbRowPtr row;
- XkbKeyPtr key;
+ struct xkb_row * row;
+ struct xkb_key * key;
int r, k;
/* find out which row each key is in */
while ((oi->keys != NULL) && (oi->keys->sectionRow == _GOK_UnknownRow))
{
next = (OverlayKeyInfo *) oi->keys->defs.next;
- uFree(oi->keys);
+ free(oi->keys);
oi->keys = next;
oi->nKeys--;
}
{
ki->defs.next = next->defs.next;
oi->nKeys--;
- uFree(next);
+ free(next);
next = (OverlayKeyInfo *) ki->defs.next;
}
}
}
static Bool
-CopyOverlayDef(XkbGeometryPtr geom,
- XkbSectionPtr section, OverlayInfo * oi, GeometryInfo * info)
+CopyOverlayDef(struct xkb_geometry * geom,
+ struct xkb_section * section, OverlayInfo * oi, GeometryInfo * info)
{
- Atom name;
- XkbOverlayPtr ol;
- XkbOverlayRowPtr row;
- XkbOverlayKeyPtr key;
+ uint32_t name;
+ struct xkb_overlay * ol;
+ struct xkb_overlay_row * row;
+ struct xkb_overlay_key * key;
OverlayKeyInfo *ki;
short rowMap[256], rowSize[256];
int i;
if (!VerifyOverlayInfo(geom, section, oi, info, rowMap, rowSize))
return False;
- name = XkbcInternAtom(XkbcAtomGetString(oi->name), False);
+ name = oi->name;
ol = XkbcAddGeomOverlay(section, name, oi->nRows);
if (!ol)
{
{
row = &ol->rows[ki->overlayRow];
key = &row->keys[row->num_keys++];
- bzero(key, sizeof(XkbOverlayKeyRec));
+ bzero(key, sizeof(struct xkb_overlay_key));
strncpy(key->over.name, ki->over, XkbKeyNameLength);
strncpy(key->under.name, ki->under, XkbKeyNameLength);
}
/***====================================================================***/
static Bool
-CopySectionDef(XkbGeometryPtr geom, SectionInfo * si, GeometryInfo * info)
+CopySectionDef(struct xkb_geometry * geom, SectionInfo * si, GeometryInfo * info)
{
- XkbSectionPtr section;
- XkbRowPtr row;
- XkbKeyPtr key;
+ struct xkb_section * section;
+ struct xkb_row * row;
+ struct xkb_key * key;
KeyInfo *ki;
RowInfo *ri;
- Atom name;
- name = XkbcInternAtom(XkbcAtomGetString(si->name), False);
- section =
- XkbcAddGeomSection(geom, name, si->nRows, si->nDoodads, si->nOverlays);
+ section = XkbcAddGeomSection(geom, si->name, si->nRows, si->nDoodads,
+ si->nOverlays);
if (section == NULL)
{
WSGO("Couldn't allocate section in geometry\n");
row->vertical = ri->vertical;
for (ki = ri->keys; ki != NULL; ki = (KeyInfo *) ki->defs.next)
{
- XkbColorPtr color;
+ struct xkb_color * color;
if ((ki->defs.defined & _GK_Name) == 0)
{
ERROR("Key %d of row %d in section %s has no name\n",
}
if (ki->color != None)
color =
- XkbcAddGeomColor(geom,
- XkbcAtomGetString(ki->color),
- geom->num_colors);
+ XkbcAddGeomColor(geom, XkbcAtomText(ki->color),
+ geom->num_colors);
else
color = XkbcAddGeomColor(geom, "white", geom->num_colors);
XkbSetKeyColor(geom, key, color);
/***====================================================================***/
Bool
-CompileGeometry(XkbFile *file, XkbcDescPtr xkb, unsigned merge)
+CompileGeometry(XkbFile *file, struct xkb_desc * xkb, unsigned merge)
{
GeometryInfo info;
if (info.errorCount == 0)
{
- XkbGeometryPtr geom;
- XkbGeometrySizesRec sizes;
+ struct xkb_geometry * geom;
+ struct xkb_geometry_sizes sizes;
bzero(&sizes, sizeof(sizes));
sizes.which = XkbGeomAllMask;
sizes.num_properties = info.nProps;
geom->height_mm = info.heightMM;
if (info.name != NULL)
{
- geom->name = XkbcInternAtom(info.name, False);
+ geom->name = xkb_intern_atom(info.name);
if (XkbcAllocNames(xkb, XkbGeometryNameMask, 0, 0) == Success)
xkb->names->geometry = geom->name;
}
if (info.fontSpec != None)
- geom->label_font =
- _XkbDupString(XkbcAtomGetString(info.fontSpec));
+ geom->label_font = XkbcAtomGetString(info.fontSpec);
else
geom->label_font = FontFromParts(info.font, info.fontWeight,
info.fontSlant,
XkbcAddGeomColor(geom, "white", geom->num_colors);
if (info.baseColor == None)
- info.baseColor = XkbcInternAtom("white", False);
+ info.baseColor = xkb_intern_atom("white");
if (info.labelColor == None)
- info.labelColor = XkbcInternAtom("black", False);
+ info.labelColor = xkb_intern_atom("black");
geom->base_color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(info.baseColor),
- geom->num_colors);
+ XkbcAddGeomColor(geom, XkbcAtomText(info.baseColor),
+ geom->num_colors);
geom->label_color =
- XkbcAddGeomColor(geom, XkbcAtomGetString(info.labelColor),
- geom->num_colors);
+ XkbcAddGeomColor(geom, XkbcAtomText(info.labelColor),
+ geom->num_colors);
if (info.props)
{
projects / platform / upstream / libxkbcommon.git / blobdiff