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 == NULL) {
 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== NULL) {
 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
 293   XtSetArg(args[0], XtNeditType,&edit_mode);
 294   XtGetValues(ctx->text.source, args, ONE);
 295
 296   InitializeSearchWidget(ctx->text.search, dir, (edit_mode == XawtextEdit));
 297
 298   CenterWidgetOnPoint(ctx->text.search->search_popup, event);
 299   XtPopup(ctx->text.search->search_popup, XtGrabNone);
 300 }
 301
 302 /*      Function Name: InitializeSearchWidget
 303  *      Description: This function initializes the search widget and
 304  *                   is called each time the search widget is poped up.
 305  *      Arguments: search - the search widget structure.
 306  *                 dir - direction to search.
 307  *                 replace_active - state of the sensitivity for the
 308  *                                  replace button.
 309  *      Returns: none.
 310  */
 311
 312 static void
 313 InitializeSearchWidget(struct SearchAndReplace *search,
 314   XawTextScanDirection dir, Boolean replace_active)
 315 {
 316 replace_active = replace_active; /* PH - shuts compilers up */
 317
 318   switch (dir) {
 319   case XawsdLeft:
 320     SetResource(search->left_toggle, XtNstate, (XtArgVal) TRUE);
 321     break;
 322   case XawsdRight:
 323     SetResource(search->right_toggle, XtNstate, (XtArgVal) TRUE);
 324     break;
 325   default:
 326     break;
 327   }
 328 }
 329
 330 /*      Function Name: AddSearchChildren
 331  *      Description: Adds all children to the Search Dialog Widget.
 332  *      Arguments: form - the form widget for the search widget.
 333  *                 ptr - a pointer to the initial string for the Text Widget.
 334  *                 tw - the main text widget.
 335  *      Returns: none.
 336  */
 337
 338 static void
 339 AddSearchChildren(form, ptr, tw)
 340 Widget form, tw;
 341 char * ptr;
 342 {
 343   Arg args[10];
 344   Cardinal num_args;
 345   Widget cancel, search_button, s_label, s_text;
 346   XtTranslations trans;
 347   struct SearchAndReplace * search = ((TextWidget) tw)->text.search;
 348
 349   num_args = 0;
 350   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 351   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 352   XtSetArg(args[num_args], XtNresizable, TRUE ); num_args++;
 353   XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++;
 354   search->label1 = XtCreateManagedWidget("label1", labelWidgetClass,
 355                                          form, args, num_args);
 356
 357  /*
 358  * We need to add R_OFFSET to the radio_data, because the value zero (0)
 359  * has special meaning.
 360  */
 361
 362   num_args = 0;
 363   XtSetArg(args[num_args], XtNlabel, "Backward"); num_args++;
 364   XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++;
 365   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 366   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 367   XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdLeft + R_OFFSET);
 368   num_args++;
 369   search->left_toggle = XtCreateManagedWidget("backwards", toggleWidgetClass,
 370                                               form, args, num_args);
 371
 372   num_args = 0;
 373   XtSetArg(args[num_args], XtNlabel, "Forward"); num_args++;
 374   XtSetArg(args[num_args], XtNfromVert, search->label1); num_args++;
 375   XtSetArg(args[num_args], XtNfromHoriz, search->left_toggle); num_args++;
 376   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 377   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 378   XtSetArg(args[num_args], XtNradioGroup, search->left_toggle); num_args++;
 379   XtSetArg(args[num_args], XtNradioData, (caddr_t) XawsdRight + R_OFFSET);
 380   num_args++;
 381   search->right_toggle = XtCreateManagedWidget("forwards", toggleWidgetClass,
 382                                                form, args, num_args);
 383
 384   {
 385     XtTranslations radio_translations;
 386
 387     radio_translations = XtParseTranslationTable(radio_trans_string);
 388     XtOverrideTranslations(search->left_toggle, radio_translations);
 389     XtOverrideTranslations(search->right_toggle, radio_translations);
 390   }
 391
 392   num_args = 0;
 393   XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++;
 394   XtSetArg(args[num_args], XtNlabel, "Search for:  ");num_args++;
 395   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 396   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 397   XtSetArg(args[num_args], XtNborderWidth, 0 ); num_args++;
 398   s_label = XtCreateManagedWidget("searchLabel", labelWidgetClass,
 399                                   form, args, num_args);
 400
 401   num_args = 0;
 402   XtSetArg(args[num_args], XtNfromVert, search->left_toggle); num_args++;
 403   XtSetArg(args[num_args], XtNfromHoriz, s_label); num_args++;
 404   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 405   XtSetArg(args[num_args], XtNright, XtChainRight); num_args++;
 406   XtSetArg(args[num_args], XtNeditType, XawtextEdit); num_args++;
 407   XtSetArg(args[num_args], XtNresizable, TRUE); num_args++;
 408   XtSetArg(args[num_args], XtNresize, XawtextResizeWidth); num_args++;
 409   XtSetArg(args[num_args], XtNstring, ptr); num_args++;
 410   s_text = XtCreateManagedWidget("searchText", asciiTextWidgetClass, form,
 411                                  args, num_args);
 412   search->search_text = s_text;
 413
 414   num_args = 0;
 415   XtSetArg(args[num_args], XtNlabel, "Search"); num_args++;
 416   XtSetArg(args[num_args], XtNfromVert, s_text); num_args++;
 417   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 418   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 419   search_button = XtCreateManagedWidget("search", commandWidgetClass, form,
 420                                         args, num_args);
 421
 422   num_args = 0;
 423   XtSetArg(args[num_args], XtNlabel, "Cancel"); num_args++;
 424   XtSetArg(args[num_args], XtNfromVert, s_text); num_args++;
 425   XtSetArg(args[num_args], XtNfromHoriz, search_button); num_args++;
 426   XtSetArg(args[num_args], XtNleft, XtChainLeft); num_args++;
 427   XtSetArg(args[num_args], XtNright, XtChainLeft); num_args++;
 428   cancel = XtCreateManagedWidget(DISMISS_NAME, commandWidgetClass, form,
 429                                  args, num_args);
 430
 431   XtAddCallback(search_button, XtNcallback, SearchButton, (XtPointer) search);
 432   XtAddCallback(cancel, XtNcallback, PopdownSearch, (XtPointer) search);
 433
 434 /*
 435  * Initialize the text entry fields.
 436  */
 437
 438   SetSearchLabels(search, "Search", "", FALSE);
 439   XtSetKeyboardFocus(form, search->search_text);
 440
 441 /*
 442  * Bind Extra translations.
 443  */
 444
 445   trans = XtParseTranslationTable(search_text_trans);
 446   XtOverrideTranslations(search->search_text, trans);
 447 }
 448
 449 /*      Function Name: DoSearch
 450  *      Description: Performs a search.
 451  *      Arguments: search - the search structure.
 452  *      Returns: TRUE if successful.
 453  */
 454
 455 /* ARGSUSED */
 456 static Boolean
 457 DoSearch(search)
 458 struct SearchAndReplace * search;
 459 {
 460   char msg[BUFSIZ];
 461   Widget tw = XtParent(search->search_popup);
 462   XawTextPosition pos;
 463   XawTextScanDirection dir;
 464   XawTextBlock text;
 465
 466   text.ptr = GetString(search->search_text);
 467   text.length = strlen(text.ptr);
 468   text.firstPos = 0;
 469   text.format = FMT8BIT;
 470
 471   dir = (XawTextScanDirection) ((long)XawToggleGetCurrent(search->left_toggle) -
 472                                 R_OFFSET);
 473
 474   pos = XawTextSearch( tw, dir, &text);
 475
 476   if (pos == XawTextSearchError)
 477     sprintf( msg, "Could not find string '%s'.", text.ptr);
 478   else {
 479     if (dir == XawsdRight)
 480       XawTextSetInsertionPoint( tw, pos + text.length);
 481     else
 482       XawTextSetInsertionPoint( tw, pos);
 483
 484     XawTextSetSelection( tw, pos, pos + text.length);
 485     search->selection_changed = FALSE; /* selection is good. */
 486     return(TRUE);
 487   }
 488
 489   XawTextUnsetSelection(tw);
 490   SetSearchLabels(search, msg, "", TRUE);
 491   return(FALSE);
 492 }
 493
 494
 495 /*      Function Name: SetSearchLabels
 496  *      Description: Sets both the search labels, and also rings the bell
 497  *  HACKED: Only one label needed now
 498  *      Arguments: search - the search structure.
 499  *                 msg1, msg2 - message to put in each search label.
 500  *                 bell - if TRUE then ring bell.
 501  *      Returns: none.
 502  */
 503
 504 static void
 505 SetSearchLabels(struct SearchAndReplace *search, String msg1, String msg2,
 506   Boolean bell)
 507 {
 508 msg2 = msg2; /* PH - shuts compilers up */
 509   (void) SetResource( search->label1, XtNlabel, (XtArgVal) msg1);
 510   /* (void) SetResource( search->label2, XtNlabel, (XtArgVal) msg2); */
 511   if (bell)
 512     XBell(XtDisplay(search->search_popup), 0);
 513 }
 514
 515 /************************************************************
 516  *
 517  * This section of the file contains utility routines used by
 518  * other functions in this file.
 519  *
 520  ************************************************************/
 521
 522
 523 /*      Function Name: SetResource
 524  *      Description: Sets a resource in a widget
 525  *      Arguments: w - the widget.
 526  *                 res_name - name of the resource.
 527  *                 value - the value of the resource.
 528  *      Returns: none.
 529  */
 530
 531 static void
 532 SetResource(w, res_name, value)
 533 Widget w;
 534 char * res_name;
 535 XtArgVal value;
 536 {
 537   Arg args[1];
 538
 539   XtSetArg(args[0], res_name, value);
 540   XtSetValues( w, args, ONE );
 541 }
 542
 543 /*      Function Name: GetString
 544  *      Description:   Gets the value for the string in the popup.
 545  *      Arguments:     text - the text widget whose string we will get.
 546  *      Returns:       the string.
 547  */
 548
 549 static String
 550 GetString(text)
 551 Widget text;
 552 {
 553   String string;
 554   Arg args[1];
 555
 556   XtSetArg( args[0], XtNstring, &string );
 557   XtGetValues( text, args, ONE );
 558   return(string);
 559 }
 560
 561 /*      Function Name: CenterWidgetOnPoint.
 562  *      Description: Centers a shell widget on a point relative to
 563  *                   the root window.
 564  *      Arguments: w - the shell widget.
 565  *                 event - event containing the location of the point
 566  *      Returns: none.
 567  *
 568  * NOTE: The widget is not allowed to go off the screen.
 569  */
 570
 571 static void
 572 CenterWidgetOnPoint(w, event)
 573 Widget w;
 574 XEvent *event;
 575 {
 576   Arg args[3];
 577   Cardinal num_args;
 578   Dimension width, height, b_width;
 579   Position x=0, y=0, max_x, max_y;
 580
 581   if (event != NULL) {
 582     switch (event->type) {
 583     case ButtonPress:
 584     case ButtonRelease:
 585       x = event->xbutton.x_root;
 586       y = event->xbutton.y_root;
 587       break;
 588     case KeyPress:
 589     case KeyRelease:
 590       x = event->xkey.x_root;
 591       y = event->xkey.y_root;
 592       break;
 593     default:
 594       return;
 595     }
 596   }
 597
 598   num_args = 0;
 599   XtSetArg(args[num_args], XtNwidth, &width); num_args++;
 600   XtSetArg(args[num_args], XtNheight, &height); num_args++;
 601   XtSetArg(args[num_args], XtNborderWidth, &b_width); num_args++;
 602   XtGetValues(w, args, num_args);
 603
 604   width += 2 * b_width;
 605   height += 2 * b_width;
 606
 607   x -= ( (Position) width/2 );
 608   if (x < 0) x = 0;
 609   if ( x > (max_x = (Position) (XtScreen(w)->width - width)) ) x = max_x;
 610
 611   y -= ( (Position) height/2 );
 612   if (y < 0) y = 0;
 613   if ( y > (max_y = (Position) (XtScreen(w)->height - height)) ) y = max_y;
 614
 615   num_args = 0;
 616   XtSetArg(args[num_args], XtNx, x); num_args++;
 617   XtSetArg(args[num_args], XtNy, y); num_args++;
 618   XtSetValues(w, args, num_args);
 619 }
 620
 621 /*      Function Name: CreateDialog
 622  *      Description: Actually creates a dialog.
 623  *      Arguments: parent - the parent of the dialog - the main text widget.
 624  *                 ptr - initial_string for the dialog.
 625  *                 name - name of the dialog.
 626  *                 func - function to create the children of the dialog.
 627  *      Returns: the popup shell of the dialog.
 628  *
 629  * NOTE:
 630  *
 631  * The function argument is passed the following arguments.
 632  *
 633  * form - the from widget that is the dialog.
 634  * ptr - the initial string for the dialog's text widget.
 635  * parent - the parent of the dialog - the main text widget.
 636  */
 637
 638 static Widget
 639 CreateDialog(parent, ptr, name, func)
 640 Widget parent;
 641 String ptr, name;
 642 void (*func)();
 643 {
 644   Widget popup, form;
 645   Arg args[5];
 646   Cardinal num_args;
 647
 648   num_args = 0;
 649   XtSetArg(args[num_args], XtNiconName, name); num_args++;
 650   XtSetArg(args[num_args], XtNgeometry, NULL); num_args++;
 651   XtSetArg(args[num_args], XtNallowShellResize, TRUE); num_args++;
 652   XtSetArg(args[num_args], XtNtransientFor, GetShell(parent)); num_args++;
 653   popup = XtCreatePopupShell(name, transientShellWidgetClass,
 654                              parent, args, num_args);
 655
 656   form = XtCreateManagedWidget(FORM_NAME, formWidgetClass, popup,
 657                                NULL, ZERO);
 658
 659   (*func) (form, ptr, parent);
 660   return(popup);
 661 }
 662
 663  /*     Function Name: GetShell
 664   *     Description: Walks up the widget hierarchy to find the
 665   *             nearest shell widget.
 666   *     Arguments: w - the widget whose parent shell should be returned.
 667   *     Returns: The shell widget among the ancestors of w that is the
 668   *             fewest levels up in the widget hierarchy.
 669   */
 670
 671 static Widget
 672 GetShell(w)
 673 Widget w;
 674 {
 675     while ((w != NULL) && !XtIsShell(w))
 676         w = XtParent(w);
 677
 678     return (w);
 679 }
 680
 681 /* Add proper prototype to keep IRIX 6 compiler happy. PH */
 682
 683 static Boolean InParams(String, String *, Cardinal);
 684
 685 static Boolean InParams(str, p, n)
 686     String str;
 687     String *p;
 688     Cardinal n;
 689 {
 690     int i;
 691     for (i=0; i < n; p++, i++)
 692         if (! XmuCompareISOLatin1(*p, str)) return True;
 693     return False;
 694 }
 695
 696 static char *WM_DELETE_WINDOW = "WM_DELETE_WINDOW";
 697
 698 static void WMProtocols(w, event, params, num_params)
 699     Widget w;           /* popup shell */
 700     XEvent *event;
 701     String *params;
 702     Cardinal *num_params;
 703 {
 704     Atom wm_delete_window;
 705     Atom wm_protocols;
 706
 707     wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, True);
 708     wm_protocols = XInternAtom(XtDisplay(w), "WM_PROTOCOLS", True);
 709
 710     /* Respond to a recognized WM protocol request iff
 711      * event type is ClientMessage and no parameters are passed, or
 712      * event type is ClientMessage and event data is matched to parameters, or
 713      * event type isn't ClientMessage and parameters make a request.
 714      */
 715 #define DO_DELETE_WINDOW InParams(WM_DELETE_WINDOW, params, *num_params)
 716
 717     if ((event->type == ClientMessage &&
 718          event->xclient.message_type == wm_protocols &&
 719          event->xclient.data.l[0] == wm_delete_window &&
 720          (*num_params == 0 || DO_DELETE_WINDOW))
 721         ||
 722         (event->type != ClientMessage && DO_DELETE_WINDOW)) {
 723
 724 #undef DO_DELETE_WINDOW
 725
 726         Widget cancel;
 727         char descendant[DISMISS_NAME_LEN + 2];
 728         sprintf(descendant, "*%s", DISMISS_NAME);
 729         cancel = XtNameToWidget(w, descendant);
 730         if (cancel) XtCallCallbacks(cancel, XtNcallback, (XtPointer)NULL);
 731     }
 732 }
 733
 734 static void SetWMProtocolTranslations(w)
 735     Widget      w;      /* realized popup shell */
 736 {
 737     int i;
 738     XtAppContext app_context;
 739     Atom wm_delete_window;
 740     static XtTranslations compiled_table;       /* initially 0 */
 741     static XtAppContext *app_context_list;      /* initially 0 */
 742     static Cardinal list_size;                  /* initially 0 */
 743
 744     app_context = XtWidgetToApplicationContext(w);
 745
 746     /* parse translation table once */
 747     if (! compiled_table) compiled_table = XtParseTranslationTable
 748         ("<Message>WM_PROTOCOLS: XawWMProtocols()\n");
 749
 750     /* add actions once per application context */
 751     for (i=0; i < list_size && app_context_list[i] != app_context; i++) ;
 752     if (i == list_size) {
 753         XtActionsRec actions[1];
 754         actions[0].string = "XawWMProtocols";
 755         actions[0].proc = WMProtocols;
 756         list_size++;
 757         app_context_list = (XtAppContext *) XtRealloc
 758             ((char *)app_context_list, list_size * sizeof(XtAppContext));
 759         XtAppAddActions(app_context, actions, 1);
 760         app_context_list[i] = app_context;
 761     }
 762
 763     /* establish communication between the window manager and each shell */
 764     XtAugmentTranslations(w, compiled_table);
 765     wm_delete_window = XInternAtom(XtDisplay(w), WM_DELETE_WINDOW, False);
 766     (void) XSetWMProtocols(XtDisplay(w), XtWindow(w), &wm_delete_window, 1);
 767 }