![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XMenuActivate.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / contrib / X / XMenu|
Return to XMenuActivate.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / XMenu |
1.1 root 1: /* $Header: XMenuActivate.c,v 10.16 86/02/01 16:14:11 tony Rel $ */
2: /* Copyright Massachusetts Institute of Technology 1985 */
3:
4: /*
5: * XMenu: MIT Project Athena, X Window system menu package
6: *
7: * XMenuActivate - Maps a given menu to the display and activates
8: * the menu for user selection. The user is allowed to
9: * specify which pane and selection will be current,
10: * the X and Y location of the menu (relative to the
11: * parent window) and the mouse button event mask that
12: * will be used to identify a selection request.
13: *
14: * A menu selection is shown to be current by placing
15: * a highlight box around the selection as the mouse
16: * cursor enters its active region. Inactive selections
17: * will not be highlited. As the mouse cursor moved
18: * from one menu pane to another menu pane the pane being
19: * entered is raised and made current and the pane being
20: * left is lowered.
21: *
22: * Anytime XMenuActivate returns, the p_num and
23: * s_num are left at their last known values (i.e.,
24: * the last known current pane and selection indices).
25: * The following are the defined return states:
26: *
27: * 1) If at any time an error occurs the data
28: * pointer is left untouched and XM_FAILURE
29: * is returned.
30: *
31: * 2) When a selection request is recieved (i.e.,
32: * when the specified mouse event occurs) the
33: * data pointer will be set to the data
34: * associated with the particular selection
35: * current at the time of the selection request
36: * and XM_SUCCESS is returned.
37: *
38: * 3) If no selection was current at the time a
39: * selection request is made the data pointer
40: * will be left untouched and XM_NO_SELECT will
41: * be returned.
42: *
43: * 4) If the selection that was current at the time
44: * a selection request is made is not an active
45: * selection the data pointer will be left
46: * untouched and XM_IA_SELECT will be returned.
47: *
48: * Author: Tony Della Fera, DEC
49: * January 13, 1986
50: *
51: */
52:
53: #include "XMenuInternal.h"
54:
55: int
56: XMenuActivate(menu, p_num, s_num, x_pos, y_pos, event_mask, data)
57: register XMenu *menu; /* Menu to activate. */
58: int *p_num; /* Pane number selected. */
59: int *s_num; /* Selection number selected. */
60: int x_pos; /* X coordinate of menu position. */
61: int y_pos; /* Y coordinate of menu position. */
62: int event_mask; /* Mouse button event mask. */
63: char **data; /* Pointer to return data value. */
64: {
65: register int i; /* Loop counter. */
66: int status; /* X routine call status. */
67: int orig_x; /* Upper left menu origin X coord. */
68: int orig_y; /* Upper left menu origin Y coord. */
69: int save_x; /* Upper left X of save region. */
70: int save_y; /* Upper left Y of save region. */
71: int save_w; /* Width of pixmap save region. */
72: int save_h; /* Height of pixmap save region. */
73: int save_w_offscr; /* Pixmap save width off screen. */
74: int save_h_offscr; /* Pixmap save height off screen. */
75: int x, y; /* Dummy X and Y arguments. */
76: int ret_val; /* Return value. */
77:
78: register XMPane *p_ptr; /* Current XMPane. */
79: register XMPane *event_xmp; /* Event XMPane pointer. */
80: register XMPane *cur_p; /* Current pane. */
81: register XMSelect *cur_s; /* Current selection. */
82: XMWindow *event_xmw; /* Event XMWindow pointer. */
83: XEvent event; /* X input event. */
84: XCrossingEvent *xc_event; /* X window crossing event. */
85: Window xc_window; /* X window crossing event window. */
86:
87: Pixmap save_pixmap; /* Pixmap to save bits under menu. */
88:
89: Bool saved = TRUE; /* Pixmap save succeeded. */
90: Bool selection = FALSE; /* Selection has been made. */
91: Bool forward = TRUE; /* Moving forward in the pane list. */
92: Bool p_lock = TRUE; /* Pane entrance lock. */
93: Bool s_lock = TRUE; /* Selection entrance lock. */
94:
95: /*
96: * Are the position arguments are positive?
97: */
98: if ((x_pos <= 0) || (y_pos <= 0)) {
99: _XMErrorCode = XME_ARG_BOUNDS;
100: return(XM_FAILURE);
101: }
102:
103: /*
104: * If there are no panes in the menu then return failure
105: * beacuse the menu is not initialized.
106: */
107: if (menu->p_count == 0) {
108: _XMErrorCode = XME_NOT_INIT;
109: return(XM_FAILURE);
110: }
111:
112: /*
113: * Find the desired current pane.
114: */
115: cur_p = _XMGetPanePtr(menu, *p_num);
116: if (cur_p == NULL) return(XM_FAILURE);
117:
118: /*
119: * Find the desired current selection.
120: */
121: cur_s = _XMGetSelectionPtr(cur_p, *s_num);
122: if (cur_s == NULL) return(XM_FAILURE);
123:
124: /*
125: * Check to see that the menu's dependencies have been
126: * recomputed and are up to date. If not, do it now.
127: */
128: if (menu->recompute) XMenuRecompute(menu);
129:
130: /*
131: * If the current pane is active then activate it.
132: */
133: if (cur_p->active) {
134: cur_p->activated = 1;
135: XChangeBackground(cur_p->window, menu->bkgnd_pixmap);
136: }
137:
138: /*
139: * Compute the new menu origin such that the cursor hot point lies
140: * in the center of the desired current pane and selection.
141: */
142: _XMTransToOrigin(menu, cur_p, cur_s, x_pos, y_pos, &orig_x, &orig_y);
143:
144: /*
145: * Then move all the panes into position relative to the newly
146: * computed origin.
147: */
148: for (
149: p_ptr = menu->p_list->next;
150: p_ptr != menu->p_list;
151: p_ptr = p_ptr->next
152: ){
153: XMoveWindow(
154: p_ptr->window,
155: orig_x + p_ptr->window_x,
156: orig_y + p_ptr->window_y
157: );
158: }
159:
160: /*<
161: * If server freeze mode is selected...
162: */
163: if (menu->freeze) {
164: /*
165: * Compute pixmap save region.
166: */
167: save_x = max(orig_x, 0);
168: save_y = max(orig_y, 0);
169: save_w_offscr = (orig_x + menu->width) - DisplayWidth();
170: save_h_offscr = (orig_y + menu->height) - DisplayHeight();
171: if (save_w_offscr < 0) save_w = menu->width;
172: else save_w = menu->width - save_w_offscr;
173: if (save_h_offscr < 0) save_h = menu->height;
174: else save_h = menu->height - save_h_offscr;
175:
176: /*
177: * Grab the X server.
178: */
179: XGrabServer();
180:
181: /*
182: * Save the bits under where the menu will be.
183: */
184: save_pixmap = XPixmapSave(
185: menu->parent,
186: save_x, save_y,
187: save_w, save_h
188: );
189: if (save_pixmap == _X_FAILURE) saved = FALSE;
190: }
191: else {
192: saved = FALSE;
193: }
194:
195: /*
196: * Synchronize the X buffers and the event queue.
197: * From here on, all events in the queue that don't belong to
198: * XMenu are send back to the application via an application
199: * provided event handler or discarded if the application has
200: * not provided an event handler.
201: */
202: XSync(0);
203:
204: /*
205: * Grab the mouse for menu input.
206: */
207: status = XGrabMouse(menu->parent, menu->mouse_cursor, event_mask);
208: if (status == _X_FAILURE) {
209: _XMErrorCode = XME_GRAB_MOUSE;
210: return(XM_FAILURE);
211: }
212:
213: /*
214: * Map the menu panes.
215: */
216: for (
217: p_ptr = menu->p_list->prev;
218: p_ptr != menu->p_list;
219: p_ptr = p_ptr->prev
220: ){
221: if (p_ptr == cur_p) break;
222: XMapWindow(p_ptr->window);
223: }
224: for (
225: p_ptr = menu->p_list->next;
226: p_ptr != menu->p_list;
227: p_ptr = p_ptr->next
228: ){
229: if (p_ptr == cur_p) break;
230: XMapWindow(p_ptr->window);
231: }
232: XMapWindow(cur_p->window);
233:
234: /*
235: * Clear the current selection.
236: */
237: cur_s = NULL;
238:
239: /*
240: * Begin event processing loop.
241: */
242: while (1) {
243: /*
244: * Fetch the next event.
245: */
246: XNextEvent(&event);
247: /*
248: * Dispatch on the event type.
249: */
250: switch (event.type) {
251: case ExposeWindow:
252: event_xmp = (XMPane *)XLookUpAssoc(
253: menu->assoc_tab, event.window
254: );
255: if (event_xmp == NULL) {
256: if (_XMEventHandler) (*_XMEventHandler)(&event);
257: break;
258: }
259: if (event_xmp == cur_p) {
260: _XMRefreshPane(menu, cur_p);
261: }
262: else _XMRefreshPaneText(menu, event_xmp);
263: break;
264: case EnterWindow:
265: event_xmw = (XMWindow *)XLookUpAssoc(
266: menu->assoc_tab,
267: event.window
268: );
269: if (event_xmw == NULL) break;
270: if (event_xmw->type == SELECTION) {
271: /*
272: * We have entered a selection.
273: */
274: cur_s = (XMSelect *)event_xmw;
275: /*
276: * If the pane we are in is active and the
277: * selection entered is active then activate
278: * the selection.
279: */
280: if (cur_p->active && cur_s->active) {
281: cur_s->activated = 1;
282: _XMRefreshSelection(menu, cur_s);
283: }
284: }
285: else {
286: /*
287: * We have entered a pane.
288: */
289: xc_event = (XCrossingEvent *)&event;
290: status = XInterpretLocator(
291: menu->parent,
292: &x, &y,
293: &xc_window,
294: xc_event->location
295: );
296: if (status == _X_FAILURE) {
297: _XMErrorCode = XME_INTERP_LOC;
298: return(XM_FAILURE);
299: }
300: event_xmp = (XMPane *)XLookUpAssoc(
301: menu->assoc_tab,
302: xc_window
303: );
304: if (event_xmp->window == cur_p->window) break;
305: if (event_xmp->serial > cur_p->serial) forward = TRUE;
306: else forward = FALSE;
307: p_ptr = cur_p;
308: while(1) {
309: if (forward) p_ptr = p_ptr->next;
310: else p_ptr = p_ptr->prev;
311: /*
312: * If the new pane is an active pane then
313: * activate it.
314: */
315: if (p_ptr->active) {
316: p_ptr->activated = 1;
317: XChangeBackground(
318: p_ptr->window,
319: menu->bkgnd_pixmap
320: );
321: XClear(p_ptr->window);
322: }
323: /*
324: * Raise the new pane.
325: */
326: XRaiseWindow(p_ptr->window);
327: /*
328: * If the previous current pane was activated
329: * deactivate it.
330: */
331: if (cur_p->activated) {
332: cur_p->activated = 0;
333: XChangeBackground(
334: cur_p->window,
335: menu->inact_pixmap
336: );
337: _XMRefreshPaneText(menu, cur_p);
338: }
339: /*
340: * Make the new pane the current pane.
341: */
342: cur_p = p_ptr;
343: /*
344: * If we have cycled through to the event
345: * pane we are done.
346: */
347: if (p_ptr->window == event_xmp->window) break;
348: }
349: }
350: break;
351: case LeaveWindow:
352: event_xmw = (XMWindow *)XLookUpAssoc(
353: menu->assoc_tab,
354: event.window
355: );
356: if (event_xmw == NULL) break;
357: /*
358: * If the current selection was activated then
359: * deactivate it.
360: */
361: if (cur_s->activated) {
362: cur_s->activated = 0;
363: _XMRefreshSelection(menu, cur_s);
364: }
365: cur_s = NULL;
366: break;
367: case ButtonPressed:
368: case ButtonReleased:
369: *p_num = cur_p->serial;
370: /*
371: * Check to see if there is a current selecion.
372: */
373: if (cur_s != NULL) {
374: /*
375: * Set the selection number to the current selection.
376: */
377: *s_num = cur_s->serial;
378: /*
379: * If the current selection was activated then
380: * we have a valid selection otherwise we have
381: * an inactive selection.
382: */
383: if (cur_s->activated) {
384: *data = cur_s->data;
385: ret_val = XM_SUCCESS;
386: }
387: else {
388: ret_val = XM_IA_SELECT;
389: }
390: }
391: else {
392: /*
393: * No selection was current.
394: */
395: ret_val = XM_NO_SELECT;
396: }
397: selection = TRUE;
398: break;
399: default:
400: if (_XMEventHandler) (*_XMEventHandler)(&event);
401: }
402: /*
403: * If a selection has been made, break out of the event loop.
404: */
405: if (selection == TRUE) break;
406: }
407:
408: /*
409: * Unmap the menu.
410: */
411: if (saved) {
412: for (
413: p_ptr = menu->p_list->next;
414: p_ptr != menu->p_list;
415: p_ptr = p_ptr->next
416: ) {
417: XUnmapTransparent(p_ptr->window);
418: }
419: }
420: else {
421: for (
422: p_ptr = menu->p_list->next;
423: p_ptr != menu->p_list;
424: p_ptr = p_ptr->next
425: ) {
426: XUnmapWindow(p_ptr->window);
427: }
428: }
429:
430: /*
431: * Ungrab the mouse.
432: */
433: XUngrabMouse();
434:
435: /*
436: * Restore bits under where the menu was if we managed
437: * to save them and free the pixmap.
438: */
439: if (saved) {
440: XPixmapPut(
441: menu->parent,
442: 0, 0,
443: save_x, save_y,
444: save_w, save_h,
445: save_pixmap,
446: GXcopy, AllPlanes
447: );
448: XFreePixmap(save_pixmap);
449: }
450:
451: /*
452: * Ungrab the X server.
453: */
454: if (menu->freeze) XUngrabServer();
455:
456: /*
457: * If there is a current selection deactivate it.
458: */
459: if (cur_s != NULL) cur_s->activated = 0;
460:
461: /*
462: * Deactivate the current pane.
463: */
464: cur_p->activated = 0;
465: XChangeBackground(cur_p->window, menu->inact_pixmap);
466:
467: /*
468: * Synchronize the X buffers and the event queue.
469: */
470: XSync(0);
471:
472: /*
473: * Now discard any extraneous events.
474: */
475: while (QLength()) {
476: /*
477: * Fetch the next event.
478: */
479: XNextEvent(&event);
480:
481: /*
482: * Dispatch on the event type.
483: */
484: switch (event.type) {
485: case ExposeWindow:
486: case EnterWindow:
487: case LeaveWindow:
488: case ButtonPressed:
489: case ButtonReleased:
490: event_xmp = (XMPane *)XLookUpAssoc(
491: menu->assoc_tab,
492: event.window
493: );
494: if ((event_xmp == NULL) && (_XMEventHandler != NULL))
495: (*_XMEventHandler)(&event);
496: break;
497: default:
498: if (_XMEventHandler) (*_XMEventHandler)(&event);
499: }
500: }
501:
502: /*
503: * Return successfully.
504: */
505: _XMErrorCode = XME_NO_ERROR;
506: return(ret_val);
507: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.