![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XMenuInternal.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 XMenuInternal.c CVS log | Up to [CSRG BSD Unix] / 43BSD / contrib / X / XMenu |
1.1 root 1: #include <X/mit-copyright.h>
2:
3: /* $Header: XMenuInternal.c,v 10.17 86/02/01 16:15:10 tony Rel $ */
4: /* Copyright Massachusetts Institute of Technology 1985 */
5:
6: /*
7: * XMenu: MIT Project Athena, X Window system menu package
8: *
9: * XMenuInternal.c - XMenu internal (not user visable) routines.
10: *
11: * Author: Tony Della Fera, DEC
12: * November, 1985
13: *
14: */
15:
16: #include "XMenuInternal.h"
17:
18: /*
19: * Toggle color macro.
20: */
21: #define toggle_color(x) \
22: ((x) == menu->bkgnd_color ? menu->s_frg_color : menu->bkgnd_color)
23:
24: /*
25: * Internal Window creation queue sizes.
26: */
27: #define S_QUE_SIZE 300
28: #define P_QUE_SIZE 20
29: #define BUFFER_SIZE (S_QUE_SIZE >= P_QUE_SIZE ? S_QUE_SIZE : P_QUE_SIZE)
30:
31:
32: /*
33: * XMWinQue - Internal window creation queue datatype.
34: */
35: typedef struct _xm_win_que_def {
36: int sq_size;
37: XMSelect *sq[S_QUE_SIZE];
38: XMSelect **sq_ptr;
39: int pq_size;
40: XMPane *pq[P_QUE_SIZE];
41: XMPane **pq_ptr;
42: } XMWinQue;
43:
44: /*
45: * _XMWinQue - Internal static window creation queue.
46: */
47: static XMWinQue _XMWinQue;
48:
49: /*
50: * _XMErrorCode - Global XMenu error code.
51: */
52: int _XMErrorCode = XME_NO_ERROR;
53:
54: /*
55: * _XMErrorList - Global XMenu error code discription strings.
56: */
57: char *
58: _XMErrorList[XME_CODE_COUNT] = {
59: "No error", /* XME_NO_ERROR */
60: "Menu not initialized", /* XME_NOT_INIT */
61: "Argument out of bounds", /* XME_ARG_BOUNDS */
62: "Pane not found", /* XME_P_NOT_FOUND */
63: "Selection not found", /* XME_S_NOT_FOUND */
64: "Invalid menu style parameter", /* XME_STYLE_PARAM */
65: "Unable to grab mouse", /* XME_GRAB_MOUSE */
66: "Unable to interpret locator", /* XME_INTERP_LOC */
67: "Unable to calloc memory", /* XME_CALLOC */
68: "Unable to create XAssocTable", /* XME_CREATE_ASSOC */
69: "Unable to store bitmap", /* XME_STORE_BITMAP */
70: "Unable to make tile pixmaps", /* XME_MAKE_TILES */
71: "Unable to make pixmap", /* XME_MAKE_PIXMAP */
72: "Unable to create cursor", /* XME_CREATE_CURSOR */
73: "Unable to open font", /* XME_OPEN_FONT */
74: "Unable to create windows", /* XME_CREATE_WINDOW */
75: "Unable to create transparencies", /* XME_CREATE_TRANSP */
76: };
77:
78: /*
79: * _XMEventHandler - Internal event handler variable.
80: */
81: int (*_XMEventHandler)() = NULL;
82:
83:
84:
85: /*
86: * _XMWinQueInit - Internal routine to initialize the window
87: * queue.
88: */
89: _XMWinQueInit()
90: {
91: /*
92: * Blank the queue structure.
93: */
94: bzero(&_XMWinQue, sizeof(XMWinQue));
95:
96: /*
97: * Initialize the next free location pointers.
98: */
99: _XMWinQue.sq_ptr = _XMWinQue.sq;
100: _XMWinQue.pq_ptr = _XMWinQue.pq;
101: }
102:
103:
104:
105: /*
106: * _XMWinQueAddPane - Internal routine to add a pane to the pane
107: * window queue.
108: */
109: int
110: _XMWinQueAddPane(menu, p_ptr)
111: register XMenu *menu; /* Menu being manipulated. */
112: register XMPane *p_ptr; /* XMPane being queued. */
113: {
114: /*
115: * If the queue is currently full then flush it.
116: */
117: if (_XMWinQue.pq_size == P_QUE_SIZE) {
118: if (_XMWinQueFlush(menu) == _FAILURE) return(_FAILURE);
119: }
120:
121: /*
122: * Insert the new XMPane pointer and increment the queue pointer
123: * and the queue size.
124: */
125: *_XMWinQue.pq_ptr = p_ptr;
126: _XMWinQue.pq_ptr++;
127: _XMWinQue.pq_size++;
128:
129: /*
130: * All went well, return successfully.
131: */
132: _XMErrorCode = XME_NO_ERROR;
133: return(_SUCCESS);
134: }
135:
136:
137:
138: /*
139: * _XMWinQueAddSelection - Internal routine to add a selection to
140: * the selection window queue.
141: */
142: int
143: _XMWinQueAddSelection(menu, s_ptr)
144: register XMenu *menu; /* Menu being manipulated. */
145: register XMSelect *s_ptr; /* XMSelection being queued. */
146: {
147: /*
148: * If this entry will overflow the queue then flush it.
149: */
150: if (_XMWinQue.sq_size == S_QUE_SIZE) {
151: if (_XMWinQueFlush(menu) == _FAILURE) return(_FAILURE);
152: }
153:
154: /*
155: * Insert the new XMSelect pointer and increment the queue pointer
156: * and the queue size.
157: */
158: *_XMWinQue.sq_ptr = s_ptr;
159: _XMWinQue.sq_ptr++;
160: _XMWinQue.sq_size++;
161:
162: /*
163: * All went well, return successfully.
164: */
165: _XMErrorCode = XME_NO_ERROR;
166: return(_SUCCESS);
167: }
168:
169:
170:
171: /*
172: * _XMWinQueFlush - Internal routine to flush the pane and
173: * selection window queues.
174: */
175: int
176: _XMWinQueFlush(menu)
177: register XMenu *menu; /* Menu being manipulated. */
178: {
179: register int pq_index; /* Pane queue index. */
180: register int sq_index; /* Selection queue index. */
181: register XMPane *p_ptr; /* XMPane pointer. */
182: register XMSelect *s_ptr; /* XMSelect pointer. */
183:
184: int win_count; /* Count of created windows. */
185: Window window; /* Window id temporary variable. */
186: BatchFrame batch_buf[BUFFER_SIZE]; /* Window batch creation buffer. */
187:
188: /*
189: * If the pane window queue is not empty...
190: */
191: if (_XMWinQue.pq_size > 0) {
192: /*
193: * Pack the window batch buffer.
194: */
195: for (pq_index = 0; pq_index < _XMWinQue.pq_size; pq_index++) {
196: /*
197: * Retrieve the an XMPane pointer.
198: */
199: p_ptr = _XMWinQue.pq[pq_index];
200:
201: /*
202: * Pack the next buffer location with the data
203: * associated with the XMPane.
204: */
205: batch_buf[pq_index].type = IsOpaque;
206: batch_buf[pq_index].parent = menu->parent;
207: batch_buf[pq_index].x = p_ptr->window_x;
208: batch_buf[pq_index].y = p_ptr->window_y;
209: batch_buf[pq_index].width = p_ptr->window_w;
210: batch_buf[pq_index].height = p_ptr->window_h;
211: batch_buf[pq_index].bdrwidth = menu->p_bdr_width;
212: batch_buf[pq_index].border = menu->p_bdr_pixmap;
213: batch_buf[pq_index].background = menu->inact_pixmap;
214: }
215:
216: /*
217: * Transmit the pane window buffer.
218: */
219: win_count = XCreateWindowBatch(batch_buf, _XMWinQue.pq_size);
220: if (win_count != _XMWinQue.pq_size) {
221: _XMErrorCode = XME_CREATE_WINDOW;
222: return(_FAILURE);
223: }
224:
225: /*
226: * Retrieve the resulting window id's.
227: */
228: for (pq_index = 0; pq_index < _XMWinQue.pq_size; pq_index++) {
229: window = batch_buf[pq_index].self;
230: /*
231: * Store the window id with its XMPane structure.
232: */
233: p_ptr = _XMWinQue.pq[pq_index];
234: p_ptr->window = window;
235: /*
236: * Insert the new window id and its
237: * associated XMPane structure into the
238: * assoction table.
239: */
240: XMakeAssoc(menu->assoc_tab, window, p_ptr);
241: /*
242: * Select input events on the new window.
243: */
244: XSelectInput(window, menu->p_events);
245: }
246:
247: /*
248: * Reset the pane queue pointer and size.
249: */
250: _XMWinQue.pq_size = 0;
251: _XMWinQue.pq_ptr = _XMWinQue.pq;
252: }
253:
254: /*
255: * If the selection window queue is not empty...
256: */
257: if (_XMWinQue.sq_size > 0) {
258: /*
259: * Pack the selection transparency buffer.
260: */
261: for (sq_index = 0; sq_index < _XMWinQue.sq_size; sq_index++) {
262: /*
263: * Retrieve the an XMSelect pointer.
264: */
265: s_ptr = _XMWinQue.sq[sq_index];
266:
267: /*
268: * Pack the next buffer location with the data
269: * associated with the XMPane.
270: */
271: batch_buf[sq_index].type = IsTransparent;
272: batch_buf[sq_index].parent = s_ptr->parent_p->window;
273: batch_buf[sq_index].x = s_ptr->window_x;
274: batch_buf[sq_index].y = s_ptr->window_y;
275: batch_buf[sq_index].width = s_ptr->window_w;
276: batch_buf[sq_index].height = s_ptr->window_h;
277: }
278:
279: /*
280: * Transmit the selection transparency buffer.
281: */
282: win_count = XCreateWindowBatch(batch_buf, _XMWinQue.sq_size);
283: if (win_count != _XMWinQue.sq_size) {
284: _XMErrorCode = XME_CREATE_TRANSP;
285: return(_FAILURE);
286: }
287:
288: /*
289: * Retrieve the resulting window id's.
290: */
291: for (sq_index = 0; sq_index < _XMWinQue.sq_size; sq_index++) {
292: window = batch_buf[sq_index].self;
293: /*
294: * Store the window id with its XMSelect structure.
295: */
296: s_ptr = _XMWinQue.sq[sq_index];
297: s_ptr->window = window;
298: /*
299: * Insert the new window id and its
300: * associated XMSelect structure into the
301: * assoction table.
302: */
303: XMakeAssoc(menu->assoc_tab, window, s_ptr);
304: /*
305: * Select input events on the new window.
306: */
307: XSelectInput(window, menu->s_events);
308: }
309:
310: /*
311: * Reset the selection queue pointer and size.
312: */
313: _XMWinQue.sq_size = 0;
314: _XMWinQue.sq_ptr = _XMWinQue.sq;
315: }
316:
317: /*
318: * Flush X's internal queues.
319: */
320: XFlush();
321:
322: /*
323: * All went well, return successfully.
324: */
325: _XMErrorCode = XME_NO_ERROR;
326: return(_SUCCESS);
327: }
328:
329:
330:
331: /*
332: * _XMGetPanePtr - Given a menu pointer and a pane index number, return
333: * a pane pointer that points to the indexed pane.
334: */
335: XMPane *
336: _XMGetPanePtr(menu, p_num)
337: register XMenu *menu; /* Menu to find the pane in. */
338: register int p_num; /* Index number of pane to find. */
339: {
340: register XMPane *p_ptr; /* Pane pointer to be returned. */
341: register int i; /* Loop counter. */
342:
343: /*
344: * Is the pane number out of range?
345: */
346: if ((p_num < 0) || (p_num > (menu->p_count - 1))) {
347: _XMErrorCode = XME_P_NOT_FOUND;
348: return(NULL);
349: }
350:
351: /*
352: * Find the right pane.
353: */
354: p_ptr = menu->p_list->next;
355: for (i = 0; i < p_num; i++) p_ptr = p_ptr->next;
356:
357: /*
358: * Return successfully.
359: */
360: _XMErrorCode = XME_NO_ERROR;
361: return(p_ptr);
362: }
363:
364:
365:
366: /*
367: * _XMGetSelectionPtr - Given pane pointer and a selection index number,
368: * return a selection pointer that points to the
369: * indexed selection.
370: */
371: XMSelect *
372: _XMGetSelectionPtr(p_ptr, s_num)
373: register XMPane *p_ptr; /* Pane to find the selection in. */
374: register int s_num; /* Index number of the selection to find. */
375: {
376: register XMSelect *s_ptr; /* Selection pointer to be returned. */
377: register int i; /* Loop counter. *./
378:
379: /*
380: * Is the selection number out of range?
381: */
382: if ((s_num < 0) || (s_num > (p_ptr->s_count - 1))) {
383: _XMErrorCode = XME_S_NOT_FOUND;
384: return(NULL);
385: }
386:
387: /*
388: * Find the right selection.
389: */
390: s_ptr = p_ptr->s_list->next;
391: for (i = 0; i < s_num; i++) s_ptr = s_ptr->next;
392:
393: /*
394: * Return successfully.
395: */
396: _XMErrorCode = XME_NO_ERROR;
397: return(s_ptr);
398: }
399:
400:
401:
402: /*
403: * _XMRecomputeGlobals - Internal subroutine to recompute menu wide
404: * global values.
405: */
406: _XMRecomputeGlobals(menu)
407: register XMenu *menu; /* Menu object to compute from. */
408: {
409: register XMPane *p_ptr; /* Pane pointer. */
410: register XMSelect *s_ptr; /* Selection pointer. */
411:
412: register int max_p_label = 0; /* Maximum pane label width. */
413: register int max_s_label = 0; /* Maximum selection label width. */
414: register int s_count = 0; /* Maximum selection count. */
415:
416: int p_s_pad; /* Pane <-> selection padding. */
417: int p_s_diff; /* Pane <-> selection seperation. */
418:
419: int p_height; /* Pane window height. */
420: int p_width; /* Pane window width. */
421: int s_width; /* Selection window width. */
422:
423: int seperation; /* Pane window, selection window seperation. */
424:
425: /*
426: * For each pane...
427: */
428: for (
429: p_ptr = menu->p_list->next;
430: p_ptr != menu->p_list;
431: p_ptr = p_ptr->next
432: ){
433: /*
434: * Recompute maximum pane label width.
435: */
436: max_p_label = max(max_p_label, p_ptr->label_width);
437:
438: /*
439: * Recompute maximum selection count.
440: */
441: s_count = max(s_count, p_ptr->s_count);
442:
443: /*
444: * For each selection in the current pane...
445: */
446: for (
447: s_ptr = p_ptr->s_list->next;
448: s_ptr != p_ptr->s_list;
449: s_ptr = s_ptr->next
450: ){
451: /*
452: * Recompute maximum selection label width.
453: */
454: max_s_label = max(max_s_label, s_ptr->label_width);
455: }
456: }
457:
458: /*
459: * Recompute pane height.
460: */
461: p_height = (menu->flag_height << 1) + (menu->s_y_off * s_count);
462:
463: /*
464: * Recompute horizontal padding between the pane window and the
465: * selection windows.
466: */
467: p_s_pad = menu->p_x_off << 1;
468:
469: /*
470: * Recompute pane and selection window widths.
471: * This is done by first computing the window sizes from the maximum
472: * label widths. If the spacing between the selection window and the
473: * containing pane window is less than the pane selection padding value
474: * (twice the pane X offset) then change the size of the pane to be
475: * the size of the selection window plus the padding. If, however the
476: * spacing between the selection window and the containing pane window
477: * is more than the pane selection padding value increase the size of
478: * the selection to its maximum possible value (the pane width minus
479: * the pane selection padding value).
480: */
481: p_width = max_p_label + p_s_pad;
482: s_width = max_s_label + (menu->s_fnt_pad << 1) + (menu->s_bdr_width << 1);
483: p_s_diff = p_width - s_width;
484: if (p_s_diff < p_s_pad) {
485: p_width = s_width + p_s_pad;
486: }
487: else if (p_s_diff > p_s_pad) {
488: s_width = p_width - p_s_pad;
489: }
490:
491: /*
492: * Reset menu wide global values.
493: */
494: menu->s_count = s_count;
495: menu->p_height = p_height;
496: menu->p_width = p_width;
497: menu->s_width = s_width;
498: }
499:
500:
501:
502: /*
503: * _XMRecomputePane - Internal subroutine to recompute pane
504: * window dependencies.
505: */
506: int
507: _XMRecomputePane(menu, p_ptr, p_num)
508: register XMenu *menu; /* Menu object being recomputed. */
509: register XMPane *p_ptr; /* Pane pointer. */
510: register int p_num; /* Pane sequence number. */
511: {
512: register int window_x; /* Recomputed window X coordinate. */
513: register int window_y; /* Recomputed window Y coordinate. */
514:
515: register Bool config_p = FALSE; /* Reconfigure pane window? */
516:
517: /*
518: * Update the pane serial number.
519: */
520: p_ptr->serial = p_num;
521:
522: /*
523: * Recompute window X and Y coordinates.
524: */
525: switch (menu->menu_style) {
526: case LEFT:
527: window_x = menu->p_x_off * ((menu->p_count - 1) - p_num);
528: window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
529: break;
530: case RIGHT:
531: window_x = menu->p_x_off * p_num;
532: window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
533: break;
534: case CENTER:
535: window_x = 0;
536: window_y = menu->p_y_off * ((menu->p_count - 1) - p_num);
537: break;
538: default:
539: /* Error! Invalid style parameter. */
540: _XMErrorCode = XME_STYLE_PARAM;
541: return(_FAILURE);
542: }
543:
544: /*
545: * If the newly compute pane coordinates differ from the
546: * current coordinates, reset the current coordinates and
547: * reconfigure the pane.
548: */
549: if (
550: (window_x != p_ptr->window_x) ||
551: (window_y != p_ptr->window_y)
552: ){
553: /*
554: * Reset the coordinates and schedule
555: * the pane for reconfiguration.
556: */
557: p_ptr->window_x = window_x;
558: p_ptr->window_y = window_y;
559: config_p = TRUE;
560: }
561:
562: /*
563: * If the local pane width and height differs from the
564: * menu pane width and height, reset the local values.
565: */
566: if (
567: (p_ptr->window_w != menu->p_width) ||
568: (p_ptr->window_h != menu->p_height)
569: ){
570: /*
571: * Reset window width and height and schedule
572: * the pane for reconfiguration.
573: */
574: p_ptr->window_w = menu->p_width;
575: p_ptr->window_h = menu->p_height;
576: config_p = TRUE;
577: }
578:
579: /*
580: * If we need to reconfigure the pane window do it now.
581: */
582: if (config_p == TRUE) {
583: /*
584: * If the pane window has already been created then
585: * reconfigure the existing window, otherwise queue
586: * it for creation with the new configuration.
587: */
588: if (p_ptr->window) {
589: XConfigureWindow(
590: p_ptr->window,
591: p_ptr->window_x, p_ptr->window_y,
592: p_ptr->window_w, p_ptr->window_h
593: );
594: }
595: else {
596: if (_XMWinQueAddPane(menu, p_ptr) == _FAILURE) {
597: return(_FAILURE);
598: }
599: }
600: }
601:
602: /*
603: * Recompute label X position.
604: */
605: switch (menu->p_style) {
606: case LEFT:
607: p_ptr->label_x = menu->p_x_off + menu->p_fnt_pad;
608: break;
609: case RIGHT:
610: p_ptr->label_x = menu->p_width -
611: (p_ptr->label_width + menu->p_x_off + menu->p_fnt_pad);
612: break;
613: case CENTER:
614: p_ptr->label_x = (menu->p_width - p_ptr->label_width) >> 1;
615: break;
616: default:
617: /* Error! Invalid style parameter. */
618: _XMErrorCode = XME_STYLE_PARAM;
619: return(_FAILURE);
620: }
621: /*
622: * Recompute label Y positions.
623: */
624: p_ptr->label_uy = menu->p_fnt_pad;
625: p_ptr->label_ly = (menu->p_height - menu->flag_height) + menu->p_fnt_pad;
626:
627: /*
628: * All went well, return successfully.
629: */
630: _XMErrorCode = XME_NO_ERROR;
631: return(_SUCCESS);
632: }
633:
634:
635:
636: /*
637: * _XMRecomputeSelection - Internal subroutine to recompute
638: * selection window dependencies.
639: */
640: int
641: _XMRecomputeSelection(menu, s_ptr, s_num)
642: register XMenu *menu; /* Menu object being recomputed. */
643: register XMSelect *s_ptr; /* Selection pointer. */
644: register int s_num; /* Selection sequence number. */
645: {
646: register Bool config_s = FALSE; /* Reconfigure selection window? */
647:
648: /*
649: * If the selection serial numbers are out of order, begin
650: * resequencing selections. Recompute selection window coordinates
651: * and serial number.
652: *
653: * When selections are created they are given a serial number of
654: * -1, this causes this routine to give a new selection
655: * its initial coordinates and serial number.
656: */
657: if (s_ptr->serial != s_num) {
658: /*
659: * Fix the sequence number.
660: */
661: s_ptr->serial = s_num;
662: /*
663: * Recompute window X and Y coordinates.
664: */
665: s_ptr->window_x = menu->s_x_off;
666: s_ptr->window_y = menu->flag_height + (menu->s_y_off * s_num);
667: /*
668: * We must reconfigure the window.
669: */
670: config_s = TRUE;
671: }
672:
673: /*
674: * If the local selection width and height differs from the
675: * menu selection width and height, reset the local values.
676: */
677: if (
678: (s_ptr->window_w != menu->s_width) ||
679: (s_ptr->window_h != menu->s_height)
680: ){
681: /*
682: * We must reconfigure the window.
683: */
684: config_s = TRUE;
685: /*
686: * Reset window width and height.
687: */
688: s_ptr->window_w = menu->s_width;
689: s_ptr->window_h = menu->s_height;
690: }
691:
692: /*
693: * If we need to reconfigure the selection window do it now.
694: */
695: if (config_s == TRUE) {
696: /*
697: * If the selection window has already been created then
698: * reconfigure the existing window, otherwise queue it
699: * for creation with the new configuration.
700: */
701: if (s_ptr->window) {
702: XConfigureWindow(
703: s_ptr->window,
704: s_ptr->window_x, s_ptr->window_y,
705: s_ptr->window_w, s_ptr->window_h
706: );
707: }
708: else {
709: if (_XMWinQueAddSelection(menu, s_ptr) == _FAILURE) {
710: return(_FAILURE);
711: }
712: }
713: }
714:
715: /*
716: * Recompute label X position.
717: */
718: switch (menu->s_style) {
719: case LEFT:
720: s_ptr->label_x = menu->s_bdr_width + menu->s_fnt_pad;
721: break;
722: case RIGHT:
723: s_ptr->label_x = menu->s_width -
724: (s_ptr->label_width + menu->s_bdr_width + menu->s_fnt_pad);
725: break;
726: case CENTER:
727: s_ptr->label_x = (menu->s_width - s_ptr->label_width) >> 1;
728: break;
729: default:
730: /* Error! Invaild style parameter. */
731: _XMErrorCode = XME_STYLE_PARAM;
732: return(_FAILURE);
733: }
734: /*
735: * Recompute label Y position.
736: */
737: s_ptr->label_y = menu->s_fnt_pad + menu->s_bdr_width;
738:
739: /*
740: * All went well, return successfully.
741: */
742: _XMErrorCode = XME_NO_ERROR;
743: return(_SUCCESS);
744: }
745:
746:
747:
748: /*
749: * _XMTransToOrigin - Internal subroutine to translate the point at
750: * the center of the current pane and selection to the
751: * the menu origin.
752: *
753: * WARNING! ****** Be certain that all menu depencies have been
754: * recomputed before calling this routine or
755: * unpredicable results will follow.
756: */
757: _XMTransToOrigin(menu, p_ptr, s_ptr, x_pos, y_pos, orig_x, orig_y)
758: register XMenu *menu; /* Menu being computed against. */
759: register XMPane *p_ptr; /* Current pane pointer. */
760: register XMSelect *s_ptr; /* Current selection pointer. */
761: int x_pos; /* X coordinate of point to translate. */
762: int y_pos; /* Y coordinate of point to translate. */
763: int *orig_x; /* Return value X coord. of the menu origin. */
764: int *orig_y; /* Return value Y coord. of the menu origin. */
765: {
766: register int l_orig_x; /* Local X coordinate of the menu origin. */
767: register int l_orig_y; /* local Y coordinate of the menu origin. */
768:
769: /*
770: * Translate the menu origin such that the cursor hot point will be in the
771: * center of the desired current selection and pane.
772: */
773:
774: /*
775: * First translate to the upper left of the current selection window.
776: */
777: l_orig_x = x_pos - (menu->s_width >> 1);
778: l_orig_y = y_pos - (menu->s_height >> 1);
779:
780: /*
781: * Then translate to the upper left of the current pane window.
782: */
783: l_orig_x -= (s_ptr->window_x + menu->p_bdr_width);
784: l_orig_y -= (s_ptr->window_y + menu->p_bdr_width);
785:
786: /*
787: * Finally translate to the upper left of the menu.
788: */
789: l_orig_x -= p_ptr->window_x;
790: l_orig_y -= p_ptr->window_y;
791:
792: /*
793: * Set the return values.
794: */
795: *orig_x = l_orig_x;
796: *orig_y = l_orig_y;
797: }
798:
799:
800:
801: /*
802: * _XMRefreshPaneLabels - Internal subroutine that refreshes
803: * the labels in a menu pane.
804: */
805: _XMRefreshPaneText(menu, pane)
806: register XMenu *menu;
807: register XMPane *pane;
808: {
809: /*
810: * First clear the pane.
811: */
812: XClear(pane->window);
813: /*
814: * Then redraw the label text.
815: */
816: XTextMask(
817: pane->window,
818: pane->label_x, pane->label_uy,
819: pane->label, pane->label_length,
820: menu->p_fnt_info->id,
821: menu->p_frg_color
822: );
823: XTextMask(
824: pane->window,
825: pane->label_x, pane->label_ly,
826: pane->label, pane->label_length,
827: menu->p_fnt_info->id,
828: menu->p_frg_color
829: );
830: }
831:
832:
833:
834: /*
835: * _XMRefreshPane - Internal subroutine to completely refresh
836: * the contents of a pane.
837: */
838: _XMRefreshPane(menu,pane)
839: register XMenu *menu;
840: register XMPane *pane;
841: {
842: register XMSelect *s_list = pane->s_list;
843: register XMSelect *s_ptr;
844:
845: /*
846: * First clear the pane.
847: */
848: XClear(pane->window);
849: /*
850: * Then redraw the label text.
851: */
852: XTextMask(
853: pane->window,
854: pane->label_x, pane->label_uy,
855: pane->label, pane->label_length,
856: menu->p_fnt_info->id,
857: menu->p_frg_color
858: );
859: XTextMask(
860: pane->window,
861: pane->label_x, pane->label_ly,
862: pane->label, pane->label_length,
863: menu->p_fnt_info->id,
864: menu->p_frg_color
865: );
866: /*
867: * Finally refresh each selection.
868: */
869: for (s_ptr = s_list->next; s_ptr != s_list; s_ptr = s_ptr->next){
870: _XMRefreshSelection(menu, s_ptr);
871: }
872: }
873:
874:
875:
876: /*
877: * _XMRefreshSelection - Internal subroutine that refreshes
878: * a single selection window.
879: */
880: _XMRefreshSelection(menu, select)
881: register XMenu *menu;
882: register XMSelect *select;
883: {
884: register int width = select->window_w;
885: register int height = select->window_h;
886: register int bdr_width = menu->s_bdr_width;
887:
888: if (select->activated) {
889: if (menu->menu_mode == INVERT) {
890: XPixSet(select->window, 0, 0, width, height, menu->s_frg_color);
891: XTextMask(
892: select->window,
893: select->label_x, select->label_y,
894: select->label, select->label_length,
895: menu->s_fnt_info->id,
896: menu->bkgnd_color
897: );
898: }
899: else {
900: /*
901: * Since most drawing routines with arbitrary width lines
902: * are slow compared to raster-ops lets use a raster-op to
903: * draw the boxes.
904: */
905: XPixSet(select->window, 0, 0, width, height, menu->bkgnd_color);
906: XPixSet(
907: select->window,
908: 0, 0,
909: (width - bdr_width), bdr_width,
910: menu->s_bdr_color
911: );
912: XPixSet(
913: select->window,
914: (0 + (width - bdr_width)), 0,
915: bdr_width, (height - bdr_width),
916: menu->s_bdr_color
917: );
918: XPixSet(
919: select->window,
920: (0 + bdr_width), (0 + (height - bdr_width)),
921: (width - bdr_width), bdr_width,
922: menu->s_bdr_color
923: );
924: XPixSet(
925: select->window,
926: 0, (0 + bdr_width),
927: bdr_width, (height - bdr_width),
928: menu->s_bdr_color
929: );
930: XTextMask(
931: select->window,
932: select->label_x, select->label_y,
933: select->label, select->label_length,
934: menu->s_fnt_info->id,
935: menu->s_frg_color
936: );
937: }
938: }
939: else {
940: XClear(select->window);
941: XTextMask(
942: select->window,
943: select->label_x, select->label_y,
944: select->label, select->label_length,
945: menu->s_fnt_info->id,
946: menu->s_frg_color
947: );
948: }
949: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.