/* $TOG: Obso2_0.c /main/10 1998/08/18 18:59:44 samborn $ */
/*
 * 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


#include <ctype.h>
#ifndef X_NOT_STDC_ENV
#include <stdlib.h>
#include <unistd.h>
#endif

#include <X11/Intrinsic.h>
#include <Xm/BaseClassP.h>
#include <Xm/ColorP.h>
#include <Xm/DesktopP.h>
#include <Xm/DisplayP.h>
#include <Xm/DrawingAP.h>
#include <Xm/FileSBP.h>
#include <Xm/GadgetP.h>
#include <Xm/List.h>
#include <Xm/ManagerP.h>
#include <Xm/MenuShellP.h>
#include <Xm/MenuStateP.h>
#include <Xm/PrimitiveP.h>
#include <Xm/PushBGP.h>
#include <Xm/PushBP.h>
#include <Xm/RowColumnP.h>
#include <Xm/ScaleP.h>
#include <Xm/ScreenP.h>
#include <Xm/ScrolledWP.h>
#include <Xm/Text.h>
#include <Xm/TextF.h>
#include <Xm/TextInP.h>
#include <Xm/TextP.h>
#include <Xm/TransltnsP.h>
#include <Xm/VendorSEP.h>
#include <Xm/XmP.h>
#include <Xm/XmosP.h>
#include "BaseClassI.h"
#include "BulletinBI.h"
#include "ColorI.h"
#include "ExtObjectI.h"
#include "ImageCachI.h"
#include "MapEventsI.h"
#include "MenuStateI.h"
#include "MessagesI.h"
#include "PixConvI.h"
#include "ReadImageI.h"
#include "ResConverI.h"
#include "TextOutI.h"
#include "TravActI.h"
#include "TraversalI.h"
#include "XmI.h"

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

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

/* Exported variables that are now static. */

XmPrimitiveClassExtRec _XmLabelPrimClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmPrimitiveClassExtRec), NULL, NULL, NULL
};

XmPrimitiveClassExtRec _XmTextPrimClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmPrimitiveClassExtRec),
  _XmTextGetBaselines, _XmTextGetDisplayRect, _XmTextMarginsProc
};

XmPrimitiveClassExtRec _XmTextFPrimClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmPrimitiveClassExtRec), NULL, NULL, NULL
};


XmGadgetClassExtRec _XmGadClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmGadgetClassExtRec), NULL, NULL
};

XmGadgetClassExtRec _XmLabelGadClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmGadgetClassExtRec), NULL, NULL
};

XmGadgetClassExtRec _XmPushBGadClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmGadgetClassExtRec),
  XmInheritBaselineProc, XmInheritDisplayRectProc
};

XmGadgetClassExtRec _XmToggleBGadClassExtRec = {
  NULL, NULLQUARK, 1L, sizeof(XmGadgetClassExtRec),
  XmInheritBaselineProc, XmInheritDisplayRectProc
};

/* XmWorld is defunct. */

typedef struct _XmWorldClassPart {
  XtPointer		extension;
} XmWorldClassPart;

typedef struct _XmWorldClassRec {
  ObjectClassPart	object_class;
  XmExtClassPart	ext_class;
  XmDesktopClassPart 	desktop_class;
  XmWorldClassPart	world_class;
} XmWorldClassRec;

typedef struct {
  int			foo;
} XmWorldPart;

typedef struct _XmWorldRec {
  ObjectPart		object;
  XmExtPart		ext;
  XmDesktopPart		desktop;
  XmWorldPart		world;
} XmWorldRec;

externaldef(worldobjectclass) XmWorldClassRec xmWorldClassRec =
{
  {	
    (WidgetClass) &xmDesktopClassRec, /* superclass		*/   
    "World",			/* class_name 		*/   
    sizeof(XmWorldRec),		/* size 		*/   
    NULL,			/* Class Initializer 	*/   
    NULL,			/* class_part_init 	*/ 
    FALSE,			/* Class init'ed ? 	*/   
    NULL,			/* initialize         	*/   
    NULL,			/* initialize_notify    */ 
    NULL,			/* realize            	*/   
    NULL,			/* actions            	*/   
    0,				/* num_actions        	*/   
    NULL,			/* resources          	*/   
    0,				/* resource_count     	*/   
    NULLQUARK, 			/* xrm_class          	*/   
    FALSE,			/* compress_motion    	*/   
    FALSE,			/* compress_exposure  	*/   
    FALSE,			/* compress_enterleave	*/   
    FALSE,			/* visible_interest   	*/   
    NULL,			/* destroy            	*/   
    NULL,			/* resize             	*/   
    NULL,			/* expose             	*/   
    NULL,			/* set_values         	*/   
    NULL,			/* set_values_hook      */ 
    NULL,			/* set_values_almost    */ 
    NULL,			/* get_values_hook      */ 
    NULL,			/* accept_focus       	*/   
    XtVersion, 			/* intrinsics version 	*/   
    NULL,			/* callback offsets   	*/   
    NULL,			/* tm_table           	*/   
    NULL,			/* query_geometry       */ 
    NULL,			/* world_accelerator    */ 
    NULL,			/* extension            */ 
  },	
  {				/* ext			*/
    NULL,			/* synthetic resources	*/
    0,				/* num syn resources	*/
    NULL,			/* extension		*/
  },
  {				/* desktop		*/
    (WidgetClass) &xmDisplayClassRec, /* child_class		*/
    XtInheritInsertChild,	/* insert_child		*/
    XtInheritDeleteChild,	/* delete_child		*/
    NULL,			/* extension		*/
  }
};

externaldef(worldobjectclass) WidgetClass 
     xmWorldClass = (WidgetClass) &xmWorldClassRec;

/************************************************************************
 *                                                                      *
 * _XmGetRealXlations - was global in ScrolledW.c, is now static.       *
 *                                                                      *
 ************************************************************************/

char * 
_XmGetRealXlations(
        Display *dpy,
        _XmBuildVirtualKeyStruct *keys,
        int num_keys )
{
  char *result, buf[1000];
  char *tmp = buf;
  char *keystring;
  register int i;
  int num_vkeys;
  XmKeyBinding vkeys;
  KeySym    keysym;
  Modifiers mods;
  
  *tmp = '\0';
  for (i = 0; i < num_keys; i++)
    {
      keysym = XStringToKeysym(keys[i].key);
      if (keysym == NoSymbol) 
	break;
      
      /* A virtual keysym may map to multiple real keysyms. */
      num_vkeys = XmeVirtualToActualKeysyms(dpy, keysym, &vkeys);
      while (--num_vkeys >= 0)
	{
	  keystring = XKeysymToString(vkeys[num_vkeys].keysym);
	  if (!keystring)
	    break;
	  mods = vkeys[num_vkeys].modifiers | keys[i].mod;
	  
	  if (mods & ControlMask)
	    strcat(tmp, "Ctrl ");
	  
	  if (mods & ShiftMask)
	    strcat(tmp, "Shift ");
	  
	  if (mods & Mod1Mask)
	    strcat(tmp, "Mod1 ");  /* "Alt" may not be right on some systems */
	  
	  strcat(tmp,"<Key>");
	  strcat(tmp, keystring);
	  strcat(tmp,": ");
	  strcat(tmp,keys[i].action);

	  tmp += strlen(tmp);
	  assert((tmp - buf) < 1000);
	}

      XtFree((char*) vkeys);
    }

  if (buf[0] != '\0')
    result = XtNewString(buf);
  else 
    result = NULL;
  return(result);
  
}


/************************************************************************
 *
 *  _XmSetEtchedSlider
 *	Set the scrollbar variable which causes the slider pixmap
 *	to be etched. Was in ScrollBar.c
 ************************************************************************/
void 
_XmSetEtchedSlider(
        XmScrollBarWidget sbw )
{
   XtVaSetValues((Widget) sbw, XmNsliderVisual, XmETCHED_LINE, NULL);
}




/**********************************************************************
 *
 * _XmSortResourceList: superceded by XmReorderResourceList
 * 
 **********************************************************************/
void 
_XmSortResourceList(
        XrmResource *list[],
        Cardinal len )
{
	static Boolean first_time = TRUE;
	static XrmQuark unitQ;
	int n,i;
	XrmResource *p = NULL;

	if (first_time)
	{
		unitQ = XrmPermStringToQuark(XmNunitType);
		first_time = FALSE;
	}

	for (n=0; n < len; n++)
		if (list[n]->xrm_name == unitQ)
		{
			p = list[n];
			break;
		}
	
	if (n == len)
		return; /* No unit type resource found in this list. */
	else
	{
		for (i=n; i > 0; i--)
			list[i] = list[i-1];
		
		list[0] = p;
	}
}


/************************************************************************
 ************************************************************************
  Stuff that was in Visual.c, now obsolete by the XtReOrderResourceList
  API.
 ************************************************************************/



/************************************************************************
 *
 *  _XmGetBGPixmapName
 *	Return the background pixmap name set by the string to background
 *	resource converter.  This is used by primitive and manager.
 *
 ************************************************************************/
char * 
_XmGetBGPixmapName( void )
{
   return NULL;
}



/************************************************************************
 *
 *  _XmClearBGPixmapName
 *	Clear the background pixmap name set by the string to background
 *	resource converter.  This is used by primitive and manager.
 *
 ************************************************************************/
void 
_XmClearBGPixmapName( void )
{
  /*EMPTY*/
}


/**---------------------------------------------------------*/
/**---------------------------------------------------------*/
/* This code was in Visual.c, global while only localy used */

#define MESSAGE0	_XmMsgVisual_0000
#define MESSAGE1	_XmMsgVisual_0001
#define MESSAGE2	_XmMsgVisual_0002


extern Pixel
_XmBlackPixel(
	      Screen *screen,
	      Colormap colormap,
	      XColor blackcolor )
{
  Pixel p;
  
  blackcolor.red = 0;
  blackcolor.green = 0;
  blackcolor.blue = 0;

  if (colormap == DefaultColormapOfScreen(screen))
    p = blackcolor.pixel = BlackPixelOfScreen(screen);
  else if (XAllocColor(screen->display, colormap, &blackcolor))
    p = blackcolor.pixel;
  else
    p = blackcolor.pixel = BlackPixelOfScreen(screen); /* fallback pixel */
  
  return (p);
}


extern Pixel
_XmWhitePixel(
	      Screen *screen,
	      Colormap colormap,
	      XColor whitecolor )
{
  Pixel p;

  whitecolor.red = XmMAX_SHORT;
  whitecolor.green = XmMAX_SHORT;
  whitecolor.blue = XmMAX_SHORT;
 
  if (colormap == DefaultColormapOfScreen(screen))
    p = whitecolor.pixel = WhitePixelOfScreen(screen);
  else if (XAllocColor(screen->display, colormap, &whitecolor))
    p = whitecolor.pixel;
  else
    p = whitecolor.pixel = WhitePixelOfScreen(screen); /* fallback pixel */
  return (p);
}
  

String   
_XmGetDefaultBackgroundColorSpec( Screen *screen )
{
  XrmName names[2];
  XrmClass classes[2];
  XrmRepresentation rep;
  XrmValue db_value;
  String default_background_color_spec = NULL ;

  names[0] = XrmPermStringToQuark(XmNbackground);
  names[1] = NULLQUARK;
      
  classes[0] = XrmPermStringToQuark(XmCBackground);
  classes[1] = NULLQUARK;
	 
  if (XrmQGetResource(XtScreenDatabase(screen), names, classes,
		      &rep, &db_value)) 
     {
	if (rep == XrmPermStringToQuark(XmRString))
	    default_background_color_spec = db_value.addr;
     }
  else default_background_color_spec = XmDEFAULT_BACKGROUND;

  return(default_background_color_spec);
}


/*ARGSUSED*/
void 
_XmSetDefaultBackgroundColorSpec(
	Screen *screen,	/* unused */
        String new_color_spec )
{
    static Boolean app_defined = FALSE;
    String default_background_color_spec = NULL ;

    if (app_defined)
	{
	    XtFree(default_background_color_spec);
	}

    default_background_color_spec = (String)
	XtMalloc(strlen(new_color_spec) + 1);
    /* this needs to be set per screen */
    strcpy(default_background_color_spec, new_color_spec);

    app_defined = TRUE;
}

/*
 * GLOBAL VARIABLES
 *
 * These variables define the color cache.
 */


/* Thresholds for brightness
   above LITE threshold, LITE color model is used
   below DARK threshold, DARK color model is be used
   use STD color model in between */

static int XmCOLOR_LITE_THRESHOLD;
static int XmCOLOR_DARK_THRESHOLD;
static int XmFOREGROUND_THRESHOLD;
static Boolean XmTHRESHOLDS_INITD = FALSE;



void
_XmGetDefaultThresholdsForScreen( Screen *screen )
{
  XrmName names[2];
  XrmClass classes[2];
  XrmRepresentation rep;
  XrmValue db_value, to_value;
  int int_value;
  int default_light_threshold_spec;
  int default_dark_threshold_spec;
  int default_foreground_threshold_spec;
  WidgetRec widget;

  XmTHRESHOLDS_INITD = True;

 /* 
  * We need a widget to pass into the XtConvertAndStore() function
  * to convert the string to an int.  Since a widget can't be
  * passed into this procedure because the public interfaces
  * that call this routine don't have a widget, we need this hack
  * to create a dummy widget.
  */
  bzero((void*) &widget, sizeof(widget) );
  widget.core.self = &widget;
  widget.core.widget_class = coreWidgetClass;
  widget.core.screen = screen;
  XtInitializeWidgetClass(coreWidgetClass);


  names[0] = XrmPermStringToQuark(XmNlightThreshold);
  names[1] = NULLQUARK;
      
  classes[0] = XrmPermStringToQuark(XmCLightThreshold);
  classes[1] = NULLQUARK;

  if (XrmQGetResource(XtScreenDatabase(screen), names, classes,
		      &rep, &db_value))  
    {
     /* convert the string to an int value */
      to_value.size = sizeof(int);
      to_value.addr = (XPointer) &int_value;
      if (XtConvertAndStore(&widget, XmRString, &db_value, XmRInt, &to_value))
      {
	default_light_threshold_spec = int_value;
	if ( (default_light_threshold_spec < 0) ||
	     (default_light_threshold_spec > 100) )
	  default_light_threshold_spec = XmDEFAULT_LIGHT_THRESHOLD;
      }
      else default_light_threshold_spec = XmDEFAULT_LIGHT_THRESHOLD;
    }
  else default_light_threshold_spec = XmDEFAULT_LIGHT_THRESHOLD; 

  names[0] = XrmPermStringToQuark(XmNdarkThreshold);
  names[1] = NULLQUARK;
      
  classes[0] = XrmPermStringToQuark(XmCDarkThreshold);
  classes[1] = NULLQUARK;
      
  if (XrmQGetResource(XtScreenDatabase(screen), names, classes,
		      &rep, &db_value))  
    {
     /* convert the string to an int value */
      to_value.size = sizeof(int);
      to_value.addr = (XPointer) &int_value;
      if (XtConvertAndStore(&widget, XmRString, &db_value, XmRInt, &to_value))
      {
        XtConvertAndStore(&widget, XmRString, &db_value, XmRInt, &to_value);
	default_dark_threshold_spec = int_value;
	if ( (default_dark_threshold_spec < 0) ||
	     (default_dark_threshold_spec > 100) )
	  default_dark_threshold_spec = XmDEFAULT_DARK_THRESHOLD;
       }
       else default_dark_threshold_spec = XmDEFAULT_DARK_THRESHOLD;
    }
  else default_dark_threshold_spec = XmDEFAULT_DARK_THRESHOLD;

  names[0] = XrmPermStringToQuark(XmNforegroundThreshold);
  names[1] = NULLQUARK;
      
  classes[0] = XrmPermStringToQuark(XmCForegroundThreshold);
  classes[1] = NULLQUARK;
      
  if (XrmQGetResource(XtScreenDatabase(screen), names, classes,
		      &rep, &db_value))  
    {
     /* convert the string to an int value */
      to_value.size = sizeof(int);
      to_value.addr = (XPointer) &int_value;
      if (XtConvertAndStore(&widget, XmRString, &db_value, XmRInt, &to_value))
      {
	default_foreground_threshold_spec = int_value;
	if ( (default_foreground_threshold_spec < 0) ||
	     (default_foreground_threshold_spec > 100) )
	  default_foreground_threshold_spec = XmDEFAULT_FOREGROUND_THRESHOLD;
      }
      else default_foreground_threshold_spec = XmDEFAULT_FOREGROUND_THRESHOLD;
    }
  else default_foreground_threshold_spec = XmDEFAULT_FOREGROUND_THRESHOLD;

  XmCOLOR_LITE_THRESHOLD = default_light_threshold_spec * XmCOLOR_PERCENTILE;
  XmCOLOR_DARK_THRESHOLD = default_dark_threshold_spec * XmCOLOR_PERCENTILE;
  XmFOREGROUND_THRESHOLD = default_foreground_threshold_spec * XmCOLOR_PERCENTILE;
}




/********--------------------------------------
  IconPixmap VendorShell stuff previously in VendorSE.c.
  Obsolete because XmRBitmap is now used to convert
 ********-------------------------------------*/


/************************************************************************
 *
 *  _XmGetIconPixmapName
 *      Return the icon pixmap name set by the string to icon resource
 *      converter.  This is used by the vendor shell.
 *
 ************************************************************************/
char*
_XmGetIconPixmapName( void )
{
   return NULL;
}

/************************************************************************
 *
 *  _XmClearIconPixmapName
 *      Clear the icon pixmap name set by the string to icon resource
 *      converter.  This is used by the vendor shell.
 *
 ************************************************************************/
void 
_XmClearIconPixmapName( void )
{
  /*EMPTY*/
}


/************************************************************************
 *									*
 * _XmInitializeScrollBars - initialize the scrollbars for auto mode.	*
 *			WAS in ScrolledW.c      			*
 ************************************************************************/
#define ScrollBarVisible( wid)      (wid && XtIsManaged( wid))
void 
_XmInitializeScrollBars(
        Widget w )
{
    XmScrolledWindowWidget	sw = (XmScrolledWindowWidget) w;
    int i, inc;
    Dimension bw;
    Arg vSBArgs[6];
    Arg hSBArgs[6];
    
    if (sw->swindow.VisualPolicy == XmVARIABLE)
	return;	
    
    bw = 0;
    if (sw->swindow.WorkWindow)
        bw = sw->swindow.WorkWindow->core.border_width;
    
    sw->swindow.vmin = 0;    
    sw->swindow.vOrigin = 0;
    sw->swindow.hmin = 0;    
    sw->swindow.hOrigin = 0;
    if (ScrollBarVisible(sw->swindow.WorkWindow))
    {
        sw->swindow.vOrigin = abs(sw->swindow.WorkWindow->core.y);
	sw->swindow.vmax = sw->swindow.WorkWindow->core.height + (2 * bw);
	if (sw->swindow.vmax <1) sw->swindow.vmax = 1;
	sw->swindow.vExtent = sw->swindow.AreaHeight;
        if (sw->swindow.vOrigin < sw->swindow.vmin)
            sw->swindow.vOrigin = sw->swindow.vmin;

	if ((sw->swindow.vExtent + sw->swindow.vOrigin) > sw->swindow.vmax)
	    sw->swindow.vExtent = sw->swindow.vmax - sw->swindow.vOrigin;
	if (sw->swindow.vExtent < 0)
        {
	    sw->swindow.vExtent = sw->swindow.vmax;
            sw->swindow.vOrigin = sw->swindow.vmin;
        }

	sw->swindow.hmax = sw->swindow.WorkWindow->core.width + (2 * bw);
	if (sw->swindow.hmax <1) sw->swindow.hmax = 1;
        sw->swindow.hOrigin = abs(sw->swindow.WorkWindow->core.x);
	sw->swindow.hExtent = sw->swindow.AreaWidth;
        if (sw->swindow.hOrigin < sw->swindow.hmin)
            sw->swindow.hOrigin = sw->swindow.hmin;

	if ((sw->swindow.hExtent + sw->swindow.hOrigin) > sw->swindow.hmax)
	    sw->swindow.hExtent = sw->swindow.hmax - sw->swindow.hOrigin;
	if (sw->swindow.hExtent < 0)
        {
	    sw->swindow.hExtent = sw->swindow.hmax;
            sw->swindow.hOrigin = sw->swindow.hmin;
        }

    }
    else
    {
	sw->swindow.vExtent = (sw->swindow.ClipWindow->core.height > 0) ?
			       sw->swindow.ClipWindow->core.height : 1;
	sw->swindow.hExtent = (sw->swindow.ClipWindow->core.width > 0) ?
			       sw->swindow.ClipWindow->core.width : 1;
	sw->swindow.vmax = sw->swindow.vExtent;
	sw->swindow.hmax = sw->swindow.hExtent;
    }
    if(sw->swindow.vScrollBar)
    {
	i = 0;
        if (sw->swindow.WorkWindow)
        {
            if ((inc = ((sw->swindow.WorkWindow->core.height) / 10)) < 1)
                inc = 1;
            XtSetArg (vSBArgs[i], XmNincrement, (XtArgVal) inc); i++; 
        }
	if ((inc = (sw->swindow.AreaHeight - (sw->swindow.AreaHeight / 10))) < 1)
	    inc = sw->swindow.AreaHeight;
        XtSetArg (vSBArgs[i], XmNpageIncrement, (XtArgVal) inc); i++;
	XtSetArg (vSBArgs[i], XmNminimum, (XtArgVal) (sw->swindow.vmin)); i++;
	XtSetArg (vSBArgs[i], XmNmaximum, (XtArgVal) (sw->swindow.vmax)); i++;
	XtSetArg (vSBArgs[i], XmNvalue, (XtArgVal) sw->swindow.vOrigin); i++;
	XtSetArg (vSBArgs[i], XmNsliderSize, (XtArgVal) (sw->swindow.vExtent)); i++;
	assert(i <= XtNumber(vSBArgs));
	XtSetValues((Widget) sw->swindow.vScrollBar,vSBArgs,i);
    }
    if(sw->swindow.hScrollBar)
    {
	i = 0;
        if (sw->swindow.WorkWindow)
        {
            if ((inc = ((sw->swindow.WorkWindow->core.width) / 10)) < 1)
                inc = 1;
            XtSetArg (hSBArgs[i], XmNincrement, (XtArgVal) inc); i++; 
        }
	if ((inc = (sw->swindow.AreaWidth - (sw->swindow.AreaWidth / 10))) < 1)
	    inc = sw->swindow.AreaWidth;

        XtSetArg (hSBArgs[i], XmNpageIncrement, (XtArgVal) inc); i++;
	XtSetArg (hSBArgs[i], XmNminimum, (XtArgVal) (sw->swindow.hmin)); i++;
	XtSetArg (hSBArgs[i], XmNmaximum, (XtArgVal) (sw->swindow.hmax)); i++;
	XtSetArg (hSBArgs[i], XmNvalue, (XtArgVal) sw->swindow.hOrigin); i++;
	XtSetArg (hSBArgs[i], XmNsliderSize, (XtArgVal) (sw->swindow.hExtent)); i++;
	assert(i <= XtNumber(hSBArgs));
	XtSetValues((Widget) sw->swindow.hScrollBar,hSBArgs,i);
    }
    
}

void 
InitializeScrollBars(
        Widget w )
{
  _XmInitializeScrollBars( w) ;
}


void 
_XmClearBCompatibility(
        Widget pb )
{

	((XmPushButtonWidget) pb)->pushbutton.compatible =  False;
}


void 
_XmClearBGCompatibility(
        Widget pbg )
{
	 PBG_Compatible (pbg) = False;
}




/****************************************************************/
void 
_XmBulletinBoardSetDefaultShadow(
        Widget button )
{   
            Arg             argv[2] ;
            Cardinal        argc ;
            Dimension       dbShadowTh = 0;
            Dimension       shadowTh ;
/****************/

    if(    XmIsPushButtonGadget( button)    )
    {   _XmClearBGCompatibility( button) ;
        } 
    else
    {   if(    XmIsPushButton( button)    )
        {   _XmClearBCompatibility( button) ;
            } 
        } 
    argc = 0 ;
    XtSetArg( argv[argc], XmNshadowThickness, &shadowTh) ; ++argc ;
    XtSetArg( argv[argc], XmNdefaultButtonShadowThickness, 
                                                        &dbShadowTh) ; ++argc ;
    XtGetValues( button, argv, argc) ;
    
    if(    !dbShadowTh    )
    {   if(    shadowTh > 1    )
        {   dbShadowTh = shadowTh >> 1 ;
            }
        else
        {   dbShadowTh = shadowTh ;
            } 
        argc = 0 ;
        XtSetArg( argv[argc], XmNdefaultButtonShadowThickness, 
                                                         dbShadowTh) ; ++argc ;
        XtSetValues( button, argv, argc) ;
        } 
    return ;
    }


static Widget
GetBBWithDB(
 	Widget wid)
 {
   Widget focus ;
 
   if(    (_XmGetFocusPolicy( wid) == XmEXPLICIT)
      &&  (    (focus = XmGetFocusWidget( wid))
 	  ||  (focus = _XmGetFirstFocus( wid)))    )
     {
       while(    focus
 	    &&  !XtIsShell( focus)    )
 	{
 	  if(    XmIsBulletinBoard( focus)
 	     &&  BB_DefaultButton( focus)    )
 	    {
 	      return focus ;
 	    }
 	  focus = XtParent( focus) ;
 	}
 
     }
   return NULL ;
 }


void
_XmBBUpdateDynDefaultButton(
 	Widget bb)
 {
   Widget bbwdb = GetBBWithDB( bb) ;
 
   if(    bbwdb == NULL    )
     {
       if(    ((XmBulletinBoardWidget) bb)
 	                           ->bulletin_board.dynamic_default_button    )
 	{
 	  _XmBulletinBoardSetDynDefaultButton( bb, NULL) ;
 	}
     }
   else
     {
       if(    bbwdb == bb    )
 	{
 	  _XmBulletinBoardSetDynDefaultButton( bb, BB_DefaultButton( bb)) ;
 	}
     }
 }
 
/********************************************************************/

Boolean 
_XmDifferentBackground(
        Widget w,
        Widget parent )
{
    if (XmIsPrimitive (w) && XmIsManager (parent)) {
	if (w->core.background_pixel != parent->core.background_pixel ||
	    w->core.background_pixmap != parent->core.background_pixmap)
	    return (True);
    }
    
    return (False);
}


/*******************************************************************
  More Visual.c stuff not used */



static void 
SetMonochromeColors(
        XmColorData *colors )
{
	Screen *screen = colors->screen;
	Pixel background = colors->background.pixel;

	if (background == BlackPixelOfScreen(screen))
	{
		colors->foreground.pixel = WhitePixelOfScreen (screen);
		colors->foreground.red = colors->foreground.green = 
			colors->foreground.blue = XmMAX_SHORT;

		colors->bottom_shadow.pixel = WhitePixelOfScreen(screen);
		colors->bottom_shadow.red = colors->bottom_shadow.green = 
			colors->bottom_shadow.blue = XmMAX_SHORT;

		colors->select.pixel = WhitePixelOfScreen(screen);
		colors->select.red = colors->select.green = 
			colors->select.blue = XmMAX_SHORT;

		colors->top_shadow.pixel = BlackPixelOfScreen(screen);
		colors->top_shadow.red = colors->top_shadow.green = 
			colors->top_shadow.blue = 0;
	}
	else if (background == WhitePixelOfScreen(screen))
	{
		colors->foreground.pixel = BlackPixelOfScreen(screen);
		colors->foreground.red = colors->foreground.green = 
			colors->foreground.blue = 0;

		colors->top_shadow.pixel = WhitePixelOfScreen(screen);
		colors->top_shadow.red = colors->top_shadow.green = 
			colors->top_shadow.blue = XmMAX_SHORT;

		colors->bottom_shadow.pixel = BlackPixelOfScreen(screen);
		colors->bottom_shadow.red = colors->bottom_shadow.green = 
			colors->bottom_shadow.blue = 0;

		colors->select.pixel = BlackPixelOfScreen(screen);
		colors->select.red = colors->select.green = 
			colors->select.blue = 0;
	}

	colors->allocated |= (XmFOREGROUND | XmTOP_SHADOW 
		| XmBOTTOM_SHADOW | XmSELECT);
}


/* This one still used by mwm: fix mwm */

/*********************************************************************
 *
 *  _XmGetColors
 *
 *********************************************************************/
XmColorData * 
_XmGetColors(
        Screen *screen,
        Colormap color_map,
        Pixel background )
{
	Display * display = DisplayOfScreen (screen);
	XmColorData *old_colors;
	XmColorData new_colors;
	XmColorProc ColorRGBCalcProc ;


	new_colors.screen = screen;
	new_colors.color_map = color_map;
	new_colors.background.pixel = background;

	if (_XmSearchColorCache(
		(XmLOOK_AT_SCREEN | XmLOOK_AT_CMAP | XmLOOK_AT_BACKGROUND),
			&new_colors, &old_colors)) {
               /*
		* initialize the thresholds if the current color scheme
		* already matched what is in the cache and the thresholds
		* haven't already been initialized.
                */
                if (!XmTHRESHOLDS_INITD)
	            _XmGetDefaultThresholdsForScreen(screen);
		return(old_colors);
        }

	XQueryColor (display, color_map, &(new_colors.background));
	new_colors.allocated = XmBACKGROUND;

	/*
	 * Just in case somebody looks at these before they're ready,
	 * initialize them to a value that is always valid (for most
	 * implementations of X).
	 */
	new_colors.foreground.pixel = new_colors.top_shadow.pixel = 
		new_colors.top_shadow.pixel = new_colors.select.pixel = 0;

	/*  Generate the foreground, top_shadow, and bottom_shadow based  */
	/*  on the background                                             */

	if (DefaultDepthOfScreen(screen) == 1)
		SetMonochromeColors(&new_colors);
	else
	  {
	    _XmGetDefaultThresholdsForScreen(screen);
	    ColorRGBCalcProc = XmGetColorCalculation() ;
	    (*ColorRGBCalcProc)(&(new_colors.background),
				&(new_colors.foreground), &(new_colors.select),
				&(new_colors.top_shadow), &(new_colors.bottom_shadow));
	  }
	return (_XmAddToColorCache(&new_colors));
}



XmColorData * 
_XmGetDefaultColors(
        Screen *screen,
        Colormap color_map )
{
	static XmColorData ** default_set = NULL;
	static int default_set_count = 0;
	static int default_set_size = 0;
	register int i;
	XColor color_def;
	static Pixel background;
        XrmValue fromVal;
        XrmValue toVal;
        XrmValue args[2];
        Cardinal num_args;
	String default_string = XtDefaultBackground;

	/*  Look through  a set of screen / background pairs to see  */
	/*  if the default is already in the table.                  */

	for (i = 0; i < default_set_count; i++)
	{
	if ((default_set[i]->screen == screen) &&
		(default_set[i]->color_map == color_map))
		return (default_set[i]);
	}

	/*  See if more space is needed in the array  */
  
	if (default_set == NULL)
	{
		default_set_size = 10;
		default_set = (XmColorData **) XtRealloc((char *) default_set, 
			(sizeof(XmColorData *) * default_set_size));
		
	}
	else if (default_set_count == default_set_size)
	{
		default_set_size += 10;
		default_set = (XmColorData **) XtRealloc((char *) default_set, 
			sizeof(XmColorData *) * default_set_size);
	}

	/* Find the background based on the depth of the screen */
	if (DefaultDepthOfScreen(screen) == 1)
        {
	  /*
	   * Fix for 4603 - Convert the string XtDefaultBackground into a Pixel
	   *                value using the XToolkit converter.  This converter
	   *                will set this value to WhitePixelOfScreen if reverse
	   *                video is not on, and to BlackPixelOfScreen if reverse
	   *                video is on.
	   */
	  args[0].addr = (XPointer) &screen;
	  args[0].size = sizeof(Screen*);
	  args[1].addr = (XPointer) &color_map;
	  args[1].size = sizeof(Colormap);
	  num_args = 2;
	  
	  fromVal.addr = default_string;
	  fromVal.size = strlen(default_string);
	  
	  toVal.addr = (XPointer) &background;
	  toVal.size = sizeof(Pixel);
	  
	  if(!XtCallConverter(DisplayOfScreen(screen),XtCvtStringToPixel, 
			      args, num_args, &fromVal, &toVal, NULL))
	    background = WhitePixelOfScreen(screen);
        }

	else
	{
		/*  Parse out a color for the default background  */

		if (XParseColor(DisplayOfScreen(screen), color_map,
			_XmGetDefaultBackgroundColorSpec(screen), &color_def))
		{
			if (XAllocColor(DisplayOfScreen(screen), color_map,
				&color_def))
			{
				background = color_def.pixel;
			}
			else
			{
				XtWarning(MESSAGE1);
				background = WhitePixelOfScreen(screen);
			}
		}
		else
		{
			XtWarning(MESSAGE2);
			background = WhitePixelOfScreen(screen);
		}
	}

	/*
	 * Get the color data generated and save it in the next open
	 * slot in the default set array.  default_set points to a subset
	 * of the data pointed to by color_set (defined in _XmGetColors).
	 */

	default_set[default_set_count] = 
		_XmGetColors(screen, color_map, background);
	default_set_count++;

	return (default_set[default_set_count - 1]);
}



static int 
_XmBrightness(
        XColor *color )
{
	int brightness;
	int intensity;
	int light;
	int luminosity, maxprimary, minprimary;
	int red = color->red;
	int green = color->green;
	int blue = color->blue;

	intensity = (red + green + blue) / 3;

	/* 
	 * The casting nonsense below is to try to control the point at
	 * the truncation occurs.
	 */

	luminosity = (int) ((XmRED_LUMINOSITY * (float) red)
		+ (XmGREEN_LUMINOSITY * (float) green)
		+ (XmBLUE_LUMINOSITY * (float) blue));

	maxprimary = ( (red > green) ?
					( (red > blue) ? red : blue ) :
					( (green > blue) ? green : blue ) );

	minprimary = ( (red < green) ?
					( (red < blue) ? red : blue ) :
					( (green < blue) ? green : blue ) );

	light = (minprimary + maxprimary) / 2;

	brightness = ( (intensity * XmINTENSITY_FACTOR) +
				   (light * XmLIGHT_FACTOR) +
				   (luminosity * XmLUMINOSITY_FACTOR) ) / 100;
	return(brightness);
}

/* This one still used by mwm: fix mwm */
Pixel 
_XmAccessColorData(
        XmColorData *cd,
#if NeedWidePrototypes
        unsigned int which )
#else
        unsigned char which )
#endif /* NeedWidePrototypes */
{
    Pixel p;
    
    switch(which) {
    case XmBACKGROUND:
	if (!(cd->allocated & which) && 
	    (XAllocColor(cd->screen->display,
			 cd->color_map, &(cd->background)) == 0)) {
	    if (_XmBrightness(&(cd->background))
		< XmFOREGROUND_THRESHOLD )
		cd->background.pixel = _XmBlackPixel(cd->screen, 
						     cd->color_map,
						     cd->background);
	    else 
		cd->background.pixel = _XmWhitePixel(cd->screen, 
						     cd->color_map,
						     cd->background);				    
	    XQueryColor(cd->screen->display, cd->color_map, 
			&(cd->background));
	}
	p = cd->background.pixel;
	cd->allocated |= which;
	break;
    case XmFOREGROUND:
	if (!(cd->allocated & which) &&
	    (XAllocColor(cd->screen->display,
			 cd->color_map, &(cd->foreground)) == 0 )) 
	    {
		if (_XmBrightness(&(cd->background))
		    < XmFOREGROUND_THRESHOLD )
		    cd->foreground.pixel = _XmWhitePixel(cd->screen, 
							 cd->color_map,
							 cd->foreground);
		else 
		    cd->foreground.pixel = _XmBlackPixel(cd->screen, 
							 cd->color_map,
							 cd->foreground);
		XQueryColor(cd->screen->display, cd->color_map, 
			    &(cd->foreground));
	    }
	p =  cd->foreground.pixel;	
	cd->allocated |= which;
	break;
    case XmTOP_SHADOW:
	if (!(cd->allocated & which) &&
	    (XAllocColor(cd->screen->display,
			 cd->color_map, &(cd->top_shadow)) == 0))
	    {
		if (_XmBrightness(&(cd->background))
		    > XmCOLOR_LITE_THRESHOLD)
		    cd->top_shadow.pixel = 
			_XmBlackPixel(cd->screen, cd->color_map,
				      cd->top_shadow);
		else
		    cd->top_shadow.pixel =
			_XmWhitePixel(cd->screen, cd->color_map,
				      cd->top_shadow);
		XQueryColor(cd->screen->display, cd->color_map, 
			    &(cd->top_shadow));
		
	    }
	p = cd->top_shadow.pixel;
	cd->allocated |= which;
	break;
    case XmBOTTOM_SHADOW:
	if (!(cd->allocated & which) &&
	    (XAllocColor(cd->screen->display,
			 cd->color_map, &(cd->bottom_shadow)) == 0))
	    {
		if (_XmBrightness(&(cd->background))
		    < XmCOLOR_DARK_THRESHOLD)
		    cd->bottom_shadow.pixel =  
			_XmWhitePixel(cd->screen, cd->color_map,
				      cd->bottom_shadow);
		else
		    cd->bottom_shadow.pixel = 
			_XmBlackPixel(cd->screen, cd->color_map,
				      cd->bottom_shadow);
		XQueryColor(cd->screen->display, cd->color_map, 
			    &(cd->bottom_shadow));
	    }
	p = cd->bottom_shadow.pixel;
	cd->allocated |= which;
	break;
    case XmSELECT:
	if (!(cd->allocated & which) &&
	    (XAllocColor(cd->screen->display,
			 cd->color_map, &(cd->select)) == 0))
	    {
		if (_XmBrightness(&(cd->background)) 
		    < XmFOREGROUND_THRESHOLD)
		    cd->select.pixel = _XmWhitePixel(cd->screen, 
						     cd->color_map, 
						     cd->select);
		else
		    cd->select.pixel = _XmBlackPixel(cd->screen, 
						     cd->color_map, 
						     cd->select);
		XQueryColor(cd->screen->display, cd->color_map, 
			    &(cd->select));
	    }
	p = cd->select.pixel;
	cd->allocated |= which;
	break;
    default:
	XtWarning(MESSAGE0);
	p = _XmBlackPixel(cd->screen, cd->color_map, cd->background);
	break;
    }
    
    return(p);
}


/* OBSOLETE: Replaced by _XmMapKeyEvents. */
Boolean 
_XmMapKeyEvent(
        register String str,
        int *eventType,
        unsigned int *keysym,
        unsigned int *modifiers )
{
  int		count;
  int          *all_types;
  KeySym       *all_keys;
  unsigned int *all_mods;

  /* Initialize the return parameters. */
  *eventType = 0;
  *keysym = 0;
  *modifiers = 0;

  /* Convert the string to a list of keysyms. */
  count = _XmMapKeyEvents(str, &all_types, &all_keys, &all_mods);

  /* The old implementation ignored trailing garbage. */
  if (count > 0)
    {
      *eventType = *all_types;
      *keysym = *all_keys;
      *modifiers = *all_mods;
    }

  XtFree((char*) all_types);
  XtFree((char*) all_keys);
  XtFree((char*) all_mods);

  return (count > 0);
}


void XmRegisterConverters() { _XmRegisterConverters() ; } 


/************************************************************************
 *
 *  _XmGetImageAndHotSpotFromFile
 *	Given a filename, extract and create an image from the file data.
 *
 ************************************************************************/
XImage * 
_XmGetImageAndHotSpotFromFile(
        char *filename,
	int *hot_x, 
	int *hot_y)
{
    return _XmReadImageAndHotSpotFromFile(_XmGetDefaultDisplay(), 
					filename, hot_x, hot_y) ;

}


/************************************************************************
 *
 *  _XmGetImageFromFile
 *	Given a filename, extract and create an image from the file data.
 *
 ************************************************************************/

XImage * 
_XmGetImageFromFile(
        char *filename )
{
   int hot_x, hot_y;
   return _XmReadImageAndHotSpotFromFile(_XmGetDefaultDisplay(), 
					filename, &hot_x, &hot_y) ;
}

Boolean
_XmFocusIsInShell(
        Widget wid)
{
  /* CR 7568: Actually return the value. */
  return XmeFocusIsInShell(wid);
}


void
_XmSleep(
        unsigned int secs)
{
  sleep( secs) ;
}

int
_XmOSPutenv(
    char *string)
{
#ifndef NO_PUTENV
  return (putenv(string));
  
#else
  char *value;
  
  if ((value = strchr(string, '=')) != NULL)
    {
      char *name  = XtNewString(string);
      int result;
      
      name[value-string] = '\0';
      
      result = setenv(name, value+1, 1);
      XtFree(name);
      return result;
    }
  else
    return -1;
#endif
}

/* after rework of inheritance of class extension method */
externaldef(xmprimbaseclassextrec) XmBaseClassExtRec
     _XmPrimbaseClassExtRec = { 0 };
externaldef(xmprimclassextrec) XmPrimitiveClassExtRec
     _XmPrimClassExtRec = { 0 };
externaldef(xmdrawnbprimclassextrec) XmPrimitiveClassExtRec 
     _XmDrawnBPrimClassExtRec = { 0 };
externaldef(xmtogglebprimclassextrec) XmPrimitiveClassExtRec
     _XmToggleBPrimClassExtRec = { 0 }; 
externaldef(xmpushbprimclassextrec) XmPrimitiveClassExtRec 
     _XmPushBPrimClassExtRec = { 0 };
externaldef(xmcascadebprimclassextrec) XmPrimitiveClassExtRec
     _XmCascadeBPrimClassExtRec = { 0 };
externaldef(xmtearoffbprimclassextrec) XmPrimitiveClassExtRec 
     _XmTearOffBPrimClassExtRec = { 0 };




/* From old Visual.c */

void 
_XmPrimitiveTopShadowPixmapDefault(
        Widget widget,
        int offset,
        XrmValue *value )
{
    _XmTopShadowPixmapDefault(widget, offset, value );
}

void 
_XmManagerTopShadowPixmapDefault(
        Widget widget,
        int offset,
        XrmValue *value )
{
    _XmTopShadowPixmapDefault(widget, offset, value );
}

void 
_XmPrimitiveHighlightPixmapDefault(
        Widget widget,
        int offset,
        XrmValue *value )
{
    _XmHighlightPixmapDefault(widget, offset, value );
}

void 
_XmManagerHighlightPixmapDefault(
        Widget widget,
        int offset,
        XrmValue *value )
{
    _XmHighlightPixmapDefault(widget, offset, value );
}



/************************************************************************
 *
 *  _XmFilterResources
 *
 ************************************************************************/
Cardinal 
_XmFilterResources(
        XtResource *resources,
        Cardinal numResources,
        WidgetClass filterClass,
        XtResource **filteredResourcesRtn )
{
    XtResource		*filteredResources;
    Cardinal		copyIndexes[256];
    Cardinal		filterOffset;
    Cardinal		i, j;

    filterOffset = filterClass->core_class.widget_size;

    for (i = 0, j = 0; i < numResources; i++)
      {
	  if (resources[i].resource_offset >= filterOffset)
	    {
		copyIndexes[j++] = i;
	    }
      }

    filteredResources = (XtResource *) XtMalloc(j * sizeof(XtResource));

    for (i = 0; i < j; i++)
      {
	  filteredResources[i] = resources[copyIndexes[i]];
      }
    *filteredResourcesRtn = filteredResources;
    return j;
}



/************************************************************************
 *
 *  _XmRootGeometryManager
 *
 ************************************************************************/
/*ARGSUSED*/
XtGeometryResult 
_XmRootGeometryManager(
	 Widget w,
	 XtWidgetGeometry *request,
	 XtWidgetGeometry *reply )
{
    XmWidgetExtData	extData = _XmGetWidgetExtData(w, XmSHELL_EXTENSION);
    XmShellExtObject	se = (XmShellExtObject)extData->widget;
    XtGeometryHandler	wmGeoHandler;
    ShellWidgetClass	swc = (ShellWidgetClass)wmShellWidgetClass;
    ShellClassExtensionRec **scExtPtr;
    XtGeometryResult	returnVal = XtGeometryNo;
    WMShellWidget	wmShell = (WMShellWidget)w;

    if(extData == NULL)
    {
#ifdef DEBUG
        XmeWarning(NULL, "_XmGetWidgetExtData() returned NULL pointer.");
#endif
        return XtGeometryNo;
    }    

    if (se)
      {
	   se->shell.lastConfigureRequest = NextRequest(XtDisplay(w));
      }
#ifdef DEBUG
    else
      XtError("no extension object");
#endif /* DEBUG */

    scExtPtr = (ShellClassExtensionRec **)
      _XmGetClassExtensionPtr( (XmGenericClassExt *) &(swc->shell_class.extension),
			       NULLQUARK);
    if (request->request_mode & XtCWQueryOnly)
      {
	   if (!(wmShell->shell.allow_shell_resize) &&
	       (request->request_mode & 
		(CWWidth | CWHeight | CWBorderWidth)))
	     return XtGeometryNo;
	   /*
	    * we should switch on useAsyncGeometry but we won't |||
	    */
	   else 
	     return XtGeometryYes;
      }

    if (se->shell.useAsyncGeometry)
      {
	   /* make wait_for_wm = FALSE to force desired behaviour */
	   wmShell->wm.wait_for_wm = FALSE;
	   /* FIX for 1684: remove the timeout = 0 line, not
	      needed and introduced a bug if not saved/restore together
	      with useAsync change - wait_for_wm will be later reset
	      by Shell in Xt */
      }
    if ((wmGeoHandler = (*scExtPtr)->root_geometry_manager) != NULL)
      {
	   returnVal =  (*wmGeoHandler)(w, request, reply);
	   if (se->shell.useAsyncGeometry) {
	       /* X configure was sent to the server, while this is happening,
		  let's everybody think it's a success (which is true
		  most of the time): set the shell size to what it wants
		  to be and return Yes */
	       if (request->request_mode & CWWidth)
		   w->core.width = request->width;
	       if (request->request_mode & CWHeight)
		   w->core.height = request->height ;
	       if (request->request_mode & CWBorderWidth)
		   w->core.border_width = request->border_width ;
	       if (request->request_mode & CWX) 
		   w->core.x = request->x;
	       if (request->request_mode & CWY) 
		   w->core.y = request->y;

	       returnVal = XtGeometryYes;
	   }
      }
    return returnVal;
}


/*ARGSUSED*/
void 
_XmVendorExtRealize(
	 Widget w,
	 XtPointer closure,	/* unused */
	 XtPointer call_data )	/* unused */
{
    XtWarning("Don't use _XmVendorExtRealize! It does nothing.");
}



/**********************
  Stuff from Desktop.c
**********************/

static XContext	actualClassContext = (XContext) NULL;


/*ARGSUSED*/
static void 
DisplayDestroyCallback 
	( Widget w,
        XtPointer client_data,
        XtPointer call_data )	/* unused */
{
    XDeleteContext(XtDisplay(w), (XID) client_data, actualClassContext);
}


/************************************************************************
 *
 *  _XmGetActualClass
 *
 ************************************************************************/
/* ARGSUSED */
WidgetClass 
_XmGetActualClass(
	Display     *display,
        WidgetClass w_class )
{
	  WidgetClass		actualClass;

	  if (actualClassContext == (XContext) NULL)
	    actualClassContext = XUniqueContext();
	  
	  /*
	   * see if a non-default class has been specified for the
	   * class
	   */
	  if (XFindContext(display,
			   (Window) w_class,
			   actualClassContext,
			   (char **) &actualClass))
	    {
		return w_class;
	    }
	  else
	    return actualClass;
}

/************************************************************************
 *
 *  _XmSetActualClass
 *
 ************************************************************************/
/* ARGSUSED */
void 
_XmSetActualClass(
	Display     *display,
        WidgetClass w_class,
        WidgetClass actualClass )
{
    XmDisplay   dd = (XmDisplay) XmGetXmDisplay(display);
    WidgetClass previous;
    WidgetClass oldActualClass;

    if (actualClassContext == (XContext) NULL)
      actualClassContext = XUniqueContext();
    
    /*
     * see if a non-default class has been specified for the
     * class
     */
    previous = _XmGetActualClass(display, w_class);
    XtRemoveCallback((Widget)dd, XtNdestroyCallback,
			DisplayDestroyCallback, (XtPointer) previous);


    /*
     * Save class data.
     * Delete old context if one exists.
     */
    if (XFindContext (display, (Window) w_class, actualClassContext,
			(char **)&oldActualClass)) {
	XSaveContext(display, (Window) w_class, actualClassContext,
			(char *) actualClass);
    }
    else if (oldActualClass != actualClass) {
	XDeleteContext (display, (Window) w_class, actualClassContext);
	XSaveContext(display, (Window) w_class, actualClassContext,
			(char *) actualClass);

    }

    XtAddCallback((Widget)dd, XtNdestroyCallback, 
			DisplayDestroyCallback, (XtPointer) w_class);
}



/************************************************************************
 *
 *  _XmGetWorldObject
 *
 ************************************************************************/
/* ARGSUSED */
XmDesktopObject
_XmGetWorldObject(
        Widget shell,
        ArgList args,
        Cardinal *num_args )
{
    XmDesktopObject	worldObject;
    static XContext	worldObjectContext = (XContext) NULL;
    XmWidgetExtData     ext;
    Display		*display;
    
    /*
    ** Note: in an ideal World we would be sure to delete this context when
    ** the display is closed, so that we don't get bad data if a second 
    ** display with the same id is opened.
    */
    if (worldObjectContext == (XContext) NULL)
      worldObjectContext = XUniqueContext();

    display = XtDisplayOfObject(shell);
    
    if (XFindContext(display,
		     (Window) NULL,
		     worldObjectContext,
		     (char **) &worldObject))
      {
	  WidgetClass		worldClass;
	  Widget		appShell = shell;

	  worldClass = _XmGetActualClass(display, xmDesktopClass);
	  
	  while (XtParent(appShell)) 
	    appShell = XtParent(appShell);
	  
	  worldObject = (XmDesktopObject)
	    XtCreateWidget("world",
			   worldClass,
			   appShell,
			   args,
			   num_args ? *num_args: 0);

          ext = _XmGetWidgetExtData(worldObject->ext.logicalParent,
                                    worldObject->ext.extensionType);

          if(ext != NULL)
          {
            _XmExtObjFree((XtPointer) ext->reqWidget);
            ext->reqWidget = NULL;
          }
#ifdef DEBUG
          else
          {
            XmeWarning(NULL, "_XmGetWidgetExtData() returned NULL pointer.");
          }
#endif
	  
	  XSaveContext(display,
		       (Window) NULL,
		       worldObjectContext,
		       (char *) worldObject);
      }
    return 
      worldObject;
}

/************************************************************************
 *
 *  _XmVirtKeysHandler
 *     
 ************************************************************************/

/*ARGSUSED*/
void 
_XmVirtKeysHandler(Widget    widget,
		   XtPointer client_data,
		   XEvent   *event,
		   Boolean  *dontSwallow )
{
  if (widget->core.being_destroyed)
    {
      *dontSwallow = False;
      return;
    }
}



/****************************************************************
 *
 *  TextOut.c functions 
 *
 ****************************************************************/

/* ARGSUSED */
void 
_XmTextDrawDestination(XmTextWidget tw)
{
  /* DEPRECATED */
}

/* ARGSUSED */
void 
_XmTextClearDestination(XmTextWidget tw,
#if NeedWidePrototypes
        int ignore_sens)
#else
        Boolean ignore_sens)
#endif /* NeedWidePrototypes */
{
  /* DEPRECATED */
}

/* ARGSUSED */
void 
_XmTextDestinationVisible(Widget w,
#if NeedWidePrototypes
        int turn_on)
#else
        Boolean turn_on)
#endif /* NeedWidePrototypes */
{
  /* DEPRECATED */
}


/****************************************************************
 *
 *  TextStrSo.c functions 
 *
 ****************************************************************/

Boolean
_XmStringSourceFindString(Widget w,
			  XmTextPosition start,
			  char* string,
			  XmTextPosition *position)
{
  return(XmTextFindString(w, start, string, XmTEXT_FORWARD, position));
}

/****************************************************************
 *
 *  TextIn.c functions 
 *
 ****************************************************************/

XmTextPosition 
_XmTextGetAnchor(XmTextWidget tw)
{
  InputData data = tw->text.input->data;
  
  return(data->anchor);
}

/****************************************************************
 *
 *  Traversal.c functions 
 *
 ****************************************************************/

/*ARGSUSED*/
Boolean 
_XmGrabTheFocus(
        Widget w,
        XEvent *event )		/* unused */
{
  /* Function used by TextEdit widgets to grab the focus.
   */
  return _XmMgrTraversal( w, XmTRAVERSE_CURRENT) ;
}


/*ARGSUSED*/
void 
_XmProcessTraversal(
        Widget w,
        XmTraversalDirection dir,
#if NeedWidePrototypes
        int check )		/* unused */
#else
        Boolean check )		/* unused */
#endif /* NeedWidePrototypes */
{   
  _XmMgrTraversal( w, dir ) ;
}


Widget 
_XmFindNextTabGroup(
        Widget wid )
{
  return _XmNavigate( wid, XmTRAVERSE_NEXT_TAB_GROUP) ;
}


Widget 
_XmFindPrevTabGroup(
        Widget wid )
{
  return _XmNavigate( wid, XmTRAVERSE_PREV_TAB_GROUP) ;
}


Boolean 
_XmCreateVisibilityRect(Widget w,
			XRectangle *rectPtr)
{   
  return _XmComputeVisibilityRect(w, rectPtr, FALSE, TRUE);
}

/****************************************************************
 *
 *  MenuShell.c functions 
 *
 ****************************************************************/
void
_XmSetLastManagedMenuTime (
	Widget wid,
	Time newTime )
{
   _XmGetMenuState((Widget)wid)->MS_LastManagedMenuTime = newTime;
}


/****************************************************************
 *
 *  XmString.c functions 
 *
 ****************************************************************/

/*
 * count the number of lines in an _XmString.
 */
int 
_XmStringLineCount(
        _XmString string )
{
  return(XmStringLineCount(string));
}

/* Used to create internal XmString, now just copies. */
_XmString 
_XmStringCreate(
        XmString cs )
{
  return((_XmString)XmStringCopy(cs));
}

/* Used to create external XmString from internal, now just copies. */
/*ARGSUSED*/
XmString 
_XmStringCreateExternal(
        XmRenderTable rendertable, /* unused */
        _XmString cs )
{
  return(XmStringCopy((XmString)cs));
}  

Boolean 
_XmStringEmpty(
        _XmString string )
{
  return(XmStringEmpty(string));
}

void 
_XmStringFree(
        _XmString string )
{
  XmStringFree(string);
}

/*
 * find total height of XmString
 */
Dimension 
_XmStringHeight(
        XmRenderTable rendertable,
        _XmString string )
{
  if (!string || !rendertable) return (0);

  return(XmStringHeight(rendertable, string));
}

/*
 * find the rectangle which will enclose the text 
 */
void 
_XmStringExtent(
        XmRenderTable rendertable,
        _XmString string,
        Dimension *width,
        Dimension *height )
{
  if (!string || !rendertable)
    {
      *width = 0;
      *height = 0;
      return;
    }

  XmStringExtent(rendertable, string, width, height);
}


/*
 * find width of widest line in XmString
 */
Dimension 
_XmStringWidth(
        XmRenderTable rendertable,
        _XmString string )
{
  if (!string || !rendertable) return (0);

  return(XmStringWidth(rendertable, string));
}

void 
_XmStringDraw(
        Display *d,
        Window w,
        XmRenderTable rendertable,
        _XmString string,
        GC gc,
#if NeedWidePrototypes
        int x,
        int y,
        int width,
        unsigned int align,
        unsigned int lay_dir,
#else
        Position x,
        Position y,
        Dimension width,
        unsigned char align,
        unsigned char lay_dir,
#endif /* NeedWidePrototypes */
        XRectangle *clip )
{
    XmStringDraw(d, w, rendertable, string, gc, x, y, width, 
		 align, lay_dir, clip);
}

void 
_XmStringDrawImage(
        Display *d,
        Window w,
        XmRenderTable rendertable,
        _XmString string,
        GC gc,
#if NeedWidePrototypes
        int x,
        int y,
        int width,
        unsigned int align,
        unsigned int lay_dir,
#else
        Position x,
        Position y,
        Dimension width,
        unsigned char align,
        unsigned char lay_dir,
#endif /* NeedWidePrototypes */
        XRectangle *clip )
{
    XmStringDrawImage(d, w, rendertable, string, gc, x, y, width, 
		      align, lay_dir, clip);
}

void 
_XmStringDrawUnderline(
        Display *d,
        Window w,
        XmRenderTable f,
        _XmString s,
        GC gc,
#if NeedWidePrototypes
        int x,
        int y,
        int width,
        unsigned int align,
        unsigned int lay_dir,
#else
        Position x,
        Position y,
        Dimension width,
        unsigned char align,
        unsigned char lay_dir,
#endif /* NeedWidePrototypes */
        XRectangle *clip,
        _XmString u )
{
    XmStringDrawUnderline(d, w, f, s, gc, x, y, width, 
			  align, lay_dir, clip, u);
}

void 
_XmStringDrawMnemonic(
        Display *d,
        Window w,
        XmRenderTable rendertable,
        _XmString string,
        GC gc,
#if NeedWidePrototypes
        int x,
        int y,
        int width,
        unsigned int align,
        unsigned int lay_dir,
#else
        Position x,
        Position y,
        Dimension width,
        unsigned char align,
        unsigned char lay_dir,
#endif /* NeedWidePrototypes */
        XRectangle *clip,
        String mnemonic,
        XmStringTag tag )
{
    XmString underline;
 
    underline = XmStringCreate(mnemonic, tag);
 
    XmStringDrawUnderline(d, w, rendertable, string, gc, x, y, width, 
			  align, lay_dir, clip, underline);
    XmStringFree(underline);
}

/*
 * internal structure access routines
 */
Boolean 
_XmStringInitContext(
        _XmStringContext *context,
        _XmString string )
{
  return(XmStringInitContext(context, string));
}

void 
_XmStringFreeContext(
        _XmStringContext context )
{
  XmStringFreeContext(context);
}

_XmString 
_XmStringCopy( _XmString string )
{
  if (string == (_XmString) NULL) return ((_XmString) NULL);
  else return((_XmString)XmStringCopy(string));
}

/*
 * check these two internals
 */
Boolean 
_XmStringByteCompare(
        _XmString a,
        _XmString b )
{
  if (!a && !b) return(TRUE);
  if (!a || !b) return(FALSE);

  return(XmStringByteCompare(a, b));
}

Dimension 
_XmStringBaseline(
        XmRenderTable rendertable,
        _XmString string )
{
  if (!string || !rendertable) return (0);

  return(XmStringBaseline(rendertable, string));
}

Boolean 
_XmStringHasSubstring(
        _XmString string,
        _XmString substring )
{
  if ((string == NULL) || (substring == NULL) || (XmStringEmpty(substring)))
    return (FALSE);

  return(XmStringHasSubstring(string, substring));
}




/* Replaced by XmTextGetInsertionPosition */

XmTextPosition 
XmTextGetCursorPosition(Widget widget)
{
  if (XmIsTextField(widget))
    return(XmTextFieldGetCursorPosition(widget));
  else {
    return(XmTextGetInsertionPosition(widget));
  }
}


/* Replaced by XmTextSetInsertionPosition */

void 
XmTextSetCursorPosition(Widget widget,
			XmTextPosition position)
{
  if (XmIsTextField(widget))
    XmTextFieldSetCursorPosition(widget, position);
  else {
    XmTextSetInsertionPosition(widget, position);
  }
}

/* Replaced by XmTextFieldSetInsertionPosition */

void 
XmTextFieldSetCursorPosition(Widget w,
			     XmTextPosition position)
{
  XmTextFieldSetInsertionPosition(w, position);
}

/* Replaced by XmTextFieldGetInsertionPosition */

XmTextPosition 
XmTextFieldGetCursorPosition(Widget w)
{
  return XmTextFieldGetInsertionPosition(w);
}


/****************************************************************
 *
 *  TravAct.c functions 
 *
 ****************************************************************/


/*
 * Get the state of the 'ResettingFocus' flag, based upon the
 * display to which the widget is tied.
 */
Boolean 
_XmGetFocusResetFlag(
        Widget w )
{
   return( (Boolean) _XmGetFocusFlag(w, XmFOCUS_RESET) );
}


/*
 * Set the state of the 'ResettingFocus' flag.
 */
void 
_XmSetFocusResetFlag(
        Widget w,
#if NeedWidePrototypes
        int value )
#else
        Boolean value )
#endif /* NeedWidePrototypes */
{
   _XmSetFocusFlag(w, XmFOCUS_RESET, value);
}

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

/*ARGSUSED*/
void 
_XmStringUpdate(XmFontList fontlist, /* unused */
		_XmString string ) /* unused */
{
  /*EMPTY*/
}



/* From BaseClass.c */

/*ARGSUSED*/
void 
_XmFreeWidgetExtData(
        Widget widget )		/* unused */
{
  /*EMPTY*/
}


/*ARGSUSED*/
void 
_XmBaseClassPartInitialize(
        WidgetClass wc )	/* unused */
{
  /*EMPTY*/
}


Boolean 
_XmIsSlowSubclass(
        WidgetClass wc,
        unsigned int bit )
{
  XmBaseClassExt *wcePtr = _XmGetBaseClassExtPtr(wc, XmQmotif);
  
  if (!wcePtr || !(*wcePtr))
    return False;
  
  if ((_XmGetFlagsBit((*wcePtr)->flags, bit)) != 0)
    return True;
  else
    return False;
}


Boolean
_XmIsStandardMotifWidgetClass(
        WidgetClass wc)
{
  /* This routine depends on ALL standard Motif classes use fast subclassing. */
  XmBaseClassExt * fastPtr;
  XmBaseClassExt * superFastPtr;
  WidgetClass super_wc = wc->core_class.superclass;
  
  if ((fastPtr = _XmGetBaseClassExtPtr( wc, XmQmotif)) && *fastPtr)
    {
      if (!(superFastPtr = _XmGetBaseClassExtPtr( super_wc, XmQmotif)))
        {
          /* This catches all Motif classes which are direct subclasses
           * of an Xt Intrinsics widget class.
           */
          return TRUE;
        }
      if (*superFastPtr)
        {
          unsigned char * flags = (*fastPtr)->flags;
          unsigned char * superFlags = (*superFastPtr)->flags;
          unsigned numBytes = (XmLAST_FAST_SUBCLASS_BIT >> 3) + 1;
          unsigned Index;
	  
          Index = numBytes;
          while (Index--)
            {
              if (flags[Index] != superFlags[Index])
                {
                  /* Since all Motif classes use fast subclassing, the fast
                   * subclassing bits of any standard Motif class will be
                   * different than those of its superclass (the superclass
                   * will have one less bit set).  Any non-standard Motif
                   * subclass will have the same fast subclass bits as its
                   * superclass.
                   */
                  return TRUE;
                }
            }
        }
    }
  return FALSE;
}



/** Obsolete from ImageCache.c */

Pixmap 
_XmGetPixmap(
    Screen *screen,
    char *image_name,
    int depth,
    Pixel foreground,
    Pixel background)
{    
    return(XmGetPixmapByDepth(screen, image_name,
			      foreground, background, depth));
}

 
Boolean 
_XmInstallPixmap(
        Pixmap pixmap,
        Screen *screen,
        char *image_name,
        Pixel foreground,
        Pixel background )
{
  return _XmCachePixmap(pixmap, screen, image_name, 
			foreground, background, 0, 0, 0);
}




