Initial commit

17 files changed, 10287 insertions, 0 deletions

diff --git a/vendor/x11iraf/obm/ObmW/zz/Separator.c b/vendor/x11iraf/obm/ObmW/zz/Separator.c
new file mode 100644
index 00000000..f7669a76
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Separator.c
@@ -0,0 +1,357 @@
+/*
+ * Separator.c - Separator widget Vladimir Romanovski
+ *
+ */
+#include <X11/IntrinsicP.h>
+#include <X11/RectObjP.h>
+#include <X11/StringDefs.h>
+#include <X11/Xos.h>
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/SeparatorP.h>
+
+#include <X11/Xmu/Converters.h>
+#include <X11/Xmu/CharSet.h>
+#include <X11/Xmu/Drawing.h>
+
+#include <stdio.h>
+#include <ctype.h>
+
+/****************************************************************
+ *
+ * Full class record constant
+ *
+ ****************************************************************/
+
+/* Private Data */
+
+#define offset(field) XtOffsetOf(SeparatorRec, field)
+
+static XtResource resources[] = {
+  {
+    XtNorientation, XtCOrientation, XtROrientation, sizeof(XtOrientation),
+    offset(separator.orientation), XtRImmediate, (XtPointer) XtorientHorizontal
+  },
+  {
+    XtNmargin, XtCMargin, XtRDimension, sizeof(Dimension),
+    offset(separator.margin), XtRImmediate, (caddr_t)1
+  },
+  {
+    XtNseparatorType, XtCSeparatorType, XtRSeparatorType,
+    sizeof(XawSeparatorType), offset(separator.separatorType),
+    XtRImmediate,(caddr_t)XawSHADOW_ETCHED_IN
+  },
+  {
+    XtNshadowWidth, XtCShadowWidth, XtRDimension, sizeof(Dimension),
+    offset(simple.shadow_thickness), XtRImmediate, (XtPointer)0
+  }
+};
+#undef offset
+
+static void Initialize();
+static void Resize();
+static void Redisplay();
+static Boolean SetValues();
+static void ClassInitialize();
+static void Destroy();
+
+SeparatorClassRec separatorClassRec = {
+  {
+    /* core_class fields */	
+    /* superclass	  	*/	(WidgetClass) &simpleClassRec,
+    /* class_name	  	*/	"Separator",
+    /* widget_size	  	*/	sizeof(SeparatorRec),
+    /* class_initialize   	*/	ClassInitialize,
+    /* class_part_initialize	*/	NULL,
+    /* class_inited       	*/	FALSE,
+    /* initialize	  	*/	Initialize,
+    /* initialize_hook		*/	NULL,
+    /* realize		  	*/	XtInheritRealize,
+    /* actions		  	*/	NULL,
+    /* num_actions	  	*/	0,
+    /* resources	  	*/	resources,
+    /* num_resources	  	*/	XtNumber(resources),
+    /* xrm_class	  	*/	NULLQUARK,
+    /* compress_motion	  	*/	TRUE,
+    /* compress_exposure  	*/	TRUE,
+    /* compress_enterleave	*/	TRUE,
+    /* visible_interest	  	*/	FALSE,
+    /* destroy		  	*/	Destroy,
+    /* resize		  	*/	Resize,
+    /* expose		  	*/	Redisplay,
+    /* set_values	  	*/	SetValues,
+    /* set_values_hook		*/	NULL,
+    /* set_values_almost	*/	XtInheritSetValuesAlmost,
+    /* get_values_hook		*/	NULL,
+    /* accept_focus	 	*/	NULL,
+    /* version			*/	XtVersion,
+    /* callback_private   	*/	NULL,
+    /* tm_table		   	*/	NULL,
+    /* query_geometry		*/	XtInheritQueryGeometry,
+    /* display_accelerator	*/	XtInheritDisplayAccelerator,
+    /* extension		*/	NULL
+  },
+  { /* Simple class fields initialization */
+    /* change_sensitive         */      XtInheritChangeSensitive,
+    /* display_rect             */      XtInheritDisplayRectProc,
+    /* extension                */      NULL				
+  },
+  { /* Separator class fields initialization */
+    /* ignore 			*/	0
+  }
+};
+
+WidgetClass separatorWidgetClass = (WidgetClass)&separatorClassRec;
+
+/****************************************************************
+ *
+ * Private Procedures
+ *
+ ****************************************************************/
+
+/*---------------------------------------------*/
+#define done( type, value )			\
+{						\
+    if ( toVal->addr != NULL )			\
+    {						\
+	if ( toVal->size < sizeof( type ) )	\
+	{					\
+	    toVal->size = sizeof( type );	\
+	    return False;			\
+	}					\
+	*(type*)(toVal->addr) = (value);	\
+    }						\
+    else					\
+    {						\
+	static type static_val;			\
+	static_val = (value);			\
+	toVal->addr = (caddr_t)&static_val;	\
+    }						\
+    toVal->size = sizeof(type);			\
+    return True;				\
+}                                               \
+/*---------------------------------------------*/
+
+static  XrmQuark  QSingle, QDouble, QShadowIn, QShadowOut;
+
+/* ARGSUSED */
+static Boolean
+CvtStringToSeparatorType(dpy, args, num_args, fromVal, toVal, convData)
+     Display    *dpy;             
+     XrmValuePtr args;		/* unused */
+     Cardinal	*num_args;	/* unused */
+     XrmValuePtr fromVal;
+     XrmValuePtr toVal;
+     XtPointer  *convData;       /* unused */
+{
+  static XawSeparatorType separatorType;
+  XrmQuark    q;
+  char        lowerName[BUFSIZ];
+
+  XmuCopyISOLatin1Lowered (lowerName, (char *)fromVal->addr);
+  q = XrmStringToQuark(lowerName);
+
+  separatorType = XawSINGLE_LINE;
+  
+  if      (q == QSingle)          separatorType = XawSINGLE_LINE;
+  else if (q == QDouble)          separatorType = XawDOUBLE_LINE;
+  else if (q == QShadowIn)        separatorType = XawSHADOW_ETCHED_IN;
+  else if (q == QShadowOut)       separatorType = XawSHADOW_ETCHED_OUT;
+  else 
+    XtDisplayStringConversionWarning( dpy, (char *)fromVal->addr,
+				     XtRSeparatorType);
+  
+  done(XawSeparatorType, separatorType);
+}
+#undef done
+
+static void ClassInitialize()
+{
+  XawInitializeWidgetSet();
+  XtSetTypeConverter( XtRString, XtRSeparatorType, CvtStringToSeparatorType, 
+		     (XtConvertArgList)NULL, (Cardinal)0,
+		     XtCacheNone, (XtDestructor)NULL);
+
+  QSingle    = XrmStringToQuark(XawSingle_Line);
+  QDouble    = XrmStringToQuark(XawDouble_Line);
+  QShadowIn  = XrmStringToQuark(XawShadow_Etched_In);
+  QShadowOut = XrmStringToQuark(XawShadow_Etched_Out);
+}
+
+static void GetGC(sw)
+    SeparatorWidget sw;
+{
+  XGCValues values;
+  unsigned long mask;
+  
+  values.foreground = sw->simple.foreground;
+  values.line_width = 0;
+  mask = GCForeground | GCLineWidth;
+    
+  sw->separator.gc = XtGetGC ((Widget)sw, mask, (XGCValues*)&values);
+}
+
+/* ARGSUSED */
+static void Initialize(request, new, args, num_args)
+    Widget request, new;
+    ArgList args;
+    Cardinal *num_args;
+{
+  SeparatorWidget newsw = (SeparatorWidget) new;
+
+  if (newsw->core.width == 0)
+    newsw->core.width = 8 + 2*SIMPLE_MARGIN(new);
+
+  if (newsw->core.height == 0)
+    newsw->core.height = 8 + 2*SIMPLE_MARGIN(new);
+  
+  GetGC(newsw);
+
+}
+
+static void Resize(w)
+    Widget w;
+{
+ /* If widget is realized, clear and redisplay it */
+
+  if (XtIsRealized(w)) {
+    XClearWindow(XtDisplay(w), XtWindow(w));
+    (*separatorClassRec.core_class.expose) (w, (XEvent*)NULL, (Region)NULL);
+  }
+}
+
+/* ARGSUSED */
+static Boolean SetValues(current, request, new, args, num_args)
+    Widget current, request, new;
+    ArgList args;
+    Cardinal *num_args;
+{
+  SeparatorWidget cursw = (SeparatorWidget) current;
+  SeparatorWidget newsw = (SeparatorWidget) new;
+  Boolean redisplay     = False;
+
+#define NE(field) (cursw->separator.field != newsw->separator.field)
+
+  if (newsw->core.width == 0)
+    newsw->core.width = 8 + 2*SIMPLE_MARGIN(new);
+
+  if (newsw->core.height == 0)
+    newsw->core.height = 8 + 2*SIMPLE_MARGIN(new);
+  
+  if (NE(margin) || NE(separatorType)) 
+    redisplay = True;
+  
+  if (cursw->simple.foreground != newsw->simple.foreground)
+  {
+    XtReleaseGC(new, cursw->separator.gc);
+    GetGC(newsw);
+    redisplay = True;
+  }
+
+  return redisplay;
+}
+
+static void Destroy(w)
+    Widget w;
+{
+  XtReleaseGC( w, ((SeparatorWidget)w)->separator.gc );
+}
+
+static void Redisplay(gw, event, region)
+    Widget gw;
+    XEvent *event;
+    Region region;
+{
+  register SeparatorWidget sw = (SeparatorWidget) gw;
+  int x1, y1, x2, y2;
+  
+  if (!XtIsRealized(gw))
+    return;
+  
+  if (sw->simple.shadow_thickness > 0)
+    (*simpleWidgetClass->core_class.expose) (gw, event, region);
+
+  if (sw->separator.orientation == XtorientHorizontal) {
+    x1 = sw->separator.margin;
+    x2 = sw->core.width - (x1 * 2);
+    
+    switch(sw->separator.separatorType) {
+      
+    case XawSHADOW_ETCHED_IN :
+      y1 = (sw->core.height - 2) / 2;
+      y2 = y1 + 1;
+      
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.bottom_shadow_GC,
+		x1, y1, x2, y1);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.top_shadow_GC,
+		x1, y2, x2, y2);
+      break;
+    case XawSHADOW_ETCHED_OUT:
+      y1 = (sw->core.height - 2) / 2;
+      y2 = y1 + 1;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.bottom_shadow_GC,
+		x1, y2, x2, y2);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.top_shadow_GC,
+		x1, y1, x2, y1);
+      break;
+      
+    case XawDOUBLE_LINE:
+      y1 = (sw->core.height - 2)/ 2;
+      y2 = y1 + 2;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x1, y1, x2, y1);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x1, y2, x2, y2);
+      break;
+      
+    case XawSINGLE_LINE :
+      y1 = sw->core.height / 2;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x1, y1, x2, y1);
+    default:
+    break;
+    }
+  } else {
+    y1 = sw->separator.margin;
+    y2 = sw->core.height - (y1 * 2);
+    
+    switch(sw->separator.separatorType) {
+      
+    case XawSHADOW_ETCHED_IN :
+      x1 = (sw->core.width - 2) / 2;
+      x2 = x1 + 1;
+      
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.bottom_shadow_GC,
+		x1, y1, x1, y2);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.top_shadow_GC,
+		x2, y1, x2, y2);
+      break;
+    case XawSHADOW_ETCHED_OUT:
+      x1 = (sw->core.width - 2) / 2;
+      x2 = x1 + 1;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.bottom_shadow_GC,
+		x1, y1, x1, y2);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->simple.top_shadow_GC,
+		x2, y1, x2, y2);
+      break;
+      
+    case XawDOUBLE_LINE:
+      x1 = (sw->core.width - 2)/ 2;
+      x2 = x1 + 2;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x1, y1, x1, y2);
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x2, y1, x2, y2);
+      break;
+      
+    case XawSINGLE_LINE :
+      x1 = sw->core.width / 2;
+      XDrawLine(XtDisplay(gw), XtWindow(gw), sw->separator.gc,
+		x1, y1, x1, y2);
+    default:
+    break;
+    }
+  }
+}
+
+
diff --git a/vendor/x11iraf/obm/ObmW/zz/Separator.h b/vendor/x11iraf/obm/ObmW/zz/Separator.h
new file mode 100644
index 00000000..6d5ad87f
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Separator.h
@@ -0,0 +1,99 @@
+#ifndef _XawSeparator_h
+#define _XawSeparator_h
+
+/***********************************************************************
+ *
+ * Separator Widget
+ *
+ ***********************************************************************/
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/Simple.h>
+
+/* Resources:
+
+ Name		     Class		RepType		Default Value
+ ----		     -----		-------		-------------
+ background	     Background		Pixel		XtDefaultBackground
+ bitmap		     Pixmap		Pixmap		None
+ border		     BorderColor	Pixel		XtDefaultForeground
+ borderWidth	     BorderWidth	Dimension	1
+ cursor		     Cursor		Cursor		None
+ cursorName	     Cursor		String		NULL
+ destroyCallback     Callback		XtCallbackList	NULL
+ foreground	     Foreground		Pixel		XtDefaultForeground
+ height		     Height		Dimension	text height
+ mappedWhenManaged   MappedWhenManaged	Boolean		True
+ width		     Width		Dimension	text width
+ x		     Position		Position	0
+ y		     Position		Position	0
+
+*/
+
+
+
+
+typedef enum {
+  XawSINGLE_LINE = Xraw_SEPARATOR,
+  XawDOUBLE_LINE,
+  XawSHADOW_ETCHED_IN,
+  XawSHADOW_ETCHED_OUT
+} XawSeparatorType;
+
+
+#define XawSingle_Line       "singleline"
+#define XawDouble_Line       "doubleline"
+#define XawShadow_Etched_In  "shadowetchedin"
+#define XawShadow_Etched_Out "shadowetchedout"
+
+
+
+#ifndef XtNmargin
+#define XtNmargin "margin"
+#endif
+
+#ifndef XtCMargin
+#define XtCMargin "Margin"
+#endif
+
+#ifndef XtNseparatorType
+#define XtNseparatorType "separatorType"
+#endif
+
+#ifndef XtCSeparatorType
+#define XtCSeparatorType "SeparatorType"
+#endif
+
+#ifndef XtRSeparatorType
+#define XtRSeparatorType "SeparatorType"
+#endif
+
+#define XawTextEncoding8bit 0
+#define XawTextEncodingChar2b 1
+
+#define XtNleftBitmap "leftBitmap"
+#define XtCLeftBitmap "LeftBitmap"
+#define XtNencoding "encoding"
+#define XtCEncoding "Encoding"
+
+#ifndef _XtStringDefs_h_
+#define XtNbitmap "bitmap"
+#define XtNforeground "foreground"
+#define XtNseparator "separator"
+#define XtNfont "font"
+#define XtNinternalWidth "internalWidth"
+#define XtNinternalHeight "internalHeight"
+#define XtNresize "resize"
+#define XtCResize "Resize"
+#define XtCBitmap "Bitmap"
+#endif
+
+/* Class record constants */
+
+extern WidgetClass separatorWidgetClass;
+
+typedef struct _SeparatorClassRec *SeparatorWidgetClass;
+typedef struct _SeparatorRec      *SeparatorWidget;
+
+#endif /* _XawSeparator_h */
+/* DON'T ADD STUFF AFTER THIS #endif */
diff --git a/vendor/x11iraf/obm/ObmW/zz/SeparatorP.h b/vendor/x11iraf/obm/ObmW/zz/SeparatorP.h
new file mode 100644
index 00000000..75250d38
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/SeparatorP.h
@@ -0,0 +1,60 @@
+/* 
+ * SeparatorP.h - Private definitions for Separator widget
+ * 
+ */
+
+#ifndef _XawSeparatorP_h
+#define _XawSeparatorP_h
+
+/***********************************************************************
+ *
+ * Separator Widget Private Data
+ *
+ ***********************************************************************/
+
+#include <X11/Xmu/Converters.h>
+#include <X11/Xraw/SimpleP.h>
+#include <X11/Xraw/Separator.h>
+
+
+/* New fields for the Separator widget class record */
+
+typedef struct {int foo;} SeparatorClassPart;
+
+/* Full class record declaration */
+typedef struct _SeparatorClassRec {
+    CoreClassPart	core_class;
+    SimpleClassPart     simple_class;
+    SeparatorClassPart	separator_class;
+} SeparatorClassRec;
+
+extern SeparatorClassRec separatorClassRec;
+
+/* New fields for the Separator widget record */
+
+typedef struct {
+
+  /* Public Resources */
+  XtOrientation    orientation;
+  Dimension        margin;
+  XawSeparatorType separatorType;
+
+  /* Private part */
+  GC               gc;
+
+} SeparatorPart;
+
+
+/****************************************************************
+ *
+ * Full instance record declaration
+ *
+ ****************************************************************/
+
+typedef struct _SeparatorRec {
+    CorePart	  core;
+    SimplePart    simple;
+    SeparatorPart separator;
+} SeparatorRec;
+
+#endif /* _XawSeparatorP_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/Simple.c b/vendor/x11iraf/obm/ObmW/zz/Simple.c
new file mode 100644
index 00000000..83797833
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Simple.c
@@ -0,0 +1,489 @@
+#include <stdio.h>
+
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+
+#include <X11/Xmu/Drawing.h>
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/3d.h>
+#include <X11/Xraw/SimpleP.h>
+#include <X11/Xraw/ContainerP.h>
+
+#define UnspecifiedPixmap (Pixmap)2
+#define UndefinedGC       (GC)2
+  
+static void InsPixel();
+
+static XtResource resources[] = {
+#define offset(field) XtOffset(SimpleWidget, simple.field)
+  {
+    XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
+    offset(cursor), XtRImmediate, (XtPointer) None
+  },
+  {
+    XtNinsensitiveBorder, XtCInsensitive, XtRPixmap, sizeof(Pixmap),
+    offset(insensitive_border), XtRImmediate, (XtPointer) None
+  },
+  {
+    XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
+    offset(foreground), XtRImmediate, (XtPointer) XtDefaultForeground
+  },
+  {
+    "top.gc", "Top.gc", XtRString, sizeof(String),
+    offset(top_shadow_GC), XtRImmediate, (XtPointer)NULL 
+  },
+  {
+    "bottom.gc", "Bottom.gc", XtRString, sizeof(String),
+    offset(bottom_shadow_GC), XtRImmediate, (XtPointer)NULL 
+  },
+  {
+    "highlight.gc", "Highlight.gc", XtRString, sizeof(String),
+    offset(highlight_GC), XtRImmediate, (XtPointer)NULL 
+  },
+  {
+    XtNshadowWidth, XtCShadowWidth, XtRDimension, sizeof(Dimension),
+    offset(shadow_thickness), XtRImmediate, (XtPointer) 0
+  },
+  {
+    XtNtopShadowPixmap, XtCTopShadowPixmap, XtRPixmap, sizeof(Pixmap),
+    offset(top_shadow_pixmap), XtRImmediate, (XtPointer) UnspecifiedPixmap
+  },
+  {
+    XtNtopShadowPixel, XtCTopShadowPixel, XtRPixel, sizeof(Pixel),
+    offset(top_shadow_color), XtRCallProc, (XtPointer) InsPixel
+  },
+  {
+    XtNbottomShadowPixmap, XtCBottomShadowPixmap, XtRPixmap, sizeof(Pixmap),
+    offset(bottom_shadow_pixmap), XtRImmediate, (XtPointer) UnspecifiedPixmap
+  },
+  {
+    XtNbottomShadowPixel, XtCBottomShadowPixel, XtRPixel, sizeof(Pixel),
+    offset(bottom_shadow_color), XtRCallProc, (XtPointer) InsPixel
+  },
+  {
+    XtNhighlightPixmap, XtCHighlightPixmap, XtRPixmap, sizeof(Pixmap),
+    offset(highlight_pixmap), XtRImmediate, (XtPointer) UnspecifiedPixmap
+  },
+  {
+    XtNhighlightPixel, XtCHighlightPixel, XtRPixel, sizeof(Pixel),
+    offset(highlight_color), XtRCallProc, (XtPointer) InsPixel
+  },
+  {
+    XtNhighlightThickness, XtCHighlightThickness, XtRDimension,
+    sizeof(Dimension),
+    offset(highlight_thickness), XtRImmediate, (XtPointer) 2
+  },
+  {
+    XtNuserData, XtCUserData, XtRPixmap, sizeof(Pixmap),
+     offset(user_data), XtRImmediate, (XtPointer) NULL
+  },
+  {
+    XtNborderWidth, XtCBorderWidth, XtRDimension, sizeof(Dimension),
+    XtOffsetOf(RectObjRec,rectangle.border_width), XtRImmediate, (XtPointer)0
+  }
+
+};
+
+static void InsPixel(w, off, value)
+     Widget w;
+     int off;
+     XrmValue *value;
+{
+  register SimpleWidget p = (SimpleWidget) w;
+  static Pixel pixel;
+  
+  if (off == offset(top_shadow_color))
+  {
+    p->simple.top_shadow_GC = UndefinedGC;
+  }
+  else if (off == offset(bottom_shadow_color))
+  {  
+    p->simple.bottom_shadow_GC = UndefinedGC;
+  }
+  else 
+  {  
+    p->simple.highlight_GC = UndefinedGC;
+  }
+  value->addr = (XtPointer) &pixel;
+}
+
+#undef offset
+
+static void ClasstInitialize();
+static void ClassPartInitialize();
+static void Initialize();
+static void Realize();
+static void Redisplay();
+static void Destroy();
+
+static Boolean SetValues();
+static Boolean DisplayRectProc();
+static Boolean ChangeSensitive();
+
+static XtGeometryResult QueryGeometry();
+
+SimpleClassRec simpleClassRec = {
+  { /* core fields */
+    /* superclass		*/	(WidgetClass) &widgetClassRec,
+    /* class_name		*/	"Simple",
+    /* widget_size		*/	sizeof(SimpleRec),
+    /* class_initialize		*/	ClasstInitialize,
+    /* class_part_initialize	*/	ClassPartInitialize,
+    /* class_inited		*/	FALSE,
+    /* initialize		*/	Initialize,
+    /* initialize_hook		*/	NULL,
+    /* realize			*/	Realize,
+    /* actions			*/	NULL,
+    /* num_actions		*/	0,
+    /* resources		*/	resources,
+    /* num_resources		*/	XtNumber(resources),
+    /* xrm_class		*/	NULLQUARK,
+    /* compress_motion		*/	TRUE,
+    /* compress_exposure	*/	TRUE,
+    /* compress_enterleave	*/	TRUE,
+    /* visible_interest		*/	FALSE,
+    /* destroy			*/	Destroy,
+    /* resize			*/	NULL,
+    /* expose			*/	Redisplay,
+    /* set_values		*/	SetValues,
+    /* set_values_hook		*/	NULL,
+    /* set_values_almost	*/	XtInheritSetValuesAlmost,
+    /* get_values_hook		*/	NULL,
+    /* accept_focus		*/	NULL,
+    /* version			*/	XtVersion,
+    /* callback_private		*/	NULL,
+    /* tm_table			*/	NULL,
+    /* query_geometry		*/	QueryGeometry,
+    /* display_accelerator	*/	XtInheritDisplayAccelerator,
+    /* extension		*/	NULL
+  },
+  { /* simple fields */
+    /* change_sensitive		*/	ChangeSensitive,
+    /* display_rect		*/	DisplayRectProc,
+    /* extension		*/	NULL				
+  }
+};
+
+WidgetClass simpleWidgetClass = (WidgetClass)&simpleClassRec;
+
+static void ClasstInitialize()
+{
+/* EMPTY */
+}
+     
+static void ClassPartInitialize(class)
+    WidgetClass class;
+{
+  register SimpleWidgetClass c = (SimpleWidgetClass)class;
+
+  if (c->simple_class.change_sensitive == NULL)
+  {
+    char buf[BUFSIZ];
+
+    sprintf(buf,
+	    "%s Widget: The Simple Widget class method 'change_sensitive' is undefined.\nA function must be defined or inherited.",
+	    c->core_class.class_name);
+    XtWarning(buf);
+	c->simple_class.change_sensitive = ChangeSensitive;
+  }
+
+  if (c->simple_class.change_sensitive == XtInheritChangeSensitive)
+    c->simple_class.change_sensitive = ChangeSensitive;
+  
+  if (c->simple_class.display_rect == XtInheritDisplayRectProc)
+    c->simple_class.display_rect = DisplayRectProc;
+}
+
+/* ARGSUSED */
+static void Initialize(request, new, args, num_args)
+    Widget request, new;
+    ArgList args;
+    Cardinal *num_args;
+{
+  SimpleWidget sw = (SimpleWidget)new;
+  SimplePart*  sp = (SimplePart*)&(sw->simple);
+  
+  if (sp->top_shadow_pixmap == UnspecifiedPixmap)
+    sp->top_shadow_pixmap = None;
+  
+  if (sp->top_shadow_GC == NULL){
+    if (sp->top_shadow_pixmap != None)
+      sp->top_shadow_GC = AllocGCFromPixmap (new, sp->top_shadow_pixmap);
+    else
+      sp->top_shadow_GC = AllocGCFromPixel (new, sp->top_shadow_color);
+  } else if (sp->top_shadow_GC == UndefinedGC)
+    sp->top_shadow_GC = MakeTopShadowGC (new, new->core.background_pixel);
+
+  
+  if (sp->bottom_shadow_pixmap == UnspecifiedPixmap)
+    sp->bottom_shadow_pixmap = None;
+  
+  if (sp->bottom_shadow_GC == NULL){
+    if (sp->bottom_shadow_pixmap != None)
+      sp->bottom_shadow_GC = AllocGCFromPixmap (new, sp->bottom_shadow_pixmap);
+    else
+      sp->bottom_shadow_GC = AllocGCFromPixel (new, sp->bottom_shadow_color);
+  } else if (sp->bottom_shadow_GC == UndefinedGC)
+    sp->bottom_shadow_GC =MakeBottomShadowGC (new, new->core.background_pixel);
+
+
+  if (sp->highlight_pixmap == UnspecifiedPixmap)
+    sp->highlight_pixmap = None;
+  
+  if (sp->highlight_GC == NULL){
+    if (sp->highlight_pixmap != None)
+      sp->highlight_GC = AllocGCFromPixmap (new, sp->highlight_pixmap);
+    else
+      sp->highlight_GC = AllocGCFromPixel (new, sp->highlight_color);
+  } else if (sp->highlight_GC == UndefinedGC)
+    sp->highlight_GC = MakeBottomShadowGC (new, new->core.background_pixel);
+
+}
+
+static void Realize(w, valueMask, attributes)
+     Widget w;
+     Mask *valueMask;
+     XSetWindowAttributes *attributes;
+{
+  Pixmap border_pixmap;
+  
+  if (!XtIsSensitive(w))
+  {
+    /* change border to gray; have to remember the old one,
+     * so XtDestroyWidget deletes the proper one */
+    if (((SimpleWidget)w)->simple.insensitive_border == None)
+      ((SimpleWidget)w)->simple.insensitive_border =
+	XmuCreateStippledPixmap(XtScreen(w),
+				w->core.border_pixel, 
+				w->core.background_pixel,
+				w->core.depth);
+    border_pixmap = w->core.border_pixmap;
+    attributes->border_pixmap =
+      w->core.border_pixmap = ((SimpleWidget)w)->simple.insensitive_border;
+    
+    *valueMask |= CWBorderPixmap;
+    *valueMask &= ~CWBorderPixel;
+  }
+  
+  if ((attributes->cursor = ((SimpleWidget)w)->simple.cursor) != None)
+    *valueMask |= CWCursor;
+  
+  XtCreateWindow( w, (unsigned int)InputOutput, (Visual *)CopyFromParent,
+		 *valueMask, attributes );
+  
+  if (!XtIsSensitive(w))
+    w->core.border_pixmap = border_pixmap;
+}
+
+/* ARGSUSED */
+static Boolean SetValues(current, request, new, args, num_args)
+     Widget   current, request, new;
+     ArgList  args;
+     Cardinal *num_args;
+{
+  SimpleWidget s_old  = (SimpleWidget) current;
+  SimpleWidget s_new  = (SimpleWidget) new;
+  SimplePart*  sp     = (SimplePart*)&(s_new->simple);
+  Boolean      redraw = False;
+  
+#define NE(field) (s_new->simple.field != s_old->simple.field)  
+
+  if ( XtIsSensitive(current) != XtIsSensitive(new) )
+    (*((SimpleWidgetClass)XtClass(new))->
+     simple_class.change_sensitive) ( new );
+
+  if ( NE(cursor) && XtIsRealized(new))
+    XDefineCursor(XtDisplay(new), XtWindow(new), s_new->simple.cursor);
+
+  if (NE(top_shadow_pixmap))
+  {
+    XtReleaseGC (new, sp->top_shadow_GC); 
+    sp->top_shadow_GC = AllocGCFromPixmap (new, sp->top_shadow_pixmap);
+    redraw = True;
+  }
+  else if (NE(top_shadow_color) && sp->top_shadow_pixmap == None)
+  {
+    XtReleaseGC (new, sp->top_shadow_GC);
+    sp->top_shadow_GC = AllocGCFromPixel (new, sp->top_shadow_color);
+    redraw = True;
+  }
+
+  if (NE(bottom_shadow_pixmap))
+  {
+    XtReleaseGC (new, sp->bottom_shadow_GC); 
+    sp->bottom_shadow_GC = AllocGCFromPixmap (new, sp->bottom_shadow_pixmap);
+    redraw = True;
+  }
+  else if (NE(bottom_shadow_color) && sp->bottom_shadow_pixmap == None)
+  {
+    XtReleaseGC (new, sp->bottom_shadow_GC);
+    sp->bottom_shadow_GC = AllocGCFromPixel (new, sp->bottom_shadow_color);
+    redraw = True;
+  }
+
+  if (NE(highlight_pixmap))
+  {
+    XtReleaseGC (new, sp->highlight_GC); 
+    sp->highlight_GC = AllocGCFromPixmap (new, sp->highlight_pixmap);
+    redraw = True;
+  }
+  else if (NE(highlight_color) && sp->highlight_pixmap)
+  {
+    XtReleaseGC (new, sp->highlight_GC);
+    sp->highlight_GC = AllocGCFromPixel (new, sp->highlight_color);
+    redraw = True;
+  }
+
+#undef NE
+  
+  return redraw;
+}
+
+
+static void Unhighlight (gw)
+     Widget gw;
+{
+  register Dimension thick  = ((SimpleWidget)gw)->simple.highlight_thickness;
+  register Dimension  width  = gw->core.width;
+  register Dimension  height = gw->core.height;
+  
+  if (!XtIsRealized(gw))
+          return;
+  
+  if ( XtIsSubclass(XtParent(gw), containerWidgetClass))
+  {
+    XRectangle rectangles[4];
+    GC gc = ((ContainerWidget) XtParent(gw))->container.background_GC;
+
+#define SET_RECTANGLE(I,X,Y,W,H)  \
+    rectangles[I].x = X;     rectangles[I].y = Y; \
+    rectangles[I].width = W; rectangles[I].height = H
+
+    SET_RECTANGLE(0, 0, 0, thick, height);
+    SET_RECTANGLE(1, 0, height - thick, width, thick);
+    SET_RECTANGLE(2, 0, 0, width, thick);
+    SET_RECTANGLE(3, width - thick, 0, thick, height);
+
+    XFillRectangles (XtDisplay(gw), XtWindow(gw), gc, rectangles, 4);
+
+  }
+  else
+  {
+    Display *dpy = XtDisplay(gw);
+    Window   win = XtWindow(gw);
+    
+    XClearArea( dpy, win, 0, 0, thick, height, False);
+    XClearArea( dpy, win, 0, height - thick, width, thick, False);
+    XClearArea( dpy, win, 0, 0, width, thick, False);
+    XClearArea( dpy, win, width - thick, 0, thick, height, False);
+  }
+}
+
+
+/* ARGSUSED */
+static void Redisplay( gw, event, region )
+   Widget gw;
+   XEvent *event;
+   Region region;
+{
+  register SimpleWidget s = (SimpleWidget)gw;
+
+  if (XtIsRealized(gw))
+  {
+    Unhighlight (gw);
+
+    if (s->simple.shadow_thickness)
+      XawDrawFrame (gw,
+		    s->simple.highlight_thickness,
+		    s->simple.highlight_thickness,
+		    s->core.width - 2 * s->simple.highlight_thickness,
+		    s->core.height - 2 * s->simple.highlight_thickness,
+		    XawRAISED,
+		    s->simple.shadow_thickness,
+		    s->simple.top_shadow_GC,
+		    s->simple.bottom_shadow_GC);
+  }
+}
+
+static void Destroy(w)
+     Widget w;
+{
+  register SimpleWidget s = (SimpleWidget)w;
+
+  XtReleaseGC(w, s->simple.top_shadow_GC);
+  XtReleaseGC(w, s->simple.bottom_shadow_GC);
+}
+
+static Boolean DisplayRectProc (w, rect)
+     Widget w;
+     XRectangle *rect;
+{
+  register SimpleWidget s = (SimpleWidget)w;
+  
+  rect->x      =
+  rect->y      = s->simple.highlight_thickness + s->simple.shadow_thickness;
+  rect->width  = s->core.width - 2 * rect->x;
+  rect->height = s->core.height - 2 * rect->y;
+  
+  return True;
+}
+
+
+static XtGeometryResult QueryGeometry(w, intended, preferred)
+    Widget w;
+    XtWidgetGeometry *intended, *preferred;
+{
+    register SimpleWidget sw = (SimpleWidget)w;
+
+
+    preferred->request_mode = CWWidth | CWHeight;
+
+    preferred->width = preferred->height = 2 * SIMPLE_MARGIN(sw) + 1;
+
+#define WIDTH_HEIGHT (CWWidth | CWHeight)
+    
+    if (intended
+	&& ((intended->request_mode & WIDTH_HEIGHT) == WIDTH_HEIGHT)
+	&& intended->width == preferred->width
+	&& intended->height == preferred->height)
+    {  
+	return XtGeometryYes;
+    }
+    else if (preferred->width == w->core.width
+	     && preferred->height == w->core.height)
+    {
+	return XtGeometryNo;
+    }
+    else
+    {
+      return XtGeometryAlmost;
+    }
+}
+
+
+static Boolean ChangeSensitive(w)
+    register Widget w;
+{
+    if (XtIsRealized(w)) {
+	if (XtIsSensitive(w))
+	    if (w->core.border_pixmap != UnspecifiedPixmap)
+		XSetWindowBorderPixmap( XtDisplay(w), XtWindow(w),
+				        w->core.border_pixmap );
+	    else
+		XSetWindowBorder( XtDisplay(w), XtWindow(w), 
+				  w->core.border_pixel );
+	else {
+	    if (((SimpleWidget)w)->simple.insensitive_border == None)
+		((SimpleWidget)w)->simple.insensitive_border =
+		    XmuCreateStippledPixmap(XtScreen(w),
+					    w->core.border_pixel, 
+					    w->core.background_pixel,
+					    w->core.depth);
+	    XSetWindowBorderPixmap( XtDisplay(w), XtWindow(w),
+				    ((SimpleWidget)w)->
+				        simple.insensitive_border );
+	}
+    }
+    return False;
+}
diff --git a/vendor/x11iraf/obm/ObmW/zz/Simple.h b/vendor/x11iraf/obm/ObmW/zz/Simple.h
new file mode 100644
index 00000000..bbe11cda
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Simple.h
@@ -0,0 +1,96 @@
+/*
+ * $XConsortium: Simple.h,v 1.9 89/07/21 01:44:53 kit Exp $
+ */
+
+/***********************************************************
+Copyright 1987, 1988 by Digital Equipment Corporation, Maynard, Massachusetts,
+and the Massachusetts Institute of Technology, Cambridge, Massachusetts.
+
+                        All Rights Reserved
+
+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 names of Digital or MIT not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL 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 _Simple_h
+#define _Simple_h
+
+/****************************************************************
+ *
+ * Simple widgets
+ *
+ ****************************************************************/
+
+/* Resources:
+
+ Name		     Class		RepType		Default Value
+ ----		     -----		-------		-------------
+ background	     Background		Pixel		XtDefaultBackground
+ border		     BorderColor	Pixel		XtDefaultForeground
+ borderWidth	     BorderWidth	Dimension	1
+ cursor		     Cursor		Cursor		None
+ destroyCallback     Callback		Pointer		NULL
+ height		     Height		Dimension	0
+ insensitiveBorder   Insensitive	Pixmap		Gray
+ mappedWhenManaged   MappedWhenManaged	Boolean		True
+ sensitive	     Sensitive		Boolean		True
+ width		     Width		Dimension	0
+ x		     Position		Position	0
+ y		     Position		Position	0
+
+ shadowWidth	      ShadowWidth          Dimension     2
+ topShadowPixel       TopShadowPixel       Pixel         dynamic
+ bottomShadowPixel    BottomShadowPixel    Pixel         dynamic
+ topShadowContrast    TopShadowContrast    Int           20
+ bottomShadowContrast BottomShadowContrast Int           40
+ userData             UserData             XtPointer     NULL
+ beNiceToColormap     BeNiceToColormap     Boolean       False
+
+*/
+
+#define XtNcursor "cursor"
+#define XtNinsensitiveBorder "insensitiveBorder"
+#define XtNuserData "userData"
+#define XtCUserData "UserData"
+
+#define XtCInsensitive "Insensitive"
+
+#define XtNtopShadowPixmap "topShadowPixmap"
+#define XtCTopShadowPixmap "TopShadowPixmap"
+#define XtNbottomShadowPixmap "bottomShadowPixmap"
+#define XtCBottomShadowPixmap "BottomShadowPixmap"
+#define XtNhighlightPixmap "highlightPixmap"
+#define XtCHighlightPixmap "HighlightPixmap"
+#define XtNhighlightThickness "highlightThickness"
+#define XtCHighlightThickness "HighlightThickness"
+
+
+#define XtNshadowWidth "shadowWidth"
+#define XtCShadowWidth "ShadowWidth"
+#define XtNtopShadowPixel "topShadowPixel"
+#define XtCTopShadowPixel "TopShadowPixel"
+#define XtNbottomShadowPixel "bottomShadowPixel"
+#define XtCBottomShadowPixel "BottomShadowPixel"
+#define XtNhighlightPixel "highlightPixel"
+#define XtCHighlightPixel "HighlightPixel"
+
+typedef struct _SimpleClassRec	*SimpleWidgetClass;
+typedef struct _SimpleRec	*SimpleWidget;
+
+extern WidgetClass simpleWidgetClass;
+
+#endif /* _Simple_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/SimpleMenP.h b/vendor/x11iraf/obm/ObmW/zz/SimpleMenP.h
new file mode 100644
index 00000000..32f5ccf9
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/SimpleMenP.h
@@ -0,0 +1,113 @@
+/*
+ * $XConsortium: SimpleMenP.h,v 1.12 89/12/11 15:01:39 kit Exp $
+ *
+ * Copyright 1989 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, 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 M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * 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.
+ *
+ */
+
+/*
+ * SimpleMenuP.h - Private Header file for SimpleMenu widget.
+ *
+ * Date:    April 3, 1989
+ *
+ * By:      Chris D. Peterson
+ *          MIT X Consortium
+ *          kit@expo.lcs.mit.edu
+ */
+
+#ifndef _SimpleMenuP_h
+#define _SimpleMenuP_h
+
+#include <X11/ShellP.h>
+#include <X11/Xraw/3d.h>
+#include <X11/Xraw/SimpleMenu.h>
+#include <X11/Xraw/SmeP.h>
+
+#define SMW(w) ((SimpleMenuWidget)w)->simple_menu
+
+typedef struct {
+    XtPointer extension;		/* For future needs. */
+} SimpleMenuClassPart;
+
+typedef struct _SimpleMenuClassRec {
+  CoreClassPart	          core_class;
+  CompositeClassPart      composite_class;
+  ShellClassPart          shell_class;
+  OverrideShellClassPart  override_shell_class;
+  SimpleMenuClassPart	  simpleMenu_class;
+} SimpleMenuClassRec;
+
+extern SimpleMenuClassRec simpleMenuClassRec;
+
+typedef struct _SimpleMenuPart {
+    /* resources */
+  Dimension 	  shadow_thickness;
+  Dimension 	  bsb_shadow_thickness;
+
+  Pixel	          top_shadow_color;
+  Pixmap	  top_shadow_pixmap;
+  Pixel	          bottom_shadow_color;
+  Pixmap	  bottom_shadow_pixmap;
+
+  GC		  top_shadow_GC;
+  GC		  bottom_shadow_GC;
+
+  XawFrameType    frame_type;
+    
+  XtPointer	  user_data;
+
+  /* resources */
+
+  String       label_string;	/* The string for the label or NULL. */
+  SmeObject    label;		/* If label_string is non-NULL then this is
+				   the label widget. */
+  WidgetClass  label_class;	/* Widget Class of the menu label object. */
+
+  Dimension    top_margin;	/* Top and bottom margins. */
+  Dimension    bottom_margin;
+  Dimension    row_height;	/* height of each row (menu entry) */
+
+  Cursor       cursor;		/* The menu's cursor. */
+  SmeObject    popup_entry;	/* The entry to position the cursor on for
+				   when using XawPositionSimpleMenu. */
+  Boolean      menu_on_screen;	/* Force the menus to be fully on the screen.*/
+  int          backing_store;	/* What type of backing store to use. */
+
+  /* private state */
+
+  Boolean recursive_set_values;	/* contain a possible infinite loop. */
+
+  Boolean menu_width;		/* If true then force width to remain 
+				   core.width */
+  Boolean menu_height;		/* Just like menu_width, but for height. */
+
+  SmeObject entry_set;		/* The entry that is currently set or
+				   highlighted. */
+} SimpleMenuPart;
+
+typedef struct _SimpleMenuRec {
+  CorePart		core;
+  CompositePart 	composite;
+  ShellPart 	        shell;
+  OverrideShellPart     override;
+  SimpleMenuPart	simple_menu;
+} SimpleMenuRec, *SimpleMenu;
+
+#endif /* _SimpleMenuP_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.c b/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.c
new file mode 100644
index 00000000..eeade452
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.c
@@ -0,0 +1,1467 @@
+/* $XConsortium: SimpleMenu.c,v 1.32 89/12/11 15:01:50 kit Exp $ */
+
+/*
+ * Copyright 1989 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, 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 M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * 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.
+ */
+
+/*
+ * SimpleMenu.c - Source code file for SimpleMenu widget.
+ *
+ * Date:    April 3, 1989
+ *
+ * By:      Chris D. Peterson
+ *          MIT X Consortium 
+ *          kit@expo.lcs.mit.edu
+ * --------------------------------
+ *
+ * Date:    Jul 4, 1995
+ *
+ * Changes: Vladimir T. Romanovski
+ *          romsky@hp1.oea.ihep.su   // IHEP (Russia)
+ *          romsky@munin.ucsf.edu    // University of California San Francisco
+ *
+ */
+
+#include <stdio.h>
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/3d.h>
+#include <X11/Xraw/SimpleMenP.h>
+#include <X11/Xraw/SmeBSB.h>
+#include <X11/Xraw/Cardinals.h>
+#include <X11/Xraw/SmeLineP.h>
+
+#include <X11/Xmu/Initer.h>
+#include <X11/Xmu/CharSet.h>
+
+#define CORE(w) (w)->core
+
+#define ForAllChildren(smw, childP) \
+  for ( (childP) = (SmeObject *) (smw)->composite.children ; \
+        (childP) < (SmeObject *) ((smw)->composite.children + \
+				 (smw)->composite.num_children ) ; \
+        (childP)++ )
+
+
+#define UnspecifiedPixmap (Pixmap)2
+#define UndefinedGC       (GC)2
+  
+static void InsPixel();
+
+static XtResource resources[] = { 
+#define offset(field) XtOffset(SimpleMenuWidget, simple_menu.field)
+  {
+    "top.gc", "Top.gc", XtRString, sizeof(String),
+    offset(top_shadow_GC), XtRImmediate, (XtPointer)NULL 
+  },
+  {
+    "bottom.gc", "Bottom.gc", XtRString, sizeof(String),
+    offset(bottom_shadow_GC), XtRImmediate, (XtPointer)NULL 
+  },
+  {
+    XtNshadowWidth, XtCShadowWidth, XtRDimension, sizeof(Dimension),
+    offset(shadow_thickness), XtRImmediate, (XtPointer) 2
+  },
+  {
+    XtNbsbShadowWidth, XtCBsbShadowWidth, XtRDimension, sizeof(Dimension),
+    offset(bsb_shadow_thickness), XtRImmediate, (XtPointer) 2
+  },
+  {
+    XtNtopShadowPixmap, XtCTopShadowPixmap, XtRPixmap, sizeof(Pixmap),
+    offset(top_shadow_pixmap), XtRImmediate, (XtPointer) UnspecifiedPixmap
+  },
+  {
+    XtNtopShadowPixel, XtCTopShadowPixel, XtRPixel, sizeof(Pixel),
+    offset(top_shadow_color), XtRCallProc, (XtPointer) InsPixel
+  },
+  {
+    XtNbottomShadowPixmap, XtCBottomShadowPixmap, XtRPixmap, sizeof(Pixmap),
+    offset(bottom_shadow_pixmap), XtRImmediate, (XtPointer) UnspecifiedPixmap
+  },
+  {
+    XtNbottomShadowPixel, XtCBottomShadowPixel, XtRPixel, sizeof(Pixel),
+    offset(bottom_shadow_color), XtRCallProc, (XtPointer) InsPixel
+  },
+  {
+    XtNuserData, XtCUserData, XtRPixmap, sizeof(Pixmap),
+     offset(user_data), XtRImmediate, (XtPointer) NULL
+  },
+  {
+    XtNborderWidth, XtCBorderWidth, XtRDimension, sizeof(Dimension),
+    XtOffsetOf(RectObjRec,rectangle.border_width), XtRImmediate, (XtPointer)0
+  },
+  {
+    XtNframeType, XtCFrameType, XtRFrameType, sizeof(XawFrameType),
+    offset(frame_type), XtRImmediate, (XtPointer) XawRAISED
+  },
+
+/*
+ * Label Resources.
+ */
+
+  {
+    XtNlabel,  XtCLabel, XtRString, sizeof(String),
+    offset(label_string), XtRString, NULL
+  },
+  {
+    XtNlabelClass,  XtCLabelClass, XtRPointer, sizeof(WidgetClass),
+    offset(label_class), XtRImmediate, (XtPointer) NULL
+  },
+
+/*
+ * Layout Resources.
+ */
+
+  {
+    XtNrowHeight,  XtCRowHeight, XtRDimension, sizeof(Dimension),
+    offset(row_height), XtRImmediate, (XtPointer) 0
+  },
+  {
+    XtNtopMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
+     offset(top_margin), XtRImmediate, (XtPointer) 0
+  },
+  {
+    XtNbottomMargin,  XtCVerticalMargins, XtRDimension, sizeof(Dimension),
+     offset(bottom_margin), XtRImmediate, (XtPointer) 0
+  },
+
+/*
+ * Misc. Resources
+ */
+
+  {
+    XtNallowShellResize, XtCAllowShellResize, XtRBoolean, sizeof(Boolean),
+    XtOffset(SimpleMenuWidget, shell.allow_shell_resize),
+    XtRImmediate, (XtPointer) TRUE
+  },
+  {
+    XtNcursor, XtCCursor, XtRCursor, sizeof(Cursor),
+    offset(cursor), XtRImmediate, (XtPointer) None
+  },
+  {
+    XtNmenuOnScreen,  XtCMenuOnScreen, XtRBoolean, sizeof(Boolean),
+    offset(menu_on_screen), XtRImmediate, (XtPointer) TRUE
+  },
+  {
+    XtNpopupOnEntry,  XtCPopupOnEntry, XtRWidget, sizeof(Widget),
+    offset(popup_entry), XtRWidget, NULL
+  },
+  {
+    XtNbackingStore, XtCBackingStore, XtRBackingStore, sizeof (int),
+    offset(backing_store), XtRImmediate,
+    (XtPointer) (Always + WhenMapped + NotUseful)
+  }
+};  
+
+static void InsPixel(w, off, value)
+     Widget w;
+     int off;
+     XrmValue *value;
+{
+  register SimpleMenuWidget p = (SimpleMenuWidget) w;
+  static Pixel pixel;
+  
+  if (off == offset(top_shadow_color))
+  {
+    p->simple_menu.top_shadow_GC = UndefinedGC;
+  }
+  else if (off == offset(bottom_shadow_color))
+  {  
+    p->simple_menu.bottom_shadow_GC = UndefinedGC;
+  }
+  value->addr = (XtPointer) &pixel;
+}
+
+#undef offset
+
+static char defaultTranslations[] =
+    "<EnterWindow>:     highlight()            \n\
+     <LeaveWindow>:     unhighlight()          \n\
+     <BtnMotion>:       highlight()            \n\
+     <BtnUp>:           MenuPopdown() notify() unhighlight()"; 
+
+/*
+ * Semi Public function definitions. 
+ */
+
+static void Redisplay(), Realize(), Resize(), ChangeManaged();
+static void Initialize(), ClassInitialize(), ClassPartInitialize();
+static Boolean SetValues(), SetValuesHook();
+static XtGeometryResult GeometryManager();
+
+/*
+ * Action Routine Definitions
+ */
+
+static void Highlight(), Unhighlight(), Notify(), PositionMenuAction();
+
+/* 
+ * Private Function Definitions.
+ */
+
+static void MakeSetValuesRequest(), CreateLabel(), Layout();
+static void AddPositionAction(), PositionMenu();
+static Dimension GetMenuWidth(), GetMenuHeight();
+static Widget FindMenu();
+static SmeObject GetEventEntry();
+
+static XtActionsRec actionsList[] =
+{
+  {"notify",            Notify},
+  {"highlight",         Highlight},
+  {"unhighlight",       Unhighlight}
+};
+ 
+CompositeClassExtensionRec extension_rec = {
+    /* next_extension  */ NULL,
+    /* record_type     */ NULLQUARK,
+    /* version         */ XtCompositeExtensionVersion,
+    /* record_size     */ sizeof(CompositeClassExtensionRec),
+    /* accepts_objects */ TRUE,
+};
+
+#define superclass (&overrideShellClassRec)
+    
+SimpleMenuClassRec simpleMenuClassRec = {
+  {
+    /* superclass         */    (WidgetClass) superclass,
+    /* class_name         */    "SimpleMenu",
+    /* size               */    sizeof(SimpleMenuRec),
+    /* class_initialize   */	ClassInitialize,
+    /* class_part_initialize*/	ClassPartInitialize,
+    /* Class init'ed      */	False,
+    /* initialize         */    Initialize,
+    /* initialize_hook    */	NULL,
+    /* realize            */    Realize,
+    /* actions            */    actionsList,
+    /* num_actions        */    XtNumber(actionsList),
+    /* resources          */    resources,
+    /* resource_count     */	XtNumber(resources),
+    /* xrm_class          */    NULLQUARK,
+    /* compress_motion    */    TRUE, 
+    /* compress_exposure  */    TRUE,
+    /* compress_enterleave*/ 	TRUE,
+    /* visible_interest   */    False,
+    /* destroy            */    NULL,
+    /* resize             */    Resize,
+    /* expose             */    Redisplay,
+    /* set_values         */    SetValues,
+    /* set_values_hook    */	SetValuesHook,
+    /* set_values_almost  */	XtInheritSetValuesAlmost,  
+    /* get_values_hook    */	NULL,			
+    /* accept_focus       */    NULL,
+    /* intrinsics version */	XtVersion,
+    /* callback offsets   */    NULL,
+    /* tm_table		  */    defaultTranslations,
+    /* query_geometry	  */    NULL,
+    /* display_accelerator*/    NULL,
+    /* extension	  */    NULL
+  },{
+    /* geometry_manager   */    GeometryManager,
+    /* change_managed     */    ChangeManaged,
+    /* insert_child	  */	XtInheritInsertChild,
+    /* delete_child	  */	XtInheritDeleteChild,
+    /* extension	  */    NULL
+  },{
+    /* Shell extension	  */    NULL
+  },{
+    /* Override extension */    NULL
+  },{
+    /* Simple Menu extension*/  NULL
+  }
+};
+
+WidgetClass simpleMenuWidgetClass = (WidgetClass)&simpleMenuClassRec;
+
+/************************************************************
+ *
+ * Semi-Public Functions.
+ *
+ ************************************************************/
+#define done(type, value)  \
+  { \
+      if (to->addr != NULL) { \
+	  if (to->size < sizeof(type)) { \
+	      to->size = sizeof(type); \
+	      return False; \
+	  } \
+	  *(type*)(to->addr) = (value); \
+      } else { \
+	  static type static_val; \
+	  static_val = (value); \
+	  to->addr = (XtPointer)&static_val; \
+      } \
+      to->size = sizeof(type); \
+      return True; \
+  }
+
+
+/* ARGSUSED */
+static  Boolean
+cvtStringToFrameType ( display, args, num_args,  from, to, converter_data)
+     Display *display;
+     XrmValuePtr args;
+     Cardinal *num_args;
+     XrmValuePtr from;
+     XrmValuePtr to;
+     XtPointer *converter_data;
+{
+  String s = (String) from->addr;
+  
+  if (*num_args != 0)
+    XtAppErrorMsg(XtDisplayToApplicationContext(display),
+		  "cvtStringToFrameType", "wrongParameters",
+		  "XtToolkitError",
+		  "String to frame type conversion needs no arguments",
+		  (String*) NULL, (Cardinal*) NULL);
+  
+  if (XmuCompareISOLatin1(s, "raised") == 0) done(XawFrameType, XawRAISED);
+  if (XmuCompareISOLatin1(s, "sunken") == 0) done(XawFrameType, XawSUNKEN);
+  if (XmuCompareISOLatin1(s, "chiseled") == 0) done(XawFrameType, XawCHISELED);
+  if (XmuCompareISOLatin1(s, "ledged") == 0) done(XawFrameType, XawLEDGED);
+  if (XmuCompareISOLatin1(s, "tack")     == 0) done(XawFrameType, XawTACK);
+
+  XtDisplayStringConversionWarning(display, s, XtRFrameType);
+  printf("SimpleMenu.c");
+
+  done(XawFrameType, XawRAISED);
+}
+
+/*      Function Name: ClassInitialize
+ *      Description: Class Initialize routine, called only once.
+ *      Arguments: none.
+ *      Returns: none.
+ */
+
+static void
+ClassInitialize()
+{
+  XawInitializeWidgetSet();
+  XtAddConverter( XtRString, XtRBackingStore, XmuCvtStringToBackingStore,
+		 NULL, 0 );
+  XmuAddInitializer( AddPositionAction, NULL);
+
+  XtSetTypeConverter(XtRString, XtRFrameType, cvtStringToFrameType,
+		     NULL, 0, XtCacheNone, NULL);
+}
+
+/*      Function Name: ClassPartInitialize
+ *      Description: Class Part Initialize routine, called for every
+ *                   subclass.  Makes sure that the subclasses pick up 
+ *                   the extension record.
+ *      Arguments: wc - the widget class of the subclass.
+ *      Returns: none.
+ */
+
+static void
+ClassPartInitialize(wc)
+WidgetClass wc;
+{
+    SimpleMenuWidgetClass smwc = (SimpleMenuWidgetClass) wc;
+
+/*
+ * Make sure that our subclass gets the extension rec too.
+ */
+
+    extension_rec.next_extension = smwc->composite_class.extension;
+    smwc->composite_class.extension = (XtPointer) &extension_rec;
+}
+
+/*      Function Name: Initialize
+ *      Description: Initializes the simple menu widget
+ *      Arguments: request - the widget requested by the argument list.
+ *                 new     - the new widget with both resource and non
+ *                           resource values.
+ *      Returns: none.
+ */
+
+/* ARGSUSED */
+static void
+Initialize(request, new)
+Widget request, new;
+{
+  SimpleMenuWidget smw = (SimpleMenuWidget) new;
+  register SimpleMenuPart* smwp = (SimpleMenuPart*)&smw->simple_menu;
+  
+  XmuCallInitializers(XtWidgetToApplicationContext(new));
+
+  if (smwp->label_class == NULL) 
+      smwp->label_class = smeBSBObjectClass;
+
+  smwp->label                = NULL;
+  smwp->entry_set            = NULL;
+  smwp->recursive_set_values = False;
+
+  if (smwp->label_string != NULL)
+      CreateLabel(new);
+
+  smwp->menu_width = TRUE;
+
+  if (smw->core.width == 0)
+  {
+      smwp->menu_width = False;
+      smw->core.width  = GetMenuWidth(new, NULL);
+  }
+
+  smwp->menu_height = TRUE;
+
+  if (smw->core.height == 0)
+  {
+      smwp->menu_height = False;
+      smw->core.height  = GetMenuHeight(new);
+  }
+
+
+  /*
+   *   Top & Bottom Shadow GCs
+   */
+  
+  if (smwp->top_shadow_pixmap == UnspecifiedPixmap)
+    smwp->top_shadow_pixmap = None;
+  
+  if (smwp->top_shadow_GC == NULL){
+    if (smwp->top_shadow_pixmap != None)
+      smwp->top_shadow_GC = AllocGCFromPixmap (new, smwp->top_shadow_pixmap);
+    else
+      smwp->top_shadow_GC = AllocGCFromPixel (new, smwp->top_shadow_color);
+  } else if (smwp->top_shadow_GC == UndefinedGC)
+    smwp->top_shadow_GC = MakeTopShadowGC (new, new->core.background_pixel);
+
+  
+  if (smwp->bottom_shadow_pixmap == UnspecifiedPixmap)
+    smwp->bottom_shadow_pixmap = None;
+  
+  if (smwp->bottom_shadow_GC == NULL){
+    if (smwp->bottom_shadow_pixmap != None)
+      smwp->bottom_shadow_GC =
+	              AllocGCFromPixmap (new, smwp->bottom_shadow_pixmap);
+    else
+      smwp->bottom_shadow_GC =
+	              AllocGCFromPixel (new, smwp->bottom_shadow_color);
+  } else if (smwp->bottom_shadow_GC == UndefinedGC)
+    smwp->bottom_shadow_GC =
+                      MakeBottomShadowGC (new, new->core.background_pixel);
+}
+
+/*      Function Name: Redisplay
+ *      Description: Redisplays the contents of the widget.
+ *      Arguments: w - the simple menu widget.
+ *                 event - the X event that caused this redisplay.
+ *                 region - the region the needs to be repainted. 
+ *      Returns: none.
+ */
+
+/* ARGSUSED */
+static void Redisplay(w, event, region)
+     Widget   w;
+     XEvent * event;
+     Region   region;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject *    entry;
+    SmeObjectClass class;
+
+    if (region == NULL)
+	XClearWindow(XtDisplay(w), XtWindow(w));
+
+    /*
+     * Check and Paint each of the entries
+     */
+
+    ForAllChildren(smw, entry) 
+      if (XtIsManaged ((Widget)*entry))
+      {
+	class = (SmeObjectClass) (*entry)->object.widget_class;
+
+	if (class->rect_class.expose)
+	  (*class->rect_class.expose) ((Widget)*entry, NULL, region);
+      }
+
+    XawDrawFrame(w,
+		 0, 0, CORE(w).width, CORE(w).height,
+		 SMW(w).frame_type,
+		 SMW(w).shadow_thickness,
+		 SMW(w).top_shadow_GC,
+		 SMW(w).bottom_shadow_GC);
+
+}
+
+/*      Function Name: Realize
+ *      Description: Realizes the widget.
+ *      Arguments: w - the simple menu widget.
+ *                 mask - value mask for the window to create.
+ *                 attrs - attributes for the window to create.
+ *      Returns: none
+ */
+
+static void
+Realize(w, mask, attrs)
+Widget w;
+XtValueMask * mask;
+XSetWindowAttributes * attrs;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+
+    attrs->cursor = smw->simple_menu.cursor;
+    *mask |= CWCursor;
+    if ((smw->simple_menu.backing_store == Always) ||
+	(smw->simple_menu.backing_store == NotUseful) ||
+	(smw->simple_menu.backing_store == WhenMapped) ) {
+	*mask |= CWBackingStore;
+	attrs->backing_store = smw->simple_menu.backing_store;
+    }
+    else
+	*mask &= ~CWBackingStore;
+
+    *mask |= CWSaveUnder;
+    attrs->save_under = True;
+    
+    (*superclass->core_class.realize) (w, mask, attrs);
+}
+
+/*      Function Name: Resize
+ *      Description: Handle the menu being resized bigger.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: none.
+ */
+
+static void Resize(w)
+     Widget w;
+{
+  SimpleMenuWidget smw = (SimpleMenuWidget) w;
+  SmeObject * entry;
+  
+  if ( !XtIsRealized(w) ) return;
+  
+  ForAllChildren(smw, entry) 	/* reset width of all entries. */
+    if (XtIsManaged( (Widget) *entry)) {     
+      (*entry)->rectangle.width = smw->core.width -
+	                                 2 * SMW(w).shadow_thickness;
+      (*entry)->rectangle.x     = SMW(w).shadow_thickness;
+    }
+
+  XClearWindow(XtDisplay(w), XtWindow(w));
+  
+  Redisplay(w, (XEvent *) NULL, (Region) NULL);
+
+}
+    
+/*      Function Name: SetValues
+ *      Description: Relayout the menu when one of the resources is changed.
+ *      Arguments: current - current state of the widget.
+ *                 request - what was requested.
+ *                 new - what the widget will become.
+ *      Returns: none
+ */
+
+/* ARGSUSED */
+static Boolean SetValues(current, request, new)
+     Widget current;
+     Widget request;
+     Widget new;
+{
+    SimpleMenuWidget      smw_old = (SimpleMenuWidget) current;
+    SimpleMenuWidget      smw_new = (SimpleMenuWidget) new;
+    register SimpleMenuPart* smwp = (SimpleMenuPart*)&smw_new->simple_menu;
+    Boolean               ret_val = False;
+    Boolean                layout = False;
+    Boolean             redisplay = False;
+    
+#define NE(name) (smw_old->simple_menu.name != smw_new->simple_menu.name)
+
+    if (!XtIsRealized(current))
+      return False;
+    
+    if (!smw_new->simple_menu.recursive_set_values)
+    {
+	if (smw_new->core.width != smw_old->core.width)
+	{
+	    smw_new->simple_menu.menu_width = (smw_new->core.width != 0);
+	    layout = TRUE;
+	}
+	if (smw_new->core.height != smw_old->core.height)
+	{
+	    smw_new->simple_menu.menu_height = (smw_new->core.height != 0);
+	    layout = TRUE;
+	}
+    }
+
+    if (NE(cursor))
+	XDefineCursor(XtDisplay(new),
+		      XtWindow(new), smw_new->simple_menu.cursor);
+    
+    if (NE(label_string))
+	if (smw_new->simple_menu.label_string == NULL)         /* Destroy. */
+	  XtDestroyWidget((Widget)smw_old->simple_menu.label);
+	else if (smw_old->simple_menu.label_string == NULL)    /* Create. */
+	  CreateLabel(new);
+	else                                                  /* Change. */
+	  XtVaSetValues((Widget)smw_new->simple_menu.label,
+			XtNlabel, smw_new->simple_menu.label_string,
+			NULL);
+    
+    if (NE(label_class))
+	XtAppWarning(XtWidgetToApplicationContext(new),
+		     "No Dynamic class change of the SimpleMenu Label.");
+    
+    if (NE(top_margin) || NE(bottom_margin)) /* filler.................  */ 
+    {
+      layout = TRUE;
+      ret_val = TRUE;
+    }
+
+    if (layout)
+	Layout(new, NULL, NULL);
+    {
+
+      if ( NE(shadow_thickness) )
+	redisplay = TRUE;
+      
+      if (NE(top_shadow_pixmap))
+      {
+	
+	XtReleaseGC (new, smwp->top_shadow_GC); 
+	smwp->top_shadow_GC = AllocGCFromPixmap (new, smwp->top_shadow_pixmap);
+	redisplay = True;
+	
+      }
+      else  if (NE(top_shadow_color && smwp->top_shadow_pixmap))
+      {
+
+	XtReleaseGC (new, smwp->top_shadow_GC);
+	smwp->top_shadow_GC = AllocGCFromPixel (new, smwp->top_shadow_color);
+	redisplay = True;
+	
+      }
+      
+      if (NE(bottom_shadow_pixmap))
+      {
+	
+	XtReleaseGC (new, smwp->bottom_shadow_GC); 
+	smwp->bottom_shadow_GC =
+	  AllocGCFromPixmap (new, smwp->bottom_shadow_pixmap);
+
+	redisplay = True;
+	
+      }
+      else  if (NE(bottom_shadow_color && smwp->bottom_shadow_pixmap))
+      {
+	
+	XtReleaseGC (new, smwp->bottom_shadow_GC);
+	smwp->bottom_shadow_GC =
+	                 AllocGCFromPixel (new, smwp->bottom_shadow_color);
+	redisplay = True;
+	
+      }
+
+#undef NE
+    }
+
+    return(ret_val || redisplay);
+}
+
+/*      Function Name: SetValuesHook
+ *      Description: To handle a special case, this is passed the
+ *                   actual arguments.
+ *      Arguments: w - the menu widget.
+ *                 arglist - the argument list passed to XtSetValues.
+ *                 num_args - the number of args.
+ *      Returns: none
+ */
+
+/* 
+ * If the user actually passed a width and height to the widget
+ * then this MUST be used, rather than our newly calculated width and
+ * height.
+ */
+
+static Boolean
+SetValuesHook(w, arglist, num_args)
+Widget w;
+ArgList arglist;
+Cardinal *num_args;
+{
+    register Cardinal i;
+    Dimension width, height;
+    
+    width = w->core.width;
+    height = w->core.height;
+    
+    for ( i = 0 ; i < *num_args ; i++) {
+	if ( streq(arglist[i].name, XtNwidth) )
+	    width = (Dimension) arglist[i].value;
+	if ( streq(arglist[i].name, XtNheight) )
+	    height = (Dimension) arglist[i].value;
+    }
+
+    if ((width != w->core.width) || (height != w->core.height))
+	MakeSetValuesRequest(w, width, height);
+    return(False);
+}
+
+/************************************************************
+ *
+ * Geometry Management routines.
+ *
+ ************************************************************/
+
+/*	Function Name: GeometryManager
+ *	Description: This is the SimpleMenu Widget's Geometry Manager.
+ *	Arguments: w - the Menu Entry making the request.
+ *                 request - requested new geometry.
+ *                 reply - the allowed geometry.
+ *	Returns: XtGeometry{Yes, No, Almost}.
+ */
+
+static XtGeometryResult
+GeometryManager(w, request, reply)
+Widget w;
+XtWidgetGeometry * request, * reply;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) XtParent(w);
+    SmeObject entry = (SmeObject) w;
+    XtGeometryMask mode = request->request_mode;
+    XtGeometryResult answer;
+    Dimension old_height, old_width;
+
+    if ( !(mode & CWWidth) && !(mode & CWHeight) )
+	return(XtGeometryNo);
+
+    reply->width = request->width;
+    reply->height = request->height;
+
+    old_width = entry->rectangle.width;
+    old_height = entry->rectangle.height;
+
+    Layout(w, &(reply->width), &(reply->height) );
+
+/*
+ * Since we are an override shell and have no parent there is no one to
+ * ask to see if this geom change is okay, so I am just going to assume
+ * we can do whatever we want.  If you subclass be very careful with this
+ * assumption, it could bite you.
+ *
+ * Chris D. Peterson - Sept. 1989.
+ */
+
+    if ( (reply->width == request->width) &&
+	 (reply->height == request->height) ) {
+
+	if ( mode & XtCWQueryOnly ) { /* Actually perform the layout. */
+	    entry->rectangle.width = old_width;
+	    entry->rectangle.height = old_height;	
+	}
+	else {
+	    Layout(( Widget) smw, NULL, NULL);
+	}
+	answer = XtGeometryDone;
+    }
+    else {
+	entry->rectangle.width = old_width;
+	entry->rectangle.height = old_height;	
+
+	if ( ((reply->width == request->width) && !(mode & CWHeight)) ||
+	      ((reply->height == request->height) && !(mode & CWWidth)) ||
+	      ((reply->width == request->width) && 
+	       (reply->height == request->height)) )
+	    answer = XtGeometryNo;
+	else {
+	    answer = XtGeometryAlmost;
+	    reply->request_mode = 0;
+	    if (reply->width != request->width)
+		reply->request_mode |= CWWidth;
+	    if (reply->height != request->height)
+		reply->request_mode |= CWHeight;
+	}
+    }
+    return(answer);
+}
+
+/*	Function Name: ChangeManaged
+ *	Description: called whenever a new child is managed.
+ *	Arguments: w - the simple menu widget.
+ *	Returns: none.
+ */
+
+static void
+ChangeManaged(w)
+Widget w;
+{
+    Layout(w, NULL, NULL);
+}
+
+/************************************************************
+ *
+ * Global Action Routines.
+ * 
+ * These actions routines will be added to the application's
+ * global action list. 
+ * 
+ ************************************************************/
+
+/*      Function Name: PositionMenuAction
+ *      Description: Positions the simple menu widget.
+ *      Arguments: w - a widget (no the simple menu widget.)
+ *                 event - the event that caused this action.
+ *                 params, num_params - parameters passed to the routine.
+ *                                      we expect the name of the menu here.
+ *      Returns: none
+ */
+
+/* ARGSUSED */
+static void
+PositionMenuAction(w, event, params, num_params)
+Widget w;
+XEvent * event;
+String * params;
+Cardinal * num_params;
+{ 
+  Widget menu;
+  XPoint loc;
+
+  if (*num_params != 1) {
+    char error_buf[BUFSIZ];
+    sprintf(error_buf, "%s %s",
+	    "Xaw - SimpleMenuWidget: position menu action expects only one",
+	    "parameter which is the name of the menu.");
+    XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
+    return;
+  }
+
+  if ( (menu = FindMenu(w, params[0])) == NULL) {
+    char error_buf[BUFSIZ];
+    sprintf(error_buf, "%s '%s'",
+	    "Xaw - SimpleMenuWidget: could not find menu named: ", params[0]);
+    XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
+    return;
+  }
+  
+  switch (event->type) {
+  case ButtonPress:
+  case ButtonRelease:
+    loc.x = event->xbutton.x_root;
+    loc.y = event->xbutton.y_root;
+    PositionMenu(menu, &loc);
+    break;
+  case EnterNotify:
+  case LeaveNotify:
+    loc.x = event->xcrossing.x_root;
+    loc.y = event->xcrossing.y_root;
+    PositionMenu(menu, &loc);
+    break;
+  case MotionNotify:
+    loc.x = event->xmotion.x_root;
+    loc.y = event->xmotion.y_root;
+    PositionMenu(menu, &loc);
+    break;
+  default:
+    PositionMenu(menu, NULL);
+    break;
+  }
+}  
+
+/************************************************************
+ *
+ * Widget Action Routines.
+ * 
+ ************************************************************/
+
+/*      Function Name: Unhighlight
+ *      Description: Unhighlights current entry.
+ *      Arguments: w - the simple menu widget.
+ *                 event - the event that caused this action.
+ *                 params, num_params - ** NOT USED **
+ *      Returns: none
+ */
+
+/* ARGSUSED */
+static void
+Unhighlight(w, event, params, num_params)
+Widget w;
+XEvent * event;
+String * params;
+Cardinal * num_params;
+{ 
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject entry = smw->simple_menu.entry_set;
+    SmeObjectClass class;
+ 
+    if ( entry == NULL) return;
+
+    smw->simple_menu.entry_set = NULL;
+    class = (SmeObjectClass) entry->object.widget_class;
+    (class->sme_class.unhighlight) ( (Widget) entry);
+}
+
+/*      Function Name: Highlight
+ *      Description: Highlights current entry.
+ *      Arguments: w - the simple menu widget.
+ *                 event - the event that caused this action.
+ *                 params, num_params - ** NOT USED **
+ *      Returns: none
+ */
+
+/* ARGSUSED */
+static void
+Highlight(w, event, params, num_params)
+Widget w;
+XEvent * event;
+String * params;
+Cardinal * num_params;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject entry;
+    SmeObjectClass class;
+    
+    if ( !XtIsSensitive(w) ) return;
+    
+    entry = GetEventEntry(w, event);
+
+    if (entry == smw->simple_menu.entry_set) return;
+
+    Unhighlight(w, event, params, num_params);  
+
+    if (entry == NULL) return;
+
+    if ( !XtIsSensitive( (Widget) entry)) {
+	smw->simple_menu.entry_set = NULL;
+	return;
+    }
+
+    smw->simple_menu.entry_set = entry;
+    class = (SmeObjectClass) entry->object.widget_class;
+
+    (class->sme_class.highlight) ( (Widget) entry);
+}
+
+/*      Function Name: Notify
+ *      Description: Notify user of current entry.
+ *      Arguments: w - the simple menu widget.
+ *                 event - the event that caused this action.
+ *                 params, num_params - ** NOT USED **
+ *      Returns: none
+ */
+
+/* ARGSUSED */
+static void
+Notify(w, event, params, num_params)
+Widget w;
+XEvent * event;
+String * params;
+Cardinal * num_params;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject entry = smw->simple_menu.entry_set;
+    SmeObjectClass class;
+    
+    if ( (entry == NULL) || !XtIsSensitive((Widget) entry) ) return;
+
+    class = (SmeObjectClass) entry->object.widget_class;
+    (class->sme_class.notify)( (Widget) entry );
+}
+
+/************************************************************
+ *
+ * Public Functions.
+ *
+ ************************************************************/
+ 
+/*	Function Name: XawSimpleMenuAddGlobalActions
+ *	Description: adds the global actions to the simple menu widget.
+ *	Arguments: app_con - the appcontext.
+ *	Returns: none.
+ */
+
+void
+XawSimpleMenuAddGlobalActions(app_con)
+XtAppContext app_con;
+{
+    XtInitializeWidgetClass(simpleMenuWidgetClass);
+    XmuCallInitializers( app_con );
+} 
+
+ 
+/*	Function Name: XawSimpleMenuGetActiveEntry
+ *	Description: Gets the currently active (set) entry.
+ *	Arguments: w - the smw widget.
+ *	Returns: the currently set entry or NULL if none is set.
+ */
+
+Widget
+XawSimpleMenuGetActiveEntry(w)
+Widget w;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+
+    return( (Widget) smw->simple_menu.entry_set);
+} 
+
+/*	Function Name: XawSimpleMenuClearActiveEntry
+ *	Description: Unsets the currently active (set) entry.
+ *	Arguments: w - the smw widget.
+ *	Returns: none.
+ */
+
+void
+XawSimpleMenuClearActiveEntry(w)
+Widget w;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+
+    smw->simple_menu.entry_set = NULL;
+} 
+
+/************************************************************
+ *
+ * Private Functions.
+ *
+ ************************************************************/
+
+/*	Function Name: CreateLabel
+ *	Description: Creates a the menu label.
+ *	Arguments: w - the smw widget.
+ *	Returns: none.
+ * 
+ * Creates the label object and makes sure it is the first child in
+ * in the list.
+ */
+
+static void
+CreateLabel(w)
+Widget w;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    register Widget * child, * next_child;
+    register int i;
+    Arg args[2];
+
+    if ( (smw->simple_menu.label_string == NULL) ||
+	 (smw->simple_menu.label != NULL) ) {
+	char error_buf[BUFSIZ];
+
+	sprintf(error_buf, "Xaw Simple Menu Widget: %s or %s, %s",
+		"label string is NULL", "label already exists", 
+		"no label is being created.");
+	XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
+	return;
+    }
+
+    XtSetArg(args[0], XtNlabel, smw->simple_menu.label_string);
+    XtSetArg(args[1], XtNjustify, XtJustifyCenter);
+    smw->simple_menu.label = (SmeObject) 
+	                      XtCreateManagedWidget("menuLabel", 
+					    smw->simple_menu.label_class, w,
+					    args, TWO);
+
+    next_child = NULL;
+    for (child = smw->composite.children + smw->composite.num_children,
+	 i = smw->composite.num_children ; i > 0 ; i--, child--) {
+	if (next_child != NULL)
+	    *next_child = *child;
+	next_child = child;
+    }
+    *child = (Widget) smw->simple_menu.label;
+}
+
+/*	Function Name: Layout
+ *	Description: lays the menu entries out all nice and neat.
+ *	Arguments: w - See below (+++)
+ *                 width_ret, height_ret - The returned width and 
+ *                                         height values.
+ *	Returns: none.
+ *
+ * if width == NULL || height == NULL then it assumes the you do not care
+ * about the return values, and just want a relayout.
+ *
+ * if this is not the case then it will set width_ret and height_ret
+ * to be width and height that the child would get if it were layed out
+ * at this time.
+ *
+ * +++ "w" can be the simple menu widget or any of its object children.
+ */
+
+static void
+Layout(w, width_ret, height_ret)
+Widget w;
+Dimension *width_ret, *height_ret;
+{
+    SmeObject current_entry, *entry;
+    SimpleMenuWidget smw;
+    Dimension width, height;
+    Boolean do_layout = ((height_ret == NULL) || (width_ret == NULL));
+    Boolean allow_change_size;
+    height = 0;
+
+    if ( XtIsSubclass(w, simpleMenuWidgetClass) ) {
+	smw = (SimpleMenuWidget) w;
+	current_entry = NULL;
+    }
+    else {
+	smw = (SimpleMenuWidget) XtParent(w);
+	current_entry = (SmeObject) w;
+    }
+
+    allow_change_size = (!XtIsRealized((Widget)smw) ||
+			 (smw->shell.allow_shell_resize));
+
+    if ( smw->simple_menu.menu_height )
+	height = smw->core.height;
+    else
+	if (do_layout) {
+	    height = smw->simple_menu.top_margin;
+	    height += smw->simple_menu.shadow_thickness;
+	    ForAllChildren(smw, entry) {
+		if (!XtIsManaged( (Widget) *entry)) continue;
+
+		if ( (smw->simple_menu.row_height != 0) && 
+		    (*entry != smw->simple_menu.label) ) 
+		    (*entry)->rectangle.height = smw->simple_menu.row_height;
+		
+		(*entry)->rectangle.y = height;
+		(*entry)->rectangle.x = smw->simple_menu.shadow_thickness;
+		height += (*entry)->rectangle.height;
+	    }
+	    height += smw->simple_menu.bottom_margin;
+	    height += smw->simple_menu.shadow_thickness;
+	  }
+	else {
+	    if ((smw->simple_menu.row_height != 0) && 
+		(current_entry != smw->simple_menu.label) )
+		height = smw->simple_menu.row_height;
+	}
+    
+    if (smw->simple_menu.menu_width)
+	width = smw->core.width;
+    else if ( allow_change_size ){
+        width = GetMenuWidth((Widget) smw, (Widget) current_entry);
+        width +=2*smw->simple_menu.shadow_thickness;
+      }
+    else
+	width = smw->core.width;
+
+    if (do_layout) {
+	ForAllChildren(smw, entry)
+	    if (XtIsManaged( (Widget) *entry)) 
+		(*entry)->rectangle.width = width -
+		  2*smw->simple_menu.shadow_thickness;
+
+	if (allow_change_size)
+	    MakeSetValuesRequest((Widget) smw, width, height);
+    }
+    else {
+	*width_ret = width;
+	if (height != 0)
+	    *height_ret = height;
+    }
+}
+    
+/*	Function Name: AddPositionAction
+ *	Description: Adds the XawPositionSimpleMenu action to the global
+ *                   action list for this appcon.
+ *	Arguments: app_con - the application context for this app.
+ *                 data - NOT USED.
+ *	Returns: none.
+ */
+
+/* ARGSUSED */
+static void
+AddPositionAction(app_con, data)
+XtAppContext app_con;
+XtPointer data;
+{
+    static XtActionsRec pos_action[] = {
+        { "XawPositionSimpleMenu", PositionMenuAction },
+    };
+
+    XtAppAddActions(app_con, pos_action, XtNumber(pos_action));
+}
+
+/*	Function Name: FindMenu
+ *	Description: Find the menu give a name and reference widget.
+ *	Arguments: widget - reference widget.
+ *                 name   - the menu widget's name.
+ *	Returns: the menu widget or NULL.
+ */
+
+static Widget 
+FindMenu(widget, name)
+Widget widget;
+String name;
+{
+    register Widget w, menu;
+    
+    for ( w = widget ; w != NULL ; w = XtParent(w) )
+	if ( (menu = XtNameToWidget(w, name)) != NULL )
+	    return(menu);
+    return(NULL);
+}
+
+/*	Function Name: MoveMenu
+ *	Description: Actually moves the menu, may force it to
+ *                   to be fully visable if menu_on_screen is TRUE.
+ *	Arguments: w - the simple menu widget.
+ *                 x, y - the current location of the widget.
+ *	Returns: none 
+ */
+
+static void
+MoveMenu(w, x, y)
+Widget w;
+Position x, y;
+{
+    Arg arglist[2];
+    Cardinal num_args = 0;
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    
+    if (smw->simple_menu.menu_on_screen) {
+	int width = w->core.width + 2 * w->core.border_width;
+	int height = w->core.height + 2 * w->core.border_width;
+	
+	if (x < 0) 
+	    x = 0;
+	else {
+	    int scr_width = WidthOfScreen(XtScreen(w));
+	    if (x + width > scr_width)
+		x = scr_width - width;
+	}
+	
+	if (y < 0)
+	    y = 0;
+	else {
+	    int scr_height = HeightOfScreen(XtScreen(w));
+	    if (y + height > scr_height)
+		y = scr_height - height;
+	}
+    }
+    
+    XtSetArg(arglist[num_args], XtNx, x); num_args++;
+    XtSetArg(arglist[num_args], XtNy, y); num_args++;
+    XtSetValues(w, arglist, num_args);
+}
+
+/*	Function Name: PositionMenu
+ *	Description: Places the menu
+ *	Arguments: w - the simple menu widget.
+ *                 location - a pointer the the position or NULL.
+ *	Returns: none.
+ */
+
+static void
+PositionMenu(w, location)
+Widget w;
+XPoint * location;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject entry;
+    XPoint t_point;
+    
+    if (location == NULL) {
+	Window junk1, junk2;
+	int root_x, root_y, junkX, junkY;
+	unsigned int junkM;
+	
+	location = &t_point;
+	if (XQueryPointer(XtDisplay(w), XtWindow(w), &junk1, &junk2, 
+			  &root_x, &root_y, &junkX, &junkY, &junkM) == False) {
+	    char error_buf[BUFSIZ];
+	    sprintf(error_buf, "%s %s", "Xaw - SimpleMenuWidget:",
+		    "Could not find location of mouse pointer");
+	    XtAppWarning(XtWidgetToApplicationContext(w), error_buf);
+	    return;
+	}
+	location->x = (short) root_x;
+	location->y = (short) root_y;
+    }
+    
+    /*
+     * The width will not be correct unless it is realized.
+     */
+    
+    XtRealizeWidget(w);
+    
+    location->x -= (Position) w->core.width/2;
+    
+    if (smw->simple_menu.popup_entry == NULL)
+	entry = smw->simple_menu.label;
+    else
+	entry = smw->simple_menu.popup_entry;
+
+    if (entry != NULL)
+	location->y -= entry->rectangle.y + entry->rectangle.height/2;
+
+    MoveMenu(w, (Position) location->x, (Position) location->y);
+}
+
+/*      Function Name: MakeSetValuesRequest
+ *      Description: Makes a (possibly recursive) call to SetValues,
+ *                   I take great pains to not go into an infinite loop.
+ *      Arguments: w - the simple menu widget.
+ *                 width, height - the size of the ask for.
+ *      Returns: none
+ */
+
+static void
+MakeSetValuesRequest(w, width, height)
+Widget w;
+Dimension width, height;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    Arg arglist[2];
+    Cardinal num_args = (Cardinal) 0;
+    
+    if ( !smw->simple_menu.recursive_set_values ) {
+	if ( (smw->core.width != width) || (smw->core.height != height) ) {
+	    smw->simple_menu.recursive_set_values = TRUE;
+	    XtSetArg(arglist[num_args], XtNwidth, width);   num_args++;
+	    XtSetArg(arglist[num_args], XtNheight, height); num_args++;
+	    XtSetValues(w, arglist, num_args);
+	}
+	else if (XtIsRealized( (Widget) smw))
+	    Redisplay((Widget) smw, (XEvent *) NULL, (Region) NULL);
+    }
+    smw->simple_menu.recursive_set_values = False;
+}
+
+/*      Function Name: GetMenuWidth
+ *      Description: Sets the length of the widest entry in pixels.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: width of menu.
+ */
+
+static Dimension
+GetMenuWidth(w, w_ent)
+Widget w, w_ent;
+{
+    SmeObject cur_entry = (SmeObject) w_ent;
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    Dimension width, widest = (Dimension) 0;
+    SmeObject * entry;
+    
+    if ( smw->simple_menu.menu_width ) 
+	return(smw->core.width);
+
+    ForAllChildren(smw, entry) {
+	XtWidgetGeometry preferred;
+
+	if (!XtIsManaged( (Widget) *entry)) continue;
+	
+	if (*entry != cur_entry) {
+	    XtQueryGeometry((Widget)*entry, NULL, &preferred);
+	    
+	    if (preferred.request_mode & CWWidth)
+		width = preferred.width;
+	    else
+		width = (*entry)->rectangle.width;
+	}
+	else
+	    width = (*entry)->rectangle.width;
+	
+	if ( width > widest )
+	    widest = width;
+    }
+    
+    return(widest);
+}
+
+/*      Function Name: GetMenuHeight
+ *      Description: Sets the length of the widest entry in pixels.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: width of menu.
+ */
+
+static Dimension
+GetMenuHeight(w)
+Widget w;
+{
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject * entry;
+    Dimension height;
+    
+    if (smw->simple_menu.menu_height)
+	return(smw->core.height);
+
+    height = smw->simple_menu.top_margin + smw->simple_menu.bottom_margin;
+    
+    if (smw->simple_menu.row_height == 0) 
+	ForAllChildren(smw, entry) 
+	    if (XtIsManaged ((Widget) *entry)) 
+		height += (*entry)->rectangle.height;
+    else 
+	height += smw->simple_menu.row_height * smw->composite.num_children;
+	
+    return(height);
+}
+
+/*      Function Name: GetEventEntry
+ *      Description: Gets an entry given an event that has X and Y coords.
+ *      Arguments: w - the simple menu widget.
+ *                 event - the event.
+ *      Returns: the entry that this point is in.
+ */
+
+static SmeObject
+GetEventEntry(w, event)
+Widget w;
+XEvent * event;
+{
+    Position x_loc, y_loc;
+    SimpleMenuWidget smw = (SimpleMenuWidget) w;
+    SmeObject * entry;
+    
+    switch (event->type) {
+    case MotionNotify:
+	x_loc = event->xmotion.x;
+	y_loc = event->xmotion.y;
+	break;
+    case EnterNotify:
+    case LeaveNotify:
+	x_loc = event->xcrossing.x;
+	y_loc = event->xcrossing.y;
+	break;
+    case ButtonPress:
+    case ButtonRelease:
+	x_loc = event->xbutton.x;
+	y_loc = event->xbutton.y;
+	break;
+    default:
+	XtAppError(XtWidgetToApplicationContext(w),
+		   "Unknown event type in GetEventEntry().");
+	break;
+    }
+    
+    if ( (x_loc < 0) || (x_loc >= smw->core.width) || (y_loc < 0) ||
+	(y_loc >= smw->core.height) )
+	return(NULL);
+    
+    ForAllChildren(smw, entry) {
+	if (!XtIsManaged ((Widget) *entry)) continue;
+
+	if ( ((*entry)->rectangle.y <= y_loc) &&
+	    ((*entry)->rectangle.y + (*entry)->rectangle.height >= y_loc) )
+	    if ( *entry == smw->simple_menu.label )
+		return(NULL);	/* cannot select the label. */
+	    else
+		return(*entry);
+    }
+    
+    return(NULL);
+}
diff --git a/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.h b/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.h
new file mode 100644
index 00000000..752be892
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/SimpleMenu.h
@@ -0,0 +1,169 @@
+/*
+ * $XConsortium: SimpleMenu.h,v 1.17 89/12/11 15:01:55 kit Exp $
+ *
+ * Copyright 1989 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, 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 M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * 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.
+ *
+ * Author:  Chris D. Peterson, MIT X Consortium
+ */
+
+/*
+ * SimpleMenu.h - Public Header file for SimpleMenu widget.
+ *
+ * This is the public header file for the Athena SimpleMenu widget.
+ * It is intended to provide one pane pulldown and popup menus within
+ * the framework of the X Toolkit.  As the name implies it is a first and
+ * by no means complete implementation of menu code. It does not attempt to
+ * fill the needs of all applications, but does allow a resource oriented
+ * interface to menus.
+ *
+ * Date:    April 3, 1989
+ *
+ * By:      Chris D. Peterson
+ *          MIT X Consortium 
+ *          kit@expo.lcs.mit.edu
+ */
+
+#ifndef _SimpleMenu_h
+#define _SimpleMenu_h
+
+#include <X11/Shell.h>
+#include <X11/Xmu/Converters.h>
+
+/****************************************************************
+ *
+ * SimpleMenu widget
+ *
+ ****************************************************************/
+
+/* SimpleMenu Resources:
+
+ Name		     Class		RepType		Default Value
+ ----		     -----		-------		-------------
+ background	     Background		Pixel		XtDefaultBackground
+ backgroundPixmap    BackgroundPixmap	Pixmap          None
+ borderColor	     BorderColor	Pixel		XtDefaultForeground
+ borderPixmap	     BorderPixmap	Pixmap		None
+ borderWidth	     BorderWidth	Dimension	1
+ bottomMargin        VerticalMargins    Dimension       VerticalSpace
+ columnWidth         ColumnWidth        Dimension       Width of widest text
+ cursor              Cursor             Cursor          None
+ destroyCallback     Callback		Pointer		NULL
+ height		     Height		Dimension	0
+ label               Label              String          NULL (No label)
+ labelClass          LabelClass         Pointer         smeBSBObjectClass
+ mappedWhenManaged   MappedWhenManaged	Boolean		True
+ rowHeight           RowHeight          Dimension       Height of Font
+ sensitive	     Sensitive		Boolean		True
+ topMargin           VerticalMargins    Dimension       VerticalSpace
+ width		     Width		Dimension	0
+ x		     Position		Position	0
+ y		     Position		Position	0
+
+*/
+
+typedef struct _SimpleMenuClassRec*	SimpleMenuWidgetClass;
+typedef struct _SimpleMenuRec*		SimpleMenuWidget;
+
+extern WidgetClass simpleMenuWidgetClass;
+
+#define XtNcursor "cursor"
+#define XtNbottomMargin "bottomMargin"
+#define XtNcolumnWidth "columnWidth"
+#define XtNlabelClass "labelClass"
+#define XtNmenuOnScreen "menuOnScreen"
+#define XtNpopupOnEntry "popupOnEntry"
+#define XtNrowHeight "rowHeight"
+#define XtNtopMargin "topMargin"
+
+#define XtCColumnWidth "ColumnWidth"
+#define XtCLabelClass "LabelClass"
+#define XtCMenuOnScreen "MenuOnScreen"
+#define XtCPopupOnEntry "PopupOnEntry"
+#define XtCRowHeight "RowHeight"
+#define XtCVerticalMargins "VerticalMargins"
+
+/* New fields */
+#define XtNshadowWidth "shadowWidth"
+#define XtCShadowWidth "ShadowWidth"
+#define XtNbsbShadowWidth "bsbShadowWidth"
+#define XtCBsbShadowWidth "BsbShadowWidth"
+#define XtNtopShadowPixel "topShadowPixel"
+#define XtCTopShadowPixel "TopShadowPixel"
+#define XtNbottomShadowPixel "bottomShadowPixel"
+#define XtCBottomShadowPixel "BottomShadowPixel"
+#define XtNtopShadowContrast "topShadowContrast"
+#define XtCTopShadowContrast "TopShadowContrast"
+#define XtNbottomShadowContrast "bottomShadowContrast"
+#define XtCBottomShadowContrast "BottomShadowContrast"
+#define XtNbeNiceToColormap "beNiceToColormap"
+#define XtCBeNiceToColormap "BeNiceToColormap"
+#define XtNtopShadowPixmap "topShadowPixmap"
+#define XtCTopShadowPixmap "TopShadowPixmap"
+#define XtNbottomShadowPixmap "bottomShadowPixmap"
+#define XtCBottomShadowPixmap "BottomShadowPixmap"
+#define XtNuserData "userData"
+#define XtCUserData "UserData"
+#define XtNframeType "frameType"
+#define XtCFrameType "FrameType"
+#define XtRFrameType "FrameType"
+
+/************************************************************
+ *
+ * Public Functions.
+ *
+ ************************************************************/
+
+/*	Function Name: XawSimpleMenuAddGlobalActions
+ *	Description: adds the global actions to the simple menu widget.
+ *	Arguments: app_con - the appcontext.
+ *	Returns: none.
+ */
+
+void 
+XawSimpleMenuAddGlobalActions(/* app_con */);
+/*
+XtAppContext app_con;
+*/
+ 
+/*	Function Name: XawSimpleMenuGetActiveEntry
+ *	Description: Gets the currently active (set) entry.
+ *	Arguments: w - the smw widget.
+ *	Returns: the currently set entry or NULL if none is set.
+ */
+
+Widget
+XawSimpleMenuGetActiveEntry( /* w */);
+/*
+Widget w;
+*/
+
+/*	Function Name: XawSimpleMenuClearActiveEntry
+ *	Description: Unsets the currently active (set) entry.
+ *	Arguments: w - the smw widget.
+ *	Returns: none.
+ */
+
+void
+XawSimpleMenuClearActiveEntry(/* w */);
+/*
+Widget w;
+*/
+
+#endif /* _SimpleMenu_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/SimpleP.h b/vendor/x11iraf/obm/ObmW/zz/SimpleP.h
new file mode 100644
index 00000000..f4044709
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/SimpleP.h
@@ -0,0 +1,62 @@
+#ifndef _SimpleP_h
+#define _SimpleP_h
+
+#include <X11/IntrinsicP.h>
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/Simple.h>
+
+#define SIMPLE(w) ((SimpleWidget) w)->simple
+
+typedef Boolean (*XawDisplayRectProc) Xraw_PROTO((Widget, XRectangle * ));
+typedef Boolean (*XawChangeSensitive) Xraw_PROTO((Widget));
+
+typedef struct {
+  XawChangeSensitive  change_sensitive;
+  XawDisplayRectProc  display_rect;
+  caddr_t 	      extension;
+} SimpleClassPart;
+
+typedef struct _SimpleClassRec {
+    CoreClassPart	core_class;
+    SimpleClassPart	simple_class;
+} SimpleClassRec;
+
+extern SimpleClassRec simpleClassRec;
+
+typedef struct {
+    /* resources */
+  Cursor        cursor;
+  Pixmap        insensitive_border;
+  Pixel   	foreground;
+  
+  Dimension   	shadow_thickness;
+  Pixel   	top_shadow_color;
+  Pixmap  	top_shadow_pixmap;
+  Pixel   	bottom_shadow_color;
+  Pixmap  	bottom_shadow_pixmap;
+  Pixel   	highlight_color;
+  Pixmap  	highlight_pixmap;
+  Dimension	highlight_thickness;
+  
+  caddr_t	user_data;
+  
+    /* private state */
+  GC		top_shadow_GC;
+  GC		bottom_shadow_GC;
+  GC            highlight_GC;
+} SimplePart;
+
+typedef struct _SimpleRec {
+    CorePart	core;
+    SimplePart	simple;
+} SimpleRec;
+
+#define SIMPLE_MARGIN(w) (((SimpleWidget)w)->simple.highlight_thickness + \
+			  ((SimpleWidget)w)->simple.shadow_thickness)
+
+#define XtSimpleClass(w) ((SimpleWidgetClass)XtClass(w))
+#define XtInheritDisplayRectProc ((Boolean (*)())_XtInherit)
+#define XtInheritChangeSensitive ((Boolean (*)())_XtInherit)
+
+#endif /* _SimpleP_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/Table.c b/vendor/x11iraf/obm/ObmW/zz/Table.c
new file mode 100644
index 00000000..a5387810
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Table.c
@@ -0,0 +1,4529 @@
+/***********************************************************************
+  
+                             Table widget
+		   Copyright by Vladimir T. Romanovski
+			 All rights reserved.
+
+This library is designed  for  free,  non-commercial  software  creation.
+It is changeable and can be improved. The author would greatly appreciate
+any  advice, new  components  and  patches  of  the  existing  programs.
+Commercial  usage is  also  possible  with  participation of the author.
+
+			romsky@hp1.oea.ihep.su (Russia)
+                        romsky@munin.ucsf.edu  (USA)
+
+*************************************************************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <ctype.h>
+
+#include <X11/Xatom.h>
+#include <X11/IntrinsicP.h>
+#include <X11/RectObjP.h>
+#include <X11/StringDefs.h>
+#include <X11/keysym.h>
+#include <X11/Xos.h>
+
+#include <X11/Xmu/Atoms.h>
+#include <X11/Xmu/Converters.h>
+#include <X11/Xmu/Drawing.h>
+
+#include <X11/Xraw/XawInit.h>
+#include <X11/Xraw/3d.h>
+#include <X11/Xraw/TableP.h>
+#include <X11/Xraw/Frame.h>
+#include <X11/Xraw/AsciiText.h>
+#include <X11/Xraw/Viewport.h>
+#include <X11/Xraw/Scrollbar.h>
+#include <X11/Xraw/ScrolledTable.h>
+
+#ifdef EBUG_XRAW_MALLOC
+#include <dbmalloc/malloc.h>
+#endif
+
+#define MULTI_LINE_TABLE 32767
+
+
+#undef CELL_IN /* */
+
+#ifdef MIN
+#undef MIN
+#endif
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+
+#ifdef MAX
+#undef MAX
+#endif
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+#define CALLOC(num,type) (num * sizeof(type) <= 0 ? (type*)NULL : \
+  (type*)XtMalloc((Cardinal)(num) * (Cardinal)sizeof(type)))
+
+#define NOT_A_CUT_BUFFER (-1)
+
+#define MAXCUT         30000
+#define EDIT(w)        (((XawTableWidget) w)->table.edit)
+#define InRange(n,a,b)  MAX(a,MIN(n,b))
+
+#define LEFT_EDGE(tw)  (((XawTableWidget)tw)->table.internal_width + \
+		       ((XawTableWidget)tw)->table.label_shadow_thickness)
+
+#define TOP_EDGE(tw)   (((XawTableWidget)tw)->table.internal_height + \
+		       ((XawTableWidget)tw)->table.label_shadow_thickness)
+
+#define CELL(field)    cell->field
+#define STUFF(w)       ((XawTableWidget)w)->table.table_stuff
+#define COLUMNS(w)     ((XawTableWidget)w)->table.columns
+#define ROWS(w)        ((XawTableWidget)w)->table.rows
+#define GET_CELL_LABEL ((CELL(label) == NULL ? Dummy : CELL(label)))
+
+#define COLUMN_DATA(tw) ((XawTableColumnRec*)tw->table.column_data)
+#define COLUMN_WIDTH(tw,column) \
+(tw->table.literal ?                                               \
+	             (                                             \
+                       (COLUMN_DATA(tw)[column].flag & _CL_width) ?\
+                          COLUMN_DATA(tw)[column].width :          \
+                          tw->table.column_default_width           \
+                     )                                             \
+                     * tw->table.literal_width +                   \
+		     2 * tw->table.internal_width                  \
+		   :                                               \
+                    (                                              \
+                       (COLUMN_DATA(tw)[column].flag & _CL_width) ?\
+                          COLUMN_DATA(tw)[column].width :          \
+                          tw->table.column_default_width           \
+                     )                                             \
+/* _COLUMN_WIDTH_ */)
+
+
+#define MANAGE_EDIT(tw)                                            \
+  if ( ! XtIsManaged(EDIT(tw)))                                    \
+  {                                                                \
+    XtManageChild (EDIT(tw));                                      \
+    XtSetKeyboardFocus ((Widget)tw, EDIT(tw));                     \
+  }
+
+
+#define UNMANAGE_EDIT(tw)                                          \
+  if ( XtIsManaged(EDIT(tw)))                                      \
+  {                                                                \
+    XtUnmanageChild (tw->table.edit);                              \
+    XtSetKeyboardFocus((Widget)tw, (Widget)None);                  \
+  }
+
+
+#define DO_CALLBACK(w,callback,data)                               \
+  if (XtCallbackHasSome == XtHasCallbacks(w, callback))            \
+    XtCallCallbacks (w, callback, (XtPointer)&data)
+  
+
+#define IsEditInRowColumn(tw, row, column)                         \
+  (XtIsManaged(EDIT(tw)) && (row == tw->table.edit_row)            \
+   && (column == tw->table.edit_column))
+
+
+
+#define REJECT (-1)
+#define ACCEPT (0)
+
+#define CHECK_TABLE(tw)                                            \
+  _check_table ((XtPointer)STUFF(tw), ROWS(tw), COLUMNS(tw));      \
+  CheckAllLabels(tw)
+
+
+
+typedef struct _XawTableCellRec {
+                               /* Node communication entity */
+  XawTableNodeRec node;
+                               /* Cell label entity */
+  char        *label;
+  Position     label_x;
+  Dimension    label_width;
+  Dimension    label_len;
+                               /* Cell colour entity */
+  Boolean      highlight;
+  Boolean      special_colour;
+  Pixel        fore;
+  Pixel        back;
+  GC           normal;
+  GC           reverse;
+  GC           top;
+  GC           bottom;
+
+}XawTableCellRec;
+
+#define _CL_width      (1L<<0)
+#define _CL_font       (1L<<1)
+#define _CL_label      (1L<<2)
+#define _CL_justify    (1L<<3)
+#define _CL_background (1L<<4)
+#define _CL_foreground (1L<<5)
+
+typedef struct _XawTableColumnRec {
+  int           flag;
+  int           width;
+  XFontStruct  *font;
+  char         *label;
+  XtJustify     justify;
+  Pixel         background;
+  Pixel         foreground;
+  GC            normal;
+  GC            reverse;
+  GC            top;
+  GC            bottom;
+}XawTableColumnRec;
+
+
+#ifdef CRAY
+#define WORD64
+#endif
+
+/****************************************************************
+ *
+ * Full class record constant
+ *
+ ****************************************************************/
+
+/* Private Data */
+
+static void Def_pixel();
+static void Def_scroll();
+static void Def_column_default_width();
+static void Def_literal_width();
+static void Def_shadow_thickness();
+
+#define Offset(field) XtOffsetOf(TableRec, field)
+
+static XtResource resources[] = {
+    {
+      XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
+      Offset(table.foreground), XtRString, XtDefaultForeground
+    },
+    {
+      XtNeditForeground, XtCForeground, XtRPixel, sizeof(Pixel),
+      Offset(table.edit_fore), XtRCallProc, (XtPointer)Def_pixel
+    },
+    {
+      XtNeditBackground, XtCBackground, XtRPixel, sizeof(Pixel),
+      Offset(table.edit_back), XtRCallProc, (XtPointer)Def_pixel
+    },
+    {
+      XtNrowForeground, XtCForeground, XtRPixel, sizeof(Pixel),
+      Offset(table.row_fore), XtRCallProc, (XtPointer)Def_pixel
+    },
+    {
+      XtNcolumnForeground, XtCForeground, XtRPixel, sizeof(Pixel),
+      Offset(table.column_fore), XtRCallProc, (XtPointer)Def_pixel
+    },
+    {
+      XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
+      Offset(table.font), XtRString, XtDefaultFont
+    },
+    {
+      XtNliteral,  XtCLiteral, XtRBoolean, sizeof(Boolean),
+      Offset(table.literal), XtRImmediate, (XtPointer)False
+    },
+    {
+      XtNrowOriented,  XtCRowOriented, XtRBoolean, sizeof(Boolean),
+      Offset(table.row_oriented), XtRImmediate, (XtPointer)True
+    },
+    {
+      XtNmaskNumber,  XtCMaskNumber, XtRInt, sizeof(int),
+      Offset(table.mask_number), XtRImmediate, (XtPointer)7
+    },
+    {
+      XtNcolumns,  XtCColumns, XtRInt, sizeof(int),
+      Offset(table.columns), XtRImmediate, (XtPointer)0
+    },
+    {
+      XtNrows,  XtCRows, XtRInt, sizeof(int),
+      Offset(table.rows), XtRImmediate, (XtPointer)0
+    },
+    {
+      XtNtableMargin,  XtCTableMargin, XtRDimension, sizeof(Dimension),
+      Offset(table.tab_margin), XtRImmediate, (XtPointer)2
+    },
+    {
+      XtNrowMargin,  XtCRowMargin, XtRDimension, sizeof(Dimension),
+      Offset(table.row_margin), XtRImmediate, (XtPointer)2
+    },
+    {
+      XtNcolumnMargin,  XtCColumnMargin, XtRDimension, sizeof(Dimension),
+      Offset(table.col_margin), XtRImmediate, (XtPointer)2
+    },
+    {
+      XtNlabelShadowWidth,  XtCLabelShadowWidth, XtRDimension,
+      sizeof(Dimension), Offset(table.label_shadow_thickness), XtRImmediate,
+      (XtPointer)1
+    },
+    {
+      XtNjustify, XtCJustify, XtRJustify, sizeof(XtJustify),
+      Offset(table.justify), XtRImmediate, (XtPointer)XtJustifyCenter
+    },
+    {
+      XtNinternalWidth, XtCWidth, XtRDimension,  sizeof(Dimension),
+      Offset(table.internal_width), XtRImmediate, (XtPointer)4
+    },
+    {
+      XtNinternalHeight, XtCHeight, XtRDimension, sizeof(Dimension),
+      Offset(table.internal_height), XtRImmediate, (XtPointer)2
+    },
+    {
+      XtNencoding, XtCEncoding, XtRUnsignedChar, sizeof(unsigned char),
+      Offset(table.encoding), XtRImmediate, (XtPointer)XawTextEncoding8bit
+    },
+    {
+      XtNshadowWidth, XtCShadowWidth, XtRDimension, sizeof(Dimension),
+      Offset(container.shadow_thickness), XtRCallProc,
+      (XtPointer) Def_shadow_thickness
+    },
+    {
+      XtNvetricalScroll, XtCScroll, XtRWidget, sizeof(Widget),
+      Offset(table.v_scroll), XtRCallProc, (XtPointer)Def_scroll
+    },
+    {
+      XtNhorizontalScroll, XtCScroll, XtRWidget, sizeof(Widget),
+      Offset(table.h_scroll), XtRCallProc, (XtPointer)Def_scroll
+    },
+    {
+      XtNrowHeight, XtCRowHeight, XtRInt, sizeof(int),
+      Offset(table.row_height), XtRImmediate, (XtPointer)0
+    },
+    {
+      XtNdefaultWidth, XtCDefaultWidth, XtRInt, sizeof(int),
+      Offset(table.column_default_width), XtRCallProc,
+      (XtPointer) Def_column_default_width
+    },
+    {
+      XtNeditable, XtCEditable, XtRBoolean, sizeof(Boolean),
+      Offset(table.editable), XtRImmediate, (XtPointer) TRUE
+    },
+    {
+      XtNliteralWidth, XtCLiteralWidth, XtRInt, sizeof(int),
+      Offset(table.literal_width), XtRCallProc, (XtPointer) Def_literal_width
+    },
+
+                      /* ALLOWANCE CALLBACKS */
+    {
+      XtNallowAddColumn, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.allow_add_column), XtRCallback, NULL
+    },
+    {
+      XtNallowAddRow, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.allow_add_row), XtRCallback, NULL
+    },
+    {
+      XtNallowDeleteColumn, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.allow_delete_column), XtRCallback, NULL
+    },
+    {
+      XtNallowDeleteRow, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.allow_delete_row), XtRCallback, NULL
+    },
+    {
+      XtNallowDeleteTable, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.allow_delete_table), XtRCallback, NULL
+    },
+                      /* INFORMATION CALLBACKS */
+
+    {
+      XtNaddColumn, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.add_column), XtRCallback, NULL
+    },
+    {
+      XtNaddRow, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.add_row), XtRCallback, NULL
+    },
+    {
+      XtNcreateTable, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.create_table), XtRCallback, NULL
+    },
+    {
+      XtNchangedCell, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.changed_cell), XtRCallback, NULL
+    },
+    {
+      XtNchangedColumnWidth, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.changed_column_width), XtRCallback, NULL
+    },
+    {
+      XtNchangedRowHeight, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.changed_row_height), XtRCallback, NULL
+    },
+    {
+      XtNdeleteColumn, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.delete_column), XtRCallback, NULL
+    },
+    {
+      XtNdeleteRow, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.delete_row), XtRCallback, NULL
+    },
+    {
+      XtNdeleteTable, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.delete_table), XtRCallback, NULL
+    },
+    {
+      XtNwhatCell, XtCCallback, XtRCallback, sizeof(XtPointer),
+      Offset(table.what_cell), XtRCallback, NULL
+    },
+};
+
+#define PRINTF_BOOL(a) ((a) ? "TRUE":"FALSE")
+#define PRINTF_NULL(a) ((a)==NULL ? "NULL":"not NULL")
+
+static void Def_pixel(w, offset, value)
+     Widget    w;
+     int       offset;
+     XrmValue *value;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  static Pixel pix = 0;
+  
+  
+  if (      offset == (int)Offset(table.edit_fore))
+    pix = tw->table.foreground;
+  else if ( offset == (int)Offset(table.edit_back))
+  {
+    if (!FetchPixel(w, "#d0d000", &pix))
+      pix = WhitePixelOfScreen(XtScreen(w));
+  }
+  else 
+    pix = tw->core.background_pixel;
+
+  value->addr = (XtPointer)& pix;
+}
+
+/* ARGSUSED */
+static void Def_scroll(w, offset, value)
+     Widget    w;
+     int       offset;
+     XrmValue *value;
+{
+  static Widget view;
+
+  for (view = XtParent(w);
+       (view != (Widget)NULL) && (!XtIsSubclass(view, viewportWidgetClass));
+       view = XtParent(view))
+    /* EMPTY */;
+
+  if (view) 
+  {
+    if (offset == Offset(table.v_scroll))
+    {
+      if (((view = XtNameToWidget(view, "vertical")) == (Widget)NULL)
+	  || !XtIsSubclass(view, scrollbarWidgetClass))
+	view = (Widget)NULL;
+    }
+    else
+    if (offset == Offset(table.h_scroll))
+    {
+      if (((view = XtNameToWidget(view, "horizontal")) == (Widget)NULL)
+	  || !XtIsSubclass(view, scrollbarWidgetClass))
+	view = (Widget)NULL;
+    }
+  }
+  
+  value->addr = (XtPointer)&view;
+}
+
+/* ARGSUSED */
+static void Def_column_default_width(w, offset, value)
+     Widget    w;
+     int       offset;
+     XrmValue *value;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  static int column_default_width;
+
+  if (tw->table.literal)
+    column_default_width = 10;
+  else
+    column_default_width = 60;
+
+  value->addr = (XtPointer)&column_default_width;
+}
+
+#ifndef WORD64
+#define TXT_16 XChar2b
+#else
+#define TXT_16 char
+#endif
+
+/* ARGSUSED */
+static void Def_literal_width(w, offset, value)
+     Widget    w;
+     int       offset;
+     XrmValue *value;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  static int literal_width;
+
+  if (tw->table.encoding)
+    tw->table.literal_width = XTextWidth16(tw->table.font, (TXT_16*)"mmm", 3);
+  else
+    tw->table.literal_width = XTextWidth(tw->table.font, "mmm", 3);
+
+  tw->table.literal_width /= 3;
+  
+  value->addr = (XtPointer)& literal_width;
+}
+
+/* ARGSUSED */
+static void Def_shadow_thickness(w, offset, value)
+     Widget    w;
+     int       offset;
+     XrmValue *value;
+{
+  Widget parent = XtParent (w);
+  static Dimension shadow_thickness;
+  
+  if (XtIsSubclass (parent, scrolledTableWidgetClass)
+      ||
+      XtIsSubclass (parent, viewportWidgetClass))
+    shadow_thickness = 0;
+  else
+    shadow_thickness = 2;
+
+  value->addr = (XtPointer)& shadow_thickness;
+}
+
+
+#undef offset
+
+static void MultipleChangeGC();
+static void Initialize();
+static void Realize();
+static void Resize();
+static void Redisplay();
+static void Destroy();
+
+static Boolean SetValues();
+
+static void WalkForCells();
+static void LoseSelection();
+
+static void CallEdit();
+static void InsertSelection();
+static void StoreBuffer();
+static void WhatCell();
+static void KeyReturn();
+static void HighlightCell();
+static void UnhighlightCell();
+static void DoingNothing();
+
+static char* DummyString();
+
+static Boolean InitCell();
+
+static XtGeometryResult QueryGeometry();
+static XtGeometryResult GeometryManager();
+
+static XtActionsRec actions[] = {
+  {"call-edit",        (XtActionProc)CallEdit       },
+  {"insert-selection", (XtActionProc)InsertSelection},
+  {"store-in-buffer",  (XtActionProc)StoreBuffer    },
+  {"what_cell",        (XtActionProc)WhatCell       },
+  {"key_return",       (XtActionProc)KeyReturn      },
+  {"highlight",        (XtActionProc)HighlightCell  },
+  {"unhighlight",      (XtActionProc)UnhighlightCell},
+  {"no-op",            (XtActionProc)DoingNothing   }
+};
+
+static char translations[] =
+  "Ctrl<Btn1Up>:     what_cell()                                    \n\
+   <Btn1Up>:         call-edit()                                    \n\
+   <Btn2Up>:         insert-selection(PRIMARY, CUT_BUFFER0)         \n\
+   <Btn3Up>:         highlight() store-in-buffer(PRIMARY,CUT_BUFFER0) ";
+
+static char edit_translations[] =
+  " <Key>Return:     key_return()  \n\
+    <Key>Linefeed:   key_return()  \n\
+    <Key>Down:       no-op(r)      \n\
+    <Key>Up:         no-op(r)      ";
+
+static char* Dummy = "";
+
+
+#define SuperClass ((ContainerWidgetClass)&containerClassRec)
+
+TableClassRec tableClassRec = {
+  { /* core_class fields */	
+    /* superclass	  	*/	(WidgetClass) SuperClass,
+    /* class_name	  	*/	"Table",
+    /* widget_size	  	*/	sizeof(TableRec),
+    /* classInitialize   	*/	NULL,
+    /* class_partInitialize	*/	NULL,
+    /* class_inited       	*/	FALSE,
+    /* initialize	  	*/	Initialize,
+    /* initialize_hook		*/	NULL,
+    /* realize		  	*/	Realize,
+    /* actions		  	*/	actions,
+    /* num_actions	  	*/	XtNumber(actions),
+    /* resources	  	*/	resources,
+    /* num_resources	  	*/	XtNumber(resources),
+    /* xrm_class	  	*/	NULLQUARK,
+    /* compress_motion	  	*/	TRUE,
+    /* compress_exposure  	*/	FALSE,
+    /* compress_enterleave	*/	TRUE,
+    /* visible_interest	  	*/	TRUE,
+    /* destroy		  	*/	Destroy,
+    /* resize		  	*/	Resize,
+    /* expose		  	*/	Redisplay,
+    /* set_values	  	*/	SetValues,
+    /* set_values_hook		*/	NULL,
+    /* set_values_almost	*/	XtInheritSetValuesAlmost,
+    /* get_values_hook		*/	NULL,
+    /* accept_focus	 	*/	NULL,
+    /* version			*/	XtVersion,
+    /* callback_private   	*/	NULL,
+    /* tm_table		   	*/	translations,
+    /* query_geometry		*/	QueryGeometry,
+    /* display_accelerator	*/	XtInheritDisplayAccelerator,
+    /* extension		*/	NULL
+  },
+    /* Composite class part */
+  {
+    /* geometry manager         */      GeometryManager,
+    /* change_managed           */      XtInheritChangeManaged,
+    /* insert_child             */      XtInheritInsertChild,
+    /* delete_child             */      XtInheritDeleteChild,
+    /* extension                */      NULL,
+  },
+    /* Constraint class part */
+  {
+    /* subresources             */      NULL,
+    /* subresource_count        */      0,   
+    /* constraint_size          */      0,   
+    /* initialize               */      NULL,
+    /* destroy                  */      NULL,
+    /* set_values               */      NULL,
+    /* extension                */      NULL,
+  },
+    /* Container class part */
+  {
+    /* ignore                   */      0,
+  },
+  { /* Table class fields initialization */
+    /* ignore 			*/	0
+  }
+};
+
+WidgetClass tableWidgetClass = (WidgetClass)&tableClassRec;
+
+
+/****************************************************************
+ *
+ *                   Private procedures
+ *
+ ****************************************************************/
+#define NORMAL_INDEX(fore, back) \
+  (int)(((int)fore * (int)back) & tw->table.mask_hash_table)
+
+#define SHADOW_INDEX(back) (int)(((int)back) & tw->table.mask_hash_table)
+
+#define GET_NORMAL(tw,i) (tw->table.normal_hash_table+(i))
+#define GET_SHADOW(tw,i) (tw->table.shadow_hash_table+(i))
+
+#define NEXT(i) (int)((i+1) & tw->table.mask_hash_table)
+
+static int MaskStaticArray[] = {
+                             0x1,   0x3,   0x7,   0xF,
+			     0x1F,  0x3F,  0x7F,  0xFF,
+			     0x1FF, 0x3FF, 0x7FF, 0xFFF
+			  };
+
+static NormalReverseGC*  GetNormalGC(w, fore, back, font)
+     Widget w;
+     Pixel fore;
+     Pixel back;
+     Font font;
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  int i = NORMAL_INDEX(fore, back);
+
+  while (GET_NORMAL(tw,i)->used > 0)
+  {
+
+    if (GET_NORMAL(tw,i)->fore == fore && GET_NORMAL(tw,i)->back == back)
+    {
+      GET_NORMAL(tw,i)->used++;
+      return GET_NORMAL(tw,i);
+    }
+    i = NEXT(i);
+  }
+  
+  if (GET_NORMAL(tw,i)->used == 0)
+  {
+    XtGCMask mask;
+    XGCValues values;
+    Display *dpy = XtDisplay(w);
+    Window   win = XtIsRealized(w) ? XtWindow(w) : XDefaultRootWindow(dpy);
+    
+
+    mask = GCForeground | GCBackground | GCFont;
+    values.foreground = fore;
+    values.background = back;
+    values.font       = font;
+
+    GET_NORMAL(tw,i)->normal = XCreateGC(dpy, win, mask, &values);
+    values.foreground = back;
+    values.background = fore;
+    GET_NORMAL(tw,i)->reverse = XCreateGC(dpy, win, mask, &values);
+
+    GET_NORMAL(tw,i)->used = 1;
+    GET_NORMAL(tw,i)->fore = fore;
+    GET_NORMAL(tw,i)->back = back;
+
+    return GET_NORMAL(tw,i);
+  } 
+
+  return (NormalReverseGC*)NULL;
+}
+
+static void GetGCByForeground(w, gc, fore)
+     Widget  w;
+     GC     *gc;
+     Pixel   fore;
+{
+  XGCValues values;
+  
+  values.foreground = fore;
+  (*gc) = XtGetGC(w, GCForeground, &values);
+}
+
+
+static ShadowGC* GetShadowGC(w, back)
+     Widget w;
+     Pixel back;
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  int i = SHADOW_INDEX(back);
+  
+  while (GET_SHADOW(tw,i)->used > 0)
+  {
+    if (GET_SHADOW(tw,i)->back == back)
+    {
+      GET_SHADOW(tw,i)->used++;
+      return GET_SHADOW(tw,i);
+    }
+    i = NEXT(i);
+  }
+  
+  if (GET_SHADOW(tw,i)->used == 0)
+  {
+    Pixel top;
+    Pixel bottom;
+    
+    GET_SHADOW(tw,i)->used   = 1;
+    GET_SHADOW(tw,i)->back   = back;
+
+    (void)TopShadowColor(w, back, &top);
+    (void)BottomShadowColor(w, back, &bottom);
+#ifdef CELL_IN
+    GetGCByForeground(w, (GC*)&GET_SHADOW(tw,i)->bottom, top);
+    GetGCByForeground(w, (GC*)&GET_SHADOW(tw,i)->top, bottom);
+#else
+    GetGCByForeground(w, (GC*)&GET_SHADOW(tw,i)->bottom, bottom);
+    GetGCByForeground(w, (GC*)&GET_SHADOW(tw,i)->top, top);
+#endif
+    return GET_SHADOW(tw,i);
+  } 
+
+  return (ShadowGC*)NULL;
+}
+
+static void ReleaseNormalGC(w, fore, back)
+     Widget w;
+     Pixel fore;
+     Pixel back;
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  int i = NORMAL_INDEX(fore, back);
+  
+  while (GET_NORMAL(tw,i)->used > 0)
+  {
+    if ( GET_NORMAL(tw,i)->fore == fore &&  GET_NORMAL(tw,i)->back == back)
+    {
+      if (--GET_NORMAL(tw,i)->used == 0) {
+	XFreeGC(XtDisplay(w), GET_NORMAL(tw,i)->normal);
+	XFreeGC(XtDisplay(w), GET_NORMAL(tw,i)->reverse);
+      }
+      break;
+    }
+
+    i = NEXT(i);
+  }
+}
+
+static void ReleaseShadowGC(w, back)
+     Widget w;
+     Pixel back;
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  int i = SHADOW_INDEX(back);
+  
+  while (GET_SHADOW(tw,i)->used > 0)
+  {
+    if ( GET_SHADOW(tw,i)->back == back)
+    {
+      if (--GET_SHADOW(tw,i)->used == 0)
+      {
+	XtReleaseGC(w, GET_SHADOW(tw,i)->top);
+	XtReleaseGC(w, GET_SHADOW(tw,i)->bottom);
+      }
+      break;
+    }
+    i = NEXT(i);
+  }
+}
+
+static void MultipleChangeGC(w, fore, back, font, normal, reverse)
+     Widget w;
+     Pixel *fore;
+     Pixel *back;
+     Font  *font;
+     GC    *normal;
+     GC    *reverse;
+{
+  XtGCMask mask;
+  XGCValues values;
+
+  if (normal != (GC*)NULL){
+    mask = (XtGCMask)0;
+    if (fore != (Pixel*)NULL) {
+      mask |= GCForeground;
+      values.foreground = *fore;
+    }
+    if (back != (Pixel*)NULL) {
+      mask |= GCBackground;
+      values.background = *back;
+    }
+    if (font != (Font*)NULL) {
+      mask |= GCFont;
+      values.font = *font;
+    }
+    XChangeGC(XtDisplay(w), *normal, mask, &values);
+  }
+
+  if (reverse != (GC*)NULL){
+    mask = (XtGCMask)0;
+    if (fore != (Pixel*)NULL) {
+      mask |= GCForeground;
+      values.foreground = *back;        /* reverse */
+    }
+    if (back != (Pixel*)NULL) {
+      mask |= GCBackground;
+      values.background = *fore;        /* reverse */
+    }
+    if (font != (Font*)NULL) {
+      mask |= GCFont;
+      values.font = *font;
+    }
+    XChangeGC(XtDisplay(w), *reverse, mask, &values);
+  }
+}
+
+#ifndef WORD64
+
+#define TXT16 XChar2b
+
+#else
+
+#define TXT16 char
+
+static XChar2b *buf2b;
+static int buf2blen = 0;
+
+#define XTextWidth16 _XawTableWidth16
+#define XDrawString16 _XawTableDraw16
+
+#endif /* WORD64 */
+
+
+static void CalculatePreferredSize(w, width, height)
+     Widget w;
+     Dimension *width;
+     Dimension *height;
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  register int wid;
+  register int hei;
+  int i;
+  
+  /*
+   * Calculate preferred width
+   */
+
+  wid  = 2 * (tw->table.tab_margin + tw->container.shadow_thickness);
+  wid += COLUMNS(tw) ? (COLUMNS(tw) - 1) * tw->table.col_margin : 0;
+  wid += 2 * COLUMNS(tw) * tw->table.label_shadow_thickness;
+  
+  for(i = 0 ; i < COLUMNS(tw); i++)
+    wid += (Dimension)COLUMN_WIDTH(tw,i);
+
+  /*
+   * Calculate preferred height
+   */
+
+  hei  = 2 * (tw->table.tab_margin + tw->container.shadow_thickness);
+  hei += ROWS(tw) ? (ROWS(tw) - 1) * tw->table.row_margin : 0;
+  hei += ROWS(tw) * tw->table.row_height;
+  hei += 2 * ROWS(tw) * tw->table.label_shadow_thickness;
+
+  tw->table.prefer_width  = wid;
+  tw->table.prefer_height = hei;
+
+  if (width)  *width  = wid;
+  if (height) *height = hei;
+
+}
+
+static Position GetX(tw,j)
+     register XawTableWidget tw;
+     int j;
+{
+  register TablePart* table = (TablePart*)&tw->table;
+  register Position x;
+
+  x = j * (table->col_margin + 2 * table->label_shadow_thickness) +
+          (table->tab_margin + tw->container.shadow_thickness);
+
+  for(; j > 0 ; j--)
+  {
+    register int tmp = j - 1;
+    x += (Position)COLUMN_WIDTH(tw, tmp);
+  }
+  return x;
+}
+
+static Position GetY(tw,i)
+     XawTableWidget tw;
+     int i;
+{
+  return(i * (tw->table.row_margin + tw->table.row_height +
+	       2 * tw->table.label_shadow_thickness) +
+	      (tw->table.tab_margin + tw->container.shadow_thickness));
+}
+
+
+/*
+ * Calculate width and height of displayed text in pixels
+ */
+
+static void SetLabelHeight(tw)
+     XawTableWidget tw;
+{
+  register XFontStruct *fs = tw->table.font;
+  int row_height = tw->table.row_height;
+
+  if (tw->table.row_height < 1)
+    tw->table.row_height = (fs->max_bounds.ascent  +
+			    fs->max_bounds.descent +
+			    2 * tw->table.internal_height);
+  if (row_height != tw->table.row_height)
+  {
+    XawTableCallbackStruct callback_str;
+    callback_str.reason   = XawTABLE_CHANGED_ROW_HEIGHT;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = (XawTableCell)NULL;
+    callback_str.new_cell = (XawTableCell)NULL;
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+    
+    DO_CALLBACK((Widget)tw, XtNchangedRowHeight, callback_str);
+  }
+}
+
+static void SetLiteralWidth(tw)
+     XawTableWidget tw;
+{
+  if (tw->table.encoding)
+    tw->table.literal_width = XTextWidth16(tw->table.font, (TXT16*)"mmm", 3);
+  else
+    tw->table.literal_width = XTextWidth(tw->table.font, "mmm", 3);
+
+  tw->table.literal_width /= 3;
+}
+
+
+static void SetLabelWidth(tw,i,j)
+     XawTableWidget tw;
+     int i,j;
+{
+  register XFontStruct *fs = tw->table.font;
+  XawTableCell cell;
+
+  cell = (XawTableCell)get_cell(STUFF(tw),i,j);
+
+  if (CELL(label) == NULL) {
+    CELL(label_len) = 0;
+    CELL(label_width) = 0;
+  } else {
+    CELL(label_len) = strlen(CELL(label));
+    if (tw->table.encoding)
+      CELL(label_width) =
+	XTextWidth16(fs, (TXT16*)CELL(label), (int) CELL(label_len)/2);
+    else
+      CELL(label_width) =
+	XTextWidth(fs, CELL(label), (int) CELL(label_len));
+  }
+}
+
+
+static void CreateTableCellGC(w)
+    Widget w;
+{
+  Display   *dpy = XtDisplay(w);
+  Drawable     d = XtWindow(w);
+  XawTableWidget tw = (XawTableWidget)w;
+  
+  tw->table.normal  = XCreateGC(dpy, d, (XtGCMask)0, (XGCValues*)NULL);
+  tw->table.reverse = XCreateGC(dpy, d, (XtGCMask)0, (XGCValues*)NULL);
+
+  MultipleChangeGC(w,
+		   (Pixel*)&tw->table.foreground,
+		   (Pixel*)&tw->core.background_pixel,
+		   (Font*)&tw->table.font->fid,
+		   (GC*)&tw->table.normal,
+		   (GC*)&tw->table.reverse);
+
+}
+
+static void DrawColumns(tw, b_column, e_column)
+     XawTableWidget tw;
+     int b_column, e_column;
+{
+  int j,y;
+
+  y = (int)GetY(tw,0);
+  for(j = MAX(b_column,0); j <= MIN(e_column, COLUMNS(tw) - 2); j++)
+  {
+    XFillRectangle(XtDisplay((Widget)tw),
+		   XtWindow((Widget)tw),
+		   tw->table.column_gc,
+		   (int) (GetX(tw,j+1) - tw->table.col_margin),
+		   y,
+		   (unsigned int) tw->table.col_margin,
+		   (unsigned int)(tw->table.prefer_height-(2*y)));
+    
+  }
+}
+
+static void DrawRows(tw, b_row, e_row)
+     XawTableWidget tw;
+     int b_row, e_row;
+{
+  int i,x;
+
+  x = (int)GetX(tw,0);
+  for(i = MAX(b_row, 0); i <= MIN(e_row, ROWS(tw) - 2); i++)
+  {
+    XFillRectangle(XtDisplay((Widget)tw),
+		   XtWindow((Widget)tw),
+		   tw->table.row_gc,
+		   x,
+		   (int) (GetY(tw,i+1) - tw->table.row_margin),
+		   (unsigned int) (tw->table.prefer_width-(2*x)),
+		   (unsigned int) tw->table.row_margin);
+    
+  }
+}
+
+static void DrawCage(tw, b_row, e_row, b_column, e_column)
+     XawTableWidget tw;
+     int b_row, e_row, b_column, e_column;
+{
+  int i,j;
+  Display* dpy = XtDisplay((Widget)tw);
+  Window   win = XtWindow((Widget)tw);
+  
+  if (tw->table.row_oriented)
+  {
+    if (tw->table.col_margin > (Dimension)0)
+    {
+      DrawRows(tw, b_row - 1, e_row);
+
+      for(i = b_row; i <= MIN(e_row,ROWS(tw) - 1); i++)
+      {
+	int y = (int) GetY(tw,i);
+	  
+	for(j = MAX(b_column - 1, 0); j <= MIN(e_column, COLUMNS(tw) - 2); j++)
+	{
+	  XFillRectangle (dpy,
+			  win,
+			  tw->table.column_gc,
+			  (int) (GetX(tw, j + 1) - tw->table.col_margin),
+			  y,
+			  (unsigned int) tw->table.col_margin,
+			  (unsigned int) (tw->table.row_height +
+			     2 * tw->table.label_shadow_thickness));
+
+	}
+      }
+    }
+  }
+  else
+  {
+    if (tw->table.row_margin > (Dimension)0)
+    {
+      DrawColumns(tw, b_column - 1, e_column);
+
+      for(j = b_column; j <= MIN(e_column, COLUMNS(tw) - 1); j++)
+      {
+	int x = (int) GetX(tw,j);
+	  
+	for(i = MAX(b_row - 1, 0); i <=  MIN(e_row, ROWS(tw) - 2); i++)
+	{
+	  XFillRectangle(XtDisplay((Widget)tw),
+			 XtWindow((Widget)tw),
+			 tw->table.row_gc,
+			 x,
+			 (int) (GetY(tw,i+1) - tw->table.row_margin),
+			 (unsigned int) (COLUMN_WIDTH(tw,j) +
+					 2 * tw->table.label_shadow_thickness),
+			 (unsigned int) tw->table.row_margin);
+	}
+      }
+    }
+  }
+}
+
+static void Reposition(tw, cell, i, j)
+     register XawTableWidget tw;
+     XawTableCell  cell;
+     int i,j;
+{
+  Position newPos;
+  XtJustify justify;
+  
+  if (cell == NULL)
+    cell = (XawTableCell)get_cell(STUFF(tw),i,j);
+  
+  if (COLUMN_DATA(tw)[j].flag & _CL_justify)
+    justify = COLUMN_DATA(tw)[j].justify;
+  else
+    justify = tw->table.justify;
+
+  switch (justify) {
+  case XtJustifyLeft   : newPos = tw->table.internal_width;
+    break;
+  case XtJustifyRight  : newPos = (COLUMN_WIDTH(tw,j) -
+				   CELL(label_width)         -
+				   tw->table.internal_width);
+    break;
+  case XtJustifyCenter :
+  default              : newPos = (COLUMN_WIDTH(tw,j) -
+				   CELL(label_width)) / 2;
+    break;
+  }
+
+  CELL(label_x) = MAX(newPos, tw->table.internal_width);
+}
+
+/* ARGSUSED */
+static Boolean DeleteCell(p, i, j, call_data, client_data)
+     XtPointer p;
+     int i;               /* unused */
+     int j;               /* unused */
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  Widget w = (Widget) p;
+  XawTableCell cell = (XawTableCell)call_data;
+
+
+  if (CELL(label) != (char*)NULL) 
+    XtFree(CELL(label));
+
+  if (CELL(special_colour)) 
+  {
+    ReleaseNormalGC(w, CELL(fore), CELL(back));
+    ReleaseShadowGC(w, CELL(back));
+  }
+  return False;
+}
+
+
+static void UpdateTable(tw)
+     XawTableWidget tw;
+{
+  Dimension width;
+  Dimension height;
+
+  if (tw->table.no_refigure > 0)
+    return;
+
+  CalculatePreferredSize((Widget)tw, &width, &height);
+
+  tw->table.was_resized = False;
+
+  (void)XtMakeResizeRequest((Widget)tw, width, height,
+			    (Dimension*)NULL, (Dimension*)NULL);
+  if (tw->table.was_resized == False)
+  {
+    tw->table.was_resized = True;
+    (*tableClassRec.core_class.resize) ((Widget)tw);
+  }
+}
+
+
+static int SetTableSize(w, rows, columns)
+     Widget w;
+     int    rows;
+     int    columns;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  int i;
+  
+  if (rows < 0 || columns < 0) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "SetTableSize", "SetTableSize","XawToolkitError",
+     "rows or columns for a new table in TableWidget '%s' less then zero",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  if (STUFF(tw))
+  { 
+    callback_str.reason   = XawTABLE_ALLOW_DELETE_TABLE;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = STUFF(tw);
+    callback_str.new_cell = STUFF(tw);
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+
+    DO_CALLBACK(w, XtNallowDeleteTable, callback_str);
+    
+    if (callback_str.do_it != True)
+      return REJECT;
+      
+    callback_str.reason   = XawTABLE_DELETE_TABLE;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = STUFF(tw);
+    callback_str.new_cell = STUFF(tw);
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+
+    DO_CALLBACK (w, XtNdeleteTable, callback_str);
+    
+    WalkForCells (w, (XawTableProc)DeleteCell, 
+		  0, ROWS(tw)-1, 0, COLUMNS(tw)-1);
+    
+    delete_table ((XtPointer)STUFF(tw));
+
+    STUFF(tw)   = (XawTableCell)NULL;
+    ROWS(tw)    = 0;
+    COLUMNS(tw) = 0;
+  }
+
+  if (rows == 0 || columns == 0)
+    return ACCEPT;
+      
+  STUFF(tw) = (XawTableCell)
+    create_table(rows, columns, sizeof(XawTableCellRec));
+
+  if (STUFF(tw) == (XawTableCell)NULL)
+    return ACCEPT;
+
+  ROWS(tw)    = rows;
+  COLUMNS(tw) = columns;
+  
+  WalkForCells((Widget)tw, (XawTableProc)InitCell, 0, rows-1, 0, columns-1);
+
+  if (COLUMNS(tw)) {
+    tw->table.column_data = (XawTableColumn)
+      XtRealloc((XtPointer)COLUMN_DATA(tw), 
+		(Cardinal)(COLUMNS(tw) * sizeof(XawTableColumnRec)));
+    for (i = 0; i < COLUMNS(tw); i++)
+      COLUMN_DATA(tw)[i].flag = 0;
+  }
+  else {
+    XtFree((XtPointer)tw->table.column_data);
+    tw->table.column_data = NULL;
+  }
+
+  callback_str.reason   = XawTABLE_CREATE_TABLE;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = (XawTableCell)NULL;
+  callback_str.new_cell = (XawTableCell)NULL;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+  
+  DO_CALLBACK(w, XtNcreateTable, callback_str);
+
+  return ACCEPT;
+}
+
+
+/* ARGSUSED */
+static void Initialize(request, new, args, num_args)
+     Widget    request;
+     Widget    new;
+     ArgList   args;
+     Cardinal *num_args;
+{
+  register XawTableWidget tw = (XawTableWidget) new;
+  Dimension   width;
+  Dimension   height;
+  int         i;
+
+  tw->table.no_refigure    = 0;
+  tw->table.no_redraw      = 0;
+  tw->table.num_selections = 0;
+  tw->table.cell_own       = (XawTableCell)NULL;
+  STUFF(tw)                = (XawTableCell)NULL;
+  tw->table.normal         = (GC)NULL;
+  tw->table.reverse        = (GC)NULL;
+
+  COLUMNS(tw) = MAX (COLUMNS(tw), 0);
+  ROWS(tw)    = MAX (ROWS(tw), 0);
+
+  if (COLUMNS(tw)) {
+    tw->table.column_data = (XawTableColumn)
+      CALLOC (COLUMNS(tw), XawTableColumnRec);
+    for (i = 0; i < COLUMNS(tw); i++)
+      COLUMN_DATA(tw)[i].flag = 0;
+  }
+  else
+    tw->table.column_data = NULL;
+
+  SetLiteralWidth(tw);
+		  
+  EDIT(tw) = XtVaCreateWidget
+    ("edit", asciiTextWidgetClass, new,
+     XtNeditType,         XawtextEdit,
+     XtNforeground,       tw->table.edit_fore,
+     XtNbackground,       tw->table.edit_back,
+     XtNborderWidth,      (XtArgVal)0,
+     XtNleftMargin,       2,
+     XtNrightMargin,      2,
+     XtNtopMargin,        0,        /* to be fixed in future */
+     XtNbottomMargin,     0,        /* to be fixed in future */
+     XtNuseStringInPlace, False,
+     XtNfont,             tw->table.font,
+     XtNuserData,         (XtArgVal)new,
+     NULL);
+
+  XtOverrideTranslations(EDIT(tw), XtParseTranslationTable(edit_translations));
+
+  GetGCByForeground (new, (GC*)&tw->table.row_gc,    tw->table.row_fore);
+  GetGCByForeground (new, (GC*)&tw->table.column_gc, tw->table.column_fore);
+
+  if ((COLUMNS(tw) > 0) && (ROWS(tw) > 0))
+  {
+    if (REJECT == SetTableSize(new, ROWS(tw), COLUMNS(tw)))
+    {
+      ROWS(tw)    = 0;
+      COLUMNS(tw) = 0;
+      STUFF(tw)   = (XawTableCell)NULL;
+    }
+  }
+
+  if ((tw->table.mask_number < 0)
+      || (tw->table.mask_number >= XtNumber(MaskStaticArray)))
+    tw->table.mask_number = 7;
+  
+  tw->table.mask_hash_table = MaskStaticArray[tw->table.mask_number];
+  
+  tw->table.normal_hash_table =
+    CALLOC(tw->table.mask_hash_table, NormalReverseGC);
+
+  tw->table.shadow_hash_table = CALLOC(tw->table.mask_hash_table, ShadowGC);
+  
+  for(i = 0; i < tw->table.mask_hash_table; i++)
+  {
+    GET_NORMAL(tw,i)->used    = 0;
+    GET_NORMAL(tw,i)->normal  = (GC)NULL;
+    GET_NORMAL(tw,i)->reverse = (GC)NULL;
+    GET_SHADOW(tw,i)->used   = 0;
+    GET_SHADOW(tw,i)->top    = (GC)NULL;
+    GET_SHADOW(tw,i)->bottom = (GC)NULL;
+  }
+
+  SetLabelHeight(tw);
+
+  CalculatePreferredSize(new, &width, &height);
+  
+  if (new->core.width == 0)  new->core.width = width;
+  if (new->core.height == 0) new->core.height = height;
+}
+
+
+static void Realize(w, valueMask, attributes)
+     Widget w;
+     XtValueMask *valueMask;
+     XSetWindowAttributes *attributes;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  ShadowGC *shadow;
+
+  (*SuperClass->core_class.realize) (w, valueMask, attributes);
+
+  CreateTableCellGC(w);
+
+  shadow = GetShadowGC(w, tw->table.edit_back);
+  tw->table.edit_top    = shadow->top;
+  tw->table.edit_bottom = shadow->bottom;
+
+  shadow = GetShadowGC(w, tw->core.background_pixel);
+  tw->table.top    = shadow->top;
+  tw->table.bottom = shadow->bottom;
+  
+  XtRealizeWidget(EDIT(w));
+}
+
+/* ARGSUSED */
+static Boolean MatchLabel(w, i, j, call_data, client_data)
+     Widget w;            /* unused */
+     int i;               /* unused */
+     int j;               /* unused */
+     XtPointer call_data;
+     XtPointer client_data; 
+{
+  XawTableCell cell = (XawTableCell)call_data;
+  XrmQuark* templ = (XrmQuark*)client_data;
+  
+  return ((*templ) == XrmStringToQuark (GET_CELL_LABEL));
+}
+
+/* ARGSUSED */
+static Boolean InitCell(p, i, j, call_data, client_data)
+     XtPointer p;         /* unused */
+     int i;               /* unused */
+     int j;               /* unused */
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  XawTableCell cell = (XawTableCell)call_data;
+
+  CELL(label)          = DummyString();
+  CELL(label_len)      = 0;
+  CELL(label_width)    = 0;
+  CELL(highlight)      = False;
+  CELL(special_colour) = False;
+  CELL(normal)         = (GC)NULL;
+  CELL(reverse)        = (GC)NULL;
+  CELL(top)            = (GC)NULL;
+  CELL(bottom)         = (GC)NULL;
+
+  return False;
+}
+
+/*
+ *
+ * Shadow drawing around cell
+ *
+ */
+static void PaintShadow(w, i, j, x, y, cell)
+     Widget   w;
+     int      i;      
+     int      j;      
+     Position x;
+     Position y;
+     XawTableCell  cell;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  
+  if (tw->table.label_shadow_thickness != (Dimension)0) {
+    GC top,bottom;
+
+    if (IsEditInRowColumn(tw,i,j))
+    {
+      top    = tw->table.edit_bottom;
+      bottom = tw->table.edit_top;
+    }
+    else if (CELL(special_colour))
+    {
+      top    = CELL(top);
+      bottom = CELL(bottom);
+    }else {
+      top    = tw->table.top;
+      bottom = tw->table.bottom;
+    }
+    
+    XawDrawFrame(w,
+		 x,
+		 y,
+		 (Dimension)(COLUMN_WIDTH(tw,j) +
+			     2 * tw->table.label_shadow_thickness),
+		 (Dimension)(tw->table.row_height +
+			     2 * tw->table.label_shadow_thickness),
+		 XawRAISED,
+		 tw->table.label_shadow_thickness,
+		 top,
+		 bottom);
+  }
+
+}
+
+/* ARGSUSED */
+static void PaintLabel(w, i, j, x, y, cell)
+     Widget w;
+     int i;      
+     int j;      
+     Position x,y;
+     XawTableCell cell;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  XRectangle rectangle[1];
+  Position label_x;
+  Position label_y;
+  unsigned int   width  = (unsigned int) COLUMN_WIDTH(tw,j);
+  unsigned int   height = (unsigned int) tw->table.row_height;
+
+  x += tw->table.label_shadow_thickness;
+  y += tw->table.label_shadow_thickness;
+  
+  if (CELL(special_colour) || CELL(highlight))
+  { 
+    GC gc;
+    
+    if (CELL(special_colour))
+      gc = CELL(highlight) ? CELL(normal) : CELL(reverse);
+    else
+      gc = tw->table.normal ;
+
+    /* Fill background for cell with a special colour */
+    XFillRectangle(XtDisplay(w), XtWindow(w), gc, 
+		   (int)x, (int)y, width, height);
+  }
+  else
+  {
+    XClearArea (XtDisplay(w), XtWindow(w), (int)x, (int)y, 
+		width, height, FALSE);
+  }
+
+  if (CELL(label_len) > 0)
+  {
+    GC gc;
+    register XFontStruct *fs = tw->table.font;
+
+    if (CELL(special_colour))
+      gc = CELL(highlight) ? CELL(reverse) : CELL(normal);
+    else
+      gc = CELL(highlight) ? tw->table.reverse : tw->table.normal;
+    
+    /* Set clip rectangle for label in cell */
+    rectangle[0].x      = (short)x;
+    rectangle[0].y      = (short)y;
+    rectangle[0].width  = (unsigned short)COLUMN_WIDTH(tw,j);
+    rectangle[0].height = (unsigned short)tw->table.row_height;
+    
+    XSetClipRectangles(XtDisplay(w), gc, 0, 0, rectangle, 1, YSorted);
+
+    /* Drawing label */
+    label_x = x + CELL(label_x);
+    label_y = y + 
+      (tw->table.row_height-(fs->max_bounds.ascent+fs->max_bounds.descent))/2
+	/* tw->table.internal_height  */
+	+ fs->max_bounds.ascent;
+
+    if (tw->table.encoding)
+      XDrawString16(XtDisplay(w), XtWindow(w), gc,
+		    label_x, label_y, (TXT16*)CELL(label),
+		    (int)CELL(label_len)/2);
+    else
+      XDrawString(XtDisplay(w), XtWindow(w), gc,
+		  label_x, label_y, CELL(label), (int)CELL(label_len));
+    
+    XSetClipMask(XtDisplay(w), gc, (Pixmap)None);
+  
+  }
+}
+
+/* ARGSUSED */
+static Boolean PaintCell(p, i, j, call_data, client_data)
+     XtPointer p;   
+     int i;      
+     int j;      
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  Widget       w = (Widget) p;
+  XawTableWidget tw = (XawTableWidget) w;
+  XawTableCell   cell = (XawTableCell) call_data;
+  Position     x;
+  Position     y;
+
+  x = GetX(tw,j);
+  y = GetY(tw,i);
+
+  PaintLabel (w, i, j, x, y, cell);
+  PaintShadow (w, i, j, x, y, cell);
+
+  XFlush(XtDisplay(w));
+  return False;
+}
+
+static void WhatCellsToBeDraw(tw, rect, b_row, e_row, b_column , e_column)
+     XawTableWidget tw;
+     XRectangle  rect;
+     register int *b_row, *e_row, *b_column , *e_column;
+{
+  Position    x1 = (Position)rect.x,
+              y1 = (Position)rect.y,
+              x2 = (Position)(rect.x + rect.width - 1),
+              y2 = (Position)(rect.y + rect.height - 1);
+
+  for ((*b_column) = 0; (*b_column) < COLUMNS(tw); (*b_column)++)
+  {
+    if (x1 < (GetX(tw,(*b_column) + 1) - tw->table.col_margin))
+      break;
+  }
+
+  for ((*e_column) = (*b_column); (*e_column) < COLUMNS(tw); (*e_column)++)
+  {
+    if (x2 < (GetX(tw,(*e_column) + 1) - tw->table.col_margin))
+      break;
+  }
+
+
+  for ((*b_row) = 0; (*b_row) < ROWS(tw); (*b_row)++)
+  {
+    if (y1 < (GetY(tw,(*b_row) + 1) - tw->table.row_margin))
+      break;
+  }
+
+  for ((*e_row) = (*b_row); (*e_row) < ROWS(tw); (*e_row)++)
+  {
+    if (y2 < (GetY(tw,(*e_row) + 1) - tw->table.row_margin))
+      break;
+  }
+}
+       
+
+static void Redisplay(w, event, region)
+    Widget w;
+    XEvent *event;
+    Region region;
+{
+  XawTableWidget  tw = (XawTableWidget) w;
+  XRectangle   rect;
+  int b_row, e_row, b_column , e_column ;
+  
+  if (!XtIsRealized(w) || !w->core.visible || tw->table.no_redraw)
+    return;
+
+  if (tw->container.shadow_thickness > 0)
+    (*SuperClass->core_class.expose) (w, event, region);
+  
+  if (region != NULL)
+  {
+    XClipBox(region, (XRectangle*)&rect);
+
+    WhatCellsToBeDraw(tw, rect, &b_row, &e_row, &b_column , &e_column);
+  }
+  else if (event != (XEvent*)NULL)
+  {
+    rect.x      = (short) event->xexpose.x;
+    rect.y      = (short) event->xexpose.y;
+    rect.width  = (unsigned short) event->xexpose.width;
+    rect.height = (unsigned short) event->xexpose.height;
+
+    WhatCellsToBeDraw(tw, rect, &b_row, &e_row, &b_column , &e_column);
+  }
+  else if (tw->table.v_scroll || tw->table.h_scroll)
+  {
+    rect.x      = (short) 0;
+    rect.y      = (short) 0;
+    rect.width  = (unsigned short) tw->core.width;
+    rect.height = (unsigned short) tw->core.height;
+
+    if (tw->table.v_scroll && XtIsManaged(tw->table.v_scroll))
+    {
+      float top;
+      float shown;
+    
+      XtVaGetValues (tw->table.v_scroll,
+		     XtNtopOfThumb, &top,
+		     XtNshown,      &shown,
+		     NULL);
+    
+      rect.y      = (short) ((float)(tw->core.height) * top);
+      rect.height = (unsigned short) ((float)(tw->core.height) * (top+shown));
+    }
+    
+    if (tw->table.h_scroll && XtIsManaged(tw->table.h_scroll))
+    {
+      float top;
+      float shown;
+    
+      XtVaGetValues (tw->table.h_scroll,
+		     XtNtopOfThumb, &top,
+		     XtNshown,      &shown,
+		     NULL);
+    
+      rect.x     = (short) ((float)(tw->core.width) * top);
+      rect.width = (unsigned short) ((float)(tw->core.width) * (top+shown));
+    }
+
+    
+    WhatCellsToBeDraw(tw, rect, &b_row, &e_row, &b_column , &e_column);
+  }
+  else
+  {
+    b_row = 0;
+    e_row = ROWS(tw) - 1;
+    b_column = 0;
+    e_column = COLUMNS(tw) - 1;
+  }
+
+  DrawCage(tw, b_row, e_row, b_column, e_column);
+
+  WalkForCells(w, (XawTableProc)PaintCell, b_row, e_row, b_column, e_column);
+
+  XFlush(XtDisplay(w));
+}
+
+/* ARGSUSED */
+static Boolean SetValues(current, request, new, args, num_args)
+     Widget    current;
+     Widget    request;    /* unused */
+     Widget    new;
+     ArgList   args;       /* unused */
+     Cardinal *num_args;   /* unused */
+{
+    XawTableWidget curtw = (XawTableWidget) current;
+    XawTableWidget newtw = (XawTableWidget) new;
+    register int    i;
+    int             j;
+    Boolean    resize = False;
+    Boolean redisplay = False;
+
+#define NE(field) (curtw->table.field != newtw->table.field)
+
+    if (NE(mask_number))
+      XtWarning("Resource XtNmaskNumber in Table widget can not changed");
+    
+    newtw->table.mask_number = curtw->table.mask_number;
+    newtw->table.literal     = curtw->table.literal;
+    
+    if (NE(font->fid))
+      XtVaSetValues (EDIT(newtw), XtNfont, curtw->table.font, NULL);
+
+    if (NE(foreground)             ||
+	NE(row_fore)               ||
+	NE(column_fore)            ||
+	NE(row_oriented)           ||
+	NE(font->fid)              ||
+	NE(justify)                ||
+	NE(tab_margin)             ||
+	NE(row_margin)             ||
+	NE(col_margin)             ||
+	NE(internal_width)         ||
+	NE(internal_height)        ||
+	NE(label_shadow_thickness) ||
+	NE(encoding))
+      redisplay = True;
+
+    if (NE(font->fid)              ||
+	NE(columns)                ||
+	NE(rows)                   ||
+	NE(tab_margin)             ||
+	NE(row_margin)             ||
+	NE(col_margin)             ||
+	NE(internal_width)         ||
+	NE(internal_height)        ||
+	NE(row_height)             ||
+        NE(label_shadow_thickness))
+      resize = True;
+
+    if (NE(columns) || NE(rows)) 
+      if (REJECT == SetTableSize(new, ROWS(newtw), COLUMNS(newtw))) {
+	newtw->table.columns = curtw->table.columns;
+	newtw->table.rows    = curtw->table.rows;
+      }
+
+    if(NE(row_height))
+    {
+      XawTableCallbackStruct callback_str;
+      callback_str.reason   = XawTABLE_CHANGED_ROW_HEIGHT;
+      callback_str.event    = (XEvent*)NULL;
+      callback_str.old_cell = (XawTableCell)NULL;
+      callback_str.new_cell = (XawTableCell)NULL;
+      callback_str.row      = 0;
+      callback_str.column   = 0;
+      callback_str.do_it    = True;
+      
+      DO_CALLBACK(new, XtNchangedRowHeight, callback_str);
+    }
+
+    if(NE(font->fid))
+    {
+      for(i = 0; i < ROWS(newtw); i++)
+	for(j = 0; j < COLUMNS(newtw); j++)
+	  SetLabelWidth(newtw, i, j);
+
+      SetLabelHeight(newtw);
+    }
+
+    if(NE(font->fid) || NE(encoding))
+    {
+      SetLiteralWidth(newtw);
+      
+      for(i = 0; i < ROWS(newtw); i++)
+	for(j = 0; j < COLUMNS(newtw); j++)
+	  Reposition(newtw, NULL, i, j);
+    }
+    else if(NE(internal_width) || NE(label_shadow_thickness)) {
+      for(i = 0; i < ROWS(newtw); i++)
+	for(j = 0; j < COLUMNS(newtw); j++)
+	  Reposition(newtw, NULL, i, j);
+    }
+    
+    
+    if (NE(internal_height) ||	NE(label_shadow_thickness))
+    {
+      SetLabelHeight(newtw);
+    }
+    
+    if (resize) 
+      CalculatePreferredSize(new, &newtw->core.width, &newtw->core.height);
+    
+    if (NE(foreground) || NE(font->fid) ||
+	curtw->core.background_pixel != newtw->core.background_pixel)
+    {
+      MultipleChangeGC(new,
+		       (Pixel*)&newtw->table.foreground,
+		       (Pixel*)&newtw->core.background_pixel,
+		       (Font*)&newtw->table.font->fid,
+		       (GC*)&newtw->table.normal,
+		       (GC*)&newtw->table.reverse);
+
+    }
+
+    if (NE(row_fore))
+    {
+      XtReleaseGC(new, curtw->table.row_gc);
+      GetGCByForeground(new,(GC*)&newtw->table.row_gc, newtw->table.row_fore);
+    }
+
+    if (NE(column_fore))
+    {
+      XtReleaseGC(new, curtw->table.column_gc);
+      GetGCByForeground(new, &newtw->table.column_gc,newtw->table.column_fore);
+    }
+
+    if (resize)
+      CalculatePreferredSize(new, &(new->core.width), &(new->core.height));
+
+    return redisplay;
+}
+
+
+static void Destroy(w)
+    Widget w;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+
+  if (STUFF(tw) != (XawTableCell)NULL)
+  {
+    callback_str.reason   = XawTABLE_DELETE_TABLE;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = (XawTableCell)NULL;
+    callback_str.new_cell = (XawTableCell)NULL;
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+
+    DO_CALLBACK(w, XtNdeleteTable, callback_str);
+  }
+  
+  if (tw->table.row_gc != (GC)NULL) {
+    XtReleaseGC(w, tw->table.row_gc);
+    tw->table.row_gc = (GC)NULL;
+  }
+  if (tw->table.column_gc != (GC)NULL) {
+    XtReleaseGC(w, tw->table.column_gc);
+    tw->table.column_gc = (GC)NULL;
+  }
+  if (tw->table.normal != (GC)NULL) {
+    XFreeGC(XtDisplay(w), tw->table.normal);
+    tw->table.normal = (GC)NULL;
+  }
+
+  if (tw->table.reverse != (GC)NULL) {
+    XFreeGC(XtDisplay(w), tw->table.reverse);
+    tw->table.reverse = (GC)NULL;
+  }
+
+  WalkForCells(w, (XawTableProc)DeleteCell, 0, ROWS(tw)-1, 0, COLUMNS(tw)-1);
+
+  XtFree((XtPointer)tw->table.normal_hash_table);
+  XtFree((XtPointer)tw->table.shadow_hash_table);
+
+  delete_table(tw->table.table_stuff);
+  STUFF(tw) = (XawTableCell)NULL;
+
+  if (tw->table.column_data != NULL)
+    XtFree((XtPointer)tw->table.column_data);
+
+  if (EDIT(w) != WNULL && !EDIT(w)->core.being_destroyed)
+      XtDestroyWidget(EDIT(w));
+}
+
+
+static void Resize(w)
+    Widget w;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  /* If widget is realized, just redisplay it w/o clearing */
+  if (XtIsRealized(w) && tw->table.no_redraw == 0)
+  {
+    /* XClearWindow(XtDisplay(w), XtWindow(w)); */
+    (*tableClassRec.core_class.expose) (w, (XEvent*)NULL,(Region)NULL);
+  }
+  
+  tw->table.was_resized = True;
+}   
+
+
+static XtGeometryResult QueryGeometry(w, intended, preferred)
+    Widget w;
+    XtWidgetGeometry *intended, *preferred;
+{
+  preferred->request_mode = CWWidth | CWHeight;
+
+  CalculatePreferredSize(w, &preferred->width, &preferred->height);
+
+#define Set(bit) (intended->request_mode & bit)
+
+  if (Set(CWWidth)  && intended->width  == preferred->width &&
+      Set(CWHeight) && intended->height == preferred->height) {
+    return XtGeometryYes;
+  }
+  
+  if (preferred->width  == w->core.width &&
+      preferred->height == w->core.height) {
+    return XtGeometryNo;
+  }
+
+  return XtGeometryAlmost;
+
+#undef Set
+}
+
+/* ARGSUSED */
+static XtGeometryResult GeometryManager(w, desired, allowed)
+     Widget            w;
+     XtWidgetGeometry *desired;
+     XtWidgetGeometry *allowed;
+{
+  return XtGeometryYes;
+}
+
+
+
+static void ExtractPosition(event, x, y , t)
+     XEvent *event;
+     Position *x, *y;		/* RETURN */
+     Time *t;                   /* RETURN */
+{
+  if (event == NULL)
+    return;
+  
+  switch(event->type) {
+  case MotionNotify:
+		           *x = event->xmotion.x;
+		           *y = event->xmotion.y;
+		           *t = event->xmotion.time;
+	 break;
+  case ButtonPress:
+  case ButtonRelease:
+		           *x = event->xbutton.x;
+			   *y = event->xbutton.y;
+			   *t = event->xbutton.time;
+       	 break;
+  case KeyPress:
+  case KeyRelease:
+		           *x = event->xkey.x;
+			   *y = event->xkey.y;
+			   *t = event->xkey.time;
+	 break;
+  case EnterNotify:
+  case LeaveNotify:
+		           *x = event->xcrossing.x;
+			   *y = event->xcrossing.y;
+			   *t = event->xcrossing.time;
+	 break;
+  default:
+			   *x = 0;
+			   *y = 0;
+			   *t = XtLastTimestampProcessed(event->xany.display);
+  }
+}
+
+/* ARGSUSED */
+static Boolean ExtractCell(tw, px, py, row, column)
+     XawTableWidget tw;
+     Position px,py;
+     int *row, *column;              /* RETURN */
+{
+  Position x;
+  Position y;
+#define SH (tw->table.label_shadow_thickness)
+  for(*row = 0; *row < ROWS(tw); (*row)++) {
+    for(*column = 0; *column < COLUMNS(tw); (*column)++) 
+      if ((x=GetX(tw,*column)+SH) <= px)
+	if ((y=GetY(tw,*row)+SH) <= py) 
+	  if ((x+COLUMN_WIDTH(tw,*column)) >= px)
+	    if ((y+tw->table.row_height) >= py) 
+	      return False;
+  }
+#undef SH
+
+  return True;
+}
+
+
+/* ARGSUSED */
+static void WalkForCells(w, proc, b_r, e_r, b_c, e_c)
+     Widget    w;
+     XawTableProc proc;
+     int       b_r, e_r, b_c, e_c;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  int i,j;
+
+  (void)go_table((XtPointer)w, proc, STUFF(tw),
+		 b_r, e_r, b_c, e_c, 
+		 XawTABLE_RIGHT_DOWN,
+		 &i, &j, (XtPointer)NULL);
+}
+
+static char* DummyString()
+{
+  return XtNewString("");
+}
+
+static char* CopyOnlyPrintable(raw)
+     char* raw;
+{
+  char* clear;
+  char *s,*h;
+  int lenght;
+
+  for(s = raw, lenght = 0; (*s) != '\0';)
+  {
+    if (isprint(*s++))
+      lenght++;
+  }
+
+  clear = CALLOC(++lenght, char);
+
+  for(s = raw, h = clear; (*s) != '\0';)
+  {
+    if (isprint(*s))
+      (*h++) = (*s++);
+  }
+
+  (*h) = '\0';
+
+  return clear;
+}
+
+#ifdef EBUG_XRAW_MALLOC
+/* ARGSUSED */
+static Boolean CheckLabel(p, i, j, call_data, client_data)
+     XtPointer p;   
+     int i;      
+     int j;      
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  Widget       w = (Widget) p;
+  XawTableWidget tw = (XawTableWidget) p;
+  XawTableCell cell = (XawTableCell)call_data;
+  char* label = CELL(label);
+
+  for (label = CELL(label); *label != '\0'; label++)
+    if (!isprint(*label))
+    {
+      char message[80];
+      char *p = NULL;
+   sprintf(message, "wrong label '%s' in cell (%4d,%4d) in Table widget '%s'",
+	   CELL(label), i, j, w->core.name);
+      XtWarning(message);
+      *p = '\0';
+      break;
+    }
+
+  return False;
+}
+#endif
+
+#ifdef EBUG_XRAW_MALLOC
+static void CheckAllLabels(tw)
+     XawTableWidget tw;
+{
+  WalkForCells((Widget)tw, (XawTableProc)CheckLabel, 
+	       0, ROWS(tw)-1, 0, COLUMNS(tw)-1);
+}
+#endif
+
+static void MoveEditCell (tw, row, column)
+  XawTableWidget tw;
+  int row;
+  int column;
+{
+  Position x,y;
+
+  x = GetX(tw,column);
+  y = GetY(tw,row);
+  
+  XtConfigureWidget(EDIT(tw),
+		    (Position)(x + tw->table.label_shadow_thickness),
+		    (Position)(y + tw->table.label_shadow_thickness),
+		    (Dimension) COLUMN_WIDTH(tw, column),
+		    (Dimension) tw->table.row_height,
+		    (Dimension)0);
+  XawDrawFrame((Widget)tw,
+	       x,
+	       y,
+	       (Dimension)(COLUMN_WIDTH(tw, column) +
+	       2 * tw->table.label_shadow_thickness),
+	       (Dimension)(tw->table.row_height +
+	       2 * tw->table.label_shadow_thickness),
+	       XawSUNKEN,
+	       tw->table.label_shadow_thickness,
+	       tw->table.edit_top,
+	       tw->table.edit_bottom);
+
+}  
+
+/* ARGSUSED */
+static Boolean CompareCells(p, i, j, call_data, client_data)
+     XtPointer p;
+     int i;               /* unused */
+     int j;               /* unused */
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  XawTableCell      cell = (XawTableCell)call_data;
+  XawTableCell test_cell = (XawTableCell)client_data;
+  
+  return(cell == test_cell);
+}
+
+/******************************************************************
+ *
+ *                    CONVENIENCE FUNCTIONS
+ *
+ ******************************************************************/
+
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableGetSize (Widget w, 
+		 int *rows,
+		 int *columns)
+#else
+XawTableGetSize (w, rows, columns)
+     Widget w;
+     int *rows;
+     int *columns;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  
+  *rows    = ROWS(tw);
+  *columns = COLUMNS(tw);
+}
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableDoLayout (Widget w, 
+		  Boolean do_layout)
+#else
+XawTableDoLayout (w, do_layout)
+     Widget w;
+     Boolean do_layout;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  if (do_layout)
+    tw->table.no_redraw--;
+  else
+    tw->table.no_redraw++;
+
+  tw->table.no_redraw = MAX (tw->table.no_redraw, 0);
+
+  if (tw->table.no_redraw == 0)
+    Redisplay (w, (XEvent *)NULL, (Region)NULL);
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetNewSize (Widget w,
+	     int rows,
+	     int columns)
+#else
+XawTableSetNewSize (w, rows, columns)
+     Widget w;
+     int  rows;
+     int  columns;
+#endif
+{
+  if (REJECT == SetTableSize(w, rows, columns))
+    return REJECT;
+  
+  UpdateTable((XawTableWidget)w);
+  return ACCEPT;
+}
+
+char *
+#ifdef Xraw_NEED_PROTO
+XawTableGetLabelByCell (XawTableCell cell)
+#else
+XawTableGetLabelByCell (cell)
+     XawTableCell cell;
+#endif
+{
+  return GET_CELL_LABEL;
+}
+
+void 
+#ifdef Xraw_NEED_PROTO
+XawTableGetEditPosition (Widget w, int *row, int *column)
+#else
+XawTableGetEditPosition(w, row, column)
+     Widget w;
+     int *row;
+     int *column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  *row    = tw->table.edit_row;
+  *column = tw->table.edit_column;
+}
+     
+Boolean 
+#ifdef Xraw_NEED_PROTO
+XawTableWalk (
+	      Widget w,
+	      XawTableProc proc,
+	      int b_row,
+	      int e_row,
+	      int b_column,
+	      int e_column,
+	      int direction,
+	      int *i,                              /* returned */
+	      int *j,                              /* returned */
+	      XtPointer client_data)
+#else
+XawTableWalk(w, proc, b_row, e_row, b_column, e_column, 
+	     direction, i, j, client_data)
+     Widget w;
+     XawTableProc proc;
+     int b_row, e_row, b_column, e_column;
+     int direction;
+     int *i;                              /* returned */
+     int *j;                              /* returned */
+     XtPointer client_data;
+#endif
+{
+  return go_table((XtPointer)w, proc, STUFF(w),
+		  b_row, e_row, b_column, e_column, 
+		  direction,
+		  i, j, client_data);
+}
+
+Boolean 
+#ifdef Xraw_NEED_PROTO
+XawTableSearchLabel (Widget w, char *name, int *row, int *column)
+#else
+XawTableSearchLabel (w, name, row, column)
+     Widget w;
+     char *name;
+     int *row, *column;
+#endif
+{
+  int row_start    = *row;
+  int column_start = *column;
+  XrmQuark templ   = XrmStringToQuark (name);
+
+  if (XawTableWalk(w, (XawTableProc)MatchLabel,
+		   row_start, row_start, column_start, COLUMNS(w)-1,
+		   XawTABLE_RIGHT_DOWN,
+		   row, column, (XtPointer)&templ)) {
+    return (True);
+  }
+  if (XawTableWalk(w, (XawTableProc)MatchLabel,
+		   row_start+1, ROWS(w)-1, 0, COLUMNS(w)-1,
+		   XawTABLE_RIGHT_DOWN,
+		   row, column, (XtPointer)&templ)) {
+    return (True);
+  }
+  if (XawTableWalk(w, (XawTableProc)MatchLabel,
+		   0, row_start-1, 0, COLUMNS(w)-1,
+		   XawTABLE_RIGHT_DOWN,
+		   row, column, (XtPointer)&templ)) {
+    return (True);
+  }
+  if (XawTableWalk(w, (XawTableProc)MatchLabel,
+		   row_start, row_start, 0, column_start,
+		   XawTABLE_RIGHT_DOWN,
+		   row, column, (XtPointer)&templ)) {
+    return (True);
+  }
+  return (False);
+
+}
+
+/**************************************************************
+ *
+ *
+ *
+ *                        ROW  routines
+ *
+ *
+ *
+ **************************************************************/
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTablePrependRow (Widget w)
+#else
+XawTablePrependRow(w)
+     Widget w;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell cell;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "prependRow", "XawTablePrependRow","XawToolkitError",
+	    "An attempt to add a row in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+
+  /* request for allowance */
+
+  cell = STUFF(tw);
+
+  callback_str.reason   = XawTABLE_ALLOW_ADD_ROW;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddRow, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  row_insert_before(STUFF(tw), sizeof(XawTableCellRec));
+  ROWS(tw)++;
+
+  STUFF(tw) = (XawTableCell)get_table(STUFF(tw));
+
+  WalkForCells(w, (XawTableProc)InitCell, 0, 0, 0, COLUMNS(tw)-1);
+
+  if (XawTableIsEditManaged(w)) 
+    MoveEditCell (tw, ++(tw->table.edit_row), tw->table.edit_column);
+  
+  UpdateTable(tw);
+
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddRow)) 
+  {
+    cell = STUFF(tw);
+
+    callback_str.reason   = XawTABLE_ADD_ROW;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+    
+    XtCallCallbacks (w, XtNaddRow, (XtPointer)&callback_str);
+  }
+
+  return ACCEPT;
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableAppendRow (Widget w)
+#else
+XawTableAppendRow (w)
+     Widget w;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell cell;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL)
+  {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "appendRow", "XawTableAppendRow","XawToolkitError",
+ "An attempt to add a row in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), ROWS(tw)-1, 0);
+  
+  callback_str.reason   = XawTABLE_ALLOW_ADD_ROW;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddRow, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  row_insert_after(get_cell(STUFF(tw), ROWS(tw) - 1, 0), 
+		   sizeof(XawTableCellRec));
+
+  ROWS(tw)++;
+
+  WalkForCells(w, (XawTableProc)InitCell, 
+	       ROWS(tw)-1, ROWS(tw)-1, 0, COLUMNS(tw)-1);
+
+  UpdateTable(tw);
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddRow))
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), ROWS(tw)-1, 0);
+  
+    callback_str.reason   = XawTABLE_ADD_ROW;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = ROWS(tw)-1;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+    
+    XtCallCallbacks (w, XtNaddRow, (XtPointer)&callback_str);
+  }
+
+  return ACCEPT;
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableInsertRow (Widget w, int row)
+#else
+XawTableInsertRow (w, row)
+     Widget w;
+     int row;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell cell;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "insertRow", "XawTableInsertRow","XawToolkitError",
+ "An attempt to add a row in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  if (row != InRange(row, 0, ROWS(tw)-1)) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "insertRow", "XawTableInsertRow","XawToolkitError",
+		    "Incorrect attempt to insert a row in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), row, 0);
+
+  callback_str.reason   = XawTABLE_ALLOW_ADD_ROW;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddRow, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  row_insert_before(get_cell((XtPointer)STUFF(tw), row, 0), 
+		    sizeof(XawTableCellRec));
+
+  ROWS(tw)++;
+
+  if (row == 0)
+    STUFF(tw) = (XawTableCell)get_table(STUFF(tw));
+  
+  WalkForCells(w, (XawTableProc)InitCell, row, row, 0, COLUMNS(tw)-1);
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XawTableIsEditManaged(w) && row <= tw->table.edit_row){
+    tw->table.no_redraw++;
+    MoveEditCell (tw, ++(tw->table.edit_row), tw->table.edit_column);
+    tw->table.no_redraw--;
+  }
+
+  UpdateTable(tw);
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddRow)) 
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), row, 0);
+
+    callback_str.reason   = XawTABLE_ADD_ROW;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = row;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+
+    XtCallCallbacks (w, XtNaddRow, (XtPointer)&callback_str);
+  }
+
+  return ACCEPT;
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableDeleteRow (Widget w, int row)
+#else
+XawTableDeleteRow (w, row)
+     Widget w;
+     int    row;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  XawTableCell           cell;
+  XawTableCallbackStruct callback_str;
+
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "deleteRow", "XawTableDeleteRow","XawToolkitError",
+ "An attempt to delete a row in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  if (row != InRange(row, 0, ROWS(tw)-1)) {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", ROWS(tw)-1);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "deleteRow", "XawTableDeleteRow","XawToolkitError",
+		"Incorrect value of row (%s, max is %s) in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), row, 0);
+
+  callback_str.reason   = XawTABLE_ALLOW_DELETE_ROW;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowDeleteRow, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNdeleteRow))
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), row, 0);
+  
+    callback_str.reason   = XawTABLE_DELETE_ROW;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = row;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+    
+    XtCallCallbacks (w, XtNdeleteRow, (XtPointer)&callback_str);
+  }
+
+  /* if selections owner locates here, then disown selections */
+
+  if (tw->table.cell_own != (XawTableCell)NULL) 
+  { 
+    Boolean have_find;
+    int i, j;
+    
+    have_find = go_table((XtPointer)w, CompareCells, STUFF(tw),
+			 row, row, 0, COLUMNS(tw)-1, 
+			 XawTABLE_RIGHT_DOWN, &i, &j,
+			 (XtPointer)tw->table.cell_own);
+    if (have_find) {
+      for (; 0 < tw->table.num_selections;)
+	XtDisownSelection  (w, 
+			    tw->table.selections[--(tw->table.num_selections)],
+			    XtLastTimestampProcessed(XtDisplay(w)));
+      
+      tw->table.cell_own = (XawTableCell)NULL;
+    }
+  }
+
+  if (row == 0)
+    STUFF(tw) = (XawTableCell)get_cell(STUFF(tw), 1, 0);
+
+  if (--ROWS(tw) == 0)
+    STUFF(tw) = (XawTableCell)NULL;
+  
+  WalkForCells(w, (XawTableProc)DeleteCell, row, row, 0, COLUMNS(tw)-1);
+  
+  row_delete(cell);
+
+  if (XawTableIsEditManaged(w)) 
+  {
+    tw->table.no_redraw++;
+    if (row < tw->table.edit_row){
+      MoveEditCell (tw, --(tw->table.edit_row), tw->table.edit_column);
+    }
+    else if (row == tw->table.edit_row){
+      UNMANAGE_EDIT(tw);
+      tw->table.edit_row = InRange (tw->table.edit_row, 0, ROWS(tw)-1);
+      XawTableSetEdit (w, tw->table.edit_row, tw->table.edit_column);
+    }
+    tw->table.no_redraw--;
+  }
+
+  UpdateTable(tw);
+    
+#ifdef EBUG_XRAW_MALLOC
+    CHECK_TABLE(tw);
+#endif
+
+  return ACCEPT;
+}
+
+
+
+/**************************************************************
+ *
+ *
+ *
+ *                        COLUMN  routines
+ *
+ *
+ *
+ **************************************************************/
+
+int 
+#ifdef Xraw_NEED_PROTO
+XawTablePrependColumn (Widget w, int width)
+#else
+XawTablePrependColumn (w, width)
+     Widget w;
+     int width;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  int j;
+  XawTableCell cell;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "prependColumn", "XawTablePrependColumn","XawToolkitError",
+ "An attempt to add a column in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  /* request for allowance */
+
+  cell = STUFF(tw);
+
+  callback_str.reason   = XawTABLE_ALLOW_ADD_COLUMN;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddColumn, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  column_insert_before(STUFF(tw), sizeof(XawTableCellRec));
+  COLUMNS(tw)++;
+
+  STUFF(tw) = (XawTableCell)get_table(STUFF(tw));
+
+  WalkForCells(w, (XawTableProc)InitCell, 0, ROWS(tw)-1, 0, 0);
+  
+  /* 
+   * insert new item in `column_data' list 
+   */
+
+  if (tw->table.column_data)
+  {
+    tw->table.column_data = (XawTableColumn)
+      XtRealloc((XtPointer)tw->table.column_data,
+		(Cardinal)(COLUMNS(tw) * sizeof(XawTableColumnRec)));
+  }
+  else
+  {
+    tw->table.column_data = CALLOC(COLUMNS(tw), XawTableColumnRec);
+    for(j = 0; j < COLUMNS(tw); j++)
+      COLUMN_DATA(tw)[j].flag = 0;
+  }
+  
+  for(j = COLUMNS(tw)-2; j >= 0; j--)
+    (void)memcpy((char*)&(COLUMN_DATA(tw)[j+1]), (char*)&(COLUMN_DATA(tw)[j]),
+		 sizeof(XawTableColumnRec));
+
+  COLUMN_DATA(tw)[0].flag |= _CL_width;
+  COLUMN_DATA(tw)[0].width = width;
+
+
+  if (XawTableIsEditManaged(w)) 
+    MoveEditCell (tw, tw->table.edit_row, ++(tw->table.edit_column));
+
+  /* Let's look the table which we have made now */
+  UpdateTable(tw);
+
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddColumn)) 
+  {
+    cell = STUFF(tw);
+
+    callback_str.reason   = XawTABLE_ADD_COLUMN;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = 0;
+    callback_str.column   = 0;
+    callback_str.do_it    = True;
+
+    XtCallCallbacks (w, XtNaddColumn, (XtPointer)&callback_str);
+  }
+  
+  return ACCEPT;
+}
+
+int 
+#ifdef Xraw_NEED_PROTO
+XawTableAppendColumn (Widget w, int width)
+#else
+XawTableAppendColumn (w, width)
+     Widget w;
+     int width;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  int                    j;
+  XawTableCell           cell;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "addingColumn", "XawTableAppendColumn","XawToolkitError",
+	"An attempt to add a column in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), 0, COLUMNS(tw)-1);
+  
+  callback_str.reason   = XawTABLE_ALLOW_ADD_COLUMN;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddColumn, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  column_insert_after(get_cell(STUFF(tw), 0, COLUMNS(tw)-1), 
+		      sizeof(XawTableCellRec));
+
+  COLUMNS(tw)++;
+  
+  WalkForCells(w, (XawTableProc)InitCell, 
+	       0, ROWS(tw)-1, COLUMNS(tw)-1, COLUMNS(tw)-1);
+
+
+
+
+  /* 
+   * insert new item in `column_data' list 
+   */
+
+  if (tw->table.column_data)
+  {
+    tw->table.column_data = (XawTableColumn)
+      XtRealloc((XtPointer)tw->table.column_data,
+		(Cardinal)(COLUMNS(tw) * sizeof(XawTableColumnRec)));
+  }
+  else
+  {
+    tw->table.column_data = CALLOC(COLUMNS(tw), XawTableColumnRec);
+    for(j = 0; j < COLUMNS(tw); j++)
+      COLUMN_DATA(tw)[j].flag = 0;
+  }
+  
+  COLUMN_DATA(tw)[COLUMNS(tw)-1].flag |= _CL_width;
+  COLUMN_DATA(tw)[COLUMNS(tw)-1].width = width;
+
+
+  /* Let's look the table which we have made now */
+  UpdateTable(tw);
+
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddColumn))
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), 0, COLUMNS(tw)-1);
+    
+    callback_str.reason   = XawTABLE_ADD_COLUMN;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = 0;
+    callback_str.column   = COLUMNS(tw)-1;
+    callback_str.do_it    = True;
+
+    XtCallCallbacks (w, XtNaddColumn, (XtPointer)&callback_str);
+  }
+
+  return ACCEPT;
+}
+
+int 
+#ifdef Xraw_NEED_PROTO
+XawTableInsertColumn (Widget w, int column, int width)
+#else
+XawTableInsertColumn(w, column, width)
+     Widget w;
+     int column;
+     int width;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  XawTableCell           cell;
+  int                    j;
+  XawTableCallbackStruct callback_str;
+  
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "insertColumn", "XawTableInsertColumn","XawToolkitError",
+ "An attempt to add a column in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  if (column != InRange(column, 0, COLUMNS(tw)-1)) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "insertColumn", "XawTableInsertColumn","XawToolkitError",
+		 "It detected incorrect value of column in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), 0, column);
+
+  callback_str.reason   = XawTABLE_ALLOW_ADD_COLUMN;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowAddColumn, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  column_insert_before (get_cell ((XtPointer)STUFF(tw), 0, column), 
+			sizeof(XawTableCellRec));
+  COLUMNS(tw)++;
+
+  if (column == 0)
+    STUFF(tw) = (XawTableCell) get_table (STUFF(tw));
+  
+  WalkForCells(w, (XawTableProc)InitCell, 0, ROWS(tw)-1, column, column);
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  /* 
+   * insert new item in `column_data' list 
+   */
+
+  if (tw->table.column_data)
+  {
+    tw->table.column_data = (XawTableColumn)
+      XtRealloc((XtPointer)tw->table.column_data,
+		(Cardinal)(COLUMNS(tw) * sizeof(XawTableColumnRec)));
+  }
+  else
+  {
+    tw->table.column_data = CALLOC(COLUMNS(tw), XawTableColumnRec);
+    for(j = 0; j < COLUMNS(tw); j++)
+      COLUMN_DATA(tw)[j].flag = 0;
+  }
+  
+  for(j = COLUMNS(tw)-2; j >= column; j--)
+    (void)memcpy((char*)&(COLUMN_DATA(tw)[j+1]), (char*)&(COLUMN_DATA(tw)[j]),
+		 sizeof(XawTableColumnRec));
+
+  COLUMN_DATA(tw)[column].flag |= _CL_width;
+  COLUMN_DATA(tw)[column].width = width;
+
+  /*
+   * move the edit cell
+   */
+
+  if (XawTableIsEditManaged(w) && column <= tw->table.edit_column){
+    tw->table.no_redraw++;
+    MoveEditCell (tw, tw->table.edit_row, ++(tw->table.edit_column));
+    tw->table.no_redraw--;
+  }
+
+  /* Let's look the table which we have made now */
+  UpdateTable(tw);
+ 
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNaddColumn)) 
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), 0, column);
+
+    callback_str.reason   = XawTABLE_ADD_COLUMN;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = 0;
+    callback_str.column   = column;
+    callback_str.do_it    = True;
+
+    XtCallCallbacks (w, XtNaddColumn, (XtPointer)&callback_str);
+  }
+
+  return ACCEPT;
+}
+
+int 
+#ifdef Xraw_NEED_PROTO
+XawTableDeleteColumn (Widget w, int column)
+#else
+XawTableDeleteColumn(w, column)
+     Widget w;
+     int    column;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  XawTableCell           cell;
+  int                    j;
+  XawTableCallbackStruct callback_str;
+  
+
+  if (STUFF(tw) == NULL) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "deleteColumn", "XawTableDeleteColumn","XawToolkitError",
+ "An attempt to delete a column in empty table in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  if (column != InRange(column, 0, COLUMNS(tw)-1)) {
+    String subs[1];
+    Cardinal num_subs = 1;
+    subs[0] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "deleteColumn", "XawTableDeleteColumn","XawToolkitError",
+		  "It detected incorrect value of column in TableWidget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+
+  /* request for allowance */
+
+  cell = (XawTableCell)get_cell(STUFF(tw), 0, column);
+
+  callback_str.reason   = XawTABLE_ALLOW_DELETE_COLUMN;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = 0;
+  callback_str.column   = 0;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNallowDeleteColumn, callback_str);
+
+  if (callback_str.do_it != True)
+    return REJECT;
+
+  
+
+#ifdef EBUG_XRAW_MALLOC
+  CHECK_TABLE(tw);
+#endif
+
+  if (XtCallbackHasSome == XtHasCallbacks(w, XtNdeleteColumn))
+  {
+    cell = (XawTableCell)get_cell(STUFF(tw), 0, column);
+  
+    callback_str.reason   = XawTABLE_DELETE_COLUMN;
+    callback_str.event    = (XEvent*)NULL;
+    callback_str.old_cell = cell;
+    callback_str.new_cell = cell;
+    callback_str.row      = 0;
+    callback_str.column   = column;
+    callback_str.do_it    = True;
+    
+    XtCallCallbacks (w, XtNdeleteColumn, (XtPointer)&callback_str);
+  }
+
+  /* if selections owner locates here, then disown selections */
+
+  if (tw->table.cell_own != (XawTableCell)NULL) 
+  { 
+    Boolean have_find;
+    int i, j;
+    
+    have_find = go_table((XtPointer)w, CompareCells, STUFF(tw),
+			 0, ROWS(tw)-1, column, column, 
+			 XawTABLE_RIGHT_DOWN, &i, &j,
+			 (XtPointer)tw->table.cell_own);
+    if (have_find) {
+      for (; 0 < tw->table.num_selections;)
+	XtDisownSelection  (w, 
+			    tw->table.selections[--(tw->table.num_selections)],
+			    XtLastTimestampProcessed(XtDisplay(w)));
+      
+      tw->table.cell_own = (XawTableCell)NULL;
+    }
+  }
+
+  if (column == 0)
+    STUFF(tw) = (XawTableCell)get_cell(STUFF(tw), 0, 1);
+  
+  if (--COLUMNS(tw) == 0)
+    STUFF(tw) = (XawTableCell)NULL;
+  
+
+  WalkForCells(w, (XawTableProc)DeleteCell, 0, ROWS(tw)-1, column, column);
+
+  column_delete(cell);
+
+  /*
+   * shrink column data list
+   */
+
+  if (COLUMNS(tw) == 0) {
+    XtFree((XtPointer)tw->table.column_data);
+    tw->table.column_data = NULL;
+  }
+  else
+  {
+    for(j = column; j < COLUMNS(tw); j++)
+      (void)memcpy((char*)&(COLUMN_DATA(tw)[j]),(char*)&(COLUMN_DATA(tw)[j+1]),
+		   sizeof(XawTableColumnRec));
+
+    tw->table.column_data = (XawTableColumn)
+      XtRealloc((XtPointer)tw->table.column_data,
+		(Cardinal)(COLUMNS(tw) * sizeof(XawTableColumnRec)));
+  }
+
+
+  /* 
+   * shift the edit cell 
+   */
+
+  if (XawTableIsEditManaged(w)) 
+  {
+    tw->table.no_redraw++;
+    if (column < tw->table.edit_column){
+      MoveEditCell (tw, tw->table.edit_row, --(tw->table.edit_column));
+    }
+    else if (column == tw->table.edit_column){
+      UNMANAGE_EDIT(tw);
+      tw->table.edit_column = InRange (tw->table.edit_column,0,COLUMNS(tw)-1);
+      XawTableSetEdit (w, tw->table.edit_row, tw->table.edit_column);
+    }
+    tw->table.no_redraw--;
+  }
+
+  /* Let's look the table which we have made now */
+  UpdateTable(tw);
+    
+#ifdef EBUG_XRAW_MALLOC
+    CHECK_TABLE(tw);
+#endif
+
+  return ACCEPT;
+}
+
+
+Boolean 
+#ifdef Xraw_NEED_PROTO
+XawTableIsEditManaged (Widget w)
+#else
+XawTableIsEditManaged (w)
+     Widget w;
+#endif
+{
+  return XtIsManaged(((XawTableWidget)w)->table.edit);
+}
+
+
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetLabel (Widget w, int row, int column, char *raw_label)
+#else
+XawTableSetLabel(w, row, column, raw_label)
+     Widget w;
+     int    row;
+     int    column;
+     char  *raw_label;
+#endif
+{
+  register XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  XawTableCell cell;
+  char* label = NULL;
+  XawTableCellRec new;
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row    != InRange(row, 0, ROWS(tw)-1))    || 
+      (column != InRange(column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "SetLabel", "XawTableSetLabel","XawToolkitError",
+"XawTableSetLabel\nIncorrect value of rows or columns (%s,%s) in TableWidget '%s' ",
+		    subs, &num_subs);
+    return REJECT;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (raw_label == (char*)NULL)
+    label = DummyString();
+  else
+    label = CopyOnlyPrintable(raw_label);
+
+  if (streq(label,CELL(label))) {
+    XtFree(label);                 /* XtMalloc in CopyOnlyPrintable */
+    return ACCEPT;
+  }
+
+  (void)memcpy((char*)&new, (char*)cell, sizeof(XawTableCellRec));
+  new.label = label;
+
+  callback_str.reason   = XawTABLE_CHANGED_CELL;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = &new;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+  
+  DO_CALLBACK(w, XtNchangedCell, callback_str);
+  
+  if (callback_str.do_it != True) {
+    XtFree(label);
+    return REJECT;
+  }
+  
+  
+  if (CELL(label))
+    XtFree(CELL(label));
+  
+  (void)memcpy((char*)cell, (char*)&new, sizeof(XawTableCellRec));
+  
+  SetLabelWidth (tw, row, column);
+  Reposition (tw, cell, row, column);
+    
+  if (IsEditInRowColumn (tw, row, column)) 
+  {
+    XtVaSetValues (EDIT(w), "string", CELL(label), NULL);
+  }
+  else if (XtIsRealized (w) && w->core.visible && !tw->table.no_redraw) 
+  {
+    int x               = GetX(tw,column);
+    int y               = GetY(tw,row);
+    unsigned int width  = (unsigned int) COLUMN_WIDTH(tw,column);
+    unsigned int height = (unsigned int) tw->table.row_height;
+    
+    XClearArea (XtDisplay(w), XtWindow(w), x, y, width, height, FALSE);
+    (void) PaintCell (w, row, column, (XtPointer)cell, (XtPointer)NULL);
+  }
+  return ACCEPT;
+}
+
+
+
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetCellColours (Widget w, int row, int column, 
+			Pixel fore, Pixel back)
+#else
+XawTableSetCellColours (w, row, column, fore, back)
+     Widget w;
+     int row;
+     int column;
+     Pixel fore;
+     Pixel back;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  XawTableCell cell;
+  XawTableCellRec        new;
+  NormalReverseGC*       normal;
+  ShadowGC*              shadow;
+
+
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row    != InRange (row, 0, ROWS(tw)-1)) || 
+      (column != InRange (column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "SetCellColours", "XawTableSetCellColours","XawToolkitError",
+"XawTableSetCellColours\nIncorrect value of rows or columns (%s,%s) in TableWidget '%s' ",
+		    subs, &num_subs);
+    return REJECT;
+  }
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (CELL(special_colour) && fore == CELL(fore) && back == CELL(back))
+    return ACCEPT;
+  
+  /*
+   * prepare new cell stuff from old one
+   */
+  (void)memcpy((char*)&new, (char*)cell, sizeof(XawTableCellRec));
+  new.special_colour = True;
+  new.back           = back;
+  new.fore           = fore;
+
+  /* normal and reverse GC's */
+  normal = GetNormalGC(w, fore, back, tw->table.font->fid);
+  
+  new.normal  = normal->normal;
+  new.reverse = normal->reverse;
+
+
+  /* shadow GC's */
+  shadow = GetShadowGC(w, back);
+  
+  new.top    = shadow->top;
+  new.bottom = shadow->bottom;
+
+
+  callback_str.reason   = XawTABLE_CHANGED_CELL;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = &new;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNchangedCell, callback_str);
+
+  if (callback_str.do_it) 
+  {
+    int x               = GetX(tw,column);
+    int y               = GetY(tw,row);
+    unsigned int width  = (unsigned int) COLUMN_WIDTH(tw,column);
+    unsigned int height = (unsigned int) tw->table.row_height;
+    
+    if (XtIsRealized(w) && w->core.visible && 
+	!tw->table.no_redraw && !tw->table.no_refigure) {
+      XClearArea (XtDisplay(w), XtWindow(w), 
+		  x + tw->table.label_shadow_thickness, 
+		  y + tw->table.label_shadow_thickness, 
+		  width, height, FALSE);
+      PaintLabel (w, row, column, x, y, &new);
+      PaintShadow (w, row, column, x, y, &new);
+      XFlush(XtDisplay(w));
+    }
+
+    if (CELL(special_colour)) {
+      ReleaseNormalGC(w, CELL(fore), CELL(back));
+      ReleaseShadowGC(w, CELL(back));
+    }
+    (void)memcpy((char*)cell, (char*)&new, sizeof(XawTableCellRec));
+
+    return ACCEPT;
+  }
+  else
+  {
+    ReleaseNormalGC(w, fore, back);
+    ReleaseShadowGC(w, back);
+    return REJECT;
+  }
+}
+
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetCellDefaultColours (Widget w, int row, int column)
+#else
+XawTableSetCellDefaultColours (w, row, column)
+     Widget w;
+     int row;
+     int column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  XawTableCell cell;
+  XawTableCellRec new;
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row    != InRange (row, 0, ROWS(tw)-1)) || 
+      (column != InRange (column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+        "SetCellColours", "XawTableSetCellDefaultColours","XawToolkitError",
+"XawTableSetCellDefaultColours\n\
+Incorrect value of row or column (%s,%s) in Table widget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (!CELL(special_colour))
+    return ACCEPT;
+  
+  /*
+   * prepare new cell stuff from old one
+   */
+  (void)memcpy((char*)&new, (char*)cell, sizeof(XawTableCellRec));
+  new.special_colour = False;
+  new.fore           = tw->table.foreground;
+  new.back           = tw->core.background_pixel;
+
+  callback_str.reason   = XawTABLE_CHANGED_CELL;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = &new;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNchangedCell, callback_str);
+
+  if (callback_str.do_it) 
+  {
+    int x               = GetX(tw,column);
+    int y               = GetY(tw,row);
+    unsigned int width  = (unsigned int) COLUMN_WIDTH(tw,column);
+    unsigned int height = (unsigned int) tw->table.row_height;
+    
+    if (XtIsRealized(w) && w->core.visible && !tw->table.no_redraw) {
+      XClearArea (XtDisplay(w), XtWindow(w), 
+		  x + tw->table.label_shadow_thickness, 
+		  y + tw->table.label_shadow_thickness, 
+		  width, height, FALSE);
+      PaintLabel (w, row, column, x, y, &new);
+      PaintShadow (w, row, column, x, y, &new);
+      XFlush(XtDisplay(w));
+    }
+
+    if (CELL(special_colour)) {
+      ReleaseNormalGC(w, CELL(fore), CELL(back));
+      ReleaseShadowGC(w, CELL(back));
+    }
+    (void)memcpy((char*)cell, (char*)&new, sizeof(XawTableCellRec));
+
+    return ACCEPT;
+  }
+  else
+  {
+    return REJECT;
+  }
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetCellBackground (Widget w, int row, int column, Pixel back)
+#else
+XawTableSetCellBackground (w, row, column, back)
+     Widget w;
+     int row;
+     int column;
+     Pixel back;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  XawTableCell           cell;
+  XawTableCellRec        new;
+  NormalReverseGC*       normal;
+  ShadowGC*              shadow;
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row    != InRange (row, 0, ROWS(tw)-1)) || 
+      (column != InRange (column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+	    "SetCellColours", "XawTableSetCellBackground","XawToolkitError",
+"XawTableSetCellBackground\n\
+Incorrect value of row or column (%s,%s) in Table widget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (CELL(special_colour) && back == CELL(back))
+    return ACCEPT;
+  
+  /*
+   * prepare new cell stuff from old one
+   */
+  (void)memcpy((char*)&new, (char*)cell, sizeof(XawTableCellRec));
+  new.special_colour = True;
+  new.back           = back;
+
+  if (!CELL(special_colour))
+      new.fore = tw->table.foreground;
+
+  /* normal and reverse GC's */
+  normal = GetNormalGC(w, new.fore, back, tw->table.font->fid);
+  
+  new.normal  = normal->normal;
+  new.reverse = normal->reverse;
+
+
+  /* shadow GC's */
+  shadow = GetShadowGC(w, back);
+  
+  new.top    = shadow->top;
+  new.bottom = shadow->bottom;
+
+
+  callback_str.reason   = XawTABLE_CHANGED_CELL;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = &new;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNchangedCell, callback_str);
+
+  if (callback_str.do_it) 
+  {
+    int x               = GetX(tw,column);
+    int y               = GetY(tw,row);
+    unsigned int width  = (unsigned int) COLUMN_WIDTH(tw,column);
+    unsigned int height = (unsigned int) tw->table.row_height;
+    
+    if (XtIsRealized(w) && w->core.visible && !tw->table.no_redraw) {
+      XClearArea (XtDisplay(w), XtWindow(w), 
+		  x + tw->table.label_shadow_thickness, 
+		  y + tw->table.label_shadow_thickness, 
+		  width, height, FALSE);
+      PaintLabel (w, row, column, x, y, &new);
+      PaintShadow (w, row, column, x, y, &new);
+      XFlush(XtDisplay(w));
+    }
+
+    if (CELL(special_colour)) {
+      ReleaseNormalGC(w, CELL(fore), CELL(back));
+      ReleaseShadowGC(w, CELL(back));
+    }
+    (void)memcpy((char*)cell, (char*)&new, sizeof(XawTableCellRec));
+
+    return ACCEPT;
+  }
+  else
+  {
+    ReleaseNormalGC(w, new.fore, back);
+    ReleaseShadowGC(w, back);
+    return REJECT;
+  }
+
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableSetCellForeground (Widget w, int row, int column, Pixel fore)
+#else
+XawTableSetCellForeground (w, row, column, fore)
+     Widget w;
+     int row;
+     int column;
+     Pixel fore;
+#endif
+{
+  XawTableWidget         tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  XawTableCell           cell;
+  XawTableCellRec        new;
+  NormalReverseGC*       normal;
+  ShadowGC*              shadow;
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row    != InRange (row, 0, ROWS(tw)-1)) || 
+      (column != InRange (column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+	    "SetCellColours", "XawTableSetCellBackground","XawToolkitError",
+"XawTableSetCellBackground\n\
+Incorrect value of row or column (%s,%s) in Table widget '%s'",
+		    subs, &num_subs);
+    return REJECT;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (CELL(special_colour) && fore == CELL(fore))
+    return ACCEPT;
+  
+  /*
+   * prepare new cell stuff from old one
+   */
+  (void)memcpy((char*)&new, (char*)cell, sizeof(XawTableCellRec));
+  new.special_colour = True;
+  new.fore           = fore;
+
+  if (!CELL(special_colour))
+      new.back = tw->core.background_pixel;
+
+  /* normal and reverse GC's */
+  normal = GetNormalGC(w, fore, new.back, tw->table.font->fid);
+  
+  new.normal  = normal->normal;
+  new.reverse = normal->reverse;
+
+
+  /* shadow GC's */
+  shadow = GetShadowGC(w, new.back);
+  
+  new.top    = shadow->top;
+  new.bottom = shadow->bottom;
+
+
+  callback_str.reason   = XawTABLE_CHANGED_CELL;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = &new;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNchangedCell, callback_str);
+
+  if (callback_str.do_it) 
+  {
+    int x               = GetX(tw,column);
+    int y               = GetY(tw,row);
+    unsigned int width  = (unsigned int) COLUMN_WIDTH(tw,column);
+    unsigned int height = (unsigned int) tw->table.row_height;
+    
+    if (XtIsRealized(w) && w->core.visible && !tw->table.no_redraw) {
+      XClearArea (XtDisplay(w), XtWindow(w), 
+		  x + tw->table.label_shadow_thickness, 
+		  y + tw->table.label_shadow_thickness, 
+		  width, height, FALSE);
+      PaintLabel (w, row, column, x, y, &new);
+      PaintShadow (w, row, column, x, y, &new);
+      XFlush(XtDisplay(w));
+    }
+
+    if (CELL(special_colour)) {
+      ReleaseNormalGC(w, CELL(fore), CELL(back));
+      ReleaseShadowGC(w, CELL(back));
+    }
+    (void)memcpy((char*)cell, (char*)&new, sizeof(XawTableCellRec));
+
+    return ACCEPT;
+  }
+  else
+  {
+    ReleaseNormalGC(w, fore, new.back);
+    ReleaseShadowGC(w, new.back);
+    return REJECT;
+  }
+}
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableGetCellColours (Widget w, int row, int column, 
+			Pixel *fore, Pixel *back)
+#else
+XawTableGetCellColours (w, row, column, fore, back)
+     Widget w;
+     int row;
+     int column;
+     Pixel *fore;
+     Pixel *back;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell   cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+
+  if (cell && cell->special_colour) {
+    *fore = cell->fore;
+    *back = cell->back;
+  }
+  else {
+    *fore = tw->table.foreground;
+    *back = tw->core.background_pixel;
+  }
+}
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableGetCellColoursByCell (Widget w, XawTableCell cell, 
+			      Pixel *fore, Pixel *back)
+#else
+XawTableGetCellColoursByCell (w, cell, fore, back)
+     Widget w;
+     XawTableCell cell;
+     Pixel *fore;
+     Pixel *back;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  if (cell && cell->special_colour) {
+    *fore = cell->fore;
+    *back = cell->back;
+  }
+  else {
+    *fore = tw->table.foreground;
+    *back = tw->core.background_pixel;
+  }
+}
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Column Defaults                             #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+
+#ifdef notdef
+/* ARGSUSED */
+static Boolean PaintCellWithClear(p, i, j, call_data, client_data)
+     XtPointer p;   
+     int i;      
+     int j;      
+     XtPointer call_data;
+     XtPointer client_data; /* unused */
+{
+  Widget         w      = (Widget) p;
+  XawTableWidget tw     = (XawTableWidget) w;
+  XawTableCell   cell   = (XawTableCell) call_data;
+  unsigned int   width  = (unsigned int) COLUMN_WIDTH(tw,j);
+  unsigned int   height = (unsigned int) tw->table.row_height;
+  Position       x;
+  Position       y;
+    
+
+  x = GetX(tw,j);
+  y = GetY(tw,i);
+
+  XClearArea (XtDisplay(w), XtWindow(w), 
+	      x + tw->table.label_shadow_thickness, 
+	      y + tw->table.label_shadow_thickness, 
+	      width, height, FALSE);
+
+  PaintLabel (w, i, j, x, y, cell);
+  PaintShadow (w, i, j, x, y, cell);
+
+  XFlush(XtDisplay(w));
+  return False;
+}
+#endif
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableSetColumnJustify (Widget w, int column, XtJustify justify)
+#else
+XawTableSetColumnJustify (w, column, justify)
+     Widget w;
+     int   column;
+     XtJustify justify;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  int i, j;
+
+  if (column != InRange (column, 0, COLUMNS(tw)-1)) 
+    return;
+    
+  COLUMN_DATA(tw)[column].flag |= _CL_justify;
+  COLUMN_DATA(tw)[column].justify = justify;
+  
+  for(i = 0; i < ROWS(tw); i++)
+    Reposition(tw, NULL, i, column);
+  
+  if (XtIsRealized(w) && w->core.visible && 
+      !tw->table.no_redraw && !tw->table.no_refigure) 
+  {
+    (void)go_table((XtPointer)w, PaintCell, STUFF(tw),
+		   0, ROWS(tw)-1, column, column, 
+		   XawTABLE_DOWN_RIGHT,
+		   &i, &j, (XtPointer)NULL);
+    XFlush(XtDisplay(w));
+  }
+}
+
+
+XtJustify
+#ifdef Xraw_NEED_PROTO
+XawTableGetColumnJustify (Widget w, int column)
+#else
+XawTableGetColumnJustify (w, column)
+     Widget w;
+     int   column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  if (column != InRange (column, 0, COLUMNS(tw)-1)) 
+    return XtJustifyCenter;
+    
+  if (COLUMN_DATA(tw)[column].flag & _CL_justify)
+    return COLUMN_DATA(tw)[column].justify;
+  
+  return XtJustifyCenter;
+}
+
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableSetColumnWidth (Widget w, int column, int width)
+#else
+XawTableSetColumnWidth(w, column, width)
+     Widget w;
+     int   column;
+     int   width;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCallbackStruct callback_str;
+  register int row;
+
+  if (column != InRange (column, 0, COLUMNS(tw)-1)) 
+    return;
+    
+  if ((COLUMN_DATA(tw)[column].flag & _CL_width) && 
+       COLUMN_DATA(tw)[column].width == width)
+    return;
+
+  COLUMN_DATA(tw)[column].flag |= _CL_width;
+  COLUMN_DATA(tw)[column].width = width;
+
+  for(row = 0; row < ROWS(tw); row++)
+    Reposition(tw, NULL, row, column);
+  
+  UpdateTable(tw);
+
+  callback_str.reason   = XawTABLE_CHANGED_COLUMN_WIDTH;
+  callback_str.event    = (XEvent*)NULL;
+  callback_str.old_cell = (XawTableCell)NULL;
+  callback_str.new_cell = (XawTableCell)NULL;
+  callback_str.row      = 0;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+  
+  DO_CALLBACK(w, XtNchangedColumnWidth, callback_str);
+}
+
+
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableGetColumnWidth (Widget w, int column)
+#else
+XawTableGetColumnWidth(w, column)
+     Widget w;
+     int   column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+
+  if (column != InRange (column, 0, COLUMNS(tw)-1)) 
+    return tw->table.column_default_width;
+    
+  if ((COLUMN_DATA(tw)[column].flag & _CL_width))
+    return COLUMN_DATA(tw)[column].width;
+
+  return tw->table.column_default_width;
+}
+
+int
+#ifdef Xraw_NEED_PROTO
+XawTableGetColumnPixelWidth (Widget w, int column)
+#else
+XawTableGetColumnPixelWidth(w, column)
+     Widget w;
+     int   column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  int width;
+
+  if (column != InRange (column, 0, COLUMNS(tw)-1)) 
+    width = tw->table.column_default_width;
+  else   if ((COLUMN_DATA(tw)[column].flag & _CL_width))
+    width = COLUMN_DATA(tw)[column].width;
+  else
+    width = tw->table.column_default_width;
+
+  if (tw->table.literal) {
+    width = width * tw->table.literal_width + 2 * tw->table.internal_width;
+  }
+
+  return width;
+}
+
+char *
+#ifdef Xraw_NEED_PROTO
+XawTableGetLabelByPosition (Widget w, int i, int j)
+#else
+     XawTableGetLabelByPosition(w,i,j)
+     Widget w;
+     int i,j;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell cell;
+    
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (i != InRange(i, 0, ROWS(tw)-1)) || 
+      (j != InRange(j, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", i);
+    sprintf(subs[1], "%5d", j);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "GetLabelByPosition", "XawTableGetLabelByPosition","XawToolkitError",
+"XawTableGetLabelByPosition\nIncorrect value of rows or columns (%s,%s) in TableWidget '%s' ",
+		    subs, &num_subs);
+    return NULL;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), i, j);
+  return GET_CELL_LABEL;
+}
+
+void
+#ifdef Xraw_NEED_PROTO
+XawTableUnsetEdit (Widget w)
+#else
+     XawTableUnsetEdit(w)
+     Widget w;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  char* label;
+  XawTableCell cell;
+  
+  if (XawTableIsEditManaged(w))
+  {
+    tw->table.no_redraw++;
+    UNMANAGE_EDIT(tw);
+    tw->table.no_redraw--;
+    
+    XtVaGetValues(EDIT(w), "string", &label, NULL);
+
+    label = CopyOnlyPrintable(label);
+
+    cell = (XawTableCell)
+      get_cell(STUFF(tw),tw->table.edit_row, tw->table.edit_column);
+
+    if (!streq(label,CELL(label))) 
+      XawTableSetLabel(w, tw->table.edit_row, tw->table.edit_column, label);
+
+    XtFree(label); /* XtMalloc in CopyOnlyPrintable */
+  }
+}
+
+void 
+#ifdef Xraw_NEED_PROTO
+XawTableSetEdit (Widget w, int row, int column)
+#else
+     XawTableSetEdit(w, row, column)
+     Widget w;
+     int    row;
+     int    column;
+#endif
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell     cell;
+
+  if (IsEditInRowColumn(tw, row, column) || STUFF(tw) == NULL)
+    return;
+
+  if ((ROWS(tw) < 1) || (COLUMNS(tw) < 1) ||
+      (row != InRange(row, 0, ROWS(tw)-1)) || 
+      (column != InRange(column, 0, COLUMNS(tw)-1)))
+  {
+    String subs[3];
+    Cardinal num_subs = 3;
+    sprintf(subs[0], "%5d", row);
+    sprintf(subs[1], "%5d", column);
+    subs[2] = w->core.name;
+    XtAppWarningMsg(XtWidgetToApplicationContext(w),
+		    "SetEdit", "XawTableSetEdit","XawToolkitError",
+"XawTableSetEdit\nIncorrect value of rows or columns (%s,%s) in TableWidget '%s' ",
+		    subs, &num_subs);
+    return;
+  }
+  
+  XawTableUnsetEdit(w);
+
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+  
+  if (CELL(label) == NULL)
+    XtVaSetValues(EDIT(tw), "string", Dummy, NULL);
+  else
+    XtVaSetValues(EDIT(tw), "string", CELL(label), NULL);
+    
+  tw->table.edit_row    = row;
+  tw->table.edit_column = column;
+
+  MoveEditCell (tw, tw->table.edit_row, tw->table.edit_column); 
+
+  MANAGE_EDIT(tw);
+}
+
+/******************************************************************
+ *
+ *                              Actions
+ *
+ ******************************************************************/
+
+static void HighlightCell(w,event,params,num_params)
+     Widget w;
+     XEvent *event;
+     String *params;         
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell cell;
+  int row, column;
+  Position x,y;
+  Time tm;
+
+  if (!tw->table.editable)
+    return;
+    
+  if (*num_params == 2) 
+  {
+    row    = atoi(params[0]);
+    column = atoi(params[1]);
+  }
+  else if (event != (XEvent*)NULL) 
+  {
+    ExtractPosition(event, &x, &y , &tm);
+    if (ExtractCell(tw, x, y, &row, &column))
+      return ;
+  }
+  else
+  {
+    return;
+  }
+  
+  cell = (XawTableCell) get_cell (STUFF(tw), row, column);
+
+  if (CELL(highlight))
+    return ;
+
+  CELL(highlight) = True;
+
+  x = GetX(tw,column);
+  y = GetY(tw,row);
+  
+  PaintLabel(w, row, column, x, y, cell);
+  XFlush(XtDisplay(w));
+}
+
+/* ARGSUSED */
+static void UnhighlightCell(w,event,params,num_params)
+     Widget w;
+     XEvent *event;
+     String *params;         /* unused */
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  XawTableCell      cell;
+  int          row, column;
+  Position     x,y;
+  Time         tm;
+  unsigned int width;
+  unsigned int height;
+  
+  if (!tw->table.editable)
+    return;
+    
+  if (*num_params == 2) 
+  {
+    row    = atoi(params[0]);
+    column = atoi(params[1]);
+  }
+  else if (event != (XEvent*)NULL) 
+  {
+    ExtractPosition(event, &x, &y , &tm);
+    if (ExtractCell(tw, x, y, &row, &column))
+      return ;
+  }
+  else
+  {
+    return;
+  }
+  
+  cell = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  if (!CELL(highlight))
+        return ;
+
+  CELL(highlight) = False;
+
+  width   = (unsigned int) COLUMN_WIDTH(tw, column)  +
+    2 * tw->table.label_shadow_thickness;
+  height  = (unsigned int) tw->table.row_height +
+    2 * tw->table.label_shadow_thickness;
+
+  XClearArea(XtDisplay(w), XtWindow(w),
+	     (int)GetX(tw,column),
+	     (int)GetY(tw,row),
+	     width, height, FALSE);
+
+  PaintLabel(w, row, column, x, y, cell);
+  
+  XFlush(XtDisplay(w));
+
+}
+
+/* ARGSUSED */
+static void WhatCell(w,event,params,num_params)
+     Widget w;
+     XEvent *event;
+     String *params;         /* unused */
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  Position x,y;
+  int row, column;
+  XawTableCallbackStruct callback_str;
+  XawTableCell cell;
+  Time tm;
+  
+  if (event->type != ButtonPress && event->type != ButtonRelease)
+    return;
+
+  ExtractPosition(event, &x, &y , &tm);
+
+  if (ExtractCell(tw, x, y, &row, &column))
+    return ;
+
+  cell = (XawTableCell) get_cell (STUFF(tw), row, column);
+
+  callback_str.reason   = XawTABLE_WHAT_CELL;
+  callback_str.event    = event;
+  callback_str.old_cell = cell;
+  callback_str.new_cell = cell;
+  callback_str.row      = row;
+  callback_str.column   = column;
+  callback_str.do_it    = True;
+
+  DO_CALLBACK(w, XtNwhatCell, callback_str);
+}
+
+/* ARGSUSED */
+static void KeyReturn(w, event, params, num_params)
+     Widget w;
+     XEvent *event;
+     String *params;           /* unused */
+     Cardinal *num_params;     /* unused */
+{
+  Widget tw;
+  KeySym  ksSymbol;
+  
+  ksSymbol = XtGetActionKeysym(event, (Modifiers*)NULL);
+
+  if (ksSymbol == XK_Return || ksSymbol == XK_Linefeed)
+  {
+    XtVaGetValues(w, XtNuserData, &tw, NULL);
+    XawTableUnsetEdit(tw);
+  }
+  
+}
+
+static Atom FetchAtom(w, name)
+    Widget w;
+    String name;
+{
+    Atom a;
+    XrmValue source, dest;
+
+    source.size = strlen(name)+1;
+    source.addr = name;
+    dest.size = sizeof(Atom);
+    dest.addr = (XtPointer) &a;
+	
+    (void) XtConvertAndStore(w, XtRString, &source, XtRAtom, &dest);
+    return a;
+}
+    
+/* ARGSUSED */
+static Boolean DeliverSelection(w, selection, target,
+	type, value, length, format)
+    Widget w;
+    Atom *selection, *target, *type;
+    XtPointer *value;
+    unsigned long *length;
+    int *format;
+{
+    XawTableWidget tw = (XawTableWidget) w;
+    static Atom targets = 0;
+
+    if (targets == 0) {
+	targets = FetchAtom(w, "TARGETS");
+    }
+
+    if (*target == targets) {
+	*type = XA_ATOM;
+	*value = (XtPointer) CALLOC(1, Atom);
+	*(Atom *) *value = XA_STRING;
+	*length = 1;
+	*format = 32;
+	return TRUE;
+    }
+
+    if (*target == XA_STRING) {
+	*type = XA_STRING;
+	*value = (XtPointer) XtNewString(tw->table.cell_own->label);
+	*length = tw->table.cell_own->label_len;
+	*format = 8;
+	return TRUE;
+    }
+    
+    return FALSE;    
+}
+
+/* ARGSUSED */
+static void LoseSelection(w, selection)
+    Widget w;
+    Atom *selection;
+{
+  XawTableWidget tw = (XawTableWidget) w;
+  XawTableCell cell;
+  int row, column;
+  int x,y;
+  unsigned int width, height;
+
+  cell = tw->table.cell_own;
+  tw->table.cell_own = (XawTableCell)NULL;
+  
+  if (!CELL(highlight)) 
+    return ;
+
+  get_cell_positions(cell, &row, &column);
+  
+  CELL(highlight) = False;
+
+  x      = GetX(tw,column) + tw->table.label_shadow_thickness;
+  y      = GetY(tw,row) + tw->table.label_shadow_thickness;
+  width  = (unsigned int) COLUMN_WIDTH(tw, column);
+  height = (unsigned int) tw->table.row_height;
+    
+  XClearArea(XtDisplay(w), XtWindow(w), x, y, width, height, FALSE);
+  (void)PaintCell(w, row, column, (XtPointer)cell, (XtPointer)NULL);
+
+  XFlush(XtDisplay(w));
+}
+
+static int GetCutBufferNumber();
+
+static void StoreBuffer(w, event, params, num_params)
+     Widget w;
+     XEvent *event;
+     String *params;        /* selections in precedence order */
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  Position    x, y;
+  int         row, column;
+  int         i, buffer;
+  Time        tm;
+  Atom        selection;
+
+  if (!tw->table.editable)
+    return;
+  
+  if (event->type != ButtonPress && event->type != ButtonRelease)
+    return;
+  
+  ExtractPosition(event, &x, &y ,&tm);
+
+  if (ExtractCell(tw, x, y, &row, &column))
+    return ;
+
+  if (tw->table.cell_own != (XawTableCell)NULL)
+    LoseSelection(w, (Atom*)NULL);
+  
+  tw->table.cell_own = (XawTableCell)get_cell(STUFF(tw), row, column);
+
+  for(i=0; i<(int)*num_params; i++) {
+    selection = FetchAtom(w, *(String *)(params+i));
+
+    buffer =  GetCutBufferNumber(selection);
+
+    if (buffer >= 0) {
+      if (buffer == 0) {
+
+#define Create(buffer) \
+      XChangeProperty(XtDisplay(w), DefaultRootWindow(XtDisplay(w)),\
+		      buffer,XA_STRING, 8,PropModeAppend, NULL, 0)
+
+        Create(XA_CUT_BUFFER0);
+        Create(XA_CUT_BUFFER1);
+        Create(XA_CUT_BUFFER2);
+        Create(XA_CUT_BUFFER3);
+        Create(XA_CUT_BUFFER4);
+        Create(XA_CUT_BUFFER5);
+        Create(XA_CUT_BUFFER6);
+        Create(XA_CUT_BUFFER7);
+#undef Create
+
+        XRotateBuffers(XtDisplay(w), 1);
+      }
+    
+      XStoreBuffer(XtDisplay(w), tw->table.cell_own->label,
+		   (int)MIN(tw->table.cell_own->label_len, MAXCUT), buffer);
+    
+    } else {
+      tw->table.selections[tw->table.num_selections++] = selection;
+
+      XtOwnSelection (w, selection, tm,
+		      DeliverSelection, LoseSelection,
+		      (XtSelectionDoneProc) NULL);
+    }
+  }
+}
+
+
+/* ARGSUSED */
+static void  CallEdit(w,event,params,num_params)
+     Widget w;
+     XEvent *event;
+     String *params;         /* unused */
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  Position x,y;
+  int row, column;
+  Time tm;
+
+  if (!tw->table.editable)
+    return;
+    
+  ExtractPosition(event, &x, &y , &tm);
+
+  if (ExtractCell(tw, x, y, &row, &column))
+    return ;
+
+  XawTableSetEdit(w, row, column);
+}
+
+    
+
+typedef struct {
+  Widget         w;
+  Atom          *selections;
+  Time           time;
+  int            row;
+  int            column;
+  int            count;
+  int            num;
+}RowColumn;
+
+static void GetProc();
+
+static void GetSelection (rc)
+  RowColumn *rc;
+{
+  Atom selection;
+  int buffer;
+  int nbytes;
+  char *label;
+  
+  selection = *(rc->selections + rc->num);
+
+  if (rc->num < rc->count){
+
+    buffer = GetCutBufferNumber(selection);
+
+    if (buffer >= 0) {
+      label = XFetchBuffer(XtDisplay(rc->w), &nbytes, buffer);
+      XawTableSetLabel(rc->w, rc->row, rc->column, label);
+      XtFree((XtPointer)rc->selections);
+      XtFree((XtPointer)rc);
+    }else {
+      XtGetSelectionValue(rc->w, selection, XA_STRING, GetProc,
+			  (XtPointer)rc, rc->time);
+      rc->num++;
+    }
+  }
+}
+
+/* ARGSUSED */
+static void GetProc(w, client_data, selection,
+			    type, value, length, format)
+     Widget w;
+     XtPointer client_data;
+     Atom *selection;
+     Atom *type;
+     XtPointer value;
+     unsigned long *length;
+     int *format;
+{
+  RowColumn *rc = (RowColumn*)client_data;
+    
+  if ((*type == XA_STRING) && (value != NULL)) {
+    XawTableSetLabel(w, rc->row, rc->column, (char*)value);
+    XtFree((XtPointer)value);
+    XtFree((XtPointer)client_data);
+  }else {
+    GetSelection(rc);
+  }
+
+}
+
+static void InsertSelection(w, event, params, num_params)
+     Widget w;
+     XEvent *event;
+     String *params;        /* selections in precedence order */
+     Cardinal *num_params;
+{
+  XawTableWidget tw = (XawTableWidget)w;
+  Position    x,y;
+  int         row, column;
+  RowColumn  *rc;
+  Time        tm;
+
+  if (!tw->table.editable)
+    return;
+  
+  if (event->type != ButtonPress && event->type != ButtonRelease)
+    return;
+
+  ExtractPosition(event, &x, &y ,&tm);
+  
+  if (ExtractCell(tw, x, y, &row, &column))
+    return ;
+
+  if (*num_params > 0) {
+      
+    rc = XtNew(RowColumn);
+
+    rc->time       = tm;
+    rc->w          = w;
+    rc->row        = row;
+    rc->column     = column;
+    rc->count      = (int)*num_params;
+    rc->num        = 0;
+
+    if (*num_params > (Cardinal)0) {
+      rc->selections = CALLOC(*num_params, Atom);
+      XmuInternStrings(XtDisplay(w), params, *num_params, rc->selections);
+    } else {
+      rc->selections = XtNew(Atom);
+      *rc->selections = FetchAtom(w, "PRIMARY");
+    }
+    GetSelection(rc);
+  }
+}
+
+
+static int GetCutBufferNumber(atom)
+     register Atom atom;
+{
+  if (atom == XA_CUT_BUFFER0) return(0);
+  if (atom == XA_CUT_BUFFER1) return(1);
+  if (atom == XA_CUT_BUFFER2) return(2);
+  if (atom == XA_CUT_BUFFER3) return(3);
+  if (atom == XA_CUT_BUFFER4) return(4);
+  if (atom == XA_CUT_BUFFER5) return(5);
+  if (atom == XA_CUT_BUFFER6) return(6);
+  if (atom == XA_CUT_BUFFER7) return(7);
+  return(-1);
+}
+
+
+/* ARGSUSED */
+static void DoingNothing(w, event, params, num_params)
+     Widget w;
+     XEvent *event;
+     String *params;       
+     Cardinal *num_params;
+{
+  /* doing nothing */
+}
+
diff --git a/vendor/x11iraf/obm/ObmW/zz/Table.h b/vendor/x11iraf/obm/ObmW/zz/Table.h
new file mode 100644
index 00000000..4c7ab5cf
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Table.h
@@ -0,0 +1,539 @@
+/***********************************************************************
+  
+                             Table widget
+		   Copyright by Vladimir T. Romanovski
+			 All rights reserved.
+
+This library is designed  for  free,  non-commercial  software  creation.
+It is changeable and can be improved. The author would greatly appreciate
+any  advice, new  components  and  patches  of  the  existing  programs.
+Commercial  usage is  also  possible  with  participation of the author.
+
+                      romsky@hp1.oea.ihep.su (Russia)
+                      romsky@munin.ucsf.edu  (USA)
+	
+*************************************************************************/
+
+#ifndef _XawTable_h
+#define _XawTable_h
+
+#include <X11/Xmu/Converters.h>
+
+#include <X11/Xraw/Simple.h>
+#include <X11/Xraw/XawInit.h>
+
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           New Resources                               #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+#ifndef XawTextEncoding8bit
+#define XawTextEncoding8bit     0
+#endif
+#ifndef XawTextEncodingChar2b
+#define XawTextEncodingChar2b   1
+#endif
+
+#ifndef XtNliteral
+#define XtNliteral		"literal"
+#endif
+
+#ifndef XtNrows
+#define XtNrows      	     	"rows"
+#endif
+
+#ifndef XtNcolumns
+#define XtNcolumns		"columns"
+#endif
+
+
+#ifndef XtNmaskNumber
+#define XtNmaskNumber		"maskNumber"
+#endif
+
+#ifndef XtNrowOriented
+#define XtNrowOriented     	"rowOriented"
+#endif
+
+#ifndef XtNeditForeground
+#define XtNeditForeground  	"editForeground"
+#endif
+
+#ifndef XtNeditBackground
+#define XtNeditBackground  	"editBackground"
+#endif
+
+#ifndef XtNcolumnForeground
+#define XtNcolumnForeground  	"columnForeground"
+#endif
+
+#ifndef XtNrowForeground
+#define XtNrowForeground     	"rowForeground"
+#endif
+
+#ifndef XtNvetricalScroll
+#define XtNvetricalScroll     	"vetricalScroll"
+#endif
+
+#ifndef XtNhorizontalScroll
+#define XtNhorizontalScroll     "horizontalScroll"
+#endif
+
+#ifndef XtNcolumnsWidth
+#define XtNcolumnsWidth     	"columnsWidth"
+#endif
+
+#ifndef XtNrowHeight
+#define XtNrowHeight     	"rowHeight"
+#endif
+
+#ifndef XtNdefaultWidth
+#define XtNdefaultWidth     	"defaultWidth"
+#endif
+
+#ifndef XtNeditable
+#define XtNeditable     	"editable"
+#endif
+
+#ifndef XtNliteralWidth
+#define XtNliteralWidth     	"literalWidth"
+#endif
+
+#ifndef XtNtableMargin
+#define XtNtableMargin      	"tableMargin"
+#endif
+
+#ifndef XtNrowMargin
+#define XtNrowMargin      	"rowMargin"
+#endif
+
+#ifndef XtNcolumnMargin
+#define XtNcolumnMargin      	"columnMargin"
+#endif
+
+#ifndef XtNlabelShadowWidth
+#define XtNlabelShadowWidth 	"labelShadowWidth"
+#endif
+
+#ifndef XtNencoding
+#define XtNencoding       	"encoding"
+#endif
+
+
+
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           New Resource Classes                        #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+#ifndef XtCLiteral
+#define XtCLiteral		"Literal"
+#endif
+
+#ifndef XtCColumns
+#define XtCColumns		"Columns"
+#endif
+
+#ifndef XtCMaskNumber
+#define XtCMaskNumber     	"MaskNumber"
+#endif
+
+#ifndef XtCScroll
+#define XtCScroll     		"Scroll"
+#endif
+
+#ifndef XtCColumnsWidth
+#define XtCColumnsWidth     	"ColumnsWidth"
+#endif
+
+#ifndef XtCRowHeight
+#define XtCRowHeight     	"RowHeight"
+#endif
+
+#ifndef XtCDefaultWidth
+#define XtCDefaultWidth     	"DefaultWidth"
+#endif
+
+#ifndef XtCEditable
+#define XtCEditable     	"Editable"
+#endif
+
+#ifndef XtCLiteralWidth
+#define XtCLiteralWidth     	"LiteralWidth"
+#endif
+
+#ifndef XtCRows
+#define XtCRows           	"Rows"
+#endif
+
+#ifndef XtCTableMargin
+#define XtCTableMargin      	"TableMargin"
+#endif
+
+#ifndef XtCRowMargin
+#define XtCRowMargin      	"RowMargin"
+#endif
+
+#ifndef XtCColumnMargin
+#define XtCColumnMargin      	"ColumnMargin"
+#endif
+
+#ifndef XtCLabelShadowWidth
+#define XtCLabelShadowWidth 	"LabelShadowWidth"
+#endif
+
+#ifndef XtCEncoding
+#define XtCEncoding       	"Encoding"
+#endif
+
+
+
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           New Resource Types                          #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+#ifndef XtRColumnsWidth
+#define XtRColumnsWidth     	"ColumnsWidth"
+#endif
+
+#ifndef XtCRowOriented
+#define XtCRowOriented     	"RowOriented"
+#endif
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Allowance Callbacks                         #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+#ifndef XtNallowAddColumn
+#define XtNallowAddColumn     	        "allowAddColumn"
+#endif
+
+#ifndef XtNallowAddRow
+#define XtNallowAddRow     		"allowAddRow"
+#endif
+
+#ifndef XtNallowDeleteColumn
+#define XtNallowDeleteColumn     	"allowDeleteColumn"
+#endif
+
+#ifndef XtNallowDeleteRow
+#define XtNallowDeleteRow     	        "allowDeleteRow"
+#endif
+
+#ifndef XtNallowDeleteTable
+#define XtNallowDeleteTable     	"allowDeleteTable"
+#endif
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Information Callbacks                       #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+#ifndef XtNaddColumn
+#define XtNaddColumn     	"addColumn"
+#endif
+
+#ifndef XtNaddRow
+#define XtNaddRow     		"addRow"
+#endif
+
+#ifndef XtNchangedCell
+#define XtNchangedCell     	"changedCell"
+#endif
+
+#ifndef XtNchangedColumnWidth
+#define XtNchangedColumnWidth   "changedColumnWidth"
+#endif
+
+#ifndef XtNchangedRowHeight
+#define XtNchangedRowHeight     "changedRowHeight"
+#endif
+
+#ifndef XtNcreateTable
+#define XtNcreateTable     	"createTable"
+#endif
+
+#ifndef XtNdeleteColumn
+#define XtNdeleteColumn     	"deleteColumn"
+#endif
+
+#ifndef XtNdeleteRow
+#define XtNdeleteRow     	"deleteRow"
+#endif
+
+#ifndef XtNdeleteTable
+#define XtNdeleteTable     	"deleteTable"
+#endif
+
+#ifndef XtNwhatCell
+#define XtNwhatCell     	"whatCell"
+#endif
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           XawTableCell & XawTableColumn               #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+typedef struct _XawTableCellRec   *XawTableCell;    /* opaque to outside */
+
+typedef struct _XawTableColumnRec *XawTableColumn;  /* opaque to outside */
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Bypass Routine and Direction Types          #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+typedef Boolean (*XawTableProc)     Xraw_PROTO((Widget, 
+						int, 
+						int, 
+						XawTableCell, 
+						XtPointer));
+enum XawTableBypassDirection{
+  XawTABLE_RIGHT_DOWN,
+  XawTABLE_DOWN_RIGHT
+};
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Callback Reasons                            #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+enum XawTableReasons{
+  XawTABLE_ALLOW_ADD_COLUMN = Xraw_TABLE,
+  XawTABLE_ALLOW_ADD_ROW,
+  XawTABLE_ALLOW_CREATE_TABLE,
+  XawTABLE_ALLOW_DELETE_COLUMN,
+  XawTABLE_ALLOW_DELETE_ROW,
+  XawTABLE_ALLOW_DELETE_TABLE,
+
+  XawTABLE_ADD_COLUMN,
+  XawTABLE_ADD_ROW,
+  XawTABLE_CHANGED_CELL,
+  XawTABLE_CHANGED_COLUMN_WIDTH,
+  XawTABLE_CHANGED_ROW_HEIGHT,
+  XawTABLE_CREATE_TABLE,
+  XawTABLE_DELETE_COLUMN,
+  XawTABLE_DELETE_ROW,
+  XawTABLE_DELETE_TABLE,
+  XawTABLE_WHAT_CELL
+};
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Callback Structure                          #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+typedef struct {
+  int           reason;
+  XEvent       *event;
+  XawTableCell  old_cell;
+  XawTableCell  new_cell;
+  int           row;
+  int           column;
+  Boolean       do_it;
+}XawTableCallbackStruct;
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Layout Control Routine                      #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern void XawTableDoLayout            Xraw_PROTO((Widget w,
+						    Boolean do_layout));
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Stuff Routines                              #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern int XawTableSetNewSize 		Xraw_PROTO((Widget w, 
+						    int  rows,
+						    int  columns));
+
+extern void XawTableGetSize             Xraw_PROTO((Widget w,
+						    int *rows,
+						    int *columns));
+
+     
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Row Routines                                #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern int XawTablePrependRow           Xraw_PROTO((Widget w));
+     
+extern int XawTableAppendRow 		Xraw_PROTO((Widget w));
+     
+extern int XawTableInsertRow            Xraw_PROTO((Widget w, int row));
+     
+extern int XawTableDeleteRow            Xraw_PROTO((Widget w, int row));
+     
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Column Routines                             #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern int XawTablePrependColumn        Xraw_PROTO((Widget w, int width));
+     
+extern int XawTableAppendColumn         Xraw_PROTO((Widget w, int width));
+     
+extern int XawTableInsertColumn         Xraw_PROTO((Widget w, 
+						    int column,
+						    int width));
+     
+extern int XawTableDeleteColumn 	Xraw_PROTO((Widget w, int column));
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Set Label Routines                          #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern char *XawTableGetLabelByCell 	Xraw_PROTO((XawTableCell cell));
+     
+extern char *XawTableGetLabelByPosition Xraw_PROTO((Widget w,
+						     int row,
+						     int column));
+     
+extern int XawTableSetLabel 		Xraw_PROTO((Widget w,
+						     int row,
+						     int column,
+						     char *label));
+     
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Bypass Routines                             #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern Boolean XawTableWalk 		Xraw_PROTO((Widget w,
+						     XawTableProc proc,
+						     int b_row,
+						     int e_row,
+						     int b_column,
+						     int e_column,
+						     int direction,
+						     int *row, int *column,
+						     XtPointer client_data));
+     
+extern Boolean XawTableSearchLabel 	Xraw_PROTO((Widget w,
+						     char *name,
+						     int *row,
+						     int *column));
+
+     
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Edit Cell Routines                          #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern Boolean XawTableIsEditManaged 	Xraw_PROTO((Widget w));
+
+extern void XawTableGetEditPosition 	Xraw_PROTO((Widget w,
+						     int *row,
+						     int *column));
+     
+extern void XawTableUnsetEdit 		Xraw_PROTO((Widget w));
+
+extern void XawTableSetEdit 		Xraw_PROTO((Widget w,
+						     int row,
+						     int column));
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Set Colour Routines                         #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern int XawTableSetCellBackground 	Xraw_PROTO((Widget w,
+						     int   row,
+						     int   column,
+						     Pixel background));
+     
+extern int XawTableSetCellForeground 	Xraw_PROTO((Widget w,
+						     int   row,
+						     int   column,
+						     Pixel foreground));
+
+extern int XawTableSetCellDefaultColours 	Xraw_PROTO((Widget w,
+						     int   row,
+						     int   column));
+
+extern int XawTableSetCellColours 	Xraw_PROTO((Widget w,
+						     int   row,
+						     int   column,
+						     Pixel foreground,
+						     Pixel background));
+     
+
+extern void XawTableGetCellColours    	Xraw_PROTO((Widget w,
+						     int   row,
+						     int   column,
+						     Pixel *foreground,
+						     Pixel *background));
+     
+extern void XawTableGetCellColoursByCell 	Xraw_PROTO((Widget w,
+						     XawTableCell cell,
+						     Pixel *foreground,
+						     Pixel *background));
+     
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Column Deta                                 #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern void XawTableSetColumnJustify       Xraw_PROTO((Widget w,
+						        int   column,
+						        XtJustify justify));
+
+extern XtJustify XawTableGetColumnJustify  Xraw_PROTO((Widget w,
+						        int   column));
+
+extern void XawTableSetColumnWidth         Xraw_PROTO((Widget w,
+						        int   column,
+						        int   width));
+
+extern int XawTableGetColumnWidth          Xraw_PROTO((Widget w,
+						        int   column));
+
+extern int XawTableGetColumnPixelWidth          Xraw_PROTO((Widget w,
+						        int   column));
+
+
+
+/*#########################################################################*/
+/*#                                                                       #*/
+/*#                           Widget Class Pointer                        #*/
+/*#                                                                       #*/
+/*#########################################################################*/
+extern WidgetClass tableWidgetClass;
+
+typedef struct _TableClassRec *XawTableWidgetClass;
+typedef struct _TableRec      *XawTableWidget;
+
+
+#endif /* _XawTable_h */
+/* DON'T ADD STUFF AFTER THIS #endif */
diff --git a/vendor/x11iraf/obm/ObmW/zz/Table3d.c b/vendor/x11iraf/obm/ObmW/zz/Table3d.c
new file mode 100644
index 00000000..085b2cac
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Table3d.c
@@ -0,0 +1,924 @@
+#include <X11/Xraw/3d.h>
+#include <X11/Xraw/color.h>
+
+#define WHITE WhitePixelOfScreen
+#define BLACK BlackPixelOfScreen
+#define SWITCH(a,b) (top_or_bottom == TOP ? a : b)
+
+#define DEPTH_SCREEN(w) DefaultDepthOfScreen(XtScreen(w))
+
+#ifdef MIN
+#undef MIN
+#endif
+#define MIN(a,b) ((a)<(b) ? (a) : (b))
+
+#ifdef MAX
+#undef MAX
+#endif
+#define MAX(a,b) ((a) > (b) ? (a) : (b))
+
+#define TOP_VALUE_RATIO (1.3)
+#define BOT_VALUE_RATIO (0.6)
+#define ARM_VALUE_RATIO (0.85)
+
+#define Top_Cash (1<<0L)
+#define Bot_Cash (1<<1L)
+#define Arm_Cash (1<<2L)
+
+typedef struct _ColorCashRec {
+  struct _ColorCashRec* nxt;
+  XColor         col;
+  RGB            rgb[1];
+  HSV            hsv[1];
+  RGB            top[1];
+  RGB            bot[1];
+  RGB            arm[1];
+  unsigned int   set; 
+}ColorCashRec, *ColorCash;
+
+static ColorCashRec* color_cash = NULL;
+static void GetTopShadow();
+
+
+static void GetTopShadow(trom ,to)
+     XColor* trom;
+     XColor* to;
+{
+  ColorCashRec* cash;
+  float         save;
+  
+  for (cash = color_cash; cash != NULL; cash = cash->nxt)
+  {
+    if (cash->col.red   == trom->red &&
+	cash->col.green == trom->green &&
+	cash->col.blue  == trom->blue)
+    {
+      if (cash->set & Top_Cash)
+      {
+	to->red   = cash->top[0].r;
+	to->green = cash->top[0].g;
+	to->blue  = cash->top[0].b;
+      }
+      else
+      {
+	save         = cash->hsv[0].v;
+	cash->hsv[0].v *= TOP_VALUE_RATIO;
+	cash->hsv[0].v  = MIN(cash->hsv[0].v, 1.0);
+	
+	HSVToRGB((HSV*)cash->hsv, (RGB*)cash->top);
+
+	cash->hsv[0].v  = save;
+	
+	to->red   = cash->top[0].r;
+	to->green = cash->top[0].g;
+	to->blue  = cash->top[0].b;
+
+	cash->set |= Top_Cash;
+      }
+
+      return;
+    }
+  }
+
+  cash =  XtNew (ColorCashRec);
+
+  cash->col.red   = cash->rgb[0].r = trom->red;
+  cash->col.green = cash->rgb[0].g = trom->green;
+  cash->col.blue  = cash->rgb[0].b = trom->blue;
+  
+  RGBToHSV((RGB*)cash->rgb, (HSV*)cash->hsv);
+
+  save         = cash->hsv[0].v;
+  cash->hsv[0].v *= TOP_VALUE_RATIO;
+  cash->hsv[0].v  = MIN(cash->hsv[0].v, 1.0);
+
+  HSVToRGB((HSV*)cash->hsv, (RGB*)cash->top);
+  
+  cash->hsv[0].v  = save;
+	
+  to->red   = cash->top[0].r;
+  to->green = cash->top[0].g;
+  to->blue  = cash->top[0].b;
+  
+  cash->set = Top_Cash;
+
+  cash->nxt  = color_cash;
+  color_cash = cash;
+}
+
+static void GetBotShadow(trom ,to)
+     XColor* trom;
+     XColor* to;
+{
+  ColorCashRec* cash;
+  float         save;
+  
+  for (cash = color_cash; cash != NULL; cash = cash->nxt)
+  {
+    if (cash->col.red   == trom->red &&
+	cash->col.green == trom->green &&
+	cash->col.blue  == trom->blue)
+    {
+      if (cash->set & Bot_Cash)
+      {
+	to->red   = cash->bot[0].r;
+	to->green = cash->bot[0].g;
+	to->blue  = cash->bot[0].b;
+      }
+      else
+      {
+	save         = cash->hsv[0].v;
+	cash->hsv[0].v *= BOT_VALUE_RATIO;
+	
+	HSVToRGB((HSV*)cash->hsv, (RGB*)cash->bot);
+
+	cash->hsv[0].v  = save;
+	
+	to->red   = cash->bot[0].r;
+	to->green = cash->bot[0].g;
+	to->blue  = cash->bot[0].b;
+
+	cash->set |= Bot_Cash;
+      }
+
+      return;
+    }
+  }
+
+  cash =  XtNew (ColorCashRec);
+
+  cash->col.red   = cash->rgb[0].r = trom->red;
+  cash->col.green = cash->rgb[0].g = trom->green;
+  cash->col.blue  = cash->rgb[0].b = trom->blue;
+  
+  RGBToHSV((RGB*)cash->rgb, (HSV*)cash->hsv);
+
+  save         = cash->hsv[0].v;
+  cash->hsv[0].v *= BOT_VALUE_RATIO;
+
+  HSVToRGB((HSV*)cash->hsv, (RGB*)cash->bot);
+  
+  cash->hsv[0].v  = save;
+	
+  to->red   = cash->bot[0].r;
+  to->green = cash->bot[0].g;
+  to->blue  = cash->bot[0].b;
+  
+  cash->set = Bot_Cash;
+
+  cash->nxt  = color_cash;
+  color_cash = cash;
+}
+
+static void GetArmShadow(trom ,to)
+     XColor* trom;
+     XColor* to;
+{
+  ColorCashRec* cash;
+  float         save;
+  
+  for (cash = color_cash; cash != NULL; cash = cash->nxt)
+  {
+    if (cash->col.red   == trom->red &&
+	cash->col.green == trom->green &&
+	cash->col.blue  == trom->blue)
+    {
+      if (cash->set & Arm_Cash)
+      {
+	to->red   = cash->arm[0].r;
+	to->green = cash->arm[0].g;
+	to->blue  = cash->arm[0].b;
+      }
+      else
+      {
+	save         = cash->hsv[0].v;
+	cash->hsv[0].v *= ARM_VALUE_RATIO;
+	
+	HSVToRGB((HSV*)cash->hsv, (RGB*)cash->arm);
+
+	cash->hsv[0].v  = save;
+	
+	to->red   = cash->arm[0].r;
+	to->green = cash->arm[0].g;
+	to->blue  = cash->arm[0].b;
+
+	cash->set |= Arm_Cash;
+      }
+
+      return;
+    }
+  }
+
+  cash =  XtNew (ColorCashRec);
+
+  cash->col.red   = cash->rgb[0].r = trom->red;
+  cash->col.green = cash->rgb[0].g = trom->green;
+  cash->col.blue  = cash->rgb[0].b = trom->blue;
+  
+  RGBToHSV((RGB*)cash->rgb, (HSV*)cash->hsv);
+
+  save         = cash->hsv[0].v;
+  cash->hsv[0].v *= ARM_VALUE_RATIO;
+
+  HSVToRGB((HSV*)cash->hsv, (RGB*)cash->arm);
+  
+  cash->hsv[0].v  = save;
+	
+  to->red   = cash->arm[0].r;
+  to->green = cash->arm[0].g;
+  to->blue  = cash->arm[0].b;
+  
+  cash->set = Arm_Cash;
+
+  cash->nxt  = color_cash;
+  color_cash = cash;
+}
+
+unsigned int shadowpm_width = 8;
+unsigned int shadowpm_height= 8;
+
+static char shadow_bits[] = {
+    0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55};
+
+static char mtshadowpm_bits[] = {
+    0x92, 0x24, 0x49, 0x92, 0x24, 0x49, 0x92, 0x24};
+
+static char mbshadowpm_bits[] = {
+    0x6d, 0xdb, 0xb6, 0x6d, 0xdb, 0xb6, 0x6d, 0xdb};
+
+
+GC 
+#ifdef Xraw_NEED_PROTO
+AllocGCFromPixmap (Widget w, Pixmap pixmap)
+#else
+AllocGCFromPixmap(w, pixmap)
+     Widget w;
+     Pixmap pixmap;
+#endif
+{
+  XGCValues values;
+
+  if (pixmap != None) {
+    values.tile       = pixmap;
+    values.fill_style = FillTiled;
+    return XtGetGC(w, (XtGCMask)(GCTile | GCFillStyle), &values);
+  }
+
+  return XtGetGC(w, (XtGCMask)0, (XGCValues *)NULL);
+}
+
+GC 
+#ifdef Xraw_NEED_PROTO
+AllocGCFromPixel (Widget w, Pixel fore)
+#else
+AllocGCFromPixel(w, fore)
+     Widget w;
+     Pixel fore;
+#endif
+{
+  XGCValues values;
+  
+  values.foreground = fore;
+  return XtGetGC(w, GCForeground, &values);
+}
+
+static Pixmap Depth_1_ShadowPixmap (w, top_or_bottom)
+     Widget w;
+     int top_or_bottom;
+{
+  Screen  *scn = XtScreen (w);
+
+  if (DEPTH_SCREEN(w) == 1) 
+    return XCreatePixmapFromBitmapData (XtDisplay (w),
+					RootWindowOfScreen (scn),
+					shadow_bits,
+					shadowpm_width,
+					shadowpm_height,
+					SWITCH(BLACK (scn), WHITE (scn)),
+					SWITCH(WHITE (scn), BLACK (scn)),
+					1);
+  else
+    return None;
+}
+
+static Pixmap Depth_NOT_1_ShadowPixmap (w, colour, top_or_bottom)
+     Widget w;
+     Pixel colour;
+     int top_or_bottom;
+{
+  Display *dpy = XtDisplay (w);
+  Screen  *scn = XtScreen (w);
+  unsigned long fore;
+  unsigned long back;
+  char         *pm_data;
+  int           depth = DEPTH_SCREEN(w);
+  
+  if (depth == 1)
+    return None;
+  
+  if (colour == WHITE (scn) || colour == BLACK (scn)) {
+    fore    = WHITE (scn);
+    back    = BLACK (scn);
+    pm_data = SWITCH(mtshadowpm_bits, mbshadowpm_bits); 
+  } else {
+    fore    = colour;
+    back    = SWITCH (WHITE (scn), BLACK (scn));
+    pm_data = shadow_bits;
+  }
+
+  return XCreatePixmapFromBitmapData (dpy,
+				      RootWindowOfScreen (scn),
+				      pm_data,
+				      shadowpm_width,
+				      shadowpm_height,
+				      fore,
+				      back,
+				      depth);
+}
+
+Pixmap 
+#ifdef Xraw_NEED_PROTO
+CreateShadowPixmap (Widget w, Pixel colour, int top_or_bottom)
+#else
+CreateShadowPixmap (w, colour, top_or_bottom)
+     Widget w;
+     Pixel colour;
+     int top_or_bottom;
+#endif
+{
+  if (DEPTH_SCREEN(w) == 1)
+    return Depth_1_ShadowPixmap (w, top_or_bottom);
+  else
+    return Depth_NOT_1_ShadowPixmap (w, colour, top_or_bottom);
+}
+
+#define _MIN(x,y) (unsigned short) ((x) < (y)) ? (x) : (y)
+#define _MAX(x,y) (unsigned short) ((x) < (y)) ? (y) : (x)
+
+
+Boolean 
+#ifdef Xraw_NEED_PROTO
+AllocShadowPixel (
+     Widget w,
+     Pixel  base,
+     int    brightness,   
+     Pixel *result)
+#else
+AllocShadowPixel (w, base, brightness, result)
+     Widget w;
+     Pixel  base;
+     int    brightness;   
+     Pixel *result;   /* RETURN */
+#endif
+{
+  XColor         set;
+  XColor         get;
+  double         mult;
+  Colormap       cmap= ((CoreWidget)w)->core.colormap;
+  unsigned short red;
+  unsigned short green;
+  unsigned short blue; 
+  
+  get.pixel = base;
+  XQueryColor (XtDisplay (w), cmap, &get);
+  mult = (double)(100 + brightness) / ((double) 100.0);
+
+  red   = mult * (double)get.red;
+  green = mult * (double)get.green;
+  blue  = mult * (double)get.blue;
+
+  set.red   = _MAX(0,_MIN (65535, red));
+  set.green = _MAX(0,_MIN (65535, green));
+  set.blue  = _MAX(0,_MIN (65535, blue));
+
+#define EQ(field) (set.field == get.field)  
+  if (EQ(red) && EQ(green) && EQ(blue))
+#undef EQ  
+    return False;
+
+  if (XAllocColor (XtDisplay (w), cmap, &set) != 0) {
+    *result = set.pixel;
+    return True;
+  } else
+    return False;
+}
+
+GC 
+#ifdef Xraw_NEED_PROTO
+MakeGC (Widget w,
+	Pixel base,
+	int brightness,
+	Boolean pseudo,
+	int top_or_bottom)
+#else
+MakeGC(w, base, brightness, pseudo, top_or_bottom)
+     Widget w;
+     Pixel base;
+     int brightness;
+     Boolean pseudo;
+     int top_or_bottom;
+#endif
+{
+  Pixel fore;
+  Pixmap tile;
+
+  if (DEPTH_SCREEN(w) > 1)  {
+    if (pseudo)     {
+      tile = Depth_NOT_1_ShadowPixmap (w, base, top_or_bottom);
+      return AllocGCFromPixmap(w, tile);
+    }     else     {
+      if (AllocShadowPixel(w, base, brightness, &fore))      {
+	return AllocGCFromPixel(w, fore);
+      }  else       {
+	tile = Depth_NOT_1_ShadowPixmap (w, base, top_or_bottom);
+	return AllocGCFromPixmap(w, tile);
+      }
+    }
+  }  else   {
+    tile =  Depth_1_ShadowPixmap (w, top_or_bottom);
+    return AllocGCFromPixmap(w, tile);
+  }
+}
+
+GC 
+#ifdef Xraw_NEED_PROTO
+MakeTopShadowGC (Widget w, Pixel base)
+#else
+MakeTopShadowGC(w, base)
+     Widget w;
+     Pixel base;
+#endif
+{
+  Pixel fore;
+  Pixmap tile;
+
+  if (DEPTH_SCREEN(w) > 1)  {
+    if (TopShadowColor(w, base, &fore))      {
+      return AllocGCFromPixel(w, fore);
+    }  else       {
+      tile = Depth_NOT_1_ShadowPixmap (w, base, TOP);
+      return AllocGCFromPixmap(w, tile);
+    }
+  }  else   {
+    tile =  Depth_1_ShadowPixmap (w, TOP);
+    return AllocGCFromPixmap(w, tile);
+  }
+}
+
+
+GC 
+#ifdef Xraw_NEED_PROTO
+MakeBottomShadowGC (Widget w, Pixel base)
+#else
+MakeBottomShadowGC(w, base)
+     Widget w;
+     Pixel base;
+#endif
+{
+  Pixel fore;
+  Pixmap tile;
+
+  if (DEPTH_SCREEN(w) > 1)  {
+    if (BottomShadowColor(w, base, &fore))      {
+      return AllocGCFromPixel(w, fore);
+    }  else       {
+      tile = Depth_NOT_1_ShadowPixmap (w, base, BOTTOM);
+      return AllocGCFromPixmap(w, tile);
+    }
+  }  else   {
+    tile =  Depth_1_ShadowPixmap (w, BOTTOM);
+    return AllocGCFromPixmap(w, tile);
+  }
+}
+
+GC 
+#ifdef Xraw_NEED_PROTO
+MakeArmedGC (Widget w, Pixel base)
+#else
+MakeArmedGC(w, base)
+     Widget w;
+     Pixel base;
+#endif
+{
+  Pixel fore;
+  Pixmap tile;
+
+  if (DEPTH_SCREEN(w) > 1)  {
+    if (ArmedColor(w, base, &fore))      {
+      return AllocGCFromPixel(w, fore);
+    }  else       {
+      tile = Depth_NOT_1_ShadowPixmap (w, base, BOTTOM);
+      return AllocGCFromPixmap(w, tile);
+    }
+  }  else   {
+    tile =  Depth_1_ShadowPixmap (w, BOTTOM);
+    return AllocGCFromPixmap(w, tile);
+  }
+}
+
+void 
+#ifdef Xraw_NEED_PROTO
+XawDrawFrame (Widget       gw,
+	      Position     x,
+	      Position     y,
+	      Dimension    w,
+	      Dimension    h,
+	      XawFrameType frame_type,
+	      Dimension    t,
+	      GC           lightgc,
+	      GC           darkgc)
+#else
+XawDrawFrame (gw, x, y, w, h, frame_type, t, lightgc, darkgc)
+     Widget       gw;
+     Position     x;
+     Position     y;
+     Dimension    w; 
+     Dimension    h;
+     XawFrameType frame_type;
+     Dimension    t;
+     GC           lightgc;
+     GC           darkgc;
+#endif
+{
+  XPoint top_polygon[6];
+  XPoint bottom_polygon[6];
+  XPoint points[3];
+
+  
+  if (t == 0 || w == 0 || h == 0)
+    return;
+
+  if( lightgc == (GC)NULL ){
+    XtWarning("XawDrawFrame: lightgc is NULL in XawDrawFrame.");
+    return;
+  }
+    
+  if( darkgc == (GC)NULL ){
+    XtWarning("XawDrawFrame: darkgc is NULL in XawDrawFrame.");
+    return;
+  }
+
+  if (!XtIsRealized(gw)) {
+    XtWarning("XawDrawFrame: widget is not realized!!!");
+    return;
+  }
+  
+#define topPolygon(i,xx,yy)           \
+  top_polygon[i].x = (short) (xx);    \
+  top_polygon[i].y = (short) (yy)
+
+#define bottomPolygon(i,xx,yy)        \
+  bottom_polygon[i].x = (short) (xx); \
+  bottom_polygon[i].y = (short) (yy)
+  
+
+  if (frame_type == XawTACK && t <= 2)
+    frame_type = XawLEDGED;
+
+  switch (frame_type) {
+
+  case XawRAISED :
+  case XawSUNKEN :
+
+    topPolygon (0,x    ,y    ); bottomPolygon (0,x+w  ,y+h  ); 
+    topPolygon (1,x+w  ,y    ); bottomPolygon (1,x    ,y+h  );
+    topPolygon (2,x+w-t,y+t  ); bottomPolygon (2,x+t  ,y+h-t);
+    topPolygon (3,x+t  ,y+t  ); bottomPolygon (3,x+w-t,y+h-t);
+    topPolygon (4,x+t  ,y+h-t); bottomPolygon (4,x+w-t,y+t  );
+    topPolygon (5,x    ,y+h  ); bottomPolygon (5,x+w  ,y    );
+    
+    if (frame_type == XawSUNKEN) 
+    {
+      XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), darkgc,
+		   top_polygon, 6, Nonconvex, CoordModeOrigin);
+      
+      XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), lightgc,
+		   bottom_polygon, 6, Nonconvex, CoordModeOrigin);
+    } 
+    else if (frame_type == XawRAISED)
+    {
+      XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), lightgc,
+		   top_polygon, 6, Nonconvex, CoordModeOrigin);
+      XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), darkgc,
+		   bottom_polygon, 6, Nonconvex, CoordModeOrigin);
+    }
+    
+    break;
+
+  case XawTACK :
+
+    t -= 2;
+
+    topPolygon (0,x    ,y    ); bottomPolygon (0,x+w  ,y+h  ); 
+    topPolygon (1,x+w  ,y    ); bottomPolygon (1,x    ,y+h  );
+    topPolygon (2,x+w-t,y+t  ); bottomPolygon (2,x+t  ,y+h-t);
+    topPolygon (3,x+t  ,y+t  ); bottomPolygon (3,x+w-t,y+h-t);
+    topPolygon (4,x+t  ,y+h-t); bottomPolygon (4,x+w-t,y+t  );
+    topPolygon (5,x    ,y+h  ); bottomPolygon (5,x+w  ,y    );
+    
+    XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), lightgc,
+		 top_polygon, 6, Nonconvex, CoordModeOrigin);
+    XFillPolygon(XtDisplayOfObject(gw), XtWindowOfObject(gw), darkgc,
+		 bottom_polygon, 6, Nonconvex, CoordModeOrigin);
+    
+    points[0].x = x + t + 1;	points[0].y = y + h - t - 2;
+    points[1].x = x + t + 1;	points[1].y = y + t + 1;
+    points[2].x = x + w - t - 2;	points[2].y = y + t + 1;
+    
+    XDrawLines (XtDisplayOfObject(gw), XtWindowOfObject(gw), darkgc,
+		points, 3, CoordModeOrigin);
+    
+ /* points[0].x = x + t + 1;	        points[0].y = y + h -t - 1;   */
+    points[1].x = x + w - t - 2;	points[1].y = y + h - t - 2;
+ /* points[2].x = x + w - t - 1;	points[2].y = y + t + 1;      */
+    
+    XDrawLines (XtDisplayOfObject(gw), XtWindowOfObject(gw), lightgc,
+		points, 3, CoordModeOrigin);
+
+    break;
+
+  case XawLEDGED :
+
+    XawDrawFrame(gw, x, y, w, h, XawRAISED, t/2, lightgc, darkgc);
+    XawDrawFrame(gw, (Position)(x + t/2), (Position)(y + t/2),
+		 (Dimension)(w - 2 * (t/2)), (Dimension)(h - 2 * (t/2)),
+		 XawSUNKEN, t/2, lightgc, darkgc);
+    break;
+
+  case XawCHISELED :
+
+    XawDrawFrame(gw, x, y, w, h, XawSUNKEN, t/2, lightgc, darkgc);
+    XawDrawFrame(gw, (Position)(x + t/2),(Position)(y + t/2),
+		 (Dimension)(w - 2 * (t/2)), (Dimension)(h - 2 * (t/2)),
+		 XawRAISED, t/2, lightgc, darkgc);
+    break;
+
+  default :
+    break;
+
+  }
+
+#undef topPolygon
+#undef bottomPolygon
+}
+
+
+Boolean
+#ifdef Xraw_NEED_PROTO
+BottomShadowColor( Widget widget,
+		   Pixel  base,
+		   Pixel  *result)
+#else
+BottomShadowColor(widget, base, result)
+     Widget widget;
+     Pixel  base;
+     Pixel  *result;
+#endif
+{
+  Colormap colormap;
+  XColor color;
+  
+  if (XtIsWidget(widget))
+    colormap = widget->core.colormap;
+  else
+    colormap = (XtParent(widget))->core.colormap;
+
+  color.pixel = base;
+  
+  XQueryColor(XtDisplay(widget), colormap, &color);
+
+  GetBotShadow(&color, &color);
+  
+  if (XAllocColor (XtDisplay(widget), colormap, &color) != 0)
+  {
+    *result = color.pixel;
+    return True;
+  }
+  else
+  {
+    HSV hsv;
+    RGB rgb;
+
+    rgb.r = color.red;
+    rgb.g = color.green;
+    rgb.b = color.blue;
+
+    RGBToHSV ((RGB*)&rgb, (HSV*)&hsv);
+
+    if (hsv.v > 0.5)
+      *result = WhitePixelOfScreen(XtScreen (widget));
+    else
+      *result = BlackPixelOfScreen(XtScreen (widget));
+    return True;
+  }
+
+}
+
+Boolean
+#ifdef Xraw_NEED_PROTO
+TopShadowColor( Widget widget,
+	       Pixel  base,
+	       Pixel  *result)
+#else
+TopShadowColor(widget, base, result)
+     Widget widget;
+     Pixel  base;
+     Pixel  *result;
+#endif
+{
+  Colormap colormap;
+  XColor color;
+  
+  if (XtIsWidget(widget))
+    colormap = widget->core.colormap;
+  else
+    colormap = (XtParent(widget))->core.colormap;
+
+  color.pixel = base;
+  
+  XQueryColor(XtDisplay(widget), colormap, &color);
+
+  GetTopShadow(&color, &color);
+
+  if (XAllocColor (XtDisplay(widget), colormap, &color) != 0)
+  {
+    *result = color.pixel;
+    return True;
+  }
+  else
+  {
+    HSV hsv;
+    RGB rgb;
+
+    rgb.r = color.red;
+    rgb.g = color.green;
+    rgb.b = color.blue;
+
+    RGBToHSV ((RGB*)&rgb, (HSV*)&hsv);
+
+    if (hsv.v > 0.5)
+      *result = WhitePixelOfScreen(XtScreen (widget));
+    else
+      *result = BlackPixelOfScreen(XtScreen (widget));
+    return True;
+  }
+
+}
+
+Boolean
+#ifdef Xraw_NEED_PROTO
+ArmedColor( Widget widget,
+	       Pixel  base,
+	       Pixel  *result)
+#else
+ArmedColor(widget, base, result)
+     Widget widget;
+     Pixel  base;
+     Pixel  *result;
+#endif
+{
+  Colormap colormap;
+  XColor color;
+  
+  if (XtIsWidget(widget))
+    colormap = widget->core.colormap;
+  else
+    colormap = (XtParent(widget))->core.colormap;
+
+  color.pixel = base;
+  
+  XQueryColor(XtDisplay(widget), colormap, &color);
+
+  GetArmShadow(&color, &color);
+
+  if (XAllocColor (XtDisplay(widget), colormap, &color) != 0)
+  {
+    *result = color.pixel;
+    return True;
+  }
+  else
+  {
+    HSV hsv;
+    RGB rgb;
+
+    rgb.r = color.red;
+    rgb.g = color.green;
+    rgb.b = color.blue;
+
+    RGBToHSV ((RGB*)&rgb, (HSV*)&hsv);
+
+    if (hsv.v > 0.5)
+      *result = WhitePixelOfScreen(XtScreen (widget));
+    else
+      *result = BlackPixelOfScreen(XtScreen (widget));
+    return True;
+  }
+
+}
+
+
+
+#undef assign_max
+#undef assign_min
+
+
+void 
+#ifdef Xraw_NEED_PROTO
+DrawRhombus (
+	      Widget w,
+	      short x,
+	      short y,
+	      short g,
+	      short t,
+	      GC top_shadow_GC,
+	      GC foreground_gc,
+	      GC bottom_shadow_GC,
+	      Boolean state )
+#else
+DrawRhombus(w, x, y, g, t,
+	     top_shadow_GC, foreground_gc, bottom_shadow_GC, state)
+     Widget w;
+     short x;
+     short y;
+     short g;
+     short t;
+     GC top_shadow_GC;
+     GC foreground_gc;
+     GC bottom_shadow_GC;
+     Boolean state;
+#endif
+{
+  XPoint top_shade[6];
+  XPoint bot_shade[6];
+  XPoint center[4];
+
+#define topPolygon(i,a,b)    top_shade[i].x = a; top_shade[i].y = b
+#define bottomPolygon(i,a,b) bot_shade[i].x = a; bot_shade[i].y = b
+#define centerPolygon(i,a,b)    center[i].x = a;    center[i].y = b
+  
+  topPolygon(0, x-g  , y    );    bottomPolygon(0, x-g  , y    );
+  topPolygon(1, x-g+t, y    );    bottomPolygon(1, x-g+t, y    );
+  topPolygon(2, x    , y-g+t);    bottomPolygon(2, x    , y+g-t);
+  topPolygon(3, x+g-t, y    );    bottomPolygon(3, x+g-t, y    );
+  topPolygon(4, x+g  , y    );    bottomPolygon(4, x+g  , y    );
+  topPolygon(5, x    , y-g  );    bottomPolygon(5, x    , y+g  );
+  
+  if (state)
+  {
+    if (foreground_gc)
+    {
+      centerPolygon(0, x-g+t, y    );
+      centerPolygon(1, x    , y-g+t);
+      centerPolygon(2, x+g-t, y    );
+      centerPolygon(3, x    , y+g-t);
+      
+      XFillPolygon(XtDisplayOfObject(w), XtWindowOfObject(w), foreground_gc,
+		   center,  XtNumber(center),
+		   Convex, CoordModeOrigin);
+    }
+
+    if (bottom_shadow_GC)
+      XFillPolygon(XtDisplayOfObject(w), XtWindowOfObject(w), bottom_shadow_GC,
+		   top_shade, XtNumber(top_shade), Nonconvex, CoordModeOrigin);
+    
+    if (top_shadow_GC)
+      XFillPolygon(XtDisplayOfObject(w), XtWindowOfObject(w), top_shadow_GC,
+		   bot_shade, XtNumber(bot_shade), Nonconvex, CoordModeOrigin);
+  }else{
+
+    if (top_shadow_GC)
+      XFillPolygon(XtDisplayOfObject(w), XtWindowOfObject(w), top_shadow_GC,
+		   top_shade, XtNumber(top_shade),
+		   Nonconvex, CoordModeOrigin);
+    
+    if (bottom_shadow_GC)
+      XFillPolygon(XtDisplayOfObject(w), XtWindowOfObject(w), bottom_shadow_GC,
+		   bot_shade, XtNumber(bot_shade),
+		   Nonconvex, CoordModeOrigin);
+  }    
+  
+#undef topPolygon
+#undef bottomPolygon
+#undef centerPolygon
+  
+}
+
+Boolean
+#ifdef Xraw_NEED_PROTO
+FetchPixel (Widget w, String name, Pixel* pixel)
+#else
+FetchPixel(w, name, pixel)
+     Widget w;
+     String name;
+     Pixel* pixel;
+#endif
+{
+  XrmValue source, dest;
+
+  source.size = strlen(name)+1;
+  source.addr = name;
+  dest.size = sizeof(Pixel);
+  dest.addr = (caddr_t) pixel;
+  
+  return XtConvertAndStore(w, XtRString, &source, XtRPixel, &dest);
+}
diff --git a/vendor/x11iraf/obm/ObmW/zz/Table3d.h b/vendor/x11iraf/obm/ObmW/zz/Table3d.h
new file mode 100644
index 00000000..8d09dddf
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/Table3d.h
@@ -0,0 +1,145 @@
+#ifndef _3d_h_
+#define _3d_h_
+
+#include <stdio.h>
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Xraw/XawInit.h>
+
+typedef enum {
+  XawRAISED = Xraw_3d,
+  XawSUNKEN,
+  XawCHISELED,
+  XawLEDGED,
+  XawTACK
+} XawFrameType;
+
+#define TOP    (1)
+#define BOTTOM (2)
+
+extern GC AllocGCFromPixmap		Xraw_PROTO((Widget  , Pixmap ));
+extern GC AllocGCFromPixel		Xraw_PROTO((Widget  , Pixel ));
+
+extern void RGBtoHLS			Xraw_PROTO((double  , 
+						    double  ,
+						    double  ,
+						    double *  ,
+						    double *  ,
+						    double * ));
+     
+extern void HLStoRGB			Xraw_PROTO((double *  ,
+						    double *  ,
+						    double *  ,
+						    double  ,
+						    double  ,
+						    double ));
+						
+extern Boolean TopShadowColor		Xraw_PROTO((Widget /* self */,
+						    Pixel  /* base */,
+						    Pixel* /* result */));
+     
+extern Boolean BottomShadowColor	Xraw_PROTO((Widget /* self */,
+						    Pixel  /* base */,
+						    Pixel* /* result */));
+     
+extern Boolean ArmedColor		Xraw_PROTO((Widget /* self */,
+						    Pixel  /* base */,
+						    Pixel* /* result */));
+     
+extern GC MakeTopShadowGC		Xraw_PROTO((Widget  , Pixel ));
+extern GC MakeBottomShadowGC		Xraw_PROTO((Widget  , Pixel ));
+extern GC MakeArmedGC			Xraw_PROTO((Widget  , Pixel ));
+		
+		   
+extern GC AllocGCFromPixmap		Xraw_PROTO((Widget  , Pixmap ));
+		
+		   
+extern GC AllocGCFromPixel		Xraw_PROTO((Widget  , Pixel ));
+		
+		   
+extern Pixmap CreateShadowPixmap	Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     int ));
+		
+		   
+extern Boolean AllocShadowPixel	        Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     int  ,
+						     Pixel * ));
+     
+		   
+extern GC MakeGC			Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     int  ,
+						     Boolean  ,
+						     int ));
+     
+		   
+extern GC MakeTopShadowGC		Xraw_PROTO((Widget  , Pixel ));
+		
+		   
+extern GC MakeBottomShadowGC		Xraw_PROTO((Widget  , Pixel ));
+		
+		   
+extern GC MakeArmedGC			Xraw_PROTO((Widget  , Pixel ));
+		
+		   
+extern void XawDrawFrame		Xraw_PROTO((Widget  ,
+						     Position  ,
+						     Position  ,
+						     Dimension  ,
+						     Dimension  ,
+						     XawFrameType  ,
+						     Dimension  ,
+						     GC  ,
+						     GC ));
+		
+		   
+extern void RGBtoHLS			Xraw_PROTO((double  ,
+						     double  ,
+						     double  ,
+						     double *  ,
+						     double *  ,
+						     double * ));
+						
+extern void HLStoRGB			Xraw_PROTO((double *  ,
+						     double *  ,
+						     double *  ,
+						     double  ,
+						     double  ,
+						     double ));
+						
+extern Boolean BottomShadowColor	Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     Pixel * ));
+     
+		   
+extern Boolean TopShadowColor		Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     Pixel * ));
+		
+		   
+extern Boolean ArmedColor		Xraw_PROTO((Widget  ,
+						     Pixel  ,
+						     Pixel * ));
+		
+		   
+extern void DrawRhombus		        Xraw_PROTO((Widget  ,
+						     short  ,
+						     short  ,
+						     short  ,
+						     short  ,
+						     GC  ,
+						     GC  ,
+						     GC  ,
+						     Boolean ));
+     
+extern Boolean FetchPixel               Xraw_PROTO((Widget  ,
+						     String name ,
+						     Pixel* ));
+
+#endif /* _3d_h_ */
+
+
+
+
diff --git a/vendor/x11iraf/obm/ObmW/zz/TableP.h b/vendor/x11iraf/obm/ObmW/zz/TableP.h
new file mode 100644
index 00000000..7daa38f8
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/TableP.h
@@ -0,0 +1,166 @@
+/***********************************************************************
+
+                             Table widget 
+       		Copyright by Vladimir T. Romanovski
+			 All rights reserved.
+			
+This  library is desined  for  free,  non-commercial  software  creation. 
+It is changeable and can be improved. The author would greatly appreciate 
+any  advises, new  components  and  patches  of  the  existing  programs.
+Commercial  usage is  also  possible  with  participation of it's author.
+
+*************************************************************************/
+
+#ifndef _XawTableP_h
+#define _XawTableP_h
+
+/***********************************************************************
+ *
+ * Table Widget Private Data
+ *
+ ***********************************************************************/
+
+
+#include <X11/Xraw/ContainerP.h>
+#include <X11/Xraw/Table.h>
+#include <X11/Xraw/table.h>
+
+/* New fields for the Table widget class record */
+
+typedef struct {int foo;} TableClassPart;
+
+/* Full class record declaration */
+typedef struct _TableClassRec {
+    CoreClassPart       core_class;
+    CompositeClassPart  composite_class;
+    ConstraintClassPart constraint_class;
+    ContainerClassPart  container_class;
+    TableClassPart	table_class;
+} TableClassRec;
+
+#define MAX_ROWS 50
+
+typedef struct _NormalReverseGC {
+  int   used;
+  Pixel fore;
+  Pixel back;
+  GC    normal;
+  GC    reverse;
+}NormalReverseGC;
+
+typedef struct _ShadowGC {
+  int   used;
+  Pixel back;
+  GC    top;
+  GC    bottom;
+}ShadowGC;
+
+
+
+/* New fields for the Table widget record */
+typedef struct {
+    /* ------------------------ resources -----------------------*/
+    Pixel	  row_fore;
+    Pixel	  column_fore;
+    Pixel	  edit_fore;
+    Pixel	  edit_back;
+    Boolean       row_oriented;
+    Boolean       editable;
+    Boolean       literal;
+
+    int           mask_number;
+    int           columns;
+    int           rows;
+    Dimension     tab_margin;
+    Dimension     row_margin;
+    Dimension     col_margin;
+    Dimension	  internal_width;
+    Dimension	  internal_height;
+    Dimension     label_shadow_thickness;
+    unsigned char encoding;
+
+    /* Default Values */
+    Pixel	  foreground;
+    XtJustify	  justify;
+    XFontStruct	 *font;
+    int           width;
+
+    /* Allowance CallbackList */
+    XtCallbackList   allow_add_row;
+    XtCallbackList   allow_add_column;
+    XtCallbackList   allow_delete_column;
+    XtCallbackList   allow_delete_row;
+    XtCallbackList   allow_delete_table;
+
+    /* Information CallbackList */
+    XtCallbackList   add_row;
+    XtCallbackList   add_column;
+    XtCallbackList   changed_cell;
+    XtCallbackList   create_table;
+    XtCallbackList   delete_column;
+    XtCallbackList   delete_row;
+    XtCallbackList   delete_table;
+    XtCallbackList   what_cell;
+    XtCallbackList   changed_column_width;
+    XtCallbackList   changed_row_height;
+
+    Widget           v_scroll;
+    Widget           h_scroll;
+
+    int              row_height;
+    int              column_default_width;
+    int              literal_width;
+
+    /* ------------------------ private state -----------------------*/
+
+    int         no_refigure;   /* no re-layout while > 0 */
+    int         no_redraw;     /* no re-draw while > 0 */
+    Boolean     was_resized;
+
+
+    XawTableColumn column_data;
+    
+    Dimension   prefer_width;
+    Dimension   prefer_height;
+    Widget      edit;
+    int         edit_row;
+    int         edit_column;
+    XawTableCell   cell_own;
+    XawTableCell   table_stuff;
+
+    GC          row_gc;        /* Intrinsics sharedable GC */
+    GC          column_gc;     /* Intrinsics sharedable GC */
+
+    GC          normal;        /* Table sharedable GC */
+    GC          reverse;       /* Table sharedable GC */
+    GC          top;
+    GC          bottom;
+
+    GC          edit_top;
+    GC          edit_bottom;
+    
+    NormalReverseGC *normal_hash_table;
+    ShadowGC        *shadow_hash_table;
+    int              mask_hash_table;
+
+    Atom             selections[30];
+    int              num_selections;
+} TablePart;
+
+/****************************************************************
+ *
+ * Full instance record declaration
+ *
+ ****************************************************************/
+
+typedef struct _TableRec {
+    CorePart	   core;
+    CompositePart  composite;
+    ConstraintPart constraint;
+    ContainerPart  container;
+    TablePart	   table;
+} TableRec;
+
+extern TableClassRec tableClassRec;
+
+#endif /* _XawTableP_h */
diff --git a/vendor/x11iraf/obm/ObmW/zz/TableUtil.c b/vendor/x11iraf/obm/ObmW/zz/TableUtil.c
new file mode 100644
index 00000000..ec2582be
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/TableUtil.c
@@ -0,0 +1,918 @@
+/***********************************************************************
+  
+                             Table widget
+		   Copyright by Vladimir T. Romanovski
+			 All rights reserved.
+
+This library is designed  for  free,  non-commercial  software  creation.
+It is changeable and can be improved. The author would greatly appreciate
+any  advice, new  components  and  patches  of  the  existing  programs.
+Commercial  usage is  also  possible  with  participation of the author.
+  
+                       romsky@hp1.oea.ihep.su (Russia)
+		       romsky@munin.ucsf.edu  (USA)
+	
+*************************************************************************/
+
+#include <X11/Xraw/table.h>
+
+#ifdef EBUG_XRAW_MALLOC
+#include <dbmalloc/malloc.h>
+#endif
+
+/************************************************************************
+ *
+ *             TABLE IS A GRID OF POINTER BINDED NODES
+ *
+ ************************************************************************/
+
+#define null (XawTableNode)NULL
+#define FREE(t) if((t) != null)XtFree((char*)(t))
+
+static void vert_tab_node_insert(f,s,p)
+     register XawTableNode f; /* insert after   */
+     register XawTableNode s; /* insert before  */
+     register XawTableNode p; /* to be inserted */
+{
+  if (f != null) f->b = p;
+  if (s != null) s->t = p;
+  if (p != null) {p->t = f;  p->b = s;}
+}
+
+static void horiz_tab_node_insert(f,s,p)
+     register XawTableNode f; /* insert after   */
+     register XawTableNode s; /* insert before  */
+     register XawTableNode p; /* to be inserted */
+{
+  if (f != null) f->r = p;
+  if (s != null) s->l = p;
+  if (p != null) {p->l = f;  p->r = s;}
+}
+
+static void vert_tab_node_reject(p)
+     register XawTableNode p;
+{
+  if (p == null) return;
+  
+  if (p->t != null) p->t->b = p->b;
+  if (p->b != null) p->b->t = p->t;
+}
+
+static void horiz_tab_node_reject(p)
+     register XawTableNode p;
+{
+  if (p == null) return;
+  
+  if (p->r != null) p->r->l = p->l;
+  if (p->l != null) p->l->r = p->r;
+}
+
+/* ARGSUSED */
+static XawTableProc del_cell (w, i, j, call_data, client_data)
+     XtPointer w;   
+     int i;
+     int j;  
+     XtPointer call_data;
+     XtPointer client_data;
+{
+  XtFree((char*)call_data);
+  return False;
+}
+
+/*
+**	Function name : row_delete
+**
+**	Description   : delete row which the node belongs to 
+**	Input         : pointer to the node 
+**	Output        : void
+*/
+
+void
+#if NeedFunctionPrototypes
+row_delete (XtPointer f)
+#else
+row_delete(f)
+     XtPointer f;
+#endif
+{
+  register XawTableNode p = (XawTableNode) f;
+
+  if (p == null)
+    return;
+
+  /* Go to left edge */
+  for(; p->l != null; p=p->l )
+    /*EMPTY*/;
+
+  /* Go to right with dettaching cell */
+  for(; p->r != null; p=p->r){
+    vert_tab_node_reject(p->l);
+    FREE(p->l);
+  }
+
+  /* Detach last but one cell in the row */
+  if (p->l != null){
+    vert_tab_node_reject(p->l);
+    FREE(p->l);
+  }
+
+  /* Detach very last cell in the row */
+  vert_tab_node_reject(p);
+  FREE(p);
+}
+
+/*
+**	Function name : column_delete
+**
+**	Description   : delete column which the node belongs to 
+**	Input         : pointer to the node 
+**	Output        : void
+*/
+
+void
+#if NeedFunctionPrototypes
+column_delete (XtPointer f)
+#else
+column_delete(f)
+     XtPointer f;
+#endif
+{
+  register XawTableNode p = (XawTableNode) f;
+
+  if (p == null)
+    return;
+
+  /* Go up to the edge */
+  for(; p->t != null; p=p->t )
+    /*EMPTY*/;
+
+  /* Go down with dettaching cell */
+  for(; p->b != null; p=p->b){
+    horiz_tab_node_reject(p->t);
+    FREE(p->t);
+  }
+
+  /* Detach bottom but one cell in the column */
+  if (p->t != null){
+    horiz_tab_node_reject(p->t);
+    FREE(p->t);
+  }
+
+  /* Detach very bottom cell in the column */
+  horiz_tab_node_reject(p);
+  FREE(p);
+}
+
+
+
+/*
+**	Function name : row_insert_after
+**
+**	Description   : insert row down to the row which the node belongs to
+**	Input         : poiter to the node, size of node
+**	Output        : True if successful
+*/
+
+Boolean
+#if NeedFunctionPrototypes
+row_insert_after (XtPointer d, int node_size)
+#else
+row_insert_after(d, node_size)
+     XtPointer d;
+     int node_size;
+#endif
+{
+  register XawTableNode f = (XawTableNode) d;
+  register XawTableNode p;
+  XawTableNode          left;
+  
+  if (f == null)
+    return False;
+
+  /* go left till row edge */
+  for(; f->l != null; f=f->l )
+    /*EMPTY*/;
+
+  /* save very left node */
+  left = f;
+  
+  /* go right and attach new cells via vertical ponters */
+  for(; f->r != null; f=f->r){
+    if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+      for(; left != f; left = left->r){
+	vert_tab_node_reject(left->b);
+	FREE(left->b);
+      }
+      return False;
+    }
+    vert_tab_node_insert(f, f->b, p);
+  }
+
+  /* attach vertically very right cell */
+  if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+    for(; left != f; left = left->r){
+      vert_tab_node_reject(left->b);
+      FREE(left->b);
+    }
+    return False;
+  }
+  vert_tab_node_insert(f, f->b, p);
+
+  /* if only one column */
+  if ( f->l == null ) {
+    f->b->l = f->b->r = null;
+    return True;
+  }
+  
+  /* attach horizontally very right cell */
+  horiz_tab_node_insert(f->l->b,null,f->b);
+  
+  /* bind via horizontal ponters */
+  for(f=f->l; f->l != null; f=f->l )
+    horiz_tab_node_insert(f->l->b,f->r->b,f->b);
+  
+  /* attach horizontally very left cell */
+  horiz_tab_node_insert(null,f->r->b,f->b);
+
+  return True;
+}
+
+/*
+**	Function name : row_insert_before 
+**
+**	Description   : the same as previous, but only on top from row
+**	Input         : pointer to the node, size of node
+**	Output        : True if successful
+*/
+
+Boolean 
+#if NeedFunctionPrototypes
+row_insert_before (XtPointer d, int node_size)
+#else
+row_insert_before(d, node_size)
+     XtPointer d;
+     int node_size;
+#endif
+{
+  register XawTableNode f = (XawTableNode) d;
+  register XawTableNode p;
+  XawTableNode          left;
+  
+  if (f == null)
+    return False;
+
+  /* go left till row edge */
+  for(; f->l != null; f=f->l )
+    /*EMPTY*/;
+
+  /* save very left node */
+  left = f;
+  
+  /* go right and attach new cells via vertical ponters */
+  for(; f->r != null; f=f->r){
+    if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+      for(; left != f; left = left->r){
+	vert_tab_node_reject(left->t);
+	FREE(left->t);
+      }
+      return False;
+    }
+    vert_tab_node_insert(f->t, f, p);
+  }
+
+  /* attach vertically very right cell */
+  if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+    for(; left != f; left = left->r){
+      vert_tab_node_reject(left->t);
+      FREE(left->t);
+    }
+    return False;
+  }
+  vert_tab_node_insert(f->t, f, p);
+
+  /* if only one column */
+  if ( f->l == null ) {
+    f->t->l = f->t->r = null;
+    return True;
+  }
+  
+  /* attach horizontally very right cell */
+  horiz_tab_node_insert(f->l->t,null,f->t);
+  
+  /* bind via horizontal ponters */
+  for(f=f->l; f->l != null; f=f->l )
+    horiz_tab_node_insert(f->l->t,f->r->t,f->t);
+  
+  /* attach horizontally very left cell */
+  horiz_tab_node_insert(null,f->r->t,f->t);
+
+  return True;
+}
+
+/*
+**	Function name : column_insert_after
+**
+**	Description   : insert column right to the column which the node belongs to 
+**	Input         : pointer to the node, size of node
+**	Output        : True if successful
+[<*/
+
+Boolean
+#if NeedFunctionPrototypes
+column_insert_after (XtPointer d, int node_size)
+#else
+column_insert_after(d, node_size)
+     XtPointer d;
+     int node_size;
+#endif
+{
+  register XawTableNode f = (XawTableNode) d;
+  register XawTableNode p;
+  XawTableNode          top;
+  
+  if (f == null)
+    return False;
+
+  /* go top till column edge */
+  for(; f->t != null; f=f->t )
+    /*EMPTY*/;
+
+  /* save very top node */
+  top = f;
+  
+  /* go down and attach new cells via horizontal ponters */
+  for(; f->b != null; f=f->b){
+    if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+      for(; top != f; top = top->b){
+	horiz_tab_node_reject(top->r);
+	FREE(top->r);
+      }
+      return False;
+    }
+    horiz_tab_node_insert(f, f->r, p);
+  }
+
+  /* attach horizontally very down cell */
+  if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+    for(; top != f; top = top->b){
+      horiz_tab_node_reject(top->r);
+      FREE(top->r);
+    }
+    return False;
+  }
+    
+  horiz_tab_node_insert(f, f->r, p);
+
+  /* if only one row */
+  if ( f->t == null ) {
+    f->r->t = f->r->b = null;
+    return True;
+  }
+  
+  /* attach vertically very down cell */
+  vert_tab_node_insert(f->t->r,null,f->r);
+  
+  /* bind via vertical ponters */
+  for(f=f->t; f->t != null; f=f->t )
+    vert_tab_node_insert(f->t->r,f->b->r,f->r);
+  
+  /* attach vertically very top cell */
+  vert_tab_node_insert(null,f->b->r,f->r);
+
+  return True;
+}
+
+/*
+**	Function name : column_insert_before
+**
+**	Description   : the same as previous, but only to left from column 
+**	Input         : pointer to node, size of node
+**	Output        : True if successful 
+*/
+
+Boolean
+#if NeedFunctionPrototypes
+column_insert_before (XtPointer d, int node_size)
+#else
+column_insert_before(d, node_size)
+     XtPointer d;
+     int node_size;
+#endif
+{
+  register XawTableNode f = (XawTableNode)d;
+  register XawTableNode p;
+  XawTableNode top;
+  
+  if (f == null)
+    return False;
+
+  /* go top till column top */
+  for(; f->t != null; f=f->t )
+    /*EMPTY*/;
+
+  /* save very top node */
+  top = f;
+  
+  /* go down and attach new cells via horizontal ponters */
+  for(; f->b != null; f=f->b){
+    if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+      for(; top != f; top = top->b){
+	horiz_tab_node_reject(top->l);
+	FREE(top->l);
+      }
+      return False;
+    }
+    horiz_tab_node_insert(f->l, f, p);
+  }
+
+  /* attach horizontally very down cell */
+  if( (p = (XawTableNode) XtMalloc (node_size)) == null){
+    for(; top != f; top = top->b){
+      horiz_tab_node_reject(top->l);
+      FREE(top->l);
+    }
+    return False;
+  }
+  horiz_tab_node_insert(f->l, f, p);
+
+  /* if only one row */
+  if ( f->t == null ) {
+    f->l->t = f->l->b = null;
+    return True;
+  }
+  
+  /* attach vertically very down cell */
+  vert_tab_node_insert(f->t->l, null, f->l);
+  
+  /* bind via vertical ponters */
+  for(f=f->t; f->t != null; f=f->t )
+    vert_tab_node_insert(f->t->l, f->b->l, f->l);
+  
+  /* attach vertically very top cell */
+  vert_tab_node_insert(null, f->b->l, f->l);
+
+  return True;
+}
+
+/*
+**	Function name : get_table
+**
+**	Description   : spot the node (0,0) in the table
+**	Input         : pointer to any node in table
+**	Output        : pointer to the node (0,0) 
+*/
+
+XtPointer 
+#if NeedFunctionPrototypes
+get_table (XtPointer f)
+#else
+get_table(f)
+     XtPointer f;
+#endif
+{
+  register XawTableNode p = (XawTableNode) f;
+
+  if (p == null)
+    return (XtPointer)NULL;
+
+  for(; p->t != null; p=p->t)
+    /*EMPTY*/;
+
+  for(; p->l != null; p=p->l)
+    /*EMPTY*/;
+
+  return (XtPointer)p;
+}
+
+/*
+**	Function name : get_cell
+**
+**	Description   : spot the node (i,j) regarding to given node
+**	Input         : pointer to the node, column, row (may be negative)
+**	Output        : pointer to the node or NULL 
+*/
+
+XtPointer
+#if NeedFunctionPrototypes
+get_cell (XtPointer f, register int i, register int j)
+#else
+get_cell (f, i, j)
+     XtPointer    f;
+     register int i;
+     register int j;
+#endif
+{
+  register XawTableNode p = (XawTableNode) f;
+  
+  if (p == null)
+    return (XtPointer)NULL;
+
+  if (i > 0) {
+    for(; i>0; i--)
+      if (p != null) p = p->b; 
+      else           return (XtPointer)NULL; 
+  } else {
+    for(; i<0; i++)
+      if (p != null) p = p->t; 
+      else           return (XtPointer)NULL;
+  }
+  
+  if (j > 0) {
+    for(; j>0; j--)
+      if (p != null) p = p->r; 
+      else           return (XtPointer)NULL;
+  } else {
+    for(; j<0; j++)
+      if (p != null) p = p->l;
+      else           return (XtPointer)NULL;
+  }
+
+  return (XtPointer)p;
+}
+
+#if 0
+static Boolean go_row(w, proc, p, begin_column, end_column, i, j, client_data)
+     XtPointer w;
+     XawTableProc proc;
+     XawTableNode   p;       /* p == get_cell(table, ... , begin_column) */
+     int  begin_column;
+     int  end_column;  
+     int *i;         /* returned */
+     int *j;         /* returned */
+     XtPointer   client_data;
+{
+  for ((*j) = begin_column; ((*j) <= end_column) && (p != null); (*j)++) 
+  {
+    XawTableProc sp = p;
+    p = p->r;
+
+    if (proc(w, *i, *j, (XtPointer)sp, client_data))
+      return True;
+  }
+
+  return False;
+}
+#endif
+
+/*
+**	Function name : go_table
+**
+**	Description   : invoke given rutine for every node in given region
+**	Input         : rutine, begin/end rows, begin/end columns...
+**	Output        : True if given rutine returned True for a node,
+**                      numbers of row and column for that node
+ */                
+
+Boolean 
+#if NeedFunctionPrototypes
+go_table (
+	  XtPointer w,
+	  XawTableProc proc,
+	  XtPointer table,
+	  int  begin_row,    
+	  int  end_row,
+	  int  begin_column,
+	  int  end_column,
+	  int  direction,
+	  register int *i,            /* returned */
+	  register int *j,            /* returned */
+	  XtPointer   client_data)
+#else
+go_table(w, proc, table, begin_row, end_row, begin_column, end_column,
+	 direction, i, j, client_data)
+     XtPointer w;
+     XawTableProc proc;
+     XtPointer table;
+     int  begin_row;
+     int  end_row;
+     int  begin_column;
+     int  end_column;
+     int direction;
+     register int *i;               /* returned */
+     register int *j;               /* returned */
+     XtPointer   client_data;
+#endif
+{
+  register XawTableNode p;
+  register XawTableNode n;
+
+  table = get_table(table);
+
+  switch (direction) {
+  case XawTABLE_DOWN_RIGHT :
+    p = (XawTableNode)get_cell(table, begin_row, begin_column);
+    
+    for (*j = begin_column; *j <= end_column && p != null; (*j)++) 
+    {
+      register XawTableNode sp = p;  /* protect against deallocated node !! */
+      p = p->r;
+      
+      for (*i = begin_row, n = sp; *i <= end_row && n != null; (*i)++) 
+      {
+	register XawTableNode sn = n; /* protect against deallocated node !! */
+	n = n->b;
+	
+	if (proc(w, *i, *j, (XtPointer)sn, client_data))
+	  return True;
+      }
+    }
+    break;
+  case XawTABLE_RIGHT_DOWN :
+  default :
+    p = (XawTableNode)get_cell(table, begin_row, begin_column);
+    
+    for (*i = begin_row; *i <= end_row && p != null; (*i)++) 
+    {
+      register XawTableNode sp = p;  /* protect against deallocated node !! */
+      p = p->b;
+      
+      for (*j = begin_column, n = sp; *j <= end_column && n != null; (*j)++) 
+      {
+	register XawTableNode sn = n; /* protect against deallocated node !! */
+	n = n->r;
+	
+	if (proc(w, *i, *j, (XtPointer)sn, client_data))
+	  return True;
+      }
+    }
+    break;
+  }
+  return False;
+}
+
+/*
+**	Function name : get_table_size
+**
+**	Description   : define dimention on the table
+**	Input         : pointer to any node in the table
+**	Output        : void
+*/
+
+void
+#if NeedFunctionPrototypes
+get_table_size (XtPointer f,
+		register int *i,   /* returned */
+		register int *j)   /* returned */
+#else
+get_table_size(f,i,j)
+     XtPointer f;
+     register int *i;   /* returned */
+     register int *j;   /* returned */
+#endif
+{
+  register XawTableNode p = (XawTableNode)f;
+  if (p == null){
+    *i = 0;
+    *j = 0;
+  }
+
+  p = (XawTableNode)get_table(f);
+  
+  for (*i = 1; p->b != null; p = p->b, (*i)++)
+    /*EMPTY*/;
+
+  for (*j = 1; p->r != null; p = p->r, (*j)++)
+    /*EMPTY*/;
+}
+
+/*
+**	Function name : delete_table
+**
+**	Description   : destroy table
+**	Input         : pointer to any node in the table
+**	Output        : void
+*/
+
+void
+#if NeedFunctionPrototypes
+delete_table (XtPointer f)
+#else
+delete_table(f)
+     XtPointer f;
+#endif
+{
+  register XawTableNode p = (XawTableNode)f;
+  int i,j;
+  int end_row, end_column;
+
+  if (p == null)
+    return;
+
+  p = (XawTableNode)get_table(f);
+  get_table_size((XtPointer)p, (int*)&end_row, (int*)&end_column);
+  (void)go_table(NULL, (XawTableProc)del_cell, (XtPointer)p,
+		 0, (int)(end_row-1), 0, (int)(end_column-1),
+		 XawTABLE_RIGHT_DOWN,
+		 (int*)&i, (int*)&j, NULL);
+}
+
+/*
+**	Function name : get_cell_positions
+**
+**	Description   : define number of row & column for node
+**	Input         : pointer to the node
+**	Output        : void
+*/
+
+void 
+#if NeedFunctionPrototypes
+get_cell_positions (XtPointer f,
+                    register int *i,   /* returned */
+                    register int *j)   /* returned */
+#else
+get_cell_positions(f, i, j)
+     XtPointer          f;
+     register int *i;  /* returned */
+     register int *j;  /* returned */
+#endif
+{
+  register XawTableNode p = (XawTableNode)f;
+  if ( p == null )
+    return;
+  
+  if ( i != (int*)NULL ) {
+    for (*i = 0; p->t != null; p = p->t, (*i)++)
+      /*EMPTY*/;
+  }
+
+  if ( j != (int*)NULL ) {
+    for (*j = 0; p->l != null; p = p->l, (*j)++)
+      /*EMPTY*/;
+  }
+}
+
+/*
+**	Function name : create_table
+**
+**	Description   : create the table
+**	Input         : row & column dimestions, size of node
+**	Output        : pointer to the node (0,0)
+*/
+
+XtPointer
+#if NeedFunctionPrototypes
+create_table ( int rows, int columns, int node_size)
+#else
+create_table(rows, columns, node_size)
+     int rows;
+     int columns;
+     int node_size;
+#endif
+{
+  register XawTableNode *area;
+  register XawTableNode  p;
+  register int i,j;
+  XawTableNode           table;
+  
+  if (rows == 0 || columns == 0)
+    return (XtPointer)NULL;
+  else{
+    register XawTableNode *s;
+
+    /* allocate temporary two-dimension array to make first node's binding */
+    if ( (s = area = (XawTableNode*)
+	  XtCalloc ((unsigned)(rows * columns), sizeof(XawTableNode))) == NULL)
+      return (XtPointer)NULL;
+    
+    /* allocate nodes */
+    for (i = 0, j = rows*columns;  i < j; i++)
+      if((*s++ = (XawTableNode) XtMalloc (node_size)) == NULL){
+	int h;
+	for (h = 0, s = area;  h < i; h++)
+	  XtFree((char*)*s++);
+	
+	XtFree((char*)area);
+	return (XtPointer)NULL;
+      }
+  }
+  
+#define a(i,j) (XawTableNode)*(area + (i)*columns + (j))
+
+  /* initialize the boundary nodes */
+  for (i = 0; i < rows; i++) {
+    p = a(i,0);         p->l = null;
+    p = a(i,columns-1); p->r = null;
+  }
+  for (j = 0; j < columns; j++) {
+    p = a(0,j);         p->t = null;
+    p = a(rows-1,j);    p->b = null;
+  }
+
+#undef a
+#define a(i,j) (( (i)>=0 && (i)<rows ) && ( (j)>=0 && (j)<columns ) ? \
+		(XawTableNode)*(area + (i)*columns + (j)) : null)
+
+  /* make internode's binding */
+  for (i = 0; i < rows; i++) {
+    for (j = i % 2; j < columns; j += 2) {
+      horiz_tab_node_insert(a(i,j-1), a(i,j+1), a(i,j));
+      vert_tab_node_insert (a(i-1,j), a(i+1,j), a(i,j));
+    }
+  }
+
+#undef a
+
+  table = *area;
+  XtFree((char*)area);
+  return (XtPointer)table;
+}
+
+
+#ifdef EBUG_XRAW_MALLOC
+/* ARGSUSED */
+static Boolean check_cell (w, row, column, call_data, client_data)
+     XtPointer w;   /* unused */
+     int row;      
+     int column;      
+     XtPointer call_data;
+     XtPointer client_data;
+{
+  register XawTableNode p = (XawTableNode)call_data;
+  int real_row, real_column;
+  char *halt = NULL;;
+  
+  get_cell_positions(p, &real_row, &real_column);
+
+  if (real_row != row){
+    XtWarning("check_table: wrong initial table row size");
+    *halt = '\0';
+  }
+
+  if (real_column != column){
+    XtWarning("check_table: wrong initial table column size");
+    *halt = '\0';
+  }
+
+  if (p->l != null) 
+    if (p->l->r != p) {
+      XtWarning("check_table: wrong cell");
+      *halt = '\0';
+    }
+  if (p->r != null) 
+    if (p->r->l != p) {
+      XtWarning("check_table: wrong cell");
+      *halt = '\0';
+    }
+  if (p->t != null) 
+    if (p->t->b != p) {
+      XtWarning("check_table: wrong cell");
+      *halt = '\0';
+	}
+  if (p->b != null) 
+    if (p->b->t != p) {
+      XtWarning("check_table: wrong cell");
+      *halt = '\0';
+    }
+  
+  return False;
+}
+
+
+
+void
+#if NeedFunctionPrototypes
+_check_table (XtPointer f, int rows, int columns)
+#else
+_check_table (f, rows, columns)
+     XtPointer f;
+     int rows;
+     int columns;
+#endif
+{
+  register XawTableNode table = (XawTableNode)f;
+  int real_rows, real_columns;
+  register int i,j;
+  char *halt = NULL;
+
+  if (f == NULL && (rows == 0 || columns == 0))
+    return;
+
+  if (table != get_table(f)){
+    XtWarning("check_table: wrong initial table cell");
+    *halt = '\0';
+  }
+    
+  get_table_size (f, &real_rows, &real_columns);
+
+  if (real_rows != rows){
+    XtWarning("check_table: wrong initial table row size");
+    *halt = '\0';
+  }
+
+  if (real_columns != columns){
+    XtWarning("check_table: wrong initial table column size");
+    *halt = '\0';
+  }
+
+
+  (void) go_table (NULL, check_cell, table, 
+		   0, rows-1, 0, columns-1,
+		   XawTABLE_RIGHT_DOWN, 
+		   &real_rows, &real_columns, (XtPointer)NULL);
+  
+}
+#endif /* EBUG_XRAW_MALLOC */
+
+#undef null
+#undef FREE
+
diff --git a/vendor/x11iraf/obm/ObmW/zz/TableUtil.h b/vendor/x11iraf/obm/ObmW/zz/TableUtil.h
new file mode 100644
index 00000000..a8262f75
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/TableUtil.h
@@ -0,0 +1,94 @@
+/***********************************************************************
+  
+                             Table widget
+		   Copyright by Vladimir T. Romanovski
+			 All rights reserved.
+
+This library is designed  for  free,  non-commercial  software  creation.
+It is changeable and can be improved. The author would greatly appreciate
+any  advice, new  components  and  patches  of  the  existing  programs.
+Commercial  usage is  also  possible  with  participation of the author.
+
+                       romsky@hp1.oea.ihep.su  (Russia)
+                       romsky@munin.ucsf.edu   (USA)
+	 
+*************************************************************************/
+
+#ifndef _table_h_
+#define _table_h_
+
+#include <stdio.h>
+#include <X11/Intrinsic.h>
+#include <X11/Xraw/Table.h>
+
+#if __STDC__ || defined(__cplusplus)
+#define F_PROTO(s) s
+#else
+#define F_PROTO(s) ()
+#endif
+
+typedef struct _XawTableNodeRec {              /* Node of table grid */
+  struct _XawTableNodeRec *l;
+  struct _XawTableNodeRec *r;
+  struct _XawTableNodeRec *t;
+  struct _XawTableNodeRec *b;
+}XawTableNodeRec, *XawTableNode;
+
+
+extern XtPointer create_table 	    F_PROTO((int rows,
+					     int columns, 
+					     int node_size));
+
+extern Boolean row_insert_after     F_PROTO((XtPointer d,
+					     int node_size));
+     
+extern Boolean row_insert_before    F_PROTO((XtPointer f,
+					     int node_size));
+     
+extern Boolean column_insert_after  F_PROTO((XtPointer d,
+					     int node_size));
+     
+extern Boolean column_insert_before F_PROTO((XtPointer f,
+					     int node_size));
+     
+extern XtPointer get_table 	    F_PROTO((XtPointer f));
+     
+extern XtPointer get_cell 	    F_PROTO((XtPointer p,
+					     int i,
+					     int j));
+     
+extern void get_table_size 	    F_PROTO((XtPointer p,
+					     int *i,
+					     int *j));
+     
+extern void get_cell_positions 	    F_PROTO((XtPointer p,
+					     int *i,
+					     int *j));
+
+extern void row_delete 		    F_PROTO((XtPointer p));
+     
+extern void column_delete 	    F_PROTO((XtPointer p));
+     
+extern void delete_table 	    F_PROTO((XtPointer p));
+
+extern Boolean go_table 	    F_PROTO((XtPointer w, 
+					     XawTableProc proc, 
+					     XtPointer table, 
+					     int begin_row,
+					     int end_row,
+					     int begin_column, 
+					     int end_column,
+					     int direction,
+					     register int *row,
+					     register int *column,
+					     XtPointer client_data));
+
+#ifdef EBUG_XRAW_MALLOC
+extern void _check_table            F_PROTO((XtPointer table, 
+					     int rows, 
+					     int columns));
+#endif
+
+#undef F_PROTO
+
+#endif /* _table_h_ */
diff --git a/vendor/x11iraf/obm/ObmW/zz/XrawInit.h b/vendor/x11iraf/obm/ObmW/zz/XrawInit.h
new file mode 100644
index 00000000..cf6bcbc8
--- /dev/null
+++ b/vendor/x11iraf/obm/ObmW/zz/XrawInit.h
@@ -0,0 +1,60 @@
+/* $XConsortium: XawInit.h,v 1.4 91/07/22 19:05:25 converse Exp $
+ *
+ * Copyright 1989 Massachusetts Institute of Technology
+ *
+ * Permission to use, copy, modify, distribute, and sell this software and its
+ * documentation for any purpose is hereby granted without fee, 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 M.I.T. not be used in advertising or
+ * publicity pertaining to distribution of the software without specific,
+ * written prior permission.  M.I.T. makes no representations about the
+ * suitability of this software for any purpose.  It is provided "as is"
+ * without express or implied warranty.
+ *
+ * M.I.T. DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL M.I.T.
+ * 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 _XawInit_
+#define _XawInit_
+
+#if !(defined(__STDC__) && __STDC__) && !defined(__cplusplus) && !defined(c_plusplus) && !defined(FUNCPROTO) && !defined(XTFUNCPROTO) && !defined(XAWFUNCPROTO) && !(defined(NeedFunctionPrototypes) && NeedFunctionPrototypes)
+#define Xraw_NO_PROTO
+#else
+#define Xraw_NEED_PROTO
+#endif /* __STDC__ */
+
+
+#ifdef  Xraw_NEED_PROTO
+#define Xraw_PROTO(args) args
+#else
+#define Xraw_PROTO(args) ()
+#endif
+
+#define Xraw_VERSION  1
+#define Xraw_REVISION 2
+
+#define Xraw_3d        1
+#define Xraw_SCROLLBAR 20
+#define Xraw_TABLE     40
+#define Xraw_SEPARATOR 60
+#define Xraw_FRAME     80
+
+#define streq(a,b) (XrmStringToQuark(a) == XrmStringToQuark(b))
+
+#define FULL_WIDTH(w)  ((w)->core.width + ((w)->core.border_width << 1))
+#define FULL_HEIGHT(w) ((w)->core.height + ((w)->core.border_width << 1))
+#define WNULL          (Widget)NULL
+
+/* called from ClassInit procs */
+extern void XawInitializeWidgetSet Xraw_PROTO((void));
+
+#if defined(XtSpecificationRelease) && XtSpecificationRelease < 5
+#define XPointer XtPointer
+#endif       
+     
+#endif /* _XawInit_ */