/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * HISTORY

*/ 

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: Primitive.c /main/25 1999/01/27 16:08:04 mgreess $"

#endif

#endif

/* (c) Copyright 1987, 1988, 1989, 1990, 1991, 1992 HEWLETT-PACKARD COMPANY */

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#include <Xm/AccColorT.h>

#include <Xm/ActivatableT.h>

#include <Xm/CareVisualT.h>

#include <Xm/DrawP.h>

#include <Xm/DisplayP.h>

#include <Xm/GadgetP.h>

#include <Xm/LayoutT.h>

#include <Xm/ManagerP.h>

#include <Xm/TraitP.h>

#include <Xm/TransltnsP.h>

#include <Xm/UnitTypeT.h>

#include <Xm/UnhighlightT.h>

#include "BaseClassI.h"

#include "ColorI.h"

#include "MessagesI.h"

#include "PixConvI.h"

#include "PrimitiveI.h"

#include "RepTypeI.h"

#include "ResConverI.h"

#include "ResIndI.h"

#include "SyntheticI.h"

#include "ToolTipI.h"

#include "TraitI.h"

#include "TravActI.h"

#include "TraversalI.h"

#include "UniqueEvnI.h"

#include "XmI.h"

#define MESSAGE1	_XmMMsgPrimitive_0000

/********    Static Function Declarations    ********/

static void GetXFromShell( 

			 Widget wid,

			 int resource_offset,

			 XtArgVal *value) ;

static void GetYFromShell( 

			 Widget wid,

			 int resource_offset,

			 XtArgVal *value) ;

static void ClassInitialize( void ) ;

static void BuildPrimitiveResources(

			 WidgetClass c ) ;

static void ClassPartInitialize( 

			 WidgetClass w) ;

static void Initialize( 

			 Widget rw,

			 Widget nw,

			 ArgList args,

			 Cardinal *num_args) ;

static void Realize( 

			 register Widget w,

			 XtValueMask *p_valueMask,

			 XSetWindowAttributes *attributes) ;

static void Destroy( 

			 Widget w) ;

static void Redisplay (

			 Widget w,

			 XEvent *event,

			 Region region);

static Boolean SetValues( 

			 Widget current,

			 Widget request,

			 Widget new_w,

			 ArgList args,

			 Cardinal *num_args) ;

static void HighlightBorder( 

			 Widget w) ;

static void UnhighlightBorder( 

			 Widget w) ;

static XmNavigability WidgetNavigable( 

			 Widget wid) ;

static void FocusChange( 

			 Widget wid,

			 XmFocusChange change) ;

static Boolean Redraw (Widget kid, 

			Widget cur_parent,

			Widget new_parent,

			Mask visual_flag);

static XmDirection GetDirection(Widget);

static void GetColors(Widget widget, 

		       XmAccessColorData color_data);

static unsigned char GetUnitType(Widget);

static void GetToolTipString(

                         Widget wid,

                         int resource, /* unused */

                         XtArgVal * value);

static XmImportOperator SetToolTipString(

                         Widget wid,

                         int resource, /* unused */

                         XtArgVal * value);

/********    End Static Function Declarations    ********/

/************************************************************************

 *

 *   Default translation table

 *	These translations will be compiled at class initialize.  When

 *	a subclass of primitive is created then these translations will

 *	be used to augment the translations of the subclass IFF

 *	traversal is on.  The SetValues routine will also augment

 *	a subclass's translations table IFF traversal goes from off to on.

 *	Since we are augmenting it should not be a problem when

 *	traversal goes from off to on to off and on again.

 *

 ************************************************************************/

#define defaultTranslations	_XmPrimitive_defaultTranslations

/************************************************************************

 *

 *   Action list.

 *

 *************************************<->***********************************/

static XtActionsRec actions[] =

{

  {"PrimitiveFocusIn",         _XmPrimitiveFocusIn},

  {"PrimitiveFocusOut",        _XmPrimitiveFocusOut},

  {"PrimitiveUnmap",           _XmPrimitiveUnmap},

  {"PrimitiveHelp",            _XmPrimitiveHelp},

  {"PrimitiveEnter",           _XmPrimitiveEnter},

  {"PrimitiveLeave",           _XmPrimitiveLeave},

  {"PrimitiveTraverseLeft",    _XmTraverseLeft},

  {"PrimitiveTraverseRight",   _XmTraverseRight},

  {"PrimitiveTraverseUp",      _XmTraverseUp },

  {"PrimitiveTraverseDown",    _XmTraverseDown },

  {"PrimitiveTraverseNext",    _XmTraverseNext },

  {"PrimitiveTraversePrev",    _XmTraversePrev },

  {"PrimitiveTraverseHome",    _XmTraverseHome },

  {"PrimitiveNextTabGroup",    _XmTraverseNextTabGroup },

  {"PrimitivePrevTabGroup",    _XmTraversePrevTabGroup },

  {"PrimitiveParentActivate",  _XmPrimitiveParentActivate },

  {"PrimitiveParentCancel",    _XmPrimitiveParentCancel },

  {"unmap",                    _XmPrimitiveUnmap},      /* Motif 1.0 BC. */

  {"Help",                     _XmPrimitiveHelp},       /* Motif 1.0 BC. */

  {"enter",                    _XmPrimitiveEnter},      /* Motif 1.0 BC. */

  {"leave",                    _XmPrimitiveLeave},      /* Motif 1.0 BC. */

  {"PrevTabGroup",	       _XmTraversePrevTabGroup},/* Motif 1.0 BC. */

  {"NextTabGroup",	       _XmTraverseNextTabGroup},/* Motif 1.0 BC. */

};

/*****************************************/

/*  Resource definitions for XmPrimitive */

static XtResource resources[] =

{

   {

     XmNunitType, XmCUnitType, XmRUnitType, 

     sizeof (unsigned char), XtOffsetOf(XmPrimitiveRec, primitive.unit_type),

     XmRCallProc, (XtPointer) _XmUnitTypeDefault

   },

   {

     XmNx, XmCPosition, XmRHorizontalPosition, 

     sizeof(Position), XtOffsetOf(WidgetRec, core.x), 

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNy, XmCPosition, XmRVerticalPosition, 

     sizeof(Position), XtOffsetOf(WidgetRec, core.y), 

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNwidth, XmCDimension, XmRHorizontalDimension, 

     sizeof(Dimension), XtOffsetOf(WidgetRec, core.width), 

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNheight, XmCDimension, XmRVerticalDimension, 

     sizeof(Dimension), XtOffsetOf(WidgetRec, core.height), 

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNborderWidth, XmCBorderWidth, XmRHorizontalDimension, 

     sizeof(Dimension), XtOffsetOf(WidgetRec, core.border_width), 

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNforeground, XmCForeground, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(XmPrimitiveRec, primitive.foreground),

     XmRCallProc, (XtPointer) _XmForegroundColorDefault

   },

   {

     XmNbackground, XmCBackground, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(WidgetRec, core.background_pixel),

     XmRCallProc, (XtPointer) _XmBackgroundColorDefault

   },

   {

     XmNtraversalOn, XmCTraversalOn, XmRBoolean, 

     sizeof (Boolean), XtOffsetOf(XmPrimitiveRec, primitive.traversal_on),

     XmRImmediate, (XtPointer) True

   },

   {

     XmNhighlightOnEnter, XmCHighlightOnEnter, XmRBoolean, 

     sizeof(Boolean), 

     XtOffsetOf(XmPrimitiveRec, primitive.highlight_on_enter),

     XmRImmediate, (XtPointer) False

   },

   {

     XmNnavigationType, XmCNavigationType, XmRNavigationType, 

     sizeof (unsigned char), 

     XtOffsetOf(XmPrimitiveRec, primitive.navigation_type),

     XmRImmediate, (XtPointer) XmNONE

   },

   {

     XmNhighlightThickness, XmCHighlightThickness, XmRHorizontalDimension,

     sizeof (Dimension),

     XtOffsetOf(XmPrimitiveRec, primitive.highlight_thickness),

     XmRCallProc, (XtPointer) _XmSetThickness

   },

   {

     XmNhighlightColor, XmCHighlightColor, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(XmPrimitiveRec, primitive.highlight_color),

     XmRCallProc, (XtPointer) _XmHighlightColorDefault

   },

   {

     XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension,

     sizeof (Dimension), 

     XtOffsetOf(XmPrimitiveRec, primitive.shadow_thickness),

     XmRCallProc, (XtPointer) _XmSetThickness

   },

   {

     XmNtopShadowColor, XmCTopShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmPrimitiveRec, primitive.top_shadow_color),

     XmRCallProc, (XtPointer) _XmTopShadowColorDefault

   },

   {

     XmNbottomShadowColor, XmCBottomShadowColor, XmRPixel, 

     sizeof (Pixel),

     XtOffsetOf(XmPrimitiveRec, primitive.bottom_shadow_color),

     XmRCallProc, (XtPointer) _XmBottomShadowColorDefault

   },

   {

     XmNbackgroundPixmap, XmCPixmap, XmRPixmap, 

     sizeof (Pixmap), XtOffsetOf(WidgetRec, core.background_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNhighlightPixmap, XmCHighlightPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap), XtOffsetOf(XmPrimitiveRec, primitive.highlight_pixmap),

     XmRCallProc, (XtPointer) _XmHighlightPixmapDefault

   },

   {

     XmNtopShadowPixmap, XmCTopShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmPrimitiveRec, primitive.top_shadow_pixmap),

     XmRCallProc, (XtPointer) _XmTopShadowPixmapDefault

   },

   {

     XmNbottomShadowPixmap, XmCBottomShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap),

     XtOffsetOf(XmPrimitiveRec, primitive.bottom_shadow_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNhelpCallback, XmCCallback, XmRCallback, 

     sizeof(XtCallbackList),

     XtOffsetOf(XmPrimitiveRec, primitive.help_callback),

     XmRPointer, (XtPointer) NULL

   },

   {

     XmNuserData, XmCUserData, XmRPointer, 

     sizeof(XtPointer),

     XtOffsetOf(XmPrimitiveRec, primitive.user_data),

     XmRImmediate, (XtPointer) NULL

   },

#ifndef XM_PART_BC

   {

     XmNpopupHandlerCallback, XmCCallback, XmRCallback, 

     sizeof(XtCallbackList),

     XtOffsetOf(XmPrimitiveRec, primitive.popup_handler_callback),

     XmRPointer, (XtPointer) NULL

   },

   {

      XmNconvertCallback, XmCCallback, XmRCallback, sizeof(XtCallbackList),

      XtOffsetOf(XmPrimitiveRec, primitive.convert_callback),

      XmRCallback, NULL

   },

   {

     XmNlayoutDirection, XmCLayoutDirection, XmRDirection,

     sizeof(XmDirection), 

     XtOffsetOf(XmPrimitiveRec, primitive.layout_direction),

     XmRCallProc, (XtPointer) _XmDirectionDefault

   },

#endif

};

#ifdef XM_PART_BC

XmDirection XmPrimLayoutDir = XmDEFAULT_DIRECTION ;

#endif

/***************************************/

/*  Definition for synthetic resources */

static XmSyntheticResource syn_resources[] =

{

   { XmNx,

     sizeof (Position), XtOffsetOf(WidgetRec, core.x), 

     GetXFromShell, XmeToHorizontalPixels },

   { XmNy, 

     sizeof (Position), XtOffsetOf(WidgetRec, core.y), 

     GetYFromShell, XmeToVerticalPixels },

   { XmNwidth,

     sizeof (Dimension), XtOffsetOf(WidgetRec, core.width),

     XmeFromHorizontalPixels, XmeToHorizontalPixels },

   { XmNheight,

     sizeof (Dimension), XtOffsetOf(WidgetRec, core.height), 

     XmeFromVerticalPixels, XmeToVerticalPixels },

   { XmNborderWidth, 

     sizeof (Dimension), XtOffsetOf(WidgetRec, core.border_width), 

     XmeFromHorizontalPixels, XmeToHorizontalPixels },

   { XmNhighlightThickness, 

     sizeof (Dimension), 

     XtOffsetOf(XmPrimitiveRec, primitive.highlight_thickness), 

     XmeFromHorizontalPixels, XmeToHorizontalPixels },

   { XmNshadowThickness, 

     sizeof (Dimension),

     XtOffsetOf(XmPrimitiveRec, primitive.shadow_thickness), 

     XmeFromHorizontalPixels, XmeToHorizontalPixels },

   { XmNtoolTipString,

     0,

     0,

     GetToolTipString, SetToolTipString }

};

/*******************************************/

/*  Declaration of class extension records */

static XmBaseClassExtRec baseClassExtRec = {

    NULL,

    NULLQUARK,

    XmBaseClassExtVersion,

    sizeof(XmBaseClassExtRec),

    NULL,				/* InitializePrehook	*/

    NULL,				/* SetValuesPrehook	*/

    NULL,				/* InitializePosthook	*/

    NULL,				/* SetValuesPosthook	*/

    NULL,				/* secondaryObjectClass	*/

    NULL,				/* secondaryCreate	*/

    NULL,		                /* getSecRes data	*/

    { 0 },				/* fastSubclass flags	*/

    NULL,				/* get_values_prehook	*/

    NULL,				/* get_values_posthook	*/

    NULL,                               /* classPartInitPrehook */

    NULL,                               /* classPartInitPosthook*/

    NULL,                               /* ext_resources        */

    NULL,                               /* compiled_ext_resources*/

    0,                                  /* num_ext_resources    */

    FALSE,                              /* use_sub_resources    */

    WidgetNavigable,                    /* widgetNavigable      */

    FocusChange,                        /* focusChange          */

};

static XmPrimitiveClassExtRec primClassExtRec = {

    NULL,

    NULLQUARK,

    XmPrimitiveClassExtVersion,

    sizeof(XmPrimitiveClassExtRec),

    NULL,                               /* widget_baseline */

    NULL,                               /* widget_display_rect */

    NULL                                /* widget_margins */

};

/*******************************************/

/*  The Primitive class record definition  */

externaldef(xmprimitiveclassrec) XmPrimitiveClassRec xmPrimitiveClassRec =

{

   {

      (WidgetClass) &widgetClassRec,    /* superclass	         */	

      "XmPrimitive",                    /* class_name	         */	

      sizeof(XmPrimitiveRec),           /* widget_size	         */	

      ClassInitialize,                  /* class_initialize      */    

      ClassPartInitialize,              /* class_part_initialize */

      False,                            /* class_inited          */	

      Initialize,                       /* initialize	         */	

      NULL,                             /* initialize_hook       */

      Realize,                          /* realize	         */	

      actions,                          /* actions               */	

      XtNumber(actions),                /* num_actions	         */	

      resources,                        /* resources	         */	

      XtNumber(resources),              /* num_resources         */	

      NULLQUARK,                        /* xrm_class	         */	

      True,                             /* compress_motion       */

      XtExposeCompressMaximal |		/* compress_exposure     */	

	  XtExposeNoRegion,

      True,                             /* compress_enterleave   */

      False,                            /* visible_interest      */

      Destroy,                          /* destroy               */	

      NULL,                             /* resize                */	

      Redisplay,                        /* expose                */	

      SetValues,                        /* set_values	         */	

      NULL,                             /* set_values_hook       */

      XtInheritSetValuesAlmost,         /* set_values_almost     */

      _XmPrimitiveGetValuesHook,        /* get_values_hook       */

      NULL,                             /* accept_focus	         */	

      XtVersion,                        /* version               */

      NULL,                             /* callback private      */

      NULL,                             /* tm_table              */

      NULL,                             /* query_geometry        */

      NULL,				/* display_accelerator   */

      (XtPointer)&baseClassExtRec,      /* extension             */

   },

   {

      HighlightBorder,		        /* border_highlight   */

      UnhighlightBorder,		/* border_unhighlight */

      defaultTranslations,		/* translations       */

      NULL,				/* arm_and_activate   */

      syn_resources,			/* syn resources      */

      XtNumber(syn_resources),		/* num_syn_resources  */

      (XtPointer)&primClassExtRec,      /* extension        */

   }

};

externaldef(xmprimitivewidgetclass) WidgetClass xmPrimitiveWidgetClass = 

				     (WidgetClass) &xmPrimitiveClassRec;

static XmConst XmSpecifyLayoutDirectionTraitRec primLDT = {

  0,			/* version */

  GetDirection

};

/* Care visual Trait record for Primitive */

static XmConst XmCareVisualTraitRec primCVT = {

    0,		/* version */

    Redraw,

};

/* Access Colors Trait record for Primitive */

static XmConst XmAccessColorsTraitRec primACT = {

  0,			/* version */

  GetColors

};

/* Unit Type Trait record for Primitive */

static XmConst XmSpecUnitTypeTraitRec primUTT = {

  0,			/* version */

  GetUnitType

};

/**************************************************************************

**

** Synthetic resource hooks function section

**

**************************************************************************/

static void 

GetXFromShell(

	 Widget wid,

	 int resource_offset,

	 XtArgVal *value )

{   

    /* return the x in the child's unit type; for children of shell, return

     ** the parent's x relative to the origin, in pixels

     */

    Position	rootx, rooty;

    Widget parent = XtParent(wid);

    if (XtIsShell(parent))

    {   

	 XtTranslateCoords( (Widget) wid, 

		 (Position) 0, (Position) 0, &rootx, &rooty) ;

	 *value = (XtArgVal) rootx;

    }

    else

    {

	 *value = (XtArgVal) wid->core.x ;

	 XmeFromHorizontalPixels(wid,  resource_offset, value);

    }

}

static void 

GetYFromShell(

	 Widget wid,

	 int resource_offset,

	 XtArgVal *value )

{   

    /* return the y in the child's unit type; for children of shell, return

     ** the parent's y relative to the origin, in pixels

     */

    Position	rootx, rooty;

    Widget parent = XtParent(wid);

    if (XtIsShell(parent))

    {   

	 XtTranslateCoords( (Widget) wid, 

		 (Position) 0, (Position) 0, &rootx, &rooty) ;

	 *value = (XtArgVal) rooty;

    }

    else

    {

	 *value = (XtArgVal) wid->core.y ;

	 XmeFromVerticalPixels(wid,  resource_offset, value);

    }

}

/************************************************************************

 *

 *  ClassInitialize

 *

 ************************************************************************/

static void 

ClassInitialize( void )

{

   /* These routines are called for each base classes,

	they just returned if it has been done already */

   _XmRegisterConverters();

   _XmRegisterPixmapConverters();

   _XmInitializeExtensions();

   _XmInitializeTraits();

   baseClassExtRec.record_type = XmQmotif;

}

/**********************************************************************

 *

 *  BuildPrimitiveResources

 *	Build up the primitive's synthetic resource processing 

 *      list by combining the super classes with this class.

 *

 **********************************************************************/

static void 

BuildPrimitiveResources(

	 WidgetClass c )

{

    XmPrimitiveWidgetClass wc = (XmPrimitiveWidgetClass) c ;

    XmPrimitiveWidgetClass sc = (XmPrimitiveWidgetClass) 

	 wc->core_class.superclass;

    _XmInitializeSyntheticResources(wc->primitive_class.syn_resources,

				    wc->primitive_class.num_syn_resources);

    if (sc == (XmPrimitiveWidgetClass) widgetClass) return;

    _XmBuildResources (&(wc->primitive_class.syn_resources),

			&(wc->primitive_class.num_syn_resources),

			sc->primitive_class.syn_resources,

			sc->primitive_class.num_syn_resources);

}

/************************************************************************

 *

 *  ClassPartInitialize

 *    Set up the inheritance mechanism for the routines exported by

 *    primitives class part.

 *

 ************************************************************************/

static void 

ClassPartInitialize(

	 WidgetClass w )

{

    static Boolean first_time = TRUE;

    XmPrimitiveWidgetClass wc = (XmPrimitiveWidgetClass) w;

    XmPrimitiveWidgetClass super =

	(XmPrimitiveWidgetClass) wc->core_class.superclass;

    XmPrimitiveClassExt              *wcePtr, *scePtr;

    _XmFastSubclassInit (w, XmPRIMITIVE_BIT);

    /*** first deal with inheritance of regular class method */

    if (wc->primitive_class.border_highlight == XmInheritWidgetProc)

	wc->primitive_class.border_highlight =

	    super->primitive_class.border_highlight;

    if (wc->primitive_class.border_unhighlight == XmInheritWidgetProc)

	wc->primitive_class.border_unhighlight =

	    super->primitive_class.border_unhighlight;

    if (wc->primitive_class.translations == XtInheritTranslations)

	wc->primitive_class.translations = 

	    super->primitive_class.translations;

    else if (wc->primitive_class.translations)

	wc->primitive_class.translations = (String)

	    XtParseTranslationTable(wc->primitive_class.translations);

    if (wc->primitive_class.arm_and_activate == XmInheritArmAndActivate)

        wc->primitive_class.arm_and_activate =

	    super->primitive_class.arm_and_activate;

    /* synthetic resource management */

    BuildPrimitiveResources((WidgetClass) wc);

    /*** then look at the extension.

      if it's NULL, create a new one with inherit everywhere,

      then do the inheritance. */

    wcePtr = _XmGetPrimitiveClassExtPtr(wc, NULLQUARK);

    if (*wcePtr == NULL) {

	*wcePtr = (XmPrimitiveClassExt) XtCalloc(1, 

					 sizeof(XmPrimitiveClassExtRec)) ;

	(*wcePtr)->next_extension = NULL;

	(*wcePtr)->record_type 	= NULLQUARK;

	(*wcePtr)->version	= XmPrimitiveClassExtVersion ;

	(*wcePtr)->record_size	= sizeof(XmPrimitiveClassExtRec);

	(*wcePtr)->widget_baseline = XmInheritBaselineProc;

	(*wcePtr)->widget_display_rect  = XmInheritDisplayRectProc ;

	(*wcePtr)->widget_margins = XmInheritMarginsProc ;

    }

    if ((WidgetClass)wc != xmPrimitiveWidgetClass) {

	scePtr = _XmGetPrimitiveClassExtPtr(super, NULLQUARK);

	if ((*wcePtr)->widget_baseline == XmInheritBaselineProc)

	    (*wcePtr)->widget_baseline = (*scePtr)->widget_baseline;

	if ((*wcePtr)->widget_display_rect == XmInheritDisplayRectProc)

	    (*wcePtr)->widget_display_rect  = (*scePtr)->widget_display_rect;

	if ((*wcePtr)->widget_margins == XmInheritMarginsProc)

	    (*wcePtr)->widget_margins  = (*scePtr)->widget_margins;

    }

    /*** Carry this ugly non portable code that deal with Xt internals.

       Maintain first_time because we want to do that only once 

       Object ClassPartInit has been called */

    if (first_time) {

        _XmReOrderResourceList(xmPrimitiveWidgetClass, XmNunitType, NULL);

        _XmReOrderResourceList(xmPrimitiveWidgetClass, 

			       XmNforeground, XmNbackground);

        first_time = FALSE;

    }

    /*** setting up traits for all subclasses as well.*/

    XmeTraitSet((XtPointer)wc, XmQTspecifyLayoutDirection,(XtPointer)&primLDT);

    XmeTraitSet((XtPointer)wc, XmQTcareParentVisual, (XtPointer)&primCVT);

    XmeTraitSet((XtPointer)wc, XmQTaccessColors, (XtPointer)&primACT);

    XmeTraitSet((XtPointer)wc, XmQTspecifyUnitType, (XtPointer)&primUTT);

}

/************************************************************************

 *

 *  Initialize

 *     The main widget instance initialization routine.

 *

 ************************************************************************/

static void 

Initialize(

        Widget rw,

        Widget nw,

        ArgList args,

        Cardinal *num_args )

{

    XmPrimitiveWidget request = (XmPrimitiveWidget) rw ;

    XmPrimitiveWidget pw = (XmPrimitiveWidget) nw ;

    XtTranslations translations ;

    XmString tool_tip_string;

    static XtResource subresources[] =

    {

        {

            XmNtoolTipString, XmCToolTipString, XmRXmString,

            sizeof(XmString), 0,

            XmRImmediate, (XtPointer) NULL

        },

    };

    _XmProcessLock();

    translations = (XtTranslations) ((XmPrimitiveClassRec *) XtClass( pw))

	->primitive_class.translations ;

    _XmProcessUnlock();

    XtGetSubresources(nw, &tool_tip_string, NULL, NULL,

         subresources, XtNumber(subresources),

	 args, *num_args);

    XmSetToolTipString(nw, (XmString) tool_tip_string);

    if(    pw->primitive.traversal_on

       && translations  &&  pw->core.tm.translations

       && !XmIsLabel( pw)    )

	{   

	    /*  If this widget is requesting traversal then augment its

	     * translation table with some additional events.

	     * We will only augment translations for a widget which

	     * already has some translations defined; this allows widgets

	     * which want to set different translations (i.e. menus) to

	     * it at a later point in time.

	     * We do not override RowColumn and Label subclasses, these

	     * are handled by those classes.

	     */

	    XtOverrideTranslations( (Widget) pw, translations) ;

	} 

    pw->primitive.have_traversal = FALSE ;

    pw->primitive.highlighted = FALSE ;

    pw->primitive.highlight_drawn = FALSE ;

    if((pw->primitive.navigation_type != XmDYNAMIC_DEFAULT_TAB_GROUP)

       && !XmRepTypeValidValue(XmRID_NAVIGATION_TYPE, 

                               pw->primitive.navigation_type, 

			       (Widget) pw))

	{   pw->primitive.navigation_type = XmNONE ;

	} 

    _XmNavigInitialize( (Widget) request, (Widget) pw, args, num_args);

    if(    !XmRepTypeValidValue( XmRID_UNIT_TYPE,

				pw->primitive.unit_type, (Widget) pw)    )

	{

	    pw->primitive.unit_type = XmPIXELS;

	}

    /*  Convert the fields from unit values to pixel values  */

    _XmPrimitiveImportArgs( (Widget) pw, args, num_args);

    /*  Check the geometry information for the widget  */

    if (request->core.width == 0)

	pw->core.width += pw->primitive.highlight_thickness * 2 +

	    pw->primitive.shadow_thickness * 2;

    if (request->core.height == 0)

	pw->core.height += pw->primitive.highlight_thickness * 2 + 

	    pw->primitive.shadow_thickness * 2;

    /*  Get the graphics contexts for the border drawing  */

    pw->primitive.highlight_GC = 

	_XmGetPixmapBasedGC (nw, 

			     pw->primitive.highlight_color,

			     pw->core.background_pixel,

			     pw->primitive.highlight_pixmap);

    pw->primitive.top_shadow_GC = 

	_XmGetPixmapBasedGC (nw, 

			     pw->primitive.top_shadow_color,

			     pw->core.background_pixel,

			     pw->primitive.top_shadow_pixmap);

    pw->primitive.bottom_shadow_GC = 

	_XmGetPixmapBasedGC (nw, 

			     pw->primitive.bottom_shadow_color,

			     pw->core.background_pixel,

			     pw->primitive.bottom_shadow_pixmap);

}

/************************************************************************

 *

 *  Realize

 *	General realize procedure for primitive widgets.  Lets the bit

 *	gravity default to Forget.

 *

 ************************************************************************/

static void 

Realize(

        register Widget w,

        XtValueMask *p_valueMask,

        XSetWindowAttributes *attributes )

{

   Mask valueMask = *p_valueMask;

   valueMask |= CWDontPropagate;

   attributes->do_not_propagate_mask =

      ButtonPressMask | ButtonReleaseMask |

      KeyPressMask | KeyReleaseMask | PointerMotionMask;

   XtCreateWindow (w, InputOutput, CopyFromParent, valueMask, attributes);

}

/************************************************************************

 *

 *  Redisplay

 *     General redisplay function called on exposure events.

 *

 ************************************************************************/

/* ARGSUSED */

static void 

Redisplay(

        Widget wid,

        XEvent *event,

        Region region )

{

    XmPrimitiveWidget pw = (XmPrimitiveWidget) wid ;