cde/programs/dtksh/xmcmds.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 librararies 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: xmcmds.c /main/12 1997/07/14 18:15:21 samborn $ */
  24 /*      Copyright (c) 1991, 1992 UNIX System Laboratories, Inc. */
  25 /*      All Rights Reserved     */
  26
  27 /*      THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF          */
  28 /*      UNIX System Laboratories, Inc.                          */
  29 /*      The copyright notice above does not evidence any        */
  30 /*      actual or intended publication of such source code.     */
  31
  32 #include        "shell.h"
  33 #include <signal.h>
  34 #include <malloc.h>
  35 #include <fcntl.h>
  36 #include <nl_types.h>
  37 #include <X11/X.h>
  38 #include <X11/Intrinsic.h>
  39 #include <X11/IntrinsicP.h>
  40 #include <X11/CoreP.h>
  41 #include <X11/StringDefs.h>
  42 #include <Xm/XmStrDefs.h>
  43 #include <setjmp.h>
  44 #include <string.h>
  45 #include <ctype.h>
  46 #include <Xm/Xm.h>
  47 #include <Xm/Protocols.h>
  48 #include "hash.h"
  49 #include "stdio.h"
  50 #define NO_AST
  51 #include "dtksh.h"
  52 #undef NO_AST
  53 #include "xmksh.h"
  54 #include "dtkcmds.h"
  55 #include "XtCvtrs.h"
  56 #include "widget.h"
  57 #include "dtkcvt.h"
  58 #include "xmcmds.h"
  59 #include "xmcvt.h"
  60 #include "msgs.h"
  61 #include "extra.h"
  62 #include "xmwidgets.h"
  63
  64 #include <Xm/Protocols.h>
  65 #include <Xm/AtomMgr.h>
  66 #include <Xm/ArrowB.h>
  67 #include <Xm/ArrowBG.h>
  68 #include <Xm/BulletinB.h>
  69 #include <Xm/CascadeB.h>
  70 #include <Xm/CascadeBG.h>
  71 #include <Xm/ComboBox.h>
  72 #include <Xm/Command.h>
  73 #include <Xm/CommandP.h>
  74 #include <Xm/DialogS.h>
  75 #include <Xm/DrawingA.h>
  76 #include <Xm/DrawnB.h>
  77 #include <Xm/FileSB.h>
  78 #include <Xm/FileSBP.h>
  79 #include <Xm/Form.h>
  80 #include <Xm/Frame.h>
  81 #include <Xm/Label.h>
  82 #include <Xm/LabelG.h>
  83 #include <Xm/List.h>
  84 #include <Xm/ListP.h>
  85 #include <Xm/MainW.h>
  86 #include <Xm/MenuShell.h>
  87 #include <Xm/MessageB.h>
  88 #include <Xm/PanedW.h>
  89 #include <Xm/PushB.h>
  90 #include <Xm/PushBG.h>
  91 #include <Xm/RowColumn.h>
  92 #include <Xm/Scale.h>
  93 #include <Xm/ScrollBar.h>
  94 #include <Xm/ScrolledW.h>
  95 #include <Xm/SelectioB.h>
  96 #include <Xm/SelectioBP.h>
  97 #include <Xm/Separator.h>
  98 #include <Xm/SeparatoG.h>
  99 #include <Xm/Text.h>
 100 #include <Xm/TextF.h>
 101 #include <Xm/ToggleB.h>
 102 #include <Xm/ToggleBG.h>
 103
 104 #include <Dt/HelpDialog.h>
 105 #include <Dt/HelpQuickD.h>
 106 #include <Dt/Print.h>
 107 #include <Dt/PrintDlgMgrP.h>
 108
 109
 110
 111 static int _xmcreatefunc(
 112                         Widget (*func)(),
 113                         char *wclass,
 114                         int argc,
 115                         char *argv[]) ;
 116 static wtab_t * verifyListWidget(
 117                         char *cmd,
 118                         char *widget) ;
 119 static int List_ItemAndPos(
 120                         void (*func)(),
 121                         int argc,
 122                         char *argv[]) ;
 123 static int List_ItemListAndPos(
 124                         void (*func)(),
 125                         int argc,
 126                         char *argv[]) ;
 127 static int List_WidgetOnly(
 128                         void (*func)(),
 129                         int argc,
 130                         char *argv[]) ;
 131 static int GetSelectedPosList(
 132                         Boolean (*func)(),
 133                         int paramCount,
 134                         char * errmsg,
 135                         int argc,
 136                         char *argv[] ) ;
 137 static int List_ItemOnly(
 138                         void (*func)(),
 139                         int argc,
 140                         char *argv[]) ;
 141 static int List_PositionOnly(
 142                         void (*func)(),
 143                         int argc,
 144                         char *argv[]) ;
 145 static int ListSelectItem(
 146                         Boolean usePosition,
 147                         int argc,
 148                         char *argv[]) ;
 149 static int GetMainWindowSeparator(
 150                         int childType,
 151                         int argc,
 152                         char *argv[]) ;
 153 static int CatchAndIgnoreXError(
 154                         Display *display,
 155                         XEvent *event) ;
 156 static int AddOrDeleteWMProtocols(
 157                         int argc,
 158                         char *argv[]) ;
 159 static int GetToggleState(
 160                         int argc,
 161                         char *argv[]) ;
 162 static int SetToggleState(
 163                         int argc,
 164                         char *argv[]) ;
 165 static wtab_t * verifyTextWidget(
 166                         char *cmd,
 167                         char *widget) ;
 168 static int Text_Widget(
 169                         Boolean (*func)(),
 170                         Boolean returnBoolean,
 171                         int argc,
 172                         char *argv[]) ;
 173 static int Text_VarAndWidget(
 174                         int (*func)(),
 175                         Boolean varIsString,
 176                         int argc,
 177                         char *argv[]) ;
 178 static int Text_WidgetAndBoolean(
 179                         void (*func)(),
 180                         int argc,
 181                         char *argv[]) ;
 182 static int Text_WidgetAndOneParam(
 183                         Boolean (*func)(),
 184                         Boolean returnBoolean,
 185                         Boolean paramIsString,
 186                         char *usageMsg,
 187                         int argc,
 188                         char *argv[]) ;
 189 static void GetSelBoxItemCount(
 190                         Widget w,
 191                         Cardinal * size,
 192                         XrmValue * valueReturn);
 193 static void GetFileSelBoxFileItemCount(
 194                         Widget w,
 195                         Cardinal * size,
 196                         XrmValue * valueReturn);
 197 static void GetFileSelBoxDirItemCount(
 198                         Widget w,
 199                         Cardinal * size,
 200                         XrmValue * valueReturn);
 201 static wtab_t * ConvertWidgetToWtab(
 202                         char * arg0,
 203                         Widget w);
 204 static int GetSubWidget(
 205                         char * errmsg,
 206                         Widget (*func)(),
 207                         int argc,
 208                         char *argv[] );
 209
 210 static int _CreatePDMJobSetup(
 211                         Widget (*func)(),
 212                         int argc,
 213                         char *argv[]) ;
 214
 215
 216 #define MAXARGS 4096
 217 #define SLISTITEMSIZE   16
 218
 219 #define MWSep1 1
 220 #define MWSep2 2
 221 #define MWSep3 3
 222
 223 static char str_APPNAME[] = "DTKSH_APPNAME";
 224 static char str_TOPLEVEL[] = "DTKSH_TOPLEVEL";
 225
 226 static XtConvertArgRec listItemConvertArgs[] = {
 227     { XtWidgetBaseOffset,
 228         (XtPointer)XtOffset(XmListWidget, list.itemCount),
 229         sizeof (int)
 230     }
 231 };
 232
 233 static XtConvertArgRec selectedListItemConvertArgs[] = {
 234     { XtWidgetBaseOffset,
 235         (XtPointer) XtOffset(XmListWidget, list.selectedItemCount),
 236         sizeof (int)
 237     }
 238 };
 239
 240 static XtConvertArgRec selBoxItemConvertArgs[] = {
 241     { XtProcedureArg,
 242        (XtPointer)GetSelBoxItemCount,
 243        sizeof (int)
 244     }
 245 };
 246
 247 static XtConvertArgRec fileSelBoxFileConvertArgs[] = {
 248     { XtProcedureArg,
 249        (XtPointer)GetFileSelBoxFileItemCount,
 250        sizeof (int)
 251     }
 252 };
 253
 254 static XtConvertArgRec fileSelBoxDirConvertArgs[] = {
 255     { XtProcedureArg,
 256        (XtPointer)GetFileSelBoxDirItemCount,
 257        sizeof (int)
 258     }
 259 };
 260
 261
 262 static wtab_t *
 263 ConvertWidgetToWtab(
 264         char * arg0,
 265         Widget w)
 266 {
 267    wtab_t * wtab;
 268    classtab_t *ctab;
 269
 270    wtab = (wtab_t *)widget_to_wtab(w);
 271    /*
 272     * If the widget class has no resources registered, then this is
 273     * the first known instance of this widget class, so we need to
 274     * force the resource list to be loaded.  This can frequently
 275     * occur if a Motif convenience function is used, which creates
 276     * a 'hidden' parent.
 277     */
 278    ctab = wtab->wclass;
 279    if (ctab->res == NULL)
 280       (void)str_to_class(arg0, ctab->cname);
 281
 282    return(wtab);
 283 }
 284
 285
 286 static void
 287 GetSelBoxItemCount(
 288         Widget w,
 289         Cardinal * size,
 290         XrmValue * valueReturn )
 291 {
 292    XmSelectionBoxWidget sel = (XmSelectionBoxWidget) w;
 293    static int data;
 294    Arg args[1] ;
 295
 296     if( SB_List( sel) )
 297     {
 298         XtSetArg( args[0], XmNitemCount, &data) ;
 299         XtGetValues( SB_List( sel), args, 1) ;
 300     }
 301     else
 302     {
 303         data = (XtArgVal) 0 ;
 304     }
 305
 306    valueReturn->addr = (XtPointer) &data ;
 307    valueReturn->size = sizeof(int *);
 308 }
 309
 310 static void
 311 GetFileSelBoxDirItemCount(
 312         Widget w,
 313         Cardinal * size,
 314         XrmValue * valueReturn )
 315 {
 316    static int data;
 317    Widget dirList;
 318    Arg args[5];
 319
 320    dirList = XmFileSelectionBoxGetChild(w, XmDIALOG_DIR_LIST);
 321    XtSetArg(args[0], XmNitemCount, &data);
 322    XtGetValues(dirList, args, 1);
 323    valueReturn->addr = (XtPointer) &data ;
 324    valueReturn->size = sizeof(int *);
 325 }
 326
 327 static void
 328 GetFileSelBoxFileItemCount(
 329         Widget w,
 330         Cardinal * size,
 331         XrmValue * valueReturn )
 332 {
 333    static int data;
 334    Widget dirList;
 335    Arg args[5];
 336
 337    if (FS_StateFlags(w) & XmFS_NO_MATCH)
 338       data = 0;
 339    else
 340    {
 341       dirList = XmFileSelectionBoxGetChild(w, XmDIALOG_LIST);
 342       XtSetArg(args[0], XmNitemCount, &data);
 343       XtGetValues(dirList, args, 1);
 344    }
 345    valueReturn->addr = (XtPointer) &data ;
 346    valueReturn->size = sizeof(int *);
 347 }
 348
 349 int
 350 toolkit_initialize(
 351         int argc,
 352         char *argv[] )
 353 {
 354         int i;
 355         char name[8], *var;
 356         wtab_t *w;
 357         int newargc;
 358         char **newargv;
 359         char envbuf[2048];
 360         char * errmsg;
 361         int * lockedFds;
 362
 363         init_widgets();
 364
 365         newargv = (char **)malloc((argc - 3) * sizeof(char *));
 366
 367         /*
 368          * We apparently must alloc a long-lived array of strings for argv.
 369          * If we don't, then the WM_COMMAND on the Toplevel shell is munged.
 370          * This is presumably because XtInitialize just hangs onto a copy
 371          * of the pointer to the argv[n] element of interest, but the shell
 372          * apparently frees them up after toolkit_initialize returns.
 373          * The argument list looks like:
 374          * XtInitialize widgVar widgName className appName $@
 375          * or:
 376          * XtInitialize widgVar widgName className $0 $@
 377          */
 378         for(i = 0, newargc = argc - 4; i < newargc; i++)
 379         {
 380                 newargv[i] = (char *)malloc(strlen(argv[i + 4]) + 1);
 381                 strcpy(newargv[i], argv[i + 4]);
 382         }
 383         newargv[i] = (char *)NULL;
 384
 385         Toplevel = XtInitialize((char *)NULL, argv[3], (XrmOptionDescRec *)NULL,
 386                                                         0, &newargc, newargv);
 387
 388         if (Toplevel == NULL) {
 389                 errmsg = strdup(GETMESSAGE(15,1,
 390                                 "Unable to initialize the Toolkit"));
 391                 printerr(argv[0], errmsg, NULL);
 392                 free(errmsg);
 393                 env_blank(argv[1]);
 394                 return(1);
 395         }
 396
 397         lockedFds = LockKshFileDescriptors();
 398         DtInitialize(XtDisplay(Toplevel), Toplevel, argv[4], argv[4]);
 399         UnlockKshFileDescriptors(lockedFds);
 400
 401         DtkshRegisterNamedIntConverters();
 402         XtAddConverter(XmRTopItemPosition, XtRString,
 403                 DtkshCvtIntToString, NULL, 0);
 404         XtAddConverter(XmRHorizontalInt, XtRString,
 405                 DtkshCvtIntToString, NULL, 0);
 406         XtAddConverter(XmRVerticalInt, XtRString,
 407                 DtkshCvtIntToString, NULL, 0);
 408         XtAddConverter(XmRWhichButton, XtRString,
 409                 DtkshCvtIntToString, NULL, 0);
 410         XtAddConverter(XmRShellHorizPos, XtRString,
 411                 DtkshCvtIntToString, NULL, 0);
 412         XtAddConverter(XmRShellVertPos, XtRString,
 413                 DtkshCvtIntToString, NULL, 0);
 414         XtAddConverter(XmRShellHorizDim, XtRString,
 415                 DtkshCvtIntToString, NULL, 0);
 416         XtAddConverter(XmRShellVertDim, XtRString,
 417                 DtkshCvtIntToString, NULL, 0);
 418         XtAddConverter(XmRKeySym, XtRString,
 419                 DtkshCvtKeySymToString, NULL, 0);
 420         XtAddConverter(XtRInt, XtRString,
 421                 DtkshCvtIntToString, NULL, 0);
 422         XtAddConverter(XtRShort, XtRString,
 423                 DtkshCvtIntToString, NULL, 0);
 424         XtAddConverter(XtRCardinal, XtRString,
 425                 DtkshCvtIntToString, NULL, 0);
 426         XtAddConverter(XtRDimension, XtRString,
 427                 DtkshCvtIntToString, NULL, 0);
 428         XtAddConverter(XmRBooleanDimension, XtRString,
 429                 DtkshCvtIntToString, NULL, 0);
 430         XtAddConverter(XtRPosition, XtRString,
 431                 DtkshCvtIntToString, NULL, 0);
 432         XtAddConverter(XmRHorizontalDimension, XtRString,
 433                 DtkshCvtIntToString, NULL, 0);
 434         XtAddConverter(XmRVerticalDimension, XtRString,
 435                 DtkshCvtIntToString, NULL, 0);
 436         XtAddConverter(XmRHorizontalPosition, XtRString,
 437                 DtkshCvtIntToString, NULL, 0);
 438         XtAddConverter(XmRVerticalPosition, XtRString,
 439                 DtkshCvtIntToString, NULL, 0);
 440         XtAddConverter(XmRTextPosition, XtRString,
 441                 DtkshCvtIntToString, NULL, 0);
 442         XtAddConverter(XtRBoolean, XtRString,
 443                 DtkshCvtBooleanToString, NULL, 0);
 444         XtAddConverter("Set", XtRString,
 445                 DtkshCvtBooleanToString, NULL, 0);
 446         XtAddConverter(XtRBool, XtRString,
 447                 DtkshCvtBooleanToString, NULL, 0);
 448         XtAddConverter(XtRPixel, XtRString,
 449                 DtkshCvtHexIntToString, NULL, 0);
 450         XtAddConverter(XtRPixmap, XtRString,
 451                 DtkshCvtHexIntToString, NULL, 0);
 452         XtAddConverter("XE_ModifierState", XtRString,
 453                 DtkshCvtXEModifierStateToString, NULL, 0);
 454         XtAddConverter("XE_MotionHint", XtRString,
 455                 DtkshCvtXEMotionHintToString, NULL, 0);
 456         XtAddConverter("XE_HexValue", XtRString,
 457                 DtkshCvtHexIntToString, NULL, 0);
 458         XtAddConverter("XE_IntValue", XtRString,
 459                 DtkshCvtIntToString, NULL, 0);
 460         XtAddConverter(XtRPointer, XtRString,
 461                 DtkshCvtHexIntToString, NULL, 0);
 462         XtAddConverter("XE_Window", XtRString,
 463                 DtkshCvtWindowToString, NULL, 0);
 464         XtAddConverter(XtRScreen, XtRString,
 465                 DtkshCvtScreenToString, NULL, 0);
 466         XtAddConverter(XtRString, XtRScreen,
 467                 DtkshCvtStringToScreen, NULL, 0);
 468         XtAddConverter(XtRString, XmRTopItemPosition,
 469                 DtkshCvtStringToTopItemPosition, NULL, 0);
 470         XtAddConverter(XtRString, XmRUnitType,
 471                 XmCvtStringToUnitType, NULL, 0);
 472         XtSetTypeConverter(XmRXmString, XtRString,
 473                 (XtTypeConverter)DtkshCvtXmStringToString, NULL, 0,
 474                 XtCacheNone, NULL);
 475         XtSetTypeConverter(XtRWidget, XtRString,
 476                 (XtTypeConverter)DtkshCvtWidgetToString, NULL, 0,
 477                 XtCacheNone, NULL);
 478         XtSetTypeConverter("MenuWidget", XtRString,
 479                 (XtTypeConverter)DtkshCvtWidgetToString, NULL, 0,
 480                 XtCacheNone, NULL);
 481         XtSetTypeConverter(XtRString, XtRWidget,
 482                 (XtTypeConverter)DtkshCvtStringToWidget, NULL, 0,
 483                 XtCacheNone, NULL);
 484         XtSetTypeConverter(XtRString, "MenuWidget",
 485                 (XtTypeConverter)DtkshCvtStringToWidget, NULL, 0,
 486                 XtCacheNone, NULL);
 487         XtSetTypeConverter(XtRString, XtRCallback,
 488                 (XtTypeConverter)DtkshCvtStringToCallback, NULL, 0,
 489                 XtCacheNone, NULL);
 490         XtSetTypeConverter(XtRCallback, XtRString,
 491                 (XtTypeConverter)DtkshCvtCallbackToString, NULL, 0,
 492                 XtCacheNone, NULL);
 493         XtSetTypeConverter(XtRString, DtRPrintSetupProc,
 494                 (XtTypeConverter)DtkshCvtStringToPrintSetupProc, NULL, 0,
 495                 XtCacheNone, NULL);
 496         XtSetTypeConverter(XtRString, "EventMask",
 497                 (XtTypeConverter)DtkshCvtStringToEventMask, NULL, 0,
 498                 XtCacheNone, NULL);
 499         XtSetTypeConverter(XtRString, "MWMDecoration",
 500                 (XtTypeConverter)DtkshCvtStringToMWMDecoration, NULL, 0,
 501                 XtCacheNone, NULL);
 502         XtSetTypeConverter("MWMDecoration", XtRString,
 503                 (XtTypeConverter)DtkshCvtMWMDecorationToString, NULL, 0,
 504                 XtCacheNone, NULL);
 505         XtSetTypeConverter(XtRString, "MWMFunctions",
 506                 (XtTypeConverter)DtkshCvtStringToMWMFunctions, NULL, 0,
 507                 XtCacheNone, NULL);
 508         XtSetTypeConverter("MWMFunctions", XtRString,
 509                 (XtTypeConverter)DtkshCvtMWMFunctionsToString, NULL, 0,
 510                 XtCacheNone, NULL);
 511         XtSetTypeConverter(XtRString, "ListItems",
 512                 (XtTypeConverter)DtkshCvtStringToListItems, NULL, 0,
 513                 XtCacheNone, NULL);
 514         XtSetTypeConverter(XtRString, "SelectedListItems",
 515                 (XtTypeConverter)DtkshCvtStringToListItems, NULL, 0,
 516                 XtCacheNone, NULL);
 517         XtSetTypeConverter(XtRString, "SelBoxItems",
 518                 (XtTypeConverter)DtkshCvtStringToListItems, NULL, 0,
 519                 XtCacheNone, NULL);
 520         XtSetTypeConverter(XtRString, "FSFileItems",
 521                 (XtTypeConverter)DtkshCvtStringToListItems, NULL, 0,
 522                 XtCacheNone, NULL);
 523         XtSetTypeConverter(XtRString, "FSDirItems",
 524                 (XtTypeConverter)DtkshCvtStringToListItems, NULL, 0,
 525                 XtCacheNone, NULL);
 526         XtSetTypeConverter(XtRString, XmRWidgetClass,
 527                 (XtTypeConverter)DtkshCvtStringToWidgetClass, NULL, 0,
 528                 XtCacheNone, NULL);
 529         XtSetTypeConverter(XtRString, "PanedWinPosIndex",
 530                 (XtTypeConverter)DtkshCvtStringToPanedWinPosIndex, NULL, 0,
 531                 XtCacheNone, NULL);
 532         XtSetTypeConverter("PanedWinPosIndex", XtRString,
 533                 (XtTypeConverter)DtkshCvtPanedWinPosIndexToString, NULL, 0,
 534                 XtCacheNone, NULL);
 535         XtSetTypeConverter("ListItems", XtRString,
 536                 (XtTypeConverter)DtkshCvtListItemsToString,
 537                 listItemConvertArgs, 1,
 538                 XtCacheNone, NULL);
 539         XtSetTypeConverter("SelBoxItems", XtRString,
 540                 (XtTypeConverter)DtkshCvtListItemsToString,
 541                 selBoxItemConvertArgs, 1,
 542                 XtCacheNone, NULL);
 543         XtSetTypeConverter("SelectedListItems", XtRString,
 544                 (XtTypeConverter)DtkshCvtListItemsToString,
 545                 selectedListItemConvertArgs, 1,
 546                 XtCacheNone, NULL);
 547         XtSetTypeConverter("FSFileItems", XtRString,
 548                 (XtTypeConverter)DtkshCvtListItemsToString,
 549                 fileSelBoxFileConvertArgs, 1,
 550                 XtCacheNone, NULL);
 551         XtSetTypeConverter("FSDirItems", XtRString,
 552                 (XtTypeConverter)DtkshCvtListItemsToString,
 553                 fileSelBoxDirConvertArgs, 1,
 554                 XtCacheNone, NULL);
 555         XtSetTypeConverter(XmRWidgetClass, XtRString,
 556                 (XtTypeConverter)DtkshCvtWidgetClassToString,
 557                 NULL, 0, XtCacheNone, NULL);
 558
 559         /*
 560          * Override standard Xt StringToPixel converter;
 561          * we need to handle both pixel names and pixel values.
 562          */
 563         RegisterXtOverrideConverters();
 564
 565         w = set_up_w(Toplevel, NULL, argv[1], argv[2],
 566                      str_to_class(argv[0], "ApplicationShell"));
 567
 568         var = env_get(str_TOPLEVEL);
 569         if (var == NULL || *var == '\0') {
 570                 env_set_var(str_TOPLEVEL, w->widid);
 571         }
 572
 573         var = env_get(str_APPNAME);
 574         if (var == NULL || *var == '\0') {
 575                 env_set_var(str_APPNAME, argv[2]);
 576         }
 577
 578         ksh_eval("unset DTKSH_ARGV");
 579         for (i = 0; i < newargc; i++) {
 580                 sprintf(envbuf, "DTKSH_ARGV[%d]=%s", i, newargv[i]);
 581                 env_set(envbuf);
 582         }
 583         return(0);
 584 }
 585
 586 /*
 587  * There are certain classes of resources which cannot be specified when
 588  * a widget is created.  These are resources which rely on a unit of
 589  * measure typically specified with the 'unitType' resource.  Since there
 590  * is no widget yet when we convert the resources from string to internal
 591  * representation, there, of course, is no known unitType yet; thus the
 592  * conversions cannot be performed.  That is why we have this check, and
 593  * why we have to tell the user to use XtSetValues().
 594  *
 595  * There is a second class of resources where this problem also exists;
 596  * these are the gadget pixmaps.  The problem exists because the string
 597  * to pixmap converter for gadgets assumes that it has access to the
 598  * widget ID, so that it can grab the parent.  Since the widget Id does
 599  * not yet exist, this information does not exist.
 600  *
 601  * A third class of problem resources are all pixmap resources.  If these
 602  * are specified in the same resource list as the foreground or background
 603  * colors, then the converter uses the existing colors, instead of the new
 604  * colors.  To overcome this, we postpone the converting of any pixmap
 605  * resources until after all others have been set.
 606  */
 607 int
 608 toolkit_special_resource(
 609         char *arg0,
 610         XtResourceList res,
 611         wtab_t *w,
 612         wtab_t *parent,
 613         classtab_t *class,
 614         char *resource,
 615         char *val,
 616         XtArgVal *ret,
 617         int *freeit,
 618         Boolean postponePixmaps )
 619 {
 620    if ((w == NULL) &&
 621        ((strcmp(res->resource_type, XmRHorizontalDimension) == 0) ||
 622         (strcmp(res->resource_type, XmRVerticalDimension) == 0)   ||
 623         (strcmp(res->resource_type, XmRHorizontalPosition) == 0)  ||
 624         (strcmp(res->resource_type, XmRVerticalPosition) == 0)    ||
 625         (strcmp(res->resource_type, XmRBooleanDimension) == 0)    ||
 626         (strcmp(res->resource_type, XmRGadgetPixmap) == 0)    ||
 627         (strcmp(res->resource_type, DtRPrintSetupProc) == 0)))
 628    {
 629       return(TRUE);
 630    }
 631    else if (postponePixmaps  &&
 632             ((strcmp(resource, XmNpixmap) == 0) ||
 633              (strstr(resource, "Pixmap") != NULL)))
 634    {
 635       return(TRUE);
 636    }
 637
 638    return(FALSE);
 639 }
 640
 641
 642 static int
 643 _xmcreatefunc(
 644         Widget (*func)(),
 645         char *wclass,
 646         int argc,
 647         char *argv[] )
 648 {
 649         Widget widget, realparent;
 650         classtab_t *class;
 651         char *arg0 = argv[0];
 652         wtab_t *w, *pw, *wtab, *parenttab;
 653         char *wname, *parentid, *var;
 654         Arg     args[MAXARGS];
 655         register int    i;
 656         int n;
 657         char * errmsg;
 658         int pargc;
 659         char ** pargv;
 660
 661         if (argc < 4) {
 662                 errmsg = strdup(GETMESSAGE(15,3,
 663                      "Usage: %s variable parent name [argument:value ...]"));
 664                 printerrf(str_nill, errmsg, argv[0], NULL,
 665                     NULL, NULL, NULL, NULL, NULL, NULL);
 666                 free(errmsg);
 667                 return(1);
 668         }
 669         var = argv[1];
 670         parentid = argv[2];
 671         wname = argv[3];
 672         pw = str_to_wtab(argv[0], parentid);
 673         if (pw == NULL) {
 674                 errmsg = strdup(GetSharedMsg(DT_NO_PARENT));
 675                 printerr(argv[0], errmsg, NULL);
 676                 free(errmsg);
 677                 return(1);
 678         }
 679         argv += 4;
 680         argc -= 4;
 681         if ((class = str_to_class(arg0, wclass)) == NULL) {
 682                 return(1);
 683         }
 684         pargc = 0;
 685         if (argc > 0) {
 686                 pargv = (char **)XtMalloc(sizeof(char *) * argc);
 687         }
 688         else {
 689                 pargv = 0;
 690         }
 691         parse_args(arg0, argc, argv, NULL, pw, class, &n, args, &pargc, pargv,
 692                    True);
 693         widget = func(pw->w, wname, args, n);
 694         if (widget != NULL) {
 695                 /* Some of the XmCreate* functions return a widget
 696                  * id whose parent is not necessarily the parent
 697                  * passed in.  For example, DialogShell returns the
 698                  * widget of the dialog, not the Shell which is the
 699                  * real parent.
 700                  *
 701                  * So, we check to see if the parent is the same as
 702                  * the passed-in parent, and if not then we create
 703                  * a new entry for the real parent.
 704                  */
 705                 realparent = XtParent(widget);
 706                 if (realparent != pw->w) {
 707                         parenttab = (wtab_t *)widget_to_wtab(realparent);
 708                 } else
 709                         parenttab = pw;
 710                 wtab = set_up_w(widget, parenttab, var, wname, class);
 711
 712                 /* Process any postponed resources */
 713                 if (pargc > 0)
 714                 {
 715                         free_args(n, args);
 716                         n = 0;
 717                         parse_args(arg0, pargc, pargv, wtab, pw, class, &n,
 718                                    args, NULL, NULL, False);
 719                         XtSetValues(widget, args, n);
 720                 }
 721         } else {
 722                 errmsg = strdup(GetSharedMsg(DT_WIDGET_CREATE_FAILED));
 723                 printerrf(argv[0], errmsg,
 724                           wname, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
 725                 free(errmsg);
 726                 env_blank(argv[1]);
 727         }
 728         free_args(n, args);
 729         XtFree((char *)pargv);
 730
 731         return(0);
 732 }
 733
 734 int
 735 do_XmCreateArrowButton(
 736         int argc,
 737         char *argv[] )
 738 {
 739    return(_xmcreatefunc(XmCreateArrowButton, "XmArrowButton",
 740                         argc, argv));
 741 }
 742
 743
 744 int
 745 do_XmCreateArrowButtonGadget(
 746         int argc,
 747         char *argv[] )
 748 {
 749    return(_xmcreatefunc(XmCreateArrowButtonGadget,
 750                         "XmArrowButtonGadget", argc, argv));
 751 }
 752
 753
 754 int
 755 do_XmCreateBulletinBoard(
 756         int argc,
 757         char *argv[] )
 758 {
 759    return(_xmcreatefunc(XmCreateBulletinBoard, "XmBulletinBoard",
 760                         argc, argv));
 761 }
 762
 763
 764 int
 765 do_XmCreateBulletinBoardDialog(
 766         int argc,
 767         char *argv[] )
 768 {
 769    return(_xmcreatefunc(XmCreateBulletinBoardDialog, "XmBulletinBoard",
 770                         argc, argv));
 771 }
 772
 773
 774 int
 775 do_XmCreateCascadeButton(
 776         int argc,
 777         char *argv[] )
 778 {
 779    return(_xmcreatefunc(XmCreateCascadeButton, "XmCascadeButton",
 780                         argc, argv));
 781 }
 782
 783
 784 int
 785 do_XmCreateCascadeButtonGadget(
 786         int argc,
 787         char *argv[] )
 788 {
 789    return(_xmcreatefunc(XmCreateCascadeButtonGadget,
 790                         "XmCascadeButtonGadget", argc, argv));
 791 }
 792
 793
 794 int
 795 do_XmCreateComboBox(
 796         int argc,
 797         char *argv[] )
 798 {
 799    return(_xmcreatefunc(XmCreateComboBox,
 800                         "XmComboBox", argc, argv));
 801 }
 802
 803
 804 int
 805 do_XmCreateCommand(
 806         int argc,
 807         char *argv[] )
 808 {
 809    return(_xmcreatefunc(XmCreateCommand, "XmCommand", argc, argv));
 810 }
 811
 812
 813 int
 814 do_XmCreateDialogShell(
 815         int argc,
 816         char *argv[] )
 817 {
 818    return(_xmcreatefunc(XmCreateDialogShell, "XmDialogShell", argc,
 819                         argv));
 820 }
 821
 822
 823 int
 824 do_XmCreateDrawingArea(
 825         int argc,
 826         char *argv[] )
 827 {
 828    return(_xmcreatefunc(XmCreateDrawingArea, "XmDrawingArea", argc,
 829                         argv));
 830 }
 831
 832
 833 int
 834 do_XmCreateDrawnButton(
 835         int argc,
 836         char *argv[] )
 837 {
 838    return(_xmcreatefunc(XmCreateDrawnButton, "XmDrawnButton", argc,
 839                         argv));
 840 }
 841
 842
 843 int
 844 do_XmCreateErrorDialog(
 845         int argc,
 846         char *argv[] )
 847 {
 848    return(_xmcreatefunc(XmCreateErrorDialog, "XmMessageBox", argc,
 849                         argv));
 850 }
 851
 852
 853 int
 854 do_XmCreateFileSelectionBox(
 855         int argc,
 856         char *argv[] )
 857 {
 858    return(_xmcreatefunc(XmCreateFileSelectionBox, "XmFileSelectionBox",
 859                         argc, argv));
 860 }
 861
 862
 863 int
 864 do_XmCreateFileSelectionDialog(
 865         int argc,
 866         char *argv[] )
 867 {
 868    return(_xmcreatefunc(XmCreateFileSelectionDialog,
 869                         "XmFileSelectionBox", argc, argv));
 870 }
 871
 872
 873 int
 874 do_XmCreateForm(
 875         int argc,
 876         char *argv[] )
 877 {
 878    return(_xmcreatefunc(XmCreateForm, "XmForm", argc, argv));
 879 }
 880
 881
 882 int
 883 do_XmCreateFormDialog(
 884         int argc,
 885         char *argv[] )
 886 {
 887    return(_xmcreatefunc(XmCreateFormDialog, "XmForm", argc, argv));
 888 }
 889
 890
 891 int
 892 do_XmCreateFrame(
 893         int argc,
 894         char *argv[] )
 895 {
 896    return(_xmcreatefunc(XmCreateFrame, "XmFrame", argc, argv));
 897 }
 898
 899
 900 int
 901 do_XmCreateInformationDialog(
 902         int argc,
 903         char *argv[] )
 904 {
 905    return(_xmcreatefunc(XmCreateInformationDialog, "XmMessageBox",
 906                         argc, argv));
 907 }
 908
 909
 910 int
 911 do_XmCreateLabel(
 912         int argc,
 913         char *argv[] )
 914 {
 915    return(_xmcreatefunc(XmCreateLabel, "XmLabel", argc, argv));
 916 }
 917
 918
 919 int
 920 do_XmCreateLabelGadget(
 921         int argc,
 922         char *argv[] )
 923 {
 924    return(_xmcreatefunc(XmCreateLabelGadget, "XmLabelGadget", argc,
 925                         argv));
 926 }
 927
 928
 929 int
 930 do_XmCreateList(
 931         int argc,
 932         char *argv[] )
 933 {
 934    return(_xmcreatefunc(XmCreateList, "XmList", argc, argv));
 935 }
 936
 937
 938 int
 939 do_XmCreateMainWindow(
 940         int argc,
 941         char *argv[] )
 942 {
 943    return(_xmcreatefunc(XmCreateMainWindow, "XmMainWindow", argc,
 944                         argv));
 945 }
 946
 947
 948 int
 949 do_XmCreateMenuBar(
 950         int argc,
 951         char *argv[] )
 952 {
 953    return(_xmcreatefunc(XmCreateMenuBar, "XmRowColumn", argc, argv));
 954 }
 955
 956
 957 int
 958 do_XmCreateMenuShell(
 959         int argc,
 960         char *argv[] )
 961 {
 962    return(_xmcreatefunc(XmCreateMenuShell, "XmMenuShell", argc, argv));
 963 }
 964
 965
 966 int
 967 do_XmCreateMessageBox(
 968         int argc,
 969         char *argv[] )
 970 {
 971    return(_xmcreatefunc(XmCreateMessageBox, "XmMessageBox", argc,
 972                         argv));
 973 }
 974
 975
 976 int
 977 do_XmCreateMessageDialog(
 978         int argc,
 979         char *argv[] )
 980 {
 981    return(_xmcreatefunc(XmCreateMessageDialog, "XmMessageBox", argc,
 982                         argv));
 983 }
 984
 985
 986 int
 987 do_XmCreateOptionMenu(
 988         int argc,
 989         char *argv[] )
 990 {
 991    return(_xmcreatefunc(XmCreateOptionMenu, "XmRowColumn", argc, argv));
 992 }
 993
 994
 995 int
 996 do_XmCreatePanedWindow(
 997         int argc,
 998         char *argv[] )
 999 {
1000    return(_xmcreatefunc(XmCreatePanedWindow, "XmPanedWindow", argc,
1001                         argv));
1002 }
1003
1004
1005 int
1006 do_XmCreatePopupMenu(
1007         int argc,
1008         char *argv[] )
1009 {
1010    return(_xmcreatefunc(XmCreatePopupMenu, "XmRowColumn", argc, argv));
1011 }
1012
1013
1014 int
1015 do_XmCreatePromptDialog(
1016         int argc,
1017         char *argv[] )
1018 {
1019    return(_xmcreatefunc(XmCreatePromptDialog, "XmSelectionBox", argc,
1020                         argv));
1021 }
1022
1023
1024 int
1025 do_XmCreatePulldownMenu(
1026         int argc,
1027         char *argv[] )
1028 {
1029    return(_xmcreatefunc(XmCreatePulldownMenu, "XmRowColumn", argc,
1030                         argv));
1031 }
1032
1033
1034 int
1035 do_XmCreatePushButton(
1036         int argc,
1037         char *argv[] )
1038 {
1039    return(_xmcreatefunc(XmCreatePushButton, "XmPushButton", argc,
1040                         argv));
1041 }
1042
1043
1044 int
1045 do_XmCreatePushButtonGadget(
1046         int argc,
1047         char *argv[] )
1048 {
1049    return(_xmcreatefunc(XmCreatePushButtonGadget, "XmPushButtonGadget",
1050                         argc, argv));
1051 }
1052
1053
1054 int
1055 do_XmCreateQuestionDialog(
1056         int argc,
1057         char *argv[] )
1058 {
1059    return(_xmcreatefunc(XmCreateQuestionDialog, "XmMessageBox", argc,
1060                         argv));
1061 }
1062
1063
1064 int
1065 do_XmCreateRadioBox(
1066         int argc,
1067         char *argv[] )
1068 {
1069    return(_xmcreatefunc(XmCreateRadioBox, "XmRowColumn", argc, argv));
1070 }
1071
1072
1073 int
1074 do_XmCreateRowColumn(
1075         int argc,
1076         char *argv[] )
1077 {
1078    return(_xmcreatefunc(XmCreateRowColumn, "XmRowColumn", argc, argv));
1079 }
1080
1081
1082 int
1083 do_XmCreateScale(
1084         int argc,
1085         char *argv[] )
1086 {
1087    return(_xmcreatefunc(XmCreateScale, "XmScale", argc, argv));
1088 }
1089
1090
1091 int
1092 do_XmCreateScrollBar(
1093         int argc,
1094         char *argv[] )
1095 {
1096    return(_xmcreatefunc(XmCreateScrollBar, "XmScrollBar", argc, argv));
1097 }
1098
1099
1100 int
1101 do_XmCreateScrolledList(
1102         int argc,
1103         char *argv[] )
1104 {
1105    return(_xmcreatefunc(XmCreateScrolledList, "XmList", argc, argv));
1106 }
1107
1108
1109 int
1110 do_XmCreateScrolledText(
1111         int argc,
1112         char *argv[] )
1113 {
1114    return(_xmcreatefunc(XmCreateScrolledText, "XmText", argc, argv));
1115 }
1116
1117
1118 int
1119 do_XmCreateScrolledWindow(
1120         int argc,
1121         char *argv[] )
1122 {
1123    return(_xmcreatefunc(XmCreateScrolledWindow, "XmScrolledWindow",
1124                         argc, argv));
1125 }
1126
1127
1128 int
1129 do_XmCreateSelectionBox(
1130         int argc,
1131         char *argv[] )
1132 {
1133    return(_xmcreatefunc(XmCreateSelectionBox, "XmSelectionBox", argc,
1134                         argv));
1135 }
1136
1137
1138 int
1139 do_XmCreateSelectionDialog(
1140         int argc,
1141         char *argv[] )
1142 {
1143    return(_xmcreatefunc(XmCreateSelectionDialog, "XmSelectionBox",
1144                         argc, argv));
1145 }
1146
1147
1148 int
1149 do_XmCreateSeparator(
1150         int argc,
1151         char *argv[] )
1152 {
1153    return(_xmcreatefunc(XmCreateSeparator, "XmSeparator", argc, argv));
1154 }
1155
1156
1157 int
1158 do_XmCreateSeparatorGadget(
1159         int argc,
1160         char *argv[] )
1161 {
1162    return(_xmcreatefunc(XmCreateSeparatorGadget, "XmSeparatorGadget",
1163                         argc, argv));
1164 }
1165
1166
1167 int
1168 do_XmCreateText(
1169         int argc,
1170         char *argv[] )
1171 {
1172    return(_xmcreatefunc(XmCreateText, "XmText", argc, argv));
1173 }
1174
1175
1176 int
1177 do_XmCreateTextField(
1178         int argc,
1179         char *argv[] )
1180 {
1181    return(_xmcreatefunc(XmCreateTextField, "XmTextField", argc, argv));
1182 }
1183
1184
1185 int
1186 do_XmCreateToggleButton(
1187         int argc,
1188         char *argv[] )
1189 {
1190    return(_xmcreatefunc(XmCreateToggleButton, "XmToggleButton", argc,
1191                         argv));
1192 }
1193
1194
1195 int
1196 do_XmCreateToggleButtonGadget(
1197         int argc,
1198         char *argv[] )
1199 {
1200    return(_xmcreatefunc(XmCreateToggleButtonGadget,
1201                         "XmToggleButtonGadget", argc, argv));
1202 }
1203
1204
1205 int
1206 do_XmCreateWarningDialog(
1207         int argc,
1208         char *argv[] )
1209 {
1210    return(_xmcreatefunc(XmCreateWarningDialog, "XmMessageBox", argc,
1211                         argv));
1212 }
1213
1214
1215 int
1216 do_XmCreateWorkArea(
1217         int argc,
1218         char *argv[] )
1219 {
1220    return(_xmcreatefunc(XmCreateWorkArea, "XmRowColumn", argc, argv));
1221 }
1222
1223
1224 int
1225 do_XmCreateWorkingDialog(
1226         int argc,
1227         char *argv[] )
1228 {
1229    return(_xmcreatefunc(XmCreateWorkingDialog, "XmMessageBox", argc,
1230                         argv));
1231 }
1232
1233
1234 int
1235 do_DtCreateHelpDialog(
1236         int argc,
1237         char *argv[] )
1238 {
1239    return(_xmcreatefunc(DtCreateHelpDialog, "DtHelpDialog", argc,
1240                         argv));
1241 }
1242
1243
1244 int
1245 do_DtCreateHelpQuickDialog(
1246         int argc,
1247         char *argv[] )
1248 {
1249    return(_xmcreatefunc(DtCreateHelpQuickDialog, "DtHelpQuickDialog", argc,
1250                         argv));
1251 }
1252
1253 int
1254 do_DtCreatePrintSetupDialog(
1255         int argc,
1256         char *argv[] )
1257 {
1258    return(_xmcreatefunc(DtCreatePrintSetupDialog, "DtPrintSetupBox", argc,
1259                         argv));
1260 }
1261
1262 int
1263 do_DtCreatePrintSetupBox(
1264         int argc,
1265         char *argv[] )
1266 {
1267    return(_xmcreatefunc(DtCreatePrintSetupBox, "DtPrintSetupBox", argc,
1268                         argv));
1269 }
1270
1271
1272 int
1273 do_DtHelpReturnSelectedWidgetId(
1274         int argc,
1275         char *argv[] )
1276 {
1277    char *arg0 = argv[0];
1278    wtab_t * w;
1279    XmString string;
1280    char * results = argv[1];
1281    char * variable = argv[3];
1282    XrmValue f, t;
1283    int res;
1284    classtab_t *ctab;
1285    Widget retWidget;
1286    char * errmsg;
1287
1288    if (argc != 4)
1289    {
1290       errmsg = strdup(GETMESSAGE(15,4,
1291          "Usage: DtHelpReturnSelectedWidgetId variable widget variable"));
1292       printerr(str_nill, errmsg, NULL);
1293       free(errmsg);
1294       return(1);
1295    }
1296
1297    w = str_to_wtab(arg0, argv[2]);
1298    if (w == NULL) {
1299         alt_env_set_var(variable, "");
1300         env_blank(results);
1301         return(1);
1302    }
1303
1304    res = DtHelpReturnSelectedWidgetId(w->w, NULL, &retWidget);
1305    XSync(XtDisplay(w->w), False);
1306
1307    f.addr = (caddr_t)&res;
1308    f.size = sizeof(int);
1309    t.addr = NULL;
1310    t.size = 0;
1311    XtConvert(w->w, "HelpReturnSelectedWidgetResultType", &f, XtRString, &t);
1312    env_set_var(results,  (char *)(t.addr));
1313
1314    if (res != DtHELP_SELECT_VALID)
1315    {
1316       alt_env_set_var(variable, "");
1317       return(0);
1318    }
1319
1320    w = ConvertWidgetToWtab(arg0, retWidget);
1321
1322    alt_env_set_var(variable,  w->widid);
1323    return(0);
1324 }
1325
1326
1327 int
1328 do_DtHelpSetCatalogName(
1329         int argc,
1330         char *argv[] )
1331 {
1332    char *arg0 = argv[0];
1333    char * errmsg;
1334
1335    if (argc != 2)
1336    {
1337       errmsg = strdup(GETMESSAGE(15,5,
1338                       "Usage: DtHelpSetCatalogName catalogName"));
1339       printerr(str_nill, errmsg, NULL);
1340       free(errmsg);
1341       return(1);
1342    }
1343
1344    DtHelpSetCatalogName(argv[1]);
1345
1346    return(0);
1347 }
1348
1349
1350 int
1351 do_DtHelpQuickDialogGetChild(
1352         int argc,
1353         char *argv[] )
1354 {
1355    char *arg0 = argv[0];
1356    wtab_t * w;
1357    XmString string;
1358    char * variable = argv[1];
1359    int childType;
1360    XrmValue f, t;
1361    Widget child;
1362    classtab_t *ctab;
1363    char * errmsg;
1364
1365    if (argc != 4)
1366    {
1367       errmsg = strdup(GETMESSAGE(15,6,
1368             "Usage: DtHelpQuickDialogGetChild variable quickHelpWidget child"));
1369       printerr(str_nill, errmsg, NULL);
1370       free(errmsg);
1371       return(1);
1372    }
1373
1374    w = str_to_wtab(arg0, argv[2]);
1375    if (w == NULL) {
1376         alt_env_set_var(variable, "");
1377         return(1);
1378    }
1379
1380    if (w->wclass->class != dtHelpQuickDialogWidgetClass) {
1381       errmsg = strdup(GETMESSAGE(15,7,
1382                       "The widget must be a 'quickHelp' widget"));
1383       printerr(arg0, errmsg, NULL);
1384       free(errmsg);
1385       alt_env_set_var(variable, "");
1386       return(1);
1387    }
1388
1389    f.addr = argv[3];
1390    f.size = strlen(argv[3]) + 1;
1391    t.addr = NULL;
1392    t.size = 0;
1393    XtConvert(w->w, XtRString, &f, "QuickHelpChildType", &t);
1394
1395    if (t.size && t.addr)
1396       childType = *((int *)t.addr);
1397    else
1398    {
1399       errmsg = strdup(GetSharedMsg(DT_UNKNOWN_CHILD_TYPE));
1400       printerrf(argv[0], errmsg, argv[2], NULL, NULL,
1401                 NULL, NULL, NULL, NULL, NULL);
1402       free(errmsg);
1403       alt_env_set_var(variable, "");
1404       return(1);
1405    }
1406
1407    child = DtHelpQuickDialogGetChild(w->w, childType);
1408
1409    if (child == NULL)
1410    {
1411       alt_env_set_var(variable, "");
1412       return(1);
1413    }
1414
1415    w = ConvertWidgetToWtab(arg0, child);
1416
1417    alt_env_set_var(variable,  w->widid);
1418    return(0);
1419 }
1420
1421
1422 static wtab_t *
1423 verifyListWidget(
1424         char *cmd,
1425         char *widget )
1426 {
1427    wtab_t *w;
1428    char * errmsg;
1429
1430    if ((w = str_to_wtab(cmd, widget)) == NULL)
1431       return(NULL);
1432
1433    if (w->wclass->class != xmListWidgetClass)
1434    {
1435       errmsg = strdup(GETMESSAGE(15,8, "The widget must be a 'list' widget"));
1436       printerr(cmd, errmsg, NULL);
1437       free(errmsg);
1438       return(NULL);
1439    }
1440
1441    return(w);
1442 }
1443
1444
1445 static int
1446 List_ItemAndPos(
1447         void (*func)(),
1448         int argc,
1449         char *argv[] )
1450 {
1451    char *arg0 = argv[0];
1452    wtab_t *w;
1453    XmString string;
1454    int position = 0;
1455    char * errmsg;
1456
1457    if (argc != 4)
1458    {
1459       errmsg = strdup(GETMESSAGE(15,9, "Usage: %s widget position item"));
1460       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL, NULL, NULL,
1461                 NULL);
1462       free(errmsg);
1463       return(1);
1464    }
1465
1466    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1467       return(1);
1468
1469    string = XmStringCreateLocalized(argv[3]);
1470    position = atoi(argv[2]);
1471
1472    (*func) (w->w, string, position);
1473    XmStringFree(string);
1474    return(0);
1475 }
1476
1477
1478 int
1479 do_XmListAddItem(
1480         int argc,
1481         char *argv[] )
1482 {
1483    return (List_ItemAndPos(XmListAddItem, argc, argv));
1484 }
1485
1486
1487 int
1488 do_XmListAddItemUnselected(
1489         int argc,
1490         char *argv[] )
1491 {
1492    return (List_ItemAndPos(XmListAddItemUnselected, argc, argv));
1493 }
1494
1495
1496 static int
1497 List_ItemListAndPos(
1498         void (*func)(),
1499         int argc,
1500         char *argv[] )
1501 {
1502    char *arg0 = argv[0];
1503    wtab_t *w;
1504    int position = 0;
1505    XmString *items = NULL;
1506    int itemCount = 0;
1507    int itemListSize = 0;
1508    int i;
1509    char * errmsg;
1510
1511    if (argc < 4)
1512    {
1513       errmsg = strdup(GETMESSAGE(15,10, "Usage: %s widget position itemList"));
1514       printerrf(str_nill, errmsg, arg0, NULL, NULL,
1515                 NULL, NULL, NULL, NULL, NULL);
1516       free(errmsg);
1517       return(1);
1518    }
1519
1520    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1521       return(1);
1522
1523    position = atoi(argv[2]);
1524
1525    for (i = 3; i < argc; i++, itemCount++)
1526    {
1527       if (itemCount >= itemListSize)
1528       {
1529          itemListSize += 10;
1530          items = (XmString *)XtRealloc((char *)items,
1531                                        sizeof(XmString) * itemListSize);
1532       }
1533       items[itemCount] = XmStringCreateLocalized(argv[i]);
1534    }
1535
1536    (*func) (w->w, items, itemCount, position);
1537
1538    for (i = 0; i < itemCount; i++)
1539       XmStringFree(items[i]);
1540    XtFree((char *)items);
1541
1542    return(0);
1543 }
1544
1545
1546 int
1547 do_XmListAddItems(
1548         int argc,
1549         char *argv[] )
1550 {
1551    return (List_ItemListAndPos(XmListAddItems, argc, argv));
1552 }
1553
1554
1555 int
1556 do_XmListAddItemsUnselected(
1557         int argc,
1558         char *argv[] )
1559 {
1560    return (List_ItemListAndPos(XmListAddItemsUnselected, argc, argv));
1561 }
1562
1563
1564 int
1565 do_XmListReplaceItemsPos(
1566         int argc,
1567         char *argv[] )
1568 {
1569    return (List_ItemListAndPos(XmListReplaceItemsPos, argc, argv));
1570 }
1571
1572
1573 int
1574 do_XmListReplaceItemsPosUnselected(
1575         int argc,
1576         char *argv[] )
1577 {
1578    return (List_ItemListAndPos(XmListReplaceItemsPosUnselected, argc, argv));
1579 }
1580
1581
1582 static int
1583 List_WidgetOnly(
1584         void (*func)(),
1585         int argc,
1586         char *argv[] )
1587 {
1588    char *arg0 = argv[0];
1589    wtab_t *w;
1590    char * errmsg;
1591
1592    if (argc != 2)
1593    {
1594       errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET));
1595       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL, NULL,
1596                 NULL, NULL);
1597       free(errmsg);
1598       return(1);
1599    }
1600
1601    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1602       return(1);
1603
1604    (*func) (w->w);
1605
1606    return(0);
1607 }
1608
1609
1610 int
1611 do_XmListDeleteAllItems(
1612         int argc,
1613         char *argv[] )
1614 {
1615    return (List_WidgetOnly(XmListDeleteAllItems, argc, argv));
1616 }
1617
1618
1619 int
1620 do_XmListDeselectAllItems(
1621         int argc,
1622         char *argv[] )
1623 {
1624    return (List_WidgetOnly(XmListDeselectAllItems, argc, argv));
1625 }
1626
1627
1628 int
1629 do_XmListUpdateSelectedList(
1630         int argc,
1631         char *argv[] )
1632 {
1633    return (List_WidgetOnly(XmListUpdateSelectedList, argc, argv));
1634 }
1635
1636
1637 static int
1638 List_ItemOnly(
1639         void (*func)(),
1640         int argc,
1641         char *argv[] )
1642 {
1643    char *arg0 = argv[0];
1644    wtab_t *w;
1645    XmString string;
1646    char * errmsg;
1647
1648    if (argc != 3)
1649    {
1650       errmsg = strdup(GETMESSAGE(15,11, "Usage: %s widget item"));
1651       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL,
1652                 NULL, NULL, NULL);
1653       free(errmsg);
1654       return(1);
1655    }
1656
1657    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1658       return(1);
1659
1660    string = XmStringCreateLocalized(argv[2]);
1661
1662    (*func) (w->w, string);
1663    XmStringFree(string);
1664    return(0);
1665 }
1666
1667
1668 int
1669 do_XmListDeleteItem(
1670         int argc,
1671         char *argv[] )
1672 {
1673    return (List_ItemOnly(XmListDeleteItem, argc, argv));
1674 }
1675
1676
1677 int
1678 do_XmListDeselectItem(
1679         int argc,
1680         char *argv[] )
1681 {
1682    return (List_ItemOnly(XmListDeselectItem, argc, argv));
1683 }
1684
1685
1686 int
1687 do_XmListSetBottomItem(
1688         int argc,
1689         char *argv[] )
1690 {
1691    return (List_ItemOnly(XmListSetBottomItem, argc, argv));
1692 }
1693
1694
1695 int
1696 do_XmListSetItem(
1697         int argc,
1698         char *argv[] )
1699 {
1700    return (List_ItemOnly(XmListSetItem, argc, argv));
1701 }
1702
1703
1704 static int
1705 List_PositionOnly(
1706         void (*func)(),
1707         int argc,
1708         char *argv[] )
1709 {
1710    char *arg0 = argv[0];
1711    wtab_t *w;
1712    int position = 0;
1713    char * errmsg;
1714
1715    if (argc != 3)
1716    {
1717       errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_POS));
1718       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL,
1719                NULL, NULL, NULL, NULL);
1720       free(errmsg);
1721       return(1);
1722    }
1723
1724    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1725       return(1);
1726
1727    position = atoi(argv[2]);
1728    (*func) (w->w, position);
1729    return(0);
1730 }
1731
1732
1733 int
1734 do_XmListDeletePos(
1735         int argc,
1736         char *argv[] )
1737 {
1738    return (List_PositionOnly(XmListDeletePos, argc, argv));
1739 }
1740
1741
1742 int
1743 do_XmListDeselectPos(
1744         int argc,
1745         char *argv[] )
1746 {
1747    return (List_PositionOnly(XmListDeselectPos, argc, argv));
1748 }
1749
1750
1751 int
1752 do_XmListSetBottomPos(
1753         int argc,
1754         char *argv[] )
1755 {
1756    return (List_PositionOnly(XmListSetBottomPos, argc, argv));
1757 }
1758
1759
1760 int
1761 do_XmListSetHorizPos(
1762         int argc,
1763         char *argv[] )
1764 {
1765    return (List_PositionOnly(XmListSetHorizPos, argc, argv));
1766 }
1767
1768
1769 int
1770 do_XmListSetPos(
1771         int argc,
1772         char *argv[] )
1773 {
1774    return (List_PositionOnly(XmListSetPos, argc, argv));
1775 }
1776
1777
1778 int
1779 do_XmListDeleteItemsPos(
1780         int argc,
1781         char *argv[] )
1782 {
1783    char *arg0 = argv[0];
1784    wtab_t *w;
1785    int position = 0;
1786    int count = 0;
1787    char * errmsg;
1788
1789    if (argc != 4)
1790    {
1791       errmsg = strdup(GETMESSAGE(15,12,
1792                "Usage: XmListDeleteItemsPos widget count position"));
1793       printerr(str_nill, errmsg, NULL);
1794       free(errmsg);
1795       return(1);
1796    }
1797
1798    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1799       return(1);
1800
1801    count = atoi(argv[2]);
1802    position = atoi(argv[3]);
1803    XmListDeleteItemsPos(w->w, count, position);
1804    return(0);
1805 }
1806
1807
1808 int
1809 do_XmListDeleteItems(
1810         int argc,
1811         char *argv[] )
1812 {
1813    char *arg0 = argv[0];
1814    wtab_t *w;
1815    XmString *items = NULL;
1816    int itemCount = 0;
1817    int itemListSize = 0;
1818    int i;
1819    char * errmsg;
1820
1821    if (argc < 3)
1822    {
1823       errmsg = strdup(GETMESSAGE(15,13,
1824                       "Usage: XmListDeleteItems widget itemList"));
1825       printerr(str_nill, errmsg, NULL);
1826       free(errmsg);
1827       return(1);
1828    }
1829
1830    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1831       return(1);
1832
1833    for (i = 2; i < argc; i++, itemCount++)
1834    {
1835       if (itemCount >= itemListSize)
1836       {
1837          itemListSize += 10;
1838          items = (XmString *)XtRealloc((char *)items,
1839                                        sizeof(XmString) * itemListSize);
1840       }
1841       items[itemCount] = XmStringCreateLocalized(argv[i]);
1842    }
1843
1844    XmListDeleteItems(w->w, items, itemCount);
1845
1846    for (i = 0; i < itemCount; i++)
1847       XmStringFree(items[i]);
1848    XtFree((char *)items);
1849
1850    return(0);
1851 }
1852
1853
1854 int
1855 do_XmListDeletePositions(
1856         int argc,
1857         char *argv[] )
1858 {
1859    char *arg0 = argv[0];
1860    wtab_t *w;
1861    int positionCount = 0;
1862    int * positionList = NULL;
1863    int positionListSize = 0;
1864    int i;
1865    char * errmsg;
1866
1867    if (argc < 3)
1868    {
1869       errmsg = strdup(GETMESSAGE(15,14,
1870            "Usage: XmListDeletePositions widget positionList"));
1871       printerr(str_nill, errmsg, NULL);
1872       free(errmsg);
1873       return(1);
1874    }
1875
1876    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
1877       return(1);
1878
1879    for (i = 2; i < argc; i++, positionCount++)
1880    {
1881       if (positionCount >= positionListSize)
1882       {
1883          positionListSize += 10;
1884          positionList = (int *)XtRealloc((char *)positionList,
1885                                          sizeof(int) * positionListSize);
1886       }
1887       positionList[positionCount] = atoi(argv[i]);
1888    }
1889
1890    XmListDeletePositions(w->w, positionList, positionCount);
1891
1892    XtFree((char *)positionList);
1893
1894    return(0);
1895 }
1896
1897
1898 static int
1899 GetSelectedPosList(
1900         Boolean (*func)(),
1901         int paramCount,
1902         char * errmsg,
1903         int argc,
1904         char *argv[] )
1905 {
1906    char *arg0 = argv[0];
1907    wtab_t *w;
1908    int i;
1909    char * buf;
1910    Boolean result;
1911    int * posList;
1912    int posCount;
1913    char pos[25];
1914    XmString string;
1915
1916    if (argc != paramCount)
1917    {
1918       printerr(str_nill, errmsg, NULL);
1919       return(1);
1920    }
1921
1922    if ((w = verifyListWidget(argv[0], argv[2])) == NULL)
1923    {
1924       alt_env_set_var(argv[1], "");
1925       return(1);
1926    }
1927
1928    if (paramCount == 3)
1929       result = (*func)(w->w, &posList, &posCount);
1930    else
1931    {
1932       string = XmStringCreateLocalized(argv[3]);
1933       result = (*func)(w->w, string, &posList, &posCount);
1934       XmStringFree(string);
1935    }
1936
1937    if (result)
1938    {
1939       buf = XtMalloc(1);
1940       buf[0] = '\0';
1941
1942       for (i = 0; i < posCount; i++)
1943       {
1944          sprintf(pos, "%d", (int)posList[i]);
1945          buf = XtRealloc(buf, strlen(buf) + strlen(pos) + 2);
1946          if (i != 0)
1947             strcat(buf, ",");
1948          strcat(buf, pos);
1949       }
1950
1951       env_set_var(argv[1], buf);
1952       XtFree ((char *)posList);
1953       XtFree(buf);
1954    }
1955    else
1956       env_blank(argv[1]);
1957
1958    return (!result);
1959 }
1960
1961
1962 int
1963 do_XmListGetSelectedPos(
1964         int argc,
1965         char *argv[] )
1966 {
1967    Boolean result;
1968    char * errmsg;
1969
1970    errmsg = strdup(GETMESSAGE(15,94,
1971                    "Usage: XmListGetSelectedPos variable widget"));
1972    result = GetSelectedPosList(XmListGetSelectedPos, 3, errmsg, argc, argv);
1973    free(errmsg);
1974    return(result);
1975 }
1976
1977
1978 int
1979 do_XmListGetMatchPos(
1980         int argc,
1981         char *argv[] )
1982 {
1983    Boolean result;
1984    char * errmsg;
1985
1986    errmsg = strdup(GETMESSAGE(15,95,
1987                    "Usage: XmListGetMatchPos variable widget item"));
1988    result = GetSelectedPosList(XmListGetMatchPos, 4, errmsg, argc, argv);
1989    free(errmsg);
1990    return(result);
1991 }
1992
1993
1994 int
1995 do_XmListGetKbdItemPos(
1996         int argc,
1997         char *argv[] )
1998 {
1999    char *arg0 = argv[0];
2000    wtab_t *w;
2001    int position;
2002    int i;
2003    char buf[24];
2004    char * errmsg;
2005
2006    if (argc != 3)
2007    {
2008       errmsg = strdup(GETMESSAGE(15,15,
2009                       "Usage: XmListGetKbdItemPos variable widget"));
2010       printerr(str_nill, errmsg, NULL);
2011       free(errmsg);
2012       return(1);
2013    }
2014
2015    if ((w = verifyListWidget(argv[0], argv[2])) == NULL)
2016    {
2017       alt_env_set_var(argv[1], "");
2018       return(1);
2019    }
2020
2021    position = XmListGetKbdItemPos(w->w);
2022    sprintf(buf, "%d", position);
2023    alt_env_set_var(argv[1],  buf);
2024
2025    return(0);
2026 }
2027
2028
2029 int
2030 do_XmListItemExists(
2031         int argc,
2032         char *argv[] )
2033 {
2034    char *arg0 = argv[0];
2035    wtab_t *w;
2036    XmString string;
2037    Boolean res;
2038    char * errmsg;
2039
2040    if (argc != 3)
2041    {
2042       errmsg = strdup(GETMESSAGE(15,16, "Usage: XmListItemExists widget item"));
2043       printerr(str_nill, errmsg, NULL);
2044       free(errmsg);
2045       return(1);
2046    }
2047
2048    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2049       return(1);
2050
2051    string = XmStringCreateLocalized(argv[2]);
2052
2053    res = !XmListItemExists(w->w, string);
2054    XmStringFree(string);
2055    return(res);
2056 }
2057
2058
2059 int
2060 do_XmListItemPos(
2061         int argc,
2062         char *argv[] )
2063 {
2064    char *arg0 = argv[0];
2065    wtab_t *w;
2066    int position;
2067    int i;
2068    char buf[24];
2069    XmString item;
2070    char * errmsg;
2071
2072    if (argc != 4)
2073    {
2074       errmsg = strdup(GETMESSAGE(15,17,
2075                       "Usage: XmListItemPos variable widget item"));
2076       printerr(str_nill, errmsg, NULL);
2077       free(errmsg);
2078       return(1);
2079    }
2080
2081    if ((w = verifyListWidget(argv[0], argv[2])) == NULL)
2082    {
2083       alt_env_set_var(argv[1], "");
2084       return(1);
2085    }
2086
2087    item = XmStringCreateLocalized(argv[3]);
2088    position = XmListItemPos(w->w, item);
2089    sprintf(buf, "%d", position);
2090    alt_env_set_var(argv[1],  buf);
2091    XmStringFree(item);
2092
2093    return(0);
2094 }
2095
2096
2097 int
2098 do_XmListPosSelected(
2099         int argc,
2100         char *argv[] )
2101 {
2102    char *arg0 = argv[0];
2103    wtab_t *w;
2104    Boolean res;
2105    int position;
2106    char * errmsg;
2107
2108    if (argc != 3)
2109    {
2110       errmsg = strdup(GETMESSAGE(15,18,
2111                       "Usage: XmListPosSelected widget position"));
2112       printerr(str_nill, errmsg, NULL);
2113       free(errmsg);
2114       return(1);
2115    }
2116
2117    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2118       return(1);
2119
2120    position = atoi(argv[2]);
2121
2122    res = !XmListPosSelected(w->w, position);
2123    return(res);
2124 }
2125
2126
2127 int
2128 do_XmListPosToBounds(
2129         int argc,
2130         char *argv[] )
2131 {
2132    char *arg0 = argv[0];
2133    wtab_t *w;
2134    Boolean res;
2135    int position;
2136    Position x;
2137    Position y;
2138    Dimension width;
2139    Dimension height;
2140    char buf[24];
2141    char * errmsg;
2142
2143    if (argc != 7)
2144    {
2145       errmsg=strdup(GETMESSAGE(15,19,
2146             "Usage: XmListPosToBounds widget position variable variable variable variable"));
2147       printerr(str_nill, errmsg, NULL);
2148       free(errmsg);
2149       return(1);
2150    }
2151
2152    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2153    {
2154       env_blank(argv[3]);
2155       env_blank(argv[4]);
2156       env_blank(argv[5]);
2157       env_blank(argv[6]);
2158       return(1);
2159    }
2160
2161    position = atoi(argv[2]);
2162
2163    res = !XmListPosToBounds(w->w, position, &x, &y, &width, &height);
2164
2165    if (res == False)
2166    {
2167       sprintf(buf, "%d", x);
2168       env_set_var(argv[3],  buf);
2169       sprintf(buf, "%d", y);
2170       env_set_var(argv[4],  buf);
2171       sprintf(buf, "%d", width);
2172       env_set_var(argv[5],  buf);
2173       sprintf(buf, "%d", height);
2174       env_set_var(argv[6],  buf);
2175    }
2176    else
2177    {
2178       env_blank(argv[3]);
2179       env_blank(argv[4]);
2180       env_blank(argv[5]);
2181       env_blank(argv[6]);
2182    }
2183    return(res);
2184 }
2185
2186
2187 static int
2188 ListSelectItem(
2189         Boolean usePosition,
2190         int argc,
2191         char *argv[] )
2192 {
2193    char *arg0 = argv[0];
2194    wtab_t *w;
2195    int i;
2196    XmString item;
2197    XrmValue fval, tval;
2198    int position = 0;
2199    Boolean notify;
2200    char * errmsg;
2201
2202    if (argc != 4)
2203    {
2204       if (usePosition)
2205       {
2206          errmsg = strdup(GETMESSAGE(15,20,
2207                          "Usage: %s widget position notifyFlag"));
2208       }
2209       else
2210       {
2211          errmsg = strdup(GETMESSAGE(15,21, "Usage: %s widget item notifyFlag"));
2212       }
2213
2214       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL, NULL, NULL,
2215                 NULL);
2216       free(errmsg);
2217       return(1);
2218    }
2219
2220    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2221       return(1);
2222
2223    if (usePosition)
2224       position = atoi(argv[2]);
2225    else
2226       item = XmStringCreateLocalized(argv[2]);
2227
2228    fval.addr = argv[3];
2229    fval.size = strlen(argv[3]);
2230    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
2231    if (tval.size != 0)
2232       notify = *((Boolean *)(tval.addr));
2233    else
2234       return(1);
2235
2236    if (usePosition)
2237       XmListSelectPos(w->w, position, notify);
2238    else
2239    {
2240       XmListSelectItem(w->w, item, notify);
2241       XmStringFree(item);
2242    }
2243
2244    return(0);
2245 }
2246
2247
2248 int
2249 do_XmListSelectItem(
2250         int argc,
2251         char *argv[] )
2252 {
2253    return(ListSelectItem(False, argc, argv));
2254 }
2255
2256
2257 int
2258 do_XmListSelectPos(
2259         int argc,
2260         char *argv[] )
2261 {
2262    return(ListSelectItem(True, argc, argv));
2263 }
2264
2265
2266 int
2267 do_XmListSetAddMode(
2268         int argc,
2269         char *argv[] )
2270 {
2271    char *arg0 = argv[0];
2272    wtab_t *w;
2273    XrmValue fval, tval;
2274    Boolean state;
2275    char * errmsg;
2276
2277    if (argc != 3)
2278    {
2279       errmsg = strdup(GETMESSAGE(15,22,
2280                       "Usage: XmListSetAddMode widget boolean"));
2281       printerr(str_nill, errmsg, NULL);
2282       free(errmsg);
2283       return(1);
2284    }
2285
2286    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2287       return(1);
2288
2289    fval.addr = argv[2];
2290    fval.size = strlen(argv[2]);
2291    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
2292    if (tval.size != 0)
2293       state = *((Boolean *)(tval.addr));
2294    else
2295       return(1);
2296
2297    XmListSetAddMode(w->w, state);
2298    return(0);
2299 }
2300
2301
2302 int
2303 do_XmListSetKbdItemPos(
2304         int argc,
2305         char *argv[] )
2306 {
2307    char *arg0 = argv[0];
2308    wtab_t *w;
2309    Boolean res;
2310    int position;
2311    char * errmsg;
2312
2313    if (argc != 3)
2314    {
2315       errmsg = strdup(GETMESSAGE(15,23,
2316                       "Usage: XmListSetKbdItemPos widget position"));
2317       printerr(str_nill, errmsg, NULL);
2318       free(errmsg);
2319       return(1);
2320    }
2321
2322    if ((w = verifyListWidget(argv[0], argv[1])) == NULL)
2323       return(1);
2324
2325    position = atoi(argv[2]);
2326
2327    res = !XmListSetKbdItemPos(w->w, position);
2328    return(res);
2329 }
2330
2331
2332 int
2333 do_XmMainWindowSetAreas(
2334         int argc,
2335         char *argv[] )
2336 {
2337    char *arg0 = argv[0];
2338    wtab_t *w[6];
2339    register int i;
2340    char * errmsg;
2341
2342    if (argc != 7)
2343    {
2344       errmsg=strdup(GETMESSAGE(15,24,
2345            "Usage: XmMainWindowSetAreas mainwindow menu command hscroll vscroll work"));
2346       printerr(str_nill, errmsg, NULL);
2347       free(errmsg);
2348       return(1);
2349    }
2350
2351    for (i = 1; i < 7; i++)
2352    {
2353       if ((argv[i][0] == '\0') ||
2354           (strcmp(argv[i], (char *)("NULL")) == 0))
2355       {
2356          w[i-1] = NULL;
2357          continue;
2358       }
2359
2360       w[i-1] = str_to_wtab(arg0, argv[i]);
2361       if (w[i-1] == NULL)
2362          continue;
2363    }
2364
2365    if (w[0] == NULL) {
2366       errmsg = strdup(GETMESSAGE(15,25, "The 'mainWindow' handle is NULL"));
2367       printerr(argv[0], errmsg, NULL);
2368       free(errmsg);
2369       return(1);
2370    }
2371
2372    if (w[0]->wclass->class != xmMainWindowWidgetClass) {
2373       errmsg = strdup(GetSharedMsg(DT_MAIN_WIN_WIDGET));
2374       printerr(arg0, errmsg, NULL);
2375       free(errmsg);
2376       return(1);
2377    }
2378
2379    XmMainWindowSetAreas(w[0]->w,
2380                         w[1] ? w[1]->w : (Widget)NULL,
2381                         w[2] ? w[2]->w : (Widget)NULL,
2382                         w[3] ? w[3]->w : (Widget)NULL,
2383                         w[4] ? w[4]->w : (Widget)NULL,
2384                         w[5] ? w[5]->w : (Widget)NULL);
2385    return(0);
2386 }
2387
2388
2389 static int
2390 GetMainWindowSeparator(
2391         int childType,
2392         int argc,
2393         char *argv[] )
2394 {
2395    char *arg0 = argv[0];
2396    wtab_t * w;
2397    XmString string;
2398    char * variable = argv[1];
2399    Widget child;
2400    classtab_t *ctab;
2401    char * errmsg;
2402
2403    if (argc != 3)
2404    {
2405       errmsg = strdup(GETMESSAGE(15,26, "Usage: %s variable mainwindow"));
2406       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL,
2407                 NULL, NULL, NULL, NULL);
2408       free(errmsg);
2409       return(1);
2410    }
2411
2412    w = str_to_wtab(arg0, argv[2]);
2413    if (w == NULL) {
2414         alt_env_set_var(variable, "");
2415         return(1);
2416    }
2417
2418    if (w->wclass->class != xmMainWindowWidgetClass) {
2419       errmsg = strdup(GetSharedMsg(DT_MAIN_WIN_WIDGET));
2420       printerr(arg0, errmsg, NULL);
2421       free(errmsg);
2422       alt_env_set_var(variable, "");
2423       return(1);
2424    }
2425
2426    if (childType == MWSep1)
2427       child = XmMainWindowSep1(w->w);
2428    else if (childType == MWSep2)
2429       child = XmMainWindowSep2(w->w);
2430    else if (childType == MWSep3)
2431       child = XmMainWindowSep3(w->w);
2432
2433    if (child == NULL)
2434    {
2435       alt_env_set_var(variable, "");
2436       return(1);
2437    }
2438
2439    w = ConvertWidgetToWtab(arg0, child);
2440
2441    alt_env_set_var(variable,  w->widid);
2442    return(0);
2443 }
2444
2445
2446 int
2447 do_XmMainWindowSep1(
2448         int argc,
2449         char *argv[] )
2450 {
2451    return(GetMainWindowSeparator(MWSep1, argc, argv));
2452 }
2453
2454
2455 int
2456 do_XmMainWindowSep2(
2457         int argc,
2458         char *argv[] )
2459 {
2460    return(GetMainWindowSeparator(MWSep2, argc, argv));
2461 }
2462
2463
2464 int
2465 do_XmMainWindowSep3(
2466         int argc,
2467         char *argv[] )
2468 {
2469    return(GetMainWindowSeparator(MWSep3, argc, argv));
2470 }
2471
2472
2473 int
2474 do_XmProcessTraversal(
2475         int argc,
2476         char *argv[] )
2477 {
2478    XrmValue f, t;
2479    wtab_t *w;
2480    char * errmsg;
2481
2482    if (argc != 3) {
2483       errmsg = strdup(GETMESSAGE(15,27,
2484                       "Usage: XmProcessTraversal widget direction"));
2485       printerr(str_nill, errmsg, NULL);
2486       free(errmsg);
2487       return(1);
2488    }
2489
2490    w = str_to_wtab(argv[0], argv[1]);
2491    if (w == NULL)
2492       return(1);
2493
2494    f.addr = argv[2];
2495    f.size = strlen(argv[2]) + 1;
2496    t.addr = NULL;
2497    t.size = 0;
2498    XtConvert(w->w, XtRString, &f, "TraversalDirection", &t);
2499
2500    if (t.size && t.addr)
2501    {
2502       int direction = ((int *)(t.addr))[0];
2503       return(!XmProcessTraversal(w->w, direction));
2504    }
2505    else
2506    {
2507       errmsg = strdup(GETMESSAGE(15,28, "Unknown traversal direction: %s"));
2508       printerrf(argv[0], errmsg, argv[2], NULL,
2509                 NULL, NULL, NULL, NULL, NULL, NULL);
2510       free(errmsg);
2511       return(1);
2512    }
2513 }
2514
2515
2516 int
2517 do_XmInternAtom(
2518         int argc,
2519         char *argv[] )
2520 {
2521    XrmValue fval, tval;
2522    Boolean onlyIfExists;
2523    char buf[24];
2524    Atom atom;
2525    Display * display;
2526    char * p;
2527    char * errmsg;
2528
2529    if (argc != 5)
2530    {
2531       errmsg = strdup(GETMESSAGE(15,29,
2532              "Usage: XmInternAtom variable display name onlyIfExists"));
2533       printerr(str_nill, errmsg, NULL);
2534       free(errmsg);
2535       return(1);
2536    }
2537
2538    display = (Display *)strtoul(argv[2], &p, 0);
2539    if (p == argv[2])
2540    {
2541       errmsg = strdup(GetSharedMsg(DT_BAD_DISPLAY));
2542       printerrf(argv[0], errmsg, argv[2], NULL, NULL, NULL, NULL, NULL,
2543                 NULL, NULL);
2544       free(errmsg);
2545       alt_env_set_var(argv[1], "");
2546       return(1);
2547    }
2548
2549    fval.addr = argv[4];
2550    fval.size = strlen(argv[4]);
2551    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
2552
2553    if (tval.size != 0)
2554       onlyIfExists = *((Boolean *)(tval.addr));
2555    else
2556    {
2557       alt_env_set_var(argv[1], "");
2558       return(1);
2559    }
2560
2561    atom = XmInternAtom (display, argv[3], onlyIfExists);
2562
2563    sprintf(buf, "%ld", atom);
2564    alt_env_set_var(argv[1],  buf);
2565    return(0);
2566 }
2567
2568
2569 /*
2570  * Simply prevents non-fatal X errors from killing the application.
2571  */
2572 static int
2573 CatchAndIgnoreXError(
2574         Display *display,
2575         XEvent *event )
2576 {
2577 }
2578
2579
2580 int
2581 do_XmGetAtomName(
2582         int argc,
2583         char *argv[] )
2584 {
2585    char *name;
2586    Atom atom;
2587    char * p;
2588    int (*oldHandler)();
2589    Display * display;
2590    char * errmsg;
2591
2592    if (argc != 4)
2593    {
2594       errmsg = strdup(GETMESSAGE(15,30,
2595                       "Usage: XmGetAtomName variable display atom"));
2596       printerr(str_nill, errmsg, NULL);
2597       free(errmsg);
2598       return(1);
2599    }
2600
2601    display = (Display *)strtoul(argv[2], &p, 0);
2602    if (p == argv[2])
2603    {
2604       errmsg = strdup(GetSharedMsg(DT_BAD_DISPLAY));
2605       printerrf(argv[0], errmsg, argv[2], NULL, NULL, NULL, NULL, NULL,
2606                 NULL, NULL);
2607       free(errmsg);
2608       alt_env_set_var(argv[1], "");
2609       return(1);
2610    }
2611
2612    atom = (Atom)strtoul(argv[3], &p, 0);
2613    if (p == argv[3])
2614    {
2615       errmsg = strdup(GETMESSAGE(15,31, "The specified atom is invalid: %s"));
2616       printerrf(argv[0], errmsg, argv[3],
2617                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2618       free(errmsg);
2619       alt_env_set_var(argv[1], "");
2620       return(1);
2621    }
2622    oldHandler = XSetErrorHandler((int(*)())CatchAndIgnoreXError);
2623    name = XmGetAtomName (display, atom);
2624    XSetErrorHandler((int(*)())oldHandler);
2625    if (name == NULL)
2626    {
2627       alt_env_set_var(argv[1], "");
2628       return(1);
2629    }
2630
2631    alt_env_set_var(argv[1],  name);
2632    XtFree(name);
2633    return(0);
2634 }
2635
2636
2637 int
2638 do_XmGetColors(
2639         int argc,
2640         char *argv[] )
2641 {
2642    wtab_t *w;
2643    char buf[24];
2644    Pixel background;
2645    Pixel foreground;
2646    Pixel topShadow;
2647    Pixel bottomShadow;
2648    Pixel select;
2649    Colormap colormap;
2650    Arg args[5];
2651    char * p;
2652    char * errmsg;
2653
2654
2655    if (argc != 7)
2656    {
2657       errmsg=strdup(GETMESSAGE(15,32,
2658           "Usage: XmGetColors widget background foreground topshadow bottomshadow select"));
2659       printerr(str_nill, errmsg, NULL);
2660       free(errmsg);
2661       return(1);
2662    }
2663
2664    w = str_to_wtab(argv[0], argv[1]);
2665    if (w == NULL)
2666    {
2667       env_blank(argv[3]);
2668       env_blank(argv[4]);
2669       env_blank(argv[5]);
2670       env_blank(argv[6]);
2671       return(1);
2672    }
2673
2674    background = strtoul(argv[2], &p, 0);
2675    if (p == argv[2])
2676    {
2677       errmsg = strdup(GETMESSAGE(15,33, "The background pixel is invalid: %s"));
2678       printerrf(argv[0], errmsg, argv[2],
2679                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2680       free(errmsg);
2681       env_blank(argv[3]);
2682       env_blank(argv[4]);
2683       env_blank(argv[5]);
2684       env_blank(argv[6]);
2685       return(1);
2686    }
2687
2688    XtSetArg (args[0], XmNcolormap,  &colormap);
2689    XtGetValues (w->w, args, 1);
2690
2691    XmGetColors (XtScreen(w->w), colormap, background, &foreground,
2692                 &topShadow, &bottomShadow, &select);
2693
2694    sprintf(buf, "0x%lx", foreground);
2695    env_set_var(argv[3],  buf);
2696    sprintf(buf, "0x%lx", topShadow);
2697    env_set_var(argv[4],  buf);
2698    sprintf(buf, "0x%lx", bottomShadow);
2699    env_set_var(argv[5],  buf);
2700    sprintf(buf, "0x%lx", select);
2701    env_set_var(argv[6],  buf);
2702    return(0);
2703 }
2704
2705
2706 int
2707 do_XmUpdateDisplay(
2708         int argc,
2709         char *argv[] )
2710 {
2711    wtab_t *w;
2712    char * p;
2713    char * errmsg;
2714
2715    if (argc != 2)
2716    {
2717       errmsg = strdup(GETMESSAGE(15,34, "Usage: XmUpdateDisplay widget"));
2718       printerr(str_nill, errmsg, NULL);
2719       free(errmsg);
2720       return(1);
2721    }
2722
2723    w = str_to_wtab(argv[0], argv[1]);
2724    if (w == NULL)
2725       return(1);
2726
2727    XmUpdateDisplay (w->w);
2728    return(0);
2729 }
2730
2731
2732 static int
2733 AddOrDeleteWMProtocols(
2734         int argc,
2735         char *argv[] )
2736 {
2737    wtab_t *w;
2738    char * p;
2739    Atom * protocolList;
2740    int i;
2741    char * errmsg;
2742
2743    if (argc < 3)
2744    {
2745       errmsg = strdup(GETMESSAGE(15,35,
2746                       "Usage: %s widget protocol [protocol ...]"));
2747       printerrf(argv[0], errmsg, argv[0],
2748                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2749       free(errmsg);
2750       return(1);
2751    }
2752
2753    w = str_to_wtab(argv[0], argv[1]);
2754    if (w == NULL)
2755       return(1);
2756
2757    protocolList = (Atom*)XtMalloc(sizeof(Atom) * (argc - 2));
2758    for (i = 2; i < argc; i++)
2759    {
2760       protocolList[i - 2] = (Atom)strtoul(argv[i], &p, 0);
2761       if (p == argv[i])
2762       {
2763          errmsg = strdup(GETMESSAGE(15,36,
2764                          "The atom specified is invalid: %s"));
2765          printerrf(argv[0], errmsg, argv[i],
2766                    NULL, NULL, NULL, NULL, NULL, NULL, NULL);
2767          free(errmsg);
2768          XtFree((char *)protocolList);
2769          return(1);
2770       }
2771    }
2772
2773    if (strcmp(argv[0], "XmAddWMProtocols") == 0)
2774       XmAddWMProtocols (w->w, protocolList, argc-2);
2775    else
2776       XmRemoveWMProtocols (w->w, protocolList, argc-2);
2777    XtFree((char *)protocolList);
2778    return(0);
2779 }
2780
2781
2782 int
2783 do_XmAddWMProtocols(
2784         int argc,
2785         char **argv )
2786 {
2787    return (AddOrDeleteWMProtocols(argc, argv));
2788 }
2789
2790
2791 int
2792 do_XmRemoveWMProtocols(
2793         int argc,
2794         char **argv )
2795 {
2796    return (AddOrDeleteWMProtocols(argc, argv));
2797 }
2798
2799
2800 int
2801 do_XmAddWMProtocolCallback(
2802         int argc,
2803         char **argv )
2804 {
2805    char * errmsg;
2806
2807    if (argc != 4)
2808    {
2809       errmsg = strdup(GETMESSAGE(15,37,
2810             "Usage: XmAddWMProtocolCallback widget protocol ksh-command"));
2811       printerr(str_nill, errmsg, NULL);
2812       free(errmsg);
2813       return(1);
2814    }
2815
2816    return(AddOneCallback(argv[0], argv[1], NULL, argv[3], argv[2]));
2817 }
2818
2819 int
2820 do_XmRemoveWMProtocolCallback(
2821         int argc,
2822         char **argv )
2823 {
2824    char * errmsg;
2825
2826    if (argc != 4)
2827    {
2828       errmsg = strdup(GETMESSAGE(15,38,
2829           "Usage: XmRemoveWMProtocolCallback widget protocol ksh-command"));
2830       printerr(str_nill, errmsg, NULL);
2831       free(errmsg);
2832       return(1);
2833    }
2834
2835    return(RemoveOneCallback (argv[0], argv[1], NULL, argv[3], argv[2], NULL));
2836 }
2837
2838
2839 int
2840 do_XmMenuPosition(
2841         int argc,
2842         char *argv[] )
2843 {
2844    wtab_t *w;
2845    char * p;
2846    XEvent * event;
2847    char * errmsg;
2848
2849    if (argc != 3)
2850    {
2851       errmsg = strdup(GETMESSAGE(15,39, "Usage: XmMenuPosition menu event"));
2852       printerr(str_nill, errmsg, NULL);
2853       free(errmsg);
2854       return(1);
2855    }
2856
2857    w = str_to_wtab(argv[0], argv[1]);
2858    if (w == NULL)
2859       return(1);
2860
2861    event = (XEvent *)strtoul(argv[2], &p, 0);
2862    if (p == argv[2])
2863    {
2864       errmsg = strdup(GETMESSAGE(15,40, "The specified event is invalid: %s"));
2865       printerrf(argv[0], errmsg, argv[2], NULL,
2866                 NULL, NULL, NULL, NULL, NULL, NULL);
2867       free(errmsg);
2868       return(1);
2869    }
2870
2871    XmMenuPosition (w->w, (XButtonPressedEvent *)event);
2872    return(0);
2873 }
2874
2875
2876 int
2877 do_XmCommandAppendValue(
2878         int argc,
2879         char *argv[] )
2880 {
2881    char *arg0 = argv[0];
2882    wtab_t * w;
2883    XmString string;
2884    char * errmsg;
2885
2886    if (argc != 3)
2887    {
2888       errmsg = strdup(GETMESSAGE(15,41,
2889              "Usage: XmCommandAppendValue commandWidget string"));
2890       printerr(str_nill, errmsg, NULL);
2891       free(errmsg);
2892       return(1);
2893    }
2894
2895    w = str_to_wtab(arg0, argv[1]);
2896    if (w == NULL)
2897       return(1);
2898
2899    if (w->wclass->class != xmCommandWidgetClass) {
2900       errmsg = strdup(GetSharedMsg(DT_CMD_WIDGET));
2901       printerr(arg0, errmsg, NULL);
2902       free(errmsg);
2903       return(1);
2904    }
2905
2906    string = XmStringCreateLocalized(argv[2]);
2907    XmCommandAppendValue(w->w, string);
2908    XmStringFree(string);
2909
2910    return(0);
2911 }
2912
2913
2914 int
2915 do_XmCommandError(
2916         int argc,
2917         char *argv[] )
2918 {
2919    char *arg0 = argv[0];
2920    wtab_t * w;
2921    XmString string;
2922    char * errmsg;
2923
2924    if (argc != 3)
2925    {
2926       errmsg = strdup(GETMESSAGE(15,42,
2927           "Usage: XmCommandError commandWidget errorMessage"));
2928       printerr(str_nill, errmsg, NULL);
2929       free(errmsg);
2930       return(1);
2931    }
2932
2933    w = str_to_wtab(arg0, argv[1]);
2934    if (w == NULL)
2935       return(1);
2936
2937    if (w->wclass->class != xmCommandWidgetClass) {
2938       errmsg = strdup(GetSharedMsg(DT_CMD_WIDGET));
2939       printerr(arg0, errmsg, NULL);
2940       free(errmsg);
2941       return(1);
2942    }
2943
2944    string = XmStringCreateLocalized(argv[2]);
2945    XmCommandError(w->w, string);
2946    XmStringFree(string);
2947
2948    return(0);
2949 }
2950
2951
2952 int
2953 do_XmCommandSetValue(
2954         int argc,
2955         char *argv[] )
2956 {
2957    char *arg0 = argv[0];
2958    wtab_t * w;
2959    XmString string;
2960    char * errmsg;
2961
2962    if (argc != 3)
2963    {
2964       errmsg = strdup(GETMESSAGE(15,43,
2965               "Usage: XmCommandSetValue commandWidget command"));
2966       printerr(str_nill, errmsg, NULL);
2967       free(errmsg);
2968       return(1);
2969    }
2970
2971    w = str_to_wtab(arg0, argv[1]);
2972    if (w == NULL)
2973       return(1);
2974
2975    if (w->wclass->class != xmCommandWidgetClass) {
2976       errmsg = strdup(GetSharedMsg(DT_CMD_WIDGET));
2977       printerr(arg0, errmsg, NULL);
2978       free(errmsg);
2979       return(1);
2980    }
2981
2982    string = XmStringCreateLocalized(argv[2]);
2983    XmCommandSetValue(w->w, string);
2984    XmStringFree(string);
2985
2986    return(0);
2987 }
2988
2989
2990 int
2991 do_XmCommandGetChild(
2992         int argc,
2993         char *argv[] )
2994 {
2995    char *arg0 = argv[0];
2996    wtab_t * w;
2997    XmString string;
2998    char * variable = argv[1];
2999    int childType;
3000    XrmValue f, t;
3001    Widget child;
3002    classtab_t *ctab;
3003    char * errmsg;
3004
3005    if (argc != 4)
3006    {
3007       errmsg = strdup(GETMESSAGE(15,44,
3008              "Usage: XmCommandGetChild variable commandWidget child"));
3009       printerr(str_nill, errmsg, NULL);
3010       free(errmsg);
3011       return(1);
3012    }
3013
3014    w = str_to_wtab(arg0, argv[2]);
3015    if (w == NULL) {
3016         alt_env_set_var(variable, "");
3017         return(1);
3018    }
3019
3020    if (w->wclass->class != xmCommandWidgetClass) {
3021       errmsg = strdup(GetSharedMsg(DT_CMD_WIDGET));
3022       printerr(arg0, errmsg, NULL);
3023       free(errmsg);
3024       alt_env_set_var(variable, "");
3025       return(1);
3026    }
3027
3028    f.addr = argv[3];
3029    f.size = strlen(argv[3]) + 1;
3030    t.addr = NULL;
3031    t.size = 0;
3032    XtConvert(w->w, XtRString, &f, "CommandChildType", &t);
3033
3034    if (t.size && t.addr)
3035       childType = *((int *)t.addr);
3036    else
3037    {
3038       errmsg = strdup(GetSharedMsg(DT_UNKNOWN_CHILD_TYPE));
3039       printerrf(argv[0], errmsg, argv[2], NULL, NULL,
3040                 NULL, NULL, NULL, NULL, NULL);
3041       free(errmsg);
3042       alt_env_set_var(variable, "");
3043       return(1);
3044    }
3045
3046    child = XmCommandGetChild(w->w, childType);
3047
3048    if (child == NULL)
3049    {
3050       alt_env_set_var(variable, "");
3051       return(1);
3052    }
3053
3054    w = ConvertWidgetToWtab(arg0, child);
3055
3056    alt_env_set_var(variable,  w->widid);
3057    return(0);
3058 }
3059
3060
3061 int
3062 do_XmMessageBoxGetChild(
3063         int argc,
3064         char *argv[] )
3065 {
3066    char *arg0 = argv[0];
3067    wtab_t * w;
3068    XmString string;
3069    char * variable = argv[1];
3070    int childType;
3071    XrmValue f, t;
3072    Widget child;
3073    classtab_t *ctab;
3074    char * errmsg;
3075
3076    if (argc != 4)
3077    {
3078       errmsg = strdup(GETMESSAGE(15,45,
3079             "Usage: XmMessageBoxGetChild variable commandWidget child"));
3080       printerr(str_nill, errmsg, NULL);
3081       free(errmsg);
3082       return(1);
3083    }
3084
3085    w = str_to_wtab(arg0, argv[2]);
3086    if (w == NULL) {
3087         alt_env_set_var(variable, "");
3088         return(1);
3089    }
3090
3091    if (w->wclass->class != xmMessageBoxWidgetClass) {
3092       errmsg = strdup(GETMESSAGE(15,46,
3093                       "The widget must be a 'messageBox' widget"));
3094       printerr(arg0, errmsg, NULL);
3095       free(errmsg);
3096       alt_env_set_var(variable, "");
3097       return(1);
3098    }
3099
3100    f.addr = argv[3];
3101    f.size = strlen(argv[3]) + 1;
3102    t.addr = NULL;
3103    t.size = 0;
3104    XtConvert(w->w, XtRString, &f, "MessageBoxChildType", &t);
3105
3106    if (t.size && t.addr)
3107       childType = *((int *)t.addr);
3108    else
3109    {
3110       errmsg = strdup(GetSharedMsg(DT_UNKNOWN_CHILD_TYPE));
3111       printerrf(argv[0], errmsg, argv[2], NULL, NULL, NULL,
3112                 NULL, NULL, NULL, NULL);
3113       free(errmsg);
3114       alt_env_set_var(variable, "");
3115       return(1);
3116    }
3117
3118    child = XmMessageBoxGetChild(w->w, childType);
3119
3120    if (child == NULL)
3121    {
3122       alt_env_set_var(variable, "");
3123       return(1);
3124    }
3125
3126    w = ConvertWidgetToWtab(arg0, child);
3127
3128    alt_env_set_var(variable,  w->widid);
3129    return(0);
3130 }
3131
3132
3133 int
3134 do_XmFileSelectionBoxGetChild(
3135         int argc,
3136         char *argv[] )
3137 {
3138    char *arg0 = argv[0];
3139    wtab_t * w;
3140    XmString string;
3141    char * variable = argv[1];
3142    int childType;
3143    XrmValue f, t;
3144    Widget child;
3145    classtab_t *ctab;
3146    char * errmsg;
3147
3148    if (argc != 4)
3149    {
3150       errmsg = strdup(GETMESSAGE(15,47,
3151              "Usage: XmFileSelectionBoxGetChild variable widget child"));
3152       printerr(str_nill, errmsg, NULL);
3153       free(errmsg);
3154       return(1);
3155    }
3156
3157    w = str_to_wtab(arg0, argv[2]);
3158    if (w == NULL) {
3159       alt_env_set_var(variable, "");
3160       return(1);
3161    }
3162
3163    if (w->wclass->class != xmFileSelectionBoxWidgetClass) {
3164       errmsg = strdup(GETMESSAGE(15,48,
3165             "The widget must be a 'file selection box' widget"));
3166       printerr(arg0, errmsg, NULL);
3167       free(errmsg);
3168       alt_env_set_var(variable, "");
3169       return(1);
3170    }
3171
3172    f.addr = argv[3];
3173    f.size = strlen(argv[3]) + 1;
3174    t.addr = NULL;
3175    t.size = 0;
3176    XtConvert(w->w, XtRString, &f, "FileSelChildType", &t);
3177
3178    if (t.size && t.addr)
3179       childType = *((int *)t.addr);
3180    else
3181    {
3182       errmsg = strdup(GetSharedMsg(DT_UNKNOWN_CHILD_TYPE));
3183       printerrf(argv[0], errmsg, argv[2], NULL, NULL, NULL,
3184                 NULL, NULL, NULL, NULL);
3185       free(errmsg);
3186       alt_env_set_var(variable, "");
3187       return(1);
3188    }
3189
3190    child = XmFileSelectionBoxGetChild(w->w, childType);
3191
3192    if (child == NULL)
3193    {
3194       alt_env_set_var(variable, "");
3195       return(1);
3196    }
3197
3198    w = ConvertWidgetToWtab(arg0, child);
3199
3200    alt_env_set_var(variable,  w->widid);
3201    return(0);
3202 }
3203
3204
3205 int
3206 do_XmSelectionBoxGetChild(
3207         int argc,
3208         char *argv[] )
3209 {
3210    char *arg0 = argv[0];
3211    wtab_t * w;
3212    XmString string;
3213    char * variable = argv[1];
3214    int childType;
3215    XrmValue f, t;
3216    Widget child;
3217    classtab_t *ctab;
3218    char * errmsg;
3219
3220    if (argc != 4)
3221    {
3222       errmsg = strdup(GETMESSAGE(15,49,
3223               "Usage: XmSelectionBoxGetChild variable widget child"));
3224       printerr(str_nill, errmsg, NULL);
3225       free(errmsg);
3226       return(1);
3227    }
3228
3229    w = str_to_wtab(arg0, argv[2]);
3230    if (w == NULL) {
3231       alt_env_set_var(variable, "");
3232       return(1);
3233    }
3234
3235    if (w->wclass->class != xmSelectionBoxWidgetClass) {
3236       errmsg = strdup(GETMESSAGE(15,50,
3237              "The widget must be a 'selection box' widget"));
3238       printerr(arg0, errmsg, NULL);
3239       free(errmsg);
3240       alt_env_set_var(variable, "");
3241       return(1);
3242    }
3243
3244    f.addr = argv[3];
3245    f.size = strlen(argv[3]) + 1;
3246    t.addr = NULL;
3247    t.size = 0;
3248    XtConvert(w->w, XtRString, &f, "SelBoxChildType", &t);
3249
3250    if (t.size && t.addr)
3251       childType = *((int *)t.addr);
3252    else
3253    {
3254       errmsg = strdup(GetSharedMsg(DT_UNKNOWN_CHILD_TYPE));
3255       printerrf(argv[0], errmsg, argv[2], NULL, NULL, NULL,
3256                 NULL, NULL, NULL, NULL);
3257       free(errmsg);
3258       alt_env_set_var(variable, "");
3259       return(1);
3260    }
3261
3262    child = XmSelectionBoxGetChild(w->w, childType);
3263
3264    if (child == NULL)
3265    {
3266       alt_env_set_var(variable, "");
3267       return(1);
3268    }
3269
3270    w = ConvertWidgetToWtab(arg0, child);
3271
3272    alt_env_set_var(variable,  w->widid);
3273    return(0);
3274 }
3275
3276 int
3277 do_XmIsTraversable(
3278         int argc,
3279         char *argv[] )
3280 {
3281         return(do_single_widget_test_func((int(*)())XmIsTraversable, argc,
3282                                           argv));
3283 }
3284
3285
3286 int
3287 do_XmScaleGetValue(
3288         int argc,
3289         char *argv[] )
3290 {
3291    char *arg0 = argv[0];
3292    wtab_t * w;
3293    char * variable = argv[2];
3294    char buf[25];
3295    int scaleValue;
3296    char * errmsg;
3297
3298    if (argc != 3)
3299    {
3300       errmsg = strdup(GETMESSAGE(15,51,
3301                       "Usage: XmScaleGetValue scaleWidget variable"));
3302       printerr(str_nill, errmsg, NULL);
3303       free(errmsg);
3304       return(1);
3305    }
3306
3307    w = str_to_wtab(arg0, argv[1]);
3308    if (w == NULL)
3309    {
3310       env_blank(variable);
3311       return(1);
3312    }
3313
3314    if (w->wclass->class != xmScaleWidgetClass) {
3315       errmsg = strdup(GetSharedMsg(DT_SCALE_WIDGET));
3316       printerr(arg0, errmsg, NULL);
3317       free(errmsg);
3318       env_blank(variable);
3319       return(1);
3320    }
3321
3322    XmScaleGetValue(w->w, &scaleValue);
3323    sprintf(buf, "%d", scaleValue);
3324    env_set_var(variable,  buf);
3325    return(0);
3326 }
3327
3328
3329 int
3330 do_XmScaleSetValue(
3331         int argc,
3332         char *argv[] )
3333 {
3334    char *arg0 = argv[0];
3335    wtab_t * w;
3336    char buf[25];
3337    int scaleValue;
3338    char * p;
3339    char * errmsg;
3340
3341    if (argc != 3)
3342    {
3343       errmsg = strdup(GETMESSAGE(15,52,
3344                       "Usage: XmScaleSetValue scaleWidget value"));
3345       printerr(str_nill, errmsg, NULL);
3346       free(errmsg);
3347       return(1);
3348    }
3349
3350    w = str_to_wtab(arg0, argv[1]);
3351    if (w == NULL)
3352         return(1);
3353
3354    if (w->wclass->class != xmScaleWidgetClass) {
3355       errmsg = strdup(GetSharedMsg(DT_SCALE_WIDGET));
3356       printerr(arg0, errmsg, NULL);
3357       free(errmsg);
3358       return(1);
3359    }
3360
3361    scaleValue = strtol(argv[2], &p, 0);
3362    if (p == argv[2])
3363    {
3364       errmsg = strdup(GETMESSAGE(15,53,
3365                       "The scale value specified is invalid: %s"));
3366       printerrf(arg0, errmsg, argv[2],
3367                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3368       free(errmsg);
3369       return(1);
3370    }
3371    XmScaleSetValue(w->w, scaleValue);
3372    return(0);
3373 }
3374
3375
3376 int
3377 do_XmScrollBarGetValues(
3378         int argc,
3379         char *argv[] )
3380 {
3381    char *arg0 = argv[0];
3382    wtab_t * w;
3383    char buf[25];
3384    int value;
3385    int sliderSize;
3386    int increment;
3387    int pageIncrement;
3388    Boolean notify;
3389    char * errmsg;
3390
3391    if (argc != 6)
3392    {
3393       errmsg=strdup(GETMESSAGE(15,54,
3394            "Usage: XmScrollBarGetValues scrollbar variable variable variable variable"));
3395       printerr(str_nill, errmsg, NULL);
3396       free(errmsg);
3397       return(1);
3398    }
3399
3400    w = str_to_wtab(arg0, argv[1]);
3401    if (w == NULL)
3402    {
3403       env_blank(argv[2]);
3404       env_blank(argv[3]);
3405       env_blank(argv[4]);
3406       env_blank(argv[5]);
3407       return(1);
3408    }
3409
3410    if (w->wclass->class != xmScrollBarWidgetClass) {
3411       errmsg = strdup(GetSharedMsg(DT_SCROLLBAR_WIDGET));
3412       printerr(arg0, errmsg, NULL);
3413       free(errmsg);
3414       env_blank(argv[2]);
3415       env_blank(argv[3]);
3416       env_blank(argv[4]);
3417       env_blank(argv[5]);
3418       return(1);
3419    }
3420
3421    XmScrollBarGetValues(w->w, &value, &sliderSize, &increment, &pageIncrement);
3422    sprintf(buf, "%d", value);
3423    env_set_var(argv[2],  buf);
3424    sprintf(buf, "%d", sliderSize);
3425    env_set_var(argv[3],  buf);
3426    sprintf(buf, "%d", increment);
3427    env_set_var(argv[4],  buf);
3428    sprintf(buf, "%d", pageIncrement);
3429    env_set_var(argv[5],  buf);
3430    return(0);
3431 }
3432
3433
3434 int
3435 do_XmScrollBarSetValues(
3436         int argc,
3437         char *argv[] )
3438 {
3439    char *arg0 = argv[0];
3440    wtab_t * w;
3441    char buf[25];
3442    int value;
3443    int sliderSize;
3444    int increment;
3445    int pageIncrement;
3446    Boolean notify;
3447    char * p;
3448    XrmValue fval, tval;
3449    char * errmsg;
3450
3451    if (argc != 7)
3452    {
3453       errmsg=strdup(GETMESSAGE(15,55,
3454            "Usage: XmScrollBarSetValues scrollbar value sliderSize increment pageIncrement notify"));
3455       printerr(str_nill, errmsg, NULL);
3456       free(errmsg);
3457       return(1);
3458    }
3459
3460    w = str_to_wtab(arg0, argv[1]);
3461    if (w == NULL)
3462         return(1);
3463
3464    if (w->wclass->class != xmScrollBarWidgetClass) {
3465       errmsg = strdup(GetSharedMsg(DT_SCROLLBAR_WIDGET));
3466       printerr(arg0, errmsg, NULL);
3467       free(errmsg);
3468       return(1);
3469    }
3470
3471    value = strtol(argv[2], &p, 0);
3472    if (p == argv[2])
3473    {
3474       errmsg = strdup(GETMESSAGE(15,56, "The value specified is invalid: %s"));
3475       printerrf(arg0, errmsg, argv[2], NULL,
3476                 NULL, NULL, NULL, NULL, NULL, NULL);
3477       free(errmsg);
3478       return(1);
3479    }
3480
3481    sliderSize = strtoul(argv[3], &p, 0);
3482    if (p == argv[3])
3483    {
3484       errmsg = strdup(GETMESSAGE(15,57,
3485                       "The slider size specified is invalid: %s"));
3486       printerrf(arg0, errmsg, argv[3],
3487                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3488       free(errmsg);
3489       return(1);
3490    }
3491
3492    increment = strtoul(argv[4], &p, 0);
3493    if (p == argv[4])
3494    {
3495       errmsg = strdup(GETMESSAGE(15,58,
3496                       "The increment specified is invalid: %s"));
3497       printerrf(arg0, errmsg, argv[4],
3498                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3499       free(errmsg);
3500       return(1);
3501    }
3502
3503    pageIncrement = strtoul(argv[5], &p, 0);
3504    if (p == argv[5])
3505    {
3506       errmsg = strdup(GETMESSAGE(15,59,
3507                       "The page increment specified is invalid: %s"));
3508       printerrf(arg0, errmsg, argv[5],
3509                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
3510       free(errmsg);
3511       return(1);
3512    }
3513
3514    fval.addr = argv[6];
3515    fval.size = strlen(argv[6]);
3516    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
3517    if (tval.size != 0)
3518       notify = *((Boolean *)(tval.addr));
3519    else
3520       return(1);
3521
3522    XmScrollBarSetValues(w->w, value, sliderSize, increment, pageIncrement,
3523                         notify);
3524    return(0);
3525 }
3526
3527
3528 int
3529 do_XmScrollVisible(
3530         int argc,
3531         char *argv[] )
3532 {
3533    char *arg0 = argv[0];
3534    wtab_t * w;
3535    wtab_t * w2;
3536    char buf[25];
3537    Dimension lrMargin;
3538    Dimension tbMargin;
3539    char * p;
3540    char * errmsg;
3541
3542    if (argc != 5)
3543    {
3544       errmsg=strdup(GETMESSAGE(15,60,
3545         "Usage: XmScrollVisible scrolledWin widget leftRightMargin topBottomMargin"));
3546       printerr(str_nill, errmsg, NULL);
3547       free(errmsg);
3548       return(1);
3549    }
3550
3551    w = str_to_wtab(arg0, argv[1]);
3552    if (w == NULL)
3553         return(1);
3554
3555    if (w->wclass->class != xmScrolledWindowWidgetClass) {
3556       errmsg = strdup(GETMESSAGE(15,61,
3557              "The widget must be a 'scrolledWindow' widget"));
3558       printerr(arg0, errmsg, NULL);
3559       free(errmsg);
3560       return(1);
3561    }
3562
3563    w2 = str_to_wtab(arg0, argv[2]);
3564    if (w2 == NULL)
3565    {
3566       errmsg = strdup(GETMESSAGE(15,62,
3567               "The widget to be made visible does not exist."));
3568       printerr(arg0, errmsg, NULL);
3569       free(errmsg);
3570       return(1);
3571    }
3572
3573    lrMargin = strtol(argv[3], &p, 0);
3574    if (p == argv[3])
3575    {
3576       errmsg = strdup(GETMESSAGE(15,63,
3577             "The left/right margin specified is invalid: %s"));
3578       printerrf(arg0, errmsg, argv[3], NULL, NULL, NULL, NULL, NULL, NULL,
3579                 NULL);
3580       free(errmsg);
3581       return(1);
3582    }
3583
3584    tbMargin = strtoul(argv[4], &p, 0);
3585    if (p == argv[4])
3586    {
3587       errmsg = strdup(GETMESSAGE(15,64,
3588              "The top/bottom margin specified is invalid: %s"));
3589       printerrf(arg0, errmsg, argv[4], NULL, NULL, NULL, NULL, NULL, NULL,
3590                 NULL);
3591       free(errmsg);
3592       return(1);
3593    }
3594
3595    XmScrollVisible(w->w, w2->w, lrMargin, tbMargin);
3596    return(0);
3597 }
3598
3599
3600 static int
3601 GetToggleState(
3602         int argc,
3603         char *argv[] )
3604 {
3605    char *arg0 = argv[0];
3606    wtab_t * w;
3607    char * errmsg;
3608
3609    if (argc != 2)
3610    {
3611       errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET));
3612       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL,
3613                 NULL, NULL, NULL);
3614       free(errmsg);
3615       return(1);
3616    }
3617
3618    w = str_to_wtab(arg0, argv[1]);
3619    if (w == NULL)
3620         return(1);
3621
3622    if ((w->wclass->class != xmToggleButtonWidgetClass) &&
3623        (w->wclass->class != xmToggleButtonGadgetClass))
3624    {
3625       errmsg = strdup(GetSharedMsg(DT_TOGGLE_WIDGET));
3626       printerr(arg0, errmsg, NULL);
3627       free(errmsg);
3628       return(1);
3629    }
3630
3631    return(do_single_widget_test_func((int(*)())XmToggleButtonGetState, argc,
3632                                      argv));
3633 }
3634
3635
3636 int
3637 do_XmToggleButtonGetState(
3638         int argc,
3639         char *argv[] )
3640 {
3641    return (GetToggleState(argc, argv));
3642 }
3643
3644
3645 int
3646 do_XmToggleButtonGadgetGetState(
3647         int argc,
3648         char *argv[] )
3649 {
3650    return (GetToggleState(argc, argv));
3651 }
3652
3653
3654 static int
3655 SetToggleState(
3656         int argc,
3657         char *argv[] )
3658 {
3659    char *arg0 = argv[0];
3660    wtab_t * w;
3661    XrmValue fval, tval;
3662    Boolean state;
3663    Boolean notify;
3664    char * errmsg;
3665
3666    if (argc != 4)
3667    {
3668       errmsg = strdup(GETMESSAGE(15,65, "Usage: %s widget state notify"));
3669       printerrf(str_nill, errmsg, arg0, NULL, NULL,
3670                 NULL, NULL, NULL, NULL, NULL);
3671       free(errmsg);
3672       return(1);
3673    }
3674
3675    w = str_to_wtab(arg0, argv[1]);
3676    if (w == NULL)
3677         return(1);
3678
3679    if ((w->wclass->class != xmToggleButtonWidgetClass) &&
3680        (w->wclass->class != xmToggleButtonGadgetClass))
3681    {
3682       errmsg = strdup(GetSharedMsg(DT_TOGGLE_WIDGET));
3683       printerr(arg0, errmsg, NULL);
3684       free(errmsg);
3685       return(1);
3686    }
3687
3688    fval.addr = argv[2];
3689    fval.size = strlen(argv[2]);
3690    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
3691    if (tval.size != 0)
3692       state = *((Boolean *)(tval.addr));
3693    else
3694       return(1);
3695
3696    fval.addr = argv[3];
3697    fval.size = strlen(argv[3]);
3698    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
3699    if (tval.size != 0)
3700       notify = *((Boolean *)(tval.addr));
3701    else
3702       return(1);
3703
3704    XmToggleButtonSetState(w->w, state, notify);
3705    return(0);
3706 }
3707
3708
3709 int
3710 do_XmToggleButtonSetState(
3711         int argc,
3712         char *argv[] )
3713 {
3714    return (SetToggleState(argc, argv));
3715 }
3716
3717 int
3718 do_XmToggleButtonGadgetSetState(
3719         int argc,
3720         char *argv[] )
3721 {
3722    return (SetToggleState(argc, argv));
3723 }
3724
3725
3726 int
3727 do_catopen(
3728         int argc,
3729         char **argv )
3730 {
3731    int * lockedFds;
3732    char * arg0 = argv[0];
3733    char * var = argv[1];
3734    char * catName = argv[2];
3735    char buf[10];
3736    char * altCatName;
3737    char * ptr;
3738    nl_catd nlmsg_fd = (nl_catd)-1;
3739    char * errmsg;
3740 #if defined(SVR4) || defined (_AIX) || defined(sco) || defined(DEC)
3741    char * nextMatch;
3742 #endif
3743
3744    if (argc != 3)
3745    {
3746       errmsg = strdup(GETMESSAGE(15,66, "Usage: catopen variable catName"));
3747       printerr(str_nill, errmsg, NULL);
3748       free(errmsg);
3749       return(1);
3750    }
3751
3752    lockedFds = LockKshFileDescriptors();
3753
3754    if ((nlmsg_fd = catopen(catName, 0)) == (nl_catd)-1)
3755    {
3756       /*
3757        * Try several other formats supported by the various
3758        * architectures; i.e. if the catName ends in ".cat",
3759        * then try removing that part, or if the catName does
3760        * not end in ".cat", then try adding it.
3761        */
3762
3763       altCatName = XtMalloc(strlen(catName) + 10);
3764 #if defined(SVR4) || defined (_AIX) || defined(sco) || defined(DEC)
3765       /* These platforms don't have strrstr() */
3766       ptr = NULL;
3767       nextMatch = catName;
3768       while (nextMatch = strstr(nextMatch, ".cat"))
3769       {
3770          ptr = nextMatch;
3771          nextMatch++;
3772       }
3773 #else
3774       ptr = (char *)strrstr(catName, ".cat");
3775 #endif
3776       if (ptr && (strlen(ptr) == 4))
3777       {
3778          /* Strip off the ".cat", and try again */
3779          *ptr = '\0';
3780          strcpy(altCatName, catName);
3781          *ptr = '.';
3782       }
3783       else
3784       {
3785          /* Add the ".cat", and try again */
3786          strcpy(altCatName, catName);
3787          strcat(altCatName, ".cat");
3788       }
3789       nlmsg_fd = catopen(altCatName, 0);
3790       XtFree(altCatName);
3791    }
3792    UnlockKshFileDescriptors(lockedFds);
3793
3794    sprintf(buf, "%ld", (long)nlmsg_fd);
3795    alt_env_set_var(var,  buf);
3796    return(0);
3797 }
3798
3799 int
3800 do_catclose(
3801         int argc,
3802         char **argv )
3803 {
3804    char * arg0 = argv[0];
3805    char * catId = argv[1];
3806    nl_catd id;
3807    long long_id;
3808    char * errmsg;
3809
3810    if (argc != 2)
3811    {
3812       errmsg = strdup(GETMESSAGE(15,67, "Usage: catclose catId"));
3813       printerr(str_nill, errmsg, NULL);
3814       free(errmsg);
3815       return(1);
3816    }
3817
3818    sscanf(catId, "%ld", &long_id);
3819    id = (nl_catd)long_id;
3820    catclose(id);
3821    return(0);
3822 }
3823
3824 int
3825 do_catgets(
3826         int argc,
3827         char **argv )
3828 {
3829    char * arg0 = argv[0];
3830    char * variable = argv[1];
3831    char * catId = argv[2];
3832    char * setNum = argv[3];
3833    char * msgNum = argv[4];
3834    char * dftMsg = argv[5];
3835    char * msg;
3836    nl_catd id;
3837    long long_id;
3838    int setNumVal;
3839    int msgNumVal;
3840    char * errmsg;
3841
3842    if (argc != 6)
3843    {
3844       errmsg = strdup(GETMESSAGE(15,68,
3845              "Usage: catgets variable catId setNum msgNum dftMsg"));
3846       printerr(str_nill, errmsg, NULL);
3847       free(errmsg);
3848       return(1);
3849    }
3850
3851    sscanf(catId, "%ld", &long_id);
3852    id = (nl_catd)long_id;
3853    sscanf(setNum, "%d", &setNumVal);
3854    sscanf(msgNum, "%d", &msgNumVal);
3855    msg = catgets(id, setNumVal, msgNumVal, dftMsg);
3856    alt_env_set_var(variable, msg);
3857    return(0);
3858 }
3859
3860
3861 static wtab_t *
3862 verifyTextWidget(
3863         char *cmd,
3864         char *widget )
3865 {
3866    wtab_t *w;
3867    char * errmsg;
3868
3869    if ((w = str_to_wtab(cmd, widget)) == NULL)
3870       return(NULL);
3871
3872    if ((w->wclass->class != xmTextWidgetClass) &&
3873        (w->wclass->class != xmTextFieldWidgetClass))
3874    {
3875       errmsg = strdup(GETMESSAGE(15,69,
3876              "The widget must be a 'text' or 'textField' widget"));
3877       printerr(cmd, errmsg, NULL);
3878       free(errmsg);
3879       return(NULL);
3880    }
3881
3882    return(w);
3883 }
3884
3885
3886 static int
3887 Text_Widget(
3888         Boolean (*func)(),
3889         Boolean returnBoolean,
3890         int argc,
3891         char *argv[] )
3892 {
3893    char *arg0 = argv[0];
3894    wtab_t *w;
3895    Boolean result;
3896    char * errmsg;
3897
3898    if (argc != 2)
3899    {
3900       errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET));
3901       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL, NULL, NULL,
3902                 NULL, NULL);
3903       free(errmsg);
3904       return(1);
3905    }
3906
3907    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
3908       return(1);
3909
3910    result = (*func) (w->w);
3911
3912    if (returnBoolean)
3913       return(!result);
3914    else
3915       return(0);
3916 }
3917
3918
3919 int
3920 do_XmTextDisableRedisplay(
3921         int argc,
3922         char *argv[] )
3923 {
3924    return (Text_Widget((Boolean (*)())XmTextDisableRedisplay, False, argc,
3925            argv));
3926 }
3927
3928
3929 int
3930 do_XmTextEnableRedisplay(
3931         int argc,
3932         char *argv[] )
3933 {
3934    return (Text_Widget((Boolean (*)())XmTextEnableRedisplay, False, argc,
3935            argv));
3936 }
3937
3938
3939 int
3940 do_XmTextPaste(
3941         int argc,
3942         char *argv[] )
3943 {
3944    return (Text_Widget(XmTextPaste, True, argc, argv));
3945 }
3946
3947
3948 int
3949 do_XmTextGetEditable(
3950         int argc,
3951         char *argv[] )
3952 {
3953    return (Text_Widget(XmTextGetEditable, True, argc, argv));
3954 }
3955
3956
3957 int
3958 do_XmTextRemove(
3959         int argc,
3960         char *argv[] )
3961 {
3962    return (Text_Widget(XmTextRemove, True, argc, argv));
3963 }
3964
3965
3966 static int
3967 Text_VarAndWidget(
3968         int (*func)(),
3969         Boolean varIsString,
3970         int argc,
3971         char *argv[] )
3972 {
3973    char *arg0 = argv[0];
3974    wtab_t *w;
3975    int result;
3976    char * string;
3977    char buf[10];
3978    char * errmsg;
3979
3980    if (argc != 3)
3981    {
3982       errmsg = strdup(GETMESSAGE(15,70, "Usage: %s variable widget"));
3983       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL,
3984                 NULL, NULL, NULL, NULL);
3985       free(errmsg);
3986       return(1);
3987    }
3988
3989    if ((w = verifyTextWidget(argv[0], argv[2])) == NULL)
3990    {
3991       alt_env_set_var(argv[1], "");
3992       return(1);
3993    }
3994
3995    if (varIsString)
3996    {
3997       string = (char *)(*func) (w->w);
3998       alt_env_set_var(argv[1],  string);
3999       XtFree(string);
4000       return(0);
4001    }
4002    else
4003    {
4004       result = (*func) (w->w);
4005       sprintf(buf, "%d", result);
4006       alt_env_set_var(argv[1],  buf);
4007       return(0);
4008    }
4009 }
4010
4011
4012 int
4013 do_XmTextGetTopCharacter(
4014         int argc,
4015         char *argv[] )
4016 {
4017    return (Text_VarAndWidget((int (*)())XmTextGetTopCharacter, False, argc,
4018            argv));
4019 }
4020
4021
4022 int
4023 do_XmTextGetBaseline(
4024         int argc,
4025         char *argv[] )
4026 {
4027    return (Text_VarAndWidget(XmTextGetBaseline, False, argc, argv));
4028 }
4029
4030
4031 int
4032 do_XmTextGetInsertionPosition(
4033         int argc,
4034         char *argv[] )
4035 {
4036    return (Text_VarAndWidget((int (*)())XmTextGetInsertionPosition, False,
4037            argc, argv));
4038 }
4039
4040
4041 int
4042 do_XmTextGetLastPosition(
4043         int argc,
4044         char *argv[] )
4045 {
4046    return (Text_VarAndWidget((int (*)())XmTextGetLastPosition, False, argc,
4047                              argv));
4048 }
4049
4050
4051 int
4052 do_XmTextGetMaxLength(
4053         int argc,
4054         char *argv[] )
4055 {
4056    return (Text_VarAndWidget(XmTextGetMaxLength, False, argc, argv));
4057 }
4058
4059
4060 int
4061 do_XmTextGetSelection(
4062         int argc,
4063         char *argv[] )
4064 {
4065    return (Text_VarAndWidget((int (*)())XmTextGetSelection, True, argc, argv));
4066 }
4067
4068
4069 int
4070 do_XmTextGetString(
4071         int argc,
4072         char *argv[] )
4073 {
4074    return (Text_VarAndWidget((int (*)())XmTextGetString, True, argc, argv));
4075 }
4076
4077
4078 static int
4079 Text_WidgetAndBoolean(
4080         void (*func)(),
4081         int argc,
4082         char *argv[] )
4083 {
4084    char *arg0 = argv[0];
4085    wtab_t *w;
4086    char buf[10];
4087    Boolean boolean;
4088    XrmValue fval, tval;
4089    char * errmsg;
4090
4091    if (argc != 3)
4092    {
4093       errmsg = strdup(GETMESSAGE(15,71, "Usage: %s widget boolean"));
4094       printerrf(str_nill, errmsg, arg0, NULL, NULL, NULL,
4095                 NULL, NULL, NULL, NULL);
4096       free(errmsg);
4097       return(1);
4098    }
4099
4100    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4101       return(1);
4102
4103    fval.addr = argv[2];
4104    fval.size = strlen(argv[2]);
4105    XtConvert(Toplevel, XtRString, &fval, XtRBoolean, &tval);
4106    if (tval.size != 0)
4107       boolean = *((Boolean *)(tval.addr));
4108    else
4109       return(1);
4110
4111    (*func) (w->w, boolean);
4112    return(0);
4113 }
4114
4115
4116 int
4117 do_XmTextSetEditable(
4118         int argc,
4119         char *argv[] )
4120 {
4121    return (Text_WidgetAndBoolean(XmTextSetEditable, argc, argv));
4122 }
4123
4124
4125 int
4126 do_XmTextSetAddMode(
4127         int argc,
4128         char *argv[] )
4129 {
4130    return (Text_WidgetAndBoolean(XmTextSetAddMode, argc, argv));
4131 }
4132
4133
4134 static int
4135 Text_WidgetAndOneParam(
4136         Boolean (*func)(),
4137         Boolean returnBoolean,
4138         Boolean paramIsString,
4139         char *usageMsg,
4140         int argc,
4141         char *argv[] )
4142 {
4143    char *arg0 = argv[0];
4144    wtab_t *w;
4145    Boolean result;
4146    int string;
4147    char buf[10];
4148    char * p;
4149    int param;
4150    char * errmsg;
4151
4152    if (argc != 3)
4153    {
4154       printerrf(str_nill, usageMsg, arg0, NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4155       return(1);
4156    }
4157
4158    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4159       return(1);
4160
4161    if (paramIsString)
4162       result = (*func) (w->w, argv[2]);
4163    else
4164    {
4165       param = strtoul(argv[2], &p, 0);
4166       if (p == argv[2])
4167       {
4168          errmsg = strdup(GETMESSAGE(15,72,
4169                          "The parameter specified is invalid: %s"));
4170          printerrf(arg0, errmsg, argv[2],
4171                    NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4172          free(errmsg);
4173          return(1);
4174       }
4175       result = (*func) (w->w, param);
4176    }
4177
4178    if (returnBoolean)
4179       return (!result);
4180    else
4181       return(0);
4182 }
4183
4184
4185 int
4186 do_XmTextScroll(
4187         int argc,
4188         char *argv[] )
4189 {
4190    char * errmsg;
4191    int retVal;
4192
4193    errmsg = strdup(GETMESSAGE(15,73, "Usage: %s widget lines"));
4194    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextScroll, False, False,
4195                                     errmsg, argc, argv);
4196    free(errmsg);
4197    return (retVal);
4198 }
4199
4200
4201 int
4202 do_XmTextSetInsertionPosition(
4203         int argc,
4204         char *argv[] )
4205
4206 {
4207    char * errmsg;
4208    int retVal;
4209
4210    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_POS));
4211    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextSetInsertionPosition,
4212                                     False, False, errmsg, argc, argv);
4213    free(errmsg);
4214    return(retVal);
4215 }
4216
4217
4218 int
4219 do_XmTextSetTopCharacter(
4220         int argc,
4221         char *argv[] )
4222 {
4223    char * errmsg;
4224    int retVal;
4225
4226    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_POS));
4227    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextSetTopCharacter, False,
4228                                    False, errmsg, argc, argv);
4229    free(errmsg);
4230    return(retVal);
4231 }
4232
4233
4234 int
4235 do_XmTextSetMaxLength(
4236         int argc,
4237         char *argv[] )
4238 {
4239    char * errmsg;
4240    int retVal;
4241
4242    errmsg = strdup(GETMESSAGE(15,74, "Usage: %s widget maxLength"));
4243    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextSetMaxLength, False,
4244                                    False, errmsg, argc, argv);
4245    free(errmsg);
4246    return(retVal);
4247 }
4248
4249
4250 int
4251 do_XmTextSetString(
4252         int argc,
4253         char *argv[] )
4254 {
4255    char * errmsg;
4256    int retVal;
4257
4258    errmsg = strdup(GETMESSAGE(15,75, "Usage: %s widget string"));
4259    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextSetString, False, True,
4260                                    errmsg, argc, argv);
4261    free(errmsg);
4262    return(retVal);
4263 }
4264
4265
4266 int
4267 do_XmTextShowPosition(
4268         int argc,
4269         char *argv[] )
4270 {
4271    char * errmsg;
4272    int retVal;
4273
4274    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_POS));
4275    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextShowPosition, False,
4276                                    False, errmsg, argc, argv);
4277    free(errmsg);
4278    return(retVal);
4279 }
4280
4281
4282 int
4283 do_XmTextClearSelection(
4284         int argc,
4285         char *argv[] )
4286 {
4287    char * errmsg;
4288    int retVal;
4289
4290    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_TIME));
4291    retVal = Text_WidgetAndOneParam((Boolean (*)())XmTextClearSelection, False,
4292                                     False, errmsg, argc, argv);
4293    free(errmsg);
4294    return(retVal);
4295 }
4296
4297
4298 int
4299 do_XmTextCopy(
4300         int argc,
4301         char *argv[] )
4302 {
4303    char * errmsg;
4304    int retVal;
4305
4306    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_TIME));
4307    retVal = Text_WidgetAndOneParam(XmTextCopy, True, False, errmsg, argc, argv);
4308    free(errmsg);
4309    return(retVal);
4310 }
4311
4312
4313 int
4314 do_XmTextCut(
4315         int argc,
4316         char *argv[] )
4317 {
4318    char * errmsg;
4319    int retVal;
4320
4321    errmsg = strdup(GetSharedMsg(DT_USAGE_WIDGET_TIME));
4322    retVal = Text_WidgetAndOneParam(XmTextCut, True, False, errmsg, argc, argv);
4323    free(errmsg);
4324    return(retVal);
4325 }
4326
4327
4328 int
4329 do_XmTextGetSelectionPosition(
4330         int argc,
4331         char *argv[] )
4332 {
4333    char *arg0 = argv[0];
4334    wtab_t *w;
4335    char buf[10];
4336    XmTextPosition left;
4337    XmTextPosition right;
4338    Boolean result;
4339    char * errmsg;
4340
4341    if (argc != 4)
4342    {
4343       errmsg = strdup(GETMESSAGE(15,76, "Usage: %s widget variable variable"));
4344       printerrf(str_nill, errmsg, arg0, NULL, NULL,
4345                 NULL, NULL, NULL, NULL, NULL);
4346       free(errmsg);
4347       return(1);
4348    }
4349
4350    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4351    {
4352       env_blank(argv[2]);
4353       env_blank(argv[3]);
4354       return(1);
4355    }
4356
4357    result = XmTextGetSelectionPosition(w->w, &left, &right);
4358    if (result)
4359    {
4360       sprintf(buf, "%ld", left);
4361       env_set_var(argv[2],  buf);
4362       sprintf(buf, "%ld", right);
4363       env_set_var(argv[3],  buf);
4364    }
4365    else
4366    {
4367       env_blank(argv[2]);
4368       env_blank(argv[3]);
4369    }
4370
4371    return(!result);
4372 }
4373
4374
4375 int
4376 do_XmTextInsert(
4377         int argc,
4378         char *argv[] )
4379 {
4380    char *arg0 = argv[0];
4381    wtab_t *w;
4382    XmTextPosition position;
4383    char * p;
4384    char * errmsg;
4385
4386    if (argc != 4)
4387    {
4388       errmsg = strdup(GETMESSAGE(15,77, "Usage: %s widget position string"));
4389       printerrf(str_nill, errmsg, arg0, NULL, NULL,
4390                 NULL, NULL, NULL, NULL, NULL);
4391       free(errmsg);
4392       return(1);
4393    }
4394
4395    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4396       return(1);
4397
4398    position = strtoul(argv[2], &p, 0);
4399    if (p == argv[2])
4400    {
4401       errmsg = strdup(GetSharedMsg(DT_BAD_POSITION));
4402       printerrf(arg0, errmsg, argv[2],
4403                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4404       free(errmsg);
4405       return(1);
4406    }
4407
4408    XmTextInsert(w->w, position, argv[3]);
4409    return(0);
4410 }
4411
4412
4413 int
4414 do_XmTextPosToXY(
4415         int argc,
4416         char *argv[] )
4417 {
4418    char *arg0 = argv[0];
4419    wtab_t *w;
4420    XmTextPosition position;
4421    Position x;
4422    Position y;
4423    char * p;
4424    Boolean result;
4425    char buf[10];
4426    char * errmsg;
4427
4428    if (argc != 5)
4429    {
4430       errmsg = strdup(GETMESSAGE(15,78,
4431                       "Usage: %s widget position variable variable"));
4432       printerrf(str_nill, errmsg, arg0, NULL,
4433                 NULL, NULL, NULL, NULL, NULL, NULL);
4434       free(errmsg);
4435       return(1);
4436    }
4437
4438    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4439    {
4440       env_blank(argv[3]);
4441       env_blank(argv[4]);
4442       return(1);
4443    }
4444
4445    position = strtoul(argv[2], &p, 0);
4446    if (p == argv[2])
4447    {
4448       errmsg = strdup(GetSharedMsg(DT_BAD_POSITION));
4449       printerrf(arg0, errmsg, argv[2], NULL,
4450                 NULL, NULL, NULL, NULL, NULL, NULL);
4451       free(errmsg);
4452       env_blank(argv[3]);
4453       env_blank(argv[4]);
4454       return(1);
4455    }
4456
4457    result = XmTextPosToXY(w->w, position, &x, &y);
4458    if (result)
4459    {
4460       sprintf(buf, "%d", x);
4461       env_set_var(argv[3],  buf);
4462       sprintf(buf, "%d", y);
4463       env_set_var(argv[4],  buf);
4464    }
4465    else
4466    {
4467       env_blank(argv[3]);
4468       env_blank(argv[4]);
4469    }
4470    return(!result);
4471 }
4472
4473
4474 int
4475 do_XmTextReplace(
4476         int argc,
4477         char *argv[] )
4478 {
4479    char *arg0 = argv[0];
4480    wtab_t *w;
4481    XmTextPosition from;
4482    XmTextPosition to;
4483    char * p;
4484    char * errmsg;
4485
4486    if (argc != 5)
4487    {
4488       errmsg = strdup(GETMESSAGE(15,79,
4489               "Usage: %s widget fromPosition toPosition string"));
4490       printerrf(str_nill, errmsg, arg0, NULL,
4491                NULL, NULL, NULL, NULL, NULL, NULL);
4492       free(errmsg);
4493       return(1);
4494    }
4495
4496    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4497       return(1);
4498
4499    from = strtoul(argv[2], &p, 0);
4500    if (p == argv[2])
4501    {
4502       errmsg = strdup(GETMESSAGE(15,80,
4503                "The 'from' position specified is invalid: %s"));
4504       printerrf(arg0, errmsg, argv[2],
4505                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4506       free(errmsg);
4507       return(1);
4508    }
4509
4510    to = strtoul(argv[3], &p, 0);
4511    if (p == argv[3])
4512    {
4513       errmsg = strdup(GETMESSAGE(15,81,
4514                       "The 'to' position specified is invalid: %s"));
4515       printerrf(arg0, errmsg, argv[3],
4516                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4517       free(errmsg);
4518       return(1);
4519    }
4520
4521    XmTextReplace(w->w, from, to, argv[4]);
4522    return(0);
4523 }
4524
4525
4526 int
4527 do_XmTextSetSelection(
4528         int argc,
4529         char *argv[] )
4530 {
4531    char *arg0 = argv[0];
4532    wtab_t *w;
4533    XmTextPosition first;
4534    XmTextPosition last;
4535    Time time;
4536    char * p;
4537    char * errmsg;
4538
4539    if (argc != 5)
4540    {
4541       errmsg = strdup(GETMESSAGE(15,82,
4542               "Usage: %s widget firstPosition lastPosition time"));
4543       printerrf(str_nill, errmsg, arg0, NULL,
4544                 NULL, NULL, NULL, NULL, NULL, NULL);
4545       free(errmsg);
4546       return(1);
4547    }
4548
4549    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4550       return(1);
4551
4552    first = strtoul(argv[2], &p, 0);
4553    if (p == argv[2])
4554    {
4555       errmsg = strdup(GETMESSAGE(15,83,
4556                       "The first position specified is invalid: %s"));
4557       printerrf(arg0, errmsg, argv[2],
4558                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4559       free(errmsg);
4560       return(1);
4561    }
4562
4563    last = strtoul(argv[3], &p, 0);
4564    if (p == argv[3])
4565    {
4566       errmsg = strdup(GETMESSAGE(15,84,
4567                       "The last position specified is invalid: %s"));
4568       printerrf(arg0, errmsg, argv[3],
4569                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4570       free(errmsg);
4571       return(1);
4572    }
4573
4574    time = strtoul(argv[4], &p, 0);
4575    if (p == argv[4])
4576    {
4577       errmsg = strdup(GETMESSAGE(15,85, "The time specified is invalid: %s"));
4578       printerrf(arg0, errmsg, argv[4],
4579                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4580       free(errmsg);
4581       return(1);
4582    }
4583
4584    XmTextSetSelection(w->w, first, last, time);
4585    return(0);
4586 }
4587
4588
4589 int
4590 do_XmTextXYToPos(
4591         int argc,
4592         char *argv[] )
4593 {
4594    char *arg0 = argv[0];
4595    wtab_t *w;
4596    Position x;
4597    Position y;
4598    XmTextPosition position;
4599    char * p;
4600    char buf[10];
4601    char * errmsg;
4602
4603    if (argc != 5)
4604    {
4605       errmsg = strdup(GETMESSAGE(15,86, "Usage: %s variable widget x y"));
4606       printerrf(str_nill, errmsg, arg0, NULL, NULL,
4607                 NULL, NULL, NULL, NULL, NULL);
4608       free(errmsg);
4609       return(1);
4610    }
4611
4612    if ((w = verifyTextWidget(argv[0], argv[2])) == NULL)
4613    {
4614       alt_env_set_var(argv[1], "");
4615       return(1);
4616    }
4617
4618    x = strtoul(argv[3], &p, 0);
4619    if (p == argv[3])
4620    {
4621       errmsg = strdup(GETMESSAGE(15,87,
4622                       "The x position specified is invalid: %s"));
4623       printerrf(arg0, errmsg, argv[3],
4624                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4625       free(errmsg);
4626       alt_env_set_var(argv[1], "");
4627       return(1);
4628    }
4629
4630    y = strtoul(argv[4], &p, 0);
4631    if (p == argv[4])
4632    {
4633       errmsg = strdup(GETMESSAGE(15,88,
4634                       "The y position specified is invalid: %s"));
4635       printerrf(arg0, errmsg, argv[4],
4636                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4637       free(errmsg);
4638       alt_env_set_var(argv[1], "");
4639       return(1);
4640    }
4641
4642    position = XmTextXYToPos(w->w, x, y);
4643    sprintf(buf, "%ld", position);
4644    alt_env_set_var(argv[1],  buf);
4645    return(0);
4646 }
4647
4648
4649 int
4650 do_XmTextSetHighlight(
4651         int argc,
4652         char *argv[] )
4653 {
4654    char *arg0 = argv[0];
4655    wtab_t *w;
4656    XmTextPosition left;
4657    XmTextPosition right;
4658    XmHighlightMode mode;
4659    char * p;
4660    XrmValue fval, tval;
4661    char * errmsg;
4662
4663    if (argc != 5)
4664    {
4665       errmsg = strdup(GETMESSAGE(15,89, "Usage: %s widget left right mode"));
4666       printerrf(str_nill, errmsg, arg0, NULL, NULL,
4667                 NULL, NULL, NULL, NULL, NULL);
4668       free(errmsg);
4669       return(1);
4670    }
4671
4672    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4673       return(1);
4674
4675    left = strtoul(argv[2], &p, 0);
4676    if (p == argv[2])
4677    {
4678       errmsg = strdup(GETMESSAGE(15,90,
4679                       "The left position specified is invalid: %s"));
4680       printerrf(arg0, errmsg, argv[2],
4681                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4682       free(errmsg);
4683       return(1);
4684    }
4685
4686    right = strtoul(argv[3], &p, 0);
4687    if (p == argv[3])
4688    {
4689       errmsg = strdup(GETMESSAGE(15,91,
4690                       "The right position specified is invalid: %s"));
4691       printerrf(arg0, errmsg, argv[3],
4692                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4693       free(errmsg);
4694       return(1);
4695    }
4696
4697    fval.addr = argv[4];
4698    fval.size = strlen(argv[4]);
4699    XtConvert(Toplevel, XtRString, &fval, "TextHighlightMode", &tval);
4700    if (tval.size != 0)
4701       mode = *((XmHighlightMode *)(tval.addr));
4702    else
4703       return(1);
4704
4705    XmTextSetHighlight(w->w, left, right, mode);
4706    return(0);
4707 }
4708
4709
4710 int
4711 do_XmTextFindString(
4712         int argc,
4713         char *argv[] )
4714 {
4715    char *arg0 = argv[0];
4716    wtab_t *w;
4717    XmTextPosition start;
4718    XmTextDirection direction;
4719    XmTextPosition position;
4720    char * p;
4721    XrmValue fval, tval;
4722    Boolean result;
4723    char buf[10];
4724    char * errmsg;
4725
4726    if (argc != 6)
4727    {
4728       errmsg = strdup(GETMESSAGE(15,92,
4729               "Usage: %s widget start string direction variable"));
4730       printerrf(str_nill, errmsg, arg0, NULL,
4731                 NULL, NULL, NULL, NULL, NULL, NULL);
4732       free(errmsg);
4733       return(1);
4734    }
4735
4736    if ((w = verifyTextWidget(argv[0], argv[1])) == NULL)
4737    {
4738       env_blank(argv[5]);
4739       return(1);
4740    }
4741
4742    start = strtoul(argv[2], &p, 0);
4743    if (p == argv[2])
4744    {
4745       errmsg = strdup(GETMESSAGE(15,93,
4746                       "The start position specified is invalid: %s"));
4747       printerrf(arg0, errmsg, argv[2],
4748                 NULL, NULL, NULL, NULL, NULL, NULL, NULL);
4749       free(errmsg);
4750       env_blank(argv[5]);
4751       return(1);
4752    }
4753
4754    fval.addr = argv[4];
4755    fval.size = strlen(argv[4]);
4756    XtConvert(Toplevel, XtRString, &fval, "TextSearchDirection", &tval);
4757    if (tval.size != 0)
4758       direction = *((XmTextDirection *)(tval.addr));
4759    else
4760    {
4761       env_blank(argv[5]);
4762       return(1);
4763    }
4764
4765    result = XmTextFindString(w->w, start, argv[3], direction, &position);
4766    if (result)
4767    {
4768       sprintf(buf, "%ld", position);
4769       env_set_var(argv[5],  buf);
4770    }
4771    else
4772       env_blank(argv[5]);
4773
4774    return(!result);
4775 }
4776
4777
4778 static int
4779 GetSubWidget(
4780         char * errmsg,
4781         Widget (*func)(),
4782         int argc,
4783         char *argv[] )
4784 {
4785    char *arg0 = argv[0];
4786    wtab_t * w;
4787    char * variable = argv[1];
4788    Widget child;
4789
4790    if (argc != 3)
4791    {
4792       printerr(str_nill, errmsg, NULL);
4793       return(1);
4794    }
4795
4796    w = str_to_wtab(arg0, argv[2]);
4797    if (w == NULL) {
4798       alt_env_set_var(variable, "");
4799       return(1);
4800    }
4801
4802    child = (*func)(w->w);
4803
4804    if (child == NULL)
4805    {
4806       alt_env_set_var(variable, "");
4807       return(1);
4808    }
4809
4810    w = ConvertWidgetToWtab(arg0, child);
4811
4812    alt_env_set_var(variable,  w->widid);
4813    return(0);
4814 }
4815
4816
4817 int
4818 do_XmOptionLabelGadget(
4819         int argc,
4820         char *argv[] )
4821 {
4822    int retVal;
4823    char * errmsg;
4824
4825    errmsg = strdup(GETMESSAGE(15,96,
4826               "Usage: XmOptionLabelGadget variable widget"));
4827    retVal = GetSubWidget(errmsg, XmOptionLabelGadget, argc, argv);
4828    XtFree(errmsg);
4829    return(retVal);
4830 }
4831
4832
4833 int
4834 do_XmOptionButtonGadget(
4835         int argc,
4836         char *argv[] )
4837 {
4838    int retVal;
4839    char * errmsg;
4840
4841    errmsg = strdup(GETMESSAGE(15,97,
4842               "Usage: XmOptionButtonGadget variable widget"));
4843    retVal = GetSubWidget(errmsg, XmOptionButtonGadget, argc, argv);
4844    XtFree(errmsg);
4845    return(retVal);
4846 }
4847
4848
4849 int
4850 do_XmGetVisibility(
4851         int argc,
4852         char *argv[] )
4853 {
4854    char *arg0 = argv[0];
4855    wtab_t * w;
4856    char * results = argv[1];
4857    XrmValue f, t;
4858    XmVisibility res;
4859    char * errmsg;
4860
4861    if (argc != 3)
4862    {
4863       errmsg = strdup(GETMESSAGE(15,98,
4864          "Usage: XmGetVisibility variable widget"));
4865       printerr(str_nill, errmsg, NULL);
4866       free(errmsg);
4867       return(1);
4868    }
4869
4870    w = str_to_wtab(arg0, argv[2]);
4871    if (w == NULL) {
4872         alt_env_set_var(results, "");
4873         return(1);
4874    }
4875
4876    res = XmGetVisibility(w->w);
4877
4878    f.addr = (caddr_t)&res;
4879    f.size = sizeof(XmVisibility);
4880    t.addr = NULL;
4881    t.size = 0;
4882    XtConvert(w->w, "VisibilityType", &f, XtRString, &t);
4883    alt_env_set_var(results,  (char *)(t.addr));
4884    return(0);
4885 }
4886
4887
4888 int
4889 do_XmGetTearOffControl(
4890         int argc,
4891         char *argv[] )
4892 {
4893    int retVal;
4894    char * errmsg;
4895
4896    errmsg = strdup(GETMESSAGE(15,99,
4897               "Usage: XmGetTearOffControl variable widget"));
4898    retVal = GetSubWidget(errmsg, XmGetTearOffControl, argc, argv);
4899    XtFree(errmsg);
4900    return(retVal);
4901 }
4902
4903
4904 int
4905 do_XmGetTabGroup(
4906         int argc,
4907         char *argv[] )
4908 {
4909    int retVal;
4910    char * errmsg;
4911
4912    errmsg = strdup(GETMESSAGE(15,100,
4913               "Usage: XmGetTabGroup variable widget"));
4914    retVal = GetSubWidget(errmsg, XmGetTabGroup, argc, argv);
4915    XtFree(errmsg);
4916    return(retVal);
4917 }
4918
4919
4920 int
4921 do_XmGetPostedFromWidget(
4922         int argc,
4923         char *argv[] )
4924 {
4925    int retVal;
4926    char * errmsg;
4927
4928    errmsg = strdup(GETMESSAGE(15,101,
4929               "Usage: XmGetPostedFromWidget variable widget"));
4930    retVal = GetSubWidget(errmsg, XmGetPostedFromWidget, argc, argv);
4931    XtFree(errmsg);
4932    return(retVal);
4933 }
4934
4935
4936 int
4937 do_XmGetFocusWidget(
4938         int argc,
4939         char *argv[] )
4940 {
4941    int retVal;
4942    char * errmsg;
4943
4944    errmsg = strdup(GETMESSAGE(15,102,
4945               "Usage: XmGetFocusWidget variable widget"));
4946    retVal = GetSubWidget(errmsg, XmGetFocusWidget, argc, argv);
4947    XtFree(errmsg);
4948    return(retVal);
4949 }
4950
4951
4952 int
4953 do_XmFileSelectionDoSearch(
4954         int argc,
4955         char *argv[] )
4956 {
4957    char *arg0 = argv[0];
4958    wtab_t *w;
4959    XmString string;
4960    char * errmsg;
4961
4962    if (argc != 3)
4963    {
4964       errmsg = strdup(GETMESSAGE(15,103,
4965               "Usage: XmFileSelectionDoSearch widget directoryMask"));
4966       printerr(str_nill, errmsg, NULL);
4967       free(errmsg);
4968       return(1);
4969    }
4970
4971    w = str_to_wtab(arg0, argv[1]);
4972    if (w == NULL)
4973         return(1);
4974
4975    string = XmStringCreateLocalized(argv[2]);
4976
4977    XmFileSelectionDoSearch(w->w, string);
4978    XmStringFree(string);
4979    return(0);
4980 }
4981
4982 static int
4983 _CreatePDMJobSetup(
4984         Widget (*func)(),
4985         int argc,
4986         char *argv[] )
4987 {
4988         Widget widget, realparent;
4989         classtab_t *class;
4990         char *arg0 = argv[0];
4991         wtab_t *w, *pw, *wtab, *parenttab;
4992         char *parentid, *var;
4993         register int    i;
4994         int n;
4995         char * errmsg;
4996         WidgetClass wclass;
4997
4998         if (argc < 2) {
4999                 errmsg = strdup(GETMESSAGE(15,3,
5000                      "Usage: %s variable parent"));
5001                 printerrf(str_nill, errmsg, argv[0], NULL,
5002                     NULL, NULL, NULL, NULL, NULL, NULL);
5003                 free(errmsg);
5004                 return(1);
5005         }
5006         var = argv[1];
5007         parentid = argv[2];
5008         pw = str_to_wtab(argv[0], parentid);
5009         if (pw == NULL) {
5010                 errmsg = strdup(GetSharedMsg(DT_NO_PARENT));
5011                 printerr(argv[0], errmsg, NULL);
5012                 free(errmsg);
5013                 return(1);
5014         }
5015         widget = func(pw->w);
5016         wclass = XtClass(widget);
5017         if ((class = str_to_class(arg0, wclass->core_class.class_name)) == NULL) {
5018                 return(1);
5019         }
5020         if (widget != NULL) {
5021                 /* Some of the XmCreate* functions return a widget
5022                  * id whose parent is not necessarily the parent
5023                  * passed in.  For example, DialogShell returns the
5024                  * widget of the dialog, not the Shell which is the
5025                  * real parent.
5026                  *
5027                  * So, we check to see if the parent is the same as
5028                  * the passed-in parent, and if not then we create
5029                  * a new entry for the real parent.
5030                  */
5031                 realparent = XtParent(widget);
5032                 if (realparent != pw->w) {
5033                         parenttab = (wtab_t *)widget_to_wtab(realparent);
5034                 } else
5035                         parenttab = pw;
5036                 wtab = set_up_w(widget, parenttab, var, XtName(widget), class);
5037
5038         } else {
5039                 errmsg = strdup(GetSharedMsg(DT_WIDGET_CREATE_FAILED));
5040                 printerrf(argv[0], errmsg,
5041                           wclass->core_class.class_name, NULL, NULL, NULL,
5042                         NULL, NULL, NULL, NULL);
5043                 free(errmsg);
5044                 env_blank(argv[1]);
5045         }
5046         return(0);
5047 }
5048
5049 int
5050 do_DtCreatePDMJobSetup(
5051         int argc,
5052         char *argv[] )
5053 {
5054         return(_CreatePDMJobSetup(_DtCreatePDMJobSetup, argc, argv));
5055 }
5056