src/exim_monitor/em_TextPop.c

   1 /***********************************************************
   2 Copyright 1989 by the Massachusetts Institute of Technology,
   3 Cambridge, Massachusetts.
   4
   5                         All Rights Reserved
   6
   7 Permission to use, copy, modify, and distribute this software and its
   8 documentation for any purpose and without fee is hereby granted,
   9 provided that the above copyright notice appear in all copies and that
  10 both that copyright notice and this permission notice appear in
  11 supporting documentation, and that the names of Digital or MIT not be
  12 used in advertising or publicity pertaining to distribution of the
  13 software without specific, written prior permission.
  14
  15 DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  16 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  17 DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  18 ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  19 WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  20 ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  21 SOFTWARE.
  22
  23 ******************************************************************/
  24
  25
  26 /****************************************************************************
  27 * Modified by Philip Hazel for use with Exim. The "replace" and "insert     *
  28 * file" features of the search facility have been removed.  Also took out   *
  29 * the declaration of sys_errlist, as it isn't used and causes trouble on    *
  30 * some systems that declare it differently. September 1996.                 *
  31 * Added the arguments into the static functions declared at the head, to    *
  32 * stop some compiler warnings. August 1999.                                 *
  33 * Took out the separate declarations of errno and sys_nerr at the start,    *
  34 * because they too aren't actually used, and the declaration causes trouble *
  35 * on some systems. December 2002.                                           *
  36 ****************************************************************************/
  37
  38
  39 /************************************************************
  40  *
  41  * This file is broken up into three sections one dealing with
  42  * each of the three popups created here:
  43  *
  44  * FileInsert, Search, and Replace.
  45  *
  46  * There is also a section at the end for utility functions
  47  * used by all more than one of these dialogs.
  48  *
  49  * The following functions are the only non-static ones defined
  50  * in this module.  They are located at the beginning of the
  51  * section that contains this dialog box that uses them.
  52  *
  53  * void _XawTextInsertFileAction(w, event, params, num_params);
  54  * void _XawTextDoSearchAction(w, event, params, num_params);
  55  * void _XawTextDoReplaceAction(w, event, params, num_params);
  56  * void _XawTextInsertFile(w, event, params, num_params);
  57  *
  58  *************************************************************/
  59
  60 #include <X11/IntrinsicP.h>
  61 #include <X11/StringDefs.h>
  62 #include <X11/Shell.h>
  63
  64 #include <X11/Xaw/TextP.h>
  65 #include <X11/Xaw/AsciiText.h>
  66 #include <X11/Xaw/Cardinals.h>
  67 #include <X11/Xaw/Command.h>
  68 #include <X11/Xaw/Form.h>
  69 #include <X11/Xaw/Toggle.h>
  70 #include <X11/Xmu/CharSet.h>
  71 #include <stdio.h>
  72 #include <X11/Xos.h>            /* for O_RDONLY */
  73 #include <errno.h>
  74
  75 /* extern int errno, sys_nerr; */
  76 /* extern char* sys_errlist[]; */
  77
  78 #define DISMISS_NAME  ("cancel")
  79 #define DISMISS_NAME_LEN 6
  80 #define FORM_NAME     ("form")
  81 #define LABEL_NAME    ("label")
  82 #define TEXT_NAME     ("text")
  83
  84 #define R_OFFSET      1
  85
  86 /* Argument types added by PH August 1999 */
  87
  88 static void CenterWidgetOnPoint(Widget, XEvent *);
  89 static void PopdownSearch(Widget, XtPointer, XtPointer);
  90 static void InitializeSearchWidget(struct SearchAndReplace *,
  91   XawTextScanDirection, Boolean);
  92 static void  SetResource(Widget, char *, XtArgVal);
  93 static void  SetSearchLabels(struct SearchAndReplace *, String, String,
  94   Boolean);
  95 static Widget CreateDialog(Widget, String, String,
  96   void (*)(Widget, char *, Widget));
  97 static Widget  GetShell(Widget);
  98 static void SetWMProtocolTranslations(Widget w);
  99 static Boolean DoSearch(struct SearchAndReplace *);
 100 static String GetString(Widget);
 101
 102 static void AddSearchChildren(Widget, char *, Widget);
 103
 104 static char radio_trans_string[] =
 105     "<Btn1Down>,<Btn1Up>:   set() notify()";
 106
 107 static char search_text_trans[] =
 108   "~Shift<Key>Return:      DoSearchAction(Popdown) \n\
 109    Ctrl<Key>c:             PopdownSearchAction() \n\
 110    ";
 111
 112
 113
 114 /************************************************************
 115  *
 116  * This section of the file contains all the functions that
 117  * the search dialog box uses.
 118  *
 119  ************************************************************/
 120
 121 /*      Function Name: _XawTextDoSearchAction
 122  *      Description: Action routine that can be bound to dialog box's
 123  *                   Text Widget that will search for a string in the main
 124  *                   Text Widget.
 125  *      Arguments:   (Standard Action Routine args)
 126  *      Returns:     none.
 127  *
 128  * Note:
 129  *
 130  * If the search was successful and the argument popdown is passed to
 131  * this action routine then the widget will automatically popdown the
 132  * search widget.
 133  */
 134
 135 /* ARGSUSED */
 136 void
 137 _XawTextDoSearchAction(w, event, params, num_params)
 138 Widget w;
 139 XEvent *event;
 140 String * params;
 141 Cardinal * num_params;
 142 {
 143   TextWidget tw = (TextWidget) XtParent(XtParent(XtParent(w)));
 144   Boolean popdown = FALSE;
 145
 146   if ( (*num_params == 1) &&
 147        ((params[0][0] == 'p') || (params[0][0] == 'P')) )
 148       popdown = TRUE;
 149
 150   if (DoSearch(tw->text.search) && popdown)
 151     PopdownSearch(w, (XtPointer) tw->text.search, NULL);
 152 }
 153
 154 /*      Function Name: _XawTextPopdownSearchAction
 155  *      Description: Action routine that can be bound to dialog box's
 156  *                   Text Widget that will popdown the search widget.
 157  *      Arguments:   (Standard Action Routine args)
 158  *      Returns:     none.
 159  */
 160
 161 /* ARGSUSED */
 162 void
 163 _XawTextPopdownSearchAction(w, event, params, num_params)
 164 Widget w;
 165 XEvent *event;
 166 String * params;
 167 Cardinal * num_params;
 168 {
 169   TextWidget tw = (TextWidget) XtParent(XtParent(XtParent(w)));
 170
 171   PopdownSearch(w, (XtPointer) tw->text.search, NULL);
 172 }
 173
 174 /*      Function Name: PopdownSearch
 175  *      Description: Pops down the search widget and resets it.
 176  *      Arguments: w - *** NOT USED ***.
 177  *                 closure - a pointer to the search structure.
 178  *                 call_data - *** NOT USED ***.
 179  *      Returns: none
 180  */
 181
 182 /* ARGSUSED */
 183 static void
 184 PopdownSearch(w, closure, call_data)
 185 Widget w;
 186 XtPointer closure;
 187 XtPointer call_data;
 188 {
 189   struct SearchAndReplace * search = (struct SearchAndReplace *) closure;
 190
 191   SetSearchLabels(search, "Search", "", FALSE);
 192   XtPopdown( search->search_popup );
 193 }
 194
 195 /*      Function Name: SearchButton
 196  *      Description: Performs a search when the button is clicked.
 197  *      Arguments: w - *** NOT USED **.
 198  *                 closure - a pointer to the search info.
 199  *                 call_data - *** NOT USED ***.
 200  *      Returns:
 201  */
 202
 203 /* ARGSUSED */
 204 static void
 205 SearchButton(w, closure, call_data)
 206 Widget w;
 207 XtPointer closure;
 208 XtPointer call_data;
 209 {
 210   (void) DoSearch( (struct SearchAndReplace *) closure );
 211 }
 212
 213 /*      Function Name: _XawTextSearch
 214  *      Description: Action routine that can be bound to the text widget
 215  *                   it will popup the search dialog box.
 216  *      Arguments:   w - the text widget.
 217  *                   event - X Event (used to get x and y location).
 218  *                   params, num_params - the parameter list.
 219  *      Returns:     none.
 220  *
 221  * NOTE:
 222  *
 223  * The parameter list contains one or two entries that may be the following.
 224  *
 225  * First Entry:   The first entry is the direction to search by default.
 226  *                This argument must be specified and may have a value of
 227  *                "left" or "right".
 228  *
 229  * Second Entry:  This entry is optional and contains the value of the default
 230  *                string to search for.
 231  */
 232
 233 #define SEARCH_HEADER ("Text Widget - Search():")
 234
 235 void
 236 _XawTextSearch(w, event, params, num_params)
 237 Widget w;
 238 XEvent *event;
 239 String * params;
 240 Cardinal * num_params;
 241 {
 242   TextWidget ctx = (TextWidget)w;
 243   XawTextScanDirection dir;
 244   char * ptr, buf[BUFSIZ];
 245   XawTextEditType edit_mode;
 246   Arg args[1];
 247
 248 #ifdef notdef
 249   if (!ctx->text.source->Search) {
 250       XBell(XtDisplay(w), 0);
 251       return;
 252   }
 253 #endif
 254
 255   if ( (*num_params < 1) || (*num_params > 2) ) {
 256     sprintf(buf, "%s %s\n%s", SEARCH_HEADER, "This action must have only",
 257             "one or two parameters");
 258     XtAppWarning(XtWidgetToApplicationContext(w), buf);
 259     return;
 260   }
 261   else if (*num_params == 1)
 262     ptr = "";
 263   else
 264     ptr = params[1];
 265
 266   switch(params[0][0]) {
 267   case 'b':                     /* Left. */
 268   case 'B':
 269     dir = XawsdLeft;
 270     break;
 271   case 'f':                     /* Right. */
 272   case 'F':
 273     dir = XawsdRight;
 274     break;
 275   default:
 276     sprintf(buf, "%s %s\n%s", SEARCH_HEADER, "The first parameter must be",
 277             "Either 'backward' or 'forward'");
 278     XtAppWarning(XtWidgetToApplicationContext(w), buf);
 279     return;
 280   }
 281
 282   if (!ctx->text.search) {
 283     ctx->text.search = XtNew(struct SearchAndReplace);
 284     ctx->text.search->search_popup = CreateDialog(w, ptr, "search",
 285                                                   AddSearchChildren);
 286     XtRealizeWidget(ctx->text.search->search_popup);
 287     SetWMProtocolTranslations(ctx->text.search->search_popup);
 288   }
 289   else if (*num_params > 1)
 290     XtVaSetValues(ctx->text.search->search_text, XtNstring, ptr, NULL);
 291
 292   XtSetArg(args[0], XtNeditType,&edit_mode);
 293   XtGetValues(ctx->text.source, args, ONE);
 294
 295   InitializeSearchWidget(ctx->text.search, dir, (edit_mode == XawtextEdit));
 296
 297   CenterWidgetOnPoint(ctx->text.search->search_popup, event);
 298   XtPopup(ctx->text.search->search_popup, XtGrabNone);
 299 }
 300
 301 /*      Function Name: InitializeSearchWidget
 302  *      Description: This function initializes the search widget and
 303  *                   is called each time the search widget is poped up.
 304  *      Arguments: search - the search widget structure.
 305  *                 dir - direction to search.
 306  *                 replace_active - state of the sensitivity for the
 307  *                                  replace button.
 308  *      Returns: none.
 309  */
 310
 311 static void
 312 InitializeSearchWidget(struct SearchAndReplace *search,
 313   XawTextScanDirection dir, Boolean replace_active)
 314 {
 315 replace_active = replace_active; /* PH - shuts compilers up */
 316
 317   switch (dir) {
 318   case XawsdLeft:
 319     SetResource(search->left_toggle, XtNstate, (XtArgVal) TRUE);
 320     break;
 321   case XawsdRight:
 322     SetResource(search->right_toggle, XtNstate, (XtArgVal) TRUE);
 323     break;
 324   default:
 325     break;
 326   }
 327 }
 328
 329 /*      Function Name: AddSearchChildren
 330  *      Description: Adds all children to the Search Dialog Widget.
 331  *      Arguments: form - the form widget for the search widget.
 332  *                 ptr - a pointer to the initial string for the Text Widget.
 333  *                 tw - the main text widget.
 334  *      Returns: none.
 335  */
 336
 337 static void
 338 AddSearchChildren(form, ptr, tw)
 339 Widget form, tw;
 340 char * ptr;
 341 {
 342   Arg args[10];
 343   Cardinal num_args;
 344   Widget cancel, search_button, s_label, s_text;
 345   XtTranslations trans;
 346   struct SearchAndReplace * search = ((TextWidget) tw)->text.search;
 347
 348   num_args = 0;
 349   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 350   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 351   XtSetArg(args[num_args], XtNresizable, TRUE ); num_args++;
 352   XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++;
 353   search->label1 = XtCreateManagedWidget("label1", labelWidgetClass,
 354                                          form, args, num_args);
 355
 356  /*
 357  * We need to add R_OFFSET to the radio_data, because the value zero (0)
 358  * has special meaning.
 359  */
 360
 361   num_args = 0;
 362   XtSetArg(args[num_args], XtNlabel, "Backward"); num_args++;
 363   XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++;
 364   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 365   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 366   XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdLeft + R_OFFSET);
 367   num_args++;
 368   search->left_toggle = XtCreateManagedWidget("backwards", toggleWidgetClass,
 369                                               form, args, num_args);
 370
 371   num_args = 0;
 372   XtSetArg(args[num_args], XtNlabel, "Forward"); num_args++;
 373   XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++;
 374   XtSetArg(args[num_args], XtNfromHoriz, search->left_toggle); num_args++;
 375   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 376   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 377   XtSetArg(args[num_args], XtNradioGroup, search->left_toggle); num_args++;
 378   XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdRight + R_OFFSET);
 379   num_args++;
 380   search->right_toggle = XtCreateManagedWidget("forwards", toggleWidgetClass,
 381                                                form, args, num_args);
 382
 383   {
 384     XtTranslations radio_translations;
 385
 386     radio_translations = XtParseTranslationTable(radio_trans_string);
 387     XtOverrideTranslations(search->left_toggle, radio_translations);
 388     XtOverrideTranslations(search->right_toggle, radio_translations);
 389   }
 390
 391   num_args = 0;
 392   XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++;
 393   XtSetArg(args[num_args], XtNlabel, "Search for:  ");num_args++;
 394   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 395   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 396   XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++;
 397   s_label = XtCreateManagedWidget("searchLabel", labelWidgetClass,
 398                                   form, args, num_args);
 399
 400   num_args = 0;
 401   XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++;
 402   XtSetArg(args[num_args], XtNfromHoriz, s_label); num_args++;
 403   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 404   XtSetArg(args[num_args], XtNright, XtChainRight); num_args++;
 405   XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++;
 406   XtSetArg(args[num_args], XtNresizable, TRUE); num_args++;
 407   XtSetArg(args[num_args], XtNresize, XawtextResizeWidth); num_args++;
 408   XtSetArg(args[num_args], XtNstring, ptr); num_args++;
 409   s_text = XtCreateManagedWidget("searchText", asciiTextWidgetClass, form,
 410                                  args, num_args);
 411   search->search_text = s_text;
 412
 413   num_args = 0;
 414   XtSetArg(args[num_args], XtNlabel, "Search"); num_args++;
 415   XtSetArg(args[num_args], XtNfromVert, s_text); num_args++;
 416   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 417   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 418   search_button = XtCreateManagedWidget("search", commandWidgetClass, form,
 419                                         args, num_args);
 420
 421   num_args = 0;
 422   XtSetArg(args[num_args], XtNlabel, "Cancel"); num_args++;
 423   XtSetArg(args[num_args], XtNfromVert, s_text); num_args++;
 424   XtSetArg(args[num_args], XtNfromHoriz, search_button); num_args++;
 425   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 426   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 427   cancel = XtCreateManagedWidget(DISMISS_NAME, commandWidgetClass, form,
 428                                  args, num_args);
 429
 430   XtAddCallback(search_button, XtNcallback, SearchButton, (XtPointer) search);
 431   XtAddCallback(cancel, XtNcallback, PopdownSearch, (XtPointer) search);
 432
 433 /*
 434  * Initialize the text entry fields.
 435  */
 436
 437   SetSearchLabels(search, "Search", "", FALSE);
 438   XtSetKeyboardFocus(form, search->search_text);
 439
 440 /*
 441  * Bind Extra translations.
 442  */
 443
 444   trans = XtParseTranslationTable(search_text_trans);
 445   XtOverrideTranslations(search->search_text, trans);
 446 }
 447
 448 /*      Function Name: DoSearch
 449  *      Description: Performs a search.
 450  *      Arguments: search - the search structure.
 451  *      Returns: TRUE if successful.
 452  */
 453
 454 /* ARGSUSED */
 455 static Boolean
 456 DoSearch(search)
 457 struct SearchAndReplace * search;
 458 {
 459   char msg[BUFSIZ];
 460   Widget tw = XtParent(search->search_popup);
 461   XawTextPosition pos;
 462   XawTextScanDirection dir;
 463   XawTextBlock text;
 464
 465   text.ptr = GetString(search->search_text);
 466   text.length = strlen(text.ptr);
 467   text.firstPos = 0;
 468   text.format = FMT8BIT;
 469
 470   dir = (XawTextScanDirection) ((long)XawToggleGetCurrent(search->left_toggle) -
 471                                 R_OFFSET);
 472
 473   pos = XawTextSearch( tw, dir, &text);
 474
 475   if (pos == XawTextSearchError)
 476     sprintf( msg, "Could not find string '%s'.", text.ptr);
 477   else {
 478     if (dir == XawsdRight)
 479       XawTextSetInsertionPoint( tw, pos + text.length);
 480     else
 481       XawTextSetInsertionPoint( tw, pos);
 482
 483     XawTextSetSelection( tw, pos, pos + text.length);
 484     search->selection_changed = FALSE; /* selection is good. */
 485     return(TRUE);
 486   }
 487
 488   XawTextUnsetSelection(tw);
 489   SetSearchLabels(search, msg, "", TRUE);
 490   return(FALSE);
 491 }
 492
 493
 494 /*      Function Name: SetSearchLabels
 495  *      Description: Sets both the search labels, and also rings the bell
 496  *  HACKED: Only one label needed now
 497  *      Arguments: search - the search structure.
 498  *                 msg1, msg2 - message to put in each search label.
 499  *                 bell - if TRUE then ring bell.
 500  *      Returns: none.
 501  */
 502
 503 static void
 504 SetSearchLabels(struct SearchAndReplace *search, String msg1, String msg2,
 505   Boolean bell)
 506 {
 507 msg2 = msg2; /* PH - shuts compilers up */
 508   (void) SetResource( search->label1, XtNlabel, (XtArgVal) msg1);
 509   /* (void) SetResource( search->label2, XtNlabel, (XtArgVal) msg2); */
 510   if (bell)
 511     XBell(XtDisplay(search->search_popup), 0);
 512 }
 513
 514 /************************************************************
 515  *
 516  * This section of the file contains utility routines used by
 517  * other functions in this file.
 518  *
 519  ************************************************************/
 520
 521
 522 /*      Function Name: SetResource
 523  *      Description: Sets a resource in a widget
 524  *      Arguments: w - the widget.
 525  *                 res_name - name of the resource.
 526  *                 value - the value of the resource.
 527  *      Returns: none.
 528  */
 529
 530 static void
 531 SetResource(w, res_name, value)
 532 Widget w;
 533 char * res_name;
 534 XtArgVal value;
 535 {
 536   Arg args[1];
 537
 538   XtSetArg(args[0], res_name, value);
 539   XtSetValues( w, args, ONE );
 540 }
 541
 542 /*      Function Name: GetString
 543  *      Description:   Gets the value for the string in the popup.
 544  *      Arguments:     text - the text widget whose string we will get.
 545  *      Returns:       the string.
 546  */
 547
 548 static String
 549 GetString(text)
 550 Widget text;
 551 {
 552   String string;
 553   Arg args[1];
 554
 555   XtSetArg( args[0], XtNstring, &string );
 556   XtGetValues( text, args, ONE );
 557   return(string);
 558 }
 559
 560 /*      Function Name: CenterWidgetOnPoint.
 561  *      Description: Centers a shell widget on a point relative to
 562  *                   the root window.
 563  *      Arguments: w - the shell widget.
 564  *                 event - event containing the location of the point
 565  *      Returns: none.
 566  *
 567  * NOTE: The widget is not allowed to go off the screen.
 568  */
 569
 570 static void
 571 CenterWidgetOnPoint(w, event)
 572 Widget w;
 573 XEvent *event;
 574 {
 575   Arg args[3];
 576   Cardinal num_args;
 577   Dimension width, height, b_width;
 578   Position x=0, y=0, max_x, max_y;
 579
 580   if (event != NULL) {
 581     switch (event->type) {
 582     case ButtonPress:
 583     case ButtonRelease:
 584       x = event->xbutton.x_root;
 585       y = event->xbutton.y_root;
 586       break;
 587     case KeyPress:
 588     case KeyRelease:
 589       x = event->xkey.x_root;
 590       y = event->xkey.y_root;
 591       break;
 592     default:
 593       return;
 594     }
 595   }
 596
 597   num_args = 0;
 598   XtSetArg(args[num_args], XtNwidth, &width); num_args++;
 599   XtSetArg(args[num_args], XtNheight, &height); num_args++;
 600   XtSetArg(args[num_args], XtNborderWidth, &b_width); num_args++;
 601   XtGetValues(w, args, num_args);
 602
 603   width += 2 * b_width;
 604   height += 2 * b_width;
 605
 606   x -= ( (Position) width/2 );
 607   if (x < 0) x = 0;
 608   if ( x > (max_x = (Position) (XtScreen(w)->width - width)) ) x = max_x;
 609
 610   y -= ( (Position) height/2 );
 611   if (y < 0) y = 0;
 612   if ( y > (max_y = (Position) (XtScreen(w)->height - height)) ) y = max_y;
 613
 614   num_args = 0;
 615   XtSetArg(args[num_args], XtNx, x); num_args++;
 616   XtSetArg(args[num_args], XtNy, y); num_args++;
 617   XtSetValues(w, args, num_args);
 618 }
 619
 620 /*      Function Name: CreateDialog
 621  *      Description: Actually creates a dialog.
 622  *      Arguments: parent - the parent of the dialog - the main text widget.
 623  *                 ptr - initial_string for the dialog.
 624  *                 name - name of the dialog.
 625  *                 func - function to create the children of the dialog.
 626  *      Returns: the popup shell of the dialog.
 627  *
 628  * NOTE:
 629  *
 630  * The function argument is passed the following arguments.
 631  *
 632  * form - the from widget that is the dialog.
 633  * ptr - the initial string for the dialog's text widget.
 634  * parent - the parent of the dialog - the main text widget.
 635  */
 636
 637 static Widget
 638 CreateDialog(parent, ptr, name, func)
 639 Widget parent;
 640 String ptr, name;
 641 void (*func)();
 642 {
 643   Widget popup, form;
 644   Arg args[5];
 645   Cardinal num_args;
 646
 647   num_args = 0;
 648   XtSetArg(args[num_args], XtNiconName, name); num_args++;
 649   XtSetArg(args[num_args], XtNgeometry, NULL); num_args++;
 650   XtSetArg(args[num_args], XtNallowShellResize, TRUE); num_args++;
 651   XtSetArg(args[num_args], XtNtransientFor, GetShell(parent)); num_args++;
 652   popup = XtCreatePopupShell(name, transientShellWidgetClass,
 653                              parent, args, num_args);
 654
 655   form = XtCreateManagedWidget(FORM_NAME, formWidgetClass, popup,
 656                                NULL, ZERO);
 657
 658   (*func) (form, ptr, parent);
 659   return(popup);
 660 }
 661
 662  /*     Function Name: GetShell
 663   *     Description: Walks up the widget hierarchy to find the
 664   *             nearest shell widget.
 665   *     Arguments: w - the widget whose parent shell should be returned.
 666   *     Returns: The shell widget among the ancestors of w that is the
 667   *             fewest levels up in the widget hierarchy.
 668   */
 669
 670 static Widget
 671 GetShell(w)
 672 Widget w;
 673 {
 674     while ((w != NULL) && !XtIsShell(w))
 675         w = XtParent(w);
 676
 677     return (w);
 678 }
 679
 680 /* Add proper prototype to keep IRIX 6 compiler happy. PH */
 681
 682 static Boolean InParams(String, String *, Cardinal);
 683
 684 static Boolean InParams(str, p, n)
 685     String str;
 686     String *p;
 687     Cardinal n;
 688 {
 689     int i;
 690     for (i=0; i < n; p++, i++)
 691         if (! XmuCompareISOLatin1(*p, str)) return True;
 692     return False;
 693 }
 694
 695 static char *WM_DELETE_WINDOW = "WM_DELETE_WINDOW";
 696
 697 static void WMProtocols(w, event, params, num_params)
 698     Widget w;           /* popup shell */
 699     XEvent *event;
 700     String *params;
 701     Cardinal *num_params;
 702 {
 703     Atom wm_delete_window;
 704     Atom wm_protocols;
 705
 706     wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, True);
 707     wm_protocols = XInternAtom(XtDisplay(w), "WM_PROTOCOLS", True);
 708
 709     /* Respond to a recognized WM protocol request iff
 710      * event type is ClientMessage and no parameters are passed, or
 711      * event type is ClientMessage and event data is matched to parameters, or
 712      * event type isn't ClientMessage and parameters make a request.
 713      */
 714 #define DO_DELETE_WINDOW InParams(WM_DELETE_WINDOW, params, *num_params)
 715
 716     if ((event->type == ClientMessage &&
 717          event->xclient.message_type == wm_protocols &&
 718          event->xclient.data.l[0] == wm_delete_window &&
 719          (*num_params == 0 || DO_DELETE_WINDOW))
 720         ||
 721         (event->type != ClientMessage && DO_DELETE_WINDOW)) {
 722
 723 #undef DO_DELETE_WINDOW
 724
 725         Widget cancel;
 726         char descendant[DISMISS_NAME_LEN + 2];
 727         sprintf(descendant, "*%s", DISMISS_NAME);
 728         cancel = XtNameToWidget(w, descendant);
 729         if (cancel) XtCallCallbacks(cancel, XtNcallback, (XtPointer)NULL);
 730     }
 731 }
 732
 733 static void SetWMProtocolTranslations(w)
 734     Widget      w;      /* realized popup shell */
 735 {
 736     int i;
 737     XtAppContext app_context;
 738     Atom wm_delete_window;
 739     static XtTranslations compiled_table;       /* initially 0 */
 740     static XtAppContext *app_context_list;      /* initially 0 */
 741     static Cardinal list_size;                  /* initially 0 */
 742
 743     app_context = XtWidgetToApplicationContext(w);
 744
 745     /* parse translation table once */
 746     if (! compiled_table) compiled_table = XtParseTranslationTable
 747         ("<Message>WM_PROTOCOLS: XawWMProtocols()\n");
 748
 749     /* add actions once per application context */
 750     for (i=0; i < list_size && app_context_list[i] != app_context; i++) ;
 751     if (i == list_size) {
 752         XtActionsRec actions[1];
 753         actions[0].string = "XawWMProtocols";
 754         actions[0].proc = WMProtocols;
 755         list_size++;
 756         app_context_list = (XtAppContext *) XtRealloc
 757             ((char *)app_context_list, list_size * sizeof(XtAppContext));
 758         XtAppAddActions(app_context, actions, 1);
 759         app_context_list[i] = app_context;
 760     }
 761
 762     /* establish communication between the window manager and each shell */
 763     XtAugmentTranslations(w, compiled_table);
 764     wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, False);
 765     (void) XSetWMProtocols(XtDisplay(w), XtWindow(w), &wm_delete_window, 1);
 766 }