From 7257d4c89e52aa727df25564109cecc4d33b9543 Mon Sep 17 00:00:00 2001 From: Daniel Stone Date: Mon, 21 Jun 2010 14:28:34 +0100 Subject: [PATCH] Use CARD32 instead of Atom, move geom headers in Use CARD32 instead of Atom/KeySym/et al to avoid type size confusion between server and non-server code; relatedly, move the geometry headers in from kbproto, so every non-simple type (i.e. structs containing nothing more than basic types) is now copied into xkbcommon. Signed-off-by: Daniel Stone --- include/X11/extensions/XKBcommon.h | 315 +++++++++++++++++++++++++++++++++++-- src/alloc.c | 10 +- src/galloc.c | 216 ++++++++++++------------- src/geom.c | 36 ++--- src/malloc.c | 16 +- src/misc.c | 6 +- src/xkb.c | 2 +- src/xkballoc.h | 4 +- src/xkbcomp/alias.c | 6 +- src/xkbcomp/expr.c | 16 +- src/xkbcomp/expr.h | 24 +-- src/xkbcomp/geometry.c | 140 ++++++++--------- src/xkbcomp/indicators.c | 2 +- src/xkbcomp/indicators.h | 2 +- src/xkbcomp/keycodes.c | 8 +- src/xkbcomp/keytypes.c | 30 ++-- src/xkbcomp/listing.c | 1 - src/xkbcomp/misc.c | 2 - src/xkbcomp/parseutils.c | 23 ++- src/xkbcomp/parseutils.h | 22 +-- src/xkbcomp/symbols.c | 28 ++-- src/xkbcomp/tokens.h | 9 +- src/xkbcomp/vmod.c | 10 +- src/xkbcomp/vmod.h | 8 +- src/xkbcomp/xkbcomp.c | 2 + src/xkbcomp/xkbcomp.h | 30 ++-- src/xkbcomp/xkbparse.y | 1 - src/xkbgeom.h | 113 +++++++------ src/xkbmisc.h | 2 +- 29 files changed, 684 insertions(+), 400 deletions(-) diff --git a/include/X11/extensions/XKBcommon.h b/include/X11/extensions/XKBcommon.h index 2881458..49887fe 100644 --- a/include/X11/extensions/XKBcommon.h +++ b/include/X11/extensions/XKBcommon.h @@ -25,18 +25,43 @@ sale, use or other dealings in this Software without prior written authorization from the authors. */ +/************************************************************ +Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. + +Permission to use, copy, modify, and distribute this +software and its documentation for any purpose and without +fee is hereby granted, provided that the above copyright +notice appear in all copies and that both that copyright +notice and this permission notice appear in supporting +documentation, and that the name of Silicon Graphics not be +used in advertising or publicity pertaining to distribution +of the software without specific prior written permission. +Silicon Graphics makes no representation about the suitability +of this software for any purpose. It is provided "as is" +without any express or implied warranty. + +SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS +SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON +GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL +DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, +DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE +OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH +THE USE OR PERFORMANCE OF THIS SOFTWARE. + +********************************************************/ + + #ifndef _XKBCOMMON_H_ #define _XKBCOMMON_H_ #include #include #include +#include #include #include -#define KeySym CARD32 -#define Atom CARD32 - /* Action structures used in the server */ #define XkbcAnyActionDataSize 18 @@ -121,17 +146,27 @@ typedef union _XkbcAction { XkbPtrAction ptr; /* XXX delete for DeviceValuator */ XkbPtrBtnAction btn; /* XXX delete for DeviceBtn */ XkbMessageAction msg; /* XXX just delete */ - unsigned char type; + unsigned char type; } XkbcAction; +typedef struct _XkbcKeyType { + XkbModsRec mods; + unsigned char num_levels; + unsigned char map_count; + XkbKTMapEntryPtr map; + XkbModsPtr preserve; + CARD32 name; + CARD32 *level_names; +} XkbcKeyTypeRec, *XkbcKeyTypePtr; + typedef struct _XkbcSymInterpretRec { CARD32 sym; unsigned char flags; unsigned char match; unsigned char mods; unsigned char virtual_mod; - XkbcAnyAction act; -} XkbcSymInterpretRec,*XkbcSymInterpretPtr; + XkbcAnyAction act; +} XkbcSymInterpretRec, *XkbcSymInterpretPtr; typedef struct _XkbcCompatMapRec { XkbcSymInterpretPtr sym_interpret; @@ -143,7 +178,7 @@ typedef struct _XkbcCompatMapRec { typedef struct _XkbcClientMapRec { unsigned char size_types; unsigned char num_types; - XkbKeyTypePtr types; + XkbcKeyTypePtr types; unsigned short size_syms; unsigned short num_syms; @@ -172,6 +207,265 @@ typedef struct _XkbcServerMapRec { uint32_t *vmodmap; } XkbcServerMapRec, *XkbcServerMapPtr; +typedef struct _XkbcNamesRec { + CARD32 keycodes; + CARD32 geometry; + CARD32 symbols; + CARD32 types; + CARD32 compat; + CARD32 vmods[XkbNumVirtualMods]; + CARD32 indicators[XkbNumIndicators]; + CARD32 groups[XkbNumKbdGroups]; + XkbKeyNamePtr keys; + XkbKeyAliasPtr key_aliases; + CARD32 *radio_groups; + CARD32 phys_symbols; + + unsigned char num_keys; + unsigned char num_key_aliases; + unsigned short num_rg; +} XkbcNamesRec, *XkbcNamesPtr; + +typedef struct _XkbcProperty { + char *name; + char *value; +} XkbcPropertyRec, *XkbcPropertyPtr; + +typedef struct _XkbcColor { + unsigned int pixel; + char * spec; +} XkbcColorRec, *XkbcColorPtr; + +typedef struct _XkbcPoint { + short x; + short y; +} XkbcPointRec, *XkbcPointPtr; + +typedef struct _XkbcBounds { + short x1,y1; + short x2,y2; +} XkbcBoundsRec, *XkbcBoundsPtr; +#define XkbBoundsWidth(b) (((b)->x2)-((b)->x1)) +#define XkbBoundsHeight(b) (((b)->y2)-((b)->y1)) + +typedef struct _XkbcOutline { + unsigned short num_points; + unsigned short sz_points; + unsigned short corner_radius; + XkbcPointPtr points; +} XkbcOutlineRec, *XkbcOutlinePtr; + +typedef struct _XkbcShape { + CARD32 name; + unsigned short num_outlines; + unsigned short sz_outlines; + XkbcOutlinePtr outlines; + XkbcOutlinePtr approx; + XkbcOutlinePtr primary; + XkbcBoundsRec bounds; +} XkbcShapeRec, *XkbcShapePtr; +#define XkbOutlineIndex(s,o) ((int)((o)-&(s)->outlines[0])) + +typedef struct _XkbcShapeDoodad { + CARD32 name; + unsigned char type; + unsigned char priority; + short top; + short left; + short angle; + unsigned short color_ndx; + unsigned short shape_ndx; +} XkbcShapeDoodadRec, *XkbcShapeDoodadPtr; +#define XkbShapeDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) +#define XkbShapeDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) +#define XkbSetShapeDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) +#define XkbSetShapeDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + +typedef struct _XkbcTextDoodad { + CARD32 name; + unsigned char type; + unsigned char priority; + short top; + short left; + short angle; + short width; + short height; + unsigned short color_ndx; + char * text; + char * font; +} XkbcTextDoodadRec, *XkbcTextDoodadPtr; +#define XkbTextDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) +#define XkbSetTextDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) + +typedef struct _XkbcIndicatorDoodad { + CARD32 name; + unsigned char type; + unsigned char priority; + short top; + short left; + short angle; + unsigned short shape_ndx; + unsigned short on_color_ndx; + unsigned short off_color_ndx; +} XkbcIndicatorDoodadRec, *XkbcIndicatorDoodadPtr; +#define XkbIndicatorDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) +#define XkbIndicatorDoodadOnColor(g,d) (&(g)->colors[(d)->on_color_ndx]) +#define XkbIndicatorDoodadOffColor(g,d) (&(g)->colors[(d)->off_color_ndx]) +#define XkbSetIndicatorDoodadOnColor(g,d,c) \ + ((d)->on_color_ndx= (c)-&(g)->colors[0]) +#define XkbSetIndicatorDoodadOffColor(g,d,c) \ + ((d)->off_color_ndx= (c)-&(g)->colors[0]) +#define XkbSetIndicatorDoodadShape(g,d,s) \ + ((d)->shape_ndx= (s)-&(g)->shapes[0]) + +typedef struct _XkbcLogoDoodad { + CARD32 name; + unsigned char type; + unsigned char priority; + short top; + short left; + short angle; + unsigned short color_ndx; + unsigned short shape_ndx; + char * logo_name; +} XkbcLogoDoodadRec, *XkbcLogoDoodadPtr; +#define XkbLogoDoodadColor(g,d) (&(g)->colors[(d)->color_ndx]) +#define XkbLogoDoodadShape(g,d) (&(g)->shapes[(d)->shape_ndx]) +#define XkbSetLogoDoodadColor(g,d,c) ((d)->color_ndx= (c)-&(g)->colors[0]) +#define XkbSetLogoDoodadShape(g,d,s) ((d)->shape_ndx= (s)-&(g)->shapes[0]) + +typedef struct _XkbcAnyDoodad { + CARD32 name; + unsigned char type; + unsigned char priority; + short top; + short left; + short angle; +} XkbcAnyDoodadRec, *XkbcAnyDoodadPtr; + +typedef union _XkbcDoodad { + XkbcAnyDoodadRec any; + XkbcShapeDoodadRec shape; + XkbcTextDoodadRec text; + XkbcIndicatorDoodadRec indicator; + XkbcLogoDoodadRec logo; +} XkbcDoodadRec, *XkbcDoodadPtr; + +#define XkbUnknownDoodad 0 +#define XkbOutlineDoodad 1 +#define XkbSolidDoodad 2 +#define XkbTextDoodad 3 +#define XkbIndicatorDoodad 4 +#define XkbLogoDoodad 5 + +typedef struct _XkbcKey { + XkbKeyNameRec name; + short gap; + unsigned char shape_ndx; + unsigned char color_ndx; +} XkbcKeyRec, *XkbcKeyPtr; +#define XkbKeyShape(g,k) (&(g)->shapes[(k)->shape_ndx]) +#define XkbKeyColor(g,k) (&(g)->colors[(k)->color_ndx]) +#define XkbSetKeyShape(g,k,s) ((k)->shape_ndx= (s)-&(g)->shapes[0]) +#define XkbSetKeyColor(g,k,c) ((k)->color_ndx= (c)-&(g)->colors[0]) + +typedef struct _XkbRow { + short top; + short left; + unsigned short num_keys; + unsigned short sz_keys; + int vertical; + XkbcKeyPtr keys; + XkbcBoundsRec bounds; +} XkbcRowRec, *XkbcRowPtr; + +typedef struct _XkbcSection { + CARD32 name; + unsigned char priority; + short top; + short left; + unsigned short width; + unsigned short height; + short angle; + unsigned short num_rows; + unsigned short num_doodads; + unsigned short num_overlays; + unsigned short sz_rows; + unsigned short sz_doodads; + unsigned short sz_overlays; + XkbcRowPtr rows; + XkbcDoodadPtr doodads; + XkbcBoundsRec bounds; + struct _XkbOverlay *overlays; +} XkbcSectionRec, *XkbcSectionPtr; + +typedef struct _XkbcOverlayKey { + XkbKeyNameRec over; + XkbKeyNameRec under; +} XkbcOverlayKeyRec, *XkbcOverlayKeyPtr; + +typedef struct _XkbOverlayRow { + unsigned short row_under; + unsigned short num_keys; + unsigned short sz_keys; + XkbcOverlayKeyPtr keys; +} XkbcOverlayRowRec, *XkbcOverlayRowPtr; + +typedef struct _XkbOverlay { + CARD32 name; + XkbcSectionPtr section_under; + unsigned short num_rows; + unsigned short sz_rows; + XkbcOverlayRowPtr rows; + XkbcBoundsPtr bounds; +} XkbcOverlayRec, *XkbcOverlayPtr; + +typedef struct _XkbcGeometry { + CARD32 name; + unsigned short width_mm; + unsigned short height_mm; + char * label_font; + XkbcColorPtr label_color; + XkbcColorPtr base_color; + unsigned short sz_properties; + unsigned short sz_colors; + unsigned short sz_shapes; + unsigned short sz_sections; + unsigned short sz_doodads; + unsigned short sz_key_aliases; + unsigned short num_properties; + unsigned short num_colors; + unsigned short num_shapes; + unsigned short num_sections; + unsigned short num_doodads; + unsigned short num_key_aliases; + XkbcPropertyPtr properties; + XkbcColorPtr colors; + XkbcShapePtr shapes; + XkbcSectionPtr sections; + XkbcDoodadPtr doodads; + XkbKeyAliasPtr key_aliases; +} XkbcGeometryRec, *XkbcGeometryPtr; +#define XkbGeomColorIndex(g,c) ((int)((c)-&(g)->colors[0])) + +#define XkbGeomPropertiesMask (1<<0) +#define XkbGeomColorsMask (1<<1) +#define XkbGeomShapesMask (1<<2) +#define XkbGeomSectionsMask (1<<3) +#define XkbGeomDoodadsMask (1<<4) +#define XkbGeomKeyAliasesMask (1<<5) +#define XkbGeomAllMask (0x3f) + +typedef struct _XkbcGeometrySizes { + unsigned int which; + unsigned short num_properties; + unsigned short num_colors; + unsigned short num_shapes; + unsigned short num_sections; + unsigned short num_doodads; + unsigned short num_key_aliases; +} XkbcGeometrySizesRec, *XkbcGeometrySizesPtr; + /* Common keyboard description structure */ typedef struct _XkbcDesc { unsigned int defined; @@ -184,9 +478,9 @@ typedef struct _XkbcDesc { XkbcServerMapPtr server; XkbcClientMapPtr map; XkbIndicatorPtr indicators; - XkbNamesPtr names; + XkbcNamesPtr names; XkbcCompatMapPtr compat; - XkbGeometryPtr geom; + XkbcGeometryPtr geom; } XkbcDescRec, *XkbcDescPtr; _XFUNCPROTOBEGIN @@ -250,7 +544,4 @@ XkbcStringToKeysym(const char *s); _XFUNCPROTOEND -#undef KeySym -#undef Atom - #endif /* _XKBCOMMON_H_ */ diff --git a/src/alloc.c b/src/alloc.c index 1d1d069..b0393b9 100644 --- a/src/alloc.c +++ b/src/alloc.c @@ -117,13 +117,13 @@ XkbcFreeCompatMap(XkbcDescPtr xkb, unsigned which, Bool freeMap) int XkbcAllocNames(XkbcDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases) { - XkbNamesPtr names; + XkbcNamesPtr names; if (!xkb) return BadMatch; if (!xkb->names) { - xkb->names = _XkbTypedCalloc(1, XkbNamesRec); + xkb->names = _XkbTypedCalloc(1, XkbcNamesRec); if (!xkb->names) return BadAlloc; } @@ -131,7 +131,7 @@ XkbcAllocNames(XkbcDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases) if ((which & XkbKTLevelNamesMask) && xkb->map && xkb->map->types) { int i; - XkbKeyTypePtr type; + XkbcKeyTypePtr type; type = xkb->map->types; for (i = 0; i < xkb->map->num_types; i++, type++) { @@ -206,7 +206,7 @@ XkbcAllocNames(XkbcDescPtr xkb, unsigned which, int nTotalRG, int nTotalAliases) void XkbcFreeNames(XkbcDescPtr xkb, unsigned which, Bool freeMap) { - XkbNamesPtr names; + XkbcNamesPtr names; if (!xkb || !xkb->names) return; @@ -220,7 +220,7 @@ XkbcFreeNames(XkbcDescPtr xkb, unsigned which, Bool freeMap) if (map && map->types) { int i; - XkbKeyTypePtr type = map->types; + XkbcKeyTypePtr type = map->types; for (i = 0; i < map->num_types; i++, type++) { if (type->level_names) { diff --git a/src/galloc.c b/src/galloc.c index a81d9ba..59cde7c 100644 --- a/src/galloc.c +++ b/src/galloc.c @@ -115,7 +115,7 @@ _XkbFreeGeomNonLeafElems(Bool freeAll, int first, int count, static void _XkbClearProperty(char *prop_in) { - XkbPropertyPtr prop = (XkbPropertyPtr)prop_in; + XkbcPropertyPtr prop = (XkbcPropertyPtr)prop_in; if (prop->name) { _XkbFree(prop->name); @@ -128,17 +128,17 @@ _XkbClearProperty(char *prop_in) } void -XkbcFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll) +XkbcFreeGeomProperties(XkbcGeometryPtr geom, int first, int count, Bool freeAll) { _XkbFreeGeomNonLeafElems(freeAll, first, count, &geom->num_properties, &geom->sz_properties, (char **)&geom->properties, - sizeof(XkbPropertyRec), + sizeof(XkbcPropertyRec), _XkbClearProperty); } void -XkbcFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll) +XkbcFreeGeomKeyAliases(XkbcGeometryPtr geom, int first, int count, Bool freeAll) { _XkbFreeGeomLeafElems(freeAll, first, count, &geom->num_key_aliases, &geom->sz_key_aliases, @@ -149,92 +149,92 @@ XkbcFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll) static void _XkbClearColor(char *color_in) { - XkbColorPtr color = (XkbColorPtr)color_in; + XkbcColorPtr color = (XkbcColorPtr)color_in; if (color->spec) _XkbFree(color->spec); } void -XkbcFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll) +XkbcFreeGeomColors(XkbcGeometryPtr 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(XkbcColorRec), _XkbClearColor); } void -XkbcFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll) +XkbcFreeGeomPoints(XkbcOutlinePtr 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(XkbcPointRec)); } static void _XkbClearOutline(char *outline_in) { - XkbOutlinePtr outline = (XkbOutlinePtr)outline_in; + XkbcOutlinePtr outline = (XkbcOutlinePtr)outline_in; if (outline->points) XkbcFreeGeomPoints(outline, 0, outline->num_points, True); } void -XkbcFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll) +XkbcFreeGeomOutlines(XkbcShapePtr 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(XkbcOutlineRec), _XkbClearOutline); } static void _XkbClearShape(char *shape_in) { - XkbShapePtr shape = (XkbShapePtr)shape_in; + XkbcShapePtr shape = (XkbcShapePtr)shape_in; if (shape->outlines) XkbcFreeGeomOutlines(shape, 0, shape->num_outlines, True); } void -XkbcFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll) +XkbcFreeGeomShapes(XkbcGeometryPtr 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(XkbcShapeRec), _XkbClearShape); } void -XkbcFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, +XkbcFreeGeomOverlayKeys(XkbcOverlayRowPtr 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(XkbcOverlayKeyRec)); } static void _XkbClearOverlayRow(char *row_in) { - XkbOverlayRowPtr row = (XkbOverlayRowPtr)row_in; + XkbcOverlayRowPtr row = (XkbcOverlayRowPtr)row_in; if (row->keys) XkbcFreeGeomOverlayKeys(row, 0, row->num_keys, True); } void -XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count, +XkbcFreeGeomOverlayRows(XkbcOverlayPtr overlay, int first, int count, Bool freeAll) { _XkbFreeGeomNonLeafElems(freeAll, first, count, &overlay->num_rows, &overlay->sz_rows, (char **)&overlay->rows, - sizeof(XkbOverlayRowRec), + sizeof(XkbcOverlayRowRec), _XkbClearOverlayRow); } @@ -242,47 +242,47 @@ XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count, static void _XkbClearOverlay(char *overlay_in) { - XkbOverlayPtr overlay = (XkbOverlayPtr)overlay_in; + XkbcOverlayPtr overlay = (XkbcOverlayPtr)overlay_in; if (overlay->rows) XkbcFreeGeomOverlayRows(overlay, 0, overlay->num_rows, True); } void -XkbcFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll) +XkbcFreeGeomOverlays(XkbcSectionPtr section, int first, int count, Bool freeAll) { _XkbFreeGeomNonLeafElems(freeAll, first, count, §ion->num_overlays, §ion->sz_overlays, (char **)§ion->overlays, - sizeof(XkbOverlayRec), + sizeof(XkbcOverlayRec), _XkbClearOverlay); } void -XkbcFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll) +XkbcFreeGeomKeys(XkbcRowPtr 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(XkbcKeyRec)); } static void _XkbClearRow(char *row_in) { - XkbRowPtr row = (XkbRowPtr)row_in; + XkbcRowPtr row = (XkbcRowPtr)row_in; if (row->keys) XkbcFreeGeomKeys(row, 0, row->num_keys, True); } void -XkbcFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll) +XkbcFreeGeomRows(XkbcSectionPtr 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(XkbcRowRec), _XkbClearRow); } @@ -290,7 +290,7 @@ XkbcFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll) static void _XkbClearSection(char *section_in) { - XkbSectionPtr section = (XkbSectionPtr)section_in; + XkbcSectionPtr section = (XkbcSectionPtr)section_in; if (section->rows) XkbcFreeGeomRows(section, 0, section->num_rows, True); @@ -301,11 +301,11 @@ _XkbClearSection(char *section_in) } void -XkbcFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll) +XkbcFreeGeomSections(XkbcGeometryPtr 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(XkbcSectionRec), _XkbClearSection); } @@ -313,7 +313,7 @@ XkbcFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll) static void _XkbClearDoodad(char *doodad_in) { - XkbDoodadPtr doodad = (XkbDoodadPtr)doodad_in; + XkbcDoodadPtr doodad = (XkbcDoodadPtr)doodad_in; switch (doodad->any.type) { case XkbTextDoodad: @@ -337,10 +337,10 @@ _XkbClearDoodad(char *doodad_in) } void -XkbcFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll) +XkbcFreeGeomDoodads(XkbcDoodadPtr doodads, int nDoodads, Bool freeAll) { int i; - XkbDoodadPtr doodad; + XkbcDoodadPtr doodad; if (doodads) { for (i = 0, doodad = doodads; i < nDoodads; i++, doodad++) @@ -351,7 +351,7 @@ XkbcFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll) } void -XkbcFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap) +XkbcFreeGeometry(XkbcGeometryPtr geom, unsigned which, Bool freeMap) { if (!geom) return; @@ -424,23 +424,23 @@ _XkbGeomAlloc(char **old, unsigned short *num, unsigned short *total, #define _XkbAllocProps(g, n) _XkbGeomAlloc((char **)&(g)->properties, \ &(g)->num_properties, \ &(g)->sz_properties, \ - (n), sizeof(XkbPropertyRec)) + (n), sizeof(XkbcPropertyRec)) #define _XkbAllocColors(g, n) _XkbGeomAlloc((char **)&(g)->colors, \ &(g)->num_colors, \ &(g)->sz_colors, \ - (n), sizeof(XkbColorRec)) + (n), sizeof(XkbcColorRec)) #define _XkbAllocShapes(g, n) _XkbGeomAlloc((char **)&(g)->shapes, \ &(g)->num_shapes, \ &(g)->sz_shapes, \ - (n), sizeof(XkbShapeRec)) + (n), sizeof(XkbcShapeRec)) #define _XkbAllocSections(g, n) _XkbGeomAlloc((char **)&(g)->sections, \ &(g)->num_sections, \ &(g)->sz_sections, \ - (n), sizeof(XkbSectionRec)) + (n), sizeof(XkbcSectionRec)) #define _XkbAllocDoodads(g, n) _XkbGeomAlloc((char **)&(g)->doodads, \ &(g)->num_doodads, \ &(g)->sz_doodads, \ - (n), sizeof(XkbDoodadRec)) + (n), sizeof(XkbcDoodadRec)) #define _XkbAllocKeyAliases(g, n) _XkbGeomAlloc((char **)&(g)->key_aliases, \ &(g)->num_key_aliases, \ &(g)->sz_key_aliases, \ @@ -449,112 +449,112 @@ _XkbGeomAlloc(char **old, unsigned short *num, unsigned short *total, #define _XkbAllocOutlines(s, n) _XkbGeomAlloc((char **)&(s)->outlines, \ &(s)->num_outlines, \ &(s)->sz_outlines, \ - (n), sizeof(XkbOutlineRec)) + (n), sizeof(XkbcOutlineRec)) #define _XkbAllocRows(s, n) _XkbGeomAlloc((char **)&(s)->rows, \ &(s)->num_rows, \ &(s)->sz_rows, \ - (n), sizeof(XkbRowRec)) + (n), sizeof(XkbcRowRec)) #define _XkbAllocPoints(o, n) _XkbGeomAlloc((char **)&(o)->points, \ &(o)->num_points, \ &(o)->sz_points, \ - (n), sizeof(XkbPointRec)) + (n), sizeof(XkbcPointRec)) #define _XkbAllocKeys(r, n) _XkbGeomAlloc((char **)&(r)->keys, \ &(r)->num_keys, \ &(r)->sz_keys, \ - (n), sizeof(XkbKeyRec)) + (n), sizeof(XkbcKeyRec)) #define _XkbAllocOverlays(s, n) _XkbGeomAlloc((char **)&(s)->overlays, \ &(s)->num_overlays, \ &(s)->sz_overlays, \ - (n), sizeof(XkbOverlayRec)) + (n), sizeof(XkbcOverlayRec)) #define _XkbAllocOverlayRows(o, n) _XkbGeomAlloc((char **)&(o)->rows, \ &(o)->num_rows, \ &(o)->sz_rows, \ - (n), sizeof(XkbOverlayRowRec)) + (n), sizeof(XkbcOverlayRowRec)) #define _XkbAllocOverlayKeys(r, n) _XkbGeomAlloc((char **)&(r)->keys, \ &(r)->num_keys, \ &(r)->sz_keys, \ - (n), sizeof(XkbOverlayKeyRec)) + (n), sizeof(XkbcOverlayKeyRec)) int -XkbcAllocGeomProps(XkbGeometryPtr geom, int nProps) +XkbcAllocGeomProps(XkbcGeometryPtr geom, int nProps) { return _XkbAllocProps(geom, nProps); } int -XkbcAllocGeomColors(XkbGeometryPtr geom, int nColors) +XkbcAllocGeomColors(XkbcGeometryPtr geom, int nColors) { return _XkbAllocColors(geom, nColors); } int -XkbcAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases) +XkbcAllocGeomKeyAliases(XkbcGeometryPtr geom, int nKeyAliases) { return _XkbAllocKeyAliases(geom, nKeyAliases); } int -XkbcAllocGeomShapes(XkbGeometryPtr geom, int nShapes) +XkbcAllocGeomShapes(XkbcGeometryPtr geom, int nShapes) { return _XkbAllocShapes(geom, nShapes); } int -XkbcAllocGeomSections(XkbGeometryPtr geom, int nSections) +XkbcAllocGeomSections(XkbcGeometryPtr geom, int nSections) { return _XkbAllocSections(geom, nSections); } int -XkbcAllocGeomOverlays(XkbSectionPtr section, int nOverlays) +XkbcAllocGeomOverlays(XkbcSectionPtr section, int nOverlays) { return _XkbAllocOverlays(section, nOverlays); } int -XkbcAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows) +XkbcAllocGeomOverlayRows(XkbcOverlayPtr overlay, int nRows) { return _XkbAllocOverlayRows(overlay, nRows); } int -XkbcAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys) +XkbcAllocGeomOverlayKeys(XkbcOverlayRowPtr row, int nKeys) { return _XkbAllocOverlayKeys(row, nKeys); } int -XkbcAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads) +XkbcAllocGeomDoodads(XkbcGeometryPtr geom, int nDoodads) { return _XkbAllocDoodads(geom, nDoodads); } int -XkbcAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads) +XkbcAllocGeomSectionDoodads(XkbcSectionPtr section, int nDoodads) { return _XkbAllocDoodads(section, nDoodads); } int -XkbcAllocGeomOutlines(XkbShapePtr shape, int nOL) +XkbcAllocGeomOutlines(XkbcShapePtr shape, int nOL) { return _XkbAllocOutlines(shape, nOL); } int -XkbcAllocGeomRows(XkbSectionPtr section, int nRows) +XkbcAllocGeomRows(XkbcSectionPtr section, int nRows) { return _XkbAllocRows(section, nRows); } int -XkbcAllocGeomPoints(XkbOutlinePtr ol, int nPts) +XkbcAllocGeomPoints(XkbcOutlinePtr ol, int nPts) { return _XkbAllocPoints(ol, nPts); } int -XkbcAllocGeomKeys(XkbRowPtr row, int nKeys) +XkbcAllocGeomKeys(XkbcRowPtr row, int nKeys) { int ret = _XkbAllocKeys(row, nKeys); fprintf(stderr, "!!! allocated %d keys at %p\n", nKeys, row->keys); @@ -562,13 +562,13 @@ XkbcAllocGeomKeys(XkbRowPtr row, int nKeys) } int -XkbcAllocGeometry(XkbcDescPtr xkb, XkbGeometrySizesPtr sizes) +XkbcAllocGeometry(XkbcDescPtr xkb, XkbcGeometrySizesPtr sizes) { - XkbGeometryPtr geom; + XkbcGeometryPtr geom; int rtrn; if (!xkb->geom) { - xkb->geom = _XkbTypedCalloc(1, XkbGeometryRec); + xkb->geom = _XkbTypedCalloc(1, XkbcGeometryRec); if (!xkb->geom) return BadAlloc; } @@ -605,11 +605,11 @@ bail: return rtrn; } -XkbPropertyPtr -XkbcAddGeomProperty(XkbGeometryPtr geom,char *name,char *value) +XkbcPropertyPtr +XkbcAddGeomProperty(XkbcGeometryPtr geom,char *name,char *value) { register int i; -register XkbPropertyPtr prop; +register XkbcPropertyPtr prop; if ((!geom)||(!name)||(!value)) return NULL; @@ -644,7 +644,7 @@ register XkbPropertyPtr prop; } XkbKeyAliasPtr -XkbcAddGeomKeyAlias(XkbGeometryPtr geom,char *aliasStr,char *realStr) +XkbcAddGeomKeyAlias(XkbcGeometryPtr geom,char *aliasStr,char *realStr) { register int i; register XkbKeyAliasPtr alias; @@ -670,11 +670,11 @@ register XkbKeyAliasPtr alias; return alias; } -XkbColorPtr -XkbcAddGeomColor(XkbGeometryPtr geom,char *spec,unsigned int pixel) +XkbcColorPtr +XkbcAddGeomColor(XkbcGeometryPtr geom,char *spec,unsigned int pixel) { register int i; -register XkbColorPtr color; +register XkbcColorPtr color; if ((!geom)||(!spec)) return NULL; @@ -698,10 +698,10 @@ register XkbColorPtr color; return color; } -XkbOutlinePtr -XkbcAddGeomOutline(XkbShapePtr shape,int sz_points) +XkbcOutlinePtr +XkbcAddGeomOutline(XkbcShapePtr shape,int sz_points) { -XkbOutlinePtr outline; +XkbcOutlinePtr outline; if ((!shape)||(sz_points<0)) return NULL; @@ -710,17 +710,17 @@ XkbOutlinePtr outline; return NULL; } outline= &shape->outlines[shape->num_outlines]; - bzero(outline,sizeof(XkbOutlineRec)); + bzero(outline,sizeof(XkbcOutlineRec)); 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) +XkbcShapePtr +XkbcAddGeomShape(XkbcGeometryPtr geom,CARD32 name,int sz_outlines) { -XkbShapePtr shape; +XkbcShapePtr shape; register int i; if ((!geom)||(!name)||(sz_outlines<0)) @@ -735,7 +735,7 @@ register int i; (_XkbAllocShapes(geom,1)!=Success)) return NULL; shape= &geom->shapes[geom->num_shapes]; - bzero(shape,sizeof(XkbShapeRec)); + bzero(shape,sizeof(XkbcShapeRec)); if ((sz_outlines>0)&&(_XkbAllocOutlines(shape,sz_outlines)!=Success)) return NULL; shape->name= name; @@ -744,23 +744,23 @@ register int i; return shape; } -XkbKeyPtr -XkbcAddGeomKey(XkbRowPtr row) +XkbcKeyPtr +XkbcAddGeomKey(XkbcRowPtr row) { -XkbKeyPtr key; +XkbcKeyPtr 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(XkbcKeyRec)); return key; } -XkbRowPtr -XkbcAddGeomRow(XkbSectionPtr section,int sz_keys) +XkbcRowPtr +XkbcAddGeomRow(XkbcSectionPtr section,int sz_keys) { -XkbRowPtr row; +XkbcRowPtr row; if ((!section)||(sz_keys<0)) return NULL; @@ -768,22 +768,22 @@ XkbRowPtr row; (_XkbAllocRows(section,1)!=Success)) return NULL; row= §ion->rows[section->num_rows]; - bzero(row,sizeof(XkbRowRec)); + bzero(row,sizeof(XkbcRowRec)); if ((sz_keys>0)&&(_XkbAllocKeys(row,sz_keys)!=Success)) return NULL; section->num_rows++; return row; } -XkbSectionPtr -XkbcAddGeomSection( XkbGeometryPtr geom, - Atom name, +XkbcSectionPtr +XkbcAddGeomSection( XkbcGeometryPtr geom, + CARD32 name, int sz_rows, int sz_doodads, int sz_over) { register int i; -XkbSectionPtr section; +XkbcSectionPtr section; if ((!geom)||(name==None)||(sz_rows<0)) return NULL; @@ -815,10 +815,10 @@ XkbSectionPtr section; return section; } -XkbDoodadPtr -XkbcAddGeomDoodad(XkbGeometryPtr geom,XkbSectionPtr section,Atom name) +XkbcDoodadPtr +XkbcAddGeomDoodad(XkbcGeometryPtr geom,XkbcSectionPtr section,CARD32 name) { -XkbDoodadPtr old,doodad; +XkbcDoodadPtr old,doodad; register int i,nDoodads; if ((!geom)||(name==None)) @@ -848,21 +848,21 @@ register int i,nDoodads; return NULL; doodad= &geom->doodads[geom->num_doodads++]; } - bzero(doodad,sizeof(XkbDoodadRec)); + bzero(doodad,sizeof(XkbcDoodadRec)); doodad->any.name= name; return doodad; } -XkbOverlayKeyPtr -XkbcAddGeomOverlayKey( XkbOverlayPtr overlay, - XkbOverlayRowPtr row, +XkbcOverlayKeyPtr +XkbcAddGeomOverlayKey( XkbcOverlayPtr overlay, + XkbcOverlayRowPtr row, char * over, char * under) { register int i; -XkbOverlayKeyPtr key; -XkbSectionPtr section; -XkbRowPtr row_under; +XkbcOverlayKeyPtr key; +XkbcSectionPtr section; +XkbcRowPtr row_under; Bool found; if ((!overlay)||(!row)||(!over)||(!under)) @@ -888,11 +888,11 @@ Bool found; return key; } -XkbOverlayRowPtr -XkbcAddGeomOverlayRow(XkbOverlayPtr overlay,int row_under,int sz_keys) +XkbcOverlayRowPtr +XkbcAddGeomOverlayRow(XkbcOverlayPtr overlay,int row_under,int sz_keys) { register int i; -XkbOverlayRowPtr row; +XkbcOverlayRowPtr row; if ((!overlay)||(sz_keys<0)) return NULL; @@ -912,7 +912,7 @@ XkbOverlayRowPtr row; (_XkbAllocOverlayRows(overlay,1)!=Success)) return NULL; row= &overlay->rows[overlay->num_rows]; - bzero(row,sizeof(XkbOverlayRowRec)); + bzero(row,sizeof(XkbcOverlayRowRec)); if ((sz_keys>0)&&(_XkbAllocOverlayKeys(row,sz_keys)!=Success)) return NULL; row->row_under= row_under; @@ -920,11 +920,11 @@ XkbOverlayRowPtr row; return row; } -XkbOverlayPtr -XkbcAddGeomOverlay(XkbSectionPtr section,Atom name,int sz_rows) +XkbcOverlayPtr +XkbcAddGeomOverlay(XkbcSectionPtr section,CARD32 name,int sz_rows) { register int i; -XkbOverlayPtr overlay; +XkbcOverlayPtr overlay; if ((!section)||(name==None)||(sz_rows==0)) return NULL; diff --git a/src/geom.c b/src/geom.c index 9572f01..4793692 100644 --- a/src/geom.c +++ b/src/geom.c @@ -40,7 +40,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE. #endif static void -_XkbCheckBounds(XkbBoundsPtr bounds, int x, int y) +_XkbCheckBounds(XkbcBoundsPtr bounds, int x, int y) { if (x < bounds->x1) bounds->x1 = x; @@ -53,11 +53,11 @@ _XkbCheckBounds(XkbBoundsPtr bounds, int x, int y) } Bool -XkbcComputeShapeBounds(XkbShapePtr shape) +XkbcComputeShapeBounds(XkbcShapePtr shape) { int o, p; - XkbOutlinePtr outline; - XkbPointPtr pt; + XkbcOutlinePtr outline; + XkbcPointPtr pt; if ((!shape) || (shape->num_outlines < 1)) return False; @@ -77,11 +77,11 @@ XkbcComputeShapeBounds(XkbShapePtr shape) } Bool -XkbcComputeShapeTop(XkbShapePtr shape, XkbBoundsPtr bounds) +XkbcComputeShapeTop(XkbcShapePtr shape, XkbcBoundsPtr bounds) { int p; - XkbOutlinePtr outline; - XkbPointPtr pt; + XkbcOutlinePtr outline; + XkbcPointPtr pt; if ((!shape) || (shape->num_outlines < 1)) return False; @@ -107,18 +107,18 @@ XkbcComputeShapeTop(XkbShapePtr shape, XkbBoundsPtr bounds) } Bool -XkbcComputeRowBounds(XkbGeometryPtr geom, XkbSectionPtr section, XkbRowPtr row) +XkbcComputeRowBounds(XkbcGeometryPtr geom, XkbcSectionPtr section, XkbcRowPtr row) { int k, pos; - XkbKeyPtr key; - XkbBoundsPtr bounds, sbounds; + XkbcKeyPtr key; + XkbcBoundsPtr bounds, sbounds; if (!geom || !section || !row) return False; pos = 0; bounds = &row->bounds; - bzero(bounds, sizeof(XkbBoundsRec)); + bzero(bounds, sizeof(XkbcBoundsRec)); for (key = row->keys, pos = k = 0; k < row->num_keys; k++, key++) { sbounds = &XkbKeyShape(geom, key)->bounds; @@ -148,19 +148,19 @@ XkbcComputeRowBounds(XkbGeometryPtr geom, XkbSectionPtr section, XkbRowPtr row) } Bool -XkbcComputeSectionBounds(XkbGeometryPtr geom, XkbSectionPtr section) +XkbcComputeSectionBounds(XkbcGeometryPtr geom, XkbcSectionPtr section) { int i; - XkbShapePtr shape; - XkbRowPtr row; - XkbDoodadPtr doodad; - XkbBoundsPtr bounds, rbounds = NULL; + XkbcShapePtr shape; + XkbcRowPtr row; + XkbcDoodadPtr doodad; + XkbcBoundsPtr bounds, rbounds = NULL; if (!geom || !section) return False; bounds = §ion->bounds; - bzero(bounds, sizeof(XkbBoundsRec)); + bzero(bounds, sizeof(XkbcBoundsRec)); for (i = 0, row = section->rows; i < section->num_rows; i++, row++) { if (!XkbcComputeRowBounds(geom, section, row)) @@ -175,7 +175,7 @@ XkbcComputeSectionBounds(XkbGeometryPtr geom, XkbSectionPtr section) for (i = 0, doodad = section->doodads; i < section->num_doodads; i++, doodad++) { - static XkbBoundsRec tbounds; + static XkbcBoundsRec tbounds; switch (doodad->any.type) { case XkbOutlineDoodad: diff --git a/src/malloc.c b/src/malloc.c index 0211264..7bcea7c 100644 --- a/src/malloc.c +++ b/src/malloc.c @@ -59,7 +59,7 @@ XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes) if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) { if (!map->types) { - map->types = _XkbTypedCalloc(nTotalTypes, XkbKeyTypeRec); + map->types = _XkbTypedCalloc(nTotalTypes, XkbcKeyTypeRec); if (!map->types) return BadAlloc; @@ -67,10 +67,10 @@ XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes) map->size_types = nTotalTypes; } else if (map->size_types < nTotalTypes) { - XkbKeyTypeRec *prev_types = map->types; + XkbcKeyTypeRec *prev_types = map->types; map->types = _XkbTypedRealloc(map->types, nTotalTypes, - XkbKeyTypeRec); + XkbcKeyTypeRec); if (!map->types) { _XkbFree(prev_types); map->num_types = map->size_types = 0; @@ -79,7 +79,7 @@ XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes) map->size_types = nTotalTypes; bzero(&map->types[map->num_types], - (map->size_types - map->num_types) * sizeof(XkbKeyTypeRec)); + (map->size_types - map->num_types) * sizeof(XkbcKeyTypeRec)); } } @@ -231,7 +231,7 @@ XkbcAllocServerMap(XkbcDescPtr xkb, unsigned which, unsigned nNewActions) } int -XkbcCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into) +XkbcCopyKeyType(XkbcKeyTypePtr from, XkbcKeyTypePtr into) { if (!from || !into) return BadMatch; @@ -279,7 +279,7 @@ XkbcCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into) } int -XkbcCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types) +XkbcCopyKeyTypes(XkbcKeyTypePtr from, XkbcKeyTypePtr into, int num_types) { int i, rtrn; @@ -298,7 +298,7 @@ int XkbcResizeKeyType(XkbcDescPtr xkb, int type_ndx, int map_count, Bool want_preserve, int new_num_lvls) { - XkbKeyTypePtr type; + XkbcKeyTypePtr type; KeyCode matchingKeys[XkbMaxKeyCount], nMatchingKeys; if ((type_ndx < 0) || (type_ndx >= xkb->map->num_types) || @@ -891,7 +891,7 @@ XkbcFreeClientMap(XkbcDescPtr xkb, unsigned what, Bool freeMap) if (map->types) { if (map->num_types > 0) { int i; - XkbKeyTypePtr type; + XkbcKeyTypePtr type; for (i = 0, type = map->types; i < map->num_types; i++, type++) { if (type->map) { diff --git a/src/misc.c b/src/misc.c index d568fc8..2a1f9cd 100644 --- a/src/misc.c +++ b/src/misc.c @@ -56,7 +56,7 @@ static XkbKTMapEntryRec mapKeypad[]= { { False, 0, { 1, 0, NL_VMOD_MASK } } }; -static XkbKeyTypeRec canonicalTypes[XkbNumRequiredTypes] = { +static XkbcKeyTypeRec canonicalTypes[XkbNumRequiredTypes] = { { { 0, 0, 0 }, 1, /* num_levels */ 0, /* map_count */ @@ -87,7 +87,7 @@ int XkbcInitCanonicalKeyTypes(XkbcDescPtr xkb, unsigned which, int keypadVMod) { XkbcClientMapPtr map; - XkbKeyTypePtr from,to; + XkbcKeyTypePtr from,to; int rtrn; if (!xkb) @@ -116,7 +116,7 @@ XkbcInitCanonicalKeyTypes(XkbcDescPtr xkb, unsigned which, int keypadVMod) &to[XkbAlphabeticIndex]); if ((which & XkbKeypadMask) && (rtrn == Success)) { - XkbKeyTypePtr type; + XkbcKeyTypePtr type; rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]); type = &to[XkbKeypadIndex]; diff --git a/src/xkb.c b/src/xkb.c index 7ebe856..f5a1a0f 100644 --- a/src/xkb.c +++ b/src/xkb.c @@ -98,7 +98,7 @@ XkbcCanonicaliseComponents(XkbComponentNamesPtr names, } Bool -XkbcComputeEffectiveMap(XkbcDescPtr xkb, XkbKeyTypePtr type, +XkbcComputeEffectiveMap(XkbcDescPtr xkb, XkbcKeyTypePtr type, unsigned char *map_rtrn) { int i; diff --git a/src/xkballoc.h b/src/xkballoc.h index 0decf87..af0166b 100644 --- a/src/xkballoc.h +++ b/src/xkballoc.h @@ -73,10 +73,10 @@ extern int XkbcAllocServerMap(XkbcDescPtr xkb, unsigned which, unsigned nNewActions); extern int -XkbcCopyKeyType(XkbKeyTypePtr from, XkbKeyTypePtr into); +XkbcCopyKeyType(XkbcKeyTypePtr from, XkbcKeyTypePtr into); extern int -XkbcCopyKeyTypes(XkbKeyTypePtr from, XkbKeyTypePtr into, int num_types); +XkbcCopyKeyTypes(XkbcKeyTypePtr from, XkbcKeyTypePtr into, int num_types); extern int XkbcResizeKeyType(XkbcDescPtr xkb, int type_ndx, int map_count, diff --git a/src/xkbcomp/alias.c b/src/xkbcomp/alias.c index 97b7b48..665c34f 100644 --- a/src/xkbcomp/alias.c +++ b/src/xkbcomp/alias.c @@ -32,8 +32,6 @@ #include "alias.h" #include "keycodes.h" -#include - static void HandleCollision(AliasInfo * old, AliasInfo * new) { @@ -237,8 +235,8 @@ ApplyAliases(XkbcDescPtr xkb, Bool toGeom, AliasInfo ** info_in) { if (!xkb->geom) { - XkbGeometrySizesRec sizes; - bzero((char *) &sizes, sizeof(XkbGeometrySizesRec)); + XkbcGeometrySizesRec sizes; + bzero((char *) &sizes, sizeof(XkbcGeometrySizesRec)); sizes.which = XkbGeomKeyAliasesMask; sizes.num_key_aliases = nOld + nNew; status = XkbcAllocGeometry(xkb, &sizes); diff --git a/src/xkbcomp/expr.c b/src/xkbcomp/expr.c index 6d67d08..514868f 100644 --- a/src/xkbcomp/expr.c +++ b/src/xkbcomp/expr.c @@ -156,7 +156,7 @@ ExprResolveLhs(ExprDef * expr, Bool SimpleLookup(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { LookupEntry *entry; register char *str; @@ -184,7 +184,7 @@ SimpleLookup(char * priv, Bool RadioLookup(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { register char *str; int rg; @@ -212,7 +212,7 @@ RadioLookup(char * priv, int TableLookup(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { LookupTable *tbl = (LookupTable *) priv; register char *str; @@ -233,7 +233,7 @@ TableLookup(char * priv, if (tbl == NULL) /* didn't find a matching element */ return False; priv = (char *) tbl->entries; - return SimpleLookup(priv, (Atom) None, field, type, val_rtrn); + return SimpleLookup(priv, (CARD32) None, field, type, val_rtrn); } static LookupEntry modIndexNames[] = { @@ -251,7 +251,7 @@ static LookupEntry modIndexNames[] = { int LookupModIndex(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { return SimpleLookup((char *) modIndexNames, elem, field, type, val_rtrn); @@ -259,7 +259,7 @@ LookupModIndex(char * priv, int LookupModMask(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { char *str; Bool ret = True; @@ -317,7 +317,7 @@ ExprResolveModIndex(ExprDef * expr, val_rtrn->ival = expr->value.ival; return True; case ExprIdent: - if (LookupModIndex(lookupPriv, (Atom) None, expr->value.str, + if (LookupModIndex(lookupPriv, (CARD32) None, expr->value.str, (unsigned) TypeInt, val_rtrn)) { return True; @@ -915,7 +915,7 @@ ExprResolveEnum(ExprDef * expr, ExprResult * val_rtrn, LookupEntry * values) exprOpText(expr->op)); return False; } - if (!SimpleLookup((char *) values, (Atom) None, expr->value.str, + if (!SimpleLookup((char *) values, (CARD32) None, expr->value.str, (unsigned) TypeInt, val_rtrn)) { int nOut = 0; diff --git a/src/xkbcomp/expr.h b/src/xkbcomp/expr.h index 6bec888..fb1fa97 100644 --- a/src/xkbcomp/expr.h +++ b/src/xkbcomp/expr.h @@ -36,8 +36,8 @@ typedef union _ExprResult } ExprResult; typedef Bool(*IdentLookupFunc) (char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); @@ -76,36 +76,36 @@ extern char *exprOpText(unsigned /* type */ ); extern int RadioLookup(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); extern int SimpleLookup(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); extern int TableLookup(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); extern int LookupModIndex(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); extern int LookupModMask(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); diff --git a/src/xkbcomp/geometry.c b/src/xkbcomp/geometry.c index 5ba3f5b..59d446b 100644 --- a/src/xkbcomp/geometry.c +++ b/src/xkbcomp/geometry.c @@ -37,8 +37,6 @@ #include "keycodes.h" #include "alias.h" -#include - #define DFLT_FONT "helvetica" #define DFLT_SLANT "r" #define DFLT_WEIGHT "medium" @@ -60,13 +58,13 @@ typedef struct _PropertyInfo typedef struct _ShapeInfo { CommonInfo defs; - Atom name; + CARD32 name; short index; unsigned short nOutlines; unsigned short szOutlines; - XkbOutlinePtr outlines; - XkbOutlinePtr approx; - XkbOutlinePtr primary; + XkbcOutlinePtr outlines; + XkbcOutlinePtr approx; + XkbcOutlinePtr primary; int dfltCornerRadius; } ShapeInfo; @@ -99,7 +97,7 @@ typedef struct _ShapeInfo typedef struct _DoodadInfo { CommonInfo defs; - Atom name; + CARD32 name; unsigned char type; unsigned char priority; short top; @@ -108,18 +106,18 @@ typedef struct _DoodadInfo 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; + CARD32 shape; + CARD32 color; + CARD32 offColor; + CARD32 text; + CARD32 font; + CARD32 fontSlant; + CARD32 fontWeight; + CARD32 fontSetWidth; + CARD32 fontVariant; unsigned short fontSize; - Atom fontEncoding; - Atom fontSpec; + CARD32 fontEncoding; + CARD32 fontSpec; char *logoName; struct _SectionInfo *section; } DoodadInfo; @@ -139,8 +137,8 @@ typedef struct _KeyInfo char name[8]; short gap; short index; - Atom shape; - Atom color; + CARD32 shape; + CARD32 color; struct _RowInfo *row; } KeyInfo; #define keyText(k) ((k)&&(k)->name[0]?(k)->name:"default") @@ -177,7 +175,7 @@ typedef struct _OverlayKeyInfo typedef struct _OverlayInfo { CommonInfo defs; - Atom name; + CARD32 name; unsigned short nRows; unsigned short nKeys; OverlayKeyInfo *keys; @@ -197,7 +195,7 @@ typedef struct _OverlayInfo typedef struct _SectionInfo { CommonInfo defs; - Atom name; + CARD32 name; unsigned short top; unsigned short left; unsigned short width; @@ -235,16 +233,16 @@ typedef struct _GeometryInfo DoodadInfo *doodads; int widthMM; int heightMM; - Atom font; - Atom fontSlant; - Atom fontWeight; - Atom fontSetWidth; - Atom fontVariant; + CARD32 font; + CARD32 fontSlant; + CARD32 fontWeight; + CARD32 fontSetWidth; + CARD32 fontVariant; unsigned fontSize; - Atom fontEncoding; - Atom fontSpec; - Atom baseColor; - Atom labelColor; + CARD32 fontEncoding; + CARD32 fontSpec; + CARD32 baseColor; + CARD32 labelColor; int dfltCornerRadius; SectionInfo dfltSection; DoodadInfo *dfltDoodads; @@ -430,7 +428,7 @@ FindDoodadByType(DoodadInfo * di, unsigned type) } static DoodadInfo * -FindDoodadByName(DoodadInfo * di, Atom name) +FindDoodadByName(DoodadInfo * di, CARD32 name) { while (di) { @@ -796,7 +794,7 @@ NextShape(GeometryInfo * info) } static ShapeInfo * -FindShape(GeometryInfo * info, Atom name, const char *type, const char *which) +FindShape(GeometryInfo * info, CARD32 name, const char *type, const char *which) { ShapeInfo *old; @@ -1512,7 +1510,7 @@ SetTextDoodadField(DoodadInfo * di, char *typeName = "text doodad"; union { - Atom *str; + CARD32 *str; short *ival; unsigned short *uval; } pField; @@ -2120,7 +2118,7 @@ HandleGeometryVar(VarDef * stmt, XkbcDescPtr xkb, GeometryInfo * info) ExprResult elem, field, tmp; ExprDef *ndx; DoodadInfo *di; - Atom *pField = NULL; + CARD32 *pField = NULL; int ret; if (ExprResolveLhs(stmt->name, &elem, &field, &ndx) == 0) @@ -2400,7 +2398,7 @@ HandleShapeBody(ShapeDef * def, ShapeInfo * si, unsigned merge, { OutlineDef *ol; int nOut, nPt; - XkbOutlinePtr outline; + XkbcOutlinePtr outline; ExprDef *pt; if (def->nOutlines < 1) @@ -2410,7 +2408,7 @@ HandleShapeBody(ShapeDef * def, ShapeInfo * si, unsigned merge, return True; } si->nOutlines = def->nOutlines; - si->outlines = uTypedCalloc(def->nOutlines, XkbOutlineRec); + si->outlines = uTypedCalloc(def->nOutlines, XkbcOutlineRec); if (!si->outlines) { ERROR("Couldn't allocate outlines for \"%s\"\n", shText(si)); @@ -2430,7 +2428,7 @@ HandleShapeBody(ShapeDef * def, ShapeInfo * si, unsigned merge, 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, XkbcPointRec); if (!outline->points) { ERROR("Can't allocate points for \"%s\"\n", shText(si)); @@ -2925,12 +2923,12 @@ HandleGeometryFile(XkbFile * file, /***====================================================================***/ static Bool -CopyShapeDef(XkbGeometryPtr geom, ShapeInfo * si) +CopyShapeDef(XkbcGeometryPtr geom, ShapeInfo * si) { register int i, n; - XkbShapePtr shape; - XkbOutlinePtr old_outline, outline; - Atom name; + XkbcShapePtr shape; + XkbcOutlinePtr old_outline, outline; + CARD32 name; si->index = geom->num_shapes; name = si->name; @@ -2952,7 +2950,7 @@ CopyShapeDef(XkbGeometryPtr geom, ShapeInfo * si) return False; } n = old_outline->num_points; - memcpy(outline->points, old_outline->points, n * sizeof(XkbPointRec)); + memcpy(outline->points, old_outline->points, n * sizeof(XkbcPointRec)); outline->num_points = old_outline->num_points; outline->corner_radius = old_outline->corner_radius; } @@ -3257,10 +3255,10 @@ VerifyDoodadInfo(DoodadInfo * di, GeometryInfo * info) #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(CARD32 fontTok, + CARD32 weightTok, + CARD32 slantTok, + CARD32 setWidthTok, CARD32 varTok, int size, CARD32 encodingTok) { int totalSize; char *font, *weight, *slant, *setWidth, *variant, *encoding; @@ -3287,13 +3285,13 @@ FontFromParts(Atom fontTok, } static Bool -CopyDoodadDef(XkbGeometryPtr geom, - XkbSectionPtr section, DoodadInfo * di, GeometryInfo * info) +CopyDoodadDef(XkbcGeometryPtr geom, + XkbcSectionPtr section, DoodadInfo * di, GeometryInfo * info) { - Atom name; - XkbDoodadPtr doodad; - XkbColorPtr color; - XkbShapePtr shape; + CARD32 name; + XkbcDoodadPtr doodad; + XkbcColorPtr color; + XkbcShapePtr shape; ShapeInfo *si; if (!VerifyDoodadInfo(di, info)) @@ -3375,15 +3373,15 @@ CopyDoodadDef(XkbGeometryPtr geom, /***====================================================================***/ static Bool -VerifyOverlayInfo(XkbGeometryPtr geom, - XkbSectionPtr section, +VerifyOverlayInfo(XkbcGeometryPtr geom, + XkbcSectionPtr section, OverlayInfo * oi, GeometryInfo * info, short rowMap[256], short rowSize[256]) { register OverlayKeyInfo *ki, *next; unsigned long oKey, uKey, sKey; - XkbRowPtr row; - XkbKeyPtr key; + XkbcRowPtr row; + XkbcKeyPtr key; int r, k; /* find out which row each key is in */ @@ -3472,13 +3470,13 @@ VerifyOverlayInfo(XkbGeometryPtr geom, } static Bool -CopyOverlayDef(XkbGeometryPtr geom, - XkbSectionPtr section, OverlayInfo * oi, GeometryInfo * info) +CopyOverlayDef(XkbcGeometryPtr geom, + XkbcSectionPtr section, OverlayInfo * oi, GeometryInfo * info) { - Atom name; - XkbOverlayPtr ol; - XkbOverlayRowPtr row; - XkbOverlayKeyPtr key; + CARD32 name; + XkbcOverlayPtr ol; + XkbcOverlayRowPtr row; + XkbcOverlayKeyPtr key; OverlayKeyInfo *ki; short rowMap[256], rowSize[256]; int i; @@ -3514,7 +3512,7 @@ CopyOverlayDef(XkbGeometryPtr geom, { row = &ol->rows[ki->overlayRow]; key = &row->keys[row->num_keys++]; - bzero(key, sizeof(XkbOverlayKeyRec)); + bzero(key, sizeof(XkbcOverlayKeyRec)); strncpy(key->over.name, ki->over, XkbKeyNameLength); strncpy(key->under.name, ki->under, XkbKeyNameLength); } @@ -3524,11 +3522,11 @@ CopyOverlayDef(XkbGeometryPtr geom, /***====================================================================***/ static Bool -CopySectionDef(XkbGeometryPtr geom, SectionInfo * si, GeometryInfo * info) +CopySectionDef(XkbcGeometryPtr geom, SectionInfo * si, GeometryInfo * info) { - XkbSectionPtr section; - XkbRowPtr row; - XkbKeyPtr key; + XkbcSectionPtr section; + XkbcRowPtr row; + XkbcKeyPtr key; KeyInfo *ki; RowInfo *ri; @@ -3560,7 +3558,7 @@ CopySectionDef(XkbGeometryPtr geom, SectionInfo * si, GeometryInfo * info) row->vertical = ri->vertical; for (ki = ri->keys; ki != NULL; ki = (KeyInfo *) ki->defs.next) { - XkbColorPtr color; + XkbcColorPtr color; if ((ki->defs.defined & _GK_Name) == 0) { ERROR("Key %d of row %d in section %s has no name\n", @@ -3636,8 +3634,8 @@ CompileGeometry(XkbFile *file, XkbcDescPtr xkb, unsigned merge) if (info.errorCount == 0) { - XkbGeometryPtr geom; - XkbGeometrySizesRec sizes; + XkbcGeometryPtr geom; + XkbcGeometrySizesRec sizes; bzero(&sizes, sizeof(sizes)); sizes.which = XkbGeomAllMask; sizes.num_properties = info.nProps; diff --git a/src/xkbcomp/indicators.c b/src/xkbcomp/indicators.c index 726d37b..e2e8488 100644 --- a/src/xkbcomp/indicators.c +++ b/src/xkbcomp/indicators.c @@ -513,7 +513,7 @@ BindIndicators(XkbcDescPtr xkb, Bool force, LEDInfo *unbound, if ((xkb->names != NULL) && (xkb->names->indicators[led->indicator - 1] != led->name)) { - Atom old = xkb->names->indicators[led->indicator - 1]; + CARD32 old = xkb->names->indicators[led->indicator - 1]; ERROR("Multiple names bound to indicator %d\n", (unsigned int) led->indicator); ACTION("Using %s, ignoring %s\n", diff --git a/src/xkbcomp/indicators.h b/src/xkbcomp/indicators.h index f9c2195..23d879e 100644 --- a/src/xkbcomp/indicators.h +++ b/src/xkbcomp/indicators.h @@ -40,7 +40,7 @@ typedef struct _LEDInfo { CommonInfo defs; - Atom name; + CARD32 name; unsigned char indicator; unsigned char flags; unsigned char which_mods; diff --git a/src/xkbcomp/keycodes.c b/src/xkbcomp/keycodes.c index 70bcdbe..e8b6df2 100644 --- a/src/xkbcomp/keycodes.c +++ b/src/xkbcomp/keycodes.c @@ -60,7 +60,7 @@ typedef struct _IndicatorNameInfo { CommonInfo defs; int ndx; - Atom name; + CARD32 name; Bool virtual; } IndicatorNameInfo; @@ -142,7 +142,7 @@ FindIndicatorByIndex(KeyNamesInfo * info, int ndx) } static IndicatorNameInfo * -FindIndicatorByName(KeyNamesInfo * info, Atom name) +FindIndicatorByName(KeyNamesInfo * info, CARD32 name) { IndicatorNameInfo *old; @@ -227,7 +227,7 @@ AddIndicatorName(KeyNamesInfo * info, IndicatorNameInfo * new) else { const char *oldType, *newType; - Atom using, ignoring; + CARD32 using, ignoring; if (old->virtual) oldType = "virtual indicator"; else @@ -857,7 +857,7 @@ CompileKeycodes(XkbFile *file, XkbcDescPtr xkb, unsigned merge) } else { - WSGO("Cannot create XkbNamesRec in CompileKeycodes\n"); + WSGO("Cannot create XkbcNamesRec in CompileKeycodes\n"); return False; } if (info.leds) diff --git a/src/xkbcomp/keytypes.c b/src/xkbcomp/keytypes.c index dec9893..786052c 100644 --- a/src/xkbcomp/keytypes.c +++ b/src/xkbcomp/keytypes.c @@ -52,7 +52,7 @@ typedef struct _PreserveInfo typedef struct _KeyTypeInfo { CommonInfo defs; - Atom name; + CARD32 name; int fileID; unsigned mask; unsigned vmask; @@ -63,7 +63,7 @@ typedef struct _KeyTypeInfo XkbKTMapEntryPtr entries; PreserveInfo *preserve; int szNames; - Atom *lvlNames; + CARD32 *lvlNames; } KeyTypeInfo; typedef struct _KeyTypesInfo @@ -78,10 +78,10 @@ typedef struct _KeyTypesInfo VModInfo vmods; } KeyTypesInfo; -Atom tok_ONE_LEVEL; -Atom tok_TWO_LEVEL; -Atom tok_ALPHABETIC; -Atom tok_KEYPAD; +CARD32 tok_ONE_LEVEL; +CARD32 tok_TWO_LEVEL; +CARD32 tok_ALPHABETIC; +CARD32 tok_KEYPAD; /***====================================================================***/ @@ -108,7 +108,7 @@ extern Bool AddPreserve(XkbcDescPtr /* xkb */ , extern Bool AddLevelName(KeyTypeInfo * /* type */ , unsigned /* level */ , - Atom /* name */ , + CARD32 /* name */ , Bool /* clobber */ , Bool /* report */ ); @@ -168,10 +168,10 @@ InitKeyTypesInfo(KeyTypesInfo * info, XkbcDescPtr xkb, KeyTypesInfo * from) } if (from->dflt.lvlNames) { - info->dflt.lvlNames = uTypedCalloc(from->dflt.szNames, Atom); + info->dflt.lvlNames = uTypedCalloc(from->dflt.szNames, CARD32); if (info->dflt.lvlNames) { - register unsigned sz = from->dflt.szNames * sizeof(Atom); + register unsigned sz = from->dflt.szNames * sizeof(CARD32); memcpy(info->dflt.lvlNames, from->dflt.lvlNames, sz); } } @@ -783,12 +783,12 @@ SetPreserve(KeyTypeInfo * type, Bool AddLevelName(KeyTypeInfo * type, - unsigned level, Atom name, Bool clobber, Bool report) + unsigned level, CARD32 name, Bool clobber, Bool report) { if ((type->lvlNames == NULL) || (type->szNames <= level)) { type->lvlNames = - uTypedRecalloc(type->lvlNames, type->szNames, level + 1, Atom); + uTypedRecalloc(type->lvlNames, type->szNames, level + 1, CARD32); if (type->lvlNames == NULL) { ERROR("Couldn't allocate level names for type %s\n", @@ -837,7 +837,7 @@ SetLevelName(KeyTypeInfo * type, ExprDef * arrayNdx, ExprDef * value) { ExprResult rtrn; unsigned level; - Atom level_name; + CARD32 level_name; if (arrayNdx == NULL) return ReportTypeShouldBeArray(type, "level name"); @@ -1126,7 +1126,7 @@ HandleKeyTypesFile(XkbFile * file, } static Bool -CopyDefToKeyType(XkbcDescPtr xkb, XkbKeyTypePtr type, KeyTypeInfo * def) +CopyDefToKeyType(XkbcDescPtr xkb, XkbcKeyTypePtr type, KeyTypeInfo * def) { register int i; PreserveInfo *pre; @@ -1177,7 +1177,7 @@ CopyDefToKeyType(XkbcDescPtr xkb, XkbKeyTypePtr type, KeyTypeInfo * def) } else type->preserve = NULL; - type->name = (Atom) def->name; + type->name = (CARD32) def->name; if (def->szNames > 0) { type->level_names = uTypedCalloc(def->numLevels, CARD32); @@ -1211,7 +1211,7 @@ CompileKeyTypes(XkbFile *file, XkbcDescPtr xkb, unsigned merge) { register int i; register KeyTypeInfo *def; - register XkbKeyTypePtr type, next; + register XkbcKeyTypePtr type, next; if (info.name != NULL) { diff --git a/src/xkbcomp/listing.c b/src/xkbcomp/listing.c index a2bb9fc..9683aa5 100644 --- a/src/xkbcomp/listing.c +++ b/src/xkbcomp/listing.c @@ -122,7 +122,6 @@ SOFTWARE. #include "parseutils.h" #include "misc.h" #include "tokens.h" -#include #ifndef DFLT_XKB_CONFIG_ROOT #define DFLT_XKB_CONFIG_ROOT "/usr/share/X11/xkb" diff --git a/src/xkbcomp/misc.c b/src/xkbcomp/misc.c index 73766d5..abb0a0a 100644 --- a/src/xkbcomp/misc.c +++ b/src/xkbcomp/misc.c @@ -34,8 +34,6 @@ #include #include "parseutils.h" -#include - /***====================================================================***/ /** diff --git a/src/xkbcomp/parseutils.c b/src/xkbcomp/parseutils.c index f2847e2..b3a7c0b 100644 --- a/src/xkbcomp/parseutils.c +++ b/src/xkbcomp/parseutils.c @@ -29,7 +29,6 @@ #include "xkbmisc.h" #include "xkbpath.h" #include -#include #include XkbFile *rtrnValue; @@ -167,7 +166,7 @@ KeyAliasCreate(char *alias, char *real) } VModDef * -VModCreate(Atom name, ExprDef * value) +VModCreate(CARD32 name, ExprDef * value) { VModDef *def; def = uTypedAlloc(VModDef); @@ -207,7 +206,7 @@ VarCreate(ExprDef * name, ExprDef * value) } VarDef * -BoolVarCreate(Atom nameToken, unsigned set) +BoolVarCreate(CARD32 nameToken, unsigned set) { ExprDef *name, *value; @@ -240,7 +239,7 @@ InterpCreate(char *sym, ExprDef * match) } KeyTypeDef * -KeyTypeCreate(Atom name, VarDef * body) +KeyTypeCreate(CARD32 name, VarDef * body) { KeyTypeDef *def; @@ -307,7 +306,7 @@ GroupCompatCreate(int group, ExprDef * val) } ModMapDef * -ModMapCreate(Atom modifier, ExprDef * keys) +ModMapCreate(CARD32 modifier, ExprDef * keys) { ModMapDef *def; @@ -329,7 +328,7 @@ ModMapCreate(Atom modifier, ExprDef * keys) } IndicatorMapDef * -IndicatorMapCreate(Atom name, VarDef * body) +IndicatorMapCreate(CARD32 name, VarDef * body) { IndicatorMapDef *def; @@ -374,7 +373,7 @@ IndicatorNameCreate(int ndx, ExprDef * name, Bool virtual) } ExprDef * -ActionCreate(Atom name, ExprDef * args) +ActionCreate(CARD32 name, ExprDef * args) { ExprDef *act; @@ -414,7 +413,7 @@ CreateKeysymList(char *sym) } ShapeDef * -ShapeDeclCreate(Atom name, OutlineDef * outlines) +ShapeDeclCreate(CARD32 name, OutlineDef * outlines) { ShapeDef *shape; OutlineDef *ol; @@ -439,7 +438,7 @@ ShapeDeclCreate(Atom name, OutlineDef * outlines) } OutlineDef * -OutlineCreate(Atom field, ExprDef * points) +OutlineCreate(CARD32 field, ExprDef * points) { OutlineDef *outline; ExprDef *pt; @@ -517,7 +516,7 @@ RowDeclCreate(KeyDef * keys) } SectionDef * -SectionDeclCreate(Atom name, RowDef * rows) +SectionDeclCreate(CARD32 name, RowDef * rows) { SectionDef *section; RowDef *row; @@ -561,7 +560,7 @@ OverlayKeyCreate(char *under, char *over) } OverlayDef * -OverlayDeclCreate(Atom name, OverlayKeyDef * keys) +OverlayDeclCreate(CARD32 name, OverlayKeyDef * keys) { OverlayDef *ol; OverlayKeyDef *key; @@ -583,7 +582,7 @@ OverlayDeclCreate(Atom name, OverlayKeyDef * keys) } DoodadDef * -DoodadCreate(unsigned type, Atom name, VarDef * body) +DoodadCreate(unsigned type, CARD32 name, VarDef * body) { DoodadDef *doodad; diff --git a/src/xkbcomp/parseutils.h b/src/xkbcomp/parseutils.h index d96a20b..623347a 100644 --- a/src/xkbcomp/parseutils.h +++ b/src/xkbcomp/parseutils.h @@ -76,7 +76,7 @@ extern KeyAliasDef *KeyAliasCreate(char * /* alias */ , char * /* real */ ); -extern VModDef *VModCreate(Atom /* name */ , +extern VModDef *VModCreate(CARD32 /* name */ , ExprDef * /* value */ ); @@ -84,7 +84,7 @@ extern VarDef *VarCreate(ExprDef * /* name */ , ExprDef * /* value */ ); -extern VarDef *BoolVarCreate(Atom /* nameToken */ , +extern VarDef *BoolVarCreate(CARD32 /* nameToken */ , unsigned /* set */ ); @@ -92,7 +92,7 @@ extern InterpDef *InterpCreate(char * /* sym */ , ExprDef * /* match */ ); -extern KeyTypeDef *KeyTypeCreate(Atom /* name */ , +extern KeyTypeDef *KeyTypeCreate(CARD32 /* name */ , VarDef * /* body */ ); @@ -104,11 +104,11 @@ extern GroupCompatDef *GroupCompatCreate(int /* group */ , ExprDef * /* def */ ); -extern ModMapDef *ModMapCreate(Atom /* modifier */ , +extern ModMapDef *ModMapCreate(CARD32 /* modifier */ , ExprDef * /* keys */ ); -extern IndicatorMapDef *IndicatorMapCreate(Atom /* name */ , +extern IndicatorMapDef *IndicatorMapCreate(CARD32 /* name */ , VarDef * /* body */ ); @@ -117,18 +117,18 @@ extern IndicatorNameDef *IndicatorNameCreate(int /* ndx */ , Bool /* virtual */ ); -extern ExprDef *ActionCreate(Atom /* name */ , +extern ExprDef *ActionCreate(CARD32 /* name */ , ExprDef * /* args */ ); extern ExprDef *CreateKeysymList(char * /* sym */ ); -extern ShapeDef *ShapeDeclCreate(Atom /* name */ , +extern ShapeDef *ShapeDeclCreate(CARD32 /* name */ , OutlineDef * /* outlines */ ); -extern OutlineDef *OutlineCreate(Atom /* field */ , +extern OutlineDef *OutlineCreate(CARD32 /* field */ , ExprDef * /* points */ ); @@ -143,7 +143,7 @@ extern KeyDef *KeyDeclMerge(KeyDef * /* into */ , extern RowDef *RowDeclCreate(KeyDef * /* keys */ ); -extern SectionDef *SectionDeclCreate(Atom /* name */ , +extern SectionDef *SectionDeclCreate(CARD32 /* name */ , RowDef * /* rows */ ); @@ -151,12 +151,12 @@ extern OverlayKeyDef *OverlayKeyCreate(char * /* under */ , char * /* over */ ); -extern OverlayDef *OverlayDeclCreate(Atom /* name */ , +extern OverlayDef *OverlayDeclCreate(CARD32 /* name */ , OverlayKeyDef * /* rows */ ); extern DoodadDef *DoodadCreate(unsigned /* type */ , - Atom /* name */ , + CARD32 /* name */ , VarDef * /* body */ ); diff --git a/src/xkbcomp/symbols.c b/src/xkbcomp/symbols.c index 69964ad..e85c29f 100644 --- a/src/xkbcomp/symbols.c +++ b/src/xkbcomp/symbols.c @@ -42,9 +42,9 @@ #include "misc.h" #include "alias.h" -extern Atom tok_ONE_LEVEL; -extern Atom tok_TWO_LEVEL; -extern Atom tok_KEYPAD; +extern CARD32 tok_ONE_LEVEL; +extern CARD32 tok_TWO_LEVEL; +extern CARD32 tok_KEYPAD; /***====================================================================***/ @@ -72,13 +72,13 @@ typedef struct _KeyInfo short numLevels[XkbNumKbdGroups]; CARD32 *syms[XkbNumKbdGroups]; XkbcAction *acts[XkbNumKbdGroups]; - Atom types[XkbNumKbdGroups]; + CARD32 types[XkbNumKbdGroups]; unsigned repeat; XkbBehavior behavior; unsigned short vmodmap; unsigned long nameForOverlayKey; unsigned long allowNone; - Atom dfltType; + CARD32 dfltType; } KeyInfo; /** @@ -234,7 +234,7 @@ typedef struct _SymbolsInfo KeyInfo dflt; VModInfo vmods; ActionInfo *action; - Atom groupNames[XkbNumKbdGroups]; + CARD32 groupNames[XkbNumKbdGroups]; ModMapEntry *modMap; AliasInfo *aliases; @@ -540,7 +540,7 @@ MergeKeys(SymbolsInfo * info, KeyInfo * into, KeyInfo * from) if ((into->types[i] != None) && (report) && (into->types[i] != from->types[i])) { - Atom use, ignore; + CARD32 use, ignore; collide |= _Key_Types; if (from->defs.merge != MergeAugment) { @@ -1569,7 +1569,7 @@ SetExplicitGroup(SymbolsInfo * info, KeyInfo * key) if (key->acts[i] != NULL) uFree(key->acts[i]); key->acts[i] = (XkbcAction *) NULL; - key->types[i] = (Atom) 0; + key->types[i] = (CARD32) 0; } } key->typesDefined = key->symsDefined = key->actsDefined = 1 << group; @@ -1581,7 +1581,7 @@ SetExplicitGroup(SymbolsInfo * info, KeyInfo * key) key->acts[group] = key->acts[0]; key->acts[0] = (XkbcAction *) NULL; key->types[group] = key->types[0]; - key->types[0] = (Atom) 0; + key->types[0] = (CARD32) 0; return True; } @@ -1756,7 +1756,7 @@ FindKeyForSymbol(XkbcDescPtr xkb, CARD32 sym, unsigned int *kc_rtrn) * @return True if found, False otherwise. */ static Bool -FindNamedType(XkbcDescPtr xkb, Atom name, unsigned *type_rtrn) +FindNamedType(XkbcDescPtr xkb, CARD32 name, unsigned *type_rtrn) { register unsigned n; @@ -1764,7 +1764,7 @@ FindNamedType(XkbcDescPtr xkb, Atom name, unsigned *type_rtrn) { for (n = 0; n < xkb->map->num_types; n++) { - if (xkb->map->types[n].name == (Atom) name) + if (xkb->map->types[n].name == (CARD32) name) { *type_rtrn = n; return True; @@ -1791,7 +1791,7 @@ FindNamedType(XkbcDescPtr xkb, Atom name, unsigned *type_rtrn) * @returns True if a type could be found, False otherwise. */ static Bool -FindAutomaticType(int width, CARD32 * syms, Atom * typeNameRtrn, +FindAutomaticType(int width, CARD32 * syms, CARD32 * typeNameRtrn, Bool * autoType) { *autoType = False; @@ -1936,7 +1936,7 @@ PrepareKeyDef(KeyInfo * key) if (key->acts[i] != NULL) uFree(key->acts[i]); key->acts[i] = (XkbcAction *) NULL; - key->types[i] = (Atom) 0; + key->types[i] = (CARD32) 0; } key->symsDefined &= 1; key->actsDefined &= 1; @@ -1955,7 +1955,7 @@ CopySymbolsDef(XkbcDescPtr xkb, KeyInfo *key, int start_from) { register int i; unsigned okc, kc, width, tmp, nGroups; - XkbKeyTypePtr type; + XkbcKeyTypePtr type; Bool haveActions, autoType, useAlias; CARD32 *outSyms; XkbcAction *outActs; diff --git a/src/xkbcomp/tokens.h b/src/xkbcomp/tokens.h index c87437b..9e554ab 100644 --- a/src/xkbcomp/tokens.h +++ b/src/xkbcomp/tokens.h @@ -27,6 +27,7 @@ #define TOKENS_H 1 #include +#include #define END_OF_FILE 0 #define ERROR_TOK 255 @@ -98,9 +99,9 @@ #define FUNCTION_KEYS 76 #define ALTERNATE_GROUP 77 -extern Atom tok_ONE_LEVEL; -extern Atom tok_TWO_LEVEL; -extern Atom tok_ALPHABETIC; -extern Atom tok_KEYPAD; +extern CARD32 tok_ONE_LEVEL; +extern CARD32 tok_TWO_LEVEL; +extern CARD32 tok_ALPHABETIC; +extern CARD32 tok_KEYPAD; #endif diff --git a/src/xkbcomp/vmod.c b/src/xkbcomp/vmod.c index a7c1827..74011ca 100644 --- a/src/xkbcomp/vmod.c +++ b/src/xkbcomp/vmod.c @@ -85,7 +85,7 @@ HandleVModDef(VModDef * stmt, unsigned mergeMode, VModInfo * info) register int i, bit, nextFree; ExprResult mod; XkbcServerMapPtr srv; - XkbNamesPtr names; + XkbcNamesPtr names; srv = info->xkb->server; names = info->xkb->names; @@ -164,7 +164,7 @@ HandleVModDef(VModDef * stmt, unsigned mergeMode, VModInfo * info) */ int LookupVModIndex(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { int i; XkbcDescPtr xkb; @@ -203,7 +203,7 @@ LookupVModIndex(char * priv, */ int LookupVModMask(char * priv, - Atom elem, Atom field, unsigned type, ExprResult * val_rtrn) + CARD32 elem, CARD32 field, unsigned type, ExprResult * val_rtrn) { if (LookupVModIndex(priv, elem, field, type, val_rtrn)) { @@ -217,7 +217,7 @@ LookupVModMask(char * priv, int FindKeypadVMod(XkbcDescPtr xkb) { - Atom name; + CARD32 name; ExprResult rtrn; name = XkbcInternAtom("NumLock", False); @@ -231,7 +231,7 @@ FindKeypadVMod(XkbcDescPtr xkb) Bool ResolveVirtualModifier(ExprDef * def, ExprResult * val_rtrn, VModInfo * info) { - XkbNamesPtr names; + XkbcNamesPtr names; names = info->xkb->names; if (def->op == ExprIdent) diff --git a/src/xkbcomp/vmod.h b/src/xkbcomp/vmod.h index 61bd353..b2c76ba 100644 --- a/src/xkbcomp/vmod.h +++ b/src/xkbcomp/vmod.h @@ -54,15 +54,15 @@ extern Bool ApplyVModDefs(VModInfo * /* info */ , ); extern int LookupVModIndex(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); extern int LookupVModMask(char * /* priv */ , - Atom /* elem */ , - Atom /* field */ , + CARD32 /* elem */ , + CARD32 /* field */ , unsigned /* type */ , ExprResult * /* val_rtrn */ ); diff --git a/src/xkbcomp/xkbcomp.c b/src/xkbcomp/xkbcomp.c index b780ff9..f8109d4 100644 --- a/src/xkbcomp/xkbcomp.c +++ b/src/xkbcomp/xkbcomp.c @@ -200,6 +200,8 @@ XkbcCompileKeymapFromComponents(const XkbComponentNamesPtr ktcsg) XkbFile *file, *mapToUse; XkbcDescPtr xkb; + uSetErrorFile(NULL); + if (!ktcsg || ISEMPTY(ktcsg->keycodes)) { ERROR("keycodes required to generate XKB keymap\n"); goto fail; diff --git a/src/xkbcomp/xkbcomp.h b/src/xkbcomp/xkbcomp.h index d44f989..ba39a0b 100644 --- a/src/xkbcomp/xkbcomp.h +++ b/src/xkbcomp/xkbcomp.h @@ -140,18 +140,18 @@ typedef struct _Expr } binary; struct { - Atom element; - Atom field; + CARD32 element; + CARD32 field; } field; struct { - Atom element; - Atom field; + CARD32 element; + CARD32 field; struct _Expr *entry; } array; struct { - Atom name; + CARD32 name; struct _Expr *args; } action; struct @@ -166,7 +166,7 @@ typedef struct _Expr int y; } coord; struct _Expr *child; - Atom str; + CARD32 str; unsigned uval; int ival; char keyName[5]; @@ -186,7 +186,7 @@ typedef struct _VModDef { ParseCommon common; unsigned merge; - Atom name; + CARD32 name; ExprDef *value; } VModDef; @@ -210,7 +210,7 @@ typedef struct _KeyTypeDef { ParseCommon common; unsigned merge; - Atom name; + CARD32 name; VarDef *body; } KeyTypeDef; @@ -226,7 +226,7 @@ typedef struct _ModMapDef { ParseCommon common; unsigned merge; - Atom modifier; + CARD32 modifier; ExprDef *keys; } ModMapDef; @@ -242,7 +242,7 @@ typedef struct _InterpDef { ParseCommon common; unsigned merge; - CARD32 sym; + char *sym; ExprDef *match; VarDef *def; } InterpDef; @@ -259,7 +259,7 @@ typedef struct _IndicatorNameDef typedef struct _OutlineDef { ParseCommon common; - Atom field; + CARD32 field; int nPoints; ExprDef *points; } OutlineDef; @@ -268,7 +268,7 @@ typedef struct _ShapeDef { ParseCommon common; unsigned merge; - Atom name; + CARD32 name; int nOutlines; OutlineDef *outlines; } ShapeDef; @@ -292,7 +292,7 @@ typedef struct _SectionDef { ParseCommon common; unsigned merge; - Atom name; + CARD32 name; int nRows; RowDef *rows; } SectionDef; @@ -308,7 +308,7 @@ typedef struct _OverlayDef { ParseCommon common; unsigned merge; - Atom name; + CARD32 name; int nKeys; OverlayKeyDef *keys; } OverlayDef; @@ -318,7 +318,7 @@ typedef struct _DoodadDef ParseCommon common; unsigned merge; unsigned type; - Atom name; + CARD32 name; VarDef *body; } DoodadDef; diff --git a/src/xkbcomp/xkbparse.y b/src/xkbcomp/xkbparse.y index 32f8f0a..ae37f7a 100644 --- a/src/xkbcomp/xkbparse.y +++ b/src/xkbcomp/xkbparse.y @@ -97,7 +97,6 @@ #include "xkbmisc.h" #include #include -#include #include unsigned int parseDebug; diff --git a/src/xkbgeom.h b/src/xkbgeom.h index 5a80f32..ae6e169 100644 --- a/src/xkbgeom.h +++ b/src/xkbgeom.h @@ -30,149 +30,148 @@ authorization from the authors. #include #include #include -#include #include #include "X11/extensions/XKBcommon.h" extern void -XkbcFreeGeomProperties(XkbGeometryPtr geom, int first, int count, Bool freeAll); +XkbcFreeGeomProperties(XkbcGeometryPtr geom, int first, int count, Bool freeAll); extern void -XkbcFreeGeomKeyAliases(XkbGeometryPtr geom, int first, int count, Bool freeAll); +XkbcFreeGeomKeyAliases(XkbcGeometryPtr geom, int first, int count, Bool freeAll); extern void -XkbcFreeGeomColors(XkbGeometryPtr geom, int first, int count, Bool freeAll); +XkbcFreeGeomColors(XkbcGeometryPtr geom, int first, int count, Bool freeAll); extern void -XkbcFreeGeomPoints(XkbOutlinePtr outline, int first, int count, Bool freeAll); +XkbcFreeGeomPoints(XkbcOutlinePtr outline, int first, int count, Bool freeAll); extern void -XkbcFreeGeomOutlines(XkbShapePtr shape, int first, int count, Bool freeAll); +XkbcFreeGeomOutlines(XkbcShapePtr shape, int first, int count, Bool freeAll); extern void -XkbcFreeGeomShapes(XkbGeometryPtr geom, int first, int count, Bool freeAll); +XkbcFreeGeomShapes(XkbcGeometryPtr geom, int first, int count, Bool freeAll); extern void -XkbcFreeGeomOverlayKeys(XkbOverlayRowPtr row, int first, int count, +XkbcFreeGeomOverlayKeys(XkbcOverlayRowPtr row, int first, int count, Bool freeAll); extern void -XkbcFreeGeomOverlayRows(XkbOverlayPtr overlay, int first, int count, +XkbcFreeGeomOverlayRows(XkbcOverlayPtr overlay, int first, int count, Bool freeAll); extern void -XkbcFreeGeomOverlays(XkbSectionPtr section, int first, int count, Bool freeAll); +XkbcFreeGeomOverlays(XkbcSectionPtr section, int first, int count, Bool freeAll); extern void -XkbcFreeGeomKeys(XkbRowPtr row, int first, int count, Bool freeAll); +XkbcFreeGeomKeys(XkbcRowPtr row, int first, int count, Bool freeAll); extern void -XkbcFreeGeomRows(XkbSectionPtr section, int first, int count, Bool freeAll); +XkbcFreeGeomRows(XkbcSectionPtr section, int first, int count, Bool freeAll); extern void -XkbcFreeGeomSections(XkbGeometryPtr geom, int first, int count, Bool freeAll); +XkbcFreeGeomSections(XkbcGeometryPtr geom, int first, int count, Bool freeAll); extern void -XkbcFreeGeomDoodads(XkbDoodadPtr doodads, int nDoodads, Bool freeAll); +XkbcFreeGeomDoodads(XkbcDoodadPtr doodads, int nDoodads, Bool freeAll); extern void -XkbcFreeGeometry(XkbGeometryPtr geom, unsigned which, Bool freeMap); +XkbcFreeGeometry(XkbcGeometryPtr geom, unsigned which, Bool freeMap); extern int -XkbcAllocGeomProps(XkbGeometryPtr geom, int nProps); +XkbcAllocGeomProps(XkbcGeometryPtr geom, int nProps); extern int -XkbcAllocGeomColors(XkbGeometryPtr geom, int nColors); +XkbcAllocGeomColors(XkbcGeometryPtr geom, int nColors); extern int -XkbcAllocGeomKeyAliases(XkbGeometryPtr geom, int nKeyAliases); +XkbcAllocGeomKeyAliases(XkbcGeometryPtr geom, int nKeyAliases); extern int -XkbcAllocGeomShapes(XkbGeometryPtr geom, int nShapes); +XkbcAllocGeomShapes(XkbcGeometryPtr geom, int nShapes); extern int -XkbcAllocGeomSections(XkbGeometryPtr geom, int nSections); +XkbcAllocGeomSections(XkbcGeometryPtr geom, int nSections); extern int -XkbcAllocGeomOverlays(XkbSectionPtr section, int nOverlays); +XkbcAllocGeomOverlays(XkbcSectionPtr section, int nOverlays); extern int -XkbcAllocGeomOverlayRows(XkbOverlayPtr overlay, int nRows); +XkbcAllocGeomOverlayRows(XkbcOverlayPtr overlay, int nRows); extern int -XkbcAllocGeomOverlayKeys(XkbOverlayRowPtr row, int nKeys); +XkbcAllocGeomOverlayKeys(XkbcOverlayRowPtr row, int nKeys); extern int -XkbcAllocGeomDoodads(XkbGeometryPtr geom, int nDoodads); +XkbcAllocGeomDoodads(XkbcGeometryPtr geom, int nDoodads); extern int -XkbcAllocGeomSectionDoodads(XkbSectionPtr section, int nDoodads); +XkbcAllocGeomSectionDoodads(XkbcSectionPtr section, int nDoodads); extern int -XkbcAllocGeomOutlines(XkbShapePtr shape, int nOL); +XkbcAllocGeomOutlines(XkbcShapePtr shape, int nOL); extern int -XkbcAllocGeomRows(XkbSectionPtr section, int nRows); +XkbcAllocGeomRows(XkbcSectionPtr section, int nRows); extern int -XkbcAllocGeomPoints(XkbOutlinePtr ol, int nPts); +XkbcAllocGeomPoints(XkbcOutlinePtr ol, int nPts); extern int -XkbcAllocGeomKeys(XkbRowPtr row, int nKeys); +XkbcAllocGeomKeys(XkbcRowPtr row, int nKeys); extern int -XkbcAllocGeometry(XkbcDescPtr xkb, XkbGeometrySizesPtr sizes); +XkbcAllocGeometry(XkbcDescPtr xkb, XkbcGeometrySizesPtr sizes); -extern XkbPropertyPtr -XkbcAddGeomProperty(XkbGeometryPtr geom, char *name, char *value); +extern XkbcPropertyPtr +XkbcAddGeomProperty(XkbcGeometryPtr geom, char *name, char *value); extern XkbKeyAliasPtr -XkbcAddGeomKeyAlias(XkbGeometryPtr geom, char *aliasStr, char *realStr); +XkbcAddGeomKeyAlias(XkbcGeometryPtr geom, char *aliasStr, char *realStr); -extern XkbColorPtr -XkbcAddGeomColor(XkbGeometryPtr geom, char *spec, unsigned int pixel); +extern XkbcColorPtr +XkbcAddGeomColor(XkbcGeometryPtr geom, char *spec, unsigned int pixel); -extern XkbOutlinePtr -XkbcAddGeomOutline(XkbShapePtr shape, int sz_points); +extern XkbcOutlinePtr +XkbcAddGeomOutline(XkbcShapePtr shape, int sz_points); -extern XkbShapePtr -XkbcAddGeomShape(XkbGeometryPtr geom, Atom name, int sz_outlines); +extern XkbcShapePtr +XkbcAddGeomShape(XkbcGeometryPtr geom, CARD32 name, int sz_outlines); -extern XkbKeyPtr -XkbcAddGeomKey(XkbRowPtr row); +extern XkbcKeyPtr +XkbcAddGeomKey(XkbcRowPtr row); -extern XkbRowPtr -XkbcAddGeomRow(XkbSectionPtr section, int sz_keys); +extern XkbcRowPtr +XkbcAddGeomRow(XkbcSectionPtr section, int sz_keys); -extern XkbSectionPtr -XkbcAddGeomSection(XkbGeometryPtr geom, Atom name, +extern XkbcSectionPtr +XkbcAddGeomSection(XkbcGeometryPtr geom, CARD32 name, int sz_rows, int sz_doodads, int sz_over); -extern XkbDoodadPtr -XkbcAddGeomDoodad(XkbGeometryPtr geom, XkbSectionPtr section, Atom name); +extern XkbcDoodadPtr +XkbcAddGeomDoodad(XkbcGeometryPtr geom, XkbcSectionPtr section, CARD32 name); -extern XkbOverlayKeyPtr -XkbcAddGeomOverlayKey(XkbOverlayPtr overlay, XkbOverlayRowPtr row, +extern XkbcOverlayKeyPtr +XkbcAddGeomOverlayKey(XkbcOverlayPtr overlay, XkbcOverlayRowPtr row, char *over, char *under); -extern XkbOverlayRowPtr -XkbcAddGeomOverlayRow(XkbOverlayPtr overlay, int row_under, int sz_keys); +extern XkbcOverlayRowPtr +XkbcAddGeomOverlayRow(XkbcOverlayPtr overlay, int row_under, int sz_keys); -extern XkbOverlayPtr -XkbcAddGeomOverlay(XkbSectionPtr section, Atom name, int sz_rows); +extern XkbcOverlayPtr +XkbcAddGeomOverlay(XkbcSectionPtr section, CARD32 name, int sz_rows); /***====================================================================***/ extern Bool -XkbcComputeShapeBounds(XkbShapePtr shape); +XkbcComputeShapeBounds(XkbcShapePtr shape); extern Bool -XkbcComputeShapeTop(XkbShapePtr shape, XkbBoundsPtr bounds); +XkbcComputeShapeTop(XkbcShapePtr shape, XkbcBoundsPtr bounds); extern Bool -XkbcComputeRowBounds(XkbGeometryPtr geom, XkbSectionPtr section, XkbRowPtr row); +XkbcComputeRowBounds(XkbcGeometryPtr geom, XkbcSectionPtr section, XkbcRowPtr row); extern Bool -XkbcComputeSectionBounds(XkbGeometryPtr geom, XkbSectionPtr section); +XkbcComputeSectionBounds(XkbcGeometryPtr geom, XkbcSectionPtr section); #endif /* _XKBGEOM_H_ */ diff --git a/src/xkbmisc.h b/src/xkbmisc.h index 028e90b..0ea61a2 100644 --- a/src/xkbmisc.h +++ b/src/xkbmisc.h @@ -36,7 +36,7 @@ authorization from the authors. /***====================================================================***/ extern Bool -XkbcComputeEffectiveMap(XkbcDescPtr xkb, XkbKeyTypePtr type, +XkbcComputeEffectiveMap(XkbcDescPtr xkb, XkbcKeyTypePtr type, unsigned char *map_rtrn); /***====================================================================***/ -- 2.7.4