926dbd95b75df8e21fcf644482284dd1413deea6
[exim.git] / src / exim_monitor / em_menu.c
1 /*************************************************
2 *                  Exim Monitor                  *
3 *************************************************/
4
5 /* Copyright (c) University of Cambridge 1995 - 2018 */
6 /* Copyright (c) The Exim Maintainers 2021 */
7 /* See the file NOTICE for conditions of use and distribution. */
8 /* SPDX-License-Identifier: GPL-2.0-or-later */
9
10
11 #include "em_hdr.h"
12
13 /* This module contains code for handling the popup menus. */
14
15 static Widget menushell;
16 static Widget queue_text_sink;
17 static Widget dialog_shell, dialog_widget;
18
19 static Widget text_create(uschar *, int);
20
21 static int highlighted_start, highlighted_end, highlighted_x, highlighted_y;
22
23
24
25 static Arg queue_get_arg[] = {
26   { "textSink",   (XtArgVal)NULL },
27   { "textSource", (XtArgVal)NULL },
28   { "string",     (XtArgVal)NULL } };
29
30 static Arg dialog_arg[] = {
31   { "label",      (XtArgVal)"dialog" },
32   { "value",      (XtArgVal)"value" } };
33
34 static Arg get_pos_args[] = {
35   {"x",           (XtArgVal)NULL },
36   {"y",           (XtArgVal)NULL } };
37
38 static Arg menushell_arg[] = {
39   { "label",      (XtArgVal)NULL } };
40
41 static Arg button_arg[] = {
42   { XtNfromVert, (XtArgVal) NULL },         /* must be first */
43   { XtNlabel,    (XtArgVal) " Dismiss " },
44   { "left",      XawChainLeft },
45   { "right",     XawChainLeft },
46   { "top",       XawChainBottom },
47   { "bottom",    XawChainBottom } };
48
49 static Arg text_arg[] = {
50   { XtNfromVert, (XtArgVal) NULL },         /* must be first */
51   { "editType",  XawtextEdit },
52   { "string",    (XtArgVal)"" },            /* dummy to get it going */
53   { "scrollVertical", XawtextScrollAlways },
54   { "wrap",      XawtextWrapWord },
55   { "top",       XawChainTop },
56   { "bottom",    XawChainBottom } };
57
58 static Arg item_1_arg[] = {
59   { XtNfromVert,  (XtArgVal)NULL },         /* must be first */
60   { "label",      (XtArgVal)" Message log" } };
61
62 static Arg item_2_arg[] = {
63   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
64   { "label",      (XtArgVal)" Headers" } };
65
66 static Arg item_3_arg[] = {
67   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
68   { "label",      (XtArgVal)" Body" } };
69
70 static Arg item_4_arg[] = {
71   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
72   { "label",      (XtArgVal)" Deliver message" } };
73
74 static Arg item_5_arg[] = {
75   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
76   { "label",      (XtArgVal)" Freeze message" } };
77
78 static Arg item_6_arg[] = {
79   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
80   { "label",      (XtArgVal)" Thaw message" } };
81
82 static Arg item_7_arg[] = {
83   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
84   { "label",      (XtArgVal)" Give up on msg" } };
85
86 static Arg item_8_arg[] = {
87   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
88   { "label",      (XtArgVal)" Remove message" } };
89
90 static Arg item_9_arg[] = {
91   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
92   { "label",      (XtArgVal)"----------------" } };
93
94 static Arg item_10_arg[] = {
95   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
96   { "label",      (XtArgVal)" Add recipient" } };
97
98 static Arg item_11_arg[] = {
99   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
100   { "label",      (XtArgVal)" Mark delivered" } };
101
102 static Arg item_12_arg[] = {
103   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
104   { "label",      (XtArgVal)" Mark all delivered" } };
105
106 static Arg item_13_arg[] = {
107   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
108   { "label",      (XtArgVal)" Edit sender" } };
109
110 static Arg item_99_arg[] = {
111   { XtNfromVert,  (XtArgVal) NULL },        /* must be first */
112   { "label",      (XtArgVal)" " } };
113
114
115
116 /*************************************************
117 *        Destroy the menu when popped down       *
118 *************************************************/
119
120 static void
121 popdownAction(Widget w, XtPointer client_data, XtPointer call_data)
122 {
123 if (highlighted_x >= 0)
124   XawTextSinkDisplayText(queue_text_sink,
125     highlighted_x, highlighted_y,
126     highlighted_start, highlighted_end, 0);
127 XtDestroyWidget(w);
128 menu_is_up = FALSE;
129 }
130
131
132
133 /*************************************************
134 *          Display the message log               *
135 *************************************************/
136
137 static void
138 msglogAction(Widget w, XtPointer client_data, XtPointer call_data)
139 {
140 Widget text = text_create(US client_data, text_depth);
141 uschar * fname = NULL;
142 FILE * f = NULL;
143
144 /* End up with the split version, so message looks right when non-exist */
145
146 for (int i = 0; i < (spool_is_split ? 2:1); i++)
147   {
148   message_subdir[0] = i != 0 ? (US client_data)[5] : 0;
149   fname = spool_fname(US"msglog", message_subdir, US client_data, US"");
150   if ((f = fopen(CS fname, "r")))
151     break;
152   }
153
154 if (!f)
155   text_showf(text, "%s: %s\n", fname, strerror(errno));
156 else
157   {
158   uschar buffer[256];
159   while (Ufgets(buffer, sizeof(buffer), f) != NULL) text_show(text, buffer);
160   fclose(f);
161   }
162 }
163
164
165
166 /*************************************************
167 *          Display the message body               *
168 *************************************************/
169
170 static void
171 bodyAction(Widget w, XtPointer client_data, XtPointer call_data)
172 {
173 Widget text = text_create(US client_data, text_depth);
174 FILE *f = NULL;
175
176 for (int i = 0; i < (spool_is_split? 2:1); i++)
177   {
178   uschar * fname;
179   message_subdir[0] = i != 0 ? (US client_data)[5] : 0;
180   fname = spool_fname(US"input", message_subdir, US client_data, US"-D");
181   if ((f = fopen(CS fname, "r")))
182     break;
183   }
184
185 if (!f)
186   text_showf(text, "Failed to open file: %s\n", strerror(errno));
187 else
188   {
189   uschar buffer[256];
190   int count = 0;
191
192   while (Ufgets(buffer, sizeof(buffer), f) != NULL)
193     {
194     text_show(text, buffer);
195     count += Ustrlen(buffer);
196     if (count > body_max)
197       {
198       text_show(text, US"\n*** Message length exceeds BODY_MAX ***\n");
199       break;
200       }
201     }
202   fclose(f);
203   }
204 }
205
206
207
208 /*************************************************
209 *        Do something to a message               *
210 *************************************************/
211
212 /* The output is not shown in a window for non-delivery actions that succeed,
213 unless action_output is set. We can't, however, tell until we have run
214 the command whether we want the output or not, so the pipe has to be set up in
215 all cases. */
216
217 static void
218 ActOnMessage(uschar *id, uschar *action, uschar *address_arg)
219 {
220 int pid;
221 int pipe_fd[2];
222 int delivery = Ustrcmp(action + Ustrlen(action) - 2, "-M") == 0;
223 uschar *quote = US"";
224 uschar *at = US"";
225 uschar *qualify = US"";
226 uschar buffer[256];
227 queue_item *qq;
228 Widget text = NULL;
229
230 /* If the address arg is not empty and does not contain @ and there is a
231 qualify domain, qualify it. (But don't qualify '<>'.)*/
232
233 if (address_arg[0] != 0)
234   {
235   quote = US"\'";
236   if (Ustrchr(address_arg, '@') == NULL &&
237       Ustrcmp(address_arg, "<>") != 0 &&
238       qualify_domain != NULL &&
239       qualify_domain[0] != 0)
240     {
241     at = US"@";
242     qualify = qualify_domain;
243     }
244   }
245 sprintf(CS buffer, "%s %s %s %s %s %s%s%s%s%s", exim_path,
246   (alternate_config == NULL)? US"" : US"-C",
247   (alternate_config == NULL)? US"" : alternate_config,
248   action, id, quote, address_arg, at, qualify, quote);
249
250 /* If we know we are going to need the window, create it now. */
251
252 if (action_output || delivery)
253   {
254   text = text_create(id, text_depth);
255   text_showf(text, "%s\n", buffer);
256   }
257
258 /* Create the pipe for output. Remember, on most systems pipe[0] is
259 for reading and pipe[1] is for writing! Solaris, with its two-way
260 pipes is a trap! */
261
262 if (pipe(pipe_fd) != 0)
263   {
264   if (text == NULL)
265     {
266     text = text_create(id, text_depth);
267     text_showf(text, "%s\n", buffer);
268     }
269   text_show(text, US"*** Failed to create pipe ***\n");
270   return;
271   }
272
273 if (  fcntl(pipe_fd[0], F_SETFL, O_NONBLOCK)
274    || fcntl(pipe_fd[1], F_SETFL, O_NONBLOCK))
275   {
276   perror("set nonblocking on pipe");
277   exit(1);
278   }
279
280 /* Delivering a message can take some time, and we want to show the
281 output as it goes along. This requires subprocesses and is coded below. For
282 other commands, we can assume an immediate response, and so need not waste
283 resources with subprocesses. If action_output is FALSE, don't show the
284 output at all. */
285
286 if (!delivery)
287   {
288   int count, rc;
289   int save_stdout = dup(1);
290   int save_stderr = dup(2);
291
292   close(1);
293   close(2);
294
295   dup2(pipe_fd[1], 1);
296   dup2(pipe_fd[1], 2);
297   close(pipe_fd[1]);
298
299   rc = system(CS buffer);
300
301   close(1);
302   close(2);
303
304   if (action_output || rc != 0)
305     {
306     if (text == NULL)
307       {
308       text = text_create(id, text_depth);
309       text_showf(text, "%s\n", buffer);
310       }
311     while ((count = read(pipe_fd[0], buffer, 254)) > 0)
312       {
313       buffer[count] = 0;
314       text_show(text, buffer);
315       }
316     }
317
318   close(pipe_fd[0]);
319
320   dup2(save_stdout, 1);
321   dup2(save_stderr, 2);
322   close(save_stdout);
323   close(save_stderr);
324
325   /* If action was to change the sender, and it succeeded, we have to
326   update the in-store data. */
327
328   if (rc == 0 && Ustrcmp(action + Ustrlen(action) - 4, "-Mes") == 0)
329     {
330     queue_item *q = find_queue(id, queue_noop, 0);
331     if (q)
332       {
333       if (q->sender) store_free(q->sender);
334       q->sender = store_malloc(Ustrlen(address_arg) + 1);
335       Ustrcpy(q->sender, address_arg);
336       }
337     }
338
339   /* If configured, cause a display update and return */
340
341   if (action_queue_update) tick_queue_accumulator = 999999;
342   return;
343   }
344
345 /* Message is to be delivered. Ensure that it is marked unfrozen,
346 because nothing will get written to the log to show that this has
347 happened. (Other freezing/unfreezings get logged and picked up from
348 there.) */
349
350 qq = find_queue(id, queue_noop, 0);
351 if (qq != NULL) qq->frozen = FALSE;
352
353 /* New, asynchronous code runs in a subprocess for commands that
354 will take some time. The main process does not wait. There is a
355 SIGCHLD handler in the main program that cleans up any terminating
356 sub processes. */
357
358 if ((pid = fork()) == 0)
359   {
360   close(1);
361   close(2);
362
363   dup2(pipe_fd[1], 1);
364   dup2(pipe_fd[1], 2);
365   close(pipe_fd[1]);
366
367   system(CS buffer);
368
369   close(1);
370   close(2);
371   close(pipe_fd[0]);
372   _exit(0);
373   }
374
375 /* Main process - set up an item for the main ticker to watch. */
376
377 if (pid < 0) text_showf(text, "Failed to fork: %s\n", strerror(errno)); else
378   {
379   pipe_item *p = (pipe_item *)store_malloc(sizeof(pipe_item));
380
381   if (p == NULL)
382     {
383     text_show(text, US"Run out of store\n");
384     return;
385     }
386
387   p->widget = text;
388   p->fd = pipe_fd[0];
389
390   p->next = pipe_chain;
391   pipe_chain = p;
392
393   close(pipe_fd[1]);
394   }
395 }
396
397
398
399
400 /*************************************************
401 *        Cause a message to be delivered         *
402 *************************************************/
403
404 static void
405 deliverAction(Widget w, XtPointer client_data, XtPointer call_data)
406 {
407 ActOnMessage(US client_data, US"-v -M", US"");
408 }
409
410 /*************************************************
411 *        Cause a message to be Frozen            *
412 *************************************************/
413
414 static void
415 freezeAction(Widget w, XtPointer client_data, XtPointer call_data)
416 {
417 ActOnMessage(US client_data, US"-Mf", US"");
418 }
419
420 /*************************************************
421 *        Cause a message to be thawed            *
422 *************************************************/
423
424 static void
425 thawAction(Widget w, XtPointer client_data, XtPointer call_data)
426 {
427 ActOnMessage(US client_data, US"-Mt", US"");
428 }
429
430 /*************************************************
431 *          Take action using dialog data         *
432 *************************************************/
433
434 /* This function is called after a dialog box has been filled
435 in. It is global because it is set up in the action table at
436 start-up time. If the string is empty, do nothing. */
437
438 XtActionProc
439 dialogAction(Widget w, XEvent *event, String *ss, Cardinal *c)
440 {
441 uschar *s = US XawDialogGetValueString(dialog_widget);
442
443 XtPopdown((Widget)dialog_shell);
444 XtDestroyWidget((Widget)dialog_shell);
445 while (isspace(*s)) s++;
446 if (s[0] != 0)
447   if (actioned_message[0] != 0)
448     ActOnMessage(actioned_message, action_required, s);
449   else
450     NonMessageDialogue(s);    /* When called from somewhere else */
451 return NULL;
452 }
453
454
455
456 /*************************************************
457 *              Create a dialog box               *
458 *************************************************/
459
460 /* The focus is grabbed exclusively, so nothing else can
461 be done to the application until the box is filled in. This
462 function is also used by the Hide button handler. */
463
464 void
465 create_dialog(uschar *label, uschar *value)
466 {
467 Arg warg[4];
468 Dimension x, y, xx, yy;
469 XtTranslations pop_trans;
470 Widget text;
471
472 /* Get the position of a reference widget so the dialog box can be put
473 near to it. */
474
475 get_pos_args[0].value = (XtArgVal)(&x);
476 get_pos_args[1].value = (XtArgVal)(&y);
477 XtGetValues(dialog_ref_widget, get_pos_args, 2);
478
479 /* When this is not a message_specific thing, the position of the reference
480 widget is relative to the window. Get the position of the top level widget and
481 add to the position. */
482
483 if (dialog_ref_widget != menushell)
484   {
485   get_pos_args[0].value = (XtArgVal)(&xx);
486   get_pos_args[1].value = (XtArgVal)(&yy);
487   XtGetValues(toplevel_widget, get_pos_args, 2);
488   x += xx;
489   y += yy;
490   }
491
492 /* Create a transient shell for the dialog box. */
493
494 XtSetArg(warg[0], XtNtransientFor, queue_widget);
495 XtSetArg(warg[1], XtNx, x + 50);
496 XtSetArg(warg[2], XtNy, y + 50);
497 XtSetArg(warg[3], XtNallowShellResize, True);
498 dialog_shell = XtCreatePopupShell("forDialog", transientShellWidgetClass,
499    toplevel_widget, warg, 4);
500
501 /* Create the dialog box. */
502
503 dialog_arg[0].value = (XtArgVal)label;
504 dialog_arg[1].value = (XtArgVal)value;
505 dialog_widget = XtCreateManagedWidget("dialog", dialogWidgetClass, dialog_shell,
506   dialog_arg, XtNumber(dialog_arg));
507
508 /* Get the text widget from within the dialog box, give it the keyboard focus,
509 make it wider than the default, and override its translations to make Return
510 call the dialog action function. */
511
512 text = XtNameToWidget(dialog_widget, "value");
513 XawTextSetInsertionPoint(text, Ustrlen(value));
514 XtSetKeyboardFocus(dialog_widget, text);
515 xs_SetValues(text, 1, "width", 200);
516 pop_trans = XtParseTranslationTable(
517   "<Key>Return:         dialogAction()\n");
518 XtOverrideTranslations(text, pop_trans);
519
520 /* Pop the thing up. */
521
522 XtPopup(dialog_shell, XtGrabExclusive);
523 XFlush(X_display);
524 }
525
526
527 /*************************************************
528 *        Cause a recipient to be added           *
529 *************************************************/
530
531 /* This just sets up the dialog box; the action happens when it has been filled
532 in. */
533
534 static void
535 addrecipAction(Widget w, XtPointer client_data, XtPointer call_data)
536 {
537 Ustrncpy(actioned_message, client_data, 24);
538 actioned_message[23] = '\0';
539 action_required = US"-Mar";
540 dialog_ref_widget = menushell;
541 create_dialog(US"Recipient address to add?", US"");
542 }
543
544 /*************************************************
545 *    Cause an address to be marked delivered     *
546 *************************************************/
547
548 static void
549 markdelAction(Widget w, XtPointer client_data, XtPointer call_data)
550 {
551 Ustrncpy(actioned_message, client_data, 24);
552 actioned_message[23] = '\0';
553 action_required = US"-Mmd";
554 dialog_ref_widget = menushell;
555 create_dialog(US"Recipient address to mark delivered?", US"");
556 }
557
558 /*************************************************
559 *   Cause all addresses to be marked delivered   *
560 *************************************************/
561
562 static void
563 markalldelAction(Widget w, XtPointer client_data, XtPointer call_data)
564 {
565 ActOnMessage(US client_data, US"-Mmad", US"");
566 }
567
568 /*************************************************
569 *        Edit the message's sender               *
570 *************************************************/
571
572 static void
573 editsenderAction(Widget w, XtPointer client_data, XtPointer call_data)
574 {
575 queue_item *q;
576 uschar *sender;
577
578 Ustrncpy(actioned_message, client_data, 24);
579 actioned_message[23] = '\0';
580 q = find_queue(actioned_message, queue_noop, 0);
581 sender = !q ? US"" : q->sender[0] == 0 ? US"<>" : q->sender;
582 action_required = US"-Mes";
583 dialog_ref_widget = menushell;
584 create_dialog(US"New sender address?", sender);
585 }
586
587 /*************************************************
588 *    Cause a message to be returned to sender    *
589 *************************************************/
590
591 static void
592 giveupAction(Widget w, XtPointer client_data, XtPointer call_data)
593 {
594 ActOnMessage(US client_data, US"-v -Mg", US"");
595 }
596
597 /*************************************************
598 *      Cause a message to be cancelled           *
599 *************************************************/
600
601 static void
602 removeAction(Widget w, XtPointer client_data, XtPointer call_data)
603 {
604 ActOnMessage(US client_data, US"-Mrm", US"");
605 }
606
607 /*************************************************
608 *             Display a message's headers        *
609 *************************************************/
610
611 static void
612 headersAction(Widget w, XtPointer client_data, XtPointer call_data)
613 {
614 uschar buffer[256];
615 Widget text = text_create(US client_data, text_depth);
616 rmark reset_point;
617
618 /* Remember the point in the dynamic store so we can recover to it afterwards.
619 Then use Exim's function to read the header. */
620
621 reset_point = store_mark();
622
623 sprintf(CS buffer, "%s-H", US client_data);
624 if (spool_read_header(buffer, TRUE, FALSE) != spool_read_OK)
625   {
626   if (errno == ERRNO_SPOOLFORMAT)
627     {
628     struct stat statbuf;
629     sprintf(CS big_buffer, "%s/input/%s", spool_directory, buffer);
630     if (Ustat(big_buffer, &statbuf) == 0)
631       text_showf(text, "Format error in spool file %s: size=%lu\n", buffer,
632         (unsigned long)statbuf.st_size);
633     else text_showf(text, "Format error in spool file %s\n", buffer);
634     }
635   else text_showf(text, "Read error for spool file %s\n", buffer);
636   store_reset(reset_point);
637   return;
638   }
639
640 if (sender_address)
641   text_showf(text, "%s sender: <%s>\n", f.sender_local ? "Local" : "Remote",
642     sender_address);
643
644 if (recipients_list)
645   {
646   text_show(text, US"Recipients:\n");
647   for (int i = 0; i < recipients_count; i++)
648     text_showf(text, "  %s %s\n",
649       tree_search(tree_nonrecipients, recipients_list[i].address)
650         ? "*" : " ",
651       recipients_list[i].address);
652   text_show(text, US"\n");
653   }
654
655 for (header_line * next, * h = header_list; h; h = next)
656   {
657   next = h->next;
658   text_showf(text, "%c ", h->type);   /* Don't push h->text through a %s */
659   text_show(text, h->text);           /* expansion as it may be v large */
660   }
661
662 store_reset(reset_point);
663 }
664
665 /*************************************************
666 *              Dismiss a text window             *
667 *************************************************/
668
669 static void
670 dismissAction(Widget w, XtPointer client_data, XtPointer call_data)
671 {
672 XtPopdown((Widget)client_data);
673 XtDestroyWidget((Widget)client_data);
674
675 /* If this is a text widget for a sub-process, clear it out of
676 the chain so that subsequent data doesn't try to use it. We have
677 to search the parents of the saved widget to see if one of them
678 is what we have just destroyed. */
679
680 for (pipe_item * p = pipe_chain; p; p = p->next)
681   for (Widget pp = p->widget; pp; pp = XtParent(pp))
682     if (pp == (Widget)client_data) { p->widget = NULL; return; }
683 }
684
685
686
687 /*************************************************
688 *             Set up popup text window           *
689 *************************************************/
690
691 static Widget
692 text_create(uschar *name, int height)
693 {
694 Widget textshell, form, text, button;
695
696 /* Create a popup shell widget to display as an additional
697 toplevel window. */
698
699 textshell = XtCreatePopupShell("textshell", topLevelShellWidgetClass,
700   toplevel_widget, NULL, 0);
701 xs_SetValues(textshell, 4,
702   "title",     name,
703   "iconName",  name,
704   "minWidth",  100,
705   "minHeight", 100);
706
707 /* Create a form widget, containing the text widget and the
708 dismiss button widget. */
709
710 form = XtCreateManagedWidget("textform", formWidgetClass,
711   textshell, NULL, 0);
712 xs_SetValues(form, 1, "defaultDistance", 8);
713
714 text = XtCreateManagedWidget("texttext", asciiTextWidgetClass,
715   form, text_arg, XtNumber(text_arg));
716 xs_SetValues(text, 4,
717   "editType",        XawtextAppend,
718   "width",           700,
719   "height",          height,
720   "translations",    text_trans);
721 XawTextDisplayCaret(text, TRUE);
722
723 /* Use the same font as for the queue display */
724
725 if (queue_font != NULL)
726   {
727   XFontStruct *f = XLoadQueryFont(X_display, CS queue_font);
728   if (f != NULL) xs_SetValues(text, 1, "font", f);
729   }
730
731 button_arg[0].value = (XtArgVal)text;
732 button = XtCreateManagedWidget("dismiss", commandWidgetClass,
733   form, button_arg, XtNumber(button_arg));
734 XtAddCallback(button, "callback",  dismissAction, (XtPointer)textshell);
735
736 /* Get the toplevel popup displayed, and yield the text widget so
737 that text can be put into it. */
738
739 XtPopup(textshell, XtGrabNone);
740 return text;
741 }
742
743 /*************************************************
744 *            Set up menu in queue window         *
745 *************************************************/
746
747 /* We have added an action table that causes this function to
748 be called, and set up button 2 in the text widgets to call it. */
749
750 void
751 menu_create(Widget w, XEvent *event, String *actargs, Cardinal *count)
752 {
753 int line;
754 int i;
755 uschar *s;
756 XawTextPosition p;
757 Widget src, menu_line, item_1, item_2, item_3, item_4,
758   item_5, item_6, item_7, item_8, item_9, item_10, item_11,
759   item_12, item_13;
760 XtTranslations menu_trans = XtParseTranslationTable(
761   "<EnterWindow>:   highlight()\n\
762    <LeaveWindow>:   unhighlight()\n\
763    <BtnMotion>:     highlight()\n\
764    <BtnUp>:         MenuPopdown()notify()unhighlight()\n\
765   ");
766
767 /* Get the sink and source and the current text pointer */
768
769 queue_get_arg[0].value = (XtArgVal)(&queue_text_sink);
770 queue_get_arg[1].value = (XtArgVal)(&src);
771 queue_get_arg[2].value = (XtArgVal)(&s);
772 XtGetValues(w, queue_get_arg, 3);
773
774 /* Find the line number of the pointer in the window, and the
775 character offset of the top lefthand of the window. */
776
777 line = (event->xbutton).y / XawTextSinkMaxHeight(queue_text_sink, 1);
778 p = XawTextTopPosition(w);
779
780 /* Find the start of the line on which the button was clicked. */
781
782 i = line;
783 while (i-- > 0)
784   {
785   while (s[p] != 0 && s[p++] != '\n');
786   }
787
788 /* Now pointing either at 0 or 1st uschar after \n, or very 1st uschar.
789 If 0, the click was beyond the end of the data; just set up a dummy
790 menu. (Not easy to ignore as several actions are specified for the
791 mouse click and it expects this one to set up a menu.) If on a
792 continuation line, move back to the main line. */
793
794 if (s[p] == 0)
795   {
796   menushell_arg[0].value = (XtArgVal)"No message selected";
797   menushell = XtCreatePopupShell("menu", simpleMenuWidgetClass,
798     queue_widget, menushell_arg, XtNumber(menushell_arg));
799   XtAddCallback(menushell, "popdownCallback", popdownAction, NULL);
800   xs_SetValues(menushell, 2,
801     "cursor",       XCreateFontCursor(X_display, XC_arrow),
802     "translations", menu_trans);
803
804   /* To keep the widgets in XFree86 happy, we have to create at least one menu
805   item, it seems. (Openwindows doesn't mind a menu with no items.) Otherwise
806   there's a complaint about a zero width menu, and a crash. */
807
808   menu_line = XtCreateManagedWidget("line", smeLineObjectClass, menushell,
809     NULL, 0);
810
811   item_99_arg[0].value = (XtArgVal)menu_line;
812   (void)XtCreateManagedWidget("item99", smeBSBObjectClass, menushell,
813     item_99_arg, XtNumber(item_99_arg));
814
815   highlighted_x = -1;
816   return;
817   }
818
819 while (p > 0 && s[p+11] == ' ')
820   {
821   line--;
822   p--;
823   while (p > 0 && s[p-1] != '\n') p--;
824   }
825
826 /* Now pointing at first character of a main line. */
827
828 Ustrncpy(message_id, s+p+11, MESSAGE_ID_LENGTH);        /*III*/
829 message_id[MESSAGE_ID_LENGTH] = 0;
830
831 /* Highlight the line being menued, and save its parameters so that it
832 can be de-highlighted at popdown. */
833
834 highlighted_start = highlighted_end = p;
835 while (s[highlighted_end] != '\n') highlighted_end++;
836 highlighted_x = 17;
837 highlighted_y = line * XawTextSinkMaxHeight(queue_text_sink, 1) + 2;
838
839 XawTextSinkDisplayText(queue_text_sink,
840   highlighted_x, highlighted_y,
841   highlighted_start, highlighted_end, 1);
842
843 /* Create the popup shell and the other widgets that comprise the menu.
844 Set the translations and pointer shape, and add the callback pointers. */
845
846 menushell_arg[0].value = (XtArgVal)message_id;
847 menushell = XtCreatePopupShell("menu", simpleMenuWidgetClass,
848   queue_widget, menushell_arg, XtNumber(menushell_arg));
849 XtAddCallback(menushell, "popdownCallback", popdownAction, NULL);
850
851 xs_SetValues(menushell, 2,
852   "cursor",       XCreateFontCursor(X_display, XC_arrow),
853   "translations", menu_trans);
854
855 menu_line = XtCreateManagedWidget("line", smeLineObjectClass, menushell,
856   NULL, 0);
857
858 item_1_arg[0].value = (XtArgVal)menu_line;
859 item_1 = XtCreateManagedWidget("item1", smeBSBObjectClass, menushell,
860   item_1_arg, XtNumber(item_1_arg));
861 XtAddCallback(item_1, "callback",  msglogAction, (XtPointer)message_id);
862
863 item_2_arg[0].value = (XtArgVal)item_1;
864 item_2 = XtCreateManagedWidget("item2", smeBSBObjectClass, menushell,
865   item_2_arg, XtNumber(item_2_arg));
866 XtAddCallback(item_2, "callback",  headersAction, (XtPointer)message_id);
867
868 item_3_arg[0].value = (XtArgVal)item_2;
869 item_3 = XtCreateManagedWidget("item3", smeBSBObjectClass, menushell,
870   item_3_arg, XtNumber(item_3_arg));
871 XtAddCallback(item_3, "callback",  bodyAction, (XtPointer)message_id);
872
873 item_4_arg[0].value = (XtArgVal)item_3;
874 item_4 = XtCreateManagedWidget("item4", smeBSBObjectClass, menushell,
875   item_4_arg, XtNumber(item_4_arg));
876 XtAddCallback(item_4, "callback",  deliverAction, (XtPointer)message_id);
877
878 item_5_arg[0].value = (XtArgVal)item_4;
879 item_5 = XtCreateManagedWidget("item5", smeBSBObjectClass, menushell,
880   item_5_arg, XtNumber(item_5_arg));
881 XtAddCallback(item_5, "callback",  freezeAction, (XtPointer)message_id);
882
883 item_6_arg[0].value = (XtArgVal)item_5;
884 item_6 = XtCreateManagedWidget("item6", smeBSBObjectClass, menushell,
885   item_6_arg, XtNumber(item_6_arg));
886 XtAddCallback(item_6, "callback",  thawAction, (XtPointer)message_id);
887
888 item_7_arg[0].value = (XtArgVal)item_6;
889 item_7 = XtCreateManagedWidget("item7", smeBSBObjectClass, menushell,
890   item_7_arg, XtNumber(item_7_arg));
891 XtAddCallback(item_7, "callback",  giveupAction, (XtPointer)message_id);
892
893 item_8_arg[0].value = (XtArgVal)item_7;
894 item_8 = XtCreateManagedWidget("item8", smeBSBObjectClass, menushell,
895   item_8_arg, XtNumber(item_8_arg));
896 XtAddCallback(item_8, "callback",  removeAction, (XtPointer)message_id);
897
898 item_9_arg[0].value = (XtArgVal)item_8;
899 item_9 = XtCreateManagedWidget("item9", smeBSBObjectClass, menushell,
900   item_9_arg, XtNumber(item_9_arg));
901
902 item_10_arg[0].value = (XtArgVal)item_9;
903 item_10 = XtCreateManagedWidget("item10", smeBSBObjectClass, menushell,
904   item_10_arg, XtNumber(item_10_arg));
905 XtAddCallback(item_10, "callback",  addrecipAction, (XtPointer)message_id);
906
907 item_11_arg[0].value = (XtArgVal)item_10;
908 item_11 = XtCreateManagedWidget("item11", smeBSBObjectClass, menushell,
909   item_11_arg, XtNumber(item_11_arg));
910 XtAddCallback(item_11, "callback",  markdelAction, (XtPointer)message_id);
911
912 item_12_arg[0].value = (XtArgVal)item_11;
913 item_12 = XtCreateManagedWidget("item12", smeBSBObjectClass, menushell,
914   item_12_arg, XtNumber(item_12_arg));
915 XtAddCallback(item_12, "callback",  markalldelAction, (XtPointer)message_id);
916
917 item_13_arg[0].value = (XtArgVal)item_12;
918 item_13 = XtCreateManagedWidget("item13", smeBSBObjectClass, menushell,
919   item_13_arg, XtNumber(item_13_arg));
920 XtAddCallback(item_13, "callback",  editsenderAction, (XtPointer)message_id);
921
922 /* Arrange that the menu pops up with the first item selected. */
923
924 xs_SetValues(menushell, 1, "popupOnEntry", item_1);
925
926 /* Flag that the menu is up to suppress queue updates. */
927
928 menu_is_up = TRUE;
929 }
930
931 /* End of em_menu.c */