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