cde/programs/dtksh/dtkcvt.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these libraries and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: dtkcvt.c /main/7 1998/04/20 12:54:59 mgreess $ */
  24
  25 /*      Copyright (c) 1991, 1992 UNIX System Laboratories, Inc. */
  26 /*      All Rights Reserved     */
  27
  28 /*      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF          */
  29 /*      UNIX System Laboratories, Inc.                          */
  30 /*      The copyright notice above does not evidence any        */
  31 /*      actual or intended publication of such source code.     */
  32
  33 /* X includes */
  34
  35 #include        "shell.h"
  36 #include <signal.h>
  37 #include <fcntl.h>
  38 #include <X11/X.h>
  39 #include <X11/Intrinsic.h>
  40 #include <X11/IntrinsicP.h>
  41 #include <X11/CoreP.h>
  42 #include <X11/StringDefs.h>
  43 #include <Xm/XmStrDefs.h>
  44 #include <setjmp.h>
  45 #include <string.h>
  46 #include <ctype.h>
  47 #include <Xm/Xm.h>
  48 #include <Xm/Protocols.h>
  49 #include <Xm/MwmUtil.h>
  50 #include <Dt/Service.h>
  51 #include <Dt/Wsm.h>
  52 #include <Dt/HourGlass.h>
  53 #include <Dt/Help.h>
  54 #include <Dt/EnvControlP.h>
  55 #include <Dt/Print.h>
  56 #include "hash.h"
  57 #include "stdio.h"
  58 #define NO_AST
  59 #include "dtksh.h"
  60 #undef NO_AST
  61 #include "xmksh.h"
  62 #include "XtCvtrs.h"
  63 #include "dtkcmds.h"
  64 #include "xmcvt.h"
  65 #include "widget.h"
  66 #include "extra.h"
  67 #include "xmwidgets.h"
  68 #include "msgs.h"
  69
  70 extern Hashtab_t * Wclasses;
  71
  72
  73
  74 static void CvtStringToMWMValue(
  75         MWMTable * table,
  76         Display *dpy,
  77         XrmValuePtr args,
  78         Cardinal *nargs,
  79         XrmValuePtr fval,
  80         XrmValuePtr toval,
  81         XtPointer data ) ;
  82 static void CvtMWMValueToString(
  83         MWMTable * table,
  84         Display *dpy,
  85         XrmValuePtr args,
  86         Cardinal *nargs,
  87         XrmValuePtr fval,
  88         XrmValuePtr toval,
  89         XtPointer data ) ;
  90
  91 /*
  92  * Converters for dtksh
  93  */
  94
  95 void
  96 DtkshCvtWindowToString(
  97         XrmValuePtr args,
  98         Cardinal *nargs,
  99         XrmValuePtr fval,
 100         XrmValuePtr toval )
 101 {
 102    static char result[16];
 103    Window window;
 104    char * errmsg;
 105
 106    if (fval->size != sizeof(Window))
 107    {
 108       errmsg = strdup(GETMESSAGE(6,1,
 109             "DtkshCvtWindowToString: The 'from' value is an invalid size"));
 110       XtWarning(errmsg);
 111       free(errmsg);
 112       toval->addr = NULL;
 113       toval->size = 0;
 114       return;
 115    }
 116    window = ((Window *)(fval->addr))[0];
 117    if (window == None)
 118       sprintf(result, "None");
 119    else
 120       sprintf(result, "0x%x", window);
 121    toval->addr = result;
 122    toval->size = strlen(result)+1;
 123 }
 124
 125 void
 126 DtkshCvtScreenToString(
 127         XrmValuePtr args,
 128         Cardinal *nargs,
 129         XrmValuePtr fval,
 130         XrmValuePtr toval )
 131 {
 132    static char result[16];
 133    Screen * screen;
 134    char * errmsg;
 135
 136    if (fval->size != sizeof(Screen *))
 137    {
 138       errmsg = strdup(GETMESSAGE(6,14,
 139             "DtkshCvtScreenToString: The 'from' value is an invalid size"));
 140       XtWarning(errmsg);
 141       free(errmsg);
 142       toval->addr = NULL;
 143       toval->size = 0;
 144       return;
 145    }
 146    screen = ((Screen **)(fval->addr))[0];
 147    sprintf(result, "0x%lx", (unsigned long)screen);
 148    toval->addr = result;
 149    toval->size = strlen(result)+1;
 150 }
 151
 152 void
 153 DtkshCvtStringToScreen(
 154         XrmValuePtr args,
 155         Cardinal *nargs,
 156         XrmValuePtr fval,
 157         XrmValuePtr toval )
 158 {
 159    static Screen * screen;
 160    char * errmsg;
 161    char * p;
 162
 163    if (fval->size <= 0 || fval->addr == NULL)
 164    {
 165       toval->addr = NULL;
 166       toval->size = 0;
 167       return;
 168    }
 169
 170    screen = (Screen *)strtoul(fval->addr, &p, 0);
 171    if (p != fval->addr)
 172    {
 173       toval->addr = (XtPointer)&screen;
 174       toval->size = sizeof(Screen *);
 175    }
 176    else
 177    {
 178       toval->addr = NULL;
 179       toval->size = 0;
 180       return;
 181    }
 182 }
 183
 184 void
 185 DtkshCvtStringToTopItemPosition(
 186         XrmValuePtr args,
 187         Cardinal *nargs,
 188         XrmValuePtr fval,
 189         XrmValuePtr toval )
 190 {
 191    static int topItemPosition;
 192    char * p;
 193
 194    if (fval->size <= 0 || fval->addr == NULL)
 195    {
 196       toval->addr = NULL;
 197       toval->size = 0;
 198       return;
 199    }
 200
 201    topItemPosition = (int)strtoul(fval->addr, &p, 0);
 202    if (p != fval->addr)
 203    {
 204       toval->addr = (XtPointer)&topItemPosition;
 205       toval->size = sizeof(int);
 206    }
 207    else
 208    {
 209       toval->addr = NULL;
 210       toval->size = 0;
 211       return;
 212    }
 213 }
 214
 215 void
 216 DtkshCvtHexIntToString(
 217         XrmValuePtr args,
 218         Cardinal *nargs,
 219         XrmValuePtr fval,
 220         XrmValuePtr toval )
 221 {
 222    static char result[16];
 223    char * errmsg;
 224
 225    if (fval->size != sizeof(long) && fval->size != sizeof(int) &&
 226        fval->size != sizeof(short) && fval->size != sizeof(char))
 227    {
 228       errmsg = strdup(GETMESSAGE(6,2,
 229            "DtkshCvtHexIntToString: The 'from' value is an invalid size"));
 230       XtWarning(errmsg);
 231       free(errmsg);
 232       toval->addr = NULL;
 233       toval->size = 0;
 234       return;
 235    }
 236    if (fval->size == sizeof(long))
 237       sprintf(result, "0x%lx", ((long *)(fval->addr))[0]);
 238    else if (fval->size == sizeof(int))
 239       sprintf(result, "0x%x", ((int *)(fval->addr))[0]);
 240    else if (fval->size == sizeof(short))
 241       sprintf(result, "0x%x", (int)(((short *)(fval->addr))[0]));
 242    else if (fval->size == sizeof(char))
 243       sprintf(result, "0x%x", (int)(((char *)(fval->addr))[0]));
 244    toval->addr = result;
 245    toval->size = strlen(result)+1;
 246 }
 247
 248 void
 249 DtkshCvtIntToString(
 250         XrmValuePtr args,
 251         Cardinal *nargs,
 252         XrmValuePtr fval,
 253         XrmValuePtr toval )
 254 {
 255    static char result[16];
 256    char * errmsg;
 257
 258    if (fval->size != sizeof(int) && fval->size != sizeof(short))
 259    {
 260       errmsg = strdup(GETMESSAGE(6,3,
 261              "DtkshCvtIntToString: The 'from' value is an invalid size"));
 262       XtWarning(errmsg);
 263       free(errmsg);
 264       toval->addr = NULL;
 265       toval->size = 0;
 266       return;
 267    }
 268    if (fval->size == sizeof(int))
 269       sprintf(result, "%d", ((int *)(fval->addr))[0]);
 270    else
 271       sprintf(result, "%d", (int)(((short *)(fval->addr))[0]));
 272    toval->addr = result;
 273    toval->size = strlen(result)+1;
 274 }
 275
 276 void
 277 DtkshCvtBooleanToString(
 278         XrmValuePtr args,
 279         Cardinal *nargs,
 280         XrmValuePtr fval,
 281         XrmValuePtr toval )
 282 {
 283    char * errmsg;
 284    Boolean booleanState;
 285
 286    if (fval->size != sizeof(int) && fval->size != sizeof(short) &&
 287        fval->size != sizeof(char))
 288    {
 289       errmsg = strdup(GETMESSAGE(6,4,
 290              "DtkshCvtBooleanToString: The 'from' value is an invalid size"));
 291       XtWarning(errmsg);
 292       free(errmsg);
 293       toval->addr = NULL;
 294       toval->size = 0;
 295       return;
 296    }
 297
 298    if (fval->size == sizeof(int))
 299       booleanState = (Boolean) (((int *)(fval->addr))[0]);
 300    else if (fval->size == sizeof(short))
 301       booleanState =  (Boolean) (((short *)(fval->addr))[0]);
 302    else if (fval->size == sizeof(char))
 303       booleanState = (Boolean) (((char *)(fval->addr))[0]);
 304
 305    if (booleanState)
 306       toval->addr = (caddr_t)("true");
 307    else
 308       toval->addr = (caddr_t)("false");
 309
 310    toval->size = strlen(toval->addr)+1;
 311 }
 312
 313 void
 314 DtkshCvtStringToPointer(
 315         XrmValuePtr args,
 316         Cardinal *nargs,
 317         XrmValuePtr fval,
 318         XrmValuePtr toval )
 319 {
 320    static XtPointer ret;
 321
 322    if (fval->size <= 0 || fval->addr == NULL)
 323    {
 324       toval->addr = NULL;
 325       toval->size = 0;
 326       return;
 327    }
 328    ret = (XtPointer)strdup(fval->addr);
 329    toval->addr = (XtPointer)&ret;
 330    toval->size = sizeof(XtPointer);
 331    return;
 332 }
 333
 334 void
 335 DtkshCvtStringToWidget(
 336         Display *dpy,
 337         XrmValuePtr args,
 338         Cardinal *nargs,
 339         XrmValuePtr fval,
 340         XrmValuePtr toval,
 341         XtPointer data )
 342 {
 343    char *wname;
 344    static Widget wid;
 345    wtab_t *w;
 346    char * errmsg;
 347
 348    if (fval->size <= 0)
 349    {
 350       errmsg = strdup(GETMESSAGE(6,5,
 351              "DtkshCvtStringToWidget: The 'from' value is an invalid size"));
 352       XtWarning(errmsg);
 353       free(errmsg);
 354       toval->addr = NULL;
 355       toval->size = 0;
 356       return;
 357    }
 358    wname = (char *)fval->addr;
 359    if (wname == NULL || wname[0] == '\0' || strcmp(wname, "NULL") == 0)
 360    {
 361       static Widget NullWidget = NULL;
 362
 363       toval->addr = (XtPointer)&NullWidget;
 364       toval->size = sizeof(Widget);
 365       return;
 366    }
 367    if ((w = str_to_wtab("DtkshCvtStringToWidget", wname)) != NULL)
 368    {
 369       wid= w->w;
 370       toval->addr = (XtPointer)&wid;
 371       toval->size = sizeof(Widget);
 372       return;
 373    }
 374    /*
 375     * If we couldn't find it in our table, try looking up the
 376     * name in standard resource format.
 377     */
 378    if ((wid = DtkshNameToWidget(wname)) != NULL)
 379    {
 380       toval->addr = (XtPointer)&wid;
 381       toval->size = sizeof(Widget);
 382       return;
 383    }
 384    /*
 385     * We failed completely
 386     */
 387    {
 388       char errbuf[1024];
 389
 390       errmsg = strdup(GETMESSAGE(6,6,
 391                "DtkshCvtStringToWidget: Unable to find a widget named '%s'"));
 392       sprintf(errbuf, errmsg, wname);
 393       XtWarning(errbuf);
 394       free(errmsg);
 395    }
 396    toval->addr = NULL;
 397    toval->size = 0;
 398 }
 399
 400 void
 401 DtkshCvtStringToCallback(
 402         Display *dpy,
 403         XrmValuePtr args,
 404         Cardinal *nargs,
 405         XrmValuePtr fval,
 406         XrmValuePtr toval,
 407         XtPointer data )
 408 {
 409    static XtCallbackList cb;
 410    dtksh_client_data_t *cdata;
 411    classtab_t *c = DTKSHConversionClass;
 412    wtab_t *w = DTKSHConversionWidget;
 413    char * errmsg;
 414
 415    if (fval->size <= 0)
 416    {
 417       errmsg = strdup(GETMESSAGE(6,7,
 418              "DtkshCvtStringToCallback: The 'from' value is an invalid size"));
 419       XtWarning(errmsg);
 420       free(errmsg);
 421       toval->addr = NULL;
 422       toval->size = 0;
 423       return;
 424    }
 425
 426    cb = (XtCallbackList)XtMalloc(sizeof(XtCallbackRec)*2);
 427    cb[0].callback = (XtCallbackProc)stdCB;
 428
 429    cdata = GetNewCBData((String)fval->addr, w, DTKSHConversionResource, None);
 430
 431    cb[0].closure = (caddr_t)cdata;
 432    cb[1].callback = NULL;
 433    toval->addr = (XtPointer)&cb;
 434    toval->size = sizeof(XtCallbackList);
 435 }
 436
 437 void
 438 DtkshCvtCallbackToString(
 439         Display *display,
 440         XrmValuePtr args,
 441         Cardinal *nargs,
 442         XrmValuePtr fval,
 443         XrmValuePtr toval,
 444         XtPointer converterData )
 445 {
 446    XtCallbackList cb;
 447    char buf[2048];
 448    char *p;
 449    char * errmsg;
 450    Boolean count = 0;
 451
 452    if (fval->size != sizeof(XtCallbackList))
 453    {
 454       errmsg = strdup(GETMESSAGE(6,8,
 455           "DtkshCvtCallbackToString: The 'from' value is an invalid size"));
 456       XtWarning(errmsg);
 457       free(errmsg);
 458       toval->addr = NULL;
 459       toval->size = 0;
 460       return;
 461    }
 462    if (fval->addr == NULL)
 463    {
 464       toval->addr = ": ;";
 465       toval->size = 1;
 466       return;
 467    }
 468    p = &buf[0];
 469    *p = '\0';
 470    for (cb = ((XtCallbackList *)(fval->addr))[0]; cb->callback != NULL; cb++)
 471    {
 472       if (cb->callback == (XtCallbackProc)stdCB)
 473       {
 474          dtksh_client_data_t *cdata = (dtksh_client_data_t *)cb->closure;
 475
 476          if (p + strlen((String)cdata->ksh_cmd) + 1 - buf > sizeof(buf))
 477          {
 478             errmsg = strdup(GetSharedMsg(DT_CONV_BUF_OVFL));
 479             XtWarning(errmsg);
 480             free(errmsg);
 481             break;
 482          }
 483          if (count > 0)
 484             p += sprintf(p, "|%s", (String)cdata->ksh_cmd);
 485          else
 486             p += sprintf(p, "%s", (String)cdata->ksh_cmd);
 487          count++;
 488       }
 489    }
 490    toval->addr = (XtPointer)strdup(buf);
 491    toval->size = strlen(buf) + 1;
 492 }
 493
 494
 495 void
 496 DtkshCvtWidgetToString(
 497         Display *dpy,
 498         XrmValuePtr args,
 499         Cardinal *nargs,
 500         XrmValuePtr fval,
 501         XrmValuePtr toval,
 502         XtPointer data )
 503 {
 504    char *wname;
 505    Widget widget;
 506    wtab_t *w;
 507    char * errmsg;
 508
 509    if (fval->size != sizeof(Widget) || fval->addr == NULL)
 510    {
 511       errmsg = strdup(GETMESSAGE(6,9,
 512            "DtkshCvtWidgetToString: The 'from' value is an invalid size"));
 513       XtWarning(errmsg);
 514       free(errmsg);
 515       toval->addr = NULL;
 516       toval->size = 0;
 517       return;
 518    }
 519    widget = ((Widget *)fval->addr)[0];
 520    if (widget == NULL)
 521    {
 522       toval->addr = (XtPointer)("NULL");
 523       toval->size = 5;
 524       return;
 525    }
 526    if ((w = widget_to_wtab(widget)) == NULL)
 527    {
 528       errmsg = strdup(GETMESSAGE(6,10,
 529           "DtkshCvtWidgetToString: Unable to find a name for the widget"));
 530       XtWarning(errmsg);
 531       free(errmsg);
 532       toval->addr = NULL;
 533       toval->size = 0;
 534       return;
 535    }
 536    toval->addr = (XtPointer)w->widid;
 537    toval->size = strlen(w->widid) + 1;
 538 }
 539
 540
 541 /***********************************************/
 542
 543 static EventMaskTable eventMasks[] = {
 544    {"XtAllEvents", XtAllEvents},
 545    {"NoEventMask", NoEventMask},
 546    {"KeyPressMask", KeyPressMask},
 547    {"KeyReleaseMask", KeyReleaseMask},
 548    {"ButtonPressMask", ButtonPressMask},
 549    {"ButtonReleaseMask", ButtonReleaseMask},
 550    {"EnterWindowMask", EnterWindowMask},
 551    {"LeaveWindowMask", LeaveWindowMask},
 552    {"PointerMotionMask", PointerMotionMask},
 553    {"PointerMotionHintMask", PointerMotionHintMask},
 554    {"Button1MotionMask", Button1MotionMask},
 555    {"Button2MotionMask", Button2MotionMask},
 556    {"Button3MotionMask", Button3MotionMask},
 557    {"Button4MotionMask", Button4MotionMask},
 558    {"Button5MotionMask", Button5MotionMask},
 559    {"ButtonMotionMask", ButtonMotionMask},
 560    {"KeymapStateMask", KeymapStateMask},
 561    {"ExposureMask", ExposureMask},
 562    {"VisibilityChangeMask", VisibilityChangeMask},
 563    {"StructureNotifyMask", StructureNotifyMask},
 564    {"ResizeRedirectMask", ResizeRedirectMask},
 565    {"SubstructureNotifyMask", SubstructureNotifyMask},
 566    {"SubstructureRedirectMask", SubstructureRedirectMask},
 567    {"FocusChangeMask", FocusChangeMask},
 568    {"PropertyChangeMask", PropertyChangeMask},
 569    {"ColormapChangeMask", ColormapChangeMask},
 570    {"OwnerGrabButtonMask", OwnerGrabButtonMask},
 571    {NULL, NoEventMask},
 572 };
 573
 574
 575 void
 576 DtkshCvtStringToEventMask(
 577         Display *dpy,
 578         XrmValuePtr args,
 579         Cardinal *nargs,
 580         XrmValuePtr fval,
 581         XrmValuePtr toval,
 582         XtPointer data )
 583 {
 584    static EventMask eventMask = 0;
 585    int i;
 586    char * ptr;
 587    char * eventMaskString;
 588
 589    toval->addr = (XtPointer)&eventMask;
 590    toval->size = sizeof(EventMask);
 591
 592    if (fval->size <= 0 || fval->addr == NULL)
 593       return;
 594
 595    ptr = eventMaskString = strdup(fval->addr);
 596
 597    /*  Skip any leading whitespace.  */
 598    while (isspace(*ptr) && (*ptr != '\0'))
 599       ptr++;
 600
 601    eventMask = 0;
 602    ptr = strtok(ptr, "|");
 603    while (ptr)
 604    {
 605       for (i = 0; eventMasks[i].name; i++)
 606       {
 607          if (DtCompareISOLatin1(ptr, eventMasks[i].name))
 608          {
 609             eventMask |= eventMasks[i].mask;
 610             break;
 611          }
 612       }
 613       ptr = strtok(NULL, "|");
 614    }
 615
 616    XtFree(eventMaskString);
 617 }
 618
 619
 620 void
 621 DtkshCvtStringToListItems(
 622         Display *dpy,
 623         XrmValuePtr args,
 624         Cardinal *nargs,
 625         XrmValuePtr fval,
 626         XrmValuePtr toval,
 627         XtPointer data )
 628 {
 629    XtConvert(Toplevel, XtRString, fval, XmRXmStringTable, toval);
 630 }
 631
 632
 633 void
 634 DtkshCvtWidgetClassToString(
 635         Display *dpy,
 636         XrmValuePtr args,
 637         Cardinal *nargs,
 638         XrmValuePtr fval,
 639         XrmValuePtr toval,
 640         XtPointer data )
 641 {
 642    static char result[16];
 643    char * errmsg;
 644    WidgetClass wc;
 645    int i;
 646
 647    if (fval->size != sizeof(WidgetClass))
 648    {
 649       errmsg = strdup(GETMESSAGE(6,11,
 650            "DtkshCvtWidgetClassToString: The 'from' value is an invalid size"));
 651       XtWarning(errmsg);
 652       free(errmsg);
 653       toval->addr = NULL;
 654       toval->size = 0;
 655       return;
 656    }
 657
 658    if ((wc = ((WidgetClass *)(fval->addr))[0]) == NULL)
 659    {
 660       toval->addr = "";
 661       toval->size = 1;
 662       return;
 663    }
 664
 665    for (i = 0; C[i].cname != NULL; i++)
 666    {
 667       if (C[i].class == wc)
 668       {
 669          toval->addr = C[i].cname;
 670          toval->size = strlen(C[i].cname)+1;
 671          return;
 672       }
 673    }
 674
 675    /* No match found */
 676    errmsg = strdup(GETMESSAGE(6,12,
 677           "DtkshCvtWidgetClassToString: Unknown widget class"));
 678    XtWarning(errmsg);
 679    free(errmsg);
 680    toval->addr = NULL;
 681    toval->size = 0;
 682    return;
 683 }
 684
 685 void
 686 DtkshCvtStringToWidgetClass(
 687         Display *dpy,
 688         XrmValuePtr args,
 689         Cardinal *nargs,
 690         XrmValuePtr fval,
 691         XrmValuePtr toval,
 692         XtPointer data )
 693 {
 694    static char result[16];
 695    char * errmsg;
 696    static WidgetClass wc;
 697    int i;
 698    char * wcName;
 699    char * hashInfo;
 700    classtab_t * classtab;
 701
 702    if (fval->size <= 0 || fval->addr == NULL)
 703    {
 704       toval->addr = NULL;
 705       toval->size = 0;
 706       return;
 707    }
 708
 709    wcName = (char *)(fval->addr);
 710    if ((hashInfo = hashget(Wclasses, wcName)) != NULL)
 711    {
 712       classtab = (classtab_t *)hashInfo;
 713       wc = classtab->class;
 714       toval->addr = (caddr_t)&wc;
 715       toval->size = sizeof(WidgetClass);
 716       return;
 717    }
 718
 719    /* No match found */
 720    errmsg = strdup(GETMESSAGE(6,13,
 721           "DtkshCvtStringToWidgetClass: Unknown widget class name"));
 722    XtWarning(errmsg);
 723    free(errmsg);
 724    toval->addr = NULL;
 725    toval->size = 0;
 726    return;
 727 }
 728
 729
 730 static MWMTable mwmDecorations[] = {
 731    {"MWM_DECOR_ALL", MWM_DECOR_ALL},
 732    {"MWM_DECOR_BORDER", MWM_DECOR_BORDER},
 733    {"MWM_DECOR_RESIZEH", MWM_DECOR_RESIZEH},
 734    {"MWM_DECOR_TITLE", MWM_DECOR_TITLE},
 735    {"MWM_DECOR_MENU", MWM_DECOR_MENU},
 736    {"MWM_DECOR_MINIMIZE", MWM_DECOR_MINIMIZE},
 737    {"MWM_DECOR_MAXIMIZE", MWM_DECOR_MAXIMIZE},
 738    {NULL, 0},
 739 };
 740
 741 static MWMTable mwmFunctions[] = {
 742    {"MWM_FUNC_ALL", MWM_FUNC_ALL},
 743    {"MWM_FUNC_RESIZE", MWM_FUNC_RESIZE},
 744    {"MWM_FUNC_MOVE", MWM_FUNC_MOVE},
 745    {"MWM_FUNC_MINIMIZE", MWM_FUNC_MINIMIZE},
 746    {"MWM_FUNC_MAXIMIZE", MWM_FUNC_MAXIMIZE},
 747    {"MWM_FUNC_CLOSE", MWM_FUNC_CLOSE},
 748    {NULL, 0},
 749 };
 750
 751 static void
 752 CvtStringToMWMValue(
 753         MWMTable * table,
 754         Display *dpy,
 755         XrmValuePtr args,
 756         Cardinal *nargs,
 757         XrmValuePtr fval,
 758         XrmValuePtr toval,
 759         XtPointer data )
 760 {
 761    static long value;
 762    int i;
 763    char * ptr;
 764    char * valueString;
 765    char * p;
 766    int intVal;
 767
 768    value = 0;
 769    toval->addr = (XtPointer)&value;
 770    toval->size = sizeof(int);
 771
 772    if (fval->size <= 0 || fval->addr == NULL)
 773       return;
 774
 775    ptr = valueString = strdup(fval->addr);
 776
 777    /*  Skip any leading whitespace.  */
 778    while (isspace(*ptr) && (*ptr != '\0'))
 779       ptr++;
 780
 781    /* Integer values, especially -1, are also supported */
 782    intVal = strtol(ptr, &p, 0);
 783    if (p != ptr)
 784    {
 785       value = intVal;
 786       XtFree(valueString);
 787       return;
 788    }
 789
 790    ptr = strtok(ptr, "|");
 791    while (ptr)
 792    {
 793       for (i = 0; table[i].name; i++)
 794       {
 795          if (DtCompareISOLatin1(ptr, table[i].name))
 796          {
 797             value |= table[i].value;
 798             break;
 799          }
 800       }
 801       ptr = strtok(NULL, "|");
 802    }
 803
 804    XtFree(valueString);
 805 }
 806
 807
 808 static void
 809 CvtMWMValueToString(
 810         MWMTable * table,
 811         Display *dpy,
 812         XrmValuePtr args,
 813         Cardinal *nargs,
 814         XrmValuePtr fval,
 815         XrmValuePtr toval,
 816         XtPointer data )
 817 {
 818    static char *string = NULL;
 819    int value;
 820    int i = 0;
 821    Boolean firstOne = True;
 822
 823    value = ((int *)(fval->addr))[0];
 824
 825    if (value == -1)
 826    {
 827       string = XtRealloc(string, 5);
 828       strcpy(string, "-1");
 829    }
 830    else
 831    {
 832       string = XtRealloc(string, 1);
 833       string[0] = '\0';
 834
 835       while (table[i].name)
 836       {
 837          if (value & table[i].value)
 838          {
 839             if (!firstOne)
 840             {
 841                string = XtRealloc(string,
 842                      strlen(string) + strlen(table[i].name) + 2);
 843                strcat(string, "|");
 844                strcat(string, table[i].name);
 845             }
 846             else
 847             {
 848                firstOne = False;
 849                string = XtRealloc(string,
 850                      strlen(string) + strlen(table[i].name) + 1);
 851                strcat(string, table[i].name);
 852             }
 853          }
 854          i++;
 855       }
 856    }
 857
 858    toval->addr = (caddr_t)string;
 859    toval->size = strlen(string) + 1;
 860 }
 861
 862 void
 863 DtkshCvtStringToMWMDecoration(
 864         Display *dpy,
 865         XrmValuePtr args,
 866         Cardinal *nargs,
 867         XrmValuePtr fval,
 868         XrmValuePtr toval,
 869         XtPointer data )
 870 {
 871    CvtStringToMWMValue(mwmDecorations, dpy, args, nargs, fval, toval, data);
 872 }
 873
 874
 875 void
 876 DtkshCvtMWMDecorationToString(
 877         Display *dpy,
 878         XrmValuePtr args,
 879         Cardinal *nargs,
 880         XrmValuePtr fval,
 881         XrmValuePtr toval,
 882         XtPointer data )
 883 {
 884    CvtMWMValueToString(mwmDecorations, dpy, args, nargs, fval, toval, data);
 885 }
 886
 887 void
 888 DtkshCvtStringToMWMFunctions(
 889         Display *dpy,
 890         XrmValuePtr args,
 891         Cardinal *nargs,
 892         XrmValuePtr fval,
 893         XrmValuePtr toval,
 894         XtPointer data )
 895 {
 896    CvtStringToMWMValue(mwmFunctions, dpy, args, nargs, fval, toval, data);
 897 }
 898
 899
 900 void
 901 DtkshCvtMWMFunctionsToString(
 902         Display *dpy,
 903         XrmValuePtr args,
 904         Cardinal *nargs,
 905         XrmValuePtr fval,
 906         XrmValuePtr toval,
 907         XtPointer data )
 908 {
 909    CvtMWMValueToString(mwmFunctions, dpy, args, nargs, fval, toval, data);
 910 }
 911
 912 void
 913 DtkshCvtStringToPanedWinPosIndex(
 914         Display *dpy,
 915         XrmValuePtr args,
 916         Cardinal *nargs,
 917         XrmValuePtr fval,
 918         XrmValuePtr toval,
 919         XtPointer data )
 920 {
 921    static short value;
 922    char * pos;
 923    char * p;
 924
 925    if (fval->size <= 0 || fval->addr == NULL)
 926    {
 927       toval->addr = NULL;
 928       toval->size = 0;
 929       return;
 930    }
 931
 932    pos = (char *)fval->addr;
 933    if (DtCompareISOLatin1(pos, "LAST_POSITION"))
 934       value = XmLAST_POSITION;
 935    else
 936       value = strtol(pos, &p, 0);
 937
 938    toval->addr = (XtPointer)&value;
 939    toval->size = sizeof(short);
 940 }
 941
 942 void
 943 DtkshCvtPanedWinPosIndexToString(
 944         Display *dpy,
 945         XrmValuePtr args,
 946         Cardinal *nargs,
 947         XrmValuePtr fval,
 948         XrmValuePtr toval,
 949         XtPointer data )
 950 {
 951    static char result[50];
 952    short value;
 953
 954    if (fval->size != sizeof(short))
 955    {
 956       toval->addr = NULL;
 957       toval->size = 0;
 958       return;
 959    }
 960    value = ((short *)(fval->addr))[0];
 961    if (value == XmLAST_POSITION)
 962       sprintf(result, "LAST_POSITION");
 963    else
 964       sprintf(result, "%d", value);
 965    toval->addr = result;
 966    toval->size = strlen(result)+1;
 967 }
 968
 969
 970 void
 971 DtkshCvtStringToPrintSetupProc(
 972         Display *dpy,
 973         XrmValuePtr args,
 974         Cardinal *nargs,
 975         XrmValuePtr fval,
 976         XrmValuePtr toval,
 977         XtPointer data)
 978 {
 979         static void (*proc)();
 980         extern wtab_t *DTKSHConversionWidget;
 981         wtab_t *w = DTKSHConversionWidget;
 982         extern char *DTKSHConversionResource;
 983         ProcInfo_t *pinfo;
 984
 985         if (w != NULL) {
 986                 if (w->info == NULL) {
 987                         w->info = (XtPointer)XtMalloc(sizeof(ProcInfo_t));
 988                         memset(w->info, '\0', sizeof(ProcInfo_t));
 989                 }
 990                 pinfo = (ProcInfo_t *)w->info;
 991                 if (strcmp(DTKSHConversionResource, CONSTCHAR "printerInfoProc") == 0) {
 992                         if (pinfo->printerInfoProcCommand != NULL)
 993                                 XtFree(pinfo->printerInfoProcCommand);
 994                         pinfo->printerInfoProcCommand = strdup((String)fval->addr);
 995                         proc = stdPrinterInfoProc;
 996                 } else if (strcmp(DTKSHConversionResource, CONSTCHAR "selectFileProc") == 0) {
 997                         if (pinfo->selectFileProcCommand != NULL)
 998                                 XtFree(pinfo->selectFileProcCommand);
 999                         pinfo->selectFileProcCommand = strdup((String)fval->addr);
1000                         proc = stdSelectFileProc;
1001                 }
1002                 else if (strcmp(DTKSHConversionResource, CONSTCHAR "selectPrinterProc") == 0) {
1003                         if (pinfo->selectPrinterProcCommand != NULL)
1004                                 XtFree(pinfo->selectPrinterProcCommand);
1005                         pinfo->selectPrinterProcCommand = strdup((String)fval->addr);
1006                         proc = stdSelectPrinterProc;
1007                 }
1008                 else if (strcmp(DTKSHConversionResource, CONSTCHAR "setupProc") == 0) {
1009                         if (pinfo->setupProcCommand != NULL)
1010                                 XtFree(pinfo->setupProcCommand);
1011                         pinfo->setupProcCommand = strdup((String)fval->addr);
1012                         proc = stdSetupProc;
1013                 }
1014                 else if (strcmp(DTKSHConversionResource, CONSTCHAR "verifyPrinterProc") == 0) {
1015                         if (pinfo->verifyPrinterProcCommand != NULL)
1016                                 XtFree(pinfo->verifyPrinterProcCommand);
1017                         pinfo->verifyPrinterProcCommand = strdup((String)fval->addr);
1018                         proc = stdVerifyPrinterProc;
1019                 }
1020                 else {
1021                         XtWarningMsg(CONSTCHAR "CvtStringToPrintSetupProc", CONSTCHAR "unsupported DtPrintSetupBox resource.", CONSTCHAR "XtToolkitError", "This resource is not currently supported by dtksh.", NULL, 0);
1022                 }
1023         } else {
1024                 XtWarningMsg(CONSTCHAR "CvtStringToPrintSetupProc", CONSTCHAR "widget must exist.", CONSTCHAR "XtToolkitError", "This resource cannot be set at creation time by dtksh, use XtSetValues after creation instead.", NULL, 0);
1025                 toval->size = 0;
1026                 toval->addr = NULL;
1027                 return;
1028         }
1029
1030         toval->size = sizeof(DtPrintSetupProc);
1031         toval->addr = (XtPointer)&proc;
1032         return;
1033 }