cde/programs/dtcreate/FileCharacteristics.c

   1 /*
   2  * CDE - Common Desktop Environment
   3  *
   4  * Copyright (c) 1993-2012, The Open Group. All rights reserved.
   5  *
   6  * These libraries and programs are free software; you can
   7  * redistribute them and/or modify them under the terms of the GNU
   8  * Lesser General Public License as published by the Free Software
   9  * Foundation; either version 2 of the License, or (at your option)
  10  * any later version.
  11  *
  12  * These libraries and programs are distributed in the hope that
  13  * they will be useful, but WITHOUT ANY WARRANTY; without even the
  14  * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  15  * PURPOSE. See the GNU Lesser General Public License for more
  16  * details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with these librararies and programs; if not, write
  20  * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
  21  * Floor, Boston, MA 02110-1301 USA
  22  */
  23 /* $TOG: FileCharacteristics.c /main/7 1999/09/17 15:43:31 mgreess $ */
  24
  25 /*******************************************************************************
  26         FileCharacteristics.c
  27
  28        Associated Header file: FileCharacteristics.h
  29 *******************************************************************************/
  30
  31 #include <stdio.h>
  32 #include <sys/stat.h>
  33 #include <string.h>
  34
  35 #include <Xm/Xm.h>
  36 #include <Xm/MwmUtil.h>
  37 #include <Xm/DialogS.h>
  38 #include <Xm/MenuShell.h>
  39 #include <Xm/RowColumn.h>
  40 #include <Xm/Form.h>
  41 #include <Xm/ToggleBG.h>
  42 #include <Xm/TextF.h>
  43 #include <Xm/Label.h>
  44 #include <Xm/PushBG.h>
  45 #include <Xm/Form.h>
  46 #include <Xm/ScrolledW.h>
  47
  48 #include "UxXt.h"
  49 #include "dtcreate.h"
  50 #include "cmncbs.h"
  51
  52 #define CONTEXT_MACRO_ACCESS 1
  53 #include "FileCharacteristics.h"
  54 #undef CONTEXT_MACRO_ACCESS
  55
  56 /*******************************************************************************
  57        Includes, Defines, and Global variables from the Declarations Editor:
  58 *******************************************************************************/
  59
  60 /*
  61 int     set=1;
  62 */
  63 Widget  FC_ReadOnToggle, FC_ReadOffToggle, FC_ReadEitherToggle;
  64 Widget  FC_WriteOnToggle, FC_WriteOffToggle, FC_WriteEitherToggle;
  65 Widget  FC_ExecuteOnToggle, FC_ExecuteOffToggle, FC_ExecuteEitherToggle;
  66 Widget  FC_PermissionForm;
  67 Widget  FC_ReadLabel;
  68 Widget  FC_WriteLabel;
  69 Widget  FC_ExecuteLabel;
  70
  71 /******************************************************************************/
  72 /*                                                                            */
  73 /* GetPermissionsPattern                                                      */
  74 /*                                                                            */
  75 /* INPUT: none                                                                */
  76 /* OUTPUT: permissions pattern in database format                             */
  77 /*                                                                            */
  78 /******************************************************************************/
  79 void GetPermissionsPattern(char **ppszPermPattern)
  80
  81 {
  82   if (*ppszPermPattern) {
  83      XtFree(*ppszPermPattern);
  84      *ppszPermPattern = (char *)NULL;
  85   }
  86
  87   *ppszPermPattern = (char *)XtMalloc(20);
  88   memset(*ppszPermPattern, 0, 20);
  89
  90   if (XmToggleButtonGadgetGetState(FC_DirectoryToggle)) {
  91     strcat(*ppszPermPattern, "d");
  92   } else {
  93     strcat(*ppszPermPattern, "!d");
  94   }
  95
  96   if (XmToggleButtonGadgetGetState(FC_PermissionToggle)) {
  97      /******************************************************************/
  98      /* Get Read state                                                 */
  99      /******************************************************************/
 100      if (XmToggleButtonGadgetGetState(FC_ReadOnToggle)) {
 101         strcat(*ppszPermPattern, "&r");
 102      } else {
 103         if (XmToggleButtonGadgetGetState(FC_ReadOffToggle)) {
 104            strcat(*ppszPermPattern, "&!r");
 105         }
 106      }
 107      /******************************************************************/
 108      /* Get Write state                                                */
 109      /******************************************************************/
 110      if (XmToggleButtonGadgetGetState(FC_WriteOnToggle)) {
 111         strcat(*ppszPermPattern, "&w");
 112      } else {
 113        if (XmToggleButtonGadgetGetState(FC_WriteOffToggle)) {
 114           strcat(*ppszPermPattern, "&!w");
 115        }
 116      }
 117      /******************************************************************/
 118      /* Get Execute state                                              */
 119      /******************************************************************/
 120      if (XmToggleButtonGadgetGetState(FC_ExecuteOnToggle)) {
 121         strcat(*ppszPermPattern, "&x");
 122      } else {
 123         if (XmToggleButtonGadgetGetState(FC_ExecuteOffToggle)) {
 124            strcat(*ppszPermPattern, "&!x");
 125         }
 126      }
 127   }
 128
 129 #if 0
 130   if (XmToggleButtonGadgetGetState(FC_PermissionToggle)) {
 131      if (XmToggleButtonGadgetGetState(FC_ReadToggle)) {
 132        strcat(*ppszPermPattern, "&r");
 133      } else {
 134        strcat(*ppszPermPattern, "&!r");
 135      }
 136      if (XmToggleButtonGadgetGetState(FC_WriteToggle)) {
 137        strcat(*ppszPermPattern, "&w");
 138      } else {
 139        strcat(*ppszPermPattern, "&!w");
 140      }
 141      if (XmToggleButtonGadgetGetState(FC_ExecuteToggle)) {
 142        strcat(*ppszPermPattern, "&x");
 143      } else {
 144        strcat(*ppszPermPattern, "&!x");
 145      }
 146   }
 147 #endif
 148 }
 149
 150 /******************************************************************************/
 151 /*                                                                            */
 152 /* GetContentsType                                                            */
 153 /*                                                                            */
 154 /* INPUT: none                                                                */
 155 /* OUTPUT: contents type selected                                             */
 156 /*                                                                            */
 157 /******************************************************************************/
 158 ushort GetContentsType(void)
 159
 160 {
 161   if (XmToggleButtonGadgetGetState(FC_StringToggle)) {
 162     return((ushort)CA_FT_CNTSTRING);
 163   } else if (XmToggleButtonGadgetGetState(FC_ByteToggle)) {
 164     return((ushort)CA_FT_CNTBYTE);
 165   } else if (XmToggleButtonGadgetGetState(FC_ShortToggle)) {
 166     return((ushort)CA_FT_CNTSHORT);
 167   } else if (XmToggleButtonGadgetGetState(FC_LongToggle)) {
 168     return((ushort)CA_FT_CNTLONG);
 169   }
 170 }
 171
 172 /******************************************************************************/
 173 /*                                                                            */
 174 /* Save_FileChar_Info                                                         */
 175 /*                                                                            */
 176 /* INPUT: none                                                                */
 177 /* OUTPUT: none                                                               */
 178 /*                                                                            */
 179 /******************************************************************************/
 180 void Save_FileChar_Info(void)
 181
 182 {
 183   FiletypeData *pFtD;
 184   char         *ptr = (char *)NULL;
 185   short        sContentsType;
 186
 187   /**************************************************************************/
 188   /* Clear file characteristics text widget on the AddFiletype dialog.      */
 189   /**************************************************************************/
 190   XmTextSetString(AF_IdCharacteristicsText, "");
 191
 192   /**************************************************************************/
 193   /* Get pointer to FiletypeData structure.                                 */
 194   /* Also, update the filetypes listbox on the AddFiletype window.          */
 195   /**************************************************************************/
 196   XtVaGetValues(FileCharacteristics,
 197                 XmNuserData, &pFtD,
 198                 NULL);
 199
 200   /**************************************************************************/
 201   /* Get Name Pattern Info                                                  */
 202   /**************************************************************************/
 203   if (XmToggleButtonGadgetGetState(FC_NameOrPathToggle)) {
 204     GetWidgetTextString(FC_NameOrPathText, &(pFtD->pszPattern));
 205 #if DEBUG
 206     printf("Pattern is '%s'\n", pFtD->pszPattern);
 207 #endif
 208   } else {
 209     if (pFtD->pszPattern) {
 210        XtFree(pFtD->pszPattern);
 211        pFtD->pszPattern = (char *)NULL;
 212     }
 213   }
 214
 215   /**************************************************************************/
 216   /* Get Permission Info                                                    */
 217   /**************************************************************************/
 218   GetPermissionsPattern(&(pFtD->pszPermissions));
 219
 220   /**************************************************************************/
 221   /* Get Content Pattern Info                                               */
 222   /**************************************************************************/
 223   if (XmToggleButtonGadgetGetState(FC_ContentsToggle)) {
 224
 225     /************************************************************************/
 226     /* Save data in structure.                                              */
 227     /************************************************************************/
 228     GetWidgetTextString(FC_ContentsPatternText, &(pFtD->pszContents));
 229     ptr = (char *)NULL;
 230     GetWidgetTextString(FC_StartByteTextField, &ptr);
 231     if (ptr) {
 232        pFtD->sStart = atoi(ptr);
 233        XtFree(ptr);
 234     }
 235 #if 0
 236     ptr = (char *)NULL;
 237     GetWidgetTextString(FC_EndByteTextField, &ptr);
 238     if (ptr) {
 239        pFtD->sEnd = atoi(ptr);
 240        XtFree(ptr);
 241     }
 242 #endif
 243     pFtD->fsFlags = GetContentsType();
 244
 245   } else {
 246     if (pFtD->pszContents) {
 247        XtFree(pFtD->pszContents);
 248        pFtD->pszContents = (char *)NULL;
 249     }
 250     pFtD->sStart = 0;
 251   }
 252
 253   /**************************************************************************/
 254   /* Parse the ID fields in the FiletypeData structure and create a text    */
 255   /* string for the Identifying Characteristics text field in AddFiletype.  */
 256   /**************************************************************************/
 257   ParseAndUpdateID(pFtD);
 258
 259 }
 260
 261 /******************************************************************************/
 262 /*                                                                            */
 263 /* ParseAndUpdateID                                                           */
 264 /*                                                                            */
 265 /* INPUT: none                                                                */
 266 /* OUTPUT: none                                                               */
 267 /*                                                                            */
 268 /******************************************************************************/
 269 void ParseAndUpdateID(FiletypeData *pFtD)
 270
 271 {
 272   char    *ptr = (char *)NULL;
 273   int     size;
 274
 275   /**************************************************************************/
 276   /* Init size variable.  This will be used to indicate size of buffer to   */
 277   /* allocate to hold text string that will be displayed in FC text widget. */
 278   /**************************************************************************/
 279   size = 0;
 280
 281   /**************************************************************************/
 282   /* Get Name Pattern Info                                                  */
 283   /**************************************************************************/
 284   if (pFtD->pszPattern) {
 285      /*size += strlen("Name: ");*/
 286      size += strlen(GETMESSAGE(9, 20, "Name Pattern:")) + 1; /* 1 for space */
 287      size += strlen(pFtD->pszPattern);
 288      size += 1;                                    /* For newline character */
 289   }
 290
 291   /**************************************************************************/
 292   /* Get Permission Info                                                    */
 293   /**************************************************************************/
 294   if (pFtD->pszPermissions) {
 295      size += strlen(GETMESSAGE(9, 21, "Permission Pattern:")) + 1; /* space */
 296      size += strlen(pFtD->pszPermissions);
 297      size += 1;                                    /* For newline character */
 298   }
 299
 300   /**************************************************************************/
 301   /* Get Content Pattern Info                                               */
 302   /**************************************************************************/
 303   if (pFtD->pszContents) {
 304      size += strlen(GETMESSAGE(9, 28, "Contents:")) + 1;     /* 1 for space */
 305      size += strlen(pFtD->pszContents);
 306      size += 1;                                    /* For newline character */
 307   }
 308
 309   /**************************************************************************/
 310   /* Allocate buffer and fill with ID info.                                 */
 311   /**************************************************************************/
 312   if (size > 0) {
 313     ptr = XtMalloc(size);
 314     if (ptr) {
 315        memset(ptr, 0, size);
 316        if (pFtD->pszPattern) {
 317           strcat(ptr, GETMESSAGE(9, 20, "Name Pattern:"));
 318           strcat(ptr, " ");
 319           strcat(ptr, pFtD->pszPattern);
 320           strcat(ptr, "\n");
 321        }
 322        if (pFtD->pszPermissions) {
 323           strcat(ptr, GETMESSAGE(9, 21, "Permission Pattern:"));
 324           strcat(ptr, " ");
 325           strcat(ptr, pFtD->pszPermissions);
 326           strcat(ptr, "\n");
 327        }
 328        if (pFtD->pszContents) {
 329           strcat(ptr, GETMESSAGE(9, 28, "Contents:"));
 330           strcat(ptr, " ");
 331           strcat(ptr, pFtD->pszContents);
 332           strcat(ptr, "\n");
 333        }
 334        XmTextSetString(AF_IdCharacteristicsText, ptr);
 335        XtFree(ptr);
 336     }
 337   }
 338 }
 339
 340 /*****************************************************************************/
 341 /*                                                                           */
 342 /*  CalculateAND                                                             */
 343 /*                                                                           */
 344 /*                                                                           */
 345 /*****************************************************************************/
 346 void CalculateAND(void)
 347 {
 348   Boolean set1, set2, set3, set4;
 349   int     cnt;
 350
 351   XtVaGetValues(FC_NameOrPathToggle, XmNset, &set1, NULL);
 352   XtVaGetValues(FC_PermissionToggle, XmNset, &set2, NULL);
 353   XtVaGetValues(FC_ContentsToggle, XmNset, &set3, NULL);
 354   XtSetSensitive(FC_AndLabel1, False);
 355   XtSetSensitive(FC_AndLabel2, False);
 356
 357   cnt = (int)set1 + (int)set2 + (int)set3;
 358     if (set1 && (set2 || set3))
 359           XtSetSensitive(FC_AndLabel1, True);
 360     if (set2 && set3)
 361           XtSetSensitive(FC_AndLabel2, True);
 362 }
 363
 364 /*******************************************************************************
 365        The following are callback functions.
 366 *******************************************************************************/
 367
 368 static  void    activateCB_FC_OkButton( Widget  UxWidget,
 369                                         XtPointer UxClientData,
 370                                         XtPointer UxCallbackArg)
 371
 372 {
 373   if (!FileCharCheckFields()) {
 374      Save_FileChar_Info();
 375      UxPopdownInterface(FileCharacteristics);
 376   }
 377 }
 378
 379 static  void    activateCB_FC_ClearButton(Widget UxWidget,
 380                                           XtPointer UxClientData,
 381                                           XtPointer UxCallbackArg)
 382
 383 {
 384   /* Clear_FileChar_Info(); */
 385   clear_FileCharacteristics_dialog_fields();
 386 }
 387
 388 static  void    activateCB_FC_CancelButton(Widget UxWidget,
 389                                           XtPointer UxClientData,
 390                                           XtPointer UxCallbackArg)
 391 {
 392       /*
 393         _UxCFileCharacteristics *UxSaveCtx, *UxContext;
 394
 395         UxSaveCtx = UxFileCharacteristicsContext;
 396         UxFileCharacteristicsContext = UxContext =
 397                         (_UxCFileCharacteristics *) UxGetContext( UxWidget );
 398         {
 399        */
 400         UxPopdownInterface(FileCharacteristics);
 401        /*
 402         }
 403         UxFileCharacteristicsContext = UxSaveCtx;
 404        */
 405 }
 406
 407 static  void    valueChangedCB_FC_PermissionToggle(Widget UxWidget,
 408                                           XtPointer UxClientData,
 409                                           XtPointer UxCallbackArg)
 410 {
 411   Boolean set;
 412
 413   XtVaGetValues(UxWidget, XmNset, &set, NULL);
 414   XtSetSensitive(FC_PermissionLabel, set);
 415   XtSetSensitive(FC_PermissionForm, set);
 416   /*
 417   XtSetSensitive(FC_ReadLabel, set);
 418   XtSetSensitive(FC_WriteLabel, set);
 419   XtSetSensitive(FC_ExecuteLabel, set);
 420
 421   XtSetSensitive(FC_ReadOnToggle, set);
 422   XtSetSensitive(FC_WriteOnToggle, set);
 423   XtSetSensitive(FC_ExecuteOnToggle, set);
 424
 425   XtSetSensitive(FC_ReadOffToggle, set);
 426   XtSetSensitive(FC_WriteOffToggle, set);
 427   XtSetSensitive(FC_ExecuteOffToggle, set);
 428
 429   XtSetSensitive(FC_ReadEitherToggle, set);
 430   XtSetSensitive(FC_WriteEitherToggle, set);
 431   XtSetSensitive(FC_ExecuteEitherToggle, set);
 432   */
 433   CalculateAND();
 434 }
 435
 436 #if 0
 437 static  void    armCB_FC_StringToggle(Widget UxWidget,
 438                                           XtPointer UxClientData,
 439                                           XtPointe`r UxCallbackArg)
 440 {
 441   /*set=1;*/
 442 }
 443
 444 static  void    armCB_FC_ByteToggle(Widget UxWidget,
 445                                     XtPointer UxClientData,
 446                                     XtPointer UxCallbackArg)
 447 {
 448   /*set=2;*/
 449 }
 450
 451 static  void    armCB_FC_ShortToggle(Widget UxWidget,
 452                                     XtPointer UxClientData,
 453                                     XtPointer UxCallbackArg)
 454 {
 455   /*set=3;*/
 456 }
 457
 458 static  void    armCB_FC_LongToggle( Widget UxWidget,
 459                                     XtPointer UxClientData,
 460                                     XtPointer UxCallbackArg)
 461 {
 462   /*set=4;*/
 463 }
 464 #endif
 465
 466 static  void    valueChangedCB_FC_ContentsToggle( Widget UxWidget,
 467                                                  XtPointer UxClientData,
 468                                                  XtPointer UxCallbackArg)
 469 {
 470   Boolean set;
 471
 472   XtVaGetValues(UxWidget, XmNset, &set, NULL);
 473   XtSetSensitive(FC_ContentsLabel, set);
 474   XtSetSensitive(FC_ContentsBox, set);
 475   if (set) {
 476      XmProcessTraversal(FC_ContentsPatternText, XmTRAVERSE_CURRENT);
 477   }
 478   CalculateAND();
 479 }
 480
 481 static  void    valueChangedCB_FC_NameOrPathToggle(Widget UxWidget,
 482                                                    XtPointer UxClientData,
 483                                                    XtPointer UxCallbackArg)
 484
 485 {
 486   Boolean set;
 487
 488   XtVaGetValues(UxWidget, XmNset, &set, NULL);
 489   XtSetSensitive(FC_NamePatternLabel, set);
 490   XtSetSensitive(FC_NameOrPathText, set);
 491   if (set) {
 492      XmProcessTraversal(FC_NameOrPathText, XmTRAVERSE_CURRENT);
 493   }
 494   CalculateAND();
 495 }
 496
 497 /*******************************************************************************
 498        The 'build_' function creates all the widgets
 499        using the resource values specified in the Property Editor.
 500 *******************************************************************************/
 501
 502 static Widget   _Uxbuild_FileCharacteristics(void)
 503 {
 504         Widget          _UxParent;
 505         Widget          FC_ActionAreaForm;
 506         Widget          FC_OkButton;
 507         Widget          FC_ClearButton;
 508         Widget          FC_CancelButton;
 509         Widget          FC_HelpButton;
 510         Widget          FC_MainLabel1;
 511         Widget          FC_MainLabel2;
 512         Widget          FC_TypeFileRowColumn;
 513
 514         Widget          FC_ReadRowColumn;
 515         Widget          FC_WriteRowColumn;
 516         Widget          FC_ExecuteRowColumn;
 517         int             ntotalbuttons = 4;
 518         int             nbutton = 0;
 519 #define TIGHTNESS       20
 520         Widget          FC_ScrolledWindow;
 521         Widget          FC_BigForm;
 522         char            *dialog_title, *pre, *suf;
 523
 524
 525         /* Creation of FileCharacteristics */
 526 #if 0
 527         _UxParent = UxParent;
 528         if ( _UxParent == NULL )
 529         {
 530              _UxParent = UxTopLevel;
 531         }
 532 #endif
 533
 534         _UxParent = UxTopLevel;
 535
 536         pre = GETMESSAGE(3, 10, "Create Action");
 537         suf = GETMESSAGE(9, 10, "Identifying Characteristics");
 538         dialog_title = XtMalloc(strlen(pre) + strlen(suf) + 2);
 539         sprintf(dialog_title, "%s - %s", pre, suf);
 540
 541         if (bLowRes) {
 542            _UxParent = XtVaCreatePopupShell( "FileCharacteristics_shell",
 543                         xmDialogShellWidgetClass, _UxParent,
 544                         XmNx, 398,
 545                         XmNy, 222,
 546                         XmNwidth, 446,
 547                         XmNheight, 579,
 548                         XmNshellUnitType, XmPIXELS,
 549                         XmNtitle, dialog_title,
 550                         NULL );
 551            FC_BigForm = XtVaCreateWidget( "FC_BigForm",
 552                         xmFormWidgetClass,
 553                         _UxParent,
 554                         XmNunitType, XmPIXELS,
 555                         XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
 556                         RES_CONVERT( XmNdialogTitle, dialog_title ),
 557                         XmNautoUnmanage, FALSE,
 558                         XmNrubberPositioning, FALSE,
 559                         NULL );
 560            FC_ScrolledWindow = XtVaCreateManagedWidget( "FC_ScrolledWindow",
 561                         xmScrolledWindowWidgetClass,
 562                         FC_BigForm,
 563                         XmNscrollingPolicy, XmAUTOMATIC,
 564                         XmNleftAttachment, XmATTACH_FORM,
 565                         XmNrightAttachment, XmATTACH_FORM,
 566                         XmNbottomAttachment, XmATTACH_FORM,
 567                         XmNtopAttachment, XmATTACH_FORM,
 568                         NULL );
 569            XtVaSetValues(FC_BigForm, XmNuserData, FC_ScrolledWindow, NULL);
 570
 571            FileCharacteristics = XtVaCreateManagedWidget( "FileCharacteristics",
 572                            xmFormWidgetClass,
 573                            FC_ScrolledWindow,
 574                            NULL );
 575         } else {
 576            _UxParent = XtVaCreatePopupShell( "FileCharacteristics_shell",
 577                         xmDialogShellWidgetClass, _UxParent,
 578                         XmNx, 398,
 579                         XmNy, 222,
 580                         XmNmwmDecorations, MWM_DECOR_ALL | MWM_DECOR_RESIZEH,
 581                         XmNwidth, 446,
 582                         XmNheight, 579,
 583                         XmNshellUnitType, XmPIXELS,
 584                         XmNtitle, dialog_title,
 585                         NULL );
 586            FileCharacteristics = XtVaCreateWidget( "FileCharacteristics",
 587                         xmFormWidgetClass,
 588                         _UxParent,
 589                         XmNunitType, XmPIXELS,
 590                         XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL,
 591                         RES_CONVERT( XmNdialogTitle, dialog_title ),
 592                         XmNautoUnmanage, FALSE,
 593                         XmNrubberPositioning, FALSE,
 594                         NULL );
 595         }
 596         XtFree(dialog_title);
 597         XtAddCallback( FileCharacteristics, XmNhelpCallback,
 598                 (XtCallbackProc) helpCB_general,
 599                 (XtPointer) HELP_FILECHAR );
 600
 601         /* Creation of FC_MainLabel1 */
 602         FC_MainLabel1 = XtVaCreateManagedWidget( "FC_MainLabel1",
 603                         xmLabelWidgetClass,
 604                         FileCharacteristics,
 605                         XmNalignment, XmALIGNMENT_BEGINNING,
 606                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 11, "Include All")),
 607                         XmNleftOffset, 40,
 608                         XmNleftAttachment, XmATTACH_FORM,
 609                         XmNrightAttachment, XmATTACH_FORM,
 610                         XmNtopOffset, 15,
 611                         XmNtopAttachment, XmATTACH_FORM,
 612                         NULL );
 613
 614         /* Creation of FC_TypeFileRowColumn */
 615         FC_TypeFileRowColumn = XtVaCreateManagedWidget( "FC_TypeFileRowColumn",
 616                         xmRowColumnWidgetClass,
 617                         FileCharacteristics,
 618                         XmNradioBehavior, TRUE,
 619                         XmNsensitive, TRUE,
 620                         XmNnumColumns, 2,
 621                         XmNorientation, XmVERTICAL,
 622                         XmNpacking, XmPACK_COLUMN,
 623                         XmNshadowThickness, 1,
 624                         XmNleftWidget, FC_MainLabel1,
 625                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 626                         XmNtopOffset, 5,
 627                         XmNtopWidget, FC_MainLabel1,
 628                         XmNtopAttachment, XmATTACH_WIDGET,
 629                         NULL );
 630
 631         /* Creation of FC_FileToggle */
 632         FC_FileToggle = XtVaCreateManagedWidget( "FC_FileToggle",
 633                         xmToggleButtonGadgetClass,
 634                         FC_TypeFileRowColumn,
 635                         XmNindicatorType, XmONE_OF_MANY,
 636                         XmNindicatorSize, 17,
 637                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 12, "Files")),
 638                         XmNset, TRUE,
 639                         NULL );
 640
 641         /* Creation of FC_DirectoryToggle */
 642         FC_DirectoryToggle = XtVaCreateManagedWidget( "FC_DirectoryToggle",
 643                         xmToggleButtonGadgetClass,
 644                         FC_TypeFileRowColumn,
 645                         XmNindicatorType, XmONE_OF_MANY,
 646                         XmNindicatorSize, 17,
 647                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 13, "Folders")),
 648                         NULL );
 649
 650         /* Creation of FC_MainLabel2 */
 651         FC_MainLabel2 = XtVaCreateManagedWidget( "FC_MainLabel2",
 652                         xmLabelWidgetClass,
 653                         FileCharacteristics,
 654                         XmNalignment, XmALIGNMENT_BEGINNING,
 655                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 14, "That Match the Following:")),
 656                         XmNleftOffset, 40,
 657                         XmNleftAttachment, XmATTACH_FORM,
 658                         XmNrightAttachment, XmATTACH_FORM,
 659                         XmNtopOffset, 5,
 660                         XmNtopWidget, FC_TypeFileRowColumn,
 661                         XmNtopAttachment, XmATTACH_WIDGET,
 662                         NULL );
 663
 664         /* Creation of FC_NamePatternLabel */
 665         FC_NamePatternLabel = XtVaCreateManagedWidget( "FC_NamePatternLabel",
 666                         xmLabelWidgetClass,
 667                         FileCharacteristics,
 668                         XmNalignment, XmALIGNMENT_BEGINNING,
 669                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 20, "Name Pattern:")),
 670                         XmNleftWidget, FC_MainLabel2,
 671                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 672                         XmNrightAttachment, XmATTACH_NONE,
 673                         XmNtopOffset, 20,
 674                         XmNtopWidget, FC_MainLabel2,
 675                         XmNtopAttachment, XmATTACH_WIDGET,
 676                         NULL );
 677
 678         /* Creation of FC_NameOrPathText */
 679         FC_NameOrPathText = XtVaCreateManagedWidget( "FC_NameOrPathText",
 680                         xmTextFieldWidgetClass,
 681                         FileCharacteristics,
 682                         XmNx, 59,
 683                         XmNy, 66,
 684                         XmNleftWidget, FC_NamePatternLabel,
 685                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 686                         XmNtopOffset, 0,
 687                         XmNtopWidget, FC_NamePatternLabel,
 688                         XmNtopAttachment, XmATTACH_WIDGET,
 689                         NULL );
 690
 691         /* Creation of FC_AndLabel1 */
 692         FC_AndLabel1 = XtVaCreateManagedWidget( "FC_AndLabel1",
 693                         xmLabelWidgetClass,
 694                         FileCharacteristics,
 695                         XmNx, 420,
 696                         XmNy, 98,
 697                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 27, "AND")),
 698                         XmNsensitive, FALSE,
 699                         XmNrightOffset, 30,
 700                         XmNrightAttachment, XmATTACH_FORM,
 701                         XmNtopOffset, 0,
 702                         XmNtopWidget, FC_NamePatternLabel,
 703                         XmNtopAttachment, XmATTACH_WIDGET,
 704                         NULL );
 705
 706         XtVaSetValues(FC_NameOrPathText,
 707                       XmNrightOffset, 30,
 708                       XmNrightWidget, FC_AndLabel1,
 709                       XmNrightAttachment, XmATTACH_WIDGET,
 710                       NULL);
 711
 712
 713         /* Creation of FC_NameOrPathToggle */
 714         FC_NameOrPathToggle = XtVaCreateManagedWidget( "FC_NameOrPathToggle",
 715                         xmToggleButtonGadgetClass,
 716                         FileCharacteristics,
 717                         RES_CONVERT( XmNlabelString, "" ),
 718                         XmNset, TRUE,
 719                         XmNnavigationType, XmTAB_GROUP,
 720                         XmNindicatorSize, 20,
 721                         XmNleftAttachment, XmATTACH_NONE,
 722                         XmNrightOffset, 2,
 723                         XmNrightWidget, FC_NameOrPathText,
 724                         XmNrightAttachment, XmATTACH_WIDGET,
 725                         XmNtopWidget, FC_NameOrPathText,
 726                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
 727                         XmNbottomAttachment, XmATTACH_NONE,
 728                         NULL );
 729         XtAddCallback( FC_NameOrPathToggle, XmNvalueChangedCallback,
 730                 (XtCallbackProc) valueChangedCB_FC_NameOrPathToggle,
 731                 (XtPointer) NULL );
 732
 733         /******************************************************************/
 734         /*                                                                */
 735         /* Permission Area creation        <<<<<<<>>>>>>>>                */
 736         /*                                                                */
 737         /******************************************************************/
 738         /* Creation of FC_PermissionLabel */
 739         FC_PermissionLabel = XtVaCreateManagedWidget( "FC_PermissionLabel",
 740                         xmLabelWidgetClass,
 741                         FileCharacteristics,
 742                         XmNx, 50,
 743                         XmNy, 155,
 744                         XmNalignment, XmALIGNMENT_BEGINNING,
 745                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 21, "Permission Pattern:")),
 746                         XmNsensitive, FALSE,
 747                         XmNleftWidget, FC_NameOrPathText,
 748                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 749                         XmNrightAttachment, XmATTACH_NONE,
 750                         XmNtopOffset, 15,
 751                         XmNtopWidget, FC_NameOrPathText,
 752                         XmNtopAttachment, XmATTACH_WIDGET,
 753                         NULL );
 754
 755         FC_PermissionForm = XtVaCreateManagedWidget( "FC_PermissionForm",
 756                         xmFormWidgetClass,
 757                         FileCharacteristics,
 758                         XmNresizePolicy, XmRESIZE_NONE,
 759                         XmNborderWidth, 1,
 760                         XmNsensitive, FALSE,
 761                         XmNleftWidget, FC_PermissionLabel,
 762                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
 763                         XmNtopOffset, 0,
 764                         XmNtopWidget, FC_PermissionLabel,
 765                         XmNtopAttachment, XmATTACH_WIDGET,
 766                         NULL );
 767
 768         /******************************************************************/
 769         /* Creation of FC_ReadRowColumn                                   */
 770         /*                                                                */
 771         /* This is the read row column - on, off, either radio buttons    */
 772         /******************************************************************/
 773         FC_ReadRowColumn = XtVaCreateManagedWidget( "FC_ReadRowColumn",
 774                         xmRowColumnWidgetClass,
 775                         FC_PermissionForm,
 776                         XmNradioBehavior, TRUE,
 777                         XmNnumColumns, 3,
 778                         XmNorientation, XmVERTICAL,
 779                         XmNpacking, XmPACK_COLUMN,
 780                         XmNshadowThickness, 1,
 781                         XmNrightOffset, 10,
 782                         XmNrightAttachment, XmATTACH_FORM,
 783                         XmNtopOffset, 10,
 784                         XmNtopAttachment, XmATTACH_FORM,
 785                         NULL );
 786
 787         /* Creation of FC_ReadOnToggle */
 788         FC_ReadOnToggle = XtVaCreateManagedWidget( "FC_ReadOnToggle",
 789                         xmToggleButtonGadgetClass,
 790                         FC_ReadRowColumn,
 791                         XmNindicatorType, XmONE_OF_MANY,
 792                         XmNindicatorSize, 17,
 793                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 43, "On")),
 794                         XmNset, FALSE,
 795                         NULL );
 796
 797         /* Creation of FC_ReadOffToggle */
 798         FC_ReadOffToggle = XtVaCreateManagedWidget( "FC_ReadOffToggle",
 799                         xmToggleButtonGadgetClass,
 800                         FC_ReadRowColumn,
 801                         XmNindicatorType, XmONE_OF_MANY,
 802                         XmNindicatorSize, 17,
 803                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 44, "Off")),
 804                         XmNset, FALSE,
 805                         NULL );
 806
 807         /* Creation of FC_ReadEitherToggle */
 808         FC_ReadEitherToggle = XtVaCreateManagedWidget( "FC_ReadEitherToggle",
 809                         xmToggleButtonGadgetClass,
 810                         FC_ReadRowColumn,
 811                         XmNindicatorType, XmONE_OF_MANY,
 812                         XmNindicatorSize, 17,
 813                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 45, "Either")),
 814                         XmNset, TRUE,
 815                         NULL );
 816
 817         /******************************************************************/
 818         /* Creation of FC_WriteRowColumn                                  */
 819         /*                                                                */
 820         /* This is the write row column - on, off, either radio buttons   */
 821         /******************************************************************/
 822         FC_WriteRowColumn = XtVaCreateManagedWidget( "FC_WriteRowColumn",
 823                         xmRowColumnWidgetClass,
 824                         FC_PermissionForm,
 825                         XmNradioBehavior, TRUE,
 826                         XmNnumColumns, 3,
 827                         XmNorientation, XmVERTICAL,
 828                         XmNpacking, XmPACK_COLUMN,
 829                         XmNshadowThickness, 1,
 830                         XmNrightOffset, 10,
 831                         XmNrightAttachment, XmATTACH_FORM,
 832                         XmNtopWidget, FC_ReadRowColumn,
 833                         XmNtopAttachment, XmATTACH_WIDGET,
 834                         NULL );
 835
 836         /* Creation of FC_WriteOnToggle */
 837         FC_WriteOnToggle = XtVaCreateManagedWidget( "FC_WriteOnToggle",
 838                         xmToggleButtonGadgetClass,
 839                         FC_WriteRowColumn,
 840                         XmNindicatorType, XmONE_OF_MANY,
 841                         XmNindicatorSize, 17,
 842                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 43, "On")),
 843                         XmNset, FALSE,
 844                         NULL );
 845
 846         /* Creation of FC_WriteOffToggle */
 847         FC_WriteOffToggle = XtVaCreateManagedWidget( "FC_WriteOffToggle",
 848                         xmToggleButtonGadgetClass,
 849                         FC_WriteRowColumn,
 850                         XmNindicatorType, XmONE_OF_MANY,
 851                         XmNindicatorSize, 17,
 852                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 44, "Off")),
 853                         XmNset, FALSE,
 854                         NULL );
 855
 856         /* Creation of FC_WriteEitherToggle */
 857         FC_WriteEitherToggle = XtVaCreateManagedWidget( "FC_WriteEitherToggle",
 858                         xmToggleButtonGadgetClass,
 859                         FC_WriteRowColumn,
 860                         XmNindicatorType, XmONE_OF_MANY,
 861                         XmNindicatorSize, 17,
 862                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 45, "Either")),
 863                         XmNset, TRUE,
 864                         NULL );
 865
 866         /******************************************************************/
 867         /* Creation of FC_ExecuteRowColumn                                */
 868         /*                                                                */
 869         /* This is the execute row column - on, off, either radio buttons */
 870         /******************************************************************/
 871         FC_ExecuteRowColumn = XtVaCreateManagedWidget( "FC_ExecuteRowColumn",
 872                         xmRowColumnWidgetClass,
 873                         FC_PermissionForm,
 874                         XmNradioBehavior, TRUE,
 875                         XmNnumColumns, 3,
 876                         XmNorientation, XmVERTICAL,
 877                         XmNpacking, XmPACK_COLUMN,
 878                         XmNshadowThickness, 1,
 879                         XmNrightOffset, 10,
 880                         XmNrightAttachment, XmATTACH_FORM,
 881                         XmNtopWidget, FC_WriteRowColumn,
 882                         XmNtopAttachment, XmATTACH_WIDGET,
 883                         XmNbottomOffset, 10,
 884                         XmNbottomAttachment, XmATTACH_FORM,
 885                         NULL );
 886
 887         /* Creation of FC_ExecuteOnToggle */
 888         FC_ExecuteOnToggle = XtVaCreateManagedWidget( "FC_ExecuteOnToggle",
 889                         xmToggleButtonGadgetClass,
 890                         FC_ExecuteRowColumn,
 891                         XmNindicatorType, XmONE_OF_MANY,
 892                         XmNindicatorSize, 17,
 893                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 43, "On")),
 894                         XmNset, FALSE,
 895                         NULL );
 896
 897         /* Creation of FC_ExecuteOffToggle */
 898         FC_ExecuteOffToggle = XtVaCreateManagedWidget( "FC_ExecuteOffToggle",
 899                         xmToggleButtonGadgetClass,
 900                         FC_ExecuteRowColumn,
 901                         XmNindicatorType, XmONE_OF_MANY,
 902                         XmNindicatorSize, 17,
 903                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 44, "Off")),
 904                         XmNset, FALSE,
 905                         NULL );
 906
 907         /* Creation of FC_ExecuteEitherToggle */
 908         FC_ExecuteEitherToggle = XtVaCreateManagedWidget( "FC_ExecuteEitherToggle",
 909                         xmToggleButtonGadgetClass,
 910                         FC_ExecuteRowColumn,
 911                         XmNindicatorType, XmONE_OF_MANY,
 912                         XmNindicatorSize, 17,
 913                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 45, "Either")),
 914                         XmNset, TRUE,
 915                         NULL );
 916
 917         /******************************************************************/
 918         /* Creation of Permission Labels                                  */
 919         /******************************************************************/
 920         FC_ReadLabel = XtVaCreateManagedWidget( "FC_ReadLabel",
 921                         xmLabelWidgetClass,
 922                         FC_PermissionForm,
 923                         XmNalignment, XmALIGNMENT_BEGINNING,
 924                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 40, "Read:")),
 925                         XmNrightWidget, FC_ReadRowColumn,
 926                         XmNrightAttachment, XmATTACH_WIDGET,
 927                         XmNleftOffset, 10,
 928                         XmNleftAttachment, XmATTACH_FORM,
 929                         XmNtopWidget, FC_ReadRowColumn,
 930                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
 931                         NULL );
 932         FC_WriteLabel = XtVaCreateManagedWidget( "FC_WriteLabel",
 933                         xmLabelWidgetClass,
 934                         FC_PermissionForm,
 935                         XmNalignment, XmALIGNMENT_BEGINNING,
 936                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 41, "Write:")),
 937                         XmNrightWidget, FC_WriteRowColumn,
 938                         XmNrightAttachment, XmATTACH_WIDGET,
 939                         XmNleftOffset, 10,
 940                         XmNleftAttachment, XmATTACH_FORM,
 941                         XmNtopWidget, FC_WriteRowColumn,
 942                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
 943                         NULL );
 944         FC_ExecuteLabel = XtVaCreateManagedWidget( "FC_ExecuteLabel",
 945                         xmLabelWidgetClass,
 946                         FC_PermissionForm,
 947                         XmNalignment, XmALIGNMENT_BEGINNING,
 948                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 42, "Execute:")),
 949                         XmNrightWidget, FC_ExecuteRowColumn,
 950                         XmNrightAttachment, XmATTACH_WIDGET,
 951                         XmNleftOffset, 10,
 952                         XmNleftAttachment, XmATTACH_FORM,
 953                         XmNtopWidget, FC_ExecuteRowColumn,
 954                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
 955                         NULL );
 956
 957         /******************************************************************/
 958         /* Creation of the  AND  label for permissions.                   */
 959         /******************************************************************/
 960         FC_AndLabel2 = XtVaCreateManagedWidget( "FC_AndLabel2",
 961                         xmLabelWidgetClass,
 962                         FileCharacteristics,
 963                         XmNx, 420,
 964                         XmNy, 192,
 965                         XmNalignment, XmALIGNMENT_BEGINNING,
 966                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 27, "AND")),
 967                         XmNsensitive, FALSE,
 968                         XmNrightOffset, 30,
 969                         XmNrightAttachment, XmATTACH_FORM,
 970                         XmNtopOffset, 0,
 971                         XmNtopWidget, FC_PermissionLabel,
 972                         XmNtopAttachment, XmATTACH_WIDGET,
 973                         NULL );
 974
 975         XtVaSetValues(FC_PermissionForm,
 976                       XmNrightOffset, 30,
 977                       XmNrightWidget, FC_AndLabel2,
 978                       XmNrightAttachment, XmATTACH_WIDGET,
 979                       NULL);
 980
 981
 982         /* Creation of FC_PermissionToggle */
 983         FC_PermissionToggle = XtVaCreateManagedWidget( "FC_PermissionToggle",
 984                         xmToggleButtonGadgetClass,
 985                         FileCharacteristics,
 986                         RES_CONVERT( XmNlabelString, "" ),
 987                         XmNnavigationType, XmTAB_GROUP,
 988                         XmNindicatorSize, 20,
 989                         XmNleftAttachment, XmATTACH_NONE,
 990                         XmNrightOffset, 2,
 991                         XmNrightWidget, FC_PermissionForm,
 992                         XmNrightAttachment, XmATTACH_WIDGET,
 993                         XmNtopWidget, FC_PermissionForm,
 994                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
 995                         XmNbottomAttachment, XmATTACH_NONE,
 996                         NULL );
 997         XtAddCallback( FC_PermissionToggle, XmNvalueChangedCallback,
 998                 (XtCallbackProc) valueChangedCB_FC_PermissionToggle,
 999                 (XtPointer) NULL );
1000
1001         /* Creation of FC_ContentsLabel */
1002         FC_ContentsLabel = XtVaCreateManagedWidget( "FC_ContentsLabel",
1003                         xmLabelWidgetClass,
1004                         FileCharacteristics,
1005                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 28, "Contents:")),
1006                         XmNsensitive, FALSE,
1007                         XmNleftWidget, FC_PermissionForm,
1008                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1009                         XmNrightAttachment, XmATTACH_NONE,
1010                         XmNtopOffset, 15,
1011                         XmNtopWidget, FC_PermissionForm,
1012                         XmNtopAttachment, XmATTACH_WIDGET,
1013                         NULL );
1014
1015         /* Creation of FC_ContentsBox */
1016         FC_ContentsBox = XtVaCreateManagedWidget( "FC_ContentsBox",
1017                         xmFormWidgetClass,
1018                         FileCharacteristics,
1019                         XmNresizePolicy, XmRESIZE_NONE,
1020                         XmNborderWidth, 1,
1021                         XmNsensitive, FALSE,
1022                         XmNleftWidget, FC_ContentsLabel,
1023                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1024                         XmNrightOffset, 30,
1025                         XmNrightAttachment, XmATTACH_FORM,
1026                         XmNtopOffset, 0,
1027                         XmNtopWidget, FC_ContentsLabel,
1028                         XmNtopAttachment, XmATTACH_WIDGET,
1029                         NULL );
1030
1031         /* Creation of FC_ContentsToggle */
1032         FC_ContentsToggle = XtVaCreateManagedWidget( "FC_ContentsToggle",
1033                         xmToggleButtonGadgetClass,
1034                         FileCharacteristics,
1035                         RES_CONVERT( XmNlabelString, "" ),
1036                         XmNnavigationType, XmTAB_GROUP,
1037                         XmNindicatorSize, 20,
1038                         XmNleftAttachment, XmATTACH_NONE,
1039                         XmNrightOffset, 2,
1040                         XmNrightWidget, FC_ContentsBox,
1041                         XmNrightAttachment, XmATTACH_WIDGET,
1042                         XmNtopWidget, FC_ContentsBox,
1043                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1044                         XmNbottomAttachment, XmATTACH_NONE,
1045                         NULL );
1046         XtAddCallback( FC_ContentsToggle, XmNvalueChangedCallback,
1047                 (XtCallbackProc) valueChangedCB_FC_ContentsToggle,
1048                 (XtPointer) NULL );
1049
1050         /* Creation of FC_ContentsPatternLabel */
1051         FC_ContentsPatternLabel = XtVaCreateManagedWidget( "FC_ContentsPatternLabel",
1052                         xmLabelWidgetClass,
1053                         FC_ContentsBox,
1054                         XmNalignment, XmALIGNMENT_BEGINNING,
1055                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 29, "Pattern:")),
1056                         XmNleftOffset, 10,
1057                         XmNleftAttachment, XmATTACH_FORM,
1058                         XmNrightAttachment, XmATTACH_NONE,
1059                         XmNtopOffset, 10,
1060                         XmNtopAttachment, XmATTACH_FORM,
1061                         NULL );
1062
1063         /* Creation of FC_ContentsPatternText */
1064         FC_ContentsPatternText = XtVaCreateManagedWidget( "FC_ContentsPatternText",
1065                         xmTextFieldWidgetClass,
1066                         FC_ContentsBox,
1067                         XmNwidth, 300,
1068                         XmNleftOffset, 5,
1069                         XmNleftWidget, FC_ContentsPatternLabel,
1070                         XmNleftAttachment, XmATTACH_WIDGET,
1071                         XmNrightOffset, 10,
1072                         XmNrightAttachment, XmATTACH_FORM,
1073                         XmNbottomAttachment, XmATTACH_NONE,
1074                         XmNtopWidget, FC_ContentsPatternLabel,
1075                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1076                         NULL );
1077
1078         /* Creation of FC_TypeLabel */
1079         FC_TypeLabel = XtVaCreateManagedWidget( "FC_TypeLabel",
1080                         xmLabelWidgetClass,
1081                         FC_ContentsBox,
1082                         XmNalignment, XmALIGNMENT_BEGINNING,
1083                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 30, "Type:")),
1084                         XmNleftWidget, FC_ContentsPatternLabel,
1085                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1086                         XmNbottomAttachment, XmATTACH_NONE,
1087                         XmNtopOffset, 15,
1088                         XmNtopWidget, FC_ContentsPatternLabel,
1089                         XmNtopAttachment, XmATTACH_WIDGET,
1090                         NULL );
1091
1092         /* Creation of FC_TypeRowColumn */
1093         FC_TypeRowColumn = XtVaCreateManagedWidget( "FC_TypeRowColumn",
1094                         xmRowColumnWidgetClass,
1095                         FC_ContentsBox,
1096                         XmNnumColumns, 1,
1097                         XmNpacking, XmPACK_COLUMN,
1098                         XmNradioBehavior, TRUE,
1099                         XmNwhichButton, 1,
1100                         XmNleftWidget, FC_ContentsPatternText,
1101                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1102                         XmNrightWidget, FC_ContentsPatternText,
1103                         XmNrightAttachment, XmATTACH_OPPOSITE_WIDGET,
1104                         XmNbottomAttachment, XmATTACH_NONE,
1105                         XmNtopWidget, FC_TypeLabel,
1106                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1107                         NULL );
1108
1109         /* Creation of FC_StringToggle */
1110         FC_StringToggle = XtVaCreateManagedWidget( "FC_StringToggle",
1111                         xmToggleButtonGadgetClass,
1112                         FC_TypeRowColumn,
1113                         XmNindicatorType, XmONE_OF_MANY,
1114                         XmNindicatorSize, 17,
1115                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 31, "String")),
1116                         XmNset, TRUE,
1117                         NULL );
1118
1119         /* Creation of FC_ByteToggle */
1120         FC_ByteToggle = XtVaCreateManagedWidget( "FC_ByteToggle",
1121                         xmToggleButtonGadgetClass,
1122                         FC_TypeRowColumn,
1123                         XmNindicatorType, XmONE_OF_MANY,
1124                         XmNindicatorSize, 17,
1125                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 32, "Byte (Hex)")),
1126                         NULL );
1127
1128         /* Creation of FC_ShortToggle */
1129         FC_ShortToggle = XtVaCreateManagedWidget( "FC_ShortToggle",
1130                         xmToggleButtonGadgetClass,
1131                         FC_TypeRowColumn,
1132                         XmNindicatorType, XmONE_OF_MANY,
1133                         XmNindicatorSize, 17,
1134                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 33, "Short (Decimal)")),
1135                         NULL );
1136
1137         /* Creation of FC_LongToggle */
1138         FC_LongToggle = XtVaCreateManagedWidget( "FC_LongToggle",
1139                         xmToggleButtonGadgetClass,
1140                         FC_TypeRowColumn,
1141                         XmNindicatorType, XmONE_OF_MANY,
1142                         XmNindicatorSize, 17,
1143                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 34, "Long (Decimal)")),
1144                         NULL );
1145
1146         /* Creation of FC_StartByteLabel */
1147         FC_StartByteLabel = XtVaCreateManagedWidget( "FC_StartByteLabel",
1148                         xmLabelWidgetClass,
1149                         FC_ContentsBox,
1150                         XmNalignment, XmALIGNMENT_BEGINNING,
1151                         RES_CONVERT( XmNlabelString, GETMESSAGE(9, 35, "Start Byte:")),
1152                         XmNleftWidget, FC_TypeLabel,
1153                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1154                         XmNbottomOffset, 15,
1155                         XmNbottomAttachment, XmATTACH_FORM,
1156                         XmNtopOffset, 15,
1157                         XmNtopWidget, FC_TypeRowColumn,
1158                         XmNtopAttachment, XmATTACH_WIDGET,
1159                         NULL );
1160
1161         /* Creation of FC_StartByteTextField */
1162         FC_StartByteTextField = XtVaCreateManagedWidget( "FC_StartByteTextField",
1163                         xmTextFieldWidgetClass,
1164                         FC_ContentsBox,
1165                         XmNcursorPosition, 5,
1166                         XmNwidth, 80,
1167                         XmNleftOffset, 5,
1168                         XmNleftWidget, FC_StartByteLabel,
1169                         XmNleftAttachment, XmATTACH_WIDGET,
1170                         XmNtopWidget, FC_StartByteLabel,
1171                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1172                         NULL );
1173 #if 0
1174         /* Creation of FC_EndByteLabel */
1175         FC_EndByteLabel = XtVaCreateManagedWidget( "FC_EndByteLabel",
1176                         xmLabelWidgetClass,
1177                         FC_ContentsBox,
1178                         XmNx, 248,
1179                         XmNy, 189,
1180                         XmNalignment, XmALIGNMENT_BEGINNING,
1181                         RES_CONVERT( XmNlabelString, "End byte:" ),
1182                         XmNleftOffset, 10,
1183                         XmNleftWidget, FC_StartByteTextField,
1184                         XmNleftAttachment, XmATTACH_WIDGET,
1185                         XmNtopWidget, FC_StartByteTextField,
1186                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1187                         NULL );
1188
1189         /* Creation of FC_EndByteTextField */
1190         FC_EndByteTextField = XtVaCreateManagedWidget( "FC_EndByteTextField",
1191                         xmTextFieldWidgetClass,
1192                         FC_ContentsBox,
1193                         XmNcolumns, 6,
1194                         XmNcursorPosition, 5,
1195                         XmNwidth, 80,
1196                         XmNleftOffset, 5,
1197                         XmNleftWidget, FC_EndByteLabel,
1198                         XmNleftAttachment, XmATTACH_WIDGET,
1199                         XmNrightOffset, 10,
1200                         XmNrightAttachment, XmATTACH_FORM,
1201                         XmNtopWidget, FC_EndByteLabel,
1202                         XmNtopAttachment, XmATTACH_OPPOSITE_WIDGET,
1203                         NULL );
1204 #endif
1205
1206         FC_ActionAreaForm = XtVaCreateManagedWidget( "FC_ActionAreaForm",
1207                         xmFormWidgetClass,
1208                         FileCharacteristics,
1209                         XmNskipAdjust, TRUE,
1210                         XmNfractionBase, ((TIGHTNESS * ntotalbuttons) - 1),
1211                         XmNleftWidget, FC_ContentsBox,
1212                         XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET,
1213                         XmNrightOffset, 30,
1214                         XmNrightAttachment, XmATTACH_FORM,
1215                         XmNbottomOffset, 20,
1216                         XmNbottomAttachment, XmATTACH_FORM,
1217                         XmNtopOffset, 20,
1218                         XmNtopWidget, FC_ContentsBox,
1219                         XmNtopAttachment, XmATTACH_WIDGET,
1220                         NULL );
1221
1222         /* Creation of FC_OkButton */
1223         FC_OkButton = XtVaCreateManagedWidget( "FC_OkButton",
1224                         xmPushButtonGadgetClass,
1225                         FC_ActionAreaForm,
1226                         RES_CONVERT( XmNlabelString, GETMESSAGE(6, 10, "OK")),
1227                         XmNleftAttachment, nbutton ?
1228                                             XmATTACH_POSITION : XmATTACH_FORM,
1229                         XmNleftPosition, TIGHTNESS * nbutton,
1230                         XmNrightAttachment, nbutton != (ntotalbuttons - 1) ?
1231                                              XmATTACH_POSITION : XmATTACH_FORM,
1232                         XmNrightPosition, (TIGHTNESS * nbutton)+(TIGHTNESS - 1),
1233                         NULL );
1234         nbutton++;
1235         XtAddCallback( FC_OkButton, XmNactivateCallback,
1236                 (XtCallbackProc) activateCB_FC_OkButton,
1237                 (XtPointer) NULL );
1238
1239         /* Creation of FC_CancelButton */
1240         FC_CancelButton = XtVaCreateManagedWidget( "FC_CancelButton",
1241                         xmPushButtonGadgetClass,
1242                         FC_ActionAreaForm,
1243                         RES_CONVERT( XmNlabelString, GETMESSAGE(6, 12, "Cancel")),
1244                         XmNleftAttachment, nbutton ?
1245                                             XmATTACH_POSITION : XmATTACH_FORM,
1246                         XmNleftPosition, TIGHTNESS * nbutton,
1247                         XmNrightAttachment, nbutton != (ntotalbuttons - 1) ?
1248                                              XmATTACH_POSITION : XmATTACH_FORM,
1249                         XmNrightPosition, (TIGHTNESS * nbutton)+(TIGHTNESS - 1),
1250                         NULL );
1251         nbutton++;
1252         XtAddCallback( FC_CancelButton, XmNactivateCallback,
1253                 (XtCallbackProc) activateCB_FC_CancelButton,
1254                 (XtPointer) NULL );
1255
1256         /* Creation of FC_ClearButton */
1257         FC_ClearButton = XtVaCreateManagedWidget( "FC_ClearButton",
1258                         xmPushButtonGadgetClass,
1259                         FC_ActionAreaForm,
1260                         RES_CONVERT( XmNlabelString, GETMESSAGE(6, 14, "Clear")),
1261                         XmNleftAttachment, nbutton ?
1262                                             XmATTACH_POSITION : XmATTACH_FORM,
1263                         XmNleftPosition, TIGHTNESS * nbutton,
1264                         XmNrightAttachment, nbutton != (ntotalbuttons - 1) ?
1265                                              XmATTACH_POSITION : XmATTACH_FORM,
1266                         XmNrightPosition, (TIGHTNESS * nbutton)+(TIGHTNESS - 1),
1267                         NULL );
1268         nbutton++;
1269         XtAddCallback( FC_ClearButton, XmNactivateCallback,
1270                 (XtCallbackProc) activateCB_FC_ClearButton,
1271                 (XtPointer) NULL );
1272
1273         /* Creation of FC_HelpButton */
1274         FC_HelpButton = XtVaCreateManagedWidget( "FC_HelpButton",
1275                         xmPushButtonGadgetClass,
1276                         FC_ActionAreaForm,
1277                         RES_CONVERT( XmNlabelString, GETMESSAGE(6, 13, "Help")),
1278                         XmNuserData, FileCharacteristics,
1279                         XmNleftAttachment, nbutton ?
1280                                             XmATTACH_POSITION : XmATTACH_FORM,
1281                         XmNleftPosition, TIGHTNESS * nbutton,
1282                         XmNrightAttachment, nbutton != (ntotalbuttons - 1) ?
1283                                              XmATTACH_POSITION : XmATTACH_FORM,
1284                         XmNrightPosition, (TIGHTNESS * nbutton)+(TIGHTNESS - 1),
1285                         NULL );
1286         nbutton++;
1287         XtAddCallback( FC_HelpButton, XmNactivateCallback,
1288                 (XtCallbackProc) helpCB_general,
1289                 (XtPointer) HELP_FILECHAR );
1290
1291         XtVaSetValues(FileCharacteristics,
1292                         XmNcancelButton, FC_CancelButton,
1293                         XmNdefaultButton, FC_OkButton,
1294                         XmNinitialFocus, FC_NameOrPathText,
1295                         NULL );
1296
1297         XtAddCallback( FileCharacteristics, XmNdestroyCallback,
1298                 (XtCallbackProc) UxDestroyContextCB,
1299                 (XtPointer) NULL );
1300
1301         if (bLowRes) {
1302            return ( FC_BigForm );
1303         } else {
1304            return ( FileCharacteristics );
1305         }
1306 }
1307
1308 /*******************************************************************************
1309        The following is the 'Interface function' which is the
1310        external entry point for creating this interface.
1311        This function should be called from your application or from
1312        a callback function.
1313 *******************************************************************************/
1314
1315 Widget  create_FileCharacteristics( swidget _UxUxParent )
1316 {
1317         Widget            rtrn;
1318         Dimension         dimHeight;
1319         Dimension         dimWidth;
1320         Dimension         dimTmp;
1321         Widget            widScrolledWindow;
1322         Widget            widTmp;
1323
1324         rtrn = _Uxbuild_FileCharacteristics();
1325
1326         if (bLowRes) {
1327            XtRealizeWidget(rtrn);
1328            XtVaGetValues (FileCharacteristics,
1329                           XmNheight, &dimHeight,
1330                           XmNwidth, &dimWidth,
1331                           NULL);
1332            XtVaGetValues (rtrn,
1333                           XmNuserData, &widScrolledWindow,
1334                           NULL);
1335            XtVaGetValues (widScrolledWindow,
1336                           XmNverticalScrollBar, &widTmp,
1337                           NULL);
1338            XtVaGetValues (widTmp,
1339                           XmNwidth, &dimTmp,
1340                           NULL);
1341            dimHeight += dimTmp;
1342            dimWidth += dimTmp;
1343
1344            XtVaSetValues (rtrn,
1345                           XmNheight, dimHeight,
1346                           XmNwidth, dimWidth,
1347                           NULL);
1348         }
1349
1350         return(rtrn);
1351 }
1352
1353 /******************************************************************************/
1354 /*                                                                            */
1355 /* init_FileCharacteristics_dialog_fields                                     */
1356 /*                                                                            */
1357 /* INPUT:  FiletypeData * - pointer to FiletypeData structure                 */
1358 /* OUTPUT: none                                                               */
1359 /*                                                                            */
1360 /******************************************************************************/
1361 void init_FileCharacteristics_dialog_fields(FiletypeData *pFtD)
1362 {
1363   char buffer[MAXBUFSIZE];
1364   char *pszPerms = (char *)NULL;
1365
1366   /************************************************************************/
1367   /* Initialize name pattern.                                             */
1368   /************************************************************************/
1369   if (pFtD->pszPattern) {
1370      /*XmToggleButtonSetState(FC_NameOrPathToggle, TRUE);*/
1371      XmToggleButtonGadgetSetState(FC_NameOrPathToggle, TRUE, TRUE);
1372      PutWidgetTextString(FC_NameOrPathText, pFtD->pszPattern);
1373   } else {
1374      /*XmToggleButtonSetState(FC_NameOrPathToggle, FALSE);*/
1375      XmToggleButtonGadgetSetState(FC_NameOrPathToggle, FALSE, TRUE);
1376   }
1377
1378   /************************************************************************/
1379   /* Initialize permission pattern.                                       */
1380   /************************************************************************/
1381   if (pFtD->pszPermissions) {
1382      if (strstr(pFtD->pszPermissions, "!d")) {
1383         XmToggleButtonGadgetSetState(FC_FileToggle, TRUE, TRUE);
1384      } else {
1385         XmToggleButtonGadgetSetState(FC_DirectoryToggle, TRUE, TRUE);
1386      }
1387      pszPerms = strchr(pFtD->pszPermissions, 'd');
1388      if (pszPerms) {
1389         pszPerms++;
1390         if (!*pszPerms) {
1391            pszPerms = (char *)NULL;
1392         }
1393      }
1394   }
1395
1396   if (pszPerms) {
1397      XmToggleButtonGadgetSetState(FC_PermissionToggle, TRUE, TRUE);
1398
1399      /******************************************************************/
1400      /* Initialize Read permission                                     */
1401      /******************************************************************/
1402      if (strstr(pFtD->pszPermissions, "!r")) {
1403         XmToggleButtonGadgetSetState(FC_ReadOffToggle, TRUE, TRUE);
1404      } else {
1405         if (strstr(pFtD->pszPermissions, "r")) {
1406            XmToggleButtonGadgetSetState(FC_ReadOnToggle, TRUE, TRUE);
1407         } else {
1408            XmToggleButtonGadgetSetState(FC_ReadEitherToggle, TRUE, TRUE);
1409         }
1410      }
1411      /******************************************************************/
1412      /* Initialize Write permission                                    */
1413      /******************************************************************/
1414      if (strstr(pFtD->pszPermissions, "!w")) {
1415         XmToggleButtonGadgetSetState(FC_WriteOffToggle, TRUE, TRUE);
1416      } else {
1417         if (strstr(pFtD->pszPermissions, "w")) {
1418            XmToggleButtonGadgetSetState(FC_WriteOnToggle, TRUE, TRUE);
1419         } else {
1420            XmToggleButtonGadgetSetState(FC_WriteEitherToggle, TRUE, TRUE);
1421         }
1422      }
1423      /******************************************************************/
1424      /* Initialize Execute permission                                  */
1425      /******************************************************************/
1426      if (strstr(pFtD->pszPermissions, "!x")) {
1427         XmToggleButtonGadgetSetState(FC_ExecuteOffToggle, TRUE, TRUE);
1428      } else {
1429        if (strstr(pFtD->pszPermissions, "x")) {
1430           XmToggleButtonGadgetSetState(FC_ExecuteOnToggle, TRUE, TRUE);
1431        } else {
1432           XmToggleButtonGadgetSetState(FC_ExecuteEitherToggle, TRUE, TRUE);
1433        }
1434      }
1435
1436   } else {
1437      XmToggleButtonGadgetSetState(FC_PermissionToggle, FALSE, TRUE);
1438   }
1439
1440   /************************************************************************/
1441   /* Initialize contents pattern.                                         */
1442   /************************************************************************/
1443   if (pFtD->pszContents) {
1444      XmToggleButtonGadgetSetState(FC_ContentsToggle, TRUE, TRUE);
1445      /*XmToggleButtonSetState(FC_ContentsToggle, TRUE);*/
1446      PutWidgetTextString(FC_ContentsPatternText, pFtD->pszContents);
1447
1448      if (pFtD->fsFlags & CA_FT_CNTSTRING)
1449         XmToggleButtonGadgetSetState(FC_StringToggle, TRUE, TRUE);
1450      else if (pFtD->fsFlags & CA_FT_CNTBYTE)
1451         XmToggleButtonGadgetSetState(FC_ByteToggle, TRUE, TRUE);
1452      else if (pFtD->fsFlags & CA_FT_CNTSHORT)
1453         XmToggleButtonGadgetSetState(FC_ShortToggle, TRUE, TRUE);
1454      else if (pFtD->fsFlags & CA_FT_CNTLONG)
1455         XmToggleButtonGadgetSetState(FC_LongToggle, TRUE, TRUE);
1456
1457      sprintf(buffer, "%d", pFtD->sStart);
1458      PutWidgetTextString(FC_StartByteTextField,buffer);
1459 #if 0
1460      sprintf(buffer, "%d", pFtD->sEnd);
1461      PutWidgetTextString(FC_EndByteTextField, buffer);
1462 #endif
1463   } else {
1464      XmToggleButtonGadgetSetState(FC_ContentsToggle, FALSE, TRUE);
1465      /*XmToggleButtonSetState(FC_ContentsToggle, FALSE);*/
1466   }
1467   return;
1468 }
1469
1470 /******************************************************************************/
1471 /*                                                                            */
1472 /* clear_FileCharacteristics_dialog_fields                                    */
1473 /*                                                                            */
1474 /* INPUT:  FiletypeData * - pointer to FiletypeData structure                 */
1475 /* OUTPUT: none                                                               */
1476 /*                                                                            */
1477 /******************************************************************************/
1478 void clear_FileCharacteristics_dialog_fields(void)
1479 {
1480   /************************************************************************/
1481   /* Clear Files/Directories - set to default                             */
1482   /************************************************************************/
1483   XmToggleButtonGadgetSetState(FC_FileToggle, TRUE, TRUE);
1484
1485   /************************************************************************/
1486   /* Clear name pattern.                                                  */
1487   /************************************************************************/
1488   XmToggleButtonGadgetSetState(FC_NameOrPathToggle, FALSE, TRUE);
1489   clear_text_field(FC_NameOrPathText);
1490
1491   /************************************************************************/
1492   /* Clear permission pattern - set to default                            */
1493   /************************************************************************/
1494   XmToggleButtonGadgetSetState(FC_PermissionToggle, FALSE, TRUE);
1495   XmToggleButtonGadgetSetState(FC_ReadOnToggle, FALSE, TRUE);
1496   XmToggleButtonGadgetSetState(FC_WriteOnToggle, FALSE, TRUE);
1497   XmToggleButtonGadgetSetState(FC_ExecuteOnToggle, FALSE, TRUE);
1498
1499   XmToggleButtonGadgetSetState(FC_ReadOffToggle, FALSE, TRUE);
1500   XmToggleButtonGadgetSetState(FC_WriteOffToggle, FALSE, TRUE);
1501   XmToggleButtonGadgetSetState(FC_ExecuteOffToggle, FALSE, TRUE);
1502
1503   XmToggleButtonGadgetSetState(FC_ReadEitherToggle, TRUE, TRUE);
1504   XmToggleButtonGadgetSetState(FC_WriteEitherToggle, TRUE, TRUE);
1505   XmToggleButtonGadgetSetState(FC_ExecuteEitherToggle, TRUE, TRUE);
1506
1507   /************************************************************************/
1508   /* Clear contents pattern - set to default                              */
1509   /************************************************************************/
1510   XmToggleButtonGadgetSetState(FC_ContentsToggle, FALSE, TRUE);
1511   clear_text_field(FC_ContentsPatternText);
1512   XmToggleButtonGadgetSetState(FC_StringToggle, TRUE, TRUE);
1513   clear_text_field(FC_StartByteTextField);
1514 #if 0
1515   clear_text_field(FC_EndByteTextField);
1516 #endif
1517
1518   return;
1519 }
1520
1521 /******************************************************************************/
1522 /*                                                                            */
1523 /* FileCharCheckFields                                                        */
1524 /*                                                                            */
1525 /* INPUT:  none                                                               */
1526 /* OUTPUT: FALSE  - no errors found                                           */
1527 /*         TRUE   - found errors                                              */
1528 /*                                                                            */
1529 /******************************************************************************/
1530 Boolean FileCharCheckFields(void)
1531 {
1532   char    *ptr = (char *)NULL;
1533   Boolean bError = FALSE;
1534   char    *msgPtr, *errPtr;
1535
1536   /**************************************************************************/
1537   /* Check to make sure at least one characteristic is selected.            */
1538   /**************************************************************************/
1539   if (!bError) {
1540      if ( !(XmToggleButtonGadgetGetState(FC_NameOrPathToggle)) &&
1541           !(XmToggleButtonGadgetGetState(FC_PermissionToggle)) &&
1542           !(XmToggleButtonGadgetGetState(FC_ContentsToggle)) ) {
1543         msgPtr = GETMESSAGE(10, 30,
1544             "An identifying characteristic has not been selected.\n\
1545 Select one or more of the characteristics\n\
1546 (Name Pattern, Permissions Pattern, or Contents).");
1547         errPtr = XtNewString(msgPtr);
1548         display_error_message(FileCharacteristics, errPtr);
1549         XtFree(errPtr);
1550         XmProcessTraversal(FC_NameOrPathText, XmTRAVERSE_CURRENT);
1551         bError = TRUE;
1552      }
1553   }
1554
1555   /**************************************************************************/
1556   /* Check if name pattern is selected.  If so must have a name pattern.    */
1557   /**************************************************************************/
1558   if (!bError) {
1559      if (XmToggleButtonGadgetGetState(FC_NameOrPathToggle)) {
1560         ptr = (char *)NULL;
1561         GetWidgetTextString(FC_NameOrPathText, &ptr);
1562 #ifdef DEBUG
1563         printf("Name Pattern = '%s'\n", ptr);
1564 #endif
1565         if (!ptr) {
1566            msgPtr = GETMESSAGE(10, 10, "Name Pattern is missing.\n\
1567 If Name Pattern is selected, a name pattern\n\
1568 must be entered.");
1569            errPtr = XtNewString(msgPtr);
1570            display_error_message(FileCharacteristics, errPtr);
1571            XtFree(errPtr);
1572            XmProcessTraversal(FC_NameOrPathText, XmTRAVERSE_CURRENT);
1573            bError = TRUE;
1574         } else {
1575            XtFree(ptr);
1576         }
1577      }
1578   }
1579
1580   /**************************************************************************/
1581   /* Check if contents is selected.  If so must have a contents pattern.    */
1582   /**************************************************************************/
1583   if (!bError) {
1584      if (XmToggleButtonGadgetGetState(FC_ContentsToggle)) {
1585         ptr = (char *)NULL;
1586         GetWidgetTextString(FC_ContentsPatternText, &ptr);
1587 #ifdef DEBUG
1588         printf("Name Pattern = '%s'\n", ptr);
1589 #endif
1590         if (!ptr) {
1591            msgPtr = GETMESSAGE(10, 20, "Contents Pattern is missing.\n\
1592 If Contents is selected, then the Pattern field\n\
1593 under Contents must be filled in.");
1594            errPtr = XtNewString(msgPtr);
1595            display_error_message(FileCharacteristics, errPtr);
1596            XtFree(errPtr);
1597            bError = TRUE;
1598         } else {
1599            XtFree(ptr);
1600            /*****************************************************************/
1601            /* Now check to make sure there is a start byte value.           */
1602            /*****************************************************************/
1603            ptr = (char *)NULL;
1604            GetWidgetTextString(FC_StartByteTextField, &ptr);
1605            if (!ptr) {
1606               msgPtr = GETMESSAGE(10, 25, "Start byte value is missing.\n\
1607 If Contents is selected, then a number must be\n\
1608 entered in the 'Start Byte' field.");
1609               errPtr = XtNewString(msgPtr);
1610               display_error_message(FileCharacteristics, errPtr);
1611               XtFree(errPtr);
1612               bError = TRUE;
1613            } else {
1614               XtFree(ptr);
1615            }
1616         }
1617      }
1618   }
1619
1620   return(bError);
1621 }
1622
1623 /*******************************************************************************
1624        END OF FILE
1625 *******************************************************************************/
1626