xkb->geom = NULL;
return rtrn;
}
+
+XkbPropertyPtr
+XkbcAddGeomProperty(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)) {
+ if (prop->value)
+ _XkbFree(prop->value);
+ prop->value= (char *)_XkbAlloc(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= (char *)_XkbAlloc(strlen(name)+1);
+ if (!name)
+ return NULL;
+ strcpy(prop->name,name);
+ prop->value= (char *)_XkbAlloc(strlen(value)+1);
+ if (!value) {
+ _XkbFree(prop->name);
+ prop->name= NULL;
+ return NULL;
+ }
+ strcpy(prop->value,value);
+ geom->num_properties++;
+ return prop;
+}
+
+XkbKeyAliasPtr
+XkbcAddGeomKeyAlias(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) {
+ bzero(alias->real,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];
+ bzero(alias,sizeof(XkbKeyAliasRec));
+ 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)
+{
+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= (char *)_XkbAlloc(strlen(spec)+1);
+ if (!color->spec)
+ return NULL;
+ strcpy(color->spec,spec);
+ geom->num_colors++;
+ return color;
+}
+
+XkbOutlinePtr
+XkbcAddGeomOutline(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];
+ bzero(outline,sizeof(XkbOutlineRec));
+ 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)
+{
+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];
+ bzero(shape,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
+XkbcAddGeomKey(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++];
+ bzero(key,sizeof(XkbKeyRec));
+ return key;
+}
+
+XkbRowPtr
+XkbcAddGeomRow(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];
+ bzero(row,sizeof(XkbRowRec));
+ if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success))
+ return NULL;
+ section->num_rows++;
+ return row;
+}
+
+XkbSectionPtr
+XkbcAddGeomSection( 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) {
+ _XkbFree(section->rows);
+ section->rows= NULL;
+ section->sz_rows= section->num_rows= 0;
+ }
+ return NULL;
+ }
+ section->name= name;
+ geom->num_sections++;
+ return section;
+}
+
+XkbDoodadPtr
+XkbcAddGeomDoodad(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++];
+ }
+ bzero(doodad,sizeof(XkbDoodadRec));
+ doodad->any.name= name;
+ return doodad;
+}
+
+XkbOverlayKeyPtr
+XkbcAddGeomOverlayKey( 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
+XkbcAddGeomOverlayRow(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];
+ bzero(row,sizeof(XkbOverlayRowRec));
+ if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success))
+ return NULL;
+ row->row_under= row_under;
+ overlay->num_rows++;
+ return row;
+}
+
+XkbOverlayPtr
+XkbcAddGeomOverlay(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;
+}
si->index = geom->num_shapes;
name = XkbcInternAtom(XkbcAtomGetString(si->name), False);
- shape = XkbAddGeomShape(geom, name, si->nOutlines);
+ shape = XkbcAddGeomShape(geom, name, si->nOutlines);
if (!shape)
{
WSGO("Couldn't allocate shape in geometry\n");
old_outline = si->outlines;
for (i = 0; i < si->nOutlines; i++, old_outline++)
{
- outline = XkbAddGeomOutline(shape, old_outline->num_points);
+ outline = XkbcAddGeomOutline(shape, old_outline->num_points);
if (!outline)
{
WSGO("Couldn't allocate outline in shape\n");
if (!VerifyDoodadInfo(di, info))
return False;
name = XkbcInternAtom(XkbcAtomGetString(di->name), False);
- doodad = XkbAddGeomDoodad(geom, section, name);
+ doodad = XkbcAddGeomDoodad(geom, section, name);
if (!doodad)
{
WSGO1("Couldn't allocate doodad in %s\n",
return False;
doodad->shape.angle = di->angle;
color =
- XkbAddGeomColor(geom, XkbcAtomGetString(di->color),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
geom->num_colors);
shape = &geom->shapes[si->index];
XkbSetShapeDoodadColor(geom, &doodad->shape, color);
doodad->text.font = XkbcAtomGetString(di->fontSpec);
doodad->text.text = XkbcAtomGetString(di->text);
color =
- XkbAddGeomColor(geom, XkbcAtomGetString(di->color),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
geom->num_colors);
XkbSetTextDoodadColor(geom, &doodad->text, color);
break;
return False;
shape = &geom->shapes[si->index];
color =
- XkbAddGeomColor(geom, XkbcAtomGetString(di->color),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
geom->num_colors);
XkbSetIndicatorDoodadShape(geom, &doodad->indicator, shape);
XkbSetIndicatorDoodadOnColor(geom, &doodad->indicator, color);
color =
- XkbAddGeomColor(geom, XkbcAtomGetString(di->offColor),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(di->offColor),
geom->num_colors);
XkbSetIndicatorDoodadOffColor(geom, &doodad->indicator, color);
break;
return False;
doodad->logo.angle = di->angle;
color =
- XkbAddGeomColor(geom, XkbcAtomGetString(di->color),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(di->color),
geom->num_colors);
shape = &geom->shapes[si->index];
XkbSetLogoDoodadColor(geom, &doodad->logo, color);
if (!VerifyOverlayInfo(geom, section, oi, info, rowMap, rowSize))
return False;
name = XkbcInternAtom(XkbcAtomGetString(oi->name), False);
- ol = XkbAddGeomOverlay(section, name, oi->nRows);
+ ol = XkbcAddGeomOverlay(section, name, oi->nRows);
if (!ol)
{
WSGO2("Couldn't add overlay \"%s\" to section \"%s\"\n",
if (rowMap[tmp] == i)
row_under = tmp;
}
- if (!XkbAddGeomOverlayRow(ol, row_under, rowSize[i]))
+ if (!XkbcAddGeomOverlayRow(ol, row_under, rowSize[i]))
{
WSGO3
("Can't add row %d to overlay \"%s\" of section \"%s\"\n",
name = XkbcInternAtom(XkbcAtomGetString(si->name), False);
section =
- XkbAddGeomSection(geom, name, si->nRows, si->nDoodads, si->nOverlays);
+ XkbcAddGeomSection(geom, name, si->nRows, si->nDoodads, si->nOverlays);
if (section == NULL)
{
WSGO("Couldn't allocate section in geometry\n");
section->priority = si->priority;
for (ri = si->rows; ri != NULL; ri = (RowInfo *) ri->defs.next)
{
- row = XkbAddGeomRow(section, ri->nKeys);
+ row = XkbcAddGeomRow(section, ri->nKeys);
if (row == NULL)
{
WSGO("Couldn't allocate row in section\n");
ACTION1("Section %s ignored\n", scText(si));
return False;
}
- key = XkbAddGeomKey(row);
+ key = XkbcAddGeomKey(row);
if (key == NULL)
{
WSGO("Couldn't allocate key in row\n");
}
if (ki->color != None)
color =
- XkbAddGeomColor(geom,
+ XkbcAddGeomColor(geom,
XkbcAtomGetString(ki->color),
geom->num_colors);
else
- color = XkbAddGeomColor(geom, "white", geom->num_colors);
+ color = XkbcAddGeomColor(geom, "white", geom->num_colors);
XkbSetKeyColor(geom, key, color);
}
}
info.fontVariant,
info.fontSize,
info.fontEncoding);
- XkbAddGeomColor(geom, "black", geom->num_colors);
- XkbAddGeomColor(geom, "white", geom->num_colors);
+ XkbcAddGeomColor(geom, "black", geom->num_colors);
+ XkbcAddGeomColor(geom, "white", geom->num_colors);
if (info.baseColor == None)
info.baseColor = XkbcInternAtom("white", False);
if (info.labelColor == None)
info.labelColor = XkbcInternAtom("black", False);
geom->base_color =
- XkbAddGeomColor(geom, XkbcAtomGetString(info.baseColor),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(info.baseColor),
geom->num_colors);
geom->label_color =
- XkbAddGeomColor(geom, XkbcAtomGetString(info.labelColor),
+ XkbcAddGeomColor(geom, XkbcAtomGetString(info.labelColor),
geom->num_colors);
if (info.props)
for (pi = info.props; pi != NULL;
pi = (PropertyInfo *) pi->defs.next)
{
- if (!XkbAddGeomProperty(geom, pi->name, pi->value))
+ if (!XkbcAddGeomProperty(geom, pi->name, pi->value))
return False;
}
}