cde/programs/dtappbuilder/src/libABil/abuil_resource_attr_map.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 /*
  24  *      $XConsortium: abuil_resource_attr_map.c /main/3 1995/11/06 18:21:24 rswiston $
  25  *
  26  * @(#)abuil_resource_attr_map.c        1.16 06 Oct 1994        cose/unity1/cde_app_builder/src/libABil
  27  *
  28  *      RESTRICTED CONFIDENTIAL INFORMATION:
  29  *
  30  *      The information in this document is subject to special
  31  *      restrictions in a confidential disclosure agreement between
  32  *      HP, IBM, Sun, USL, SCO and Univel.  Do not distribute this
  33  *      document outside HP, IBM, Sun, USL, SCO, or Univel without
  34  *      Sun's specific written approval.  This document and all copies
  35  *      and derivative works thereof must be returned or destroyed at
  36  *      Sun's request.
  37  *
  38  *      Copyright 1993 Sun Microsystems, Inc.  All rights reserved.
  39  *
  40  */
  41
  42 /*
  43  * This file contains the mapping between uil resources and ABObj attributes
  44  */
  45 #include <stdlib.h>
  46 #include <ctype.h>
  47 #include <stdio.h>
  48
  49 #include "abuil_loadP.h"
  50
  51
  52 typedef enum {
  53     VAL_ARG,
  54     VAL_CONST,
  55     VAL_CONTEXT,
  56     VAL_PROC
  57 } AttrValueType;
  58
  59 typedef BOOL (*VAL_PROC_HANDLER)(
  60                     ABObj       obj,
  61                     STRING      res_name,
  62                     AB_ARG_TYPE res_type,
  63                     XtPointer   res_value
  64                 );
  65
  66 typedef struct _AttrMapRec
  67 {
  68     unsigned long       obj_mask;
  69     Cardinal            attr_offset;
  70     Cardinal            attr_size;
  71     AttrValueType       value_type;
  72     XtPointer           const_value;
  73 } AttrMap;
  74
  75 typedef struct _ResourceAttrMapRec
  76 {
  77     char        *resource_name;
  78     AttrMap     *attr_maps;
  79     Cardinal    num_maps;
  80 } ResourceAttrMap;
  81 \f
  82
  83 typedef struct _ObjRefRec
  84 {
  85     BOOL        is_resolved;
  86     void        *reference;
  87 } ObjRef;
  88
  89 typedef struct _AnyContextRec   AnyContext;
  90
  91
  92 typedef void  (*CONTEXT_STORE_HANDLER)(
  93                     ABObj,
  94                     AnyContext *
  95               );
  96 typedef void  (*CONTEXT_INIT_HANDLER)(
  97                     AnyContext *
  98               );
  99
 100 typedef struct _ABuilStrIntMapRec
 101 {
 102         char *string;
 103         int  value;
 104 } ABuilStrIntMap;
 105
 106 struct _AnyContextRec
 107 {
 108     CONTEXT_INIT_HANDLER        init_handler;
 109     CONTEXT_STORE_HANDLER       store_handler;
 110 };
 111
 112 typedef struct _AttachmentContextRec
 113 {
 114     CONTEXT_INIT_HANDLER        init_handler;
 115     CONTEXT_STORE_HANDLER       store_handler;
 116
 117     ISTRING                     att_type;
 118     ObjRef                      *att_object;
 119     int                         att_position;
 120     int                         att_offset;
 121 } AttachmentContext;
 122 \f
 123
 124 static void     attach_context_init(
 125                     AnyContext  *attach_context
 126                 );
 127 static void     north_attach_context_store(
 128                    ABObj                ab_widget,
 129                    AnyContext   *attach_context
 130                 );
 131 static void     south_attach_context_store(
 132                    ABObj                ab_widget,
 133                    AnyContext   *attach_context
 134                 );
 135 static void     east_attach_context_store(
 136                    ABObj                ab_widget,
 137                    AnyContext   *attach_context
 138                 );
 139 static void     west_attach_context_store(
 140                    ABObj                ab_widget,
 141                    AnyContext   *attach_context
 142                 );
 143
 144 static void     attach_context_store(
 145                    ABObj                ab_widget,
 146                    AB_COMPASS_POINT     dir,
 147                    AnyContext   *attach_context
 148                 );
 149
 150 static BOOL     val_proc_debug(
 151                     ABObj       obj,
 152                     STRING      res_name,
 153                     AB_ARG_TYPE res_type,
 154                     XtPointer   res_value
 155                 );
 156
 157
 158 /* Specialized VAL_PROC handlers to set object attributes from resources */
 159
 160 static BOOL val_set_label_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 161 static BOOL val_set_labeltype_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 162 static BOOL val_set_rows_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 163 static BOOL val_set_columns_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 164 static BOOL val_set_maximum_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 165 static BOOL val_set_minimum_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 166 static BOOL val_set_numcols_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 167 static BOOL val_set_orientation_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 168 static BOOL val_set_fg_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 169 static BOOL val_set_bg_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 170 static BOOL val_set_sensitive_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 171 static BOOL val_set_mnemonic_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 172 static BOOL val_set_oklabel_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 173 static BOOL val_set_directory_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 174 static BOOL val_set_pattern_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 175 static BOOL val_set_autounmanage_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 176 static BOOL val_set_filetype_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 177 static BOOL val_set_maxlen_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 178 static BOOL val_set_panemax_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 179 static BOOL val_set_panemin_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 180 static BOOL val_set_intvalue_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 181 static BOOL val_set_strvalue_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 182 static BOOL val_set_increment_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 183 static BOOL val_set_decpts_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 184 static BOOL val_set_showval_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 185 static BOOL val_set_scrollh_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 186 static BOOL val_set_scrollv_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 187 static BOOL val_set_linestyle_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 188 static BOOL val_set_wordwrap_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 189 static BOOL val_set_border_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 190 static BOOL val_set_packing_proc(ABObj, STRING, AB_ARG_TYPE, XtPointer);
 191
 192 \f
 193
 194 static AttachmentContext
 195 NorthAttach =
 196 {
 197     attach_context_init, north_attach_context_store
 198 };
 199
 200 static AttachmentContext
 201 SouthAttach =
 202 {
 203     attach_context_init, south_attach_context_store
 204 };
 205
 206 static AttachmentContext
 207 EastAttach =
 208 {
 209     attach_context_init, east_attach_context_store
 210 };
 211
 212 static AttachmentContext
 213 WestAttach =
 214 {
 215     attach_context_init, west_attach_context_store
 216 };
 217 \f
 218
 219 static AnyContext *
 220 AbuilP_attr_contexts[] =
 221 {
 222     (AnyContext *)&NorthAttach,
 223     (AnyContext *)&SouthAttach,
 224     (AnyContext *)&EastAttach,
 225     (AnyContext *)&WestAttach
 226 };
 227
 228 \f
 229
 230
 231 #define Ofs(FIELD)        XtOffsetOf(AB_OBJ, FIELD)
 232
 233 static AttrMap
 234 accelerator_map[] =
 235 {
 236     { ((unsigned long)~0L),     0,      0,
 237         VAL_ARG,        0 },
 238 };
 239
 240 static AttrMap
 241 acceleratorText_map[] =
 242 {
 243     { ((unsigned long)~0L),     0,      0,
 244         VAL_ARG,        0 },
 245 };
 246
 247 static AttrMap
 248 accelerators_map[] =
 249 {
 250     { ((unsigned long)~0L),     0,      0,
 251         VAL_ARG,        0 },
 252 };
 253
 254 static AttrMap
 255 adjustLast_map[] =
 256 {
 257     { ((unsigned long)~0L),     0,      0,
 258         VAL_ARG,        0 },
 259 };
 260
 261 static AttrMap
 262 adjustMargin_map[] =
 263 {
 264     { ((unsigned long)~0L),     0,      0,
 265         VAL_ARG,        0 },
 266 };
 267
 268 static AttrMap
 269 alignment_map[] =
 270 {
 271     { ((unsigned long)~0L),     0,      0,
 272         VAL_ARG,        0 },
 273 };
 274
 275 static AttrMap
 276 allowOverlap_map[] =
 277 {
 278     { ((unsigned long)~0L),     0,      0,
 279         VAL_ARG,        0 },
 280 };
 281
 282 static AttrMap
 283 allowResize_map[] =
 284 {
 285     { ((unsigned long)~0L),     0,      0,
 286         VAL_ARG,        0 },
 287 };
 288
 289 static AttrMap
 290 allowShellResize_map[] =
 291 {
 292     { ((unsigned long)~0L),     0,      0,
 293         VAL_ARG,        0 },
 294 };
 295
 296 static AttrMap
 297 ancestorSensitive_map[] =
 298 {
 299     { ((unsigned long)~0L),     0,      0,
 300         VAL_ARG,        0 },
 301 };
 302
 303 static AttrMap
 304 applyLabelString_map[] =
 305 {
 306     { ((unsigned long)~0L),     0,      0,
 307         VAL_ARG,        0 },
 308 };
 309
 310 static AttrMap
 311 armColor_map[] =
 312 {
 313     { ((unsigned long)~0L),     0,      0,
 314         VAL_ARG,        0 },
 315 };
 316
 317 static AttrMap
 318 armPixmap_map[] =
 319 {
 320     { ((unsigned long)~0L),     0,      0,
 321         VAL_ARG,        0 },
 322 };
 323
 324 static AttrMap
 325 arrowDirection_map[] =
 326 {
 327     { ((unsigned long)~0L),     0,      0,
 328         VAL_ARG,        0 },
 329 };
 330
 331 static AttrMap
 332 audibleWarning_map[] =
 333 {
 334     { ((unsigned long)~0L),     0,      0,
 335         VAL_ARG,        0 },
 336 };
 337
 338 static AttrMap
 339 autoShowCursorPosition_map[] =
 340 {
 341     { ((unsigned long)~0L),     0,      0,
 342         VAL_ARG,        0 },
 343 };
 344
 345 static AttrMap
 346 autoUnmanage_map[] =
 347 {
 348     { BMASK(AB_TYPE_FILE_CHOOSER),
 349             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 350         VAL_PROC,       (XtPointer) val_set_autounmanage_proc },
 351 };
 352
 353 static AttrMap
 354 automaticSelection_map[] =
 355 {
 356     { ((unsigned long)~0L),     0,      0,
 357         VAL_ARG,        0 },
 358 };
 359
 360 static AttrMap
 361 background_map[] =
 362 {
 363     { ((unsigned long)~0L),
 364             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 365         VAL_PROC,       (XtPointer) val_set_bg_proc },
 366 };
 367
 368 static AttrMap
 369 backgroundPixmap_map[] =
 370 {
 371     { ((unsigned long)~0L),     0,      0,
 372         VAL_ARG,        0 },
 373 };
 374
 375 static AttrMap
 376 baseHeight_map[] =
 377 {
 378     { ((unsigned long)~0L),     0,      0,
 379         VAL_ARG,        0 },
 380 };
 381
 382 static AttrMap
 383 baseWidth_map[] =
 384 {
 385     { ((unsigned long)~0L),     0,      0,
 386         VAL_ARG,        0 },
 387 };
 388
 389 static AttrMap
 390 blinkRate_map[] =
 391 {
 392     { ((unsigned long)~0L),     0,      0,
 393         VAL_ARG,        0 },
 394 };
 395
 396 static AttrMap
 397 borderColor_map[] =
 398 {
 399     { ((unsigned long)~0L),     0,      0,
 400         VAL_ARG,        0 },
 401 };
 402
 403 static AttrMap
 404 borderPixmap_map[] =
 405 {
 406     { ((unsigned long)~0L),     0,      0,
 407         VAL_ARG,        0 },
 408 };
 409
 410 static AttrMap
 411 borderWidth_map[] =
 412 {
 413     { ((unsigned long)~0L),     0,      0,
 414         VAL_ARG,        0 },
 415 };
 416
 417 static AttrMap
 418 bottomAttachment_map[] =
 419 {
 420     { ((unsigned long)~0L),
 421         XtOffsetOf(AttachmentContext, att_type),        sizeof(ISTRING),
 422         VAL_CONTEXT,    (XtPointer)&SouthAttach },
 423 };
 424
 425 static AttrMap
 426 bottomOffset_map[] =
 427 {
 428     { ((unsigned long)~0L),
 429         XtOffsetOf(AttachmentContext, att_offset),      sizeof(ISTRING),
 430         VAL_CONTEXT,    (XtPointer)&SouthAttach },
 431 };
 432
 433 static AttrMap
 434 bottomPosition_map[] =
 435 {
 436     { ((unsigned long)~0L),
 437         XtOffsetOf(AttachmentContext, att_position),    sizeof(int),
 438         VAL_CONTEXT,    (XtPointer)&SouthAttach },
 439 };
 440
 441 static AttrMap
 442 bottomShadowColor_map[] =
 443 {
 444     { ((unsigned long)~0L),     0,      0,
 445         VAL_ARG,        0 },
 446 };
 447
 448 static AttrMap
 449 bottomShadowPixmap_map[] =
 450 {
 451     { ((unsigned long)~0L),     0,      0,
 452         VAL_ARG,        0 },
 453 };
 454
 455 static AttrMap
 456 bottomWidget_map[] =
 457 {
 458     { ((unsigned long)~0L),
 459         XtOffsetOf(AttachmentContext, att_object),      sizeof(ObjRef *),
 460         VAL_CONTEXT,    (XtPointer)&SouthAttach },
 461 };
 462
 463 static AttrMap
 464 buttonFontList_map[] =
 465 {
 466     { ((unsigned long)~0L),     0,      0,
 467         VAL_ARG,        0 },
 468 };
 469
 470 static AttrMap
 471 cancelButton_map[] =
 472 {
 473     { ((unsigned long)~0L),     0,      0,
 474         VAL_ARG,        0 },
 475 };
 476
 477 static AttrMap
 478 cancelLabelString_map[] =
 479 {
 480     { ((unsigned long)~0L),     0,      0,
 481         VAL_ARG,        0 },
 482 };
 483
 484 static AttrMap
 485 cascadePixmap_map[] =
 486 {
 487     { ((unsigned long)~0L),     0,      0,
 488         VAL_ARG,        0 },
 489 };
 490
 491 static AttrMap
 492 childHorizontalAlignment_map[] =
 493 {
 494     { ((unsigned long)~0L),     0,      0,
 495         VAL_ARG,        0 },
 496 };
 497
 498 static AttrMap
 499 childHorizontalSpacing_map[] =
 500 {
 501     { ((unsigned long)~0L),     0,      0,
 502         VAL_ARG,        0 },
 503 };
 504
 505 static AttrMap
 506 childPlacement_map[] =
 507 {
 508     { ((unsigned long)~0L),     0,      0,
 509         VAL_ARG,        0 },
 510 };
 511
 512 static AttrMap
 513 childType_map[] =
 514 {
 515     { ((unsigned long)~0L),     0,      0,
 516         VAL_ARG,        0 },
 517 };
 518
 519 static AttrMap
 520 childVerticalAlignment_map[] =
 521 {
 522     { ((unsigned long)~0L),     0,      0,
 523         VAL_ARG,        0 },
 524 };
 525
 526 static AttrMap
 527 clipWindow_map[] =
 528 {
 529     { ((unsigned long)~0L),     0,      0,
 530         VAL_ARG,        0 },
 531 };
 532
 533 static AttrMap
 534 colormap_map[] =
 535 {
 536     { ((unsigned long)~0L),     0,      0,
 537         VAL_ARG,        0 },
 538 };
 539
 540 static AttrMap
 541 columns_map[] =
 542 {
 543     { BMASK(AB_TYPE_TERM_PANE) | BMASK(AB_TYPE_TEXT_FIELD) | BMASK(AB_TYPE_TEXT_PANE) ,
 544             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 545         VAL_PROC,       (XtPointer) val_set_columns_proc },
 546 };
 547
 548 static AttrMap
 549 command_map[] =
 550 {
 551     { ((unsigned long)~0L),     0,      0,
 552         VAL_ARG,        0 },
 553 };
 554
 555 static AttrMap
 556 commandWindow_map[] =
 557 {
 558     { ((unsigned long)~0L),     0,      0,
 559         VAL_ARG,        0 },
 560 };
 561
 562 static AttrMap
 563 commandWindowLocation_map[] =
 564 {
 565     { ((unsigned long)~0L),     0,      0,
 566         VAL_ARG,        0 },
 567 };
 568
 569 static AttrMap
 570 createPopupChildProc_map[] =
 571 {
 572     { ((unsigned long)~0L),     0,      0,
 573         VAL_ARG,        0 },
 574 };
 575
 576 static AttrMap
 577 cursorPosition_map[] =
 578 {
 579     { ((unsigned long)~0L),     0,      0,
 580         VAL_ARG,        0 },
 581 };
 582
 583 static AttrMap
 584 cursorPositionVisible_map[] =
 585 {
 586     { ((unsigned long)~0L),     0,      0,
 587         VAL_ARG,        0 },
 588 };
 589
 590 static AttrMap
 591 decimalPoints_map[] =
 592 {
 593     { BMASK(AB_TYPE_SCALE) | BMASK(AB_TYPE_SPIN_BOX) ,
 594             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 595         VAL_PROC,       (XtPointer) val_set_decpts_proc },
 596 };
 597
 598 static AttrMap
 599 defaultButton_map[] =
 600 {
 601     { ((unsigned long)~0L),     0,      0,
 602         VAL_ARG,        0 },
 603 };
 604
 605 static AttrMap
 606 defaultButtonShadowThickness_map[] =
 607 {
 608     { ((unsigned long)~0L),     0,      0,
 609         VAL_ARG,        0 },
 610 };
 611
 612 static AttrMap
 613 defaultButtonType_map[] =
 614 {
 615     { ((unsigned long)~0L),     0,      0,
 616         VAL_ARG,        0 },
 617 };
 618
 619 static AttrMap
 620 defaultFontList_map[] =
 621 {
 622     { ((unsigned long)~0L),     0,      0,
 623         VAL_ARG,        0 },
 624 };
 625
 626 static AttrMap
 627 defaultPosition_map[] =
 628 {
 629     { ((unsigned long)~0L),     0,      0,
 630         VAL_ARG,        0 },
 631 };
 632
 633 static AttrMap
 634 deleteResponse_map[] =
 635 {
 636     { ((unsigned long)~0L),     0,      0,
 637         VAL_ARG,        0 },
 638 };
 639
 640 static AttrMap
 641 depth_map[] =
 642 {
 643     { ((unsigned long)~0L),     0,      0,
 644         VAL_ARG,        0 },
 645 };
 646
 647 static AttrMap
 648 dialogStyle_map[] =
 649 {
 650     { ((unsigned long)~0L),     0,      0,
 651         VAL_ARG,        0 },
 652 };
 653
 654 static AttrMap
 655 dialogTitle_map[] =
 656 {
 657     { ((unsigned long)~0L),     0,      0,
 658         VAL_ARG,        0 },
 659 };
 660
 661 static AttrMap
 662 dialogType_map[] =
 663 {
 664     { ((unsigned long)~0L),     0,      0,
 665         VAL_ARG,        0 },
 666 };
 667
 668 static AttrMap
 669 dirListItemCount_map[] =
 670 {
 671     { ((unsigned long)~0L),     0,      0,
 672         VAL_ARG,        0 },
 673 };
 674
 675 static AttrMap
 676 dirListItems_map[] =
 677 {
 678     { ((unsigned long)~0L),     0,      0,
 679         VAL_ARG,        0 },
 680 };
 681
 682 static AttrMap
 683 dirListLabelString_map[] =
 684 {
 685     { ((unsigned long)~0L),     0,      0,
 686         VAL_ARG,        0 },
 687 };
 688
 689 static AttrMap
 690 dirMask_map[] =
 691 {
 692     { ((unsigned long)~0L),     0,      0,
 693         VAL_ARG,        0 },
 694 };
 695
 696 static AttrMap
 697 dirSearchProc_map[] =
 698 {
 699     { ((unsigned long)~0L),     0,      0,
 700         VAL_ARG,        0 },
 701 };
 702
 703 static AttrMap
 704 dirSpec_map[] =
 705 {
 706     { ((unsigned long)~0L),     0,      0,
 707         VAL_ARG,        0 },
 708 };
 709
 710 static AttrMap
 711 directory_map[] =
 712 {
 713     { BMASK(AB_TYPE_FILE_CHOOSER),
 714             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 715         VAL_PROC,       (XtPointer) val_set_directory_proc },
 716 };
 717
 718 static AttrMap
 719 doubleClickInterval_map[] =
 720 {
 721     { ((unsigned long)~0L),     0,      0,
 722         VAL_ARG,        0 },
 723 };
 724
 725 static AttrMap
 726 editMode_map[] =
 727 {
 728     { ((unsigned long)~0L),     0,      0,
 729         VAL_ARG,        0 },
 730 };
 731
 732 static AttrMap
 733 editable_map[] =
 734 {
 735     { ((unsigned long)~0L),     0,      0,
 736         VAL_ARG,        0 },
 737 };
 738
 739 static AttrMap
 740 entryAlignment_map[] =
 741 {
 742     { ((unsigned long)~0L),     0,      0,
 743         VAL_ARG,        0 },
 744 };
 745
 746 static AttrMap
 747 entryBorder_map[] =
 748 {
 749     { ((unsigned long)~0L),     0,      0,
 750         VAL_ARG,        0 },
 751 };
 752
 753 static AttrMap
 754 entryClass_map[] =
 755 {
 756     { ((unsigned long)~0L),     0,      0,
 757         VAL_ARG,        0 },
 758 };
 759
 760 static AttrMap
 761 entryVerticalAlignment_map[] =
 762 {
 763     { ((unsigned long)~0L),     0,      0,
 764         VAL_ARG,        0 },
 765 };
 766
 767 static AttrMap
 768 fileListItemCount_map[] =
 769 {
 770     { ((unsigned long)~0L),     0,      0,
 771         VAL_ARG,        0 },
 772 };
 773
 774 static AttrMap
 775 fileListItems_map[] =
 776 {
 777     { ((unsigned long)~0L),     0,      0,
 778         VAL_ARG,        0 },
 779 };
 780
 781 static AttrMap
 782 fileListLabelString_map[] =
 783 {
 784     { ((unsigned long)~0L),     0,      0,
 785         VAL_ARG,        0 },
 786 };
 787
 788 static AttrMap
 789 fileSearchProc_map[] =
 790 {
 791     { ((unsigned long)~0L),     0,      0,
 792         VAL_ARG,        0 },
 793 };
 794
 795 static AttrMap
 796 fileTypeMask_map[] =
 797 {
 798     { BMASK(AB_TYPE_FILE_CHOOSER),
 799             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 800         VAL_PROC,       (XtPointer) val_set_filetype_proc },
 801 };
 802
 803 static AttrMap
 804 fillOnArm_map[] =
 805 {
 806     { ((unsigned long)~0L),     0,      0,
 807         VAL_ARG,        0 },
 808 };
 809
 810 static AttrMap
 811 fillOnSelect_map[] =
 812 {
 813     { ((unsigned long)~0L),     0,      0,
 814         VAL_ARG,        0 },
 815 };
 816
 817 static AttrMap
 818 filterLabelString_map[] =
 819 {
 820     { ((unsigned long)~0L),     0,      0,
 821         VAL_ARG,        0 },
 822 };
 823
 824 static AttrMap
 825 fontList_map[] =
 826 {
 827     { ((unsigned long)~0L),     0,      0,
 828         VAL_ARG,        0 },
 829 };
 830
 831 static AttrMap
 832 foreground_map[] =
 833 {
 834     { ((unsigned long)~0L),
 835             0,          1,  /* size field must != 0, but unused for VAL_PROC */
 836         VAL_PROC,       (XtPointer) val_set_fg_proc },
 837 };
 838
 839 static AttrMap
 840 fractionBase_map[] =
 841 {
 842     { ((unsigned long)~0L),     0,      0,
 843         VAL_ARG,        0 },
 844 };
 845
 846 static AttrMap
 847 geometry_map[] =
 848 {
 849     { ((unsigned long)~0L),     0,      0,
 850         VAL_ARG,        0 },
 851 };
 852
 853 static AttrMap
 854 height_map[] =
 855 {
 856     { ((unsigned long)~0L),     Ofs(height),    sizeof(int),
 857         VAL_ARG,        0 },
 858 };
 859
 860 static AttrMap
 861 heightInc_map[] =
 862 {
 863     { ((unsigned long)~0L),     0,      0,
 864         VAL_ARG,        0 },
 865 };
 866
 867 static AttrMap
 868 helpLabelString_map[] =
 869 {
 870     { ((unsigned long)~0L),     0,      0,
 871         VAL_ARG,        0 },
 872 };
 873
 874 static AttrMap
 875 highlightColor_map[] =
 876 {
 877     { ((unsigned long)~0L),     0,      0,
 878         VAL_ARG,        0 },
 879 };
 880
 881 static AttrMap
 882 highlightOnEnter_map[] =
 883 {
 884     { ((unsigned long)~0L),     0,      0,
 885         VAL_ARG,        0 },
 886 };
 887
 888 static AttrMap
 889 highlightPixmap_map[] =
 890 {
 891     { ((unsigned long)~0L),     0,      0,
 892         VAL_ARG,        0 },
 893 };
 894
 895 static AttrMap
 896 highlightThickness_map[] =
 897 {
 898     { ((unsigned long)~0L),     0,      0,
 899         VAL_ARG,        0 },
 900 };
 901
 902 static AttrMap
 903 historyItemCount_map[] =
 904 {
 905     { ((unsigned long)~0L),     0,      0,
 906         VAL_ARG,        0 },
 907 };
 908
 909 static AttrMap
 910 historyItems_map[] =
 911 {
 912     { ((unsigned long)~0L),     0,      0,
 913         VAL_ARG,        0 },
 914 };
 915
 916 static AttrMap
 917 historyMaxItems_map[] =
 918 {
 919     { ((unsigned long)~0L),     0,      0,
 920         VAL_ARG,        0 },
 921 };
 922
 923 static AttrMap
 924 historyVisibleItemCount_map[] =
 925 {
 926     { ((unsigned long)~0L),     0,      0,
 927         VAL_ARG,        0 },
 928 };
 929
 930 static AttrMap
 931 horizontalScrollBar_map[] =
 932 {
 933     { ((unsigned long)~0L),     0,      0,
 934         VAL_ARG,        0 },
 935 };
 936
 937 static AttrMap
 938 horizontalSpacing_map[] =
 939 {
 940     { ((unsigned long)~0L),     0,      0,
 941         VAL_ARG,        0 },
 942 };
 943
 944 static AttrMap
 945 iconMask_map[] =
 946 {
 947     { ((unsigned long)~0L),     0,      0,
 948         VAL_ARG,        0 },
 949 };
 950
 951 static AttrMap
 952 iconName_map[] =
 953 {
 954     { ((unsigned long)~0L),     0,      0,
 955         VAL_ARG,        0 },
 956 };
 957
 958 static AttrMap
 959 iconNameEncoding_map[] =
 960 {
 961     { ((unsigned long)~0L),     0,      0,
 962         VAL_ARG,        0 },
 963 };
 964
 965 static AttrMap
 966 iconPixmap_map[] =
 967 {
 968     { ((unsigned long)~0L),     0,      0,
 969         VAL_ARG,        0 },
 970 };
 971
 972 static AttrMap
 973 iconWindow_map[] =
 974 {
 975     { ((unsigned long)~0L),     0,      0,
 976         VAL_ARG,        0 },
 977 };
 978
 979 static AttrMap
 980 iconX_map[] =
 981 {
 982     { ((unsigned long)~0L),     0,      0,
 983         VAL_ARG,        0 },
 984 };
 985
 986 static AttrMap
 987 iconY_map[] =
 988 {
 989     { ((unsigned long)~0L),     0,      0,
 990         VAL_ARG,        0 },
 991 };
 992
 993 static AttrMap
 994 iconic_map[] =
 995 {
 996     { ((unsigned long)~0L),     0,      0,
 997         VAL_ARG,        0 },
 998 };
 999
1000 static AttrMap
1001 increment_map[] =
1002 {
1003     { ((unsigned long)~0L),     0,      0,
1004         VAL_ARG,        0 },
1005 };
1006
1007 static AttrMap
1008 indicatorOn_map[] =
1009 {
1010     { ((unsigned long)~0L),     0,      0,
1011         VAL_ARG,        0 },
1012 };
1013
1014 static AttrMap
1015 indicatorSize_map[] =
1016 {
1017     { ((unsigned long)~0L),     0,      0,
1018         VAL_ARG,        0 },
1019 };
1020
1021 static AttrMap
1022 indicatorType_map[] =
1023 {
1024     { ((unsigned long)~0L),     0,      0,
1025         VAL_ARG,        0 },
1026 };
1027
1028 static AttrMap
1029 initialDelay_map[] =
1030 {
1031     { ((unsigned long)~0L),     0,      0,
1032         VAL_ARG,        0 },
1033 };
1034
1035 static AttrMap
1036 initialFocus_map[] =
1037 {
1038     { ((unsigned long)~0L),     0,      0,
1039         VAL_ARG,        0 },
1040 };
1041
1042 static AttrMap
1043 initialResourcesPersistent_map[] =
1044 {
1045     { ((unsigned long)~0L),     0,      0,
1046         VAL_ARG,        0 },
1047 };
1048
1049 static AttrMap
1050 initialState_map[] =
1051 {
1052     { ((unsigned long)~0L),     0,      0,
1053         VAL_ARG,        0 },
1054 };
1055
1056 static AttrMap
1057 input_map[] =
1058 {
1059     { ((unsigned long)~0L),     0,      0,
1060         VAL_ARG,        0 },
1061 };
1062
1063 static AttrMap
1064 inputMethod_map[] =
1065 {
1066     { ((unsigned long)~0L),     0,      0,
1067         VAL_ARG,        0 },
1068 };
1069
1070 static AttrMap
1071 insertPosition_map[] =
1072 {
1073     { ((unsigned long)~0L),     0,      0,
1074         VAL_ARG,        0 },
1075 };
1076
1077 static AttrMap
1078 isAligned_map[] =
1079 {
1080     { ((unsigned long)~0L),     0,      0,
1081         VAL_ARG,        0 },
1082 };
1083
1084 static AttrMap
1085 isHomogeneous_map[] =
1086 {
1087     { ((unsigned long)~0L),     0,      0,
1088         VAL_ARG,        0 },
1089 };
1090
1091 static AttrMap
1092 itemCount_map[] =
1093 {
1094     { ((unsigned long)~0L),     0,      0,
1095         VAL_ARG,        0 },
1096 };
1097
1098 static AttrMap
1099 items_map[] =
1100 {
1101     { ((unsigned long)~0L),     0,      0,
1102         VAL_ARG,        0 },
1103 };
1104
1105 static AttrMap
1106 keyboardFocusPolicy_map[] =
1107 {
1108     { ((unsigned long)~0L),     0,      0,
1109         VAL_ARG,        0 },
1110 };
1111
1112 static AttrMap
1113 labelFontList_map[] =
1114 {
1115     { ((unsigned long)~0L),     0,      0,
1116         VAL_ARG,        0 },
1117 };
1118
1119 static AttrMap
1120 labelInsensitivePixmap_map[] =
1121 {
1122     { ((unsigned long)~0L),     0,      0,
1123         VAL_ARG,        0 },
1124 };
1125
1126 static AttrMap
1127 labelPixmap_map[] =
1128 {
1129     { BMASK(AB_TYPE_LABEL) | BMASK(AB_TYPE_BUTTON),
1130             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1131         VAL_PROC,       (XtPointer) val_set_label_proc },
1132     { BMASK(AB_TYPE_LABEL) | BMASK(AB_TYPE_BUTTON),
1133             Ofs(label_type),    sizeof(AB_LABEL_TYPE),
1134         VAL_CONST,      (XtPointer)AB_LABEL_GLYPH },
1135 };
1136
1137 static AttrMap
1138 labelString_map[] =
1139 {
1140     { BMASK(AB_TYPE_LABEL) | BMASK(AB_TYPE_BUTTON),
1141             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1142         VAL_PROC,       (XtPointer) val_set_label_proc },
1143     { BMASK(AB_TYPE_LABEL) | BMASK(AB_TYPE_BUTTON),
1144             Ofs(label_type),    sizeof(AB_LABEL_TYPE),
1145         VAL_CONST,      (XtPointer)AB_LABEL_STRING },
1146 };
1147
1148 static AttrMap
1149 labelType_map[] =
1150 {
1151     { BMASK(AB_TYPE_LABEL) | BMASK(AB_TYPE_BUTTON),
1152             0,  1,
1153         VAL_PROC,       (XPointer)val_set_labeltype_proc },
1154 };
1155
1156 static AttrMap
1157 leftAttachment_map[] =
1158 {
1159     { ((unsigned long)~0L),
1160         XtOffsetOf(AttachmentContext, att_type),        sizeof(ISTRING),
1161         VAL_CONTEXT,    (XtPointer)&WestAttach },
1162 };
1163
1164 static AttrMap
1165 leftOffset_map[] =
1166 {
1167     { ((unsigned long)~0L),
1168         XtOffsetOf(AttachmentContext, att_offset),      sizeof(ISTRING),
1169         VAL_CONTEXT,    (XtPointer)&WestAttach },
1170 };
1171
1172 static AttrMap
1173 leftPosition_map[] =
1174 {
1175     { ((unsigned long)~0L),
1176         XtOffsetOf(AttachmentContext, att_position),    sizeof(int),
1177         VAL_CONTEXT,    (XtPointer)&WestAttach },
1178 };
1179
1180 static AttrMap
1181 leftWidget_map[] =
1182 {
1183     { ((unsigned long)~0L),
1184         XtOffsetOf(AttachmentContext, att_object),      sizeof(ObjRef *),
1185         VAL_CONTEXT,    (XtPointer)&WestAttach },
1186 };
1187
1188 static AttrMap
1189 listItemCount_map[] =
1190 {
1191     { ((unsigned long)~0L),     0,      0,
1192         VAL_ARG,        0 },
1193 };
1194
1195 static AttrMap
1196 listItems_map[] =
1197 {
1198     { ((unsigned long)~0L),     0,      0,
1199         VAL_ARG,        0 },
1200 };
1201
1202 static AttrMap
1203 listLabelString_map[] =
1204 {
1205     { ((unsigned long)~0L),     0,      0,
1206         VAL_ARG,        0 },
1207 };
1208
1209 static AttrMap
1210 listMarginHeight_map[] =
1211 {
1212     { ((unsigned long)~0L),     0,      0,
1213         VAL_ARG,        0 },
1214 };
1215
1216 static AttrMap
1217 listMarginWidth_map[] =
1218 {
1219     { ((unsigned long)~0L),     0,      0,
1220         VAL_ARG,        0 },
1221 };
1222
1223 static AttrMap
1224 listSizePolicy_map[] =
1225 {
1226     { ((unsigned long)~0L),     0,      0,
1227         VAL_ARG,        0 },
1228 };
1229
1230 static AttrMap
1231 listSpacing_map[] =
1232 {
1233     { ((unsigned long)~0L),     0,      0,
1234         VAL_ARG,        0 },
1235 };
1236
1237 static AttrMap
1238 listUpdated_map[] =
1239 {
1240     { ((unsigned long)~0L),     0,      0,
1241         VAL_ARG,        0 },
1242 };
1243
1244 static AttrMap
1245 listVisibleItemCount_map[] =
1246 {
1247     { ((unsigned long)~0L),     0,      0,
1248         VAL_ARG,        0 },
1249 };
1250
1251 static AttrMap
1252 mainWindowMarginHeight_map[] =
1253 {
1254     { ((unsigned long)~0L),     0,      0,
1255         VAL_ARG,        0 },
1256 };
1257
1258 static AttrMap
1259 mainWindowMarginWidth_map[] =
1260 {
1261     { ((unsigned long)~0L),     0,      0,
1262         VAL_ARG,        0 },
1263 };
1264
1265 static AttrMap
1266 mappedWhenManaged_map[] =
1267 {
1268     { ((unsigned long)~0L),     0,      0,
1269         VAL_ARG,        0 },
1270 };
1271
1272 static AttrMap
1273 mappingDelay_map[] =
1274 {
1275     { ((unsigned long)~0L),     0,      0,
1276         VAL_ARG,        0 },
1277 };
1278
1279 static AttrMap
1280 margin_map[] =
1281 {
1282     { ((unsigned long)~0L),     0,      0,
1283         VAL_ARG,        0 },
1284 };
1285
1286 static AttrMap
1287 marginBottom_map[] =
1288 {
1289     { ((unsigned long)~0L),     0,      0,
1290         VAL_ARG,        0 },
1291 };
1292
1293 static AttrMap
1294 marginHeight_map[] =
1295 {
1296     { ((unsigned long)~0L),     0,      0,
1297         VAL_ARG,        0 },
1298 };
1299
1300 static AttrMap
1301 marginLeft_map[] =
1302 {
1303     { ((unsigned long)~0L),     0,      0,
1304         VAL_ARG,        0 },
1305 };
1306
1307 static AttrMap
1308 marginRight_map[] =
1309 {
1310     { ((unsigned long)~0L),     0,      0,
1311         VAL_ARG,        0 },
1312 };
1313
1314 static AttrMap
1315 marginTop_map[] =
1316 {
1317     { ((unsigned long)~0L),     0,      0,
1318         VAL_ARG,        0 },
1319 };
1320
1321 static AttrMap
1322 marginWidth_map[] =
1323 {
1324     { ((unsigned long)~0L),     0,      0,
1325         VAL_ARG,        0 },
1326 };
1327
1328 static AttrMap
1329 maxAspectX_map[] =
1330 {
1331     { ((unsigned long)~0L),     0,      0,
1332         VAL_ARG,        0 },
1333 };
1334
1335 static AttrMap
1336 maxAspectY_map[] =
1337 {
1338     { ((unsigned long)~0L),     0,      0,
1339         VAL_ARG,        0 },
1340 };
1341
1342 static AttrMap
1343 maxHeight_map[] =
1344 {
1345     { ((unsigned long)~0L),     0,      0,
1346         VAL_ARG,        0 },
1347 };
1348
1349 static AttrMap
1350 maxLength_map[] =
1351 {
1352     { BMASK(AB_TYPE_TEXT_FIELD) | BMASK(AB_TYPE_TEXT_PANE) ,
1353             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1354         VAL_PROC,       (XtPointer) val_set_maxlen_proc },
1355 };
1356
1357 static AttrMap
1358 maxWidth_map[] =
1359 {
1360     { ((unsigned long)~0L),     0,      0,
1361         VAL_ARG,        0 },
1362 };
1363
1364 static AttrMap
1365 maximum_map[] =
1366 {
1367     { BMASK(AB_TYPE_SCALE),
1368             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1369         VAL_PROC,       (XtPointer) val_set_maximum_proc },
1370 };
1371
1372 static AttrMap
1373 menuAccelerator_map[] =
1374 {
1375     { ((unsigned long)~0L),     0,      0,
1376         VAL_ARG,        0 },
1377 };
1378
1379 static AttrMap
1380 menuBar_map[] =
1381 {
1382     { ((unsigned long)~0L),     0,      0,
1383         VAL_ARG,        0 },
1384 };
1385
1386 static AttrMap
1387 menuHelpWidget_map[] =
1388 {
1389     { ((unsigned long)~0L),     0,      0,
1390         VAL_ARG,        0 },
1391 };
1392
1393 static AttrMap
1394 menuHistory_map[] =
1395 {
1396     { ((unsigned long)~0L),     0,      0,
1397         VAL_ARG,        0 },
1398 };
1399
1400 static AttrMap
1401 menuPost_map[] =
1402 {
1403     { ((unsigned long)~0L),     0,      0,
1404         VAL_ARG,        0 },
1405 };
1406
1407 static AttrMap
1408 messageAlignment_map[] =
1409 {
1410     { ((unsigned long)~0L),     0,      0,
1411         VAL_ARG,        0 },
1412 };
1413
1414 static AttrMap
1415 messageString_map[] =
1416 {
1417     { ((unsigned long)~0L),     0,      0,
1418         VAL_ARG,        0 },
1419 };
1420
1421 static AttrMap
1422 messageWindow_map[] =
1423 {
1424     { ((unsigned long)~0L),     0,      0,
1425         VAL_ARG,        0 },
1426 };
1427
1428 static AttrMap
1429 minAspectX_map[] =
1430 {
1431     { ((unsigned long)~0L),     0,      0,
1432         VAL_ARG,        0 },
1433 };
1434
1435 static AttrMap
1436 minAspectY_map[] =
1437 {
1438     { ((unsigned long)~0L),     0,      0,
1439         VAL_ARG,        0 },
1440 };
1441
1442 static AttrMap
1443 minHeight_map[] =
1444 {
1445     { ((unsigned long)~0L),     0,      0,
1446         VAL_ARG,        0 },
1447 };
1448
1449 static AttrMap
1450 minWidth_map[] =
1451 {
1452     { ((unsigned long)~0L),     0,      0,
1453         VAL_ARG,        0 },
1454 };
1455
1456 static AttrMap
1457 minimizeButtons_map[] =
1458 {
1459     { ((unsigned long)~0L),     0,      0,
1460         VAL_ARG,        0 },
1461 };
1462
1463 static AttrMap
1464 minimum_map[] =
1465 {
1466     { BMASK(AB_TYPE_SCALE),
1467             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1468         VAL_PROC,       (XtPointer) val_set_minimum_proc },
1469 };
1470
1471 static AttrMap
1472 mnemonic_map[] =
1473 {
1474     { BMASK(AB_TYPE_ITEM) ,
1475             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1476         VAL_PROC,       (XtPointer) val_set_mnemonic_proc },
1477 };
1478
1479 static AttrMap
1480 mnemonicCharSet_map[] =
1481 {
1482     { ((unsigned long)~0L),     0,      0,
1483         VAL_ARG,        0 },
1484 };
1485
1486 static AttrMap
1487 multiClick_map[] =
1488 {
1489     { ((unsigned long)~0L),     0,      0,
1490         VAL_ARG,        0 },
1491 };
1492
1493 static AttrMap
1494 mustMatch_map[] =
1495 {
1496     { ((unsigned long)~0L),     0,      0,
1497         VAL_ARG,        0 },
1498 };
1499
1500 static AttrMap
1501 mwmDecorations_map[] =
1502 {
1503     { ((unsigned long)~0L),     0,      0,
1504         VAL_ARG,        0 },
1505 };
1506
1507 static AttrMap
1508 mwmFunctions_map[] =
1509 {
1510     { ((unsigned long)~0L),     0,      0,
1511         VAL_ARG,        0 },
1512 };
1513
1514 static AttrMap
1515 mwmInputMode_map[] =
1516 {
1517     { ((unsigned long)~0L),     0,      0,
1518         VAL_ARG,        0 },
1519 };
1520
1521 static AttrMap
1522 mwmMenu_map[] =
1523 {
1524     { ((unsigned long)~0L),     0,      0,
1525         VAL_ARG,        0 },
1526 };
1527
1528 static AttrMap
1529 navigationType_map[] =
1530 {
1531     { ((unsigned long)~0L),     0,      0,
1532         VAL_ARG,        0 },
1533 };
1534
1535 static AttrMap
1536 noMatchString_map[] =
1537 {
1538     { ((unsigned long)~0L),     0,      0,
1539         VAL_ARG,        0 },
1540 };
1541
1542 static AttrMap
1543 noResize_map[] =
1544 {
1545     { ((unsigned long)~0L),     0,      0,
1546         VAL_ARG,        0 },
1547 };
1548
1549 static AttrMap
1550 numColumns_map[] =
1551 {
1552     { BMASK(AB_TYPE_TERM_PANE) | BMASK(AB_TYPE_TEXT_FIELD) | BMASK(AB_TYPE_TEXT_PANE) | BMASK(AB_TYPE_CHOICE) | BMASK(AB_TYPE_CONTAINER) ,
1553             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1554         VAL_PROC,       (XtPointer) val_set_numcols_proc },
1555 };
1556
1557 static AttrMap
1558 okLabelString_map[] =
1559 {
1560     { BMASK(AB_TYPE_FILE_CHOOSER),
1561             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1562         VAL_PROC,       (XtPointer) val_set_oklabel_proc },
1563 };
1564
1565 static AttrMap
1566 orientation_map[] =
1567 {
1568     { BMASK(AB_TYPE_SEPARATOR) | BMASK(AB_TYPE_SCALE) | BMASK(AB_TYPE_CHOICE),
1569             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1570         VAL_PROC,       (XtPointer) val_set_orientation_proc },
1571 };
1572
1573 static AttrMap
1574 overrideRedirect_map[] =
1575 {
1576     { ((unsigned long)~0L),     0,      0,
1577         VAL_ARG,        0 },
1578 };
1579
1580 static AttrMap
1581 packing_map[] =
1582 {
1583     { BMASK(AB_TYPE_CONTAINER) ,
1584             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1585         VAL_PROC,       (XtPointer) val_set_packing_proc },
1586 };
1587
1588 static AttrMap
1589 pageIncrement_map[] =
1590 {
1591     { ((unsigned long)~0L),     0,      0,
1592         VAL_ARG,        0 },
1593 };
1594
1595 static AttrMap
1596 paneMaximum_map[] =
1597 {
1598     { ((unsigned long)~0L),
1599             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1600         VAL_PROC,       (XtPointer) val_set_panemax_proc },
1601 };
1602
1603 static AttrMap
1604 paneMinimum_map[] =
1605 {
1606     { ((unsigned long)~0L),
1607             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1608         VAL_PROC,       (XtPointer) val_set_panemin_proc },
1609 };
1610
1611 static AttrMap
1612 pattern_map[] =
1613 {
1614     { BMASK(AB_TYPE_FILE_CHOOSER),
1615             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1616         VAL_PROC,       (XtPointer) val_set_pattern_proc },
1617 };
1618
1619 static AttrMap
1620 pendingDelete_map[] =
1621 {
1622     { ((unsigned long)~0L),     0,      0,
1623         VAL_ARG,        0 },
1624 };
1625
1626 static AttrMap
1627 popupEnabled_map[] =
1628 {
1629     { ((unsigned long)~0L),     0,      0,
1630         VAL_ARG,        0 },
1631 };
1632
1633 static AttrMap
1634 positionIndex_map[] =
1635 {
1636     { ((unsigned long)~0L),     0,      0,
1637         VAL_ARG,        0 },
1638 };
1639
1640 static AttrMap
1641 postFromCount_map[] =
1642 {
1643     { ((unsigned long)~0L),     0,      0,
1644         VAL_ARG,        0 },
1645 };
1646
1647 static AttrMap
1648 postFromList_map[] =
1649 {
1650     { ((unsigned long)~0L),     0,      0,
1651         VAL_ARG,        0 },
1652 };
1653
1654 static AttrMap
1655 preeditType_map[] =
1656 {
1657     { ((unsigned long)~0L),     0,      0,
1658         VAL_ARG,        0 },
1659 };
1660
1661 static AttrMap
1662 processingDirection_map[] =
1663 {
1664     { ((unsigned long)~0L),     0,      0,
1665         VAL_ARG,        0 },
1666 };
1667
1668 static AttrMap
1669 promptString_map[] =
1670 {
1671     { ((unsigned long)~0L),     0,      0,
1672         VAL_ARG,        0 },
1673 };
1674
1675 static AttrMap
1676 pushButtonEnabled_map[] =
1677 {
1678     { ((unsigned long)~0L),     0,      0,
1679         VAL_ARG,        0 },
1680 };
1681
1682 static AttrMap
1683 qualifySearchDataProc_map[] =
1684 {
1685     { ((unsigned long)~0L),     0,      0,
1686         VAL_ARG,        0 },
1687 };
1688
1689 static AttrMap
1690 radioAlwaysOne_map[] =
1691 {
1692     { ((unsigned long)~0L),     0,      0,
1693         VAL_ARG,        0 },
1694 };
1695
1696 static AttrMap
1697 radioBehavior_map[] =
1698 {
1699     { ((unsigned long)~0L),     0,      0,
1700         VAL_ARG,        0 },
1701 };
1702
1703 static AttrMap
1704 recomputeSize_map[] =
1705 {
1706     { ((unsigned long)~0L),     0,      0,
1707         VAL_ARG,        0 },
1708 };
1709
1710 static AttrMap
1711 refigureMode_map[] =
1712 {
1713     { ((unsigned long)~0L),     0,      0,
1714         VAL_ARG,        0 },
1715 };
1716
1717 static AttrMap
1718 repeatDelay_map[] =
1719 {
1720     { ((unsigned long)~0L),     0,      0,
1721         VAL_ARG,        0 },
1722 };
1723
1724 static AttrMap
1725 resizable_map[] =
1726 {
1727     { ((unsigned long)~0L),     0,      0,
1728         VAL_ARG,        0 },
1729 };
1730
1731 static AttrMap
1732 resizeHeight_map[] =
1733 {
1734     { ((unsigned long)~0L),     0,      0,
1735         VAL_ARG,        0 },
1736 };
1737
1738 static AttrMap
1739 resizePolicy_map[] =
1740 {
1741     { ((unsigned long)~0L),     0,      0,
1742         VAL_ARG,        0 },
1743 };
1744
1745 static AttrMap
1746 resizeWidth_map[] =
1747 {
1748     { ((unsigned long)~0L),     0,      0,
1749         VAL_ARG,        0 },
1750 };
1751
1752 static AttrMap
1753 rightAttachment_map[] =
1754 {
1755     { ((unsigned long)~0L),
1756         XtOffsetOf(AttachmentContext, att_type),        sizeof(ISTRING),
1757         VAL_CONTEXT,    (XtPointer)&EastAttach },
1758 };
1759
1760 static AttrMap
1761 rightOffset_map[] =
1762 {
1763     { ((unsigned long)~0L),
1764         XtOffsetOf(AttachmentContext, att_offset),      sizeof(ISTRING),
1765         VAL_CONTEXT,    (XtPointer)&EastAttach },
1766 };
1767
1768 static AttrMap
1769 rightPosition_map[] =
1770 {
1771     { ((unsigned long)~0L),
1772         XtOffsetOf(AttachmentContext, att_position),    sizeof(int),
1773         VAL_CONTEXT,    (XtPointer)&EastAttach },
1774 };
1775
1776 static AttrMap
1777 rightWidget_map[] =
1778 {
1779     { ((unsigned long)~0L),
1780         XtOffsetOf(AttachmentContext, att_object),      sizeof(ObjRef *),
1781         VAL_CONTEXT,    (XtPointer)&EastAttach },
1782 };
1783
1784 static AttrMap
1785 rowColumnType_map[] =
1786 {
1787     { ((unsigned long)~0L),     0,      0,
1788         VAL_ARG,        0 },
1789 };
1790
1791 static AttrMap
1792 rows_map[] =
1793 {
1794     { BMASK(AB_TYPE_TERM_PANE) | BMASK(AB_TYPE_TEXT_PANE) ,
1795             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1796         VAL_PROC,       (XtPointer) val_set_rows_proc },
1797 };
1798
1799 static AttrMap
1800 rubberPositioning_map[] =
1801 {
1802     { ((unsigned long)~0L),     0,      0,
1803         VAL_ARG,        0 },
1804 };
1805
1806 static AttrMap
1807 sashHeight_map[] =
1808 {
1809     { ((unsigned long)~0L),     0,      0,
1810         VAL_ARG,        0 },
1811 };
1812
1813 static AttrMap
1814 sashIndent_map[] =
1815 {
1816     { ((unsigned long)~0L),     0,      0,
1817         VAL_ARG,        0 },
1818 };
1819
1820 static AttrMap
1821 sashShadowThickness_map[] =
1822 {
1823     { ((unsigned long)~0L),     0,      0,
1824         VAL_ARG,        0 },
1825 };
1826
1827 static AttrMap
1828 sashWidth_map[] =
1829 {
1830     { ((unsigned long)~0L),     0,      0,
1831         VAL_ARG,        0 },
1832 };
1833
1834 static AttrMap
1835 saveUnder_map[] =
1836 {
1837     { ((unsigned long)~0L),     0,      0,
1838         VAL_ARG,        0 },
1839 };
1840
1841 static AttrMap
1842 scaleHeight_map[] =
1843 {
1844     { ((unsigned long)~0L),     0,      0,
1845         VAL_ARG,        0 },
1846 };
1847
1848 static AttrMap
1849 scaleMultiple_map[] =
1850 {
1851     { BMASK(AB_TYPE_SCALE) | BMASK(AB_TYPE_SPIN_BOX) ,
1852             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1853         VAL_PROC,       (XtPointer) val_set_increment_proc },
1854 };
1855
1856 static AttrMap
1857 scaleWidth_map[] =
1858 {
1859     { ((unsigned long)~0L),     0,      0,
1860         VAL_ARG,        0 },
1861 };
1862
1863 static AttrMap
1864 screen_map[] =
1865 {
1866     { ((unsigned long)~0L),     0,      0,
1867         VAL_ARG,        0 },
1868 };
1869
1870 static AttrMap
1871 scrollBarDisplayPolicy_map[] =
1872 {
1873     { ((unsigned long)~0L),     0,      0,
1874         VAL_ARG,        0 },
1875 };
1876
1877 static AttrMap
1878 scrollBarPlacement_map[] =
1879 {
1880     { ((unsigned long)~0L),     0,      0,
1881         VAL_ARG,        0 },
1882 };
1883
1884 static AttrMap
1885 scrollHorizontal_map[] =
1886 {
1887     { BMASK(AB_TYPE_TEXT_PANE) ,
1888             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1889         VAL_PROC,       (XtPointer) val_set_scrollh_proc },
1890 };
1891
1892 static AttrMap
1893 scrollLeftSide_map[] =
1894 {
1895     { ((unsigned long)~0L),     0,      0,
1896         VAL_ARG,        0 },
1897 };
1898
1899 static AttrMap
1900 scrollTopSide_map[] =
1901 {
1902     { ((unsigned long)~0L),     0,      0,
1903         VAL_ARG,        0 },
1904 };
1905
1906 static AttrMap
1907 scrollVertical_map[] =
1908 {
1909     { BMASK(AB_TYPE_TEXT_PANE) ,
1910             0,          1,  /* size field must != 0, but unused for VAL_PROC */
1911         VAL_PROC,       (XtPointer) val_set_scrollv_proc },
1912 };
1913
1914 static AttrMap
1915 scrolledWindowMarginHeight_map[] =
1916 {
1917     { ((unsigned long)~0L),     0,      0,
1918         VAL_ARG,        0 },
1919 };
1920
1921 static AttrMap
1922 scrolledWindowMarginWidth_map[] =
1923 {
1924     { ((unsigned long)~0L),     0,      0,
1925         VAL_ARG,        0 },
1926 };
1927
1928 static AttrMap
1929 scrollingPolicy_map[] =
1930 {
1931     { ((unsigned long)~0L),     0,      0,
1932         VAL_ARG,        0 },
1933 };
1934
1935 static AttrMap
1936 selectColor_map[] =
1937 {
1938     { ((unsigned long)~0L),     0,      0,
1939         VAL_ARG,        0 },
1940 };
1941
1942 static AttrMap
1943 selectInsensitivePixmap_map[] =
1944 {
1945     { ((unsigned long)~0L),     0,      0,
1946         VAL_ARG,        0 },
1947 };
1948
1949 static AttrMap
1950 selectPixmap_map[] =
1951 {
1952     { ((unsigned long)~0L),     0,      0,
1953         VAL_ARG,        0 },
1954 };
1955
1956 static AttrMap
1957 selectThreshold_map[] =
1958 {
1959     { ((unsigned long)~0L),     0,      0,
1960         VAL_ARG,        0 },
1961 };
1962
1963 static AttrMap
1964 selectedItemCount_map[] =
1965 {
1966     { ((unsigned long)~0L),     0,      0,
1967         VAL_ARG,        0 },
1968 };
1969
1970 static AttrMap
1971 selectedItems_map[] =
1972 {
1973     { ((unsigned long)~0L),     0,      0,
1974         VAL_ARG,        0 },
1975 };
1976
1977 static AttrMap
1978 selectionArray_map[] =
1979 {
1980     { ((unsigned long)~0L),     0,      0,
1981         VAL_ARG,        0 },
1982 };
1983
1984 static AttrMap
1985 selectionArrayCount_map[] =
1986 {
1987     { ((unsigned long)~0L),     0,      0,
1988         VAL_ARG,        0 },
1989 };
1990
1991 static AttrMap
1992 selectionLabelString_map[] =
1993 {
1994     { ((unsigned long)~0L),     0,      0,
1995         VAL_ARG,        0 },
1996 };
1997
1998 static AttrMap
1999 selectionPolicy_map[] =
2000 {
2001     { ((unsigned long)~0L),     0,      0,
2002         VAL_ARG,        0 },
2003 };
2004
2005 static AttrMap
2006 sensitive_map[] =
2007 {
2008     { ((unsigned long)~0L),
2009             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2010         VAL_PROC,       (XtPointer) val_set_sensitive_proc },
2011 };
2012
2013 static AttrMap
2014 separatorOn_map[] =
2015 {
2016     { ((unsigned long)~0L),     0,      0,
2017         VAL_ARG,        0 },
2018 };
2019
2020 static AttrMap
2021 separatorType_map[] =
2022 {
2023     { ((unsigned long)~0L),
2024             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2025         VAL_PROC,       (XtPointer) val_set_linestyle_proc },
2026 };
2027
2028 static AttrMap
2029 set_map[] =
2030 {
2031     { ((unsigned long)~0L),     0,      0,
2032         VAL_ARG,        0 },
2033 };
2034
2035 static AttrMap
2036 shadowThickness_map[] =
2037 {
2038     { ((unsigned long)~0L),     0,      0,
2039         VAL_ARG,        0 },
2040 };
2041
2042 static AttrMap
2043 shadowType_map[] =
2044 {
2045     { ((unsigned long)~0L),
2046             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2047         VAL_PROC,       (XtPointer) val_set_border_proc },
2048     { ((unsigned long)~0L),
2049             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2050         VAL_PROC,       (XtPointer) val_proc_debug },
2051 };
2052
2053 static AttrMap
2054 shellUnitType_map[] =
2055 {
2056     { ((unsigned long)~0L),     0,      0,
2057         VAL_ARG,        0 },
2058 };
2059
2060 static AttrMap
2061 showArrows_map[] =
2062 {
2063     { ((unsigned long)~0L),     0,      0,
2064         VAL_ARG,        0 },
2065 };
2066
2067 static AttrMap
2068 showAsDefault_map[] =
2069 {
2070     { ((unsigned long)~0L),     0,      0,
2071         VAL_ARG,        0 },
2072 };
2073
2074 static AttrMap
2075 showSeparator_map[] =
2076 {
2077     { ((unsigned long)~0L),     0,      0,
2078         VAL_ARG,        0 },
2079 };
2080
2081 static AttrMap
2082 showValue_map[] =
2083 {
2084     { BMASK(AB_TYPE_TERM_PANE) | BMASK(AB_TYPE_TEXT_PANE) ,
2085             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2086         VAL_PROC,       (XtPointer) val_set_showval_proc },
2087 };
2088
2089 static AttrMap
2090 skipAdjust_map[] =
2091 {
2092     { ((unsigned long)~0L),     0,      0,
2093         VAL_ARG,        0 },
2094 };
2095
2096 static AttrMap
2097 sliderSize_map[] =
2098 {
2099     { ((unsigned long)~0L),     0,      0,
2100         VAL_ARG,        0 },
2101 };
2102
2103 static AttrMap
2104 source_map[] =
2105 {
2106     { ((unsigned long)~0L),     0,      0,
2107         VAL_ARG,        0 },
2108 };
2109
2110 static AttrMap
2111 spacing_map[] =
2112 {
2113     { ((unsigned long)~0L),     0,      0,
2114         VAL_ARG,        0 },
2115 };
2116
2117 static AttrMap
2118 stringDirection_map[] =
2119 {
2120     { ((unsigned long)~0L),     0,      0,
2121         VAL_ARG,        0 },
2122 };
2123
2124 static AttrMap
2125 subMenuId_map[] =
2126 {
2127     { ((unsigned long)~0L),     0,      0,
2128         VAL_ARG,        0 },
2129 };
2130
2131 static AttrMap
2132 symbolPixmap_map[] =
2133 {
2134     { ((unsigned long)~0L),     0,      0,
2135         VAL_ARG,        0 },
2136 };
2137
2138 static AttrMap
2139 tearOffModel_map[] =
2140 {
2141     { ((unsigned long)~0L),     0,      0,
2142         VAL_ARG,        0 },
2143 };
2144
2145 static AttrMap
2146 textAccelerators_map[] =
2147 {
2148     { ((unsigned long)~0L),     0,      0,
2149         VAL_ARG,        0 },
2150 };
2151
2152 static AttrMap
2153 textColumns_map[] =
2154 {
2155     { ((unsigned long)~0L),     0,      0,
2156         VAL_ARG,        0 },
2157 };
2158
2159 static AttrMap
2160 textFontList_map[] =
2161 {
2162     { ((unsigned long)~0L),     0,      0,
2163         VAL_ARG,        0 },
2164 };
2165
2166 static AttrMap
2167 textString_map[] =
2168 {
2169     { ((unsigned long)~0L),     0,      0,
2170         VAL_ARG,        0 },
2171 };
2172
2173 static AttrMap
2174 textTranslations_map[] =
2175 {
2176     { ((unsigned long)~0L),     0,      0,
2177         VAL_ARG,        0 },
2178 };
2179
2180 /*
2181 ** We use the ABObj's label resource to hold the title string for main windows,
2182 ** custom dialogs and file choosers.
2183 */
2184 static AttrMap
2185 title_map[] =
2186 {
2187     { BMASK(AB_TYPE_BASE_WINDOW) | BMASK(AB_TYPE_DIALOG) | BMASK(AB_TYPE_FILE_CHOOSER),
2188             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2189         VAL_PROC,       (XtPointer) val_set_label_proc },
2190 };
2191
2192 static AttrMap
2193 titleEncoding_map[] =
2194 {
2195     { ((unsigned long)~0L),     0,      0,
2196         VAL_ARG,        0 },
2197 };
2198
2199 static AttrMap
2200 titleString_map[] =
2201 {
2202     { ((unsigned long)~0L),     0,      0,
2203         VAL_ARG,        0 },
2204 };
2205
2206 static AttrMap
2207 topAttachment_map[] =
2208 {
2209     { ((unsigned long)~0L),
2210         XtOffsetOf(AttachmentContext, att_type),        sizeof(ISTRING),
2211         VAL_CONTEXT,    (XtPointer)&NorthAttach },
2212 };
2213
2214 static AttrMap
2215 topCharacter_map[] =
2216 {
2217     { ((unsigned long)~0L),     0,      0,
2218         VAL_ARG,        0 },
2219 };
2220
2221 static AttrMap
2222 topItemPosition_map[] =
2223 {
2224     { ((unsigned long)~0L),     0,      0,
2225         VAL_ARG,        0 },
2226 };
2227
2228 static AttrMap
2229 topOffset_map[] =
2230 {
2231     { ((unsigned long)~0L),
2232         XtOffsetOf(AttachmentContext, att_offset),      sizeof(int),
2233         VAL_CONTEXT,    (XtPointer)&NorthAttach },
2234 };
2235
2236 static AttrMap
2237 topPosition_map[] =
2238 {
2239     { ((unsigned long)~0L),
2240         XtOffsetOf(AttachmentContext, att_position),    sizeof(int),
2241         VAL_CONTEXT,    (XtPointer)&NorthAttach },
2242 };
2243
2244 static AttrMap
2245 topShadowColor_map[] =
2246 {
2247     { ((unsigned long)~0L),     0,      0,
2248         VAL_ARG,        0 },
2249 };
2250
2251 static AttrMap
2252 topShadowPixmap_map[] =
2253 {
2254     { ((unsigned long)~0L),     0,      0,
2255         VAL_ARG,        0 },
2256 };
2257
2258 static AttrMap
2259 topWidget_map[] =
2260 {
2261     { ((unsigned long)~0L),
2262         XtOffsetOf(AttachmentContext, att_object),      sizeof(ObjRef *),
2263         VAL_CONTEXT,    (XtPointer)&NorthAttach },
2264 };
2265
2266 static AttrMap
2267 transient_map[] =
2268 {
2269     { ((unsigned long)~0L),     0,      0,
2270         VAL_ARG,        0 },
2271 };
2272
2273 static AttrMap
2274 transientFor_map[] =
2275 {
2276     { ((unsigned long)~0L),     0,      0,
2277         VAL_ARG,        0 },
2278 };
2279
2280 static AttrMap
2281 translations_map[] =
2282 {
2283     { ((unsigned long)~0L),     0,      0,
2284         VAL_ARG,        0 },
2285 };
2286
2287 static AttrMap
2288 traversalOn_map[] =
2289 {
2290     { ((unsigned long)~0L),     0,      0,
2291         VAL_ARG,        0 },
2292 };
2293
2294 static AttrMap
2295 troughColor_map[] =
2296 {
2297     { ((unsigned long)~0L),     0,      0,
2298         VAL_ARG,        0 },
2299 };
2300
2301 static AttrMap
2302 unitType_map[] =
2303 {
2304     { ((unsigned long)~0L),     0,      0,
2305         VAL_ARG,        0 },
2306 };
2307
2308 static AttrMap
2309 unpostBehavior_map[] =
2310 {
2311     { ((unsigned long)~0L),     0,      0,
2312         VAL_ARG,        0 },
2313 };
2314
2315 static AttrMap
2316 useAsyncGeometry_map[] =
2317 {
2318     { ((unsigned long)~0L),     0,      0,
2319         VAL_ARG,        0 },
2320 };
2321
2322 static AttrMap
2323 userData_map[] =
2324 {
2325     { ((unsigned long)~0L),     0,      0,
2326         VAL_ARG,        0 },
2327 };
2328
2329 static AttrMap
2330 value_map[] =
2331 {
2332     { BMASK(AB_TYPE_TEXT_PANE) | BMASK(AB_TYPE_TEXT_FIELD),
2333             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2334         VAL_PROC,       (XtPointer) val_set_strvalue_proc },
2335     { BMASK(AB_TYPE_SCALE),
2336             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2337         VAL_PROC,       (XtPointer) val_set_intvalue_proc },
2338 };
2339
2340 static AttrMap
2341 valueWcs_map[] =
2342 {
2343     { ((unsigned long)~0L),     0,      0,
2344         VAL_ARG,        0 },
2345 };
2346
2347 static AttrMap
2348 verifyBell_map[] =
2349 {
2350     { ((unsigned long)~0L),     0,      0,
2351         VAL_ARG,        0 },
2352 };
2353
2354 static AttrMap
2355 verticalScrollBar_map[] =
2356 {
2357     { ((unsigned long)~0L),     0,      0,
2358         VAL_ARG,        0 },
2359 };
2360
2361 static AttrMap
2362 verticalSpacing_map[] =
2363 {
2364     { ((unsigned long)~0L),     0,      0,
2365         VAL_ARG,        0 },
2366 };
2367
2368 static AttrMap
2369 visibleItemCount_map[] =
2370 {
2371     { BMASK(AB_TYPE_LIST),
2372             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2373         VAL_PROC,       (XtPointer) val_set_rows_proc },
2374 };
2375
2376 static AttrMap
2377 visibleWhenOff_map[] =
2378 {
2379     { ((unsigned long)~0L),     0,      0,
2380         VAL_ARG,        0 },
2381 };
2382
2383 static AttrMap
2384 visual_map[] =
2385 {
2386     { ((unsigned long)~0L),     0,      0,
2387         VAL_ARG,        0 },
2388 };
2389
2390 static AttrMap
2391 visualPolicy_map[] =
2392 {
2393     { ((unsigned long)~0L),     0,      0,
2394         VAL_ARG,        0 },
2395 };
2396
2397 static AttrMap
2398 waitForWm_map[] =
2399 {
2400     { ((unsigned long)~0L),     0,      0,
2401         VAL_ARG,        0 },
2402 };
2403
2404 static AttrMap
2405 whichButton_map[] =
2406 {
2407     { ((unsigned long)~0L),     0,      0,
2408         VAL_ARG,        0 },
2409 };
2410
2411 static AttrMap
2412 width_map[] =
2413 {
2414     { ((unsigned long)~0L),     Ofs(width),     sizeof(int),
2415         VAL_ARG,        0 },
2416 };
2417
2418 static AttrMap
2419 widthInc_map[] =
2420 {
2421     { ((unsigned long)~0L),     0,      0,
2422         VAL_ARG,        0 },
2423 };
2424
2425 static AttrMap
2426 winGravity_map[] =
2427 {
2428     { ((unsigned long)~0L),     0,      0,
2429         VAL_ARG,        0 },
2430 };
2431
2432 static AttrMap
2433 windowGroup_map[] =
2434 {
2435     { ((unsigned long)~0L),     0,      0,
2436         VAL_ARG,        0 },
2437 };
2438
2439 static AttrMap
2440 wmTimeout_map[] =
2441 {
2442     { ((unsigned long)~0L),     0,      0,
2443         VAL_ARG,        0 },
2444 };
2445
2446 static AttrMap
2447 wordWrap_map[] =
2448 {
2449     { BMASK(AB_TYPE_TEXT_PANE),
2450             0,          1,  /* size field must != 0, but unused for VAL_PROC */
2451         VAL_PROC,       (XtPointer) val_set_wordwrap_proc },
2452 };
2453
2454 static AttrMap
2455 workWindow_map[] =
2456 {
2457     { ((unsigned long)~0L),     0,      0,
2458         VAL_ARG,        0 },
2459 };
2460
2461 static AttrMap
2462 x_map[] =
2463 {
2464     { ((unsigned long)~0L),     Ofs(x), sizeof(int),
2465         VAL_ARG,        0 },
2466 };
2467
2468 static AttrMap
2469 y_map[] =
2470 {
2471     { ((unsigned long)~0L),     Ofs(y), sizeof(int),
2472         VAL_ARG,        0 },
2473 };
2474
2475 #undef Ofs
2476
2477 static ResourceAttrMap
2478 resource_attr_map[] =
2479 {
2480     { "XmNaccelerator",
2481         accelerator_map, XtNumber(accelerator_map) },
2482     { "XmNacceleratorText",
2483         acceleratorText_map, XtNumber(acceleratorText_map) },
2484     { "XmNaccelerators",
2485         accelerators_map, XtNumber(accelerators_map) },
2486     { "XmNadjustLast",
2487         adjustLast_map, XtNumber(adjustLast_map) },
2488     { "XmNadjustMargin",
2489         adjustMargin_map, XtNumber(adjustMargin_map) },
2490     { "XmNalignment",
2491         alignment_map, XtNumber(alignment_map) },
2492     { "XmNallowOverlap",
2493         allowOverlap_map, XtNumber(allowOverlap_map) },
2494     { "XmNallowResize",
2495         allowResize_map, XtNumber(allowResize_map) },
2496     { "XmNallowShellResize",
2497         allowShellResize_map, XtNumber(allowShellResize_map) },
2498     { "XmNancestorSensitive",
2499         ancestorSensitive_map, XtNumber(ancestorSensitive_map) },
2500     { "XmNapplyLabelString",
2501         applyLabelString_map, XtNumber(applyLabelString_map) },
2502     { "XmNarmColor",
2503         armColor_map, XtNumber(armColor_map) },
2504     { "XmNarmPixmap",
2505         armPixmap_map, XtNumber(armPixmap_map) },
2506     { "XmNarrowDirection",
2507         arrowDirection_map, XtNumber(arrowDirection_map) },
2508     { "XmNaudibleWarning",
2509         audibleWarning_map, XtNumber(audibleWarning_map) },
2510     { "XmNautoShowCursorPosition",
2511         autoShowCursorPosition_map, XtNumber(autoShowCursorPosition_map) },
2512     { "XmNautoUnmanage",
2513         autoUnmanage_map, XtNumber(autoUnmanage_map) },
2514     { "XmNautomaticSelection",
2515         automaticSelection_map, XtNumber(automaticSelection_map) },
2516     { "XmNbackground",
2517         background_map, XtNumber(background_map) },
2518     { "XmNbackgroundPixmap",
2519         backgroundPixmap_map, XtNumber(backgroundPixmap_map) },
2520     { "XmNbaseHeight",
2521         baseHeight_map, XtNumber(baseHeight_map) },
2522     { "XmNbaseWidth",
2523         baseWidth_map, XtNumber(baseWidth_map) },
2524     { "XmNblinkRate",
2525         blinkRate_map, XtNumber(blinkRate_map) },
2526     { "XmNborderColor",
2527         borderColor_map, XtNumber(borderColor_map) },
2528     { "XmNborderPixmap",
2529         borderPixmap_map, XtNumber(borderPixmap_map) },
2530     { "XmNborderWidth",
2531         borderWidth_map, XtNumber(borderWidth_map) },
2532     { "XmNbottomAttachment",
2533         bottomAttachment_map, XtNumber(bottomAttachment_map) },
2534     { "XmNbottomOffset",
2535         bottomOffset_map, XtNumber(bottomOffset_map) },
2536     { "XmNbottomPosition",
2537         bottomPosition_map, XtNumber(bottomPosition_map) },
2538     { "XmNbottomShadowColor",
2539         bottomShadowColor_map, XtNumber(bottomShadowColor_map) },
2540     { "XmNbottomShadowPixmap",
2541         bottomShadowPixmap_map, XtNumber(bottomShadowPixmap_map) },
2542     { "XmNbottomWidget",
2543         bottomWidget_map, XtNumber(bottomWidget_map) },
2544     { "XmNbuttonFontList",
2545         buttonFontList_map, XtNumber(buttonFontList_map) },
2546     { "XmNcancelButton",
2547         cancelButton_map, XtNumber(cancelButton_map) },
2548     { "XmNcancelLabelString",
2549         cancelLabelString_map, XtNumber(cancelLabelString_map) },
2550     { "XmNcascadePixmap",
2551         cascadePixmap_map, XtNumber(cascadePixmap_map) },
2552     { "XmNchildHorizontalAlignment",
2553         childHorizontalAlignment_map, XtNumber(childHorizontalAlignment_map) },
2554     { "XmNchildHorizontalSpacing",
2555         childHorizontalSpacing_map, XtNumber(childHorizontalSpacing_map) },
2556     { "XmNchildPlacement",
2557         childPlacement_map, XtNumber(childPlacement_map) },
2558     { "XmNchildType",
2559         childType_map, XtNumber(childType_map) },
2560     { "XmNchildVerticalAlignment",
2561         childVerticalAlignment_map, XtNumber(childVerticalAlignment_map) },
2562     { "XmNclipWindow",
2563         clipWindow_map, XtNumber(clipWindow_map) },
2564     { "XmNcolormap",
2565         colormap_map, XtNumber(colormap_map) },
2566     { "XmNcolumns",
2567         columns_map, XtNumber(columns_map) },
2568     { "XmNcommand",
2569         command_map, XtNumber(command_map) },
2570     { "XmNcommandWindow",
2571         commandWindow_map, XtNumber(commandWindow_map) },
2572     { "XmNcommandWindowLocation",
2573         commandWindowLocation_map, XtNumber(commandWindowLocation_map) },
2574     { "XmNcreatePopupChildProc",
2575         createPopupChildProc_map, XtNumber(createPopupChildProc_map) },
2576     { "XmNcursorPosition",
2577         cursorPosition_map, XtNumber(cursorPosition_map) },
2578     { "XmNcursorPositionVisible",
2579         cursorPositionVisible_map, XtNumber(cursorPositionVisible_map) },
2580     { "XmNdecimalPoints",
2581         decimalPoints_map, XtNumber(decimalPoints_map) },
2582     { "XmNdefaultButton",
2583         defaultButton_map, XtNumber(defaultButton_map) },
2584     { "XmNdefaultButtonShadowThickness",
2585         defaultButtonShadowThickness_map, XtNumber(defaultButtonShadowThickness_map) },
2586     { "XmNdefaultButtonType",
2587         defaultButtonType_map, XtNumber(defaultButtonType_map) },
2588     { "XmNdefaultFontList",
2589         defaultFontList_map, XtNumber(defaultFontList_map) },
2590     { "XmNdefaultPosition",
2591         defaultPosition_map, XtNumber(defaultPosition_map) },
2592     { "XmNdeleteResponse",
2593         deleteResponse_map, XtNumber(deleteResponse_map) },
2594     { "XmNdepth",
2595         depth_map, XtNumber(depth_map) },
2596     { "XmNdialogStyle",
2597         dialogStyle_map, XtNumber(dialogStyle_map) },
2598     { "XmNdialogTitle",
2599         dialogTitle_map, XtNumber(dialogTitle_map) },
2600     { "XmNdialogType",
2601         dialogType_map, XtNumber(dialogType_map) },
2602     { "XmNdirListItemCount",
2603         dirListItemCount_map, XtNumber(dirListItemCount_map) },
2604     { "XmNdirListItems",
2605         dirListItems_map, XtNumber(dirListItems_map) },
2606     { "XmNdirListLabelString",
2607         dirListLabelString_map, XtNumber(dirListLabelString_map) },
2608     { "XmNdirMask",
2609         dirMask_map, XtNumber(dirMask_map) },
2610     { "XmNdirSearchProc",
2611         dirSearchProc_map, XtNumber(dirSearchProc_map) },
2612     { "XmNdirSpec",
2613         dirSpec_map, XtNumber(dirSpec_map) },
2614     { "XmNdirectory",
2615         directory_map, XtNumber(directory_map) },
2616     { "XmNdoubleClickInterval",
2617         doubleClickInterval_map, XtNumber(doubleClickInterval_map) },
2618     { "XmNeditMode",
2619         editMode_map, XtNumber(editMode_map) },
2620     { "XmNeditable",
2621         editable_map, XtNumber(editable_map) },
2622     { "XmNentryAlignment",
2623         entryAlignment_map, XtNumber(entryAlignment_map) },
2624     { "XmNentryBorder",
2625         entryBorder_map, XtNumber(entryBorder_map) },
2626     { "XmNentryClass",
2627         entryClass_map, XtNumber(entryClass_map) },
2628     { "XmNentryVerticalAlignment",
2629         entryVerticalAlignment_map, XtNumber(entryVerticalAlignment_map) },
2630     { "XmNfileListItemCount",
2631         fileListItemCount_map, XtNumber(fileListItemCount_map) },
2632     { "XmNfileListItems",
2633         fileListItems_map, XtNumber(fileListItems_map) },
2634     { "XmNfileListLabelString",
2635         fileListLabelString_map, XtNumber(fileListLabelString_map) },
2636     { "XmNfileSearchProc",
2637         fileSearchProc_map, XtNumber(fileSearchProc_map) },
2638     { "XmNfileTypeMask",
2639         fileTypeMask_map, XtNumber(fileTypeMask_map) },
2640     { "XmNfillOnArm",
2641         fillOnArm_map, XtNumber(fillOnArm_map) },
2642     { "XmNfillOnSelect",
2643         fillOnSelect_map, XtNumber(fillOnSelect_map) },
2644     { "XmNfilterLabelString",
2645         filterLabelString_map, XtNumber(filterLabelString_map) },
2646     { "XmNfontList",
2647         fontList_map, XtNumber(fontList_map) },
2648     { "XmNforeground",
2649         foreground_map, XtNumber(foreground_map) },
2650     { "XmNfractionBase",
2651         fractionBase_map, XtNumber(fractionBase_map) },
2652     { "XmNgeometry",
2653         geometry_map, XtNumber(geometry_map) },
2654     { "XmNheight",
2655         height_map, XtNumber(height_map) },
2656     { "XmNheightInc",
2657         heightInc_map, XtNumber(heightInc_map) },
2658     { "XmNhelpLabelString",
2659         helpLabelString_map, XtNumber(helpLabelString_map) },
2660     { "XmNhighlightColor",
2661         highlightColor_map, XtNumber(highlightColor_map) },
2662     { "XmNhighlightOnEnter",
2663         highlightOnEnter_map, XtNumber(highlightOnEnter_map) },
2664     { "XmNhighlightPixmap",
2665         highlightPixmap_map, XtNumber(highlightPixmap_map) },
2666     { "XmNhighlightThickness",
2667         highlightThickness_map, XtNumber(highlightThickness_map) },
2668     { "XmNhistoryItemCount",
2669         historyItemCount_map, XtNumber(historyItemCount_map) },
2670     { "XmNhistoryItems",
2671         historyItems_map, XtNumber(historyItems_map) },
2672     { "XmNhistoryMaxItems",
2673         historyMaxItems_map, XtNumber(historyMaxItems_map) },
2674     { "XmNhistoryVisibleItemCount",
2675         historyVisibleItemCount_map, XtNumber(historyVisibleItemCount_map) },
2676     { "XmNhorizontalScrollBar",
2677         horizontalScrollBar_map, XtNumber(horizontalScrollBar_map) },
2678     { "XmNhorizontalSpacing",
2679         horizontalSpacing_map, XtNumber(horizontalSpacing_map) },
2680     { "XmNiconMask",
2681         iconMask_map, XtNumber(iconMask_map) },
2682     { "XmNiconName",
2683         iconName_map, XtNumber(iconName_map) },
2684     { "XmNiconNameEncoding",
2685         iconNameEncoding_map, XtNumber(iconNameEncoding_map) },
2686     { "XmNiconPixmap",
2687         iconPixmap_map, XtNumber(iconPixmap_map) },
2688     { "XmNiconWindow",
2689         iconWindow_map, XtNumber(iconWindow_map) },
2690     { "XmNiconX",
2691         iconX_map, XtNumber(iconX_map) },
2692     { "XmNiconY",
2693         iconY_map, XtNumber(iconY_map) },
2694     { "XmNiconic",
2695         iconic_map, XtNumber(iconic_map) },
2696     { "XmNincrement",
2697         increment_map, XtNumber(increment_map) },
2698     { "XmNindicatorOn",
2699         indicatorOn_map, XtNumber(indicatorOn_map) },
2700     { "XmNindicatorSize",
2701         indicatorSize_map, XtNumber(indicatorSize_map) },
2702     { "XmNindicatorType",
2703         indicatorType_map, XtNumber(indicatorType_map) },
2704     { "XmNinitialDelay",
2705         initialDelay_map, XtNumber(initialDelay_map) },
2706     { "XmNinitialFocus",
2707         initialFocus_map, XtNumber(initialFocus_map) },
2708     { "XmNinitialResourcesPersistent",
2709         initialResourcesPersistent_map, XtNumber(initialResourcesPersistent_map) },
2710     { "XmNinitialState",
2711         initialState_map, XtNumber(initialState_map) },
2712     { "XmNinput",
2713         input_map, XtNumber(input_map) },
2714     { "XmNinputMethod",
2715         inputMethod_map, XtNumber(inputMethod_map) },
2716     { "XmNinsertPosition",
2717         insertPosition_map, XtNumber(insertPosition_map) },
2718     { "XmNisAligned",
2719         isAligned_map, XtNumber(isAligned_map) },
2720     { "XmNisHomogeneous",
2721         isHomogeneous_map, XtNumber(isHomogeneous_map) },
2722     { "XmNitemCount",
2723         itemCount_map, XtNumber(itemCount_map) },
2724     { "XmNitems",
2725         items_map, XtNumber(items_map) },
2726     { "XmNkeyboardFocusPolicy",
2727         keyboardFocusPolicy_map, XtNumber(keyboardFocusPolicy_map) },
2728     { "XmNlabelFontList",
2729         labelFontList_map, XtNumber(labelFontList_map) },
2730     { "XmNlabelInsensitivePixmap",
2731         labelInsensitivePixmap_map, XtNumber(labelInsensitivePixmap_map) },
2732     { "XmNlabelPixmap",
2733         labelPixmap_map, XtNumber(labelPixmap_map) },
2734     { "XmNlabelString",
2735         labelString_map, XtNumber(labelString_map) },
2736     { "XmNlabelType",
2737         labelType_map, XtNumber(labelType_map) },
2738     { "XmNleftAttachment",
2739         leftAttachment_map, XtNumber(leftAttachment_map) },
2740     { "XmNleftOffset",
2741         leftOffset_map, XtNumber(leftOffset_map) },
2742     { "XmNleftPosition",
2743         leftPosition_map, XtNumber(leftPosition_map) },
2744     { "XmNleftWidget",
2745         leftWidget_map, XtNumber(leftWidget_map) },
2746     { "XmNlistItemCount",
2747         listItemCount_map, XtNumber(listItemCount_map) },
2748     { "XmNlistItems",
2749         listItems_map, XtNumber(listItems_map) },
2750     { "XmNlistLabelString",
2751         listLabelString_map, XtNumber(listLabelString_map) },
2752     { "XmNlistMarginHeight",
2753         listMarginHeight_map, XtNumber(listMarginHeight_map) },
2754     { "XmNlistMarginWidth",
2755         listMarginWidth_map, XtNumber(listMarginWidth_map) },
2756     { "XmNlistSizePolicy",
2757         listSizePolicy_map, XtNumber(listSizePolicy_map) },
2758     { "XmNlistSpacing",
2759         listSpacing_map, XtNumber(listSpacing_map) },
2760     { "XmNlistUpdated",
2761         listUpdated_map, XtNumber(listUpdated_map) },
2762     { "XmNlistVisibleItemCount",
2763         listVisibleItemCount_map, XtNumber(listVisibleItemCount_map) },
2764     { "XmNmainWindowMarginHeight",
2765         mainWindowMarginHeight_map, XtNumber(mainWindowMarginHeight_map) },
2766     { "XmNmainWindowMarginWidth",
2767         mainWindowMarginWidth_map, XtNumber(mainWindowMarginWidth_map) },
2768     { "XmNmappedWhenManaged",
2769         mappedWhenManaged_map, XtNumber(mappedWhenManaged_map) },
2770     { "XmNmappingDelay",
2771         mappingDelay_map, XtNumber(mappingDelay_map) },
2772     { "XmNmargin",
2773         margin_map, XtNumber(margin_map) },
2774     { "XmNmarginBottom",
2775         marginBottom_map, XtNumber(marginBottom_map) },
2776     { "XmNmarginHeight",
2777         marginHeight_map, XtNumber(marginHeight_map) },
2778     { "XmNmarginLeft",
2779         marginLeft_map, XtNumber(marginLeft_map) },
2780     { "XmNmarginRight",
2781         marginRight_map, XtNumber(marginRight_map) },
2782     { "XmNmarginTop",
2783         marginTop_map, XtNumber(marginTop_map) },
2784     { "XmNmarginWidth",
2785         marginWidth_map, XtNumber(marginWidth_map) },
2786     { "XmNmaxAspectX",
2787         maxAspectX_map, XtNumber(maxAspectX_map) },
2788     { "XmNmaxAspectY",
2789         maxAspectY_map, XtNumber(maxAspectY_map) },
2790     { "XmNmaxHeight",
2791         maxHeight_map, XtNumber(maxHeight_map) },
2792     { "XmNmaxLength",
2793         maxLength_map, XtNumber(maxLength_map) },
2794     { "XmNmaxWidth",
2795         maxWidth_map, XtNumber(maxWidth_map) },
2796     { "XmNmaximum",
2797         maximum_map, XtNumber(maximum_map) },
2798     { "XmNmenuAccelerator",
2799         menuAccelerator_map, XtNumber(menuAccelerator_map) },
2800     { "XmNmenuBar",
2801         menuBar_map, XtNumber(menuBar_map) },
2802     { "XmNmenuHelpWidget",
2803         menuHelpWidget_map, XtNumber(menuHelpWidget_map) },
2804     { "XmNmenuHistory",
2805         menuHistory_map, XtNumber(menuHistory_map) },
2806     { "XmNmenuPost",
2807         menuPost_map, XtNumber(menuPost_map) },
2808     { "XmNmessageAlignment",
2809         messageAlignment_map, XtNumber(messageAlignment_map) },
2810     { "XmNmessageString",
2811         messageString_map, XtNumber(messageString_map) },
2812     { "XmNmessageWindow",
2813         messageWindow_map, XtNumber(messageWindow_map) },
2814     { "XmNminAspectX",
2815         minAspectX_map, XtNumber(minAspectX_map) },
2816     { "XmNminAspectY",
2817         minAspectY_map, XtNumber(minAspectY_map) },
2818     { "XmNminHeight",
2819         minHeight_map, XtNumber(minHeight_map) },
2820     { "XmNminWidth",
2821         minWidth_map, XtNumber(minWidth_map) },
2822     { "XmNminimizeButtons",
2823         minimizeButtons_map, XtNumber(minimizeButtons_map) },
2824     { "XmNminimum",
2825         minimum_map, XtNumber(minimum_map) },
2826     { "XmNmnemonic",
2827         mnemonic_map, XtNumber(mnemonic_map) },
2828     { "XmNmnemonicCharSet",
2829         mnemonicCharSet_map, XtNumber(mnemonicCharSet_map) },
2830     { "XmNmultiClick",
2831         multiClick_map, XtNumber(multiClick_map) },
2832     { "XmNmustMatch",
2833         mustMatch_map, XtNumber(mustMatch_map) },
2834     { "XmNmwmDecorations",
2835         mwmDecorations_map, XtNumber(mwmDecorations_map) },
2836     { "XmNmwmFunctions",
2837         mwmFunctions_map, XtNumber(mwmFunctions_map) },
2838     { "XmNmwmInputMode",
2839         mwmInputMode_map, XtNumber(mwmInputMode_map) },
2840     { "XmNmwmMenu",
2841         mwmMenu_map, XtNumber(mwmMenu_map) },
2842     { "XmNnavigationType",
2843         navigationType_map, XtNumber(navigationType_map) },
2844     { "XmNnoMatchString",
2845         noMatchString_map, XtNumber(noMatchString_map) },
2846     { "XmNnoResize",
2847         noResize_map, XtNumber(noResize_map) },
2848     { "XmNnumColumns",
2849         numColumns_map, XtNumber(numColumns_map) },
2850     { "XmNokLabelString",
2851         okLabelString_map, XtNumber(okLabelString_map) },
2852     { "XmNorientation",
2853         orientation_map, XtNumber(orientation_map) },
2854     { "XmNoverrideRedirect",
2855         overrideRedirect_map, XtNumber(overrideRedirect_map) },
2856     { "XmNpacking",
2857         packing_map, XtNumber(packing_map) },
2858     { "XmNpageIncrement",
2859         pageIncrement_map, XtNumber(pageIncrement_map) },
2860     { "XmNpaneMaximum",
2861         paneMaximum_map, XtNumber(paneMaximum_map) },
2862     { "XmNpaneMinimum",
2863         paneMinimum_map, XtNumber(paneMinimum_map) },
2864     { "XmNpattern",
2865         pattern_map, XtNumber(pattern_map) },
2866     { "XmNpendingDelete",
2867         pendingDelete_map, XtNumber(pendingDelete_map) },
2868     { "XmNpopupEnabled",
2869         popupEnabled_map, XtNumber(popupEnabled_map) },
2870     { "XmNpositionIndex",
2871         positionIndex_map, XtNumber(positionIndex_map) },
2872     { "XmNpostFromCount",
2873         postFromCount_map, XtNumber(postFromCount_map) },
2874     { "XmNpostFromList",
2875         postFromList_map, XtNumber(postFromList_map) },
2876     { "XmNpreeditType",
2877         preeditType_map, XtNumber(preeditType_map) },
2878     { "XmNprocessingDirection",
2879         processingDirection_map, XtNumber(processingDirection_map) },
2880     { "XmNpromptString",
2881         promptString_map, XtNumber(promptString_map) },
2882     { "XmNpushButtonEnabled",
2883         pushButtonEnabled_map, XtNumber(pushButtonEnabled_map) },
2884     { "XmNqualifySearchDataProc",
2885         qualifySearchDataProc_map, XtNumber(qualifySearchDataProc_map) },
2886     { "XmNradioAlwaysOne",
2887         radioAlwaysOne_map, XtNumber(radioAlwaysOne_map) },
2888     { "XmNradioBehavior",
2889         radioBehavior_map, XtNumber(radioBehavior_map) },
2890     { "XmNrecomputeSize",
2891         recomputeSize_map, XtNumber(recomputeSize_map) },
2892     { "XmNrefigureMode",
2893         refigureMode_map, XtNumber(refigureMode_map) },
2894     { "XmNrepeatDelay",
2895         repeatDelay_map, XtNumber(repeatDelay_map) },
2896     { "XmNresizable",
2897         resizable_map, XtNumber(resizable_map) },
2898     { "XmNresizeHeight",
2899         resizeHeight_map, XtNumber(resizeHeight_map) },
2900     { "XmNresizePolicy",
2901         resizePolicy_map, XtNumber(resizePolicy_map) },
2902     { "XmNresizeWidth",
2903         resizeWidth_map, XtNumber(resizeWidth_map) },
2904     { "XmNrightAttachment",
2905         rightAttachment_map, XtNumber(rightAttachment_map) },
2906     { "XmNrightOffset",
2907         rightOffset_map, XtNumber(rightOffset_map) },
2908     { "XmNrightPosition",
2909         rightPosition_map, XtNumber(rightPosition_map) },
2910     { "XmNrightWidget",
2911         rightWidget_map, XtNumber(rightWidget_map) },
2912     { "XmNrowColumnType",
2913         rowColumnType_map, XtNumber(rowColumnType_map) },
2914     { "XmNrows",
2915         rows_map, XtNumber(rows_map) },
2916     { "XmNrubberPositioning",
2917         rubberPositioning_map, XtNumber(rubberPositioning_map) },
2918     { "XmNsashHeight",
2919         sashHeight_map, XtNumber(sashHeight_map) },
2920     { "XmNsashIndent",
2921         sashIndent_map, XtNumber(sashIndent_map) },
2922     { "XmNsashShadowThickness",
2923         sashShadowThickness_map, XtNumber(sashShadowThickness_map) },
2924     { "XmNsashWidth",
2925         sashWidth_map, XtNumber(sashWidth_map) },
2926     { "XmNsaveUnder",
2927         saveUnder_map, XtNumber(saveUnder_map) },
2928     { "XmNscaleHeight",
2929         scaleHeight_map, XtNumber(scaleHeight_map) },
2930     { "XmNscaleMultiple",
2931         scaleMultiple_map, XtNumber(scaleMultiple_map) },
2932     { "XmNscaleWidth",
2933         scaleWidth_map, XtNumber(scaleWidth_map) },
2934     { "XmNscreen",
2935         screen_map, XtNumber(screen_map) },
2936     { "XmNscrollBarDisplayPolicy",
2937         scrollBarDisplayPolicy_map, XtNumber(scrollBarDisplayPolicy_map) },
2938     { "XmNscrollBarPlacement",
2939         scrollBarPlacement_map, XtNumber(scrollBarPlacement_map) },
2940     { "XmNscrollHorizontal",
2941         scrollHorizontal_map, XtNumber(scrollHorizontal_map) },
2942     { "XmNscrollLeftSide",
2943         scrollLeftSide_map, XtNumber(scrollLeftSide_map) },
2944     { "XmNscrollTopSide",
2945         scrollTopSide_map, XtNumber(scrollTopSide_map) },
2946     { "XmNscrollVertical",
2947         scrollVertical_map, XtNumber(scrollVertical_map) },
2948     { "XmNscrolledWindowMarginHeight",
2949         scrolledWindowMarginHeight_map, XtNumber(scrolledWindowMarginHeight_map) },
2950     { "XmNscrolledWindowMarginWidth",
2951         scrolledWindowMarginWidth_map, XtNumber(scrolledWindowMarginWidth_map) },
2952     { "XmNscrollingPolicy",
2953         scrollingPolicy_map, XtNumber(scrollingPolicy_map) },
2954     { "XmNselectColor",
2955         selectColor_map, XtNumber(selectColor_map) },
2956     { "XmNselectInsensitivePixmap",
2957         selectInsensitivePixmap_map, XtNumber(selectInsensitivePixmap_map) },
2958     { "XmNselectPixmap",
2959         selectPixmap_map, XtNumber(selectPixmap_map) },
2960     { "XmNselectThreshold",
2961         selectThreshold_map, XtNumber(selectThreshold_map) },
2962     { "XmNselectedItemCount",
2963         selectedItemCount_map, XtNumber(selectedItemCount_map) },
2964     { "XmNselectedItems",
2965         selectedItems_map, XtNumber(selectedItems_map) },
2966     { "XmNselectionArray",
2967         selectionArray_map, XtNumber(selectionArray_map) },
2968     { "XmNselectionArrayCount",
2969         selectionArrayCount_map, XtNumber(selectionArrayCount_map) },
2970     { "XmNselectionLabelString",
2971         selectionLabelString_map, XtNumber(selectionLabelString_map) },
2972     { "XmNselectionPolicy",
2973         selectionPolicy_map, XtNumber(selectionPolicy_map) },
2974     { "XmNsensitive",
2975         sensitive_map, XtNumber(sensitive_map) },
2976     { "XmNseparatorOn",
2977         separatorOn_map, XtNumber(separatorOn_map) },
2978     { "XmNseparatorType",
2979         separatorType_map, XtNumber(separatorType_map) },
2980     { "XmNset",
2981         set_map, XtNumber(set_map) },
2982     { "XmNshadowThickness",
2983         shadowThickness_map, XtNumber(shadowThickness_map) },
2984     { "XmNshadowType",
2985         shadowType_map, XtNumber(shadowType_map) },
2986     { "XmNshellUnitType",
2987         shellUnitType_map, XtNumber(shellUnitType_map) },
2988     { "XmNshowArrows",
2989         showArrows_map, XtNumber(showArrows_map) },
2990     { "XmNshowAsDefault",
2991         showAsDefault_map, XtNumber(showAsDefault_map) },
2992     { "XmNshowSeparator",
2993         showSeparator_map, XtNumber(showSeparator_map) },
2994     { "XmNshowValue",
2995         showValue_map, XtNumber(showValue_map) },
2996     { "XmNskipAdjust",
2997         skipAdjust_map, XtNumber(skipAdjust_map) },
2998     { "XmNsliderSize",
2999         sliderSize_map, XtNumber(sliderSize_map) },
3000     { "XmNsource",
3001         source_map, XtNumber(source_map) },
3002     { "XmNspacing",
3003         spacing_map, XtNumber(spacing_map) },
3004     { "XmNstringDirection",
3005         stringDirection_map, XtNumber(stringDirection_map) },
3006     { "XmNsubMenuId",
3007         subMenuId_map, XtNumber(subMenuId_map) },
3008     { "XmNsymbolPixmap",
3009         symbolPixmap_map, XtNumber(symbolPixmap_map) },
3010     { "XmNtearOffModel",
3011         tearOffModel_map, XtNumber(tearOffModel_map) },
3012     { "XmNtextAccelerators",
3013         textAccelerators_map, XtNumber(textAccelerators_map) },
3014     { "XmNtextColumns",
3015         textColumns_map, XtNumber(textColumns_map) },
3016     { "XmNtextFontList",
3017         textFontList_map, XtNumber(textFontList_map) },
3018     { "XmNtextString",
3019         textString_map, XtNumber(textString_map) },
3020     { "XmNtextTranslations",
3021         textTranslations_map, XtNumber(textTranslations_map) },
3022     { "XmNtitle",
3023         title_map, XtNumber(title_map) },
3024     { "XmNtitleEncoding",
3025         titleEncoding_map, XtNumber(titleEncoding_map) },
3026     { "XmNtitleString",
3027         titleString_map, XtNumber(titleString_map) },
3028     { "XmNtopAttachment",
3029         topAttachment_map, XtNumber(topAttachment_map) },
3030     { "XmNtopCharacter",
3031         topCharacter_map, XtNumber(topCharacter_map) },
3032     { "XmNtopItemPosition",
3033         topItemPosition_map, XtNumber(topItemPosition_map) },
3034     { "XmNtopOffset",
3035         topOffset_map, XtNumber(topOffset_map) },
3036     { "XmNtopPosition",
3037         topPosition_map, XtNumber(topPosition_map) },
3038     { "XmNtopShadowColor",
3039         topShadowColor_map, XtNumber(topShadowColor_map) },
3040     { "XmNtopShadowPixmap",
3041         topShadowPixmap_map, XtNumber(topShadowPixmap_map) },
3042     { "XmNtopWidget",
3043         topWidget_map, XtNumber(topWidget_map) },
3044     { "XmNtransient",
3045         transient_map, XtNumber(transient_map) },
3046     { "XmNtransientFor",
3047         transientFor_map, XtNumber(transientFor_map) },
3048     { "XmNtranslations",
3049         translations_map, XtNumber(translations_map) },
3050     { "XmNtraversalOn",
3051         traversalOn_map, XtNumber(traversalOn_map) },
3052     { "XmNtroughColor",
3053         troughColor_map, XtNumber(troughColor_map) },
3054     { "XmNunitType",
3055         unitType_map, XtNumber(unitType_map) },
3056     { "XmNunpostBehavior",
3057         unpostBehavior_map, XtNumber(unpostBehavior_map) },
3058     { "XmNuseAsyncGeometry",
3059         useAsyncGeometry_map, XtNumber(useAsyncGeometry_map) },
3060     { "XmNuserData",
3061         userData_map, XtNumber(userData_map) },
3062     { "XmNvalue",
3063         value_map, XtNumber(value_map) },
3064     { "XmNvalueWcs",
3065         valueWcs_map, XtNumber(valueWcs_map) },
3066     { "XmNverifyBell",
3067         verifyBell_map, XtNumber(verifyBell_map) },
3068     { "XmNverticalScrollBar",
3069         verticalScrollBar_map, XtNumber(verticalScrollBar_map) },
3070     { "XmNverticalSpacing",
3071         verticalSpacing_map, XtNumber(verticalSpacing_map) },
3072     { "XmNvisibleItemCount",
3073         visibleItemCount_map, XtNumber(visibleItemCount_map) },
3074     { "XmNvisibleWhenOff",
3075         visibleWhenOff_map, XtNumber(visibleWhenOff_map) },
3076     { "XmNvisual",
3077         visual_map, XtNumber(visual_map) },
3078     { "XmNvisualPolicy",
3079         visualPolicy_map, XtNumber(visualPolicy_map) },
3080     { "XmNwaitForWm",
3081         waitForWm_map, XtNumber(waitForWm_map) },
3082     { "XmNwhichButton",
3083         whichButton_map, XtNumber(whichButton_map) },
3084     { "XmNwidth",
3085         width_map, XtNumber(width_map) },
3086     { "XmNwidthInc",
3087         widthInc_map, XtNumber(widthInc_map) },
3088     { "XmNwinGravity",
3089         winGravity_map, XtNumber(winGravity_map) },
3090     { "XmNwindowGroup",
3091         windowGroup_map, XtNumber(windowGroup_map) },
3092     { "XmNwmTimeout",
3093         wmTimeout_map, XtNumber(wmTimeout_map) },
3094     { "XmNwordWrap",
3095         wordWrap_map, XtNumber(wordWrap_map) },
3096     { "XmNworkWindow",
3097         workWindow_map, XtNumber(workWindow_map) },
3098     { "XmNx",
3099         x_map, XtNumber(x_map) },
3100     { "XmNy",
3101         y_map, XtNumber(y_map) },
3102 };
3103
3104
3105 #ifdef TEST
3106
3107 main(
3108     int         argc,
3109     char        **argv
3110 )
3111 {
3112     int i;
3113
3114     for (i = 0; i < XtNumber(resource_attr_map); i++)
3115     {
3116         int             j;
3117         ResourceAttrMap *this_map = &(resource_attr_map[i]);
3118
3119         printf("%s[%d]\n", this_map->resource_name, this_map->num_maps);
3120
3121         for (j = 0; j < this_map->num_maps; j++)
3122         {
3123             printf("    mask 0x%lx -> offset %d size %d\n",
3124                 this_map->attr_maps[j].obj_mask,
3125                 this_map->attr_maps[j].attr_offset,
3126                 this_map->attr_maps[j].attr_size);
3127         }
3128     }
3129 }
3130
3131 #endif /* TEST */
3132
3133
3134 static int
3135 compare_maps(
3136     const void  *a,
3137     const void  *b
3138 )
3139 {
3140     return(strcmp(
3141             ((ResourceAttrMap *)a)->resource_name,
3142             ((ResourceAttrMap *)b)->resource_name));
3143 }
3144
3145
3146 extern BOOL
3147 abuilP_store_attr_in_abobj(
3148     ABObj       obj,
3149     STRING      res_name,
3150     AB_ARG_TYPE res_type,
3151     XtPointer   res_value
3152 )
3153 {
3154     BOOL                ret_val = FALSE;
3155     ResourceAttrMap     key_map;
3156     ResourceAttrMap     *match;
3157
3158     key_map.resource_name = res_name;
3159
3160     /* REMIND: fprintf(stderr,"Checking resource %s\n",res_name); */
3161     match = (ResourceAttrMap*)bsearch((void *)&key_map,
3162                 resource_attr_map, XtNumber(resource_attr_map),
3163                 sizeof(ResourceAttrMap), compare_maps);
3164
3165     if (match != (ResourceAttrMap *)NULL && match->num_maps > 0)
3166     {
3167         AB_OBJECT_TYPE  ab_type = obj_get_type(obj);
3168         unsigned long   obj_mask = BMASK(ab_type);
3169         AttrMap         *maps = match->attr_maps;
3170         register int    i;
3171
3172         /* REMIND: fprintf(stderr,"Searching matched maps\n"); */
3173         for (i = 0; i < match->num_maps; i++)
3174         {
3175             /* REMIND:
3176             fprintf(stderr,"\tmask[%d] = %ld, obj = %ld\n", i,
3177                 maps[i].obj_mask, obj_mask);
3178             */
3179             if (maps[i].obj_mask & obj_mask && maps[i].attr_size > 0)
3180             {
3181                 /* REMIND:
3182                 fprintf(stderr,"Handling resource as type %d\n",
3183                         maps[i].value_type);
3184                 */
3185                 ret_val = TRUE;
3186                 switch(maps[i].value_type)
3187                 {
3188                   case VAL_ARG:
3189                     switch(res_type)
3190                     {
3191                       case AB_ARG_STRING:
3192                       case AB_ARG_XMSTRING:
3193                       case AB_ARG_LITERAL:
3194                         {
3195                             ISTRING istr_val = istr_create((STRING)res_value);
3196
3197                             memmove((char *)obj + maps[i].attr_offset,
3198                                         &istr_val, maps[i].attr_size);
3199                         }
3200                         break;
3201                       default:
3202                         memmove((char *)obj + maps[i].attr_offset,
3203                                 &res_value, maps[i].attr_size);
3204                         break;
3205                     }
3206                     break;
3207
3208                   case VAL_CONST:
3209                     memmove((char *)obj + maps[i].attr_offset,
3210                                 &(maps[i].const_value), maps[i].attr_size);
3211                     break;
3212
3213                   case VAL_PROC:
3214                     {
3215
3216                         VAL_PROC_HANDLER handler =
3217                             (VAL_PROC_HANDLER)maps[i].const_value;
3218
3219                         if (handler != (VAL_PROC_HANDLER)NULL)
3220                             ret_val = (*handler)(obj,
3221                                                 res_name, res_type, res_value);
3222                     }
3223                     break;
3224
3225                   case VAL_CONTEXT:
3226                     {
3227                         void    *ctx_addr = (void *)maps[i].const_value;
3228                         switch(res_type)
3229                         {
3230                           case AB_ARG_STRING:
3231                           case AB_ARG_XMSTRING:
3232                           case AB_ARG_LITERAL:
3233                             {
3234                                 ISTRING istr_val =
3235                                     istr_create((STRING)res_value);
3236
3237                                 memmove((char *)ctx_addr + maps[i].attr_offset,
3238                                         &istr_val, maps[i].attr_size);
3239                             }
3240                             break;
3241                           case AB_ARG_WIDGET:
3242                           case AB_ARG_VOID_PTR:
3243                             {
3244                                 ObjRef *ref =
3245                                     (ObjRef *)XtMalloc(sizeof(ObjRef));
3246
3247                                 ref->reference = (void *)res_value;
3248                                 if (res_type == AB_ARG_WIDGET)
3249                                     ref->is_resolved = FALSE;
3250                                 else
3251                                     ref->is_resolved = TRUE;
3252                                 memmove((char *)ctx_addr + maps[i].attr_offset,
3253                                         &ref, maps[i].attr_size);
3254                             }
3255                             break;
3256                           case AB_ARG_INT:
3257                             memmove((char *)ctx_addr + maps[i].attr_offset,
3258                                     &res_value, maps[i].attr_size);
3259                             break;
3260                         }
3261                     }
3262
3263                 }
3264             }
3265         }
3266     }
3267     return(ret_val);
3268 }
3269 \f
3270 extern void
3271 abuilP_init_context_attrs(
3272     void
3273 )
3274 {
3275     int i;
3276
3277     for (i = 0; i < XtNumber(AbuilP_attr_contexts); i++)
3278     {
3279         CONTEXT_INIT_HANDLER handler = AbuilP_attr_contexts[i]->init_handler;
3280
3281         if (handler != NULL)
3282             (*handler)(AbuilP_attr_contexts[i]);
3283     }
3284 }
3285
3286 extern void
3287 abuilP_store_context_attrs(
3288     ABObj       ab_widget
3289 )
3290 {
3291     int i;
3292
3293     for (i = 0; i < XtNumber(AbuilP_attr_contexts); i++)
3294     {
3295         CONTEXT_STORE_HANDLER handler = AbuilP_attr_contexts[i]->store_handler;
3296
3297         if (handler != NULL)
3298             (*handler)(ab_widget, AbuilP_attr_contexts[i]);
3299     }
3300 }
3301 \f
3302 static void
3303 attach_context_init(
3304     AnyContext  *context
3305 )
3306 {
3307     AttachmentContext   *attach_context = (AttachmentContext *)context;
3308
3309     attach_context->att_type = (ISTRING)NULL;
3310     attach_context->att_object = (ObjRef *)NULL;
3311     attach_context->att_position = 0;
3312     attach_context->att_offset   = 0;
3313 }
3314
3315 static void
3316 north_attach_context_store(
3317     ABObj       ab_widget,
3318     AnyContext  *attach_context
3319 )
3320 {
3321     attach_context_store(ab_widget, AB_CP_NORTH, attach_context);
3322 }
3323 static void
3324 south_attach_context_store(
3325     ABObj       ab_widget,
3326     AnyContext  *attach_context
3327 )
3328 {
3329     attach_context_store(ab_widget, AB_CP_SOUTH, attach_context);
3330 }
3331 static void
3332 east_attach_context_store(
3333     ABObj       ab_widget,
3334     AnyContext  *attach_context
3335 )
3336 {
3337     attach_context_store(ab_widget, AB_CP_EAST, attach_context);
3338 }
3339 static void
3340 west_attach_context_store(
3341     ABObj       ab_widget,
3342     AnyContext  *attach_context
3343 )
3344 {
3345     attach_context_store(ab_widget, AB_CP_WEST, attach_context);
3346 }
3347
3348 static void
3349 attach_context_store(
3350     ABObj               ab_widget,
3351     AB_COMPASS_POINT    dir,
3352     AnyContext          *context
3353 )
3354 {
3355     AttachmentContext   *attach_context = (AttachmentContext *)context;
3356     STRING              attach_str;
3357     AB_ATTACH_TYPE      att_type;
3358     int                 att_pos = 0, att_off = 0, offset = 0;
3359     void                *value  = NULL;
3360     BOOL                need_val = TRUE;
3361     ObjRef              *obj_ref;
3362
3363     /* Fetch attachment position out of appropriate context */
3364     att_pos = attach_context->att_position;
3365     att_off = attach_context->att_offset;
3366
3367     /* If no attachment, just return */
3368     if (attach_context->att_type == (ISTRING)NULL) return;
3369
3370     /* Get attachment type string */
3371     attach_str = istr_string(attach_context->att_type);
3372
3373     /*
3374     ** Set up attachment attributes based on attachment type
3375     **
3376     ** XmATTACH_NONE           : do nothing - just return
3377     ** XmATTACH_FORM           : attach directly to the form, plus offset
3378     **      value = form widget, offset = XmNfooOffset value (w.r.t. form)
3379     ** XmATTACH_OPPOSITE_FORM  : attach to opposite side of form, + offset
3380     **      value = form widget, offset = XmNfooOffset value (w.r.t. form)
3381     ** XmATTACH_WIDGET         : attach to opposite side of widget specified
3382     **                         : in attach_context
3383     **      value = att_object widget, offset = XmNfooOffset (w.r.t. target)
3384     ** XmATTACH_OPPOSITE_WIDGET: attach to same side of widget specified
3385     **                         : in attach_context
3386     **      value = att_object widget, offset = XmNfooOffset (w.r.t. target)
3387     ** XmATTACH_POSITION       : attach to position set in attach_context
3388     **      value = att_position, offset = att_offset
3389     ** XmATTACH_SELF           :
3390     */
3391
3392     if (strcmp(attach_str, "XmATTACH_NONE") == 0)
3393         return;
3394     else if (strcmp(attach_str, "XmATTACH_FORM") == 0)
3395     {
3396         att_type = AB_ATTACH_OBJ;
3397         value = obj_get_parent(ab_widget); need_val = FALSE;
3398         offset = att_off;
3399     }
3400     else if (strcmp(attach_str, "XmATTACH_OPPOSITE_FORM") == 0)
3401     {
3402         att_type = AB_ATTACH_ALIGN_OBJ_EDGE;
3403         value = obj_get_parent(ab_widget); need_val = FALSE;
3404         offset = att_off;
3405     }
3406     else if (strcmp(attach_str, "XmATTACH_WIDGET") == 0)
3407     {
3408         att_type = AB_ATTACH_OBJ;
3409         offset = att_off;
3410     }
3411     else if (strcmp(attach_str, "XmATTACH_OPPOSITE_WIDGET") == 0)
3412     {
3413         att_type = AB_ATTACH_ALIGN_OBJ_EDGE;
3414         offset = att_off;
3415     }
3416     else if (strcmp(attach_str, "XmATTACH_POSITION") == 0)
3417     {
3418         att_type = AB_ATTACH_GRIDLINE;
3419         value = (void *)att_pos; need_val = FALSE;
3420         offset = att_off;
3421     }
3422     else if (strcmp(attach_str, "XmATTACH_SELF") == 0)
3423         return;
3424
3425
3426     if (need_val == TRUE && (obj_ref = attach_context->att_object) != NULL)
3427     {
3428         if (!obj_ref->is_resolved)
3429         {
3430             RefResolve  *rr = (RefResolve *)XtMalloc(sizeof(RefResolve));
3431
3432             rr->obj   = ab_widget;
3433             rr->dir   = dir;
3434             abuil_add_unresolved_ref((void *)rr);
3435         }
3436         value = obj_ref->reference;
3437         XtFree((char *)obj_ref);
3438     }
3439     obj_set_attachment(ab_widget, dir, att_type, value, offset);
3440 }
3441
3442 static BOOL
3443 val_set_label_proc(
3444                     ABObj       obj,
3445                     STRING      res_name,
3446                     AB_ARG_TYPE res_type,
3447                     XtPointer   res_value
3448 )
3449 {
3450     if(obj_set_label(obj,(STRING)res_value)) return(FALSE);
3451     else return(TRUE);
3452 }
3453
3454 static BOOL
3455 val_set_labeltype_proc(
3456                     ABObj       obj,
3457                     STRING      res_name,
3458                     AB_ARG_TYPE res_type,
3459                     XtPointer   res_value
3460 )
3461 {
3462     int ret_val;
3463
3464     /* Convert XmPIXMAP or XmSTRING to AB_LABEL_* values */
3465     if(util_streq((STRING)res_value,"XmPIXMAP")) {
3466         ret_val = obj_set_label_type(obj,AB_LABEL_GLYPH);
3467     }
3468     else {
3469         ret_val = obj_set_label_type(obj,AB_LABEL_STRING);
3470     }
3471     if(ret_val) return(FALSE);
3472     else        return(TRUE);
3473 }
3474
3475 static BOOL
3476 val_set_rows_proc(
3477                     ABObj       obj,
3478                     STRING      res_name,
3479                     AB_ARG_TYPE res_type,
3480                     XtPointer   res_value
3481 )
3482 {
3483     if(obj_set_num_rows(obj,(int)res_value)) return(FALSE);
3484     else return(TRUE);
3485 }
3486
3487 static BOOL
3488 val_set_columns_proc(
3489                     ABObj       obj,
3490                     STRING      res_name,
3491                     AB_ARG_TYPE res_type,
3492                     XtPointer   res_value
3493 )
3494 {
3495     if(obj_set_num_columns(obj,(int)res_value)) return(FALSE);
3496     else return(TRUE);
3497 }
3498
3499 static BOOL
3500 val_set_maximum_proc(
3501                     ABObj       obj,
3502                     STRING      res_name,
3503                     AB_ARG_TYPE res_type,
3504                     XtPointer   res_value
3505 )
3506 {
3507     if(obj_set_max_value(obj,(int)res_value)) return(FALSE);
3508     else return(TRUE);
3509 }
3510
3511 static BOOL
3512 val_set_minimum_proc(
3513                     ABObj       obj,
3514                     STRING      res_name,
3515                     AB_ARG_TYPE res_type,
3516                     XtPointer   res_value
3517 )
3518 {
3519     if(obj_set_min_value(obj,(int)res_value)) return(FALSE);
3520     else return(TRUE);
3521 }
3522
3523 static BOOL
3524 val_set_numcols_proc(
3525                     ABObj       obj,
3526                     STRING      res_name,
3527                     AB_ARG_TYPE res_type,
3528                     XtPointer   res_value
3529 )
3530 {
3531     if(obj_set_num_columns(obj,(int)res_value)) return(FALSE);
3532     else return(TRUE);
3533 }
3534
3535 static BOOL
3536 val_set_orientation_proc(
3537                     ABObj       obj,
3538                     STRING      res_name,
3539                     AB_ARG_TYPE res_type,
3540                     XtPointer   res_value
3541 )
3542 {
3543     int         ret_val;
3544
3545     /* Convert XmPIXMAP or XmSTRING to AB_LABEL_* values */
3546     if(util_streq((STRING)res_value,"XmVERTICAL")) {
3547         ret_val = obj_set_orientation(obj,AB_ORIENT_VERTICAL);
3548     }
3549     else {
3550         ret_val = obj_set_orientation(obj,AB_ORIENT_HORIZONTAL);
3551     }
3552     if(ret_val) return(FALSE);
3553     else return(TRUE);
3554 }
3555
3556 static BOOL
3557 val_set_fg_proc(
3558                     ABObj       obj,
3559                     STRING      res_name,
3560                     AB_ARG_TYPE res_type,
3561                     XtPointer   res_value
3562 )
3563 {
3564     if(obj_set_fg_color(obj,(STRING)res_value)) return(FALSE);
3565     else return(TRUE);
3566 }
3567
3568 static BOOL
3569 val_set_bg_proc(
3570                     ABObj       obj,
3571                     STRING      res_name,
3572                     AB_ARG_TYPE res_type,
3573                     XtPointer   res_value
3574 )
3575 {
3576     if(obj_set_bg_color(obj,(STRING)res_value)) return(FALSE);
3577     else return(TRUE);
3578 }
3579
3580 static BOOL
3581 val_set_sensitive_proc(
3582                     ABObj       obj,
3583                     STRING      res_name,
3584                     AB_ARG_TYPE res_type,
3585                     XtPointer   res_value
3586 )
3587 {
3588     int ret_val;
3589
3590     if(res_value) {
3591         ret_val = obj_set_is_initially_active(obj,TRUE);
3592     }
3593     else {
3594         ret_val = obj_set_is_initially_active(obj,FALSE);
3595     }
3596     if(ret_val) return(FALSE);
3597     else return(TRUE);
3598 }
3599
3600 static BOOL
3601 val_set_mnemonic_proc(
3602                     ABObj       obj,
3603                     STRING      res_name,
3604                     AB_ARG_TYPE res_type,
3605                     XtPointer   res_value
3606 )
3607 {
3608     if(obj_set_mnemonic(obj,(STRING)res_value)) return(FALSE);
3609     else return(TRUE);
3610 }
3611
3612 static BOOL
3613 val_set_oklabel_proc(
3614                     ABObj       obj,
3615                     STRING      res_name,
3616                     AB_ARG_TYPE res_type,
3617                     XtPointer   res_value
3618 )
3619 {
3620     if(obj_set_ok_label(obj,(STRING)res_value)) return(FALSE);
3621     else return(TRUE);
3622 }
3623
3624 static BOOL
3625 val_set_autounmanage_proc(
3626                     ABObj       obj,
3627                     STRING      res_name,
3628                     AB_ARG_TYPE res_type,
3629                     XtPointer   res_value
3630 )
3631 {
3632     int ret_val;
3633
3634     if(res_value) ret_val = obj_set_auto_dismiss(obj,TRUE);
3635     else          ret_val = obj_set_auto_dismiss(obj,FALSE);
3636
3637     if(ret_val) return(FALSE);
3638     else return(TRUE);
3639 }
3640
3641 static BOOL
3642 val_set_directory_proc(
3643                     ABObj       obj,
3644                     STRING      res_name,
3645                     AB_ARG_TYPE res_type,
3646                     XtPointer   res_value
3647 )
3648 {
3649     if(obj_set_directory(obj,(STRING)res_value)) return(FALSE);
3650     else return(TRUE);
3651 }
3652
3653 static BOOL
3654 val_set_pattern_proc(
3655                     ABObj       obj,
3656                     STRING      res_name,
3657                     AB_ARG_TYPE res_type,
3658                     XtPointer   res_value
3659 )
3660 {
3661     if(obj_set_filter_pattern(obj,(STRING)res_value)) return(FALSE);
3662     else return(TRUE);
3663 }
3664
3665 static BOOL
3666 val_set_filetype_proc(
3667                     ABObj       obj,
3668                     STRING      res_name,
3669                     AB_ARG_TYPE res_type,
3670                     XtPointer   res_value
3671 )
3672 {
3673     AB_FILE_TYPE_MASK   ftm = AB_FILE_TYPE_MASK_UNDEF;
3674
3675     if(util_streq((STRING)res_value,"XmFILE_REGULAR")) {
3676         ftm = AB_FILE_REGULAR;
3677     }
3678     else {
3679         if(util_streq((STRING)res_value,"XmFILE_DIRECTORY")) {
3680             ftm = AB_FILE_DIRECTORY;
3681         }
3682         else {
3683            if(util_streq((STRING)res_value,"XmFILE_ANY")) {
3684             ftm = AB_FILE_ANY;
3685            }
3686         }
3687     }
3688     if(obj_set_file_type_mask(obj,ftm)) return(FALSE);
3689     else return(TRUE);
3690 }
3691
3692 static BOOL
3693 val_set_maxlen_proc(
3694                     ABObj       obj,
3695                     STRING      res_name,
3696                     AB_ARG_TYPE res_type,
3697                     XtPointer   res_value
3698 )
3699 {
3700     if(obj_set_max_length(obj,(int)res_value)) return(FALSE);
3701     else return(TRUE);
3702 }
3703
3704 static BOOL
3705 val_set_panemax_proc(
3706                     ABObj       obj,
3707                     STRING      res_name,
3708                     AB_ARG_TYPE res_type,
3709                     XtPointer   res_value
3710 )
3711 {
3712     if(obj_set_pane_max(obj,(int)res_value)) return(FALSE);
3713     else return(TRUE);
3714 }
3715
3716 static BOOL
3717 val_set_panemin_proc(
3718                     ABObj       obj,
3719                     STRING      res_name,
3720                     AB_ARG_TYPE res_type,
3721                     XtPointer   res_value
3722 )
3723 {
3724     if(obj_set_pane_min(obj,(int)res_value)) return(FALSE);
3725     else return(TRUE);
3726 }
3727
3728 static BOOL
3729 val_set_intvalue_proc(
3730                     ABObj       obj,
3731                     STRING      res_name,
3732                     AB_ARG_TYPE res_type,
3733                     XtPointer   res_value
3734 )
3735 {
3736     if(obj_set_initial_value_int(obj,(int)res_value)) return(FALSE);
3737     else return(TRUE);
3738 }
3739
3740 static BOOL
3741 val_set_strvalue_proc(
3742                     ABObj       obj,
3743                     STRING      res_name,
3744                     AB_ARG_TYPE res_type,
3745                     XtPointer   res_value
3746 )
3747 {
3748     if(obj_set_initial_value_string(obj,(STRING)res_value)) return(FALSE);
3749     else return(TRUE);
3750 }
3751
3752 static BOOL
3753 val_set_increment_proc(
3754                     ABObj       obj,
3755                     STRING      res_name,
3756                     AB_ARG_TYPE res_type,
3757                     XtPointer   res_value
3758 )
3759 {
3760     if(obj_set_increment(obj,(int)res_value)) return(FALSE);
3761     else return(TRUE);
3762 }
3763
3764 static BOOL
3765 val_set_decpts_proc(
3766                     ABObj       obj,
3767                     STRING      res_name,
3768                     AB_ARG_TYPE res_type,
3769                     XtPointer   res_value
3770 )
3771 {
3772     if(obj_set_decimal_points(obj,(int)res_value)) return(FALSE);
3773     else return(TRUE);
3774 }
3775
3776 static BOOL
3777 val_set_showval_proc(
3778                     ABObj       obj,
3779                     STRING      res_name,
3780                     AB_ARG_TYPE res_type,
3781                     XtPointer   res_value
3782 )
3783 {
3784     int ret_val;
3785
3786     if(res_value) ret_val = obj_set_show_value(obj,TRUE);
3787     else          ret_val = obj_set_show_value(obj,FALSE);
3788
3789     if(ret_val) return(FALSE);
3790     else return(TRUE);
3791 }
3792
3793 static BOOL
3794 val_set_scrollh_proc(
3795                     ABObj       obj,
3796                     STRING      res_name,
3797                     AB_ARG_TYPE res_type,
3798                     XtPointer   res_value
3799 )
3800 {
3801     int ret_val;
3802
3803     if(res_value) ret_val = obj_set_hscrollbar_policy(obj,AB_SCROLLBAR_ALWAYS);
3804     else          ret_val = obj_set_hscrollbar_policy(obj,AB_SCROLLBAR_NEVER);
3805
3806     if(ret_val) return(FALSE);
3807     else return(TRUE);
3808 }
3809
3810 static BOOL
3811 val_set_scrollv_proc(
3812                     ABObj       obj,
3813                     STRING      res_name,
3814                     AB_ARG_TYPE res_type,
3815                     XtPointer   res_value
3816 )
3817 {
3818     int ret_val;
3819
3820     if(res_value) ret_val = obj_set_vscrollbar_policy(obj,AB_SCROLLBAR_ALWAYS);
3821     else          ret_val = obj_set_vscrollbar_policy(obj,AB_SCROLLBAR_NEVER);
3822
3823     if(ret_val) return(FALSE);
3824     else return(TRUE);
3825 }
3826
3827 static ABuilStrIntMap linestyle_map[] = {
3828         {"XmSINGLE_LINE",               AB_LINE_SINGLE_LINE},
3829         {"XmDOUBLE_LINE",               AB_LINE_DOUBLE_LINE},
3830         {"XmSINGLE_DASHED_LINE",        AB_LINE_SINGLE_DASHED_LINE},
3831         {"XmDOUBLE_DASHED_LINE",        AB_LINE_DOUBLE_DASHED_LINE},
3832         {"XmNO_LINE",                   AB_LINE_NONE},
3833         {"XmSHADOW_ETCHED_IN",          AB_LINE_ETCHED_IN},
3834         {"XmSHADOW_ETCHED_OUT",         AB_LINE_ETCHED_OUT},
3835         {"XmSHADOW_ETCHED_IN_DASH",     AB_LINE_ETCHED_IN_DASH},
3836         {"XmSHADOW_ETCHED_OUT_DASH",    AB_LINE_ETCHED_OUT_DASH},
3837 };
3838
3839 static BOOL
3840 val_set_linestyle_proc(
3841                     ABObj       obj,
3842                     STRING      res_name,
3843                     AB_ARG_TYPE res_type,
3844                     XtPointer   res_value
3845 )
3846 {
3847     int                 i;
3848     AB_LINE_TYPE        linestyle = AB_LINE_NONE;
3849
3850     for(i=0;i<XtNumber(linestyle_map);i++) {
3851         if(util_streq((STRING)res_value,linestyle_map[i].string)) {
3852                 linestyle = (AB_LINE_TYPE) linestyle_map[i].value;
3853                 break;
3854         }
3855     }
3856     /*
3857       fprintf(stderr,"SeparatorType %s = linestyle %d (#%d)\n",
3858         res_value,linestyle,i);
3859     */
3860     if(obj_set_line_style(obj,linestyle)) return(FALSE);
3861     else return(TRUE);
3862 }
3863
3864 static ABuilStrIntMap border_map[] = {
3865         {"XmSHADOW_IN",                 AB_LINE_SHADOW_IN},
3866         {"XmSHADOW_OUT",                AB_LINE_SHADOW_OUT},
3867         {"XmSHADOW_ETCHED_IN",          AB_LINE_ETCHED_IN},
3868         {"XmSHADOW_ETCHED_OUT",         AB_LINE_ETCHED_OUT},
3869 };
3870
3871 static BOOL
3872 val_set_border_proc(
3873                     ABObj       obj,
3874                     STRING      res_name,
3875                     AB_ARG_TYPE res_type,
3876                     XtPointer   res_value
3877 )
3878 {
3879     int                 i;
3880     AB_LINE_TYPE        border = AB_LINE_NONE;
3881
3882     for(i=0;i<XtNumber(border_map);i++) {
3883         if(util_streq((STRING)res_value,border_map[i].string)) {
3884                 border = (AB_LINE_TYPE) border_map[i].value;
3885                 break;
3886         }
3887     }
3888     /*
3889       fprintf(stderr,"ShadowType %s = linestyle %d (#%d)\n",res_value,border,i);
3890     */
3891     if(obj_set_border_frame(obj,border)) return(FALSE);
3892     else return(TRUE);
3893 }
3894
3895 static BOOL
3896 val_set_wordwrap_proc(
3897                     ABObj       obj,
3898                     STRING      res_name,
3899                     AB_ARG_TYPE res_type,
3900                     XtPointer   res_value
3901 )
3902 {
3903     int ret_val;
3904
3905     if(res_value) ret_val = obj_set_word_wrap(obj,TRUE);
3906     else          ret_val = obj_set_word_wrap(obj,TRUE);
3907
3908     if(ret_val) return(FALSE);
3909     else return(TRUE);
3910 }
3911
3912 static BOOL
3913 val_set_packing_proc(
3914                     ABObj       obj,
3915                     STRING      res_name,
3916                     AB_ARG_TYPE res_type,
3917                     XtPointer   res_value
3918 )
3919 {
3920     if(util_streq((STRING)res_value,"XmPACK_NONE")) {
3921         /* obj_set_packing(obj,AB_PACK_NONE); */
3922         obj->info.container.packing = AB_PACK_NONE;
3923         return(TRUE);
3924     }
3925     if(util_streq((STRING)res_value,"XmPACK_TIGHT")) {
3926         /* obj_set_packing(obj,AB_PACK_TIGHT); */
3927         obj->info.container.packing = AB_PACK_TIGHT;
3928         return(TRUE);
3929     }
3930     if(util_streq((STRING)res_value,"XmPACK_COLUMN")) {
3931         /* obj_set_packing(obj,AB_PACK_EQUAL); */
3932         obj->info.container.packing = AB_PACK_EQUAL;
3933         return(TRUE);
3934     }
3935     return(FALSE);
3936 }
3937
3938 /* This routine is used for map dispatch debugging */
3939 static BOOL
3940 val_proc_debug(
3941                     ABObj       obj,
3942                     STRING      res_name,
3943                     AB_ARG_TYPE res_type,
3944                     XtPointer   res_value
3945 )
3946 {
3947     fprintf(stderr,"Mapping resource \"%s\" for object %s",res_name,
3948         obj_get_name(obj));
3949     switch(res_type)
3950     {
3951       case AB_ARG_STRING:
3952       case AB_ARG_LITERAL:
3953           fprintf(stderr,", value = %s\n",res_value); break;
3954       case AB_ARG_INT:
3955           fprintf(stderr,", value = %d\n",res_value); break;
3956       case AB_ARG_FLOAT:
3957           fprintf(stderr,", value = %g\n",res_value); break;
3958       case AB_ARG_BOOLEAN:
3959           if(res_value) fprintf(stderr,", value = TRUE\n");
3960           else          fprintf(stderr,", value = FALSE\n");
3961           break;
3962       case AB_ARG_XMSTRING:
3963       case AB_ARG_XMSTRING_TBL:
3964       case AB_ARG_WIDGET:
3965       case AB_ARG_PIXEL:
3966       case AB_ARG_PIXMAP:
3967       case AB_ARG_FONT:
3968       case AB_ARG_VOID_PTR:
3969       case AB_ARG_CALLBACK:
3970       case AB_ARG_VARIABLE:
3971       case AB_ARG_MNEMONIC:
3972       default:
3973           fprintf(stderr,"\n");
3974     }
3975
3976     return(TRUE);
3977 }