/*

 * 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

#define FIX_1152

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: XmRenderT.c /main/14 1998/10/26 20:14:42 samborn $"

#endif

#endif

#ifndef X_NOT_STDC_ENV

#include <stdlib.h>

#endif

#include <string.h>

#include <ctype.h>

#include <math.h>

#ifdef __cplusplus

extern "C" { /* some 'locale.h' do not have prototypes (sun) */

#endif

#include <X11/Xlocale.h>

#ifdef __cplusplus

} /* Close scope of 'extern "C"' declaration */

#endif /* __cplusplus */

#include <Xm/XmosP.h>		/* For ALLOCATE/DEALLOCATE_LOCAL */

#include <X11/IntrinsicP.h>

#include <X11/ShellP.h>

#include <X11/Xresource.h>

#include <Xm/Display.h>		/* For XmGetXmDisplay */

#include <Xm/DisplayP.h>	/* For direct access to callback fields */

#include "MessagesI.h"

#include "XmI.h"

#include "XmRenderTI.h"

#include "XmStringI.h"

#include "XmTabListI.h"

#ifdef USE_XFT

#include <X11/Xft/Xft.h>

#endif

/* Warning Messages */

#define NO_NULL_TAG_MSG			_XmMMsgXmRenderT_0000

#define NULL_DISPLAY_MSG      		_XmMMsgXmRenderT_0001

#define INVALID_TYPE_MSG      		_XmMMsgXmRenderT_0002

#define CONVERSION_FAILED_MSG 		_XmMMsgXmRenderT_0003

#define NULL_FONT_TYPE_MSG    		_XmMMsgXmRenderT_0004

#define NULL_LOAD_IMMEDIATE_MSG		_XmMMsgXmRenderT_0005

/* local macros */

#define GetHandle(type)		(type *)XtMalloc(sizeof(type))

#define FreeHandle(handle)	XtFree((char *)handle)

#define SetPtr(handle, ptr)	*(handle) = ptr

#define GetPtr(handle)		*(handle)

#define NameIsString(fontname) \

  (((fontname) != NULL) && ((fontname) != (String)XmAS_IS))

#define ListIsList(tablist) \

  (((tablist) != NULL) && \

   ((unsigned int)(unsigned long)(tablist) != XmAS_IS))

#define  FIX_1414

#define  FIX_1449

#define  FIX_1444

#define FIX_1451

#define FIX_1536

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

 *	      IMPORTANT NOTE: IMPLEMENTATION OF SHARING

 *

 *	Instances of XmRenderTable and XmRendition are shared via a

 *	reference counting mechanism. This comment provides a general

 *	overview of how this is done.

 *

 *	First, both rendertable and renditions are indirectly

 *	referenced via a handle mechanism.  See the GetHandle,

 *	FreeHandle, SetPtr and GetPtr macros above.  This allows

 *	either the handle to change without the underlying data

 * 	structure changing, or the underlying data structure to change

 *	without the handle changing. I will indicate below where this

 *	happens.

 *

 *	Second, the real data structure for rendertable and rendition

 *	contain a reference count.  This count is incremented on copy

 *	and decremented on free.  If a decrement produces a zero

 *	refcount, the actual memory is freed.  If an increment

 *	produces a zero refcount, then the refcount has overflowed.  The

 *	refcount is decremented, and new memory is allocated for a new

 *	copy. 

 *

 *	Finally, I have defined a terminology for the different types

 *	of "copying" that can done based on allocating a new handle or

 *	not and allocating a new data structure or not.  This probably

 *	conflicts with some other existing terminology, probably in

 *	object oriented programming.  Sorry about that.

 *

 *	Function:	Clone	Copy	Renew	Duplicate

 *			(Mutate)	(Update)

 *

 *	handle		new	new	old	old

 *	structure	new	inc	new	inc

 *			(changed)	(changed)

 *

 *	(changed) indicates that the data in the new structure has

 *	been changed from the data in the old structure.

 *

 *	I will use these terms as a short hand in describing the

 *	functions below.

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

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

static void CopyInto(XmRendition toRend, 

		     XmRendition fromRend); 

static void MergeInto(XmRendition toRend, 

		     XmRendition fromRend); 

static XmRendition CloneRendition(XmRendition rend); 

static XmRendition CopyRendition(XmRendition rend); 

static XmRendition RenewRendition(XmRendition rend); 

static XmRendition DuplicateRendition(XmRendition rend); 

static Boolean FreeRendition(XmRendition rend); 

static void RenditionWarning(char *tag, char *type,

			     char *message, Display *dpy);

static void CleanupResources(XmRendition rend, Boolean copy);

static void ValidateTag(XmRendition rend,

			XmStringTag dflt);

static void ValidateAndLoadFont(XmRendition rend, Display *display);

static void SetRend(XmRendition to,

		    XmRendition from); 

static Boolean RendComplete(XmRendition rend);      

static void CopyFromArg(XtArgVal src,

			char *dst,

			unsigned int size);

static void CopyToArg(char *src,

		      XtArgVal *dst,

		      unsigned int size); 

static Cardinal GetNamesAndClasses(Widget w,

				   XrmNameList names,

				   XrmClassList classes); 

static XrmResourceList CompileResourceTable(XtResourceList resources,

					    Cardinal num_resources); 

static Boolean GetResources(XmRendition rend,

			    Display *dsp,

			    Widget wid,

			    String resname,

			    String resclass,

			    XmStringTag tag,

			    ArgList arglist,

			    Cardinal argcount);

static void SetDefault(XmRendition rend); 

#ifdef USE_XFT

#ifdef FIX_1536

static XftColor GetCachedXftColor(Display *display, Pixel color);

#endif

#endif

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

/* Resource List. */

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

/* N.B.:  The SetDefault procedure has a hardcoded list of all the	*/

/*	common resources.  Be sure to update it when adding resources.	*/

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

#define DEFAULT_loadModel		XmAS_IS

#define DEFAULT_tag			XmS

#define DEFAULT_fontName		(String)XmAS_IS

#define DEFAULT_fontType		(XmFontType)XmAS_IS

#define DEFAULT_font			(XtPointer)XmAS_IS

#define DEFAULT_tabs			(XmTabList)XmAS_IS

#define DEFAULT_background		XmUNSPECIFIED_PIXEL

#define DEFAULT_foreground		XmUNSPECIFIED_PIXEL

#define DEFAULT_underlineType		XmAS_IS

#define DEFAULT_strikethruType		XmAS_IS

#define DEFAULT_backgroundState		XmAS_IS

#define DEFAULT_foregroundState		XmAS_IS

#ifdef USE_XFT

#define DEFAULT_xftFont			(XtPointer)XmAS_IS

#define DEFAULT_fontStyle		(String)NULL

#define DEFAULT_fontFoundry		(String)NULL

#define DEFAULT_fontEncoding		(String)NULL

#define DEFAULT_fontSize		0

#endif

static XtResource _XmRenditionResources[] = {

  { 

    XmNtag, XmCTag, XmRString,

    sizeof(XmStringTag), XtOffsetOf(_XmRenditionRec, tag),

    XmRImmediate, (XtPointer) DEFAULT_tag

  },

  { 

    XmNfontName, XmCFontName, XmRString,

    sizeof(String), XtOffsetOf(_XmRenditionRec, fontName),

    XmRImmediate, (XtPointer) DEFAULT_fontName

  },

  { 

    XmNfontType, XmCFontType, XmRFontType,

    sizeof(XmFontType), XtOffsetOf(_XmRenditionRec, fontType),

    XmRImmediate, (XtPointer) DEFAULT_fontType

  },

  { 

    XmNfont, XmCFont, XmRFontStruct,

    sizeof(XtPointer), XtOffsetOf(_XmRenditionRec, font),

    XmRImmediate, (XtPointer) DEFAULT_font

  },

  { 

    XmNloadModel, XmCLoadModel, XmRLoadModel,

    sizeof(unsigned char), XtOffsetOf(_XmRenditionRec, loadModel),

    XmRImmediate, (XtPointer) DEFAULT_loadModel

  },

  { 

    XmNtabList, XmCTabList, XmRTabList,

    sizeof(XmTabList), XtOffsetOf(_XmRenditionRec, tabs),

    XmRImmediate, (XtPointer) DEFAULT_tabs

  },

#if USE_XFT

  {

    XmNxftFont, XmCXftFont, XmRPointer,

    sizeof (XtPointer), XtOffsetOf (_XmRenditionRec, xftFont),

    XmRImmediate, (XtPointer) DEFAULT_xftFont

  },

  {

    XmNrenditionBackground, XmCRenditionBackground, XmRRenditionPixel,

    sizeof (Pixel), XtOffsetOf (_XmRenditionRec, xftBackground.pixel),

    XmRImmediate, (XtPointer) DEFAULT_background

  },

  {

    XmNrenditionForeground, XmCRenditionForeground, XmRRenditionPixel,

    sizeof (Pixel), XtOffsetOf (_XmRenditionRec, xftForeground.pixel),

    XmRImmediate, (XtPointer) DEFAULT_foreground

  },

  {

    XmNfontStyle, XmCFontStyle, XmRString,

    sizeof(String), XtOffsetOf (_XmRenditionRec, fontStyle),

    XmRImmediate, (XtPointer) DEFAULT_fontStyle

  },

  {

    XmNfontFoundry, XmCFontFoundry, XmRString,

    sizeof(String), XtOffsetOf (_XmRenditionRec, fontFoundry),

    XmRImmediate, (XtPointer) DEFAULT_fontFoundry

  },

  {

    XmNfontEncoding, XmCFontEncoding, XmRString,

    sizeof(String), XtOffsetOf (_XmRenditionRec, fontEncoding),

    XmRImmediate, (XtPointer) DEFAULT_fontEncoding

  },

  {

    XmNfontSize, XmCFontSize, XmRInt,

    sizeof(int), XtOffsetOf (_XmRenditionRec, fontSize),

    XmRImmediate, (XtPointer) DEFAULT_fontSize

  },

#else

  {

    XmNrenditionBackground, XmCRenditionBackground, XmRRenditionPixel,

    sizeof (Pixel), XtOffsetOf (_XmRenditionRec, background),

    XmRImmediate, (XtPointer) DEFAULT_background

  },

  {

    XmNrenditionForeground, XmCRenditionForeground, XmRRenditionPixel,

    sizeof (Pixel), XtOffsetOf (_XmRenditionRec, foreground),

    XmRImmediate, (XtPointer) DEFAULT_foreground

  },

#endif

  { 

    XmNunderlineType, XmCUnderlineType, XmRLineType,

    sizeof(unsigned char), XtOffsetOf(_XmRenditionRec, underlineType),

    XmRImmediate, (XtPointer) DEFAULT_underlineType

  },

  { 

    XmNstrikethruType, XmCStrikethruType, XmRLineType,

    sizeof(unsigned char), XtOffsetOf(_XmRenditionRec, strikethruType),

    XmRImmediate, (XtPointer) DEFAULT_strikethruType

  },

  { 

    XmNforegroundState, XmCGroundState, XmRGroundState,

    sizeof(unsigned char), XtOffsetOf(_XmRenditionRec, foregroundState),

    XmRImmediate, (XtPointer) DEFAULT_foregroundState

  },

  { 

    XmNbackgroundState, XmCGroundState, XmRGroundState,

    sizeof(unsigned char), XtOffsetOf(_XmRenditionRec, backgroundState),

    XmRImmediate, (XtPointer) DEFAULT_backgroundState

  },

};

static XmConst Cardinal _XmNumRenditionResources = 

	XtNumber(_XmRenditionResources);

/* Searches up widget hierarchy, quarkifying ancestor names and */

/* classes. */

static Cardinal

GetNamesAndClasses(Widget w, XrmNameList names, XrmClassList classes)

{

  Cardinal length, j;

  XrmQuark t;

  WidgetClass wc;

  /* Return null-terminated quark arrays, with length the number of

     quarks (not including NULL) */

  for (length = 0; w != NULL; w = (Widget)w->core.parent)

    {

      names[length] = w->core.xrm_name;

      wc = XtClass(w);

      /* KLUDGE KLUDGE KLUDGE KLUDGE */

      if (w->core.parent == NULL && XtIsApplicationShell(w)) {

	classes[length] =

	  ((ApplicationShellWidget) w)->application.xrm_class;

      } else classes[length] = wc->core_class.xrm_class;

      length++;

    }

  /* They're in backwards order, flop them around */

  for (j = 0; j < length/2; j++)

    {

      t = names[j];

      names[j] = names[length-j-1];

      names[length-j-1] = t;

      t = classes[j];

      classes[j] = classes[length-j-1];

      classes[length-j-1] = t;

    }

  names[length] = NULLQUARK;

  classes[length] = NULLQUARK;

  return length;

}						  /* GetNamesAndClasses */

/* Converts resource list to quarkified list. */

static XrmResourceList

CompileResourceTable(XtResourceList resources,

		     Cardinal num_resources)

{

  Cardinal		count;

  XrmResourceList	table, tPtr;

  XtResourceList	rPtr;

  tPtr = table = (XrmResourceList)XtMalloc(num_resources * sizeof(XrmResource));

  rPtr = resources;

  for (count = 0; count < num_resources; count++, tPtr++, rPtr++)

    {

      tPtr->xrm_name 		= XrmPermStringToQuark(rPtr->resource_name);

      tPtr->xrm_class 		= XrmPermStringToQuark(rPtr->resource_class);

      tPtr->xrm_type 		= XrmPermStringToQuark(rPtr->resource_type);

      tPtr->xrm_size		= rPtr->resource_size;

      tPtr->xrm_offset		= rPtr->resource_offset;

      tPtr->xrm_default_type 	= XrmPermStringToQuark(rPtr->default_type);

      tPtr->xrm_default_addr	= rPtr->default_addr;

    }

  return(table);

}

/* Does resource database lookup for arglist, filling in defaults from */

/* resource list as necessary. */

static Boolean

GetResources(XmRendition rend,

	     Display *dsp,

	     Widget wid,

	     String resname,

	     String resclass,

	     XmStringTag tag,

	     ArgList arglist,

	     Cardinal argcount)

{

  XrmName		names[100];

  XrmClass		classes[100];

  Cardinal		length = 0;

  static XrmQuarkList	quarks = NULL;

  static Cardinal	num_quarks = 0;

  static Boolean	*found = NULL;

  int			i, j;

  static XrmResourceList	table = NULL;

  static XrmQuark	QString;

  static XrmQuark	Qfont;

  Arg			*arg;

  XrmName		argName;

  XrmResource		*res;

  XrmDatabase		db = NULL;

  XrmHashTable   	stackSearchList[100];

  XrmHashTable    	*searchList = stackSearchList;

  unsigned int    	searchListSize = 100;

  Boolean		got_one = False;

  XrmValue		value;

  XrmQuark		rawType;

  XrmValue		convValue;

  Boolean		have_value, copied;

#ifdef XTHREADS

  XtAppContext		app=NULL;

  if (wid)

	app = XtWidgetToApplicationContext(wid);

  else if (dsp)

	app = XtDisplayToApplicationContext(dsp);

  if (app) {

      _XmAppLock(app);

  }

  _XmProcessLock();

#endif

  /* Initialize quark cache */

  if (quarks == NULL)

    {

      quarks = (XrmQuark *)XtMalloc(_XmNumRenditionResources *

				    sizeof(XrmQuark));

      num_quarks = _XmNumRenditionResources;

    }

  /* Initialize found */

  if (found == NULL)

    found = (Boolean *)XtMalloc(_XmNumRenditionResources * sizeof(Boolean));

  bzero(found, _XmNumRenditionResources * sizeof(Boolean));

  /* Compile names and classes. */

  if (wid != NULL)

    length = GetNamesAndClasses(wid, names, classes);

  names[length] = XrmStringToQuark(resname);

  classes[length] = XrmStringToQuark(resclass);

  length++;

  if (tag != NULL)

    {

      names[length] = XrmStringToQuark(tag);

      classes[length] = XrmPermStringToQuark(XmCRendition);

      length++;

    }      

  names[length] = NULLQUARK;

  classes[length] = NULLQUARK;

  /* Cache arglist */

  if (num_quarks < argcount)

    {

      quarks = (XrmQuark *)XtRealloc((char *)quarks,

				     argcount * sizeof(XrmQuark));

      num_quarks = argcount;

    }

  for (i = 0; i < argcount; i++)

    quarks[i] = XrmStringToQuark(arglist[i].name);

  /* Compile resource description into XrmResourceList if not already done. */

  if (table == NULL)

    {

      table = CompileResourceTable(_XmRenditionResources,

				   _XmNumRenditionResources);

      QString = XrmPermStringToQuark(XtCString);

      Qfont = XrmPermStringToQuark(XmNfont);

    }

  /* Set resources from arglist. */

  for (arg = arglist, i = 0; i < argcount; arg++, i++)

    {

      argName = quarks[i];

      for (j = 0, res = table; j < _XmNumRenditionResources; j++, res++)

	{

	  if (res->xrm_name == argName)

	    {

	      CopyFromArg((arg->value),

			  ((char *)GetPtr(rend) + res->xrm_offset),

			  res->xrm_size);

	      found[j] = TRUE;

	      break;

	    }

	}

    }

  /* DB query */

  /* Get database */

  if ((wid != NULL) || (dsp != NULL))

    {

      if (wid != NULL)

	db = XtScreenDatabase(XtScreenOfObject(wid));

      else db = XtScreenDatabase(DefaultScreenOfDisplay(dsp));

      /* Get searchlist */

      while (!XrmQGetSearchList(db, names, classes,

				searchList, searchListSize))

	{

	  if (searchList == stackSearchList)

	    searchList = NULL;

	  searchList = (XrmHashTable *)XtRealloc((char*)searchList,

						 sizeof(XrmHashTable) *

						 (searchListSize *= 2));

	}

    }

  /* Loop over table */

  for (j = 0, res = table; j < _XmNumRenditionResources; j++, res++)

    {

      if (!found[j])

	{

	  copied = False;

	  have_value = False;

	  if ((db != NULL) &&

	      (XrmQGetSearchResource(searchList, res->xrm_name,

				     res->xrm_class, &rawType, &value)))

	    {

	      /* convert if necessary */

	      if (rawType != res->xrm_type)

		{

		  if (wid != NULL)

		    {

		      convValue.size = res->xrm_size;

		      convValue.addr = (char *)GetPtr(rend) + res->xrm_offset;

		      /*

		       * Check for special font case.

		       * Depending upon the fontType resource, try to convert

		       * to a FontSet, else to a FontStruct.

		       */

		      if ((res->xrm_name == Qfont) &&

			  (_XmRendFontType(rend) == XmFONT_IS_FONTSET))

			  copied = have_value =

			     XtConvertAndStore(wid, 

					       XrmQuarkToString(rawType),

					       &value,

					       "FontSet",

					       &convValue);

		      else

			  copied = have_value =

			     XtConvertAndStore(wid, 

					       XrmQuarkToString(rawType),

					       &value,

					       XrmQuarkToString(res->xrm_type),

					       &convValue);

		    }

		  else have_value = False;

		} 

	      else have_value = True;

	      /* Check for special font case */

	      if (have_value)

		{

		  if (res->xrm_name == Qfont)

		    {

		      _XmRendFontName(rend) = value.addr;

		      copied = True;

		    }

		}

	    }

	  if (!got_one && have_value) got_one = True;

	  /* Set defaults */

	  if (!have_value)

	    {

	      CopyFromArg((XtArgVal)(res->xrm_default_addr),

			  ((char *)GetPtr(rend) + res->xrm_offset),

			  res->xrm_size);

	      copied = True;

	    }

	  /* Copy if needed */

	  if (!copied)

	    {

	      if (res->xrm_type == QString)

		*((String *)((char *)GetPtr(rend) + res->xrm_offset)) =

		  value.addr;

	      else if (value.addr != NULL)

		memcpy(((char *)GetPtr(rend) + res->xrm_offset),

		       value.addr, res->xrm_size);

	      else 

		bzero(((char *)GetPtr(rend) + res->xrm_offset), res->xrm_size);

	    }

	}

    }

  if (searchList != stackSearchList) XtFree((char *)searchList);

#ifdef XTHREADS

  _XmProcessUnlock();

  if (app) {

      _XmAppUnlock(app);

  }

#endif

  return(got_one);

}

/* Sets all resources to defaults from resource list. */

static void

SetDefault(XmRendition rend)

{

  /* A more robust implementation of this routine would to to loop

   * over _XmRenditionResources and use CopyFromArg to reset values

   * in rend, but to improve performance we use direct assignments. 

   */

  if (rend == NULL) return;

#ifdef	USE_XFT

  memset (&(_XmRendXftFG(rend)), 0, sizeof (XftColor));

  memset (&(_XmRendXftBG(rend)), 0, sizeof (XftColor));

#endif

  /* Leave _XmRendFontOnly unchanged.	 */

  /* Leave _XmRendRefcount unchanged.	 */

  _XmRendLoadModel(rend)      = DEFAULT_loadModel;

  _XmRendTag(rend)	      = DEFAULT_tag;

  _XmRendFontName(rend)	      = DEFAULT_fontName;

  _XmRendFontType(rend)	      = DEFAULT_fontType;

  _XmRendFont(rend)	      = DEFAULT_font;

  /* Leave _XmRendDisplay unchanged.	 */

  /* Leave _XmRendGC unchanged.		 */

  /* Leave _XmRendTags unchanged.	 */

  /* Leave _XmRendCount unchanged.	 */

  /* Leave _XmRendHadEnds unchanged.	 */

  _XmRendTabs(rend)	      = DEFAULT_tabs;

  _XmRendBG(rend)	      = DEFAULT_background;

  _XmRendFG(rend)	      = DEFAULT_foreground;

  _XmRendUnderlineType(rend)  = DEFAULT_underlineType;

  _XmRendStrikethruType(rend) = DEFAULT_strikethruType;

  _XmRendBGState(rend)	      = DEFAULT_backgroundState;

  _XmRendFGState(rend)	      = DEFAULT_foregroundState;

#ifdef	USE_XFT

  _XmRendXftFG (rend).color.alpha = 0xFFFF; /*TODO: it is really needed? (yura)*/

  _XmRendXftBG (rend).color.alpha = 0xFFFF; /*TODO: it is really needed? (yura)*/

  _XmRendXftFont(rend) = DEFAULT_xftFont;

  _XmRendPattern(rend) = NULL;

  _XmRendFontStyle(rend) = DEFAULT_fontStyle;

  _XmRendFontFoundry(rend) = DEFAULT_fontFoundry;

  _XmRendFontEncoding(rend) = DEFAULT_fontEncoding;

  _XmRendFontSize(rend) = DEFAULT_fontSize;

  _XmRendPixelSize(rend) = 0;

  _XmRendFontSlant(rend) = 0;

  _XmRendFontSpacing(rend) = 0;

  _XmRendFontWeight(rend) = 0;

#endif

}

/* Extern function to pick out display from rendertable. */

Display *

_XmRenderTableDisplay(XmRenderTable table)

{

  return(_XmRTDisplay(table));

}

/* Find a rendition in table with matching tag.  Call callback if not */

/* found and callback available.  Fail if need_font is true and */

/* rendition found does not provide font. */

XmRendition

_XmRenderTableFindRendition(XmRenderTable table, 

			    XmStringTag tag,

#if NeedWidePrototypes

			    int cached_tag,

			    int need_font,

			    int call,

#else

			    Boolean cached_tag,

			    Boolean need_font,

			    Boolean call,

#endif /* NeedWidePrototypes */

			    short *index)

{

  int				i, j;

  XmRendition			rend;

  Boolean			hit = FALSE;

  XmDisplayCallbackStruct	cb;

  XmDisplay			dsp;

  XmRenderTable			copy;

  if ((table == NULL) || (tag == NULL)) return(NULL);

  for (;;) /* May have to try twice */

    {  

      for (i = 0; i < _XmRTCount(table); i++)

	{

	  rend = _XmRTRenditions(table)[i];

	  if ((cached_tag) ?

	      (_XmRendTag(rend) == tag) :

	      (strcmp(_XmRendTag(rend), tag) == 0))

	    {

	      hit = TRUE;

	      if ((_XmRendFont(rend) == NULL) && (_XmRendXftFont (rend) == NULL) &&

		  NameIsString(_XmRendFontName(rend)))

		{

		  if (_XmRendLoadModel(rend) == XmLOAD_DEFERRED)

		    _XmRendLoadModel(rend) = XmLOAD_IMMEDIATE;

		  ValidateAndLoadFont(rend, _XmRendDisplay(rend));

		  if (need_font && (_XmRendFont(rend) == NULL &&

                      _XmRendXftFont(rend) == NULL))

		    break;

		}

	      if (index != NULL) *index = i;

	      return(rend);

	    }

	}

      /* Are we done? */

      if (hit || !call) break;

      call = FALSE;

      /* Call callback */

      if (_XmRTDisplay(table) != NULL)

	{

	  dsp = (XmDisplay) XmGetXmDisplay(_XmRTDisplay(table));

	  /* CR 7964: XtHasCallbacks is surprisingly expensive, */

	  /*	so we use a conservative approximation here. */

	  if (dsp && dsp->display.noRenditionCallback)

	    {

	      copy = XmRenderTableCopy(table, NULL, 0);

	      cb.reason = XmCR_NO_RENDITION;

	      cb.event = NULL;

	      cb.render_table = copy;

	      cb.tag = tag;

	      XtCallCallbackList((Widget)dsp, 

				 dsp->display.noRenditionCallback, 

				 &cb;;

	      if (cb.render_table != copy)

		{

		  /* Callback mutated table.  Update table with */

		  /* substitution and search again. */

		  for (j = 0; j < _XmRTCount(table); j++)

		    if (FreeRendition(_XmRTRenditions(table)[j]))

		      FreeHandle(_XmRTRenditions(table)[j]);

		  if (_XmRTRefcountDec(table) == 0)

		    XtFree((char *)GetPtr(table));

		  SetPtr(table, GetPtr(cb.render_table));

		  FreeHandle(cb.render_table);

		}

	      else break;

	    }

	  else break;

	}

      else break;

    } 

  /* Didn't find it. */

  if (index != NULL) *index = -1;

  return(NULL);

}

/* If to has resource unset and from has it set, set in to. */

static void

SetRend(XmRendition to,

	XmRendition from)

{

  if (NameIsString(_XmRendFontName(from)) &&

      !NameIsString(_XmRendFontName(to)))

    _XmRendFontName(to) = _XmRendFontName(from);

  if ((_XmRendFontType(from) != XmAS_IS) &&

      (_XmRendFontType(to) == XmAS_IS))

    _XmRendFontType(to) = _XmRendFontType(from);

  if ((_XmRendLoadModel(from) != XmAS_IS) &&

      (_XmRendLoadModel(to) == XmAS_IS))

    _XmRendLoadModel(to) = _XmRendLoadModel(from);

  if ((_XmRendFont(from) != NULL) &&

      ((unsigned int)(unsigned long)_XmRendFont(to) == XmAS_IS))

    _XmRendFont(to) = _XmRendFont(from);

  if (ListIsList(_XmRendTabs(from)) &&

      !ListIsList(_XmRendTabs(to)))

    _XmRendTabs(to) = _XmRendTabs(from);

#if USE_XFT

  if ((_XmRendFG(from) != XmUNSPECIFIED_PIXEL) &&

      (_XmRendFG(to) == XmUNSPECIFIED_PIXEL))

    {

#ifdef FIX_1536

      _XmRendFG(to) = _XmRendFG(from);

      _XmRendXftFG(to) = GetCachedXftColor(_XmRendDisplay(to), _XmRendFG(to));

#else

      XColor xcolor;

      _XmRendFG(to) = _XmRendFG(from);

      xcolor.pixel = _XmRendFG(to);

      XQueryColor(_XmRendDisplay(to), DefaultColormapOfScreen(

                  DefaultScreenOfDisplay(_XmRendDisplay(to))), &xcolor);

      /* doesn't needed  (_XmRendXftFG (to)).pixel = xcolor.pixel; */

      (_XmRendXftFG(to)).color.red = xcolor.red;

      (_XmRendXftFG(to)).color.green = xcolor.green;

      (_XmRendXftFG(to)).color.blue = xcolor.blue;

      (_XmRendXftFG(to)).color.alpha = 0xFFFF;

#endif

    }

  if ((_XmRendBG(from) != XmUNSPECIFIED_PIXEL) &&

      (_XmRendBG(to) == XmUNSPECIFIED_PIXEL))

    {

#ifdef FIX_1536

      _XmRendBG(to) = _XmRendBG (from);

      _XmRendXftBG(to) = GetCachedXftColor(_XmRendDisplay(to), _XmRendBG(to));

#else

      XColor xcolor;

      _XmRendBG(to) = _XmRendBG (from);

      xcolor.pixel = _XmRendBG (to);

      XQueryColor(_XmRendDisplay(to), DefaultColormapOfScreen(

                  DefaultScreenOfDisplay(_XmRendDisplay(to))), &xcolor);

      /* doesn't needed  (_XmRendXftBG (to)).pixel = xcolor.pixel; */

      (_XmRendXftBG(to)).color.red = xcolor.red;

      (_XmRendXftBG(to)).color.green = xcolor.green;

      (_XmRendXftBG(to)).color.blue = xcolor.blue;

      (_XmRendXftBG(to)).color.alpha = 0xFFFF;

#endif

    }

  if ((_XmRendXftFont (from) != NULL) &&

      ((unsigned int) (unsigned long) _XmRendXftFont (to) == XmAS_IS))

    _XmRendXftFont (to) = _XmRendXftFont (from);

  if ((_XmRendFontStyle (from) != NULL) && _XmRendFontStyle (to) == NULL)

    _XmRendFontStyle (to) = _XmRendFontStyle (from);

  if ((_XmRendFontFoundry (from) != NULL) && _XmRendFontFoundry (to) == NULL)

    _XmRendFontFoundry (to) = _XmRendFontFoundry (from);

  if ((_XmRendFontEncoding (from) != NULL) && _XmRendFontEncoding (to) == NULL)

    _XmRendFontEncoding (to) = _XmRendFontEncoding (from);

  if (_XmRendFontSize (to) == 0)

    _XmRendFontSize (to) = _XmRendFontSize (from);

#else

  if ((_XmRendFG(from) != XmUNSPECIFIED_PIXEL) &&

      (_XmRendFG(to) == XmUNSPECIFIED_PIXEL))

    _XmRendFG(to) = _XmRendFG (from);

  if ((_XmRendBG(from) != XmUNSPECIFIED_PIXEL) &&

      (_XmRendBG(to) == XmUNSPECIFIED_PIXEL))

    _XmRendBG(to) = _XmRendBG (from);

#endif

  if ((_XmRendUnderlineType(from) != XmAS_IS) &&

      (_XmRendUnderlineType(to) == XmAS_IS))

    _XmRendUnderlineType(to) = _XmRendUnderlineType(from);

  if ((_XmRendStrikethruType(from) != XmAS_IS) &&

      (_XmRendStrikethruType(to) == XmAS_IS))

    _XmRendStrikethruType(to) = _XmRendStrikethruType(from);

}

/* Check that all resources are not default values. */

static Boolean

RendComplete(XmRendition rend)      

{

  return(((unsigned int)(unsigned long)_XmRendFontName(rend) != XmAS_IS) &&

	 (_XmRendFontType(rend) != XmAS_IS) &&

	 (_XmRendLoadModel(rend) != XmAS_IS) &&

	 (

	  ((unsigned int) (unsigned long) _XmRendFont (rend) != XmAS_IS)

#ifdef USE_XFT

            || ((unsigned int) (unsigned long) _XmRendXftFont (rend) != XmAS_IS)

#endif

         ) &&

	 ((unsigned int)(unsigned long)_XmRendTabs(rend) != XmAS_IS) &&

	 (_XmRendFG(rend) != XmUNSPECIFIED_PIXEL) &&

	 (_XmRendBG(rend) != XmUNSPECIFIED_PIXEL) &&

	 (_XmRendUnderlineType(rend) != XmAS_IS) &&

	 (_XmRendStrikethruType(rend) != XmAS_IS));

}

/* Search rt for all renditions matching tags, successively merging */

/* resource values in scr rendition. */

/*ARGSUSED*/