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