Initial revisionXORG-STABLE

3 files changed, 1124 insertions, 0 deletions

diff --git a/include/X11/extensions/XKBui.h b/include/X11/extensions/XKBui.h
new file mode 100644
index 0000000..aeb9cb5
--- /dev/null
+++ b/include/X11/extensions/XKBui.h
@@ -0,0 +1,217 @@
+#ifndef XKBUI_H
+#define	XKBUI_H 1
+/* $XConsortium: XKBui.h /main/2 1995/12/07 21:18:19 kaleb $ */
+/************************************************************
+ Copyright (c) 1996 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.
+
+ ********************************************************/
+
+#include <X11/Xlib.h>
+#include <X11/XKBlib.h>
+#include <X11/extensions/XKBgeom.h>
+
+typedef struct _XkbUI_View	*XkbUI_ViewPtr;
+
+typedef struct _XkbUI_ViewOpts {
+	unsigned int	present;
+	unsigned int	fg;
+	unsigned int	bg;
+	unsigned int	label_mode;
+	unsigned int	color_mode;
+	XRectangle	viewport;
+	unsigned int	margin_width;
+	unsigned int	margin_height;
+	Colormap	cmap;
+} XkbUI_ViewOptsRec,*XkbUI_ViewOptsPtr;
+
+	/*
+	 * legal values for present field of a view options
+	 */
+#define	XkbUI_BackgroundMask	(1<<0)
+#define	XkbUI_ForegroundMask	(1<<1)
+#define	XkbUI_LabelModeMask	(1<<2)
+#define	XkbUI_ColorModeMask	(1<<3)
+#define	XkbUI_WidthMask		(1<<4)
+#define	XkbUI_HeightMask	(1<<5)
+#define	XkbUI_XOffsetMask	(1<<6)
+#define	XkbUI_YOffsetMask	(1<<7)
+#define	XkbUI_ColormapMask	(1<<8)
+#define	XkbUI_MarginWidthMask	(1<<9)
+#define	XkbUI_MarginHeightMask	(1<<10)
+
+#define	XkbUI_SizeMask		(XkbUI_WidthMask|XkbUI_HeightMask)
+#define	XkbUI_OffsetMask	(XkbUI_XOffsetMask|XkbUI_YOffsetMask)
+#define	XkbUI_MarginMask	(XkbUI_MarginWidthMask|XkbUI_MarginHeightMask)
+#define	XkbUI_AllViewOptsMask	(0x7ff)
+
+	/*
+	 * legal values for the label_mode of a view options
+	 */
+#define	XkbUI_NoLabels		0
+#define	XkbUI_KeyCodes		1
+#define	XkbUI_KeyNames		2
+#define	XkbUI_StateSyms		3
+#define	XkbUI_MultiSyms		4
+
+typedef struct _XkbUI_Select {
+	unsigned		type;
+	XkbSectionPtr		section;
+	XkbKeyPtr		key;
+	XkbDoodadPtr		doodad;
+} XkbUI_SelectRec,*XkbUI_SelectPtr;
+
+	/*
+	 * legal values for 'type' field of a selection report
+	 */
+
+#define	XkbUI_Keys		0
+#define	XkbUI_Indicators	1
+#define	XkbUI_TextLabels	2
+#define	XkbUI_SolidShapes	3
+#define	XkbUI_Outlines		4
+#define	XkbUI_Logos		5
+#define	XkbUI_Sections		6
+
+	/*
+	 * legal values for 'which' field of a select call
+	 */
+#define	XkbUI_KeysMask		(1<<0)
+#define	XkbUI_IndicatorsMask	(1<<1)
+#define	XkbUI_TextLabelsMask	(1<<2)
+#define	XkbUI_SolidShapesMask	(1<<3)
+#define	XkbUI_OutlinesMask	(1<<4)
+#define	XkbUI_LogosMask		(1<<5)
+#define	XkbUI_SectionsMask	(1<<6)
+
+	/*
+	 * legal values for key appearance flag
+	 */
+#define	XkbUI_KeyDown		(1<<0)
+#define	XkbUI_Highlight		(1<<1)
+
+_XFUNCPROTOBEGIN
+
+extern	XkbUI_ViewPtr XkbUI_SimpleInit(
+#if NeedFunctionPrototypes
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* width */,
+	int			/* height */
+#endif
+);
+
+extern	XkbUI_ViewPtr XkbUI_Init(
+#if NeedFunctionPrototypes
+	Display *		/* dpy */,
+	Window			/* win */,
+	int			/* width */,
+	int			/* height */,
+	XkbDescPtr		/* xkb */,
+	XkbUI_ViewOptsPtr	/* view */
+#endif
+);
+
+extern Status XkbUI_SetViewOpts(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XkbUI_ViewOptsPtr	/* opts */
+#endif
+);
+
+extern Status XbUI_GetViewOpts(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XkbUI_ViewOptsPtr	/* opts_rtrn */
+#endif
+);
+
+extern	Status XkbUI_SetCanvasSize(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	int			/* width */,
+	int			/* height */
+#endif
+);
+
+extern	Status XkbUI_GetCanvasSize(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	int *			/* width_rtrn */,
+	int *			/* height_rtrn */
+#endif
+);
+
+extern Bool XkbUI_SetKeyAppearance(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	KeyCode			/* kc */,
+	unsigned		/* flags */
+#endif
+);
+
+extern Bool XkbUI_SetKeyAppearanceByName(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XkbKeyNamePtr		/* name */,
+	unsigned		/* flags */
+#endif
+);
+
+extern Bool XkbUI_ResetKeyAppearance(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	unsigned int		/* mask */,
+	unsigned int		/* values */
+#endif
+);
+
+extern Bool XkbUI_DrawRegion(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XRectangle *		/* viewport */
+#endif
+);
+
+extern Bool XkbUI_DrawChanged(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XRectangle *		/* viewport */,
+	XkbChangesPtr		/* changes */,
+	int			/* num_keys */,
+	XkbKeyNamePtr		/* keys */
+#endif
+);
+
+extern Bool XkbUI_Select(
+#if NeedFunctionPrototypes
+	XkbUI_ViewPtr		/* view */,
+	XPoint *		/* coord */,
+	unsigned int		/* which */,
+	XkbSectionPtr		/* section */
+#endif
+);
+
+_XFUNCPROTOEND
+
+#endif /* XKBUI_H */
diff --git a/src/XKBui.c b/src/XKBui.c
new file mode 100644
index 0000000..9dc7553
--- /dev/null
+++ b/src/XKBui.c
@@ -0,0 +1,836 @@
+/* $XConsortium: XKBui.c /main/2 1995/12/07 21:18:19 kaleb $ */
+/************************************************************
+ Copyright (c) 1996 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.
+
+ ********************************************************/
+/* $XFree86: xc/lib/xkbui/XKBui.c,v 3.6 1999/06/20 07:14:08 dawes Exp $ */
+
+#include <X11/Xos.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+#if defined(SVR4) && defined(i386) && !defined(_XOPEN_SOURCE)
+#  define _XOPEN_SOURCE
+#  include <math.h>
+#  undef _XOPEN_SOURCE
+#else
+#  include <math.h>
+#endif /* _XOPEN_SOURCE */
+
+#include <X11/Xfuncs.h>
+#include "XKBuiPriv.h"
+#include "XKBfileInt.h"
+#include <X11/extensions/XKBfile.h>
+
+#ifndef M_PI
+#  define M_PI	3.141592653589793238462
+#endif
+
+static XkbUI_ViewOptsRec dfltOpts = { 
+	XkbUI_AllViewOptsMask	/* present */,
+	1			/* fg */,
+	0			/* bg */,
+	XkbUI_KeyNames		/* label_mode */,
+	0 			/* color_mode */,
+	{ 
+		0	/* viewport.x */,
+		0	/* viewport.y */,
+		640	/* viewport.width */,
+		480	/* viewport.height */
+	},
+	10, 10,		/* margin_width, margin_height */
+	None
+};
+
+XkbUI_ViewPtr 
+#if NeedFunctionPrototypes
+XkbUI_SimpleInit(Display *dpy,Window win,int width,int height)
+#else
+XkbUI_SimpleInit(dpy,win,width,height)
+	Display *		dpy;
+	Window			win;
+	int			width;
+	int			height;
+#endif
+{
+XkbDescPtr	xkb;
+
+    if ((!dpy)||(win==None)||(width<1)||(height<1))
+	return NULL;
+    xkb= XkbGetKeyboard(dpy,XkbGBN_AllComponentsMask,XkbUseCoreKbd);
+    if (!xkb)
+	return NULL;
+    return XkbUI_Init(dpy,win,width,height,xkb,NULL);
+}
+
+static void
+#if NeedFunctionPrototypes
+_XkbUI_AllocateColors(XkbUI_ViewPtr view)
+#else
+_XkbUI_AllocateColors(view)
+    XkbUI_ViewPtr	view;
+#endif
+{
+register int i;
+Display *	dpy;
+XColor		sdef,xdef;
+XkbDescPtr	xkb;
+
+    dpy= view->dpy;
+    xkb= view->xkb;
+    if (view->opts.cmap==None)
+	view->opts.cmap= DefaultColormap(dpy,DefaultScreen(dpy));
+    for (i=0;i<xkb->geom->num_colors;i++) {
+	char *spec;
+	Bool		found;
+
+	spec= xkb->geom->colors[i].spec;
+	found= False;
+	if (XAllocNamedColor(view->dpy,view->opts.cmap,spec,&sdef,&xdef)) {
+	    xkb->geom->colors[i].pixel= sdef.pixel;
+#ifdef DEBUG
+	    fprintf(stderr,"got pixel %d for \"%s\"\n",sdef.pixel,spec);
+#endif
+	    found= True;
+	}
+	if ((!found)&&(XkbLookupCanonicalRGBColor(spec,&sdef))) { 
+	    char buf[20];
+	    sprintf(buf,"#%02x%02x%02x",(sdef.red>>8)&0xff,
+						(sdef.green>>8)&0xff,
+						(sdef.blue>>8)&&0xff);
+	    if (XAllocNamedColor(view->dpy,view->opts.cmap,buf,&sdef,&xdef)) {
+		xkb->geom->colors[i].pixel= sdef.pixel;
+#ifdef DEBUG
+		fprintf(stderr,"got pixel %d for \"%s\"\n",sdef.pixel,spec);
+#endif
+		found= True;
+	    }
+	}
+	if (!found) {
+	    xkb->geom->colors[i].pixel= view->opts.fg;
+	    fprintf(stderr,"Couldn't allocate color \"%s\"\n",spec);
+	}
+    }
+    return;
+}
+
+XkbUI_ViewPtr 
+#if NeedFunctionPrototypes
+XkbUI_Init(	Display *		dpy,
+		Window			win,
+		int			width,
+		int			height,
+		XkbDescPtr		xkb,
+		XkbUI_ViewOptsPtr	opts)
+#else
+XkbUI_Init(dpy,win,width,height,xkb,opts)
+	Display *		dpy;
+	Window			win;
+	int			width;
+	int			height;
+	XkbDescPtr		xkb;
+	XkbUI_ViewOptsPtr	opts;
+#endif
+{
+XGCValues	xgcv;
+XkbUI_ViewPtr	view;
+int		scrn;
+
+    if ((!dpy)||(!xkb)||(!xkb->geom)||(win==None)||(width<1)||(height<1))
+	return NULL;
+    view= _XkbTypedCalloc(1,XkbUI_ViewRec);
+    if (!view)
+	return NULL;
+    scrn= DefaultScreen(dpy);
+    view->dpy= 			dpy;
+    view->xkb= 			xkb;
+    view->win=			win;
+    view->opts= 		dfltOpts;
+    view->opts.fg=		WhitePixel(dpy,scrn);
+    view->opts.bg=		BlackPixel(dpy,scrn);
+    view->opts.viewport.x=	0;
+    view->opts.viewport.y=	0;
+    view->opts.viewport.width=	width;
+    view->opts.viewport.height=	height;
+    if ((opts)&&(opts->present)) {
+	if (opts->present&XkbUI_BackgroundMask)
+	    view->opts.bg=		opts->bg;
+	if (opts->present&XkbUI_ForegroundMask)
+	    view->opts.fg=		opts->fg;
+	if (opts->present&XkbUI_LabelModeMask)
+	    view->opts.label_mode=	opts->label_mode;
+	if (opts->present&XkbUI_ColorModeMask)
+	    view->opts.color_mode=	opts->color_mode;
+	if (opts->present&XkbUI_WidthMask)
+	    view->opts.viewport.width=	opts->viewport.width;
+	if (opts->present&XkbUI_HeightMask)
+	    view->opts.viewport.height=	opts->viewport.height;
+	if (opts->present&XkbUI_XOffsetMask)
+	    view->opts.viewport.x=	opts->viewport.x;
+	if (opts->present&XkbUI_YOffsetMask)
+	    view->opts.viewport.y=	opts->viewport.y;
+	if (opts->present&XkbUI_MarginWidthMask)
+	    view->opts.margin_width=	opts->margin_width;
+	if (opts->present&XkbUI_MarginHeightMask)
+	    view->opts.margin_height=	opts->margin_height;
+	if (opts->present&XkbUI_ColormapMask)
+	    view->opts.cmap=		opts->cmap;
+    }
+    view->canvas_width= width+(2*view->opts.margin_width);
+    view->canvas_height= height+(2*view->opts.margin_height);
+    if (view->opts.viewport.width>view->canvas_width) {
+	int tmp;
+	tmp= (view->opts.viewport.width-view->canvas_width)/2;
+	view->opts.margin_width+= tmp;
+    }
+    if (view->opts.viewport.height>view->canvas_height) {
+	int tmp;
+	tmp= (view->opts.viewport.height-view->canvas_height)/2;
+	view->opts.margin_height+= tmp;
+    }
+    bzero(view->state,XkbMaxLegalKeyCode+1);
+
+    xgcv.foreground= view->opts.fg;
+    xgcv.background= view->opts.bg;
+    view->gc= XCreateGC(view->dpy,view->win,GCForeground|GCBackground,&xgcv);
+    view->xscale= ((double)width)/((double)xkb->geom->width_mm);
+    view->yscale= ((double)height)/((double)xkb->geom->height_mm);
+
+    _XkbUI_AllocateColors(view);
+    return view;
+}
+
+Status 
+#if NeedFunctionPrototypes
+XkbUI_SetViewOpts(XkbUI_ViewPtr	view,XkbUI_ViewOptsPtr opts)
+#else
+XkbUI_SetViewOpts(view,opts)
+	XkbUI_ViewPtr		view;
+	XkbUI_ViewOptsPtr	opts;
+#endif
+{
+    if ((!view)||(!opts))
+	return BadValue;
+    if (opts->present==0)
+	return Success;
+    if (opts->present&XkbUI_BackgroundMask)
+	view->opts.bg=			opts->bg;
+    if (opts->present&XkbUI_ForegroundMask)
+	view->opts.fg=			opts->fg;
+    if (opts->present&XkbUI_LabelModeMask)
+	view->opts.label_mode=		opts->label_mode;
+    if (opts->present&XkbUI_ColorModeMask)
+	view->opts.color_mode=		opts->color_mode;
+    if (opts->present&XkbUI_WidthMask)
+	view->opts.viewport.width=	opts->viewport.width;
+    if (opts->present&XkbUI_HeightMask)
+	view->opts.viewport.height=	opts->viewport.height;
+    if (opts->present&XkbUI_XOffsetMask)
+	view->opts.viewport.x=		opts->viewport.x;
+    if (opts->present&XkbUI_YOffsetMask)
+	view->opts.viewport.y=		opts->viewport.y;
+    if (opts->present&XkbUI_MarginWidthMask)
+	view->opts.margin_width=	opts->margin_width;
+    if (opts->present&XkbUI_MarginHeightMask)
+	view->opts.margin_height=	opts->margin_height;
+    if (opts->present&XkbUI_ColormapMask) {
+	view->opts.cmap=		opts->cmap;
+	_XkbUI_AllocateColors(view);
+    }
+    return Success;
+}
+
+Status 
+#if NeedFunctionPrototypes
+XbUI_GetViewOpts(XkbUI_ViewPtr view,XkbUI_ViewOptsPtr opts_rtrn)
+#else
+XbUI_GetViewOpts(view,opts_rtrn)
+	XkbUI_ViewPtr		view;
+	XkbUI_ViewOptsPtr	opts_rtrn;
+#endif
+{
+    if ((!view)||(!opts_rtrn))
+	return BadValue;
+    *opts_rtrn= view->opts;
+    return Success;
+}
+
+Status 
+#if NeedFunctionPrototypes
+XkbUI_SetCanvasSize(XkbUI_ViewPtr view,int width,int height)
+#else
+XkbUI_SetCanvasSize(view,width,height)
+	XkbUI_Viewtr	view;
+	int		width;
+	int		height;
+#endif
+{
+    if ((!view)||(!view->xkb)||(!view->xkb->geom))
+	return BadValue;
+    view->canvas_width= width;
+    view->canvas_height= height;
+    view->xscale= ((double)width)/((double)view->xkb->geom->width_mm);
+    view->yscale= ((double)height)/((double)view->xkb->geom->height_mm);
+    return Success;
+}
+
+Status 
+#if NeedFunctionPrototypes
+XkbUI_GetCanvasSize(XkbUI_ViewPtr view,int *width_rtrn,int *height_rtrn)
+#else
+XkbUI_GetCanvasSize(view,width_rtrn,height_rtrn)
+	XkbUI_ViewPtr	view;
+	int *		width_rtrn;
+	int *		height_rtrn;
+#endif
+{
+    if (!view)
+	return BadValue;
+    if (width_rtrn)	*width_rtrn= view->canvas_width;
+    if (height_rtrn)	*height_rtrn= view->canvas_height;
+    return Success;
+}
+
+/***====================================================================***/
+
+static void
+#if NeedFunctionPrototypes
+_RotatePoints(	double		rangle,
+		int 		corner_x,
+		int		corner_y,
+		int		nPts,
+		XkbUI_PointPtr	pts)
+#else
+_RotatePoints(rangle,corner_x,corner_y,nPts,pts)
+	double		rangle;
+	int		corner_x;
+	int		corner_y;
+	int		nPts;
+	XkbUI_PointPtr	pts;
+#endif
+{
+register int	i;
+double		rr,rx,ry,rt;
+
+    for (i=0;i<nPts;i++,pts++) {
+	rx= pts->x-corner_x; ry= pts->y-corner_y; /* translate */
+	rr= hypot(rx,ry);
+	rt= atan2(ry,rx)+rangle;
+	rx= rr*cos(rt);
+	ry= rr*sin(rt);
+	pts->x= rx+corner_x; pts->y= ry+corner_y;
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawPoints(XkbUI_ViewPtr view,int nPts,XkbUI_PointPtr pts,XPoint *xpts)
+#else
+_DrawPoints(view,nPts,pts)
+	XkbUI_ViewPtr	view;
+	int		nPts;
+	XkbUI_PointPtr	pts;
+	XPoint *	xpts;
+#endif
+{
+register int	i;
+
+    for (i=0;i<nPts;i++) {
+	if (pts[i].x>=0.0)	xpts[i].x=	pts[i].x*view->xscale+0.5;
+	else			xpts[i].x=	pts[i].x*view->xscale-0.5;
+	xpts[i].x+= view->opts.viewport.x;
+	if (pts[i].y>=0.0)	xpts[i].y=	pts[i].y*view->yscale+0.5;
+	else			xpts[i].x=	pts[i].y*view->yscale-0.5;
+	xpts[i].y+= 	view->opts.viewport.y;
+    }
+    if ((xpts[nPts-1].x!=xpts[0].x)||(xpts[nPts-1].y!=xpts[0].y))
+	xpts[nPts++]= xpts[0]; /* close the shape, if necessary */
+    XDrawLines(view->dpy,view->win,view->gc,xpts,nPts,CoordModeOrigin);
+XFlush(view->dpy);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawSolidPoints(XkbUI_ViewPtr view,int nPts,XkbUI_PointPtr pts,XPoint *xpts)
+#else
+_DrawSolidPoints(view,nPts,pts)
+	XkbUI_ViewPtr	view;
+	int		nPts;
+	XkbUI_PointPtr	pts;
+	XPoint *	xpts;
+#endif
+{
+register int	i;
+
+    for (i=0;i<nPts;i++) {
+	if (pts[i].x>=0.0)	xpts[i].x=	pts[i].x*view->xscale+0.5;
+	else			xpts[i].x=	pts[i].x*view->xscale-0.5;
+	xpts[i].x+= view->opts.viewport.x;
+	if (pts[i].y>=0.0)	xpts[i].y=	pts[i].y*view->yscale+0.5;
+	else			xpts[i].x=	pts[i].y*view->yscale-0.5;
+	xpts[i].y+= 	view->opts.viewport.y;
+    }
+    if ((xpts[nPts-1].x!=xpts[0].x)||(xpts[nPts-1].y!=xpts[0].y))
+	xpts[nPts++]= xpts[0]; /* close the shape, if necessary */
+    XFillPolygon(view->dpy,view->win,view->gc,xpts,nPts,Nonconvex,
+							CoordModeOrigin);
+XFlush(view->dpy);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawShape(	XkbUI_ViewPtr	view,
+		double		rangle,
+		int		xoff,
+		int		yoff,
+		int		rotx,
+		int		roty,
+		XkbShapePtr	shape,
+		Bool		key)
+#else
+_DrawShape(view,rangle,xoff,yoff,rotx,roty,shape,key)
+	XkbUI_ViewPtr	view;
+	double		rangle;
+	int		xoff;
+	int		yoff;
+	int		rotx;
+	int		roty;
+	XkbShapePtr	shape;
+	Bool		key;
+#endif
+{
+XkbOutlinePtr	ol;
+register int	o;
+int		maxPts;
+XkbUI_PointPtr	uipts;
+XPoint *	xpts;
+
+    for (maxPts=4,o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
+	if ((shape->num_outlines>1)&&(ol==shape->approx))
+	    continue;
+	if (ol->num_points>maxPts)
+	    maxPts= ol->num_points;
+    }
+    uipts= _XkbTypedCalloc(maxPts,XkbUI_PointRec);
+    xpts= _XkbTypedCalloc(maxPts+1,XPoint);
+    XSetForeground(view->dpy,view->gc,view->xkb->geom->label_color->pixel);
+    for (o=0,ol=shape->outlines;o<shape->num_outlines;o++,ol++) {
+	XkbPointPtr	gpts;
+	register int 	p;
+	if ((shape->num_outlines>1)&&(ol==shape->approx))
+	    continue;
+	gpts= ol->points;
+	if (ol->num_points==1) {
+	    uipts[0].x= xoff;		uipts[0].y= yoff;
+	    uipts[1].x= xoff+gpts[0].x;	uipts[1].y= yoff;
+	    uipts[2].x= xoff+gpts[0].x;	uipts[2].y= yoff+gpts[0].y;
+	    uipts[3].x= xoff;		uipts[3].y= yoff+gpts[0].y;
+	    p= 4;
+	}
+	else if (ol->num_points==2) {
+	    uipts[0].x= xoff+gpts[0].x;	uipts[0].y= yoff+gpts[0].y;
+	    uipts[1].x= xoff+gpts[1].x;	uipts[1].y= yoff+gpts[0].y;
+	    uipts[2].x= xoff+gpts[1].x;	uipts[2].y= yoff+gpts[1].y;
+	    uipts[3].x= xoff+gpts[0].x;	uipts[3].y= yoff+gpts[1].y;
+	    p= 4;
+	}
+	else {
+	    for (p=0;p<ol->num_points;p++) {
+		uipts[p].x= xoff+gpts[p].x; 
+		uipts[p].y= yoff+gpts[p].y;
+	    }
+	    p= ol->num_points;
+	}
+	if (rangle!=0.0)
+	    _RotatePoints(rangle,rotx,roty,p,uipts);
+	if (key) {
+	    if (o==0) {
+		XSetForeground(view->dpy,view->gc,
+					view->xkb->geom->base_color->pixel);
+		_DrawSolidPoints(view,p,uipts,xpts);
+		XSetForeground(view->dpy,view->gc,
+					view->xkb->geom->label_color->pixel);
+	    }
+	    _DrawPoints(view,p,uipts,xpts);
+	}
+	else {
+	    _DrawPoints(view,p,uipts,xpts);
+	}
+    }
+    _XkbFree(uipts);
+    _XkbFree(xpts);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawRect(	XkbUI_ViewPtr	view,
+		double		rangle,
+		int		x1,
+		int		y1,
+		int		x2,
+		int		y2,
+		Bool		key)
+#else
+_DrawRect(view,rangle,x1,y1,x2,y2,key)
+	XkbUI_ViewPtr	view;
+	double		rangle;
+	int		x1;
+	int		y1;
+	int		x2;
+	int		y2;
+	Bool		key;
+#endif
+{
+XkbUI_PointRec	uipts[4];
+XPoint 		xpts[4];
+
+    XSetForeground(view->dpy,view->gc,view->xkb->geom->label_color->pixel);
+    uipts[0].x= x1; uipts[0].y= y1;
+    uipts[1].x= x2; uipts[1].y= y1;
+    uipts[2].x= x2; uipts[2].y= y2;
+    uipts[3].x= x1; uipts[3].y= y2;
+    if (rangle!=0.0)
+	_RotatePoints(rangle,0,0,4,uipts);
+    if (key) {
+	XSetForeground(view->dpy,view->gc,view->xkb->geom->base_color->pixel);
+	_DrawSolidPoints(view,4,uipts,xpts);
+	XSetForeground(view->dpy,view->gc,view->xkb->geom->label_color->pixel);
+	_DrawPoints(view,4,uipts,xpts);
+    }
+    else {
+	_DrawPoints(view,4,uipts,xpts);
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawDoodad(	XkbUI_ViewPtr	view,
+		double		rangle,
+		int		xoff,
+		int		yoff,
+		XkbDoodadPtr	doodad)
+#else
+_DrawDoodad(view,rangle,xoff,yoff,doodad)
+	XkbUI_ViewPtr	view;
+	double		rangle;
+	int		xoff;
+	int		yoff;
+	XkbDoodadPtr	doodad;
+#endif
+{
+int		x;
+int		y;
+XkbShapePtr	shape;
+Bool		solid;
+
+    x= 		doodad->any.left+xoff;
+    y= 		doodad->any.top+yoff;
+    shape=	NULL;
+    solid= 	False;
+    switch (doodad->any.type) {
+	case XkbOutlineDoodad:
+	    shape= XkbShapeDoodadShape(view->xkb->geom,(&doodad->shape));
+	    break;
+	case XkbSolidDoodad:
+	    shape= XkbShapeDoodadShape(view->xkb->geom,(&doodad->shape));
+	    solid= True;
+	    break;
+	case XkbTextDoodad:
+	    break;
+	case XkbIndicatorDoodad:
+	    shape= XkbIndicatorDoodadShape(view->xkb->geom,&doodad->indicator);
+	    solid= True;
+	    break;
+	case XkbLogoDoodad:
+	    shape= XkbLogoDoodadShape(view->xkb->geom,&doodad->logo);
+	    solid= True;
+	    break;
+    }
+    if (shape)
+	_DrawShape(view,rangle,x,y,x,y,shape,solid);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawRow(	XkbUI_ViewPtr	view,
+		double		rangle,
+		int		xoff,
+		int		yoff,
+		XkbRowPtr	row)
+#else
+_DrawRow(view,rangle,xoff,yoff,row)
+	XkbUI_ViewPtr	view;
+	double		rangle;
+	int		xoff;
+	int		yoff;
+	XkbRowPtr	row;
+#endif
+{
+register int 	k,x,y;
+XkbKeyPtr	key;
+
+    x= xoff+row->left; y= yoff+row->top;
+    for (k=0,key=row->keys;k<row->num_keys;k++,key++) {
+	XkbShapePtr	shape;
+	shape= XkbKeyShape(view->xkb->geom,key);
+	if (row->vertical) {
+	    y+= key->gap;
+	    _DrawShape(view,rangle,x,y,xoff,yoff,shape,True);
+	    y+= shape->bounds.y2;
+	}
+	else {
+	    x+= key->gap;
+	    _DrawShape(view,rangle,x,y,xoff,yoff,shape,True);
+	    x+= shape->bounds.x2;
+	}
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawSection(XkbUI_ViewPtr view,XkbSectionPtr section)
+#else
+_DrawSection(view,section)
+	XkbUI_ViewPtr	view;
+	XkbSectionPtr	section;
+#endif
+{
+double	rangle;
+
+    rangle= ((((double)(section->angle%3600))/3600.0)*(2.0*M_PI));
+    if (section->doodads) {
+	XkbDrawablePtr	first,draw;
+	first= XkbGetOrderedDrawables(NULL,section);
+	if (first) {
+	    for (draw=first;draw!=NULL;draw=draw->next) {
+		_DrawDoodad(view,rangle,section->left,section->top,draw->u.doodad);
+	    }
+	    XkbFreeOrderedDrawables(first);
+	}
+    }
+    if (section->rows) {
+	register int	r;
+	XkbRowPtr	row;
+	for (r=0,row=section->rows;r<section->num_rows;r++,row++) {
+	    _DrawRow(view,rangle,section->left,section->top,row);
+	}
+    }
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_DrawAll(XkbUI_ViewPtr view)
+#else
+_DrawAll(view)
+	XkbUI_ViewPtr	view;
+#endif
+{
+XkbGeometryPtr	geom;
+XkbDrawablePtr	first,draw;
+Bool		dfltBorder;
+
+    geom= view->xkb->geom;
+    first= XkbGetOrderedDrawables(geom,NULL);
+    if (first) {
+	dfltBorder= True;
+	for (draw=first;draw!=NULL;draw=draw->next) {
+	    char *name;
+	    if ((draw->type!=XkbDW_Doodad)||
+		((draw->u.doodad->any.type!=XkbOutlineDoodad)&&
+		 (draw->u.doodad->any.type!=XkbSolidDoodad))) {
+		continue;
+	    }
+	    name= XkbAtomGetString(view->dpy,draw->u.doodad->any.name);
+	    if ((name!=NULL)&&(_XkbStrCaseCmp(name,"edges")==0)) {
+		dfltBorder= False;
+		break;
+	    }
+	}
+	if (dfltBorder)
+	    _DrawRect(view,0.0,0,0,geom->width_mm,geom->height_mm,True);
+	for (draw=first;draw!=NULL;draw=draw->next) {
+	    switch (draw->type) {
+		case XkbDW_Section:
+		    _DrawSection(view,draw->u.section);
+		    break;
+		case XkbDW_Doodad:
+		    _DrawDoodad(view,0.0,0,0,draw->u.doodad);
+		    break;
+	    }
+	}
+	XkbFreeOrderedDrawables(first);
+    }	
+    XFlush(view->dpy);
+    return;
+}
+
+static void
+#if NeedFunctionPrototypes
+_RedrawKey(XkbUI_ViewPtr view,KeyCode kc)
+#else
+_RedrawKey(view,kc)
+	XkbUI_ViewPtr	view;
+	KeyCode 	kc;
+#endif
+{
+/*    _DrawAll(view);*/
+    return;
+}
+
+/***====================================================================***/
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_SetKeyAppearance(XkbUI_ViewPtr view,KeyCode kc,unsigned int flags)
+#else
+XkbUI_SetKeyAppearance(view,kc,flags)
+	XkbUI_ViewPtr		view;
+	KeyCode			kc;
+	unsigned int		flags;
+#endif
+{
+XkbDescPtr	xkb;
+unsigned	old;
+
+    if ((!view)||(!view->xkb))
+	return False;
+    xkb= view->xkb;
+    if ((kc<xkb->min_key_code)||(kc>xkb->max_key_code))
+	return False;
+    old= view->state[kc];
+    view->state[kc]= (flags&(~XkbUI_Obscured));
+    if (old&XkbUI_Obscured) 
+	view->state[kc]|= XkbUI_Obscured;
+    else if (old!=view->state[kc])
+	_RedrawKey(view,kc);
+    return True;
+}
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_SetKeyAppearanceByName(	XkbUI_ViewPtr 	view,
+				XkbKeyNamePtr	name,
+				unsigned int	flags)
+#else
+XkbUI_SetKeyAppearanceByName(view,name,flags)
+	XkbUI_ViewPtr		view;
+	XkbKeyNamePtr		name;
+	unsigned int		flags;
+#endif
+{
+KeyCode	kc;
+
+    if ((!view)||(!view->xkb)||(!name))
+	return False;
+    kc= XkbFindKeycodeByName(view->xkb,name->name,True);
+    if (!kc)
+	return False;
+    return XkbUI_SetKeyAppearance(view,kc,flags);
+}
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_ResetKeyAppearance(	XkbUI_ViewPtr 	view,
+				unsigned int 	mask,
+				unsigned int 	values)
+#else
+XkbUI_ResetKeyAppearance(view,mask,values)
+	XkbUI_ViewPtr		view;
+	unsigned int		mask;
+	unsigned int		values;
+#endif
+{
+register int 	i;
+unsigned	new_val;
+
+    if ((!view)||(!view->xkb))
+	return False;
+    if (!mask)
+	return True;
+    for (i=view->xkb->min_key_code;i<=view->xkb->max_key_code;i++) {
+	new_val= (view->state[i]&(~mask));
+	new_val|= (mask&values);
+	XkbUI_SetKeyAppearance(view,i,new_val);
+    }
+    return True;
+}
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_DrawRegion(XkbUI_ViewPtr view,XRectangle *viewport)
+#else
+XkbUI_DrawRegion(view,viewport)
+	XkbUI_ViewPtr		view;
+	XRectangle *		viewport;
+#endif
+{
+    if (!view) 
+	return False;
+    _DrawAll(view);
+    return True;
+}
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_DrawChanged(	XkbUI_ViewPtr	view,
+			XRectangle *	viewport,
+			XkbChangesPtr	changes,
+			int		num_keys,
+			XkbKeyNamePtr	keys)
+#else
+XkbUI_DrawChanged(view,viewport,changesnum_keys,keys)
+	XkbUI_ViewPtr		view;
+	XRectangle *		viewport;
+	XkbChangesPtr		changes;
+	int			num_keys;
+	XkbKeyNamePtr		keys;
+#endif
+{
+    return False;
+}
+
+Bool 
+#if NeedFunctionPrototypes
+XkbUI_Select(	XkbUI_ViewPtr	view,
+		XPoint *	coord,
+		unsigned int	which,
+		XkbSectionPtr	section)
+#else
+XkbUI_Select(view,coord,which,section)
+	XkbUI_ViewPtr		view;
+	XPoint *		coord;
+	unsigned int		which;
+	XkbSectionPtr		section;
+#endif
+{
+    return False;
+}
diff --git a/src/XKBuiPriv.h b/src/XKBuiPriv.h
new file mode 100644
index 0000000..c78b08e
--- /dev/null
+++ b/src/XKBuiPriv.h
@@ -0,0 +1,71 @@
+#ifndef XKBUIPRIV_H
+#define	XKBUIPRIV_H 1
+/* $XConsortium: XKBuiPriv.h /main/2 1995/12/07 21:18:19 kaleb $ */
+/************************************************************
+ Copyright (c) 1996 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.
+
+ ********************************************************/
+
+#include "XKBui.h"
+
+typedef struct _XkbUI_Point {
+	double			x;
+	double			y;
+} XkbUI_PointRec,*XkbUI_PointPtr;
+
+typedef struct _XkbUI_View {
+	Display *		dpy;
+	XkbDescPtr		xkb;
+	Window			win;
+	GC			gc;
+	XkbUI_ViewOptsRec	opts;
+	unsigned int		canvas_width;
+	unsigned int		canvas_height;
+	unsigned char		state[XkbMaxLegalKeyCode];
+
+	double			xscale;
+	double			yscale;
+} XkbUI_ViewRec;
+
+#define	_XkbAlloc(s)		malloc((s))
+#define	_XkbCalloc(n,s)		calloc((n),(s))
+#define	_XkbRealloc(o,s)	realloc((o),(s))
+#define	_XkbTypedAlloc(t)	((t *)malloc(sizeof(t)))
+#define	_XkbTypedCalloc(n,t)	((t *)calloc((n),sizeof(t)))
+#define	_XkbTypedRealloc(o,n,t) \
+	((o)?(t *)realloc((o),(n)*sizeof(t)):_XkbTypedCalloc(n,t))
+#define	_XkbClearElems(a,f,l,t)	bzero(&(a)[f],((l)-(f)+1)*sizeof(t))
+#define	_XkbFree(p)		free(p)
+
+	/*
+	 * private values for key appearance flags 
+	 * must not conflict with values from XKBui.h
+	 */
+#define	XkbUI_Obscured		(1<<7)
+
+_XFUNCPROTOBEGIN
+
+_XFUNCPROTOEND
+
+#endif /* XKBUIPRIV_H */