if (freeAll || !(*elems)) {
*num_inout = *sz_inout = 0;
if (*elems) {
- _XkbFree(*elems);
+ free(*elems);
*elems = NULL;
}
return;
if (freeAll) {
*num_inout = *sz_inout = 0;
if (*elems) {
- _XkbFree(*elems);
+ free(*elems);
*elems = NULL;
}
}
static void
_XkbClearProperty(char *prop_in)
{
- XkbPropertyPtr prop = (XkbPropertyPtr)prop_in;
+ struct xkb_property * prop = (struct xkb_property *)prop_in;
if (prop->name) {
- _XkbFree(prop->name);
+ free(prop->name);
prop->name = NULL;
}
if (prop->value) {
- _XkbFree(prop->value);
+ free(prop->value);
prop->value = NULL;
}
}
void
-XkbcFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+XkbcFreeGeomProperties(struct xkb_geometry * geom, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_properties, &geom->sz_properties,
(char **)&geom->properties,
- sizeof(XkbPropertyRec),
+ sizeof(struct xkb_property),
_XkbClearProperty);
}
void
-XkbcFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+XkbcFreeGeomKeyAliases(struct xkb_geometry * geom, int first, int count, Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&geom->num_key_aliases, &geom->sz_key_aliases,
(char **)&geom->key_aliases,
- sizeof(XkbKeyAliasRec));
+ sizeof(struct xkb_key_alias));
}
static void
_XkbClearColor(char *color_in)
{
- XkbColorPtr color = (XkbColorPtr)color_in;
+ struct xkb_color * color = (struct xkb_color *)color_in;
if (color->spec)
- _XkbFree(color->spec);
+ free(color->spec);
}
void
-XkbcFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+XkbcFreeGeomColors(struct xkb_geometry * geom, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_colors, &geom->sz_colors,
- (char **)&geom->colors, sizeof(XkbColorRec),
+ (char **)&geom->colors, sizeof(struct xkb_color),
_XkbClearColor);
}
void
-XkbcFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll)
+XkbcFreeGeomPoints(struct xkb_outline * outline, int first, int count, Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&outline->num_points, &outline->sz_points,
- (char **)&outline->points, sizeof(XkbPointRec));
+ (char **)&outline->points, sizeof(struct xkb_point));
}
static void
_XkbClearOutline(char *outline_in)
{
- XkbOutlinePtr outline = (XkbOutlinePtr)outline_in;
+ struct xkb_outline * outline = (struct xkb_outline *)outline_in;
if (outline->points)
XkbcFreeGeomPoints(outline, 0, outline->num_points, True);
}
void
-XkbcFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll)
+XkbcFreeGeomOutlines(struct xkb_shape * shape, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&shape->num_outlines, &shape->sz_outlines,
- (char **)&shape->outlines, sizeof(XkbOutlineRec),
+ (char **)&shape->outlines, sizeof(struct xkb_outline),
_XkbClearOutline);
}
static void
_XkbClearShape(char *shape_in)
{
- XkbShapePtr shape = (XkbShapePtr)shape_in;
+ struct xkb_shape * shape = (struct xkb_shape *)shape_in;
if (shape->outlines)
XkbcFreeGeomOutlines(shape, 0, shape->num_outlines, True);
}
void
-XkbcFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+XkbcFreeGeomShapes(struct xkb_geometry * geom, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_shapes, &geom->sz_shapes,
- (char **)&geom->shapes, sizeof(XkbShapeRec),
+ (char **)&geom->shapes, sizeof(struct xkb_shape),
_XkbClearShape);
}
void
-XkbcFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count,
+XkbcFreeGeomOverlayKeys(struct xkb_overlay_row * row, int first, int count,
Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&row->num_keys, &row->sz_keys,
- (char **)&row->keys, sizeof(XkbOverlayKeyRec));
+ (char **)&row->keys, sizeof(struct xkb_overlay_key));
}
static void
_XkbClearOverlayRow(char *row_in)
{
- XkbOverlayRowPtr row = (XkbOverlayRowPtr)row_in;
+ struct xkb_overlay_row * row = (struct xkb_overlay_row *)row_in;
if (row->keys)
XkbcFreeGeomOverlayKeys(row, 0, row->num_keys, True);
}
void
-XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count,
+XkbcFreeGeomOverlayRows(struct xkb_overlay * overlay, int first, int count,
Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&overlay->num_rows, &overlay->sz_rows,
(char **)&overlay->rows,
- sizeof(XkbOverlayRowRec),
+ sizeof(struct xkb_overlay_row),
_XkbClearOverlayRow);
}
static void
_XkbClearOverlay(char *overlay_in)
{
- XkbOverlayPtr overlay = (XkbOverlayPtr)overlay_in;
+ struct xkb_overlay * overlay = (struct xkb_overlay *)overlay_in;
if (overlay->rows)
XkbcFreeGeomOverlayRows(overlay, 0, overlay->num_rows, True);
}
void
-XkbcFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll)
+XkbcFreeGeomOverlays(struct xkb_section * section, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
§ion->num_overlays, §ion->sz_overlays,
(char **)§ion->overlays,
- sizeof(XkbOverlayRec),
+ sizeof(struct xkb_overlay),
_XkbClearOverlay);
}
void
-XkbcFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll)
+XkbcFreeGeomKeys(struct xkb_row * row, int first, int count, Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll, first, count,
&row->num_keys, &row->sz_keys,
- (char **)&row->keys, sizeof(XkbKeyRec));
+ (char **)&row->keys, sizeof(struct xkb_key));
}
static void
_XkbClearRow(char *row_in)
{
- XkbRowPtr row = (XkbRowPtr)row_in;
+ struct xkb_row * row = (struct xkb_row *)row_in;
if (row->keys)
XkbcFreeGeomKeys(row, 0, row->num_keys, True);
}
void
-XkbcFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll)
+XkbcFreeGeomRows(struct xkb_section * section, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
§ion->num_rows, §ion->sz_rows,
- (char **)§ion->rows, sizeof(XkbRowRec),
+ (char **)§ion->rows, sizeof(struct xkb_row),
_XkbClearRow);
}
static void
_XkbClearSection(char *section_in)
{
- XkbSectionPtr section = (XkbSectionPtr)section_in;
+ struct xkb_section * section = (struct xkb_section *)section_in;
if (section->rows)
XkbcFreeGeomRows(section, 0, section->num_rows, True);
}
void
-XkbcFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll)
+XkbcFreeGeomSections(struct xkb_geometry * geom, int first, int count, Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll, first, count,
&geom->num_sections, &geom->sz_sections,
- (char **)&geom->sections, sizeof(XkbSectionRec),
+ (char **)&geom->sections, sizeof(struct xkb_section),
_XkbClearSection);
}
static void
_XkbClearDoodad(char *doodad_in)
{
- XkbDoodadPtr doodad = (XkbDoodadPtr)doodad_in;
+ union xkb_doodad * doodad = (union xkb_doodad *)doodad_in;
switch (doodad->any.type) {
case XkbTextDoodad:
if (doodad->text.text) {
- _XkbFree(doodad->text.text);
+ free(doodad->text.text);
doodad->text.text = NULL;
}
if (doodad->text.font) {
- _XkbFree(doodad->text.font);
+ free(doodad->text.font);
doodad->text.font = NULL;
}
break;
case XkbLogoDoodad:
if (doodad->logo.logo_name) {
- _XkbFree(doodad->logo.logo_name);
+ free(doodad->logo.logo_name);
doodad->logo.logo_name = NULL;
}
break;
}
void
-XkbcFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll)
+XkbcFreeGeomDoodads(union xkb_doodad * doodads, int nDoodads, Bool freeAll)
{
int i;
- XkbDoodadPtr doodad;
+ union xkb_doodad * doodad;
if (doodads) {
for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++)
_XkbClearDoodad((char *)doodad);
if (freeAll)
- _XkbFree(doodads);
+ free(doodads);
}
}
void
-XkbcFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap)
+XkbcFreeGeometry(struct xkb_geometry * geom, unsigned which, Bool freeMap)
{
if (!geom)
return;
if (freeMap) {
if (geom->label_font) {
- _XkbFree(geom->label_font);
+ free(geom->label_font);
geom->label_font = NULL;
}
- _XkbFree(geom);
+ free(geom);
}
}
*total = (*num) + num_new;
if (*old)
- *old = (char *)_XkbRealloc(*old, (*total) * sz_elem);
+ *old = (char *)realloc(*old, (*total) * sz_elem);
else
- *old = (char *)_XkbCalloc(*total, sz_elem);
+ *old = (char *)calloc(*total, sz_elem);
if (!(*old)) {
*total = *num = 0;
return BadAlloc;
#define _XkbAllocProps(g, n) _XkbGeomAlloc((char **)&(g)->properties, \
&(g)->num_properties, \
&(g)->sz_properties, \
- (n), sizeof(XkbPropertyRec))
+ (n), sizeof(struct xkb_property))
#define _XkbAllocColors(g, n) _XkbGeomAlloc((char **)&(g)->colors, \
&(g)->num_colors, \
&(g)->sz_colors, \
- (n), sizeof(XkbColorRec))
+ (n), sizeof(struct xkb_color))
#define _XkbAllocShapes(g, n) _XkbGeomAlloc((char **)&(g)->shapes, \
&(g)->num_shapes, \
&(g)->sz_shapes, \
- (n), sizeof(XkbShapeRec))
+ (n), sizeof(struct xkb_shape))
#define _XkbAllocSections(g, n) _XkbGeomAlloc((char **)&(g)->sections, \
&(g)->num_sections, \
&(g)->sz_sections, \
- (n), sizeof(XkbSectionRec))
+ (n), sizeof(struct xkb_section))
#define _XkbAllocDoodads(g, n) _XkbGeomAlloc((char **)&(g)->doodads, \
&(g)->num_doodads, \
&(g)->sz_doodads, \
- (n), sizeof(XkbDoodadRec))
+ (n), sizeof(union xkb_doodad))
#define _XkbAllocKeyAliases(g, n) _XkbGeomAlloc((char **)&(g)->key_aliases, \
&(g)->num_key_aliases, \
&(g)->sz_key_aliases, \
- (n), sizeof(XkbKeyAliasRec))
+ (n), sizeof(struct xkb_key_alias))
#define _XkbAllocOutlines(s, n) _XkbGeomAlloc((char **)&(s)->outlines, \
&(s)->num_outlines, \
&(s)->sz_outlines, \
- (n), sizeof(XkbOutlineRec))
+ (n), sizeof(struct xkb_outline))
#define _XkbAllocRows(s, n) _XkbGeomAlloc((char **)&(s)->rows, \
&(s)->num_rows, \
&(s)->sz_rows, \
- (n), sizeof(XkbRowRec))
+ (n), sizeof(struct xkb_row))
#define _XkbAllocPoints(o, n) _XkbGeomAlloc((char **)&(o)->points, \
&(o)->num_points, \
&(o)->sz_points, \
- (n), sizeof(XkbPointRec))
+ (n), sizeof(struct xkb_point))
#define _XkbAllocKeys(r, n) _XkbGeomAlloc((char **)&(r)->keys, \
&(r)->num_keys, \
&(r)->sz_keys, \
- (n), sizeof(XkbKeyRec))
+ (n), sizeof(struct xkb_key))
#define _XkbAllocOverlays(s, n) _XkbGeomAlloc((char **)&(s)->overlays, \
&(s)->num_overlays, \
&(s)->sz_overlays, \
- (n), sizeof(XkbOverlayRec))
+ (n), sizeof(struct xkb_overlay))
#define _XkbAllocOverlayRows(o, n) _XkbGeomAlloc((char **)&(o)->rows, \
&(o)->num_rows, \
&(o)->sz_rows, \
- (n), sizeof(XkbOverlayRowRec))
+ (n), sizeof(struct xkb_overlay_row))
#define _XkbAllocOverlayKeys(r, n) _XkbGeomAlloc((char **)&(r)->keys, \
&(r)->num_keys, \
&(r)->sz_keys, \
- (n), sizeof(XkbOverlayKeyRec))
+ (n), sizeof(struct xkb_overlay_key))
int
-XkbcAllocGeomProps(XkbGeometryPtr geom, int nProps)
+XkbcAllocGeomProps(struct xkb_geometry * geom, int nProps)
{
return _XkbAllocProps(geom, nProps);
}
int
-XkbcAllocGeomColors(XkbGeometryPtr geom, int nColors)
+XkbcAllocGeomColors(struct xkb_geometry * geom, int nColors)
{
return _XkbAllocColors(geom, nColors);
}
int
-XkbcAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases)
+XkbcAllocGeomKeyAliases(struct xkb_geometry * geom, int nKeyAliases)
{
return _XkbAllocKeyAliases(geom, nKeyAliases);
}
int
-XkbcAllocGeomShapes(XkbGeometryPtr geom, int nShapes)
+XkbcAllocGeomShapes(struct xkb_geometry * geom, int nShapes)
{
return _XkbAllocShapes(geom, nShapes);
}
int
-XkbcAllocGeomSections(XkbGeometryPtr geom, int nSections)
+XkbcAllocGeomSections(struct xkb_geometry * geom, int nSections)
{
return _XkbAllocSections(geom, nSections);
}
int
-XkbcAllocGeomOverlays(XkbSectionPtr section, int nOverlays)
+XkbcAllocGeomOverlays(struct xkb_section * section, int nOverlays)
{
return _XkbAllocOverlays(section, nOverlays);
}
int
-XkbcAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows)
+XkbcAllocGeomOverlayRows(struct xkb_overlay * overlay, int nRows)
{
return _XkbAllocOverlayRows(overlay, nRows);
}
int
-XkbcAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys)
+XkbcAllocGeomOverlayKeys(struct xkb_overlay_row * row, int nKeys)
{
return _XkbAllocOverlayKeys(row, nKeys);
}
int
-XkbcAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads)
+XkbcAllocGeomDoodads(struct xkb_geometry * geom, int nDoodads)
{
return _XkbAllocDoodads(geom, nDoodads);
}
int
-XkbcAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads)
+XkbcAllocGeomSectionDoodads(struct xkb_section * section, int nDoodads)
{
return _XkbAllocDoodads(section, nDoodads);
}
int
-XkbcAllocGeomOutlines(XkbShapePtr shape, int nOL)
+XkbcAllocGeomOutlines(struct xkb_shape * shape, int nOL)
{
return _XkbAllocOutlines(shape, nOL);
}
int
-XkbcAllocGeomRows(XkbSectionPtr section, int nRows)
+XkbcAllocGeomRows(struct xkb_section * section, int nRows)
{
return _XkbAllocRows(section, nRows);
}
int
-XkbcAllocGeomPoints(XkbOutlinePtr ol, int nPts)
+XkbcAllocGeomPoints(struct xkb_outline * ol, int nPts)
{
return _XkbAllocPoints(ol, nPts);
}
int
-XkbcAllocGeomKeys(XkbRowPtr row, int nKeys)
+XkbcAllocGeomKeys(struct xkb_row * row, int nKeys)
{
int ret = _XkbAllocKeys(row, nKeys);
fprintf(stderr, "!!! allocated %d keys at %p\n", nKeys, row->keys);
}
int
-XkbcAllocGeometry(XkbcDescPtr xkb, XkbGeometrySizesPtr sizes)
+XkbcAllocGeometry(struct xkb_desc * xkb, struct xkb_geometry_sizes * sizes)
{
- XkbGeometryPtr geom;
+ struct xkb_geometry * geom;
int rtrn;
if (!xkb->geom) {
- xkb->geom = _XkbTypedCalloc(1, XkbGeometryRec);
+ xkb->geom = _XkbTypedCalloc(1, struct xkb_geometry);
if (!xkb->geom)
return BadAlloc;
}
return rtrn;
}
-XkbPropertyPtr
-XkbcAddGeomProperty(XkbGeometryPtr geom,char *name,char *value)
+struct xkb_property *
+XkbcAddGeomProperty(struct xkb_geometry * geom,const char *name,const char *value)
{
register int i;
-register XkbPropertyPtr prop;
+register struct xkb_property * prop;
if ((!geom)||(!name)||(!value))
return NULL;
for (i=0,prop=geom->properties;i<geom->num_properties;i++,prop++) {
if ((prop->name)&&(strcmp(name,prop->name)==0)) {
if (prop->value)
- _XkbFree(prop->value);
- prop->value= (char *)_XkbAlloc(strlen(value)+1);
+ free(prop->value);
+ prop->value= (char *)malloc(strlen(value)+1);
if (prop->value)
strcpy(prop->value,value);
return prop;
return NULL;
}
prop= &geom->properties[geom->num_properties];
- prop->name= (char *)_XkbAlloc(strlen(name)+1);
+ prop->name= (char *)malloc(strlen(name)+1);
if (!name)
return NULL;
strcpy(prop->name,name);
- prop->value= (char *)_XkbAlloc(strlen(value)+1);
+ prop->value= (char *)malloc(strlen(value)+1);
if (!value) {
- _XkbFree(prop->name);
+ free(prop->name);
prop->name= NULL;
return NULL;
}
return prop;
}
-XkbKeyAliasPtr
-XkbcAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr)
+struct xkb_key_alias *
+XkbcAddGeomKeyAlias(struct xkb_geometry * geom,const char *aliasStr,const char *realStr)
{
register int i;
-register XkbKeyAliasPtr alias;
+register struct xkb_key_alias * alias;
if ((!geom)||(!aliasStr)||(!realStr)||(!aliasStr[0])||(!realStr[0]))
return NULL;
return NULL;
}
alias= &geom->key_aliases[geom->num_key_aliases];
- bzero(alias,sizeof(XkbKeyAliasRec));
+ bzero(alias,sizeof(struct xkb_key_alias));
strncpy(alias->alias,aliasStr,XkbKeyNameLength);
strncpy(alias->real,realStr,XkbKeyNameLength);
geom->num_key_aliases++;
return alias;
}
-XkbColorPtr
-XkbcAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel)
+struct xkb_color *
+XkbcAddGeomColor(struct xkb_geometry * geom,const char *spec,unsigned int pixel)
{
register int i;
-register XkbColorPtr color;
+register struct xkb_color * color;
if ((!geom)||(!spec))
return NULL;
}
color= &geom->colors[geom->num_colors];
color->pixel= pixel;
- color->spec= (char *)_XkbAlloc(strlen(spec)+1);
+ color->spec= (char *)malloc(strlen(spec)+1);
if (!color->spec)
return NULL;
strcpy(color->spec,spec);
return color;
}
-XkbOutlinePtr
-XkbcAddGeomOutline(XkbShapePtr shape,int sz_points)
+struct xkb_outline *
+XkbcAddGeomOutline(struct xkb_shape * shape,int sz_points)
{
-XkbOutlinePtr outline;
+struct xkb_outline * outline;
if ((!shape)||(sz_points<0))
return NULL;
return NULL;
}
outline= &shape->outlines[shape->num_outlines];
- bzero(outline,sizeof(XkbOutlineRec));
+ bzero(outline,sizeof(struct xkb_outline));
if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success))
return NULL;
shape->num_outlines++;
return outline;
}
-XkbShapePtr
-XkbcAddGeomShape(XkbGeometryPtr geom,Atom name,int sz_outlines)
+struct xkb_shape *
+XkbcAddGeomShape(struct xkb_geometry * geom,uint32_t name,int sz_outlines)
{
-XkbShapePtr shape;
+struct xkb_shape * shape;
register int i;
if ((!geom)||(!name)||(sz_outlines<0))
(_XkbAllocShapes(geom,1)!=Success))
return NULL;
shape= &geom->shapes[geom->num_shapes];
- bzero(shape,sizeof(XkbShapeRec));
+ bzero(shape,sizeof(struct xkb_shape));
if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success))
return NULL;
shape->name= name;
return shape;
}
-XkbKeyPtr
-XkbcAddGeomKey(XkbRowPtr row)
+struct xkb_key *
+XkbcAddGeomKey(struct xkb_row * row)
{
-XkbKeyPtr key;
+struct xkb_key * key;
if (!row)
return NULL;
if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success))
return NULL;
key= &row->keys[row->num_keys++];
- bzero(key,sizeof(XkbKeyRec));
+ bzero(key,sizeof(struct xkb_key));
return key;
}
-XkbRowPtr
-XkbcAddGeomRow(XkbSectionPtr section,int sz_keys)
+struct xkb_row *
+XkbcAddGeomRow(struct xkb_section * section,int sz_keys)
{
-XkbRowPtr row;
+struct xkb_row * row;
if ((!section)||(sz_keys<0))
return NULL;
(_XkbAllocRows(section,1)!=Success))
return NULL;
row= §ion->rows[section->num_rows];
- bzero(row,sizeof(XkbRowRec));
+ bzero(row,sizeof(struct xkb_row));
if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
return NULL;
section->num_rows++;
return row;
}
-XkbSectionPtr
-XkbcAddGeomSection( XkbGeometryPtr geom,
- Atom name,
+struct xkb_section *
+XkbcAddGeomSection( struct xkb_geometry * geom,
+ uint32_t name,
int sz_rows,
int sz_doodads,
int sz_over)
{
register int i;
-XkbSectionPtr section;
+struct xkb_section * section;
if ((!geom)||(name==None)||(sz_rows<0))
return NULL;
return NULL;
if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) {
if (section->rows) {
- _XkbFree(section->rows);
+ free(section->rows);
section->rows= NULL;
section->sz_rows= section->num_rows= 0;
}
return section;
}
-XkbDoodadPtr
-XkbcAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name)
+union xkb_doodad *
+XkbcAddGeomDoodad(struct xkb_geometry * geom,struct xkb_section * section,uint32_t name)
{
-XkbDoodadPtr old,doodad;
+union xkb_doodad *old, *doodad;
register int i,nDoodads;
if ((!geom)||(name==None))
return NULL;
doodad= &geom->doodads[geom->num_doodads++];
}
- bzero(doodad,sizeof(XkbDoodadRec));
+ bzero(doodad,sizeof(union xkb_doodad));
doodad->any.name= name;
return doodad;
}
-XkbOverlayKeyPtr
-XkbcAddGeomOverlayKey( XkbOverlayPtr overlay,
- XkbOverlayRowPtr row,
- char * over,
- char * under)
+struct xkb_overlay_key *
+XkbcAddGeomOverlayKey( struct xkb_overlay * overlay,
+ struct xkb_overlay_row * row,
+ const char * over,
+ const char * under)
{
register int i;
-XkbOverlayKeyPtr key;
-XkbSectionPtr section;
-XkbRowPtr row_under;
+struct xkb_overlay_key * key;
+struct xkb_section * section;
+struct xkb_row * row_under;
Bool found;
if ((!overlay)||(!row)||(!over)||(!under))
return key;
}
-XkbOverlayRowPtr
-XkbcAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys)
+struct xkb_overlay_row *
+XkbcAddGeomOverlayRow(struct xkb_overlay * overlay,int row_under,int sz_keys)
{
register int i;
-XkbOverlayRowPtr row;
+struct xkb_overlay_row * row;
if ((!overlay)||(sz_keys<0))
return NULL;
(_XkbAllocOverlayRows(overlay,1)!=Success))
return NULL;
row= &overlay->rows[overlay->num_rows];
- bzero(row,sizeof(XkbOverlayRowRec));
+ bzero(row,sizeof(struct xkb_overlay_row));
if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
return NULL;
row->row_under= row_under;
return row;
}
-XkbOverlayPtr
-XkbcAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows)
+struct xkb_overlay *
+XkbcAddGeomOverlay(struct xkb_section * section,uint32_t name,int sz_rows)
{
register int i;
-XkbOverlayPtr overlay;
+struct xkb_overlay * overlay;
if ((!section)||(name==None)||(sz_rows==0))
return NULL;
projects / platform / upstream / libxkbcommon.git / blobdiff