IABSD.fr/xenocara/lib/libXaw/src/Converters.c

Branch : - branch - master - tag -

• Show log

  Commit

• Author : matthieu
  Date : 2006-11-25 16:53:47
  Hash : 59f6d906
  Message : import from X.Org 7.2RC2

• lib/libXaw/src/Converters.c

• /*
   * Copyright (c) 1998 by The XFree86 Project, Inc.
   *
   * Permission is hereby granted, free of charge, to any person obtaining a
   * copy of this software and associated documentation files (the "Software"),
   * to deal in the Software without restriction, including without limitation
   * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   * and/or sell copies of the Software, and to permit persons to whom the
   * Software is furnished to do so, subject to the following conditions:
   *
   * The above copyright notice and this permission notice shall be included in
   * all copies or substantial portions of the Software.
   *  
   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
   * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
   * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
   * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
   * SOFTWARE.
   *
   * Except as contained in this notice, the name of the XFree86 Project shall
   * not be used in advertising or otherwise to promote the sale, use or other
   * dealings in this Software without prior written authorization from the
   * XFree86 Project.
   */
  
  /* $XFree86: xc/lib/Xaw/Converters.c,v 3.13 1999/06/06 08:47:54 dawes Exp $ */
  
  #ifdef HAVE_CONFIG_H
  #include <config.h>
  #endif
  #include <stdio.h>
  #include <X11/IntrinsicP.h>
  #include <X11/StringDefs.h>
  #include <X11/Xmu/CharSet.h>
  #include <X11/Xmu/SysUtil.h>
  #include <X11/Xaw/Simple.h>
  #include <X11/Xaw/XawInit.h>
  #include "Private.h"
  
  #ifndef OLDXAW
  
  /*
   * Definitions
   */
  #define done(type, value)			\
  {						\
    if (toVal->addr != NULL)			\
      {						\
        if (toVal->size < sizeof(type))		\
  	{					\
  	  toVal->size = sizeof(type);		\
  	  return (False);			\
  	}					\
        *(type *)(toVal->addr) = (value);		\
      }						\
    else						\
      {						\
        static type static_val;			\
  						\
        static_val = (value);			\
        toVal->addr = (XPointer)&static_val;	\
      }						\
    toVal->size = sizeof(type);			\
    return (True);				\
  }
  
  #define string_done(value)			\
  {						\
    if (toVal->addr != NULL)			\
      {						\
        if (toVal->size < size)			\
  	{					\
  	  toVal->size = size;			\
  	  return (False);			\
  	}					\
        strcpy((char *)toVal->addr, (value));	\
      }						\
    else						\
      toVal->addr = (XPointer)(value);		\
    toVal->size = size;				\
    return (True);				\
  }
  
  /*
   * Prototypes
   */
  static Boolean _XawCvtAtomToString(Display*, XrmValue*, Cardinal*,
  				   XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtBooleanToString(Display*, XrmValue*, Cardinal*,
  				      XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtBoolToString(Display*, XrmValue*, Cardinal*,
  				   XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtCARD32ToString(Display*, XrmValue*, Cardinal*,
  				     XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtCardinalToString(Display*, XrmValue*, Cardinal*,
  				       XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtDimensionToString(Display*, XrmValue*, Cardinal*,
  					XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtDisplayListToString(Display*, XrmValue*, Cardinal*,
  				    XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtFontStructToString(Display*, XrmValue*, Cardinal*,
  					 XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtIntToString(Display*, XrmValue*, Cardinal*,
  					  XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtPixelToString(Display*, XrmValue*, Cardinal*,
  				    XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtPixmapToString(Display*, XrmValue*, Cardinal*,
  				     XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtShortToString(Display*, XrmValue*, Cardinal*,
  				    XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtPositionToString(Display*, XrmValue*, Cardinal*,
  				       XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtStringToDisplayList(Display*, XrmValue*, Cardinal*,
  					  XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtStringToPixmap(Display*, XrmValue*, Cardinal*,
  				     XrmValue*, XrmValue*, XtPointer*);
  static Boolean _XawCvtUnsignedCharToString(Display*, XrmValue*, Cardinal*,
  				     XrmValue*, XrmValue*, XtPointer*);
  static void TypeToStringNoArgsWarning(Display*, String);
  
  /*
   * Initialization
   */
  static XtConvertArgRec PixelArgs[] = {
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
     sizeof(Colormap)},
  };
  
  static XtConvertArgRec DLArgs[] = {
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
     sizeof(Screen *)},
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
     sizeof(Colormap)},
    {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.depth),
     sizeof(int)},
  };
  #endif /* OLDXAW */
  
  static String XtCToolkitError = "ToolkitError";
  static String XtNconversionError = "conversionError";
  
  #ifndef OLDXAW
  static String XtNwrongParameters = "wrongParameters";
  
  /*
   * Implementation
   */
  void
  XawInitializeDefaultConverters(void)
  {
    static Boolean first_time = True;
  
    if (first_time == False)
      return;
  
    first_time = False;
  
    /* Replace with more apropriate converters */
    XtSetTypeConverter(XtRCallback, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRColormap, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRFunction, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRPointer, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRScreen, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRStringArray, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRVisual, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRWidget, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRWidgetList, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRWindow, XtRString, _XawCvtCARD32ToString,
  		     NULL, 0, XtCacheNone, NULL);
  
    XtSetTypeConverter(XtRAtom, XtRString, _XawCvtAtomToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRBool, XtRString,  _XawCvtBoolToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRBoolean, XtRString,  _XawCvtBooleanToString,
  		     NULL, 0,  XtCacheNone, NULL);
    XtSetTypeConverter(XtRCardinal, XtRString, _XawCvtCardinalToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRDimension, XtRString, _XawCvtDimensionToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XawRDisplayList, XtRString, _XawCvtDisplayListToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRFontStruct, XtRString, _XawCvtFontStructToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRInt, XtRString, _XawCvtIntToString,
  		     NULL, 0, XtCacheNone, NULL);
    XtSetTypeConverter(XtRPixel, XtRString, _XawCvtPixelToString,
  		     &PixelArgs[0], XtNumber(PixelArgs), XtCacheNone, NULL);
    XtSetTypeConverter(XtRPixmap, XtRString, _XawCvtPixmapToString,
  		     &DLArgs[0], XtNumber(DLArgs), XtCacheNone, NULL);
    XtSetTypeConverter(XtRPosition, XtRString, _XawCvtPositionToString,
  		     NULL, 0, XtCacheNone,  NULL);
    XtSetTypeConverter(XtRShort, XtRString, _XawCvtShortToString,
  		     NULL, 0, XtCacheNone,  NULL);
    XtSetTypeConverter(XtRString, XawRDisplayList, _XawCvtStringToDisplayList,
  		     &DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
    XtSetTypeConverter(XtRString, XtRPixmap, _XawCvtStringToPixmap,
  		     &DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
    XtSetTypeConverter(XtRUnsignedChar, XtRString, _XawCvtUnsignedCharToString,
  		     NULL, 0, XtCacheNone, NULL);
  }
  #endif /* OLDXAW */
  
  void
  XawTypeToStringWarning(Display *dpy, String type)
  {
    char fname[64];
    String params[1];
    Cardinal num_params;
  
    XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
  
    params[0] = type;
    num_params = 1;
    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		  XtNconversionError, fname, XtCToolkitError,
  		  "Cannot convert %s to String",
  		  params, &num_params);
  }
  
  #ifndef OLDXAW
  static void
  TypeToStringNoArgsWarning(Display *dpy, String type)
  {
    char fname[64];
    String params[1];
    Cardinal num_params;
  
    XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
  
    params[0] = type;
    num_params = 1;
    XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		  XtNconversionError, fname,
  		  XtCToolkitError,
  		  "%s to String conversion needs no extra arguments",
  		  params, &num_params);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtBooleanToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		       XrmValue *fromVal, XrmValue *toVal,
  		       XtPointer *converter_data)
  {
    static char buffer[6];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRBoolean);
  
    XmuSnprintf(buffer, sizeof(buffer), "%s",
  	      *(Boolean *)fromVal->addr ? XtEtrue : XtEfalse);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtBoolToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		    XrmValue *fromVal, XrmValue *toVal,
  		    XtPointer *converter_data)
  {
    static char buffer[6];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRBool);
  
    XmuSnprintf(buffer, sizeof(buffer), "%s",
  	      *(Bool *)fromVal->addr ? XtEtrue : XtEfalse);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtPositionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			XrmValue *fromVal, XrmValue *toVal,
  			XtPointer *converter_data)
  {
    static char buffer[7];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRPosition);
  
    XmuSnprintf(buffer, sizeof(buffer), "%d", *(Position *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtShortToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		     XrmValue *fromVal, XrmValue *toVal,
  		     XtPointer *converter_data)
  {
    static char buffer[7];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRShort);
  
    XmuSnprintf(buffer, sizeof(buffer), "%d", *(short *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtDimensionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			 XrmValue *fromVal, XrmValue *toVal,
  			 XtPointer *converter_data)
  {
    static char buffer[6];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRDimension);
  
    XmuSnprintf(buffer, sizeof(buffer), "%u", *(Dimension *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtCARD32ToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		      XrmValue *fromVal, XrmValue *toVal,
  		      XtPointer *converter_data)
  {
    static char buffer[11];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, "CARD32");
  
    XmuSnprintf(buffer, sizeof(buffer), "0x%08hx", *(int *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtIntToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		   XrmValue *fromVal, XrmValue *toVal,
  		   XtPointer *converter_data)
  {
    static char buffer[12];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRInt);
  
    XmuSnprintf(buffer, sizeof(buffer), "%d", *(int *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtCardinalToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			XrmValue *fromVal, XrmValue *toVal,
  			XtPointer *converter_data)
  {
    static char buffer[11];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRCardinal);
  
    XmuSnprintf(buffer, sizeof(buffer), "%u", *(Cardinal *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtAtomToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		    XrmValue *fromVal, XrmValue *toVal,
  		    XtPointer *converter_data)
  {
    static char *buffer = NULL;
    static char *nullatom = "NULL";
    Cardinal size;
    Atom atom;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRAtom);
  
    if (buffer && buffer != nullatom)
      XFree(buffer);
  
    atom = *(Atom *)fromVal[0].addr;
    if (atom == 0)
      buffer = nullatom;
    else if ((buffer = XGetAtomName(dpy, *(Atom *)fromVal[0].addr)) == NULL)
      {
        XawTypeToStringWarning(dpy, XtRAtom);
        toVal->addr = NULL;
        toVal->size = sizeof(String);
        return (False);
      }
  
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtPixelToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		     XrmValue *fromVal, XrmValue *toVal,
  		     XtPointer *converter_data)
  {
    static char buffer[19];
    Cardinal size;
    Colormap colormap;
    XColor color;
  
    if (*num_args != 1)
      {
        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		      XtNwrongParameters, "cvtPixelToString",
  		      XtCToolkitError,
  		      "Pixel to String conversion needs colormap argument",
  		      NULL, NULL);
        return (False);
      }
  
    colormap = *(Colormap *)args[0].addr;
    color.pixel = *(Pixel *)fromVal->addr;
  
    /* Note:
     * If we know the visual type, we can calculate the xcolor
     * without asking Xlib.
     */
    XQueryColor(dpy, colormap, &color);
    XmuSnprintf(buffer, sizeof(buffer), "rgb:%04hx/%04hx/%04hx",
  	      color.red, color.green, color.blue);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtFontStructToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			  XrmValue *fromVal, XrmValue *toVal,
  			  XtPointer *converter_data)
  {
    static char buffer[128];
    Cardinal size;
    Atom atom;
    unsigned long value;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRFontStruct);
  
    if ((atom = XInternAtom(dpy, "FONT", True)) == None)
      return (False);
  
    size = 0;
  
    if (XGetFontProperty(*(XFontStruct **)fromVal->addr, atom, &value))
      {
        char *tmp = XGetAtomName(dpy, value);
  
        if (tmp)
  	{
  	  XmuSnprintf(buffer, sizeof(buffer), "%s", tmp);
  	  size = strlen(tmp);
  	  XFree(tmp);
  	}
      }
  
    if (size)
      {
        ++size;
      string_done(buffer);
      }
  
    XawTypeToStringWarning(dpy, XtRFontStruct);
  
    return (False);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtUnsignedCharToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			    XrmValue *fromVal, XrmValue *toVal,
  			    XtPointer *converter_data)
  {
    static char buffer[4];
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XtRUnsignedChar);
  
    XmuSnprintf(buffer, sizeof(buffer), "%u",
  	      *(unsigned char *)fromVal->addr);
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtStringToDisplayList(Display *dpy, XrmValue *args, Cardinal *num_args,
  			   XrmValue *fromVal, XrmValue *toVal,
  			   XtPointer *converter_data)
  {
    XawDisplayList *dlist;
    Screen *screen;
    Colormap colormap;
    int depth;
    String commands;
  
    if (*num_args != 3)
      {
        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		      XtNwrongParameters, "cvtStringToDisplayList",
  		      XtCToolkitError,
  		      "String to DisplayList conversion needs screen, "
  		      "colormap, and depth arguments",
  		      NULL, NULL);
        return (False);
      }
  
    screen     = *(Screen **)args[0].addr;
    colormap   = *(Colormap *)args[1].addr;
    depth      = *(int *)args[2].addr;
  
    commands = (String)(fromVal[0].addr);
  
    dlist = XawCreateDisplayList(commands, screen, colormap, depth);
  
    if (!dlist)
      {
        XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
  				       XawRDisplayList);
        toVal->addr = NULL;
        toVal->size = sizeof(XawDisplayList*);
        return (False);
      }
  
    done(XawDisplayList*, dlist);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtDisplayListToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  			   XrmValue *fromVal, XrmValue *toVal,
  			   XtPointer *converter_data)
  {
    String buffer;
    Cardinal size;
  
    if (*num_args != 0)
      TypeToStringNoArgsWarning(dpy, XawRDisplayList);
  
    buffer = XawDisplayListString(*(XawDisplayList **)(fromVal[0].addr));
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtStringToPixmap(Display *dpy, XrmValue *args, Cardinal *num_args,
  		      XrmValue *fromVal, XrmValue *toVal,
  		      XtPointer *converter_data)
  {
    XawPixmap *xaw_pixmap;
    Pixmap pixmap;
    Screen *screen;
    Colormap colormap;
    int depth;
    String name;
  
    if (*num_args != 3)
      {
        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		      XtNwrongParameters, "cvtStringToPixmap",
  		      XtCToolkitError,
  		      "String to Pixmap conversion needs screen, "
  		      "colormap, and depth arguments",
  		      NULL, NULL);
        return (False);
      }
  
    screen     = *(Screen **)args[0].addr;
    colormap   = *(Colormap *)args[1].addr;
    depth      = *(int *)args[2].addr;
  
    name = (String)(fromVal[0].addr);
  
    if (XmuCompareISOLatin1(name, "None") == 0)
      pixmap = None;
    else if (XmuCompareISOLatin1(name, "ParentRelative") == 0)
      pixmap = ParentRelative;
    else if (XmuCompareISOLatin1(name, "XtUnspecifiedPixmap") == 0)
      pixmap = XtUnspecifiedPixmap;
    else
      {
        xaw_pixmap = XawLoadPixmap(name, screen, colormap, depth);
        if (!xaw_pixmap)
  	{
  	  XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
  					   XtRPixmap);
  	  toVal->addr = (XtPointer)XtUnspecifiedPixmap;
  	  toVal->size = sizeof(Pixmap);
  	  return (False);
  	}
        else
  	pixmap = xaw_pixmap->pixmap;
      }
  
    done(Pixmap, pixmap);
  }
  
  /*ARGSUSED*/
  static Boolean
  _XawCvtPixmapToString(Display *dpy, XrmValue *args, Cardinal *num_args,
  		      XrmValue *fromVal, XrmValue *toVal,
  		      XtPointer *converter_data)
  {
    XawPixmap *xaw_pixmap;
    Pixmap pixmap;
    Screen *screen;
    Colormap colormap;
    int depth;
    String buffer = NULL;
    Cardinal size;
  
    if (*num_args != 3)
      {
        XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
  		      XtNwrongParameters, "cvtPixmapToString",
  		      XtCToolkitError,
  		      "Pixmap to String conversion needs screen, "
  		      "colormap, and depth arguments",
  		      NULL, NULL);
        return (False);
      }
  
    screen     = *(Screen **)args[0].addr;
    colormap   = *(Colormap *)args[1].addr;
    depth      = *(int *)args[2].addr;
  
    pixmap = *(Pixmap *)(fromVal[0].addr);
  
    switch (pixmap)
      {
      case None:
        buffer = "None";
        break;
      case ParentRelative:
        buffer = "ParentRelative";
        break;
      case XtUnspecifiedPixmap:
        buffer = "XtUnspecifiedPixmap";
        break;
      default:
        xaw_pixmap = XawPixmapFromXPixmap(pixmap, screen, colormap, depth);
        if (xaw_pixmap)
  	buffer = xaw_pixmap->name;
        break;
      }
  
    if (!buffer)
      /* Bad Pixmap or Pixmap was not loaded by XawLoadPixmap() */
      return (_XawCvtCARD32ToString(dpy, args, num_args, fromVal, toVal,
  				  converter_data));
  
    size = strlen(buffer) + 1;
  
    string_done(buffer);
  }
  
  #endif /* OLDXAW */