* src/editfns.c (Fmessage): Mention message-log-max. (Bug#12849)
[emacs.git] / oldXMenu / Activate.c
blobd4683da87f2211e1c183a57a576f9f77d4c9fcfc
1 /* Copyright Massachusetts Institute of Technology 1985 */
3 #include "copyright.h"
5 /*
6 Copyright (C) 2001-2012 Free Software Foundation, Inc.
8 This program is free software: you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation, either version 3 of the License, or
11 (at your option) any later version.
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
18 You should have received a copy of the GNU General Public License
19 along with this program. If not, see <http://www.gnu.org/licenses/>. */
22 * XMenu: MIT Project Athena, X Window system menu package
24 * XMenuActivate - Maps a given menu to the display and activates
25 * the menu for user selection. The user is allowed to
26 * specify which pane and selection will be current,
27 * the X and Y location of the menu (relative to the
28 * parent window) and the mouse button event mask that
29 * will be used to identify a selection request.
31 * A menu selection is shown to be current by placing
32 * a highlight box around the selection as the mouse
33 * cursor enters its active region. Inactive selections
34 * will not be highlighted. As the mouse cursor moved
35 * from one menu pane to another menu pane the pane being
36 * entered is raised and made current and the pane being
37 * left is lowered.
39 * Anytime XMenuActivate returns, the p_num and
40 * s_num are left at their last known values (i.e.,
41 * the last known current pane and selection indices).
42 * The following are the defined return states:
44 * 1) If at any time an error occurs the data
45 * pointer is left untouched and XM_FAILURE
46 * is returned.
48 * 2) When a selection request is received (i.e.,
49 * when the specified mouse event occurs) the
50 * data pointer will be set to the data
51 * associated with the particular selection
52 * current at the time of the selection request
53 * and XM_SUCCESS is returned.
55 * 3) If no selection was current at the time a
56 * selection request is made the data pointer
57 * will be left untouched and XM_NO_SELECT will
58 * be returned.
60 * 4) If the selection that was current at the time
61 * a selection request is made is not an active
62 * selection the data pointer will be left
63 * untouched and XM_IA_SELECT will be returned.
65 * Since X processes events in an asynchronous manner
66 * it is likely that XMenuActivate will encounter
67 * a "foreign event" while it is executing. Foreign
68 * events are handled in one of three ways:
70 * 1) The event is discarded. This is the default
71 * mode and requires no action on the part of the
72 * application.
74 * 2) The application has identified an asynchronous
75 * event handler that will be called and the
76 * foreign event handed off to it. Note:
77 * AEQ mode disables this mode temporarily.
79 * 3) The application has enabled asynchronous event
80 * queuing mode. In this mode all foreign events
81 * will be queued up until XMenuActivate
82 * terminates; at which time they will be
83 * returned to the X event queue. As long as
84 * AEQ mode is enabled any asynchronous event
85 * handler as temporarily disabled.
87 * Any events encountered while taking down the menu
88 * (i.e., exposure events from occluded windows) will
89 * automatically be returned to the X event queue after
90 * XMenuActivate has cleaned the queue of any of its own
91 * events that are no longer needed.
93 * Author: Tony Della Fera, DEC
94 * March 12, 1986
98 #include <config.h>
99 #include "XMenuInt.h"
100 #include <X11/keysym.h>
102 /* For debug, set this to 0 to not grab the keyboard on menu popup */
103 int x_menu_grab_keyboard = 1;
105 static Wait_func wait_func;
106 static void* wait_data;
108 void
109 XMenuActivateSetWaitFunction (Wait_func func, void *data)
111 wait_func = func;
112 wait_data = data;
116 XMenuActivate(
117 register Display *display, /* Display to put menu on. */
118 register XMenu *menu, /* Menu to activate. */
119 int *p_num, /* Pane number selected. */
120 int *s_num, /* Selection number selected. */
121 int x_pos, /* X coordinate of menu position. */
122 int y_pos, /* Y coordinate of menu position. */
123 unsigned int event_mask, /* Mouse button event mask. */
124 char **data, /* Pointer to return data value. */
125 void (*help_callback) (char const *, int, int)) /* Help callback. */
127 int status; /* X routine call status. */
128 int orig_x; /* Upper left menu origin X coord. */
129 int orig_y; /* Upper left menu origin Y coord. */
130 int ret_val; /* Return value. */
132 register XMPane *p_ptr; /* Current XMPane. */
133 register XMPane *event_xmp; /* Event XMPane pointer. */
134 register XMPane *cur_p; /* Current pane. */
135 register XMSelect *cur_s; /* Current selection. */
136 XMWindow *event_xmw; /* Event XMWindow pointer. */
137 XEvent event; /* X input event. */
138 XEvent peek_event; /* X input peek ahead event. */
140 Bool selection = False; /* Selection has been made. */
141 Bool forward = True; /* Moving forward in the pane list. */
143 Window root, child;
144 int root_x, root_y, win_x, win_y;
145 unsigned int mask;
146 KeySym keysym;
149 * Define and allocate a foreign event queue to hold events
150 * that don't belong to XMenu. These events are later restored
151 * to the X event queue.
153 typedef struct _xmeventque {
154 XEvent event;
155 struct _xmeventque *next;
156 } XMEventQue;
158 XMEventQue *feq = NULL; /* Foreign event queue. */
159 XMEventQue *feq_tmp; /* Foreign event queue temporary. */
162 * If there are no panes in the menu then return failure
163 * because the menu is not initialized.
165 if (menu->p_count == 0) {
166 _XMErrorCode = XME_NOT_INIT;
167 return(XM_FAILURE);
171 * Find the desired current pane.
173 cur_p = _XMGetPanePtr(menu, *p_num);
174 if (cur_p == NULL) {
175 return(XM_FAILURE);
177 cur_p->activated = cur_p->active;
180 * Find the desired current selection.
181 * If the current selection index is out of range a null current selection
182 * will be assumed and the cursor will be placed in the current pane
183 * header.
185 cur_s = _XMGetSelectionPtr(cur_p, *s_num);
188 * Compute origin of menu so that cursor is in
189 * Correct pane and selection.
191 _XMTransToOrigin(display,
192 menu,
193 cur_p, cur_s,
194 x_pos, y_pos,
195 &orig_x, &orig_y);
196 menu->x_pos = orig_x; /* Store X and Y coords of menu. */
197 menu->y_pos = orig_y;
199 if (XMenuRecompute(display, menu) == XM_FAILURE) {
200 return(XM_FAILURE);
204 * Flush the window creation queue.
205 * This batches all window creates since lazy evaluation
206 * is more efficient than individual evaluation.
207 * This routine also does an XFlush().
209 if (_XMWinQueFlush(display, menu, cur_p, cur_s) == _FAILURE) {
210 return(XM_FAILURE);
214 * Make sure windows are in correct order (in case we were passed
215 * an already created menu in incorrect order.)
217 for(p_ptr = menu->p_list->next; p_ptr != cur_p; p_ptr = p_ptr->next)
218 XRaiseWindow(display, p_ptr->window);
219 for(p_ptr = menu->p_list->prev; p_ptr != cur_p->prev; p_ptr = p_ptr->prev)
220 XRaiseWindow(display, p_ptr->window);
223 * Make sure all selection windows are mapped.
225 for (
226 p_ptr = menu->p_list->next;
227 p_ptr != menu->p_list;
228 p_ptr = p_ptr->next
230 XMapSubwindows(display, p_ptr->window);
234 * Synchronize the X buffers and the event queue.
235 * From here on, all events in the queue that don't belong to
236 * XMenu are sent back to the application via an application
237 * provided event handler or discarded if the application has
238 * not provided an event handler.
240 XSync(display, 0);
243 * Grab the mouse for menu input.
246 status = XGrabPointer(
247 display,
248 menu->parent,
249 True,
250 event_mask,
251 GrabModeAsync,
252 GrabModeAsync,
253 None,
254 menu->mouse_cursor,
255 CurrentTime
257 if (status == Success && x_menu_grab_keyboard)
259 status = XGrabKeyboard (display,
260 menu->parent,
261 False,
262 GrabModeAsync,
263 GrabModeAsync,
264 CurrentTime);
265 if (status != Success)
266 XUngrabPointer(display, CurrentTime);
269 if (status == _X_FAILURE) {
270 _XMErrorCode = XME_GRAB_MOUSE;
271 return(XM_FAILURE);
275 * Map the menu panes.
277 XMapWindow(display, cur_p->window);
278 for (p_ptr = menu->p_list->next;
279 p_ptr != cur_p;
280 p_ptr = p_ptr->next)
281 XMapWindow(display, p_ptr->window);
282 for (p_ptr = cur_p->next;
283 p_ptr != menu->p_list;
284 p_ptr = p_ptr->next)
285 XMapWindow(display, p_ptr->window);
287 XRaiseWindow(display, cur_p->window); /* Make sure current */
288 /* pane is on top. */
290 cur_s = NULL; /* Clear current selection. */
293 * Begin event processing loop.
295 while (1) {
296 if (wait_func) (*wait_func) (wait_data);
297 XNextEvent(display, &event); /* Get next event. */
298 switch (event.type) { /* Dispatch on the event type. */
299 case Expose:
300 event_xmp = (XMPane *)XLookUpAssoc(display,
301 menu->assoc_tab,
302 event.xexpose.window);
303 if (event_xmp == NULL) {
305 * If AEQ mode is enabled then queue the event.
307 if (menu->aeq) {
308 feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
309 if (feq_tmp == NULL) {
310 _XMErrorCode = XME_CALLOC;
311 return(XM_FAILURE);
313 feq_tmp->event = event;
314 feq_tmp->next = feq;
315 feq = feq_tmp;
317 else if (_XMEventHandler) (*_XMEventHandler)(&event);
318 break;
320 if (event_xmp->activated) {
321 XSetWindowBackground(display,
322 event_xmp->window,
323 menu->bkgnd_color);
325 else {
326 XSetWindowBackgroundPixmap(display,
327 event_xmp->window,
328 menu->inact_pixmap);
330 _XMRefreshPane(display, menu, event_xmp);
331 break;
332 case EnterNotify:
334 * First wait a small period of time, and see
335 * if another EnterNotify event follows hard on the
336 * heels of this one. i.e., the user is simply
337 * "passing through". If so, ignore this one.
340 event_xmw = (XMWindow *)XLookUpAssoc(display,
341 menu->assoc_tab,
342 event.xcrossing.window);
343 if (event_xmw == NULL) break;
344 if (event_xmw->type == SELECTION) {
346 * We have entered a selection.
348 /* if (XPending(display) == 0) usleep(150000); */
349 if (XPending(display) != 0) {
350 XPeekEvent(display, &peek_event);
351 if(peek_event.type == LeaveNotify) {
352 break;
355 cur_s = (XMSelect *)event_xmw;
356 help_callback (cur_s->help_string,
357 cur_p->serial, cur_s->serial);
360 * If the pane we are in is active and the
361 * selection entered is active then activate
362 * the selection.
364 if (cur_p->active && cur_s->active > 0) {
365 cur_s->activated = 1;
366 _XMRefreshSelection(display, menu, cur_s);
369 else {
371 * We have entered a pane.
373 /* if (XPending(display) == 0) usleep(150000); */
374 if (XPending(display) != 0) {
375 XPeekEvent(display, &peek_event);
376 if (peek_event.type == EnterNotify) break;
378 XQueryPointer(display,
379 menu->parent,
380 &root, &child,
381 &root_x, &root_y,
382 &win_x, &win_y,
383 &mask);
384 event_xmp = (XMPane *)XLookUpAssoc(display,
385 menu->assoc_tab,
386 child);
387 if (event_xmp == NULL) break;
388 if (event_xmp == cur_p) break;
389 if (event_xmp->serial > cur_p->serial) forward = True;
390 else forward = False;
391 p_ptr = cur_p;
392 while (p_ptr != event_xmp) {
393 if (forward) p_ptr = p_ptr->next;
394 else p_ptr = p_ptr->prev;
395 XRaiseWindow(display, p_ptr->window);
397 if (cur_p->activated) {
398 cur_p->activated = False;
399 XSetWindowBackgroundPixmap(display,
400 cur_p->window,
401 menu->inact_pixmap);
402 _XMRefreshPane(display, menu, cur_p);
404 if (event_xmp->active) event_xmp->activated = True;
405 #if 1
407 * i suspect the we don't get an EXPOSE event when backing
408 * store is enabled; the menu windows content is probably
409 * not drawn in when it should be in that case.
410 * in that case, this is probably an ugly fix!
411 * i hope someone more familiar with this code would
412 * take it from here. -- caveh@eng.sun.com.
414 XSetWindowBackground(display,
415 event_xmp->window,
416 menu->bkgnd_color);
417 _XMRefreshPane(display, menu, event_xmp);
418 #endif
419 cur_p = event_xmp;
421 break;
422 case LeaveNotify:
423 event_xmw = (XMWindow *)XLookUpAssoc(
424 display,
425 menu->assoc_tab,
426 event.xcrossing.window
428 if (event_xmw == NULL) break;
429 if(cur_s == NULL) break;
432 * If the current selection was activated then
433 * deactivate it.
435 if (cur_s->activated) {
436 cur_s->activated = False;
437 _XMRefreshSelection(display, menu, cur_s);
439 cur_s = NULL;
440 break;
442 case ButtonPress:
443 case ButtonRelease:
444 *p_num = cur_p->serial;
446 * Check to see if there is a current selection.
448 if (cur_s != NULL) {
450 * Set the selection number to the current selection.
452 *s_num = cur_s->serial;
454 * If the current selection was activated then
455 * we have a valid selection otherwise we have
456 * an inactive selection.
458 if (cur_s->activated) {
459 *data = cur_s->data;
460 ret_val = XM_SUCCESS;
462 else {
463 ret_val = XM_IA_SELECT;
466 else {
468 * No selection was current.
470 ret_val = XM_NO_SELECT;
472 selection = True;
473 break;
474 case KeyPress:
475 case KeyRelease:
476 keysym = XLookupKeysym (&event.xkey, 0);
478 /* Pop down on C-g and Escape. */
479 if ((keysym == XK_g && (event.xkey.state & ControlMask) != 0)
480 || keysym == XK_Escape) /* Any escape, ignore modifiers. */
482 ret_val = XM_NO_SELECT;
483 selection = True;
485 break;
486 default:
488 * If AEQ mode is enabled then queue the event.
490 if (menu->aeq) {
491 feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
492 if (feq_tmp == NULL) {
493 _XMErrorCode = XME_CALLOC;
494 return(XM_FAILURE);
496 feq_tmp->event = event;
497 feq_tmp->next = feq;
498 feq = feq_tmp;
500 else if (_XMEventHandler) (*_XMEventHandler)(&event);
503 * If a selection has been made, break out of the event loop.
505 if (selection == True) break;
509 * Unmap the menu.
511 for ( p_ptr = menu->p_list->next;
512 p_ptr != menu->p_list;
513 p_ptr = p_ptr->next)
515 XUnmapWindow(display, p_ptr->window);
519 * Ungrab the mouse.
521 XUngrabPointer(display, CurrentTime);
522 XUngrabKeyboard(display, CurrentTime);
525 * Restore bits under where the menu was if we managed
526 * to save them and free the pixmap.
530 * If there is a current selection deactivate it.
532 if (cur_s != NULL) cur_s->activated = 0;
535 * Deactivate the current pane.
537 cur_p->activated = 0;
538 XSetWindowBackgroundPixmap(display, cur_p->window, menu->inact_pixmap);
541 * Synchronize the X buffers and the X event queue.
543 XSync(display, 0);
546 * Dispatch any events remaining on the queue.
548 while (QLength(display)) {
550 * Fetch the next event.
552 XNextEvent(display, &event);
555 * Discard any events left on the queue that belong to XMenu.
556 * All others are held and then returned to the event queue.
558 switch (event.type) {
559 case Expose:
560 case EnterNotify:
561 case LeaveNotify:
562 case ButtonPress:
563 case ButtonRelease:
565 * Does this event belong to one of XMenu's windows?
566 * If so, discard it and process the next event.
567 * If not fall through and treat it as a foreign event.
569 event_xmp = (XMPane *)XLookUpAssoc(
570 display,
571 menu->assoc_tab,
572 event.xbutton.window
574 if (event_xmp != NULL) continue;
575 default:
577 * This is a foreign event.
578 * Queue it for later return to the X event queue.
580 feq_tmp = (XMEventQue *)malloc(sizeof(XMEventQue));
581 if (feq_tmp == NULL) {
582 _XMErrorCode = XME_CALLOC;
583 return(XM_FAILURE);
585 feq_tmp->event = event;
586 feq_tmp->next = feq;
587 feq = feq_tmp;
591 * Return any foreign events that were queued to the X event queue.
593 while (feq != NULL) {
594 feq_tmp = feq;
595 XPutBackEvent(display, &feq_tmp->event);
596 feq = feq_tmp->next;
597 free((char *)feq_tmp);
600 wait_func = 0;
603 * Return successfully.
605 _XMErrorCode = XME_NO_ERROR;
606 return(ret_val);