src/Converters.c

   1 /*
   2  * Copyright (c) 1998 by The XFree86 Project, Inc.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the "Software"),
   6  * to deal in the Software without restriction, including without limitation
   7  * the rights to use, copy, modify, merge, publish, distribute, sublicense,
   8  * and/or sell copies of the Software, and to permit persons to whom the
   9  * Software is furnished to do so, subject to the following conditions:
  10  *
  11  * The above copyright notice and this permission notice shall be included in
  12  * all copies or substantial portions of the Software.
  13  *
  14  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  15  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  16  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
  17  * THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
  18  * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
  19  * OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  20  * SOFTWARE.
  21  *
  22  * Except as contained in this notice, the name of the XFree86 Project shall
  23  * not be used in advertising or otherwise to promote the sale, use or other
  24  * dealings in this Software without prior written authorization from the
  25  * XFree86 Project.
  26  */
  27
  28 #ifdef HAVE_CONFIG_H
  29 #include <config.h>
  30 #endif
  31 #include <stdio.h>
  32 #include <X11/IntrinsicP.h>
  33 #include <X11/StringDefs.h>
  34 #include <X11/Xmu/CharSet.h>
  35 #include <X11/Xmu/SysUtil.h>
  36 #include <X11/Xaw/Simple.h>
  37 #include <X11/Xaw/XawInit.h>
  38 #include "Private.h"
  39
  40 #ifndef OLDXAW
  41
  42 /*
  43  * Definitions
  44  */
  45 #define done(type, value)                       \
  46 {                                               \
  47   if (toVal->addr != NULL)                      \
  48     {                                           \
  49       if (toVal->size < sizeof(type))           \
  50         {                                       \
  51           toVal->size = sizeof(type);           \
  52           return (False);                       \
  53         }                                       \
  54       *(type *)(toVal->addr) = (value);         \
  55     }                                           \
  56   else                                          \
  57     {                                           \
  58       static type static_val;                   \
  59                                                 \
  60       static_val = (value);                     \
  61       toVal->addr = (XPointer)&static_val;      \
  62     }                                           \
  63   toVal->size = sizeof(type);                   \
  64   return (True);                                \
  65 }
  66
  67 #define string_done(value)                      \
  68 {                                               \
  69   if (toVal->addr != NULL)                      \
  70     {                                           \
  71       if (toVal->size < size)                   \
  72         {                                       \
  73           toVal->size = size;                   \
  74           return (False);                       \
  75         }                                       \
  76       strcpy((char *)toVal->addr, (value));     \
  77     }                                           \
  78   else                                          \
  79     toVal->addr = (XPointer)(value);            \
  80   toVal->size = size;                           \
  81   return (True);                                \
  82 }
  83
  84 /*
  85  * Prototypes
  86  */
  87 static Boolean _XawCvtAtomToString(Display*, XrmValue*, Cardinal*,
  88                                    XrmValue*, XrmValue*, XtPointer*);
  89 static Boolean _XawCvtBooleanToString(Display*, XrmValue*, Cardinal*,
  90                                       XrmValue*, XrmValue*, XtPointer*);
  91 static Boolean _XawCvtBoolToString(Display*, XrmValue*, Cardinal*,
  92                                    XrmValue*, XrmValue*, XtPointer*);
  93 static Boolean _XawCvtCARD32ToString(Display*, XrmValue*, Cardinal*,
  94                                      XrmValue*, XrmValue*, XtPointer*);
  95 static Boolean _XawCvtCardinalToString(Display*, XrmValue*, Cardinal*,
  96                                        XrmValue*, XrmValue*, XtPointer*);
  97 static Boolean _XawCvtDimensionToString(Display*, XrmValue*, Cardinal*,
  98                                         XrmValue*, XrmValue*, XtPointer*);
  99 static Boolean _XawCvtDisplayListToString(Display*, XrmValue*, Cardinal*,
 100                                     XrmValue*, XrmValue*, XtPointer*);
 101 static Boolean _XawCvtFontStructToString(Display*, XrmValue*, Cardinal*,
 102                                          XrmValue*, XrmValue*, XtPointer*);
 103 static Boolean _XawCvtIntToString(Display*, XrmValue*, Cardinal*,
 104                                           XrmValue*, XrmValue*, XtPointer*);
 105 static Boolean _XawCvtPixelToString(Display*, XrmValue*, Cardinal*,
 106                                     XrmValue*, XrmValue*, XtPointer*);
 107 static Boolean _XawCvtPixmapToString(Display*, XrmValue*, Cardinal*,
 108                                      XrmValue*, XrmValue*, XtPointer*);
 109 static Boolean _XawCvtShortToString(Display*, XrmValue*, Cardinal*,
 110                                     XrmValue*, XrmValue*, XtPointer*);
 111 static Boolean _XawCvtPositionToString(Display*, XrmValue*, Cardinal*,
 112                                        XrmValue*, XrmValue*, XtPointer*);
 113 static Boolean _XawCvtStringToDisplayList(Display*, XrmValue*, Cardinal*,
 114                                           XrmValue*, XrmValue*, XtPointer*);
 115 static Boolean _XawCvtStringToPixmap(Display*, XrmValue*, Cardinal*,
 116                                      XrmValue*, XrmValue*, XtPointer*);
 117 static Boolean _XawCvtUnsignedCharToString(Display*, XrmValue*, Cardinal*,
 118                                      XrmValue*, XrmValue*, XtPointer*);
 119 static void TypeToStringNoArgsWarning(Display*, String);
 120
 121 /*
 122  * Initialization
 123  */
 124 static XtConvertArgRec PixelArgs[] = {
 125   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
 126    sizeof(Colormap)},
 127 };
 128
 129 static XtConvertArgRec DLArgs[] = {
 130   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.screen),
 131    sizeof(Screen *)},
 132   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.colormap),
 133    sizeof(Colormap)},
 134   {XtWidgetBaseOffset, (XtPointer)XtOffsetOf(WidgetRec, core.depth),
 135    sizeof(int)},
 136 };
 137 #endif /* OLDXAW */
 138
 139 static String XtCToolkitError = "ToolkitError";
 140 static String XtNconversionError = "conversionError";
 141
 142 #ifndef OLDXAW
 143 static String XtNwrongParameters = "wrongParameters";
 144
 145 /*
 146  * Implementation
 147  */
 148 void
 149 XawInitializeDefaultConverters(void)
 150 {
 151   static Boolean first_time = True;
 152
 153   if (first_time == False)
 154     return;
 155
 156   first_time = False;
 157
 158   /* Replace with more apropriate converters */
 159   XtSetTypeConverter(XtRCallback, XtRString, _XawCvtCARD32ToString,
 160                      NULL, 0, XtCacheNone, NULL);
 161   XtSetTypeConverter(XtRColormap, XtRString, _XawCvtCARD32ToString,
 162                      NULL, 0, XtCacheNone, NULL);
 163   XtSetTypeConverter(XtRFunction, XtRString, _XawCvtCARD32ToString,
 164                      NULL, 0, XtCacheNone, NULL);
 165   XtSetTypeConverter(XtRPointer, XtRString, _XawCvtCARD32ToString,
 166                      NULL, 0, XtCacheNone, NULL);
 167   XtSetTypeConverter(XtRScreen, XtRString, _XawCvtCARD32ToString,
 168                      NULL, 0, XtCacheNone, NULL);
 169   XtSetTypeConverter(XtRStringArray, XtRString, _XawCvtCARD32ToString,
 170                      NULL, 0, XtCacheNone, NULL);
 171   XtSetTypeConverter(XtRVisual, XtRString, _XawCvtCARD32ToString,
 172                      NULL, 0, XtCacheNone, NULL);
 173   XtSetTypeConverter(XtRWidget, XtRString, _XawCvtCARD32ToString,
 174                      NULL, 0, XtCacheNone, NULL);
 175   XtSetTypeConverter(XtRWidgetList, XtRString, _XawCvtCARD32ToString,
 176                      NULL, 0, XtCacheNone, NULL);
 177   XtSetTypeConverter(XtRWindow, XtRString, _XawCvtCARD32ToString,
 178                      NULL, 0, XtCacheNone, NULL);
 179
 180   XtSetTypeConverter(XtRAtom, XtRString, _XawCvtAtomToString,
 181                      NULL, 0, XtCacheNone, NULL);
 182   XtSetTypeConverter(XtRBool, XtRString,  _XawCvtBoolToString,
 183                      NULL, 0, XtCacheNone, NULL);
 184   XtSetTypeConverter(XtRBoolean, XtRString,  _XawCvtBooleanToString,
 185                      NULL, 0,  XtCacheNone, NULL);
 186   XtSetTypeConverter(XtRCardinal, XtRString, _XawCvtCardinalToString,
 187                      NULL, 0, XtCacheNone, NULL);
 188   XtSetTypeConverter(XtRDimension, XtRString, _XawCvtDimensionToString,
 189                      NULL, 0, XtCacheNone, NULL);
 190   XtSetTypeConverter(XawRDisplayList, XtRString, _XawCvtDisplayListToString,
 191                      NULL, 0, XtCacheNone, NULL);
 192   XtSetTypeConverter(XtRFontStruct, XtRString, _XawCvtFontStructToString,
 193                      NULL, 0, XtCacheNone, NULL);
 194   XtSetTypeConverter(XtRInt, XtRString, _XawCvtIntToString,
 195                      NULL, 0, XtCacheNone, NULL);
 196   XtSetTypeConverter(XtRPixel, XtRString, _XawCvtPixelToString,
 197                      &PixelArgs[0], XtNumber(PixelArgs), XtCacheNone, NULL);
 198   XtSetTypeConverter(XtRPixmap, XtRString, _XawCvtPixmapToString,
 199                      &DLArgs[0], XtNumber(DLArgs), XtCacheNone, NULL);
 200   XtSetTypeConverter(XtRPosition, XtRString, _XawCvtPositionToString,
 201                      NULL, 0, XtCacheNone,  NULL);
 202   XtSetTypeConverter(XtRShort, XtRString, _XawCvtShortToString,
 203                      NULL, 0, XtCacheNone,  NULL);
 204   XtSetTypeConverter(XtRString, XawRDisplayList, _XawCvtStringToDisplayList,
 205                      &DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
 206   XtSetTypeConverter(XtRString, XtRPixmap, _XawCvtStringToPixmap,
 207                      &DLArgs[0], XtNumber(DLArgs), XtCacheAll, NULL);
 208   XtSetTypeConverter(XtRUnsignedChar, XtRString, _XawCvtUnsignedCharToString,
 209                      NULL, 0, XtCacheNone, NULL);
 210 }
 211 #endif /* OLDXAW */
 212
 213 void
 214 XawTypeToStringWarning(Display *dpy, String type)
 215 {
 216   char fname[64];
 217   String params[1];
 218   Cardinal num_params;
 219
 220   XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
 221
 222   params[0] = type;
 223   num_params = 1;
 224   XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 225                   XtNconversionError, fname, XtCToolkitError,
 226                   "Cannot convert %s to String",
 227                   params, &num_params);
 228 }
 229
 230 #ifndef OLDXAW
 231 static void
 232 TypeToStringNoArgsWarning(Display *dpy, String type)
 233 {
 234   char fname[64];
 235   String params[1];
 236   Cardinal num_params;
 237
 238   XmuSnprintf(fname, sizeof(fname), "cvt%sToString", type);
 239
 240   params[0] = type;
 241   num_params = 1;
 242   XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 243                   XtNconversionError, fname,
 244                   XtCToolkitError,
 245                   "%s to String conversion needs no extra arguments",
 246                   params, &num_params);
 247 }
 248
 249 /*ARGSUSED*/
 250 static Boolean
 251 _XawCvtBooleanToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 252                        XrmValue *fromVal, XrmValue *toVal,
 253                        XtPointer *converter_data)
 254 {
 255   static char buffer[6];
 256   Cardinal size;
 257
 258   if (*num_args != 0)
 259     TypeToStringNoArgsWarning(dpy, XtRBoolean);
 260
 261   XmuSnprintf(buffer, sizeof(buffer), "%s",
 262               *(Boolean *)fromVal->addr ? XtEtrue : XtEfalse);
 263   size = strlen(buffer) + 1;
 264
 265   string_done(buffer);
 266 }
 267
 268 /*ARGSUSED*/
 269 static Boolean
 270 _XawCvtBoolToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 271                     XrmValue *fromVal, XrmValue *toVal,
 272                     XtPointer *converter_data)
 273 {
 274   static char buffer[6];
 275   Cardinal size;
 276
 277   if (*num_args != 0)
 278     TypeToStringNoArgsWarning(dpy, XtRBool);
 279
 280   XmuSnprintf(buffer, sizeof(buffer), "%s",
 281               *(Bool *)fromVal->addr ? XtEtrue : XtEfalse);
 282   size = strlen(buffer) + 1;
 283
 284   string_done(buffer);
 285 }
 286
 287 /*ARGSUSED*/
 288 static Boolean
 289 _XawCvtPositionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 290                         XrmValue *fromVal, XrmValue *toVal,
 291                         XtPointer *converter_data)
 292 {
 293   static char buffer[7];
 294   Cardinal size;
 295
 296   if (*num_args != 0)
 297     TypeToStringNoArgsWarning(dpy, XtRPosition);
 298
 299   XmuSnprintf(buffer, sizeof(buffer), "%d", *(Position *)fromVal->addr);
 300   size = strlen(buffer) + 1;
 301
 302   string_done(buffer);
 303 }
 304
 305 /*ARGSUSED*/
 306 static Boolean
 307 _XawCvtShortToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 308                      XrmValue *fromVal, XrmValue *toVal,
 309                      XtPointer *converter_data)
 310 {
 311   static char buffer[7];
 312   Cardinal size;
 313
 314   if (*num_args != 0)
 315     TypeToStringNoArgsWarning(dpy, XtRShort);
 316
 317   XmuSnprintf(buffer, sizeof(buffer), "%d", *(short *)fromVal->addr);
 318   size = strlen(buffer) + 1;
 319
 320   string_done(buffer);
 321 }
 322
 323 /*ARGSUSED*/
 324 static Boolean
 325 _XawCvtDimensionToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 326                          XrmValue *fromVal, XrmValue *toVal,
 327                          XtPointer *converter_data)
 328 {
 329   static char buffer[6];
 330   Cardinal size;
 331
 332   if (*num_args != 0)
 333     TypeToStringNoArgsWarning(dpy, XtRDimension);
 334
 335   XmuSnprintf(buffer, sizeof(buffer), "%u", *(Dimension *)fromVal->addr);
 336   size = strlen(buffer) + 1;
 337
 338   string_done(buffer);
 339 }
 340
 341 /*ARGSUSED*/
 342 static Boolean
 343 _XawCvtCARD32ToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 344                       XrmValue *fromVal, XrmValue *toVal,
 345                       XtPointer *converter_data)
 346 {
 347   static char buffer[11];
 348   Cardinal size;
 349
 350   if (*num_args != 0)
 351     TypeToStringNoArgsWarning(dpy, "CARD32");
 352
 353   XmuSnprintf(buffer, sizeof(buffer), "0x%08hx", *(int *)fromVal->addr);
 354   size = strlen(buffer) + 1;
 355
 356   string_done(buffer);
 357 }
 358
 359 /*ARGSUSED*/
 360 static Boolean
 361 _XawCvtIntToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 362                    XrmValue *fromVal, XrmValue *toVal,
 363                    XtPointer *converter_data)
 364 {
 365   static char buffer[12];
 366   Cardinal size;
 367
 368   if (*num_args != 0)
 369     TypeToStringNoArgsWarning(dpy, XtRInt);
 370
 371   XmuSnprintf(buffer, sizeof(buffer), "%d", *(int *)fromVal->addr);
 372   size = strlen(buffer) + 1;
 373
 374   string_done(buffer);
 375 }
 376
 377 /*ARGSUSED*/
 378 static Boolean
 379 _XawCvtCardinalToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 380                         XrmValue *fromVal, XrmValue *toVal,
 381                         XtPointer *converter_data)
 382 {
 383   static char buffer[11];
 384   Cardinal size;
 385
 386   if (*num_args != 0)
 387     TypeToStringNoArgsWarning(dpy, XtRCardinal);
 388
 389   XmuSnprintf(buffer, sizeof(buffer), "%u", *(Cardinal *)fromVal->addr);
 390   size = strlen(buffer) + 1;
 391
 392   string_done(buffer);
 393 }
 394
 395 /*ARGSUSED*/
 396 static Boolean
 397 _XawCvtAtomToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 398                     XrmValue *fromVal, XrmValue *toVal,
 399                     XtPointer *converter_data)
 400 {
 401   static char *buffer = NULL;
 402   static char *nullatom = "NULL";
 403   Cardinal size;
 404   Atom atom;
 405
 406   if (*num_args != 0)
 407     TypeToStringNoArgsWarning(dpy, XtRAtom);
 408
 409   if (buffer && buffer != nullatom)
 410     XFree(buffer);
 411
 412   atom = *(Atom *)fromVal[0].addr;
 413   if (atom == 0)
 414     buffer = nullatom;
 415   else if ((buffer = XGetAtomName(dpy, *(Atom *)fromVal[0].addr)) == NULL)
 416     {
 417       XawTypeToStringWarning(dpy, XtRAtom);
 418       toVal->addr = NULL;
 419       toVal->size = sizeof(String);
 420       return (False);
 421     }
 422
 423   size = strlen(buffer) + 1;
 424
 425   string_done(buffer);
 426 }
 427
 428 /*ARGSUSED*/
 429 static Boolean
 430 _XawCvtPixelToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 431                      XrmValue *fromVal, XrmValue *toVal,
 432                      XtPointer *converter_data)
 433 {
 434   static char buffer[19];
 435   Cardinal size;
 436   Colormap colormap;
 437   XColor color;
 438
 439   if (*num_args != 1)
 440     {
 441       XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 442                       XtNwrongParameters, "cvtPixelToString",
 443                       XtCToolkitError,
 444                       "Pixel to String conversion needs colormap argument",
 445                       NULL, NULL);
 446       return (False);
 447     }
 448
 449   colormap = *(Colormap *)args[0].addr;
 450   color.pixel = *(Pixel *)fromVal->addr;
 451
 452   /* Note:
 453    * If we know the visual type, we can calculate the xcolor
 454    * without asking Xlib.
 455    */
 456   XQueryColor(dpy, colormap, &color);
 457   XmuSnprintf(buffer, sizeof(buffer), "rgb:%04hx/%04hx/%04hx",
 458               color.red, color.green, color.blue);
 459   size = strlen(buffer) + 1;
 460
 461   string_done(buffer);
 462 }
 463
 464 /*ARGSUSED*/
 465 static Boolean
 466 _XawCvtFontStructToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 467                           XrmValue *fromVal, XrmValue *toVal,
 468                           XtPointer *converter_data)
 469 {
 470   static char buffer[128];
 471   Cardinal size;
 472   Atom atom;
 473   unsigned long value;
 474
 475   if (*num_args != 0)
 476     TypeToStringNoArgsWarning(dpy, XtRFontStruct);
 477
 478   if ((atom = XInternAtom(dpy, "FONT", True)) == None)
 479     return (False);
 480
 481   size = 0;
 482
 483   if (XGetFontProperty(*(XFontStruct **)fromVal->addr, atom, &value))
 484     {
 485       char *tmp = XGetAtomName(dpy, value);
 486
 487       if (tmp)
 488         {
 489           XmuSnprintf(buffer, sizeof(buffer), "%s", tmp);
 490           size = strlen(tmp);
 491           XFree(tmp);
 492         }
 493     }
 494
 495   if (size)
 496     {
 497       ++size;
 498     string_done(buffer);
 499     }
 500
 501   XawTypeToStringWarning(dpy, XtRFontStruct);
 502
 503   return (False);
 504 }
 505
 506 /*ARGSUSED*/
 507 static Boolean
 508 _XawCvtUnsignedCharToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 509                             XrmValue *fromVal, XrmValue *toVal,
 510                             XtPointer *converter_data)
 511 {
 512   static char buffer[4];
 513   Cardinal size;
 514
 515   if (*num_args != 0)
 516     TypeToStringNoArgsWarning(dpy, XtRUnsignedChar);
 517
 518   XmuSnprintf(buffer, sizeof(buffer), "%u",
 519               *(unsigned char *)fromVal->addr);
 520   size = strlen(buffer) + 1;
 521
 522   string_done(buffer);
 523 }
 524
 525 /*ARGSUSED*/
 526 static Boolean
 527 _XawCvtStringToDisplayList(Display *dpy, XrmValue *args, Cardinal *num_args,
 528                            XrmValue *fromVal, XrmValue *toVal,
 529                            XtPointer *converter_data)
 530 {
 531   XawDisplayList *dlist;
 532   Screen *screen;
 533   Colormap colormap;
 534   int depth;
 535   String commands;
 536
 537   if (*num_args != 3)
 538     {
 539       XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 540                       XtNwrongParameters, "cvtStringToDisplayList",
 541                       XtCToolkitError,
 542                       "String to DisplayList conversion needs screen, "
 543                       "colormap, and depth arguments",
 544                       NULL, NULL);
 545       return (False);
 546     }
 547
 548   screen     = *(Screen **)args[0].addr;
 549   colormap   = *(Colormap *)args[1].addr;
 550   depth      = *(int *)args[2].addr;
 551
 552   commands = (String)(fromVal[0].addr);
 553
 554   dlist = XawCreateDisplayList(commands, screen, colormap, depth);
 555
 556   if (!dlist)
 557     {
 558       XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
 559                                        XawRDisplayList);
 560       toVal->addr = NULL;
 561       toVal->size = sizeof(XawDisplayList*);
 562       return (False);
 563     }
 564
 565   done(XawDisplayList*, dlist);
 566 }
 567
 568 /*ARGSUSED*/
 569 static Boolean
 570 _XawCvtDisplayListToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 571                            XrmValue *fromVal, XrmValue *toVal,
 572                            XtPointer *converter_data)
 573 {
 574   String buffer;
 575   Cardinal size;
 576
 577   if (*num_args != 0)
 578     TypeToStringNoArgsWarning(dpy, XawRDisplayList);
 579
 580   buffer = XawDisplayListString(*(XawDisplayList **)(fromVal[0].addr));
 581   size = strlen(buffer) + 1;
 582
 583   string_done(buffer);
 584 }
 585
 586 /*ARGSUSED*/
 587 static Boolean
 588 _XawCvtStringToPixmap(Display *dpy, XrmValue *args, Cardinal *num_args,
 589                       XrmValue *fromVal, XrmValue *toVal,
 590                       XtPointer *converter_data)
 591 {
 592   XawPixmap *xaw_pixmap;
 593   Pixmap pixmap;
 594   Screen *screen;
 595   Colormap colormap;
 596   int depth;
 597   String name;
 598
 599   if (*num_args != 3)
 600     {
 601       XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 602                       XtNwrongParameters, "cvtStringToPixmap",
 603                       XtCToolkitError,
 604                       "String to Pixmap conversion needs screen, "
 605                       "colormap, and depth arguments",
 606                       NULL, NULL);
 607       return (False);
 608     }
 609
 610   screen     = *(Screen **)args[0].addr;
 611   colormap   = *(Colormap *)args[1].addr;
 612   depth      = *(int *)args[2].addr;
 613
 614   name = (String)(fromVal[0].addr);
 615
 616   if (XmuCompareISOLatin1(name, "None") == 0)
 617     pixmap = None;
 618   else if (XmuCompareISOLatin1(name, "ParentRelative") == 0)
 619     pixmap = ParentRelative;
 620   else if (XmuCompareISOLatin1(name, "XtUnspecifiedPixmap") == 0)
 621     pixmap = XtUnspecifiedPixmap;
 622   else
 623     {
 624       xaw_pixmap = XawLoadPixmap(name, screen, colormap, depth);
 625       if (!xaw_pixmap)
 626         {
 627           XtDisplayStringConversionWarning(dpy, (String)fromVal->addr,
 628                                            XtRPixmap);
 629           toVal->addr = (XtPointer)XtUnspecifiedPixmap;
 630           toVal->size = sizeof(Pixmap);
 631           return (False);
 632         }
 633       else
 634         pixmap = xaw_pixmap->pixmap;
 635     }
 636
 637   done(Pixmap, pixmap);
 638 }
 639
 640 /*ARGSUSED*/
 641 static Boolean
 642 _XawCvtPixmapToString(Display *dpy, XrmValue *args, Cardinal *num_args,
 643                       XrmValue *fromVal, XrmValue *toVal,
 644                       XtPointer *converter_data)
 645 {
 646   XawPixmap *xaw_pixmap;
 647   Pixmap pixmap;
 648   Screen *screen;
 649   Colormap colormap;
 650   int depth;
 651   String buffer = NULL;
 652   Cardinal size;
 653
 654   if (*num_args != 3)
 655     {
 656       XtAppWarningMsg(XtDisplayToApplicationContext(dpy),
 657                       XtNwrongParameters, "cvtPixmapToString",
 658                       XtCToolkitError,
 659                       "Pixmap to String conversion needs screen, "
 660                       "colormap, and depth arguments",
 661                       NULL, NULL);
 662       return (False);
 663     }
 664
 665   screen     = *(Screen **)args[0].addr;
 666   colormap   = *(Colormap *)args[1].addr;
 667   depth      = *(int *)args[2].addr;
 668
 669   pixmap = *(Pixmap *)(fromVal[0].addr);
 670
 671   switch (pixmap)
 672     {
 673     case None:
 674       buffer = "None";
 675       break;
 676     case ParentRelative:
 677       buffer = "ParentRelative";
 678       break;
 679     case XtUnspecifiedPixmap:
 680       buffer = "XtUnspecifiedPixmap";
 681       break;
 682     default:
 683       xaw_pixmap = XawPixmapFromXPixmap(pixmap, screen, colormap, depth);
 684       if (xaw_pixmap)
 685         buffer = xaw_pixmap->name;
 686       break;
 687     }
 688
 689   if (!buffer)
 690     /* Bad Pixmap or Pixmap was not loaded by XawLoadPixmap() */
 691     return (_XawCvtCARD32ToString(dpy, args, num_args, fromVal, toVal,
 692                                   converter_data));
 693
 694   size = strlen(buffer) + 1;
 695
 696   string_done(buffer);
 697 }
 698
 699 #endif /* OLDXAW */