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