#ifdef HAVE_DIX_CONFIG_H
#include <dix-config.h>
#endif
#include <stdio.h>
#include <X11/X.h>
#include <X11/Xproto.h>
#include "misc.h"
#include "inputstr.h"
#include <xkbsrv.h>
#include "xkbgeom.h"
static void
_XkbFreeGeomLeafElems( Bool freeAll,
int first,
int count,
unsigned short * num_inout,
unsigned short * sz_inout,
char ** elems,
unsigned int elem_sz)
{
if ((freeAll)||(*elems==NULL)) {
*num_inout= *sz_inout= 0;
free(*elems);
*elems = NULL;
return;
}
if ((first>=(*num_inout))||(first<0)||(count<1))
return;
if (first+count>=(*num_inout)) {
(*num_inout)= first;
}
else {
char * ptr;
int extra;
ptr= *elems;
extra= ((*num_inout)-(first+count))*elem_sz;
if (extra>0)
memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],extra);
(*num_inout)-= count;
}
return;
}
typedef void (*ContentsClearFunc)(
char *
);
static void
_XkbFreeGeomNonLeafElems( Bool freeAll,
int first,
int count,
unsigned short * num_inout,
unsigned short * sz_inout,
char ** elems,
unsigned int elem_sz,
ContentsClearFunc freeFunc)
{
register int i;
register char *ptr;
if (freeAll) {
first= 0;
count= (*num_inout);
}
else if ((first>=(*num_inout))||(first<0)||(count<1))
return;
else if (first+count>(*num_inout))
count= (*num_inout)-first;
if (*elems==NULL)
return;
if (freeFunc) {
ptr= *elems;
ptr+= first*elem_sz;
for (i=0;i<count;i++) {
(*freeFunc)(ptr);
ptr+= elem_sz;
}
}
if (freeAll) {
(*num_inout)= (*sz_inout)= 0;
free(*elems);
*elems = NULL;
}
else if (first+count>=(*num_inout))
*num_inout= first;
else {
i= ((*num_inout)-(first+count))*elem_sz;
ptr= *elems;
memmove(&ptr[first*elem_sz],&ptr[(first+count)*elem_sz],i);
(*num_inout)-= count;
}
return;
}
static void
_XkbClearProperty(char *prop_in)
{
XkbPropertyPtr prop= (XkbPropertyPtr)prop_in;
free(prop->name);
prop->name = NULL;
free(prop->value);
prop->value = NULL;
return;
}
void
XkbFreeGeomProperties( XkbGeometryPtr geom,
int first,
int count,
Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&geom->num_properties,&geom->sz_properties,
(char **)&geom->properties,
sizeof(XkbPropertyRec),_XkbClearProperty);
return;
}
void
XkbFreeGeomKeyAliases( XkbGeometryPtr 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));
return;
}
static void
_XkbClearColor(char *color_in)
{
XkbColorPtr color= (XkbColorPtr)color_in;
free(color->spec);
return;
}
void
XkbFreeGeomColors(XkbGeometryPtr geom,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&geom->num_colors,&geom->sz_colors,
(char **)&geom->colors,
sizeof(XkbColorRec),_XkbClearColor);
return;
}
void
XkbFreeGeomPoints(XkbOutlinePtr outline,int first,int count,Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll,first,count,
&outline->num_points,&outline->sz_points,
(char **)&outline->points,
sizeof(XkbPointRec));
return;
}
static void
_XkbClearOutline(char *outline_in)
{
XkbOutlinePtr outline= (XkbOutlinePtr)outline_in;
if (outline->points!=NULL)
XkbFreeGeomPoints(outline,0,outline->num_points,TRUE);
return;
}
void
XkbFreeGeomOutlines(XkbShapePtr shape,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&shape->num_outlines,&shape->sz_outlines,
(char **)&shape->outlines,
sizeof(XkbOutlineRec),_XkbClearOutline);
return;
}
static void
_XkbClearShape(char *shape_in)
{
XkbShapePtr shape= (XkbShapePtr)shape_in;
if (shape->outlines)
XkbFreeGeomOutlines(shape,0,shape->num_outlines,TRUE);
return;
}
void
XkbFreeGeomShapes(XkbGeometryPtr geom,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&geom->num_shapes,&geom->sz_shapes,
(char **)&geom->shapes,
sizeof(XkbShapeRec),_XkbClearShape);
return;
}
void
XkbFreeGeomOverlayKeys(XkbOverlayRowPtr row,int first,int count,Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll,first,count,
&row->num_keys,&row->sz_keys,
(char **)&row->keys,
sizeof(XkbOverlayKeyRec));
return;
}
static void
_XkbClearOverlayRow(char *row_in)
{
XkbOverlayRowPtr row= (XkbOverlayRowPtr)row_in;
if (row->keys!=NULL)
XkbFreeGeomOverlayKeys(row,0,row->num_keys,TRUE);
return;
}
void
XkbFreeGeomOverlayRows(XkbOverlayPtr overlay,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&overlay->num_rows,&overlay->sz_rows,
(char **)&overlay->rows,
sizeof(XkbOverlayRowRec),_XkbClearOverlayRow);
return;
}
static void
_XkbClearOverlay(char *overlay_in)
{
XkbOverlayPtr overlay= (XkbOverlayPtr)overlay_in;
if (overlay->rows!=NULL)
XkbFreeGeomOverlayRows(overlay,0,overlay->num_rows,TRUE);
return;
}
void
XkbFreeGeomOverlays(XkbSectionPtr section,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
§ion->num_overlays,§ion->sz_overlays,
(char **)§ion->overlays,
sizeof(XkbOverlayRec),_XkbClearOverlay);
return;
}
void
XkbFreeGeomKeys(XkbRowPtr row,int first,int count,Bool freeAll)
{
_XkbFreeGeomLeafElems(freeAll,first,count,
&row->num_keys,&row->sz_keys,
(char **)&row->keys,
sizeof(XkbKeyRec));
return;
}
static void
_XkbClearRow(char *row_in)
{
XkbRowPtr row= (XkbRowPtr)row_in;
if (row->keys!=NULL)
XkbFreeGeomKeys(row,0,row->num_keys,TRUE);
return;
}
void
XkbFreeGeomRows(XkbSectionPtr section,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
§ion->num_rows,§ion->sz_rows,
(char **)§ion->rows,
sizeof(XkbRowRec),_XkbClearRow);
}
static void
_XkbClearSection(char *section_in)
{
XkbSectionPtr section= (XkbSectionPtr)section_in;
if (section->rows!=NULL)
XkbFreeGeomRows(section,0,section->num_rows,TRUE);
if (section->doodads!=NULL) {
XkbFreeGeomDoodads(section->doodads,section->num_doodads,TRUE);
section->doodads= NULL;
}
return;
}
void
XkbFreeGeomSections(XkbGeometryPtr geom,int first,int count,Bool freeAll)
{
_XkbFreeGeomNonLeafElems(freeAll,first,count,
&geom->num_sections,&geom->sz_sections,
(char **)&geom->sections,
sizeof(XkbSectionRec),_XkbClearSection);
return;
}
static void
_XkbClearDoodad(char *doodad_in)
{
XkbDoodadPtr doodad= (XkbDoodadPtr)doodad_in;
switch (doodad->any.type) {
case XkbTextDoodad:
{
free(doodad->text.text);
doodad->text.text = NULL;
free(doodad->text.font);
doodad->text.font = NULL;
}
break;
case XkbLogoDoodad:
{
free(doodad->logo.logo_name);
doodad->logo.logo_name = NULL;
}
break;
}
return;
}
void
XkbFreeGeomDoodads(XkbDoodadPtr doodads,int nDoodads,Bool freeAll)
{
register int i;
register XkbDoodadPtr doodad;
if (doodads) {
for (i=0,doodad= doodads;i<nDoodads;i++,doodad++) {
_XkbClearDoodad((char *)doodad);
}
if (freeAll)
free(doodads);
}
return;
}
void
XkbFreeGeometry(XkbGeometryPtr geom,unsigned which,Bool freeMap)
{
if (geom==NULL)
return;
if (freeMap)
which= XkbGeomAllMask;
if ((which&XkbGeomPropertiesMask)&&(geom->properties!=NULL))
XkbFreeGeomProperties(geom,0,geom->num_properties,TRUE);
if ((which&XkbGeomColorsMask)&&(geom->colors!=NULL))
XkbFreeGeomColors(geom,0,geom->num_colors,TRUE);
if ((which&XkbGeomShapesMask)&&(geom->shapes!=NULL))
XkbFreeGeomShapes(geom,0,geom->num_shapes,TRUE);
if ((which&XkbGeomSectionsMask)&&(geom->sections!=NULL))
XkbFreeGeomSections(geom,0,geom->num_sections,TRUE);
if ((which&XkbGeomDoodadsMask)&&(geom->doodads!= NULL)) {
XkbFreeGeomDoodads(geom->doodads,geom->num_doodads,TRUE);
geom->doodads= NULL;
geom->num_doodads= geom->sz_doodads= 0;
}
if ((which&XkbGeomKeyAliasesMask)&&(geom->key_aliases!=NULL))
XkbFreeGeomKeyAliases(geom,0,geom->num_key_aliases,TRUE);
if (freeMap) {
free(geom->label_font);
geom->label_font = NULL;
free(geom);
}
return;
}
static Status
_XkbGeomAlloc( void ** old,
unsigned short * num,
unsigned short * total,
int num_new,
size_t sz_elem)
{
if (num_new<1)
return Success;
if ((*old)==NULL)
*num= *total= 0;
if ((*num)+num_new<=(*total))
return Success;
*total= (*num)+num_new;
if ((*old)!=NULL)
(*old)= realloc((*old),(*total)*sz_elem);
else (*old)= calloc((*total),sz_elem);
if ((*old)==NULL) {
*total= *num= 0;
return BadAlloc;
}
if (*num>0) {
char *tmp= (char *)(*old);
memset(&tmp[sz_elem*(*num)], 0, (num_new*sz_elem));
}
return Success;
}
#define _XkbAllocProps(g,n) _XkbGeomAlloc((void *)&(g)->properties,\
&(g)->num_properties,&(g)->sz_properties,\
(n),sizeof(XkbPropertyRec))
#define _XkbAllocColors(g,n) _XkbGeomAlloc((void *)&(g)->colors,\
&(g)->num_colors,&(g)->sz_colors,\
(n),sizeof(XkbColorRec))
#define _XkbAllocShapes(g,n) _XkbGeomAlloc((void *)&(g)->shapes,\
&(g)->num_shapes,&(g)->sz_shapes,\
(n),sizeof(XkbShapeRec))
#define _XkbAllocSections(g,n) _XkbGeomAlloc((void *)&(g)->sections,\
&(g)->num_sections,&(g)->sz_sections,\
(n),sizeof(XkbSectionRec))
#define _XkbAllocDoodads(g,n) _XkbGeomAlloc((void *)&(g)->doodads,\
&(g)->num_doodads,&(g)->sz_doodads,\
(n),sizeof(XkbDoodadRec))
#define _XkbAllocKeyAliases(g,n) _XkbGeomAlloc((void *)&(g)->key_aliases,\
&(g)->num_key_aliases,&(g)->sz_key_aliases,\
(n),sizeof(XkbKeyAliasRec))
#define _XkbAllocOutlines(s,n) _XkbGeomAlloc((void *)&(s)->outlines,\
&(s)->num_outlines,&(s)->sz_outlines,\
(n),sizeof(XkbOutlineRec))
#define _XkbAllocRows(s,n) _XkbGeomAlloc((void *)&(s)->rows,\
&(s)->num_rows,&(s)->sz_rows,\
(n),sizeof(XkbRowRec))
#define _XkbAllocPoints(o,n) _XkbGeomAlloc((void *)&(o)->points,\
&(o)->num_points,&(o)->sz_points,\
(n),sizeof(XkbPointRec))
#define _XkbAllocKeys(r,n) _XkbGeomAlloc((void *)&(r)->keys,\
&(r)->num_keys,&(r)->sz_keys,\
(n),sizeof(XkbKeyRec))
#define _XkbAllocOverlays(s,n) _XkbGeomAlloc((void *)&(s)->overlays,\
&(s)->num_overlays,&(s)->sz_overlays,\
(n),sizeof(XkbOverlayRec))
#define _XkbAllocOverlayRows(o,n) _XkbGeomAlloc((void *)&(o)->rows,\
&(o)->num_rows,&(o)->sz_rows,\
(n),sizeof(XkbOverlayRowRec))
#define _XkbAllocOverlayKeys(r,n) _XkbGeomAlloc((void *)&(r)->keys,\
&(r)->num_keys,&(r)->sz_keys,\
(n),sizeof(XkbOverlayKeyRec))
Status
XkbAllocGeomProps(XkbGeometryPtr geom,int nProps)
{
return _XkbAllocProps(geom,nProps);
}
Status
XkbAllocGeomColors(XkbGeometryPtr geom,int nColors)
{
return _XkbAllocColors(geom,nColors);
}
Status
XkbAllocGeomKeyAliases(XkbGeometryPtr geom,int nKeyAliases)
{
return _XkbAllocKeyAliases(geom,nKeyAliases);
}
Status
XkbAllocGeomShapes(XkbGeometryPtr geom,int nShapes)
{
return _XkbAllocShapes(geom,nShapes);
}
Status
XkbAllocGeomSections(XkbGeometryPtr geom,int nSections)
{
return _XkbAllocSections(geom,nSections);
}
Status
XkbAllocGeomOverlays(XkbSectionPtr section,int nOverlays)
{
return _XkbAllocOverlays(section,nOverlays);
}
Status
XkbAllocGeomOverlayRows(XkbOverlayPtr overlay,int nRows)
{
return _XkbAllocOverlayRows(overlay,nRows);
}
Status
XkbAllocGeomOverlayKeys(XkbOverlayRowPtr row,int nKeys)
{
return _XkbAllocOverlayKeys(row,nKeys);
}
Status
XkbAllocGeomDoodads(XkbGeometryPtr geom,int nDoodads)
{
return _XkbAllocDoodads(geom,nDoodads);
}
Status
XkbAllocGeomSectionDoodads(XkbSectionPtr section,int nDoodads)
{
return _XkbAllocDoodads(section,nDoodads);
}
Status
XkbAllocGeomOutlines(XkbShapePtr shape,int nOL)
{
return _XkbAllocOutlines(shape,nOL);
}
Status
XkbAllocGeomRows(XkbSectionPtr section,int nRows)
{
return _XkbAllocRows(section,nRows);
}
Status
XkbAllocGeomPoints(XkbOutlinePtr ol,int nPts)
{
return _XkbAllocPoints(ol,nPts);
}
Status
XkbAllocGeomKeys(XkbRowPtr row,int nKeys)
{
return _XkbAllocKeys(row,nKeys);
}
Status
XkbAllocGeometry(XkbDescPtr xkb,XkbGeometrySizesPtr sizes)
{
XkbGeometryPtr geom;
Status rtrn;
if (xkb->geom==NULL) {
xkb->geom= calloc(1, sizeof(XkbGeometryRec));
if (!xkb->geom)
return BadAlloc;
}
geom= xkb->geom;
if ((sizes->which&XkbGeomPropertiesMask)&&
((rtrn=_XkbAllocProps(geom,sizes->num_properties))!=Success)) {
goto BAIL;
}
if ((sizes->which&XkbGeomColorsMask)&&
((rtrn=_XkbAllocColors(geom,sizes->num_colors))!=Success)) {
goto BAIL;
}
if ((sizes->which&XkbGeomShapesMask)&&
((rtrn=_XkbAllocShapes(geom,sizes->num_shapes))!=Success)) {
goto BAIL;
}
if ((sizes->which&XkbGeomSectionsMask)&&
((rtrn=_XkbAllocSections(geom,sizes->num_sections))!=Success)) {
goto BAIL;
}
if ((sizes->which&XkbGeomDoodadsMask)&&
((rtrn=_XkbAllocDoodads(geom,sizes->num_doodads))!=Success)) {
goto BAIL;
}
if ((sizes->which&XkbGeomKeyAliasesMask)&&
((rtrn=_XkbAllocKeyAliases(geom,sizes->num_key_aliases))!=Success)) {
goto BAIL;
}
return Success;
BAIL:
XkbFreeGeometry(geom,XkbGeomAllMask,TRUE);
xkb->geom= NULL;
return rtrn;
}
XkbPropertyPtr
XkbAddGeomProperty(XkbGeometryPtr geom,char *name,char *value)
{
register int i;
register XkbPropertyPtr 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)) {
free(prop->value);
prop->value= malloc(strlen(value)+1);
if (prop->value)
strcpy(prop->value,value);
return prop;
}
}
if ((geom->num_properties>=geom->sz_properties)&&
(_XkbAllocProps(geom,1)!=Success)) {
return NULL;
}
prop= &geom->properties[geom->num_properties];
prop->name= malloc(strlen(name)+1);
if (!prop->name)
return NULL;
strcpy(prop->name,name);
prop->value= malloc(strlen(value)+1);
if (!prop->value) {
free(prop->name);
prop->name= NULL;
return NULL;
}
strcpy(prop->value,value);
geom->num_properties++;
return prop;
}
XkbKeyAliasPtr
XkbAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr)
{
register int i;
register XkbKeyAliasPtr alias;
if ((!geom)||(!aliasStr)||(!realStr)||(!aliasStr[0])||(!realStr[0]))
return NULL;
for (i=0,alias=geom->key_aliases;i<geom->num_key_aliases;i++,alias++) {
if (strncmp(alias->alias,aliasStr,XkbKeyNameLength)==0) {
memset(alias->real, 0, XkbKeyNameLength);
strncpy(alias->real,realStr,XkbKeyNameLength);
return alias;
}
}
if ((geom->num_key_aliases>=geom->sz_key_aliases)&&
(_XkbAllocKeyAliases(geom,1)!=Success)) {
return NULL;
}
alias= &geom->key_aliases[geom->num_key_aliases];
memset(alias, 0, sizeof(XkbKeyAliasRec));
strncpy(alias->alias,aliasStr,XkbKeyNameLength);
strncpy(alias->real,realStr,XkbKeyNameLength);
geom->num_key_aliases++;
return alias;
}
XkbColorPtr
XkbAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel)
{
register int i;
register XkbColorPtr color;
if ((!geom)||(!spec))
return NULL;
for (i=0,color=geom->colors;i<geom->num_colors;i++,color++) {
if ((color->spec)&&(strcmp(color->spec,spec)==0)) {
color->pixel= pixel;
return color;
}
}
if ((geom->num_colors>=geom->sz_colors)&&
(_XkbAllocColors(geom,1)!=Success)) {
return NULL;
}
color= &geom->colors[geom->num_colors];
color->pixel= pixel;
color->spec= malloc(strlen(spec)+1);
if (!color->spec)
return NULL;
strcpy(color->spec,spec);
geom->num_colors++;
return color;
}
XkbOutlinePtr
XkbAddGeomOutline(XkbShapePtr shape,int sz_points)
{
XkbOutlinePtr outline;
if ((!shape)||(sz_points<0))
return NULL;
if ((shape->num_outlines>=shape->sz_outlines)&&
(_XkbAllocOutlines(shape,1)!=Success)) {
return NULL;
}
outline= &shape->outlines[shape->num_outlines];
memset(outline, 0, sizeof(XkbOutlineRec));
if ((sz_points>0)&&(_XkbAllocPoints(outline,sz_points)!=Success))
return NULL;
shape->num_outlines++;
return outline;
}
XkbShapePtr
XkbAddGeomShape(XkbGeometryPtr geom,Atom name,int sz_outlines)
{
XkbShapePtr shape;
register int i;
if ((!geom)||(!name)||(sz_outlines<0))
return NULL;
if (geom->num_shapes>0) {
for (shape=geom->shapes,i=0;i<geom->num_shapes;i++,shape++) {
if (name==shape->name)
return shape;
}
}
if ((geom->num_shapes>=geom->sz_shapes)&&
(_XkbAllocShapes(geom,1)!=Success))
return NULL;
shape= &geom->shapes[geom->num_shapes];
memset(shape, 0, sizeof(XkbShapeRec));
if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success))
return NULL;
shape->name= name;
shape->primary= shape->approx= NULL;
geom->num_shapes++;
return shape;
}
XkbKeyPtr
XkbAddGeomKey(XkbRowPtr row)
{
XkbKeyPtr key;
if (!row)
return NULL;
if ((row->num_keys>=row->sz_keys)&&(_XkbAllocKeys(row,1)!=Success))
return NULL;
key= &row->keys[row->num_keys++];
memset(key, 0, sizeof(XkbKeyRec));
return key;
}
XkbRowPtr
XkbAddGeomRow(XkbSectionPtr section,int sz_keys)
{
XkbRowPtr row;
if ((!section)||(sz_keys<0))
return NULL;
if ((section->num_rows>=section->sz_rows)&&
(_XkbAllocRows(section,1)!=Success))
return NULL;
row= §ion->rows[section->num_rows];
memset(row, 0, sizeof(XkbRowRec));
if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
return NULL;
section->num_rows++;
return row;
}
XkbSectionPtr
XkbAddGeomSection( XkbGeometryPtr geom,
Atom name,
int sz_rows,
int sz_doodads,
int sz_over)
{
register int i;
XkbSectionPtr section;
if ((!geom)||(name==None)||(sz_rows<0))
return NULL;
for (i=0,section=geom->sections;i<geom->num_sections;i++,section++) {
if (section->name!=name)
continue;
if (((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))||
((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success))||
((sz_over>0)&&(_XkbAllocOverlays(section,sz_over)!=Success)))
return NULL;
return section;
}
if ((geom->num_sections>=geom->sz_sections)&&
(_XkbAllocSections(geom,1)!=Success))
return NULL;
section= &geom->sections[geom->num_sections];
if ((sz_rows>0)&&(_XkbAllocRows(section,sz_rows)!=Success))
return NULL;
if ((sz_doodads>0)&&(_XkbAllocDoodads(section,sz_doodads)!=Success)) {
if (section->rows) {
free(section->rows);
section->rows= NULL;
section->sz_rows= section->num_rows= 0;
}
return NULL;
}
section->name= name;
geom->num_sections++;
return section;
}
XkbDoodadPtr
XkbAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name)
{
XkbDoodadPtr old,doodad;
register int i,nDoodads;
if ((!geom)||(name==None))
return NULL;
if ((section!=NULL)&&(section->num_doodads>0)) {
old= section->doodads;
nDoodads= section->num_doodads;
}
else {
old= geom->doodads;
nDoodads= geom->num_doodads;
}
for (i=0,doodad=old;i<nDoodads;i++,doodad++) {
if (doodad->any.name==name)
return doodad;
}
if (section) {
if ((section->num_doodads>=geom->sz_doodads)&&
(_XkbAllocDoodads(section,1)!=Success)) {
return NULL;
}
doodad= §ion->doodads[section->num_doodads++];
}
else {
if ((geom->num_doodads>=geom->sz_doodads)&&
(_XkbAllocDoodads(geom,1)!=Success))
return NULL;
doodad= &geom->doodads[geom->num_doodads++];
}
memset(doodad, 0, sizeof(XkbDoodadRec));
doodad->any.name= name;
return doodad;
}
XkbOverlayKeyPtr
XkbAddGeomOverlayKey( XkbOverlayPtr overlay,
XkbOverlayRowPtr row,
char * over,
char * under)
{
register int i;
XkbOverlayKeyPtr key;
XkbSectionPtr section;
XkbRowPtr row_under;
Bool found;
if ((!overlay)||(!row)||(!over)||(!under))
return NULL;
section= overlay->section_under;
if (row->row_under>=section->num_rows)
return NULL;
row_under= §ion->rows[row->row_under];
for (i=0,found=FALSE;i<row_under->num_keys;i++) {
if (strncmp(under,row_under->keys[i].name.name,XkbKeyNameLength)==0) {
found= TRUE;
break;
}
}
if (!found)
return NULL;
if ((row->num_keys>=row->sz_keys)&&(_XkbAllocOverlayKeys(row,1)!=Success))
return NULL;
key= &row->keys[row->num_keys];
strncpy(key->under.name,under,XkbKeyNameLength);
strncpy(key->over.name,over,XkbKeyNameLength);
row->num_keys++;
return key;
}
XkbOverlayRowPtr
XkbAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys)
{
register int i;
XkbOverlayRowPtr row;
if ((!overlay)||(sz_keys<0))
return NULL;
if (row_under>=overlay->section_under->num_rows)
return NULL;
for (i=0;i<overlay->num_rows;i++) {
if (overlay->rows[i].row_under==row_under) {
row= &overlay->rows[i];
if ((row->sz_keys<sz_keys)&&
(_XkbAllocOverlayKeys(row,sz_keys)!=Success)) {
return NULL;
}
return &overlay->rows[i];
}
}
if ((overlay->num_rows>=overlay->sz_rows)&&
(_XkbAllocOverlayRows(overlay,1)!=Success))
return NULL;
row= &overlay->rows[overlay->num_rows];
memset(row, 0, sizeof(XkbOverlayRowRec));
if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
return NULL;
row->row_under= row_under;
overlay->num_rows++;
return row;
}
XkbOverlayPtr
XkbAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows)
{
register int i;
XkbOverlayPtr overlay;
if ((!section)||(name==None)||(sz_rows==0))
return NULL;
for (i=0,overlay=section->overlays;i<section->num_overlays;i++,overlay++) {
if (overlay->name==name) {
if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
return NULL;
return overlay;
}
}
if ((section->num_overlays>=section->sz_overlays)&&
(_XkbAllocOverlays(section,1)!=Success))
return NULL;
overlay= §ion->overlays[section->num_overlays];
if ((sz_rows>0)&&(_XkbAllocOverlayRows(overlay,sz_rows)!=Success))
return NULL;
overlay->name= name;
overlay->section_under= section;
section->num_overlays++;
return overlay;
}