Move sources to src/.

Signed-off-by: Matt Turner <mattst88@gmail.com>

1 files changed, 877 insertions, 0 deletions

diff --git a/src/SmeBSB.c b/src/SmeBSB.c
new file mode 100644
index 0000000..63bdc49
--- /dev/null
+++ b/src/SmeBSB.c
@@ -0,0 +1,877 @@
+/* $XConsortium: SmeBSB.c,v 1.19 94/04/17 20:12:49 kaleb Exp $ */
+
+/*
+Copyright (c) 1989, 1994  X Consortium
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of the X Consortium shall not be
+used in advertising or otherwise to promote the sale, use or other dealings
+in this Software without prior written authorization from the X Consortium.
+ */
+
+/*
+ * Portions Copyright (c) 2003 Brian V. Smith
+ * Rights, permissions, and disclaimer per the above X Consortium license.
+ */
+
+/*
+ * SmeBSB.c - Source code file for BSB Menu Entry object.
+ *
+ * Date:    September 26, 1989
+ *
+ * By:      Chris D. Peterson
+ *          MIT X Consortium 
+ *          kit@expo.lcs.mit.edu
+ */
+
+#include "Xaw3dP.h"
+#include <X11/IntrinsicP.h>
+#include <X11/StringDefs.h>
+#include <X11/Xos.h>
+#include <X11/Xmu/Drawing.h>
+#include <X11/Xaw3d/XawInit.h>
+#include <X11/Xaw3d/ThreeDP.h>
+#include <X11/Xaw3d/SimpleMenP.h>
+#include <X11/Xaw3d/SmeBSBP.h>
+#include <X11/Xaw3d/Cardinals.h>
+#include <stdio.h>
+
+/* needed for abs() */
+#ifndef X_NOT_STDC_ENV
+#include <stdlib.h>
+#else
+extern int abs();
+#endif
+
+#define offset(field) XtOffsetOf(SmeBSBRec, sme_bsb.field)
+
+static XtResource resources[] = {
+  {XtNlabel,  XtCLabel, XtRString, sizeof(String),
+     offset(label), XtRString, NULL},
+  {XtNvertSpace,  XtCVertSpace, XtRInt, sizeof(int),
+     offset(vert_space), XtRImmediate, (XtPointer) 25},
+  {XtNleftBitmap, XtCLeftBitmap, XtRBitmap, sizeof(Pixmap),
+     offset(left_bitmap), XtRImmediate, (XtPointer)None},
+  {XtNjustify, XtCJustify, XtRJustify, sizeof(XtJustify),
+     offset(justify), XtRImmediate, (XtPointer) XtJustifyLeft},
+  {XtNrightBitmap, XtCRightBitmap, XtRBitmap, sizeof(Pixmap),
+     offset(right_bitmap), XtRImmediate, (XtPointer)None},
+  {XtNleftMargin,  XtCHorizontalMargins, XtRDimension, sizeof(Dimension),
+     offset(left_margin), XtRImmediate, (XtPointer) 4},
+  {XtNrightMargin,  XtCHorizontalMargins, XtRDimension, sizeof(Dimension),
+     offset(right_margin), XtRImmediate, (XtPointer) 4},
+  {XtNforeground, XtCForeground, XtRPixel, sizeof(Pixel),
+     offset(foreground), XtRString, XtDefaultForeground},
+  {XtNfont,  XtCFont, XtRFontStruct, sizeof(XFontStruct *),
+     offset(font), XtRString, XtDefaultFont},
+#ifdef XAW_INTERNATIONALIZATION
+  {XtNfontSet,  XtCFontSet, XtRFontSet, sizeof(XFontSet ),
+     offset(fontset),XtRString, XtDefaultFontSet},
+#endif
+  {XtNmenuName, XtCMenuName, XtRString, sizeof(String),
+     offset(menu_name), XtRImmediate, (XtPointer) NULL},
+  {XtNunderline,  XtCIndex, XtRInt, sizeof(int),
+     offset(underline), XtRImmediate, (XtPointer) -1},
+};   
+#undef offset
+
+/*
+ * Semi Public function definitions. 
+ */
+
+static void Redisplay(), Destroy(), Initialize();
+static void Highlight(), Unhighlight();
+static void ClassInitialize();
+static Boolean SetValues();
+static XtGeometryResult QueryGeometry();
+
+/* 
+ * Private Function Definitions.
+ */
+
+static void GetDefaultSize(), DrawBitmaps(), GetBitmapInfo();
+static void CreateGCs(), DestroyGCs(), FlipColors();
+    
+#define superclass (&smeThreeDClassRec)
+SmeBSBClassRec smeBSBClassRec = {
+  {
+    /* superclass         */    (WidgetClass) superclass,
+    /* class_name         */    "SmeBSB",
+    /* size               */    sizeof(SmeBSBRec),
+    /* class_initializer  */	ClassInitialize,
+    /* class_part_initialize*/	NULL,
+    /* Class init'ed      */	FALSE,
+    /* initialize         */    Initialize,
+    /* initialize_hook    */	NULL,
+    /* realize            */    NULL,
+    /* actions            */    NULL,
+    /* num_actions        */    ZERO,
+    /* resources          */    resources,
+    /* resource_count     */	XtNumber(resources),
+    /* xrm_class          */    NULLQUARK,
+    /* compress_motion    */    FALSE, 
+    /* compress_exposure  */    FALSE,
+    /* compress_enterleave*/ 	FALSE,
+    /* 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,
+    /* intrinsics version */	XtVersion,
+    /* callback offsets   */    NULL,
+    /* tm_table		  */    NULL,
+    /* query_geometry	  */    QueryGeometry,
+    /* display_accelerator*/    NULL,
+    /* extension	  */    NULL
+  },{
+    /* SimpleMenuClass Fields */
+    /* highlight          */	Highlight,
+    /* unhighlight        */	Unhighlight,
+    /* notify             */	XtInheritNotify,		
+    /* extension	  */	NULL
+  }, {
+    /* ThreeDClass Fields */
+    /* shadowdraw         */    XtInheritXawSme3dShadowDraw
+  }, {
+    /* BSBClass Fields */  
+    /* extension	  */    NULL
+  }
+};
+
+WidgetClass smeBSBObjectClass = (WidgetClass) &smeBSBClassRec;
+
+/************************************************************
+ *
+ * Semi-Public Functions.
+ *
+ ************************************************************/
+
+/*	Function Name: ClassInitialize
+ *	Description: Initializes the SmeBSBObject. 
+ *	Arguments: none.
+ *	Returns: none.
+ */
+
+static void 
+ClassInitialize()
+{
+    XawInitializeWidgetSet();
+    XtAddConverter( XtRString, XtRJustify, XmuCvtStringToJustify, 
+		    (XtConvertArgList)NULL, (Cardinal)0 );
+}
+
+/*      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, args, num_args)
+Widget request, new;
+ArgList args;
+Cardinal *num_args;
+{
+    SmeBSBObject entry = (SmeBSBObject) new;
+
+    if (entry->sme_bsb.label == NULL) 
+	entry->sme_bsb.label = XtName(new);
+    else
+	entry->sme_bsb.label = XtNewString( entry->sme_bsb.label );
+
+    CreateGCs(new);
+
+    GetBitmapInfo(new, TRUE);	/* Left Bitmap Info */
+    GetBitmapInfo(new, FALSE);	/* Right Bitmap Info */
+
+    entry->sme_bsb.left_stippled = entry->sme_bsb.right_stippled = None;
+
+    GetDefaultSize(new, &(entry->rectangle.width), &(entry->rectangle.height));
+}
+
+/*      Function Name: Destroy
+ *      Description: Called at destroy time, cleans up.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: none.
+ */
+
+static void
+Destroy(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+
+    DestroyGCs(w);
+#ifdef XAW_MULTIPLANE_PIXMAPS
+    if (entry->sme_bsb.left_stippled != None)
+	XFreePixmap(XtDisplayOfObject(w), entry->sme_bsb.left_stippled);
+    if (entry->sme_bsb.right_stippled != None)
+	XFreePixmap(XtDisplayOfObject(w), entry->sme_bsb.right_stippled);
+#endif
+    if (entry->sme_bsb.label != XtName(w))
+	XtFree(entry->sme_bsb.label);
+}
+
+/*      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;
+{
+    GC gc;
+    SmeBSBObject entry = (SmeBSBObject) w;
+    Dimension s = entry->sme_threeD.shadow_width;
+    int	font_ascent = 0, font_descent = 0, y_loc;
+#ifdef XAW_INTERNATIONALIZATION
+    int	fontset_ascent = 0, fontset_descent = 0;
+    XFontSetExtents *ext = XExtentsOfFontSet(entry->sme_bsb.fontset);
+#endif
+
+    entry->sme_bsb.set_values_area_cleared = FALSE;    
+#ifdef XAW_INTERNATIONALIZATION
+    if ( entry->sme.international == True ) {
+        fontset_ascent = abs(ext->max_ink_extent.y);
+        fontset_descent = ext->max_ink_extent.height - fontset_ascent;
+    }
+    else
+#endif
+    { /*else, compute size from font like R5*/
+        font_ascent = entry->sme_bsb.font->max_bounds.ascent;
+        font_descent = entry->sme_bsb.font->max_bounds.descent;
+    }
+    y_loc = entry->rectangle.y;
+
+    if (XtIsSensitive(w) && XtIsSensitive( XtParent(w) ) ) {
+	if ( w == XawSimpleMenuGetActiveEntry(XtParent(w)) ) {
+	    XFillRectangle(XtDisplayOfObject(w), XtWindowOfObject(w), 
+			   entry->sme_bsb.norm_gc, s, y_loc + s,
+			   (unsigned int) entry->rectangle.width - 2 * s,
+			   (unsigned int) entry->rectangle.height - 2 * s);
+	    gc = entry->sme_bsb.rev_gc;
+	}
+	else
+	    gc = entry->sme_bsb.norm_gc;
+    }
+    else
+	gc = entry->sme_bsb.norm_gray_gc;
+    
+    if (entry->sme_bsb.label != NULL) {
+	int x_loc = entry->sme_bsb.left_margin;
+	int len = strlen(entry->sme_bsb.label);
+	int width, t_width;
+	char * label = entry->sme_bsb.label;
+
+	switch(entry->sme_bsb.justify) {
+	    case XtJustifyCenter:
+#ifdef XAW_INTERNATIONALIZATION
+		if ( entry->sme.international == True )
+		    t_width = XmbTextEscapement(entry->sme_bsb.fontset,label,len);
+		else
+#endif
+		    t_width = XTextWidth(entry->sme_bsb.font, label, len);
+
+		width = entry->rectangle.width -
+				(entry->sme_bsb.left_margin +
+				entry->sme_bsb.right_margin);
+		x_loc += (width - t_width)/2;
+		break;
+	    case XtJustifyRight:
+#ifdef XAW_INTERNATIONALIZATION
+		if ( entry->sme.international == True )
+		    t_width = XmbTextEscapement(entry->sme_bsb.fontset,label,len);
+		else
+#endif
+		    t_width = XTextWidth(entry->sme_bsb.font, label, len);
+
+		x_loc = entry->rectangle.width -
+				(entry->sme_bsb.right_margin + t_width);
+		break;
+	    case XtJustifyLeft:
+	    default:
+		break;
+	}
+
+	/* this will center the text in the gadget top-to-bottom */
+
+#ifdef XAW_INTERNATIONALIZATION
+        if ( entry->sme.international==True ) {
+            y_loc += ((int)entry->rectangle.height - 
+		  (fontset_ascent + fontset_descent)) / 2 + fontset_ascent;
+
+            XmbDrawString(XtDisplayOfObject(w), XtWindowOfObject(w),
+                entry->sme_bsb.fontset, gc, x_loc + s, y_loc, label, len);
+        }
+        else
+#endif
+        {
+            y_loc += ((int)entry->rectangle.height - 
+		  (font_ascent + font_descent)) / 2 + font_ascent;
+	
+            XDrawString(XtDisplayOfObject(w), XtWindowOfObject(w), gc,
+		    x_loc + s, y_loc, label, len);
+        }
+
+	if (entry->sme_bsb.underline >= 0 && entry->sme_bsb.underline < len) {
+	    int ul = entry->sme_bsb.underline;
+	    int ul_x1_loc = x_loc + s;
+	    int ul_wid;
+
+	    if (ul != 0)
+		ul_x1_loc += XTextWidth(entry->sme_bsb.font, label, ul);
+	    ul_wid = XTextWidth(entry->sme_bsb.font, &label[ul], 1) - 2;
+	    XDrawLine(XtDisplayOfObject(w), XtWindowOfObject(w), gc,
+		      ul_x1_loc, y_loc + 1, ul_x1_loc + ul_wid, y_loc + 1);
+	}
+    }
+
+    DrawBitmaps(w, gc);
+}
+
+
+/*      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, args, num_args)
+Widget current, request, new;
+ArgList args;
+Cardinal *num_args;
+{
+    Widget parent = XtParent(new);
+    SmeBSBObject entry = (SmeBSBObject) new;
+    SmeBSBObject old_entry = (SmeBSBObject) current;
+    Boolean ret_val = FALSE;
+
+    if (old_entry->sme_bsb.label != entry->sme_bsb.label) {
+        if (old_entry->sme_bsb.label != XtName( new ) )
+	    XtFree( (char *) old_entry->sme_bsb.label );
+
+	if (entry->sme_bsb.label != XtName(new) ) 
+	    entry->sme_bsb.label = XtNewString( entry->sme_bsb.label );
+
+	ret_val = TRUE;
+    }
+
+    if (entry->sme_bsb.underline != old_entry->sme_bsb.underline)
+	ret_val = TRUE;
+
+    if (entry->rectangle.sensitive != old_entry->rectangle.sensitive)
+	ret_val = TRUE;
+
+#ifdef XAW_INTERNATIONALIZATION
+    if (  (	(old_entry->sme_bsb.font != entry->sme_bsb.font) &&
+	(old_entry->sme.international == False )	          ) ||
+	(old_entry->sme_bsb.foreground != entry->sme_bsb.foreground) ) {
+#else
+    if (  (old_entry->sme_bsb.font != entry->sme_bsb.font) ||
+	(old_entry->sme_bsb.foreground != entry->sme_bsb.foreground) ) {
+#endif
+	DestroyGCs(current);
+	CreateGCs(new);
+
+	ret_val = TRUE;
+    }
+
+    if (entry->sme_bsb.left_bitmap != old_entry->sme_bsb.left_bitmap)
+    {
+	GetBitmapInfo(new, TRUE);
+
+#ifdef XAW_MULTIPLANE_PIXMAPS
+	entry->sme_bsb.left_stippled = None;
+	if (old_entry->sme_bsb.left_stippled != None)
+	    XFreePixmap(XtDisplayOfObject(current),
+			old_entry->sme_bsb.left_stippled);
+#endif
+
+	ret_val = TRUE;
+    }
+
+    if (entry->sme_bsb.left_margin != old_entry->sme_bsb.left_margin)
+	ret_val = TRUE;
+
+    if (entry->sme_bsb.right_bitmap != old_entry->sme_bsb.right_bitmap)
+    {
+	GetBitmapInfo(new, FALSE);
+
+#ifdef XAW_MULTIPLANE_PIXMAPS
+	entry->sme_bsb.right_stippled = None;
+	if (old_entry->sme_bsb.right_stippled != None)
+	    XFreePixmap(XtDisplayOfObject(current),
+			old_entry->sme_bsb.right_stippled);
+#endif
+
+	ret_val = TRUE;
+    }
+
+    if (entry->sme_bsb.right_margin != old_entry->sme_bsb.right_margin)
+	ret_val = TRUE;
+
+#ifdef XAW_INTERNATIONALIZATION
+    if ( ( old_entry->sme_bsb.fontset != entry->sme_bsb.fontset) &&
+				(old_entry->sme.international == True ) )
+        /* don't change the GCs - the fontset is not in them */
+        ret_val = TRUE;
+#endif
+
+    if (ret_val) {
+	GetDefaultSize(new, 
+		       &(entry->rectangle.width), &(entry->rectangle.height));
+	entry->sme_bsb.set_values_area_cleared = TRUE;
+
+	(parent->core.widget_class->core_class.resize)(new);
+    }
+
+    return(ret_val);
+}
+
+/*	Function Name: QueryGeometry.
+ *	Description: Returns the preferred geometry for this widget.
+ *	Arguments: w - the menu entry object.
+ *                 itended, return_val - the intended and return geometry info.
+ *	Returns: A Geometry Result.
+ *
+ * See the Intrinsics manual for details on what this function is for.
+ * 
+ * I just return the height and width of the label plus the margins.
+ */
+
+static XtGeometryResult
+QueryGeometry(w, intended, return_val) 
+Widget w;
+XtWidgetGeometry *intended, *return_val;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+    Dimension width, height, h;
+    XtGeometryResult ret_val = XtGeometryYes;
+    XtGeometryMask mode = intended->request_mode;
+
+    GetDefaultSize(w, &width, &height );
+
+    if ( ((mode & CWWidth) && (intended->width != width)) ||
+	 !(mode & CWWidth) ) {
+	return_val->request_mode |= CWWidth;
+	return_val->width = width;
+	ret_val = XtGeometryAlmost;
+    }
+
+    if ( ((mode & CWHeight) && (intended->height != height)) ||
+	 !(mode & CWHeight) ) {
+	return_val->request_mode |= CWHeight;
+	return_val->height = height;
+	ret_val = XtGeometryAlmost;
+    }
+
+    if (ret_val == XtGeometryAlmost) {
+	mode = return_val->request_mode;
+	
+	if ( ((mode & CWWidth) && (width == entry->rectangle.width)) &&
+	     ((mode & CWHeight) && (height == entry->rectangle.height)) )
+	    return(XtGeometryNo);
+    }
+
+    entry->rectangle.width = width;
+    entry->rectangle.height = height;
+
+    return(ret_val);
+}
+    
+/*
+ * FlipColors() used to be called directly, but it's blind
+ * state toggling caused re-unhighlighting problems.
+ */
+
+static void
+Highlight(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+
+    entry->sme_threeD.shadowed = True;
+    FlipColors(w);
+}
+
+static void
+Unhighlight(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+
+    entry->sme_threeD.shadowed = False;
+    FlipColors(w);
+}
+
+/************************************************************
+ *
+ * Private Functions.
+ *
+ ************************************************************/
+
+/*	Function Name: GetDefaultSize
+ *	Description: Calculates the Default (preferred) size of
+ *                   this menu entry.
+ *	Arguments: w - the menu entry widget.
+ *                 width, height - default sizes (RETURNED).
+ *	Returns: none.
+ */
+
+static void
+GetDefaultSize(w, width, height) 
+Widget w;
+Dimension * width, * height;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+    Dimension h;
+
+#ifdef XAW_INTERNATIONALIZATION
+    if ( entry->sme.international == True ) {
+        XFontSetExtents *ext = XExtentsOfFontSet(entry->sme_bsb.fontset);
+
+        if (entry->sme_bsb.label == NULL) 
+	    *width = 0;
+        else
+	    *width = XmbTextEscapement(entry->sme_bsb.fontset, entry->sme_bsb.label,
+			    strlen(entry->sme_bsb.label));
+
+        *height = ext->max_ink_extent.height;
+    }
+    else
+#endif
+    {
+        if (entry->sme_bsb.label == NULL) 
+	    *width = 0;
+        else
+	    *width = XTextWidth(entry->sme_bsb.font, entry->sme_bsb.label,
+			    strlen(entry->sme_bsb.label));
+
+        *height = (entry->sme_bsb.font->max_bounds.ascent +
+	       entry->sme_bsb.font->max_bounds.descent);
+    }
+
+    *width += entry->sme_bsb.left_margin + entry->sme_bsb.right_margin;
+    *width += (2 * entry->sme_threeD.shadow_width);
+
+    h = (entry->sme_bsb.left_bitmap_height > entry->sme_bsb.right_bitmap_height)
+	    ? entry->sme_bsb.left_bitmap_height : entry->sme_bsb.right_bitmap_height;
+    if (h > *height) *height = h;
+    *height = ((int)*height * (100 + entry->sme_bsb.vert_space)) / 100;
+    *height += (2 * entry->sme_threeD.shadow_width);
+}
+
+/*      Function Name: DrawBitmaps
+ *      Description: Draws left and right bitmaps.
+ *      Arguments: w - the simple menu widget.
+ *                 gc - graphics context to use for drawing.
+ *      Returns: none
+ */
+
+static void
+DrawBitmaps(w, gc)
+Widget w;
+GC gc;
+{
+#ifdef XAW_MULTIPLANE_PIXMAPS
+    Widget parent = XtParent(w);
+#endif
+    int x_loc, y_loc;
+    SmeBSBObject entry = (SmeBSBObject) w;
+    Pixmap pm;
+    
+    if ( (entry->sme_bsb.left_bitmap == None) && 
+	 (entry->sme_bsb.right_bitmap == None) ) return;
+
+/*
+ * Draw Left Bitmap.
+ */
+
+  if (entry->sme_bsb.left_bitmap != None) {
+    x_loc = entry->sme_threeD.shadow_width +
+		(int)(entry->sme_bsb.left_margin -
+		entry->sme_bsb.left_bitmap_width) / 2;
+
+    y_loc = entry->rectangle.y + (int)(entry->rectangle.height -
+		      entry->sme_bsb.left_bitmap_height) / 2;
+
+    pm = entry->sme_bsb.left_bitmap;
+#ifdef XAW_MULTIPLANE_PIXMAPS
+    if (!XtIsSensitive(w)) {
+	if (entry->sme_bsb.left_stippled == None)
+	    entry->sme_bsb.left_stippled = stipplePixmap(w,
+			entry->sme_bsb.left_bitmap,
+			parent->core.colormap,
+			parent->core.background_pixel,
+			entry->sme_bsb.left_depth);
+	if (entry->sme_bsb.left_stippled != None)
+	    pm = entry->sme_bsb.left_stippled;
+    }
+#endif
+
+    if (entry->sme_bsb.left_depth == 1)
+	XCopyPlane(XtDisplayOfObject(w), pm,
+		XtWindowOfObject(w), gc, 0, 0, 
+		entry->sme_bsb.left_bitmap_width,
+		entry->sme_bsb.left_bitmap_height, x_loc, y_loc, 1);
+    else
+	XCopyArea (XtDisplayOfObject(w), pm,
+		XtWindowOfObject(w), gc, 0, 0, 
+		entry->sme_bsb.left_bitmap_width,
+		entry->sme_bsb.left_bitmap_height, x_loc, y_loc);
+  }
+
+/*
+ * Draw Right Bitmap.
+ */
+
+  if (entry->sme_bsb.right_bitmap != None) {
+    x_loc = entry->rectangle.width - entry->sme_threeD.shadow_width -
+		(int)(entry->sme_bsb.right_margin +
+		entry->sme_bsb.right_bitmap_width) / 2;
+
+    y_loc = entry->rectangle.y + (int)(entry->rectangle.height -
+		      entry->sme_bsb.right_bitmap_height) / 2;
+
+     pm = entry->sme_bsb.right_bitmap;
+#ifdef XAW_MULTIPLANE_PIXMAPS
+    if (!XtIsSensitive(w)) {
+	if (entry->sme_bsb.right_stippled == None)
+	    entry->sme_bsb.right_stippled = stipplePixmap(w,
+			entry->sme_bsb.right_bitmap,
+			parent->core.colormap,
+			parent->core.background_pixel,
+			entry->sme_bsb.right_depth);
+	if (entry->sme_bsb.right_stippled != None)
+	    pm = entry->sme_bsb.right_stippled;
+    }
+#endif
+
+    if (entry->sme_bsb.right_depth == 1)
+	XCopyPlane(XtDisplayOfObject(w), pm,
+		XtWindowOfObject(w), gc, 0, 0, 
+		entry->sme_bsb.right_bitmap_width,
+		entry->sme_bsb.right_bitmap_height, x_loc, y_loc, 1);
+    else
+	XCopyArea (XtDisplayOfObject(w), pm,
+		XtWindowOfObject(w), gc, 0, 0, 
+		entry->sme_bsb.right_bitmap_width,
+		entry->sme_bsb.right_bitmap_height, x_loc, y_loc);
+  }
+}
+
+/*      Function Name: GetBitmapInfo
+ *      Description: Gets the bitmap information from either of the bitmaps.
+ *      Arguments: w - the bsb menu entry widget.
+ *                 is_left - TRUE if we are testing left bitmap,
+ *                           FALSE if we are testing the right bitmap.
+ *      Returns: none
+ */
+
+static void
+GetBitmapInfo(w, is_left)
+Widget w;
+Boolean is_left;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;    
+    Window root;
+    int x, y;
+    unsigned int width, height, bw;
+    char buf[BUFSIZ];
+    
+    if (is_left) {
+	width = height = 0;
+
+	if (entry->sme_bsb.left_bitmap != None) {
+	    if (!XGetGeometry(XtDisplayOfObject(w), 
+			    entry->sme_bsb.left_bitmap, &root, &x, &y,
+			    &width, &height, &bw, &entry->sme_bsb.left_depth)) {
+		(void) sprintf(buf, "Xaw SmeBSB Object: %s %s \"%s\".",
+			"Could not get Left Bitmap",
+			"geometry information for menu entry",
+			XtName(w));
+		XtAppError(XtWidgetToApplicationContext(w), buf);
+	    }
+#ifdef NEVER
+	    if (entry->sme_bsb.left_depth != 1) {
+		(void) sprintf(buf, "Xaw SmeBSB Object: %s \"%s\" %s.", 
+			"Left Bitmap of entry",  XtName(w),
+			"is not one bit deep");
+		XtAppError(XtWidgetToApplicationContext(w), buf);
+	    }
+#endif
+	}
+
+	entry->sme_bsb.left_bitmap_width = (Dimension) width; 
+	entry->sme_bsb.left_bitmap_height = (Dimension) height;
+    } else {
+	width = height = 0;
+
+	if (entry->sme_bsb.right_bitmap != None) {
+	    if (!XGetGeometry(XtDisplayOfObject(w),
+			    entry->sme_bsb.right_bitmap, &root, &x, &y,
+			    &width, &height, &bw, &entry->sme_bsb.right_depth)) {
+		(void) sprintf(buf, "Xaw SmeBSB Object: %s %s \"%s\".",
+			"Could not get Right Bitmap",
+			"geometry information for menu entry",
+			XtName(w));
+		XtAppError(XtWidgetToApplicationContext(w), buf);
+	    }
+#ifdef NEVER
+	    if (entry->sme_bsb.right_depth != 1) {
+		(void) sprintf(buf, "Xaw SmeBSB Object: %s \"%s\" %s.", 
+			"Right Bitmap of entry", XtName(w),
+			"is not one bit deep");
+		XtAppError(XtWidgetToApplicationContext(w), buf);
+	    }
+#endif
+	}
+
+	entry->sme_bsb.right_bitmap_width = (Dimension) width; 
+	entry->sme_bsb.right_bitmap_height = (Dimension) height;
+    }
+}      
+
+/*      Function Name: CreateGCs
+ *      Description: Creates all gc's for the simple menu widget.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: none.
+ */
+
+static void
+CreateGCs(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;    
+    XGCValues values;
+    XtGCMask mask;
+#ifdef XAW_INTERNATIONALIZATION
+    XtGCMask mask_i18n;
+#endif
+    
+    values.foreground = XtParent(w)->core.background_pixel;
+    values.background = entry->sme_bsb.foreground;
+    values.font = entry->sme_bsb.font->fid;
+    values.graphics_exposures = FALSE;
+    mask      = GCForeground | GCBackground | GCGraphicsExposures | GCFont;
+#ifdef XAW_INTERNATIONALIZATION
+    mask_i18n = GCForeground | GCBackground | GCGraphicsExposures;
+    if ( entry->sme.international == True )
+        entry->sme_bsb.rev_gc = XtAllocateGC(w, 0, mask_i18n, &values, GCFont, 0 );
+    else
+#endif
+        entry->sme_bsb.rev_gc = XtGetGC(w, mask, &values);
+    
+    values.foreground = entry->sme_bsb.foreground;
+    values.background = XtParent(w)->core.background_pixel;
+#ifdef XAW_INTERNATIONALIZATION
+    if ( entry->sme.international == True )
+        entry->sme_bsb.norm_gc = XtAllocateGC(w, 0, mask_i18n, &values, GCFont, 0 );
+    else
+#endif
+        entry->sme_bsb.norm_gc = XtGetGC(w, mask, &values);
+
+    values.fill_style = FillTiled;
+    values.tile   = XmuCreateStippledPixmap(XtScreenOfObject(w), 
+					    entry->sme_bsb.foreground,
+					    XtParent(w)->core.background_pixel,
+					    XtParent(w)->core.depth);
+    values.graphics_exposures = FALSE;
+    mask |= GCTile | GCFillStyle;
+#ifdef XAW_INTERNATIONALIZATION
+    if ( entry->sme.international == True )
+        entry->sme_bsb.norm_gray_gc = XtAllocateGC(w, 0, mask_i18n, &values, GCFont, 0 );
+    else
+#endif
+        entry->sme_bsb.norm_gray_gc = XtGetGC(w, mask, &values);
+
+    values.foreground ^= values.background;
+    values.background = 0;
+    values.function = GXxor;
+    mask = GCForeground | GCBackground | GCGraphicsExposures | GCFunction;
+    entry->sme_bsb.invert_gc = XtGetGC(w, mask, &values);
+}
+
+/*      Function Name: DestroyGCs
+ *      Description: Removes all gc's for the simple menu widget.
+ *      Arguments: w - the simple menu widget.
+ *      Returns: none.
+ */
+
+static void
+DestroyGCs(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;    
+
+    XtReleaseGC(w, entry->sme_bsb.norm_gc);
+    XtReleaseGC(w, entry->sme_bsb.norm_gray_gc);
+    XtReleaseGC(w, entry->sme_bsb.rev_gc);
+    XtReleaseGC(w, entry->sme_bsb.invert_gc);
+}
+
+/*      Function Name: FlipColors
+ *      Description: Invert the colors of the current entry.
+ *      Arguments: w - the bsb menu entry widget.
+ *      Returns: none.
+ */
+
+static void 
+FlipColors(w)
+Widget w;
+{
+    SmeBSBObject entry = (SmeBSBObject) w;
+    SmeBSBObjectClass oclass = (SmeBSBObjectClass) XtClass (w);
+    SimpleMenuWidget smw = (SimpleMenuWidget) XtParent (w);
+    ThreeDWidget tdw = (ThreeDWidget) smw->simple_menu.threeD;
+    Dimension s = tdw->threeD.shadow_width;
+
+    if (entry->sme_bsb.set_values_area_cleared) {
+	entry->sme_threeD.shadowed = False;
+	return;
+    }
+
+    if (entry->sme_threeD.shadow_width > 0) {
+	(*oclass->sme_threeD_class.shadowdraw) (w);
+    } else
+		XFillRectangle(XtDisplayOfObject(w), XtWindowOfObject(w),
+		   entry->sme_bsb.invert_gc, 
+		   s, (int) entry->rectangle.y,
+		   (unsigned int) entry->rectangle.width - 2 * s,
+		   (unsigned int) entry->rectangle.height);
+}
+