/* 

 * 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 HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: Manager.c /main/22 1999/01/27 16:07:30 mgreess $"

#endif

#endif

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

#include <Xm/AccColorT.h>

#include <Xm/CareVisualT.h>

#include <Xm/DrawP.h>

#include <Xm/LayoutT.h>

#include <Xm/TraitP.h>

#include <Xm/TransltnsP.h>

#include <Xm/UnitTypeT.h>

#include "BaseClassI.h"

#include "CareVisualTI.h"

#include "ColorI.h"

#include "DisplayP.h"

#include "GadgetI.h"

#include "GadgetUtiI.h"

#include "ImageCachI.h"

#include "ManagerI.h"

#include "MessagesI.h"

#include "PixConvI.h"

#include "RepTypeI.h"

#include "ResConverI.h"

#include "ResIndI.h"

#include "SyntheticI.h"

#include "TraitI.h"

#include "TravActI.h"

#include "TraversalI.h"

#include "UniqueEvnI.h"

#include "XmI.h"

#define MESSAGE1 _XmMMsgManager_0000

#define MESSAGE2 _XmMMsgManager_0001

/********    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 CompositeClassExtension FindCompClassExtension( 

                        WidgetClass widget_class) ;

static void BuildManagerResources(

			WidgetClass c) ;

static void ClassPartInitialize( 

                        WidgetClass wc) ;

static void Initialize( 

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void Realize( 

                        Widget w,

                        XtValueMask *p_valueMask,

                        XSetWindowAttributes *attributes) ;

static void Destroy( 

                        Widget w) ;

static Boolean SetValues( 

                        Widget current,

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void InsertChild( 

                        Widget child) ;

static void DeleteChild( 

                        Widget child) ;

static void ManagerMotion( 

                        Widget wid,

                        XtPointer closure,

                        XEvent *event,

                        Boolean *cont) ;

static void ManagerEnter( 

                        Widget wid,

                        XtPointer closure,

                        XEvent *event,

                        Boolean *cont) ;

static void ManagerLeave( 

                        Widget wid,

                        XtPointer closure,

                        XEvent *event,

                        Boolean *cont) ;

static void AddMotionHandlers( 

                        XmManagerWidget mw) ;

static void ConstraintInitialize( 

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static void CheckRemoveMotionHandlers( 

                        XmManagerWidget mw) ;

static void ConstraintDestroy( 

                        Widget w) ;

static Boolean ConstraintSetValues( 

                        Widget current,

                        Widget request,

                        Widget new_w,

                        ArgList args,

                        Cardinal *num_args) ;

static Boolean ManagerParentProcess( 

                        Widget widget,

                        XmParentProcessData data) ;

static XmNavigability WidgetNavigable( 

                        Widget wid) ;

static Widget ObjectAtPoint(

			      Widget wid, 

			      Position x, Position y);

static XmDirection GetDirection(Widget);

static void GetColors(Widget widget, 

		      XmAccessColorData color_data);

static unsigned char GetUnitType(Widget);

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

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

/*  Default actions for XmManager  */

static XtActionsRec actions[] = {

	{ "ManagerGadgetTraverseCurrent",  _XmGadgetTraverseCurrent },

	{ "ManagerEnter",               _XmManagerEnter },

	{ "ManagerLeave",               _XmManagerLeave },

	{ "ManagerFocusIn",             _XmManagerFocusIn },  

	{ "ManagerFocusOut",            _XmManagerFocusOut },  

	{ "ManagerGadgetPrevTabGroup",  _XmGadgetTraversePrevTabGroup},

	{ "ManagerGadgetNextTabGroup",  _XmGadgetTraverseNextTabGroup},

	{ "ManagerGadgetTraversePrev",  _XmGadgetTraversePrev },  

	{ "ManagerGadgetTraverseNext",  _XmGadgetTraverseNext },  

	{ "ManagerGadgetTraverseLeft",  _XmGadgetTraverseLeft },  

	{ "ManagerGadgetTraverseRight", _XmGadgetTraverseRight },  

	{ "ManagerGadgetTraverseUp",    _XmGadgetTraverseUp },  

	{ "ManagerGadgetTraverseDown",  _XmGadgetTraverseDown },  

	{ "ManagerGadgetTraverseHome",  _XmGadgetTraverseHome },

	{ "ManagerGadgetSelect",        _XmGadgetSelect },

	{ "ManagerParentActivate",      _XmManagerParentActivate },

	{ "ManagerParentCancel",        _XmManagerParentCancel },

	{ "ManagerGadgetButtonMotion",  _XmGadgetButtonMotion },

	{ "ManagerGadgetKeyInput",      _XmGadgetKeyInput },

	{ "ManagerGadgetHelp",          _XmManagerHelp },

        { "ManagerGadgetArm",           _XmGadgetArm },

        { "ManagerGadgetDrag",          _XmGadgetDrag },

	{ "ManagerGadgetActivate",      _XmGadgetActivate },

	{ "ManagerGadgetMultiArm",      _XmGadgetMultiArm },

	{ "ManagerGadgetMultiActivate", _XmGadgetMultiActivate },

        { "Enter",           _XmManagerEnter },         /* Motif 1.0 BC. */

        { "FocusIn",         _XmManagerFocusIn },       /* Motif 1.0 BC. */

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

        { "Arm",             _XmGadgetArm },            /* Motif 1.0 BC. */

	{ "Activate",        _XmGadgetActivate },       /* Motif 1.0 BC. */

};

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

/*  Resource definitions for XmManager  */

static XtResource resources[] =

{

   {

     XmNunitType, XmCUnitType, XmRUnitType, 

     sizeof (unsigned char), XtOffsetOf(XmManagerRec, manager.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(XmManagerRec, manager.foreground),

     XmRCallProc, (XtPointer) _XmForegroundColorDefault

   },

   {

     XmNbackground, XmCBackground, XmRPixel, 

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

     XmRCallProc, (XtPointer) _XmBackgroundColorDefault

   },

   {

     XmNbackgroundPixmap, XmCPixmap, XmRPixmap, 

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

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNhighlightColor, XmCHighlightColor, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(XmManagerRec, manager.highlight_color),

     XmRCallProc, (XtPointer) _XmHighlightColorDefault

   },

   {

     XmNhighlightPixmap, XmCHighlightPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap), XtOffsetOf(XmManagerRec, manager.highlight_pixmap),

     XmRCallProc, (XtPointer) _XmHighlightPixmapDefault

   },

   {

     XmNnavigationType, XmCNavigationType, XmRNavigationType, 

     sizeof (unsigned char), 

     XtOffsetOf(XmManagerRec, manager.navigation_type),

     XmRImmediate, (XtPointer) XmTAB_GROUP,

   },

   {

     XmNshadowThickness, XmCShadowThickness, XmRHorizontalDimension, 

     sizeof (Dimension), XtOffsetOf(XmManagerRec, manager.shadow_thickness),

     XmRImmediate, (XtPointer) 0

   },

   {

     XmNtopShadowColor, XmCTopShadowColor, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(XmManagerRec, manager.top_shadow_color),

     XmRCallProc, (XtPointer) _XmTopShadowColorDefault

   },

   {

     XmNtopShadowPixmap, XmCTopShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap), XtOffsetOf(XmManagerRec, manager.top_shadow_pixmap),

     XmRCallProc, (XtPointer) _XmTopShadowPixmapDefault

   },

   {

     XmNbottomShadowColor, XmCBottomShadowColor, XmRPixel, 

     sizeof (Pixel), XtOffsetOf(XmManagerRec, manager.bottom_shadow_color),

     XmRCallProc, (XtPointer) _XmBottomShadowColorDefault

   },

   {

     XmNbottomShadowPixmap, XmCBottomShadowPixmap, XmRNoScalingDynamicPixmap,

     sizeof (Pixmap), XtOffsetOf(XmManagerRec, manager.bottom_shadow_pixmap),

     XmRImmediate, (XtPointer) XmUNSPECIFIED_PIXMAP

   },

   {

     XmNhelpCallback, XmCCallback, XmRCallback, 

     sizeof(XtCallbackList), XtOffsetOf(XmManagerRec, manager.help_callback),

     XmRPointer, (XtPointer) NULL

   },

#ifndef XM_PART_BC

   {

     XmNpopupHandlerCallback, XmCCallback, XmRCallback, 

     sizeof(XtCallbackList), 

     XtOffsetOf(XmManagerRec, manager.popup_handler_callback),

     XmRPointer, (XtPointer) NULL

   },

#endif

   {

     XmNuserData, XmCUserData, XmRPointer, 

     sizeof(XtPointer), XtOffsetOf(XmManagerRec, manager.user_data),

     XmRPointer, (XtPointer) NULL

   },

   {

     XmNtraversalOn, XmCTraversalOn, XmRBoolean, 

     sizeof(Boolean), XtOffsetOf(XmManagerRec, manager.traversal_on),

     XmRImmediate, (XtPointer) TRUE

   },

   {

     XmNstringDirection, XmCStringDirection, XmRStringDirection,

     sizeof(XmStringDirection), 

     XtOffsetOf(XmManagerRec, manager.string_direction),

     XmRImmediate, (XtPointer) XmSTRING_DIRECTION_DEFAULT

   },

   {

     XmNlayoutDirection, XmCLayoutDirection, XmRDirection,

     sizeof(XmDirection), 

     XtOffsetOf(XmManagerRec, manager.string_direction),

     XmRCallProc, (XtPointer) _XmDirectionDefault

   },

   {   

     XmNinitialFocus, XmCInitialFocus, XmRWidget,

     sizeof(Widget), XtOffsetOf(XmManagerRec, manager.initial_focus),

     XmRImmediate, NULL

   } 

};

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

/*  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 },

   { XmNshadowThickness, 

     sizeof (Dimension), XtOffsetOf(XmManagerRec, manager.shadow_thickness), 

     XmeFromHorizontalPixels, XmeToHorizontalPixels },

   { XmNstringDirection,

     sizeof(XmStringDirection), 

     XtOffsetOf(XmManagerRec, manager.string_direction),

     _XmFromLayoutDirection, _XmToLayoutDirection }

};

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

/*  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,				/* getValuesPrehook	*/

    NULL,				/* getValuesPosthook	*/

    NULL,                               /* ClassPartInitPrehook */

    NULL,                               /* classPartInitPosthook*/

    NULL,                               /* ext_resources        */

    NULL,                               /* compiled_ext_resources*/

    0,                                  /* num_ext_resources    */

    FALSE,                              /* use_sub_resources    */

    WidgetNavigable,                    /* widgetNavigable      */

    NULL                                /* focusChange          */

};

static CompositeClassExtensionRec compositeClassExtRec = {

    NULL,

    NULLQUARK,

    XtCompositeExtensionVersion,

    sizeof(CompositeClassExtensionRec),

    TRUE,                               /* accepts_objects */

};

static XmManagerClassExtRec managerClassExtRec = {

    NULL,

    NULLQUARK,

    XmManagerClassExtVersion,

    sizeof(XmManagerClassExtRec),

    NULL,                               /* traversal_children */

    ObjectAtPoint                       /* object_at_point */

};

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

/*  The Manager class record definition.  */

externaldef(xmmanagerclassrec) XmManagerClassRec xmManagerClassRec =

{

   {

      (WidgetClass) &constraintClassRec,     /* superclass            */

     "XmManager",		             /* class_name	      */

      sizeof(XmManagerRec),                  /* 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     */

      True,                                  /* compress enterleave   */

      False,                                 /* visible_interest      */

      Destroy,                               /* destroy               */

      NULL,                                  /* resize                */

      NULL,                                  /* expose                */

      SetValues,                             /* set_values	      */

      NULL,                                  /* set_values_hook       */

      XtInheritSetValuesAlmost,              /* set_values_almost     */

      _XmManagerGetValuesHook,               /* get_values_hook       */

      NULL,                                  /* accept_focus	      */

      XtVersion,                             /* version               */

      NULL,                                  /* callback private      */

      _XmManager_defaultTranslations,        /* tm_table              */

      NULL,                                  /* query geometry        */

      NULL,                                  /* display_accelerator   */

      (XtPointer)&baseClassExtRec,           /* extension             */

   },

   {					     /* composite class   */

      NULL,                                  /* Geometry Manager  */

      NULL,                                  /* Change Managed    */

      InsertChild,                           /* Insert Child      */

      DeleteChild,	                     /* Delete Child      */

      (XtPointer)&compositeClassExtRec,      /* extension         */

   },

   {						/* constraint class	*/

      NULL,					/* resources		*/

      0,					/* num resources	*/

      sizeof (XmManagerConstraintRec),	        /* constraint record	*/

      ConstraintInitialize,			/* initialize		*/

      ConstraintDestroy,			/* destroy		*/

      ConstraintSetValues,			/* set values		*/

      NULL,					/* extension		*/

   },

   {						/* manager class	  */

      _XmManager_managerTraversalTranslations,  /* default translations   */

      syn_resources,				/* syn resources      	  */

      XtNumber(syn_resources),			/* num_syn_resources 	  */

      NULL,					/* syn_cont_resources     */

      0,					/* num_syn_cont_resources */

      ManagerParentProcess,                     /* parent_process         */

      (XtPointer)&managerClassExtRec,		/* extension		  */

   },

};

externaldef(xmmanagerwidgetclass) WidgetClass xmManagerWidgetClass = 

                                 (WidgetClass) &xmManagerClassRec;

static XmConst XmSpecifyLayoutDirectionTraitRec manLDT = {

  0,			/* version */

  GetDirection

};

/* Access Colors Trait record for Manager */

static XmConst XmAccessColorsTraitRec manACT = {

  0,			/* version */

  GetColors

};

/* Unit Type Trait record for Manager */

static XmConst XmSpecUnitTypeTraitRec manUTT = {

  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 */

    Widget parent = XtParent(wid);

    if (XtIsShell(parent)) {   

	/* at the moment menuShell doesn't reset x,y values to 0, so 

	** we'll have them counted twice if we use XtTranslateCoords

	*/

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

    } 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 */

    Widget parent = XtParent(wid);

    if (XtIsShell(parent)) {   

	/* at the moment menuShell doesn't reset x,y values to 0, so 

	** we'll have them counted twice if we use XtTranslateCoords

	*/

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

    } 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;

}

static CompositeClassExtension 

FindCompClassExtension(

        WidgetClass widget_class )

{

    CompositeClassExtension ext;

    ext = (CompositeClassExtension)((CompositeWidgetClass)widget_class)

	       ->composite_class.extension;

    while ((ext != NULL) && (ext->record_type != NULLQUARK))

      ext = (CompositeClassExtension)ext->next_extension;

    if (ext != NULL) {

	/* fix for 9640: check for older version of the extension as well */

	if (  ext->version <= XtCompositeExtensionVersion &&

	      ext->record_size <= sizeof(CompositeClassExtensionRec)) {

	    /*EMPTY*/

	    /* continue */

	} else {

	    String params[1];

	    Cardinal num_params = 1;

	    params[0] = widget_class->core_class.class_name;

	    XtErrorMsg( "invalidExtension", "ManagerClassPartInitialize",

		        "XmToolkitError",

		       MESSAGE1, params, &num_params);

	}

    }

    return ext;

}

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

 *

 *  BuildManagerResources

 *	Build up the manager's synthetic and constraint synthetic

 *	resource processing list by combining the super classes with 

 *	this class.

 *

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

static void 

BuildManagerResources(

        WidgetClass c )

{

    XmManagerWidgetClass wc = (XmManagerWidgetClass) c ;

    XmManagerWidgetClass sc;

    sc = (XmManagerWidgetClass) wc->core_class.superclass;

    _XmInitializeSyntheticResources(wc->manager_class.syn_resources,

				    wc->manager_class.num_syn_resources);

    _XmInitializeSyntheticResources(

			wc->manager_class.syn_constraint_resources,

			wc->manager_class.num_syn_constraint_resources);

    if (sc == (XmManagerWidgetClass) constraintWidgetClass) return;

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

		       &(wc->manager_class.num_syn_resources),

		       sc->manager_class.syn_resources,

		       sc->manager_class.num_syn_resources);

    _XmBuildResources (&(wc->manager_class.syn_constraint_resources),

		       &(wc->manager_class.num_syn_constraint_resources),

		       sc->manager_class.syn_constraint_resources,

		       sc->manager_class.num_syn_constraint_resources);

}

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

 *

 * ClassPartInitialize

 *

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

static void 

ClassPartInitialize(

        WidgetClass wc )

{

    static Boolean first_time = TRUE;

    XmManagerWidgetClass mw = (XmManagerWidgetClass) wc;

    XmManagerWidgetClass super = (XmManagerWidgetClass)

	                        mw->core_class.superclass;

    XmManagerClassExt *mext = (XmManagerClassExt *)

	_XmGetClassExtensionPtr((XmGenericClassExt *)

				&(mw->manager_class.extension), NULLQUARK) ;

    _XmFastSubclassInit (wc, XmMANAGER_BIT);

    /*** start by doing the inheritance for Xt... */

    if (FindCompClassExtension(wc) == NULL) {

	CompositeClassExtension comp_ext ;

	XtPointer *comp_extP

	    = &((CompositeWidgetClass)wc)->composite_class.extension;

	comp_ext = XtNew(CompositeClassExtensionRec);

	memcpy(comp_ext, FindCompClassExtension(wc->core_class.superclass),

	       sizeof(CompositeClassExtensionRec));

	comp_ext->next_extension = *comp_extP;

	*comp_extP = (XtPointer)comp_ext;

    }

    /*** deal with inheritance for regular methods */

    if (mw->manager_class.translations == XtInheritTranslations)

	mw->manager_class.translations = super->manager_class.translations;

    else if (mw->manager_class.translations)

	mw->manager_class.translations = (String)

	    XtParseTranslationTable(mw->manager_class.translations);

    if (mw->manager_class.parent_process == XmInheritParentProcess)

	mw->manager_class.parent_process = 

	    super->manager_class.parent_process;

    /* synthetic resource management */

    BuildManagerResources((WidgetClass) wc);

    /*** then deal with class extension inheritance.

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

      then do the inheritance*/

    if (*mext == NULL) {

	*mext = (XmManagerClassExt) XtCalloc(1, sizeof(XmManagerClassExtRec));

	(*mext)->record_type     = NULLQUARK ;

	(*mext)->version = XmManagerClassExtVersion ;

	(*mext)->record_size     = sizeof( XmManagerClassExtRec) ;

	(*mext)->traversal_children = XmInheritTraversalChildrenProc ;

	(*mext)->object_at_point = XmInheritObjectAtPointProc ;

    }

    if ((WidgetClass)mw != xmManagerWidgetClass) {

	XmManagerClassExt *smext = (XmManagerClassExt *)

	    _XmGetClassExtensionPtr( (XmGenericClassExt *)

				    &(super->manager_class.extension),

				    NULLQUARK) ;

	if ((*mext)->traversal_children == XmInheritTraversalChildrenProc) {

	    (*mext)->traversal_children = (*smext)->traversal_children ;

	}

	if ((*mext)->object_at_point == XmInheritObjectAtPointProc) {

	    (*mext)->object_at_point = (*smext)->object_at_point ;

	}

    } 

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

      first_time because we want to do that onlt once but

      after Object ClassPartInit has been called */

    if (first_time) {

        _XmReOrderResourceList(xmManagerWidgetClass, XmNunitType, NULL);

	_XmReOrderResourceList(xmManagerWidgetClass, 

			       XmNforeground, XmNbackground);

        first_time = FALSE;

    }

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

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

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

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

}

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

 *

 *  Initialize

 *

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

static void 

Initialize(

        Widget request,

        Widget new_w,

        ArgList args,

        Cardinal *num_args )

{

    XmManagerWidget mw = (XmManagerWidget) new_w ;

    XtTranslations translations ;

   /*  Initialize manager and composite instance data  */

   mw->manager.selected_gadget = NULL;

   mw->manager.highlighted_widget = NULL;

   mw->manager.event_handler_added = False;

   mw->manager.active_child = NULL;

   mw->manager.keyboard_list = NULL;

   mw->manager.num_keyboard_entries = 0;

   mw->manager.size_keyboard_list = 0;

   mw->manager.has_focus = False;

   _XmProcessLock();

   translations = (XtTranslations) ((XmManagerClassRec *)XtClass( mw))

                                      ->manager_class.translations ;

   _XmProcessUnlock();

   if(    mw->manager.traversal_on

       && translations  &&  mw->core.tm.translations

       && !XmIsRowColumn( mw)    )

   {   

       /*  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) mw, translations) ;

       } 

   if(    (mw->manager.navigation_type != XmDYNAMIC_DEFAULT_TAB_GROUP)

       && !XmRepTypeValidValue( XmRID_NAVIGATION_TYPE, 

                        mw->manager.navigation_type, (Widget) mw)    )

   {   mw->manager.navigation_type = XmNONE ;

       } 

   _XmNavigInitialize( request, new_w, args, num_args);

   /*  Verify resource data  */

   if(    !XmRepTypeValidValue( XmRID_UNIT_TYPE, mw->manager.unit_type,

                                          (Widget) mw)    )

   {

      mw->manager.unit_type = XmPIXELS;

   }

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

   _XmManagerImportArgs( (Widget) mw, args, num_args);

    if (mw->manager.string_direction == XmSTRING_DIRECTION_DEFAULT) {

      /* This indicates that layoutDirection was set in the arglist, but

         stringDirection defaulting overwrote the value */

      int i;

      for (i=0; i < *num_args; i++)

	if (strcmp(args[i].name, XmNlayoutDirection) == 0)

	  mw->manager.string_direction = (XmDirection)args[i].value;

    }

   /*  Get the shadow drawing GC's  */

    mw->manager.background_GC = 

	_XmGetPixmapBasedGC (new_w, 

			     mw->core.background_pixel,

			     mw->manager.foreground,

			     mw->core.background_pixmap);

    mw->manager.highlight_GC = 

	_XmGetPixmapBasedGC (new_w, 

			     mw->manager.highlight_color,

			     mw->core.background_pixel,

			     mw->manager.highlight_pixmap);

    mw->manager.top_shadow_GC = 

	_XmGetPixmapBasedGC (new_w, 

			     mw->manager.top_shadow_color,

			     mw->core.background_pixel,

			     mw->manager.top_shadow_pixmap);

    mw->manager.bottom_shadow_GC = 

	_XmGetPixmapBasedGC (new_w, 

			     mw->manager.bottom_shadow_color,

			     mw->core.background_pixel,

			     mw->manager.bottom_shadow_pixmap);

   /* Copy accelerator widget from parent or set to NULL.

    */

    {

      XmManagerWidget p = (XmManagerWidget) XtParent(mw);

      if (XmIsManager(p) && p->manager.accelerator_widget)

         mw->manager.accelerator_widget = p->manager.accelerator_widget;

      else

         mw->manager.accelerator_widget = NULL;

    }

}

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

 *

 *  Realize

 *

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

static void 

Realize(

        Widget w,

        XtValueMask *p_valueMask,

        XSetWindowAttributes *attributes )