?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Import from neverball-1.2.6-9.tar.gz
[neverball-archive.git] / share / gui.c
blob0fb5c37d5994af2d191f66eb041009215b90bf38
1 /*
2 * Copyright (C) 2003 Robert Kooima
3 *
4 * NEVERBALL is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU General Public License as published
6 * by the Free Software Foundation; either version 2 of the License,
7 * or (at your option) any later version.
8 *
9 * This program is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * General Public License for more details.
13 */
14
15 #include <stdlib.h>
16 #include <string.h>
17 #include <stdio.h>
18
19 #include "config.h"
20 #include "glext.h"
21 #include "image.h"
22 #include "vec3.h"
23 #include "gui.h"
24
25 /*---------------------------------------------------------------------------*/
26
27 #define MAXWIDGET 128
28
29 #define GUI_FREE 0
30 #define GUI_HARRAY 1
31 #define GUI_VARRAY 2
32 #define GUI_HSTACK 3
33 #define GUI_VSTACK 4
34 #define GUI_FILLER 5
35 #define GUI_STATE 6
36 #define GUI_IMAGE 7
37 #define GUI_LABEL 8
38 #define GUI_COUNT 9
39 #define GUI_CLOCK 10
40 #define GUI_SPACE 11
41 #define GUI_PAUSE 12
42
43 struct widget
44 {
45 int type;
46 int token;
47 int value;
48 int size;
49 int rect;
50
51 int x, y;
52 int w, h;
53 int car;
54 int cdr;
55
56 GLuint text_img;
57 GLuint text_obj;
58 GLuint rect_obj;
59
60 const GLfloat *color0;
61 const GLfloat *color1;
62
63 GLfloat scale;
64 };
65
66 /*---------------------------------------------------------------------------*/
67
68 const GLfloat gui_wht[4] = { 1.0f, 1.0f, 1.0f, 1.0f };
69 const GLfloat gui_yel[4] = { 1.0f, 1.0f, 0.0f, 1.0f };
70 const GLfloat gui_red[4] = { 1.0f, 0.0f, 0.0f, 1.0f };
71 const GLfloat gui_grn[4] = { 0.0f, 1.0f, 0.0f, 1.0f };
72 const GLfloat gui_blu[4] = { 0.0f, 0.0f, 1.0f, 1.0f };
73 const GLfloat gui_blk[4] = { 0.0f, 0.0f, 0.0f, 1.0f };
74 const GLfloat gui_gry[4] = { 0.0f, 0.0f, 0.0f, 0.5f };
75
76 /*---------------------------------------------------------------------------*/
77
78 static struct widget widget[MAXWIDGET];
79 static int active;
80 static int radius;
81 static TTF_Font *font[3] = { NULL, NULL, NULL };
82
83 static GLuint digit_text[3][11];
84 static GLuint digit_list[3][11];
85 static int digit_w[3][11];
86 static int digit_h[3][11];
87
88 static int pause_id;
89
90 /*---------------------------------------------------------------------------*/
91 /*
92 * Initialize a display list containing a rectangle (x, y, w, h) to
93 * which a rendered-font texture may be applied. Colors c0 and c1
94 * determine the top-to-bottom color gradiant of the text.
95 */
96
97 static GLuint gui_list(int x, int y,
98 int w, int h, const float *c0, const float *c1)
99 {
100 GLuint list = glGenLists(1);
101
102 GLfloat s0, t0;
103 GLfloat s1, t1;
104
105 int W, H, d = h / 16;
106
107 /* Assume the applied texture size is rect size rounded to power-of-two. */
108
109 image_size(&W, &H, w, h);
110
111 s0 = 0.5f * (W - w) / W;
112 t0 = 0.5f * (H - h) / H;
113 s1 = 1.0f - s0;
114 t1 = 1.0f - t0;
115
116 glNewList(list, GL_COMPILE);
117 {
118 glBegin(GL_QUADS);
119 {
120 glColor4f(0.0f, 0.0f, 0.0f, 0.5f);
121 glTexCoord2f(s0, t1); glVertex2i(x + d, y - d);
122 glTexCoord2f(s1, t1); glVertex2i(x + w + d, y - d);
123 glTexCoord2f(s1, t0); glVertex2i(x + w + d, y + h - d);
124 glTexCoord2f(s0, t0); glVertex2i(x + d, y + h - d);
125
126 glColor4fv(c0);
127 glTexCoord2f(s0, t1); glVertex2i(x, y);
128 glTexCoord2f(s1, t1); glVertex2i(x + w, y);
129
130 glColor4fv(c1);
131 glTexCoord2f(s1, t0); glVertex2i(x + w, y + h);
132 glTexCoord2f(s0, t0); glVertex2i(x, y + h);
133 }
134 glEnd();
135 }
136 glEndList();
137
138 return list;
139 }
140
141 /*
142 * Initialize a display list containing a rounded-corner rectangle (x,
143 * y, w, h). Generate texture coordinates to properly apply a texture
144 * map to the rectangle as though the corners were not rounded.
145 */
146
147 static GLuint gui_rect(int x, int y, int w, int h, int f, int r)
148 {
149 GLuint list = glGenLists(1);
150
151 int n = 8;
152 int i;
153
154 glNewList(list, GL_COMPILE);
155 {
156 glBegin(GL_QUAD_STRIP);
157 {
158 /* Left side... */
159
160 for (i = 0; i <= n; i++)
161 {
162 float a = 0.5f * V_PI * (float) i / (float) n;
163 float s = r * fsinf(a);
164 float c = r * fcosf(a);
165
166 float X = x + r - c;
167 float Ya = y + h + ((f & GUI_NW) ? (s - r) : 0);
168 float Yb = y + ((f & GUI_SW) ? (r - s) : 0);
169
170 glTexCoord2f((X - x) / w, 1 - (Ya - y) / h);
171 glVertex2f(X, Ya);
172
173 glTexCoord2f((X - x) / w, 1 - (Yb - y) / h);
174 glVertex2f(X, Yb);
175 }
176
177 /* ... Right side. */
178
179 for (i = 0; i <= n; i++)
180 {
181 float a = 0.5f * V_PI * (float) i / (float) n;
182 float s = r * fsinf(a);
183 float c = r * fcosf(a);
184
185 float X = x + w - r + s;
186 float Ya = y + h + ((f & GUI_NE) ? (c - r) : 0);
187 float Yb = y + ((f & GUI_SE) ? (r - c) : 0);
188
189 glTexCoord2f((X - x) / w, 1 - (Ya - y) / h);
190 glVertex2f(X, Ya);
191
192 glTexCoord2f((X - x) / w, 1 - (Yb - y) / h);
193 glVertex2f(X, Yb);
194 }
195 }
196 glEnd();
197 }
198 glEndList();
199
200 return list;
201 }
202
203 /*---------------------------------------------------------------------------*/
204
205 void gui_init(void)
206 {
207 const float *c0 = gui_yel;
208 const float *c1 = gui_red;
209
210 int i, j, h = config_get(CONFIG_HEIGHT);
211
212 /* Initialize font rendering. */
213
214 if (TTF_Init() == 0)
215 {
216 /* Load small, medium, and large typefaces. */
217
218 font[GUI_SML] = TTF_OpenFont(GUI_FACE, h / 24);
219 font[GUI_MED] = TTF_OpenFont(GUI_FACE, h / 12);
220 font[GUI_LRG] = TTF_OpenFont(GUI_FACE, h / 6);
221 radius = h / 60;
222
223 /* Initialize the global pause GUI. */
224
225 if ((pause_id = gui_pause(0)))
226 gui_layout(pause_id, 0, 0);
227
228 /* Initialize digit glyphs and lists for counters and clocks. */
229
230 for (i = 0; i < 3; i++)
231 {
232 char text[2];
233
234 /* Draw digits 0 throught 9. */
235
236 for (j = 0; j < 10; j++)
237 {
238 text[0] = '0' + (char) j;
239 text[1] = 0;
240
241 digit_text[i][j] = make_image_from_font(NULL, NULL,
242 &digit_w[i][j],
243 &digit_h[i][j],
244 text, font[i]);
245 digit_list[i][j] = gui_list(-digit_w[i][j] / 2,
246 -digit_h[i][j] / 2,
247 +digit_w[i][j],
248 +digit_h[i][j], c0, c1);
249 }
250
251 /* Draw the colon for the clock. */
252
253 digit_text[i][j] = make_image_from_font(NULL, NULL,
254 &digit_w[i][10],
255 &digit_h[i][10],
256 ":", font[i]);
257 digit_list[i][j] = gui_list(-digit_w[i][10] / 2,
258 -digit_h[i][10] / 2,
259 +digit_w[i][10],
260 +digit_h[i][10], c0, c1);
261 }
262 }
263
264 active = 0;
265 }
266
267 void gui_free(void)
268 {
269 int i, j, id;
270
271 /* Release any remaining widget texture and display list indices. */
272
273 for (id = 1; id < MAXWIDGET; id++)
274 {
275 if (glIsTexture(widget[id].text_img))
276 glDeleteTextures(1, &widget[id].text_img);
277
278 if (glIsList(widget[id].text_obj))
279 glDeleteLists(widget[id].text_obj, 1);
280 if (glIsList(widget[id].rect_obj))
281 glDeleteLists(widget[id].rect_obj, 1);
282
283 widget[id].type = GUI_FREE;
284 widget[id].text_img = 0;
285 widget[id].text_obj = 0;
286 widget[id].rect_obj = 0;
287 widget[id].cdr = 0;
288 widget[id].car = 0;
289 }
290
291 /* Release all digit textures and display lists. */
292
293 for (i = 0; i < 3; i++)
294 for (j = 0; j < 11; j++)
295 {
296 if (glIsTexture(digit_text[i][j]))
297 glDeleteTextures(1, &digit_text[i][j]);
298
299 if (glIsList(digit_list[i][j]))
300 glDeleteLists(digit_list[i][j], 1);
301 }
302
303 /* Release all loaded fonts and finalize font rendering. */
304
305 if (font[GUI_LRG]) TTF_CloseFont(font[GUI_LRG]);
306 if (font[GUI_MED]) TTF_CloseFont(font[GUI_MED]);
307 if (font[GUI_SML]) TTF_CloseFont(font[GUI_SML]);
308
309 TTF_Quit();
310 }
311
312 /*---------------------------------------------------------------------------*/
313
314 static int gui_widget(int pd, int type)
315 {
316 int id;
317
318 /* Find an unused entry in the widget table. */
319
320 for (id = 1; id < MAXWIDGET; id++)
321 if (widget[id].type == GUI_FREE)
322 {
323 /* Set the type and default properties. */
324
325 widget[id].type = type;
326 widget[id].token = 0;
327 widget[id].value = 0;
328 widget[id].size = 0;
329 widget[id].rect = GUI_NW | GUI_SW | GUI_NE | GUI_SE;
330 widget[id].w = 0;
331 widget[id].h = 0;
332 widget[id].text_img = 0;
333 widget[id].text_obj = 0;
334 widget[id].rect_obj = 0;
335 widget[id].color0 = gui_wht;
336 widget[id].color1 = gui_wht;
337 widget[id].scale = 1.0f;
338
339 /* Insert the new widget into the parents's widget list. */
340
341 if (pd)
342 {
343 widget[id].car = 0;
344 widget[id].cdr = widget[pd].car;
345 widget[pd].car = id;
346 }
347 else
348 {
349 widget[id].car = 0;
350 widget[id].cdr = 0;
351 }
352
353 return id;
354 }
355
356 return 0;
357 }
358
359 int gui_harray(int pd) { return gui_widget(pd, GUI_HARRAY); }
360 int gui_varray(int pd) { return gui_widget(pd, GUI_VARRAY); }
361 int gui_hstack(int pd) { return gui_widget(pd, GUI_HSTACK); }
362 int gui_vstack(int pd) { return gui_widget(pd, GUI_VSTACK); }
363 int gui_filler(int pd) { return gui_widget(pd, GUI_FILLER); }
364
365 /*---------------------------------------------------------------------------*/
366
367 void gui_set_image(int id, const char *file)
368 {
369 if (glIsTexture(widget[id].text_img))
370 glDeleteTextures(1, &widget[id].text_img);
371
372 widget[id].text_img = make_image_from_file(NULL, NULL, NULL, NULL, file);
373 }
374
375 void gui_set_label(int id, const char *text)
376 {
377 int w, h;
378
379 if (glIsTexture(widget[id].text_img))
380 glDeleteTextures(1, &widget[id].text_img);
381 if (glIsList(widget[id].text_obj))
382 glDeleteLists(widget[id].text_obj, 1);
383
384 widget[id].text_img = make_image_from_font(NULL, NULL, &w, &h,
385 text, font[widget[id].size]);
386 widget[id].text_obj = gui_list(-w / 2, -h / 2, w, h,
387 widget[id].color0, widget[id].color1);
388 }
389
390 void gui_set_count(int id, int value)
391 {
392 widget[id].value = value;
393 }
394
395 void gui_set_clock(int id, int value)
396 {
397 widget[id].value = value;
398 }
399
400 void gui_set_multi(int id, const char *text)
401 {
402 const char *p;
403
404 char s[8][MAXSTR];
405 int i, j, jd;
406
407 size_t n = 0;
408
409 /* Copy each delimited string to a line buffer. */
410
411 for (p = text, j = 0; *p && j < 8; j++)
412 {
413 strncpy(s[j], p, (n = strcspn(p, "\\")));
414 s[j][n] = 0;
415
416 if (*(p += n) == '\\') p++;
417 }
418
419 /* Set the label value for each line. */
420
421 for (i = j - 1, jd = widget[id].car; i >= 0 && jd; i--, jd = widget[jd].cdr)
422 gui_set_label(jd, s[i]);
423 }
424
425 /*---------------------------------------------------------------------------*/
426
427 int gui_image(int pd, const char *file, int w, int h)
428 {
429 int id;
430
431 if ((id = gui_widget(pd, GUI_IMAGE)))
432 {
433 widget[id].text_img = make_image_from_file(NULL, NULL,
434 NULL, NULL, file);
435 widget[id].w = w;
436 widget[id].h = h;
437 }
438 return id;
439 }
440
441 int gui_start(int pd, const char *text, int size, int token, int value)
442 {
443 int id;
444
445 if ((id = gui_state(pd, text, size, token, value)))
446 active = id;
447
448 return id;
449 }
450
451 int gui_state(int pd, const char *text, int size, int token, int value)
452 {
453 int id;
454
455 if ((id = gui_widget(pd, GUI_STATE)))
456 {
457 widget[id].text_img = make_image_from_font(NULL, NULL,
458 &widget[id].w,
459 &widget[id].h,
460 text, font[size]);
461 widget[id].size = size;
462 widget[id].token = token;
463 widget[id].value = value;
464 }
465 return id;
466 }
467
468 int gui_label(int pd, const char *text, int size, int rect, const float *c0,
469 const float *c1)
470 {
471 int id;
472
473 if ((id = gui_widget(pd, GUI_LABEL)))
474 {
475 widget[id].text_img = make_image_from_font(NULL, NULL,
476 &widget[id].w,
477 &widget[id].h,
478 text, font[size]);
479 widget[id].size = size;
480 widget[id].color0 = c0 ? c0 : gui_yel;
481 widget[id].color1 = c1 ? c1 : gui_red;
482 widget[id].rect = rect;
483 }
484 return id;
485 }
486
487 int gui_count(int pd, int value, int size, int rect)
488 {
489 int i, id;
490
491 if ((id = gui_widget(pd, GUI_COUNT)))
492 {
493 for (i = value; i; i /= 10)
494 widget[id].w += digit_w[size][0];
495
496 widget[id].h = digit_h[size][0];
497 widget[id].value = value;
498 widget[id].size = size;
499 widget[id].color0 = gui_yel;
500 widget[id].color1 = gui_red;
501 widget[id].rect = rect;
502 }
503 return id;
504 }
505
506 int gui_clock(int pd, int value, int size, int rect)
507 {
508 int id;
509
510 if ((id = gui_widget(pd, GUI_CLOCK)))
511 {
512 widget[id].w = digit_w[size][0] * 6;
513 widget[id].h = digit_h[size][0];
514 widget[id].value = value;
515 widget[id].size = size;
516 widget[id].color0 = gui_yel;
517 widget[id].color1 = gui_red;
518 widget[id].rect = rect;
519 }
520 return id;
521 }
522
523 int gui_space(int pd)
524 {
525 int id;
526
527 if ((id = gui_widget(pd, GUI_SPACE)))
528 {
529 widget[id].w = 0;
530 widget[id].h = 0;
531 }
532 return id;
533 }
534
535 int gui_pause(int pd)
536 {
537 const char *text = "Paused";
538 int id;
539
540 if ((id = gui_widget(pd, GUI_PAUSE)))
541 {
542 widget[id].text_img = make_image_from_font(NULL, NULL,
543 &widget[id].w,
544 &widget[id].h,
545 text, font[GUI_LRG]);
546 widget[id].color0 = gui_wht;
547 widget[id].color1 = gui_wht;
548 widget[id].value = 0;
549 widget[id].size = GUI_LRG;
550 widget[id].rect = GUI_ALL;
551 }
552 return id;
553 }
554
555 /*---------------------------------------------------------------------------*/
556 /*
557 * Create a multi-line text box using a vertical array of labels.
558 * Parse the text for '\' characters and treat them as line-breaks.
559 * Preserve the rect specifation across the entire array.
560 */
561
562 int gui_multi(int pd, const char *text, int size, int rect, const float *c0,
563 const float *c1)
564 {
565 int id = 0;
566
567 if (text && (id = gui_varray(pd)))
568 {
569 const char *p;
570
571 char s[8][MAXSTR];
572 int r[8];
573 int i, j;
574
575 size_t n = 0;
576
577 /* Copy each delimited string to a line buffer. */
578
579 for (p = text, j = 0; *p && j < 8; j++)
580 {
581 strncpy(s[j], p, (n = strcspn(p, "\\")));
582 s[j][n] = 0;
583 r[j] = 0;
584
585 if (*(p += n) == '\\') p++;
586 }
587
588 /* Set the curves for the first and last lines. */
589
590 if (j > 0)
591 {
592 r[0] |= rect & (GUI_NW | GUI_NE);
593 r[j - 1] |= rect & (GUI_SW | GUI_SE);
594 }
595
596 /* Create a label widget for each line. */
597
598 for (i = 0; i < j; i++)
599 gui_label(id, s[i], size, r[i], c0, c1);
600 }
601 return id;
602 }
603
604 /*---------------------------------------------------------------------------*/
605 /*
606 * The bottom-up pass determines the area of all widgets. The minimum
607 * width and height of a leaf widget is given by the size of its
608 * contents. Array and stack widths and heights are computed
609 * recursively from these.
610 */
611
612 static void gui_widget_up(int id);
613
614 static void gui_harray_up(int id)
615 {
616 int jd, c = 0;
617
618 /* Find the widest child width and the highest child height. */
619
620 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
621 {
622 gui_widget_up(jd);
623
624 if (widget[id].h < widget[jd].h)
625 widget[id].h = widget[jd].h;
626 if (widget[id].w < widget[jd].w)
627 widget[id].w = widget[jd].w;
628
629 c++;
630 }
631
632 /* Total width is the widest child width times the child count. */
633
634 widget[id].w *= c;
635 }
636
637 static void gui_varray_up(int id)
638 {
639 int jd, c = 0;
640
641 /* Find the widest child width and the highest child height. */
642
643 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
644 {
645 gui_widget_up(jd);
646
647 if (widget[id].h < widget[jd].h)
648 widget[id].h = widget[jd].h;
649 if (widget[id].w < widget[jd].w)
650 widget[id].w = widget[jd].w;
651
652 c++;
653 }
654
655 /* Total height is the highest child height times the child count. */
656
657 widget[id].h *= c;
658 }
659
660 static void gui_hstack_up(int id)
661 {
662 int jd;
663
664 /* Find the highest child height. Sum the child widths. */
665
666 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
667 {
668 gui_widget_up(jd);
669
670 if (widget[id].h < widget[jd].h)
671 widget[id].h = widget[jd].h;
672
673 widget[id].w += widget[jd].w;
674 }
675 }
676
677 static void gui_vstack_up(int id)
678 {
679 int jd;
680
681 /* Find the widest child width. Sum the child heights. */
682
683 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
684 {
685 gui_widget_up(jd);
686
687 if (widget[id].w < widget[jd].w)
688 widget[id].w = widget[jd].w;
689
690 widget[id].h += widget[jd].h;
691 }
692 }
693
694 static void gui_paused_up(int id)
695 {
696 /* Store width and height for later use in text rendering. */
697
698 widget[id].x = widget[id].w;
699 widget[id].y = widget[id].h;
700
701 /* The pause widget fills the screen. */
702
703 widget[id].w = config_get(CONFIG_WIDTH);
704 widget[id].h = config_get(CONFIG_HEIGHT);
705 }
706
707 static void gui_button_up(int id)
708 {
709 /* Store width and height for later use in text rendering. */
710
711 widget[id].x = widget[id].w;
712 widget[id].y = widget[id].h;
713
714 /* Padded text elements look a little nicer. */
715
716 if (widget[id].w < config_get(CONFIG_WIDTH))
717 widget[id].w += radius;
718 if (widget[id].h < config_get(CONFIG_HEIGHT))
719 widget[id].h += radius;
720 }
721
722 static void gui_widget_up(int id)
723 {
724 if (id)
725 switch (widget[id].type)
726 {
727 case GUI_HARRAY: gui_harray_up(id); break;
728 case GUI_VARRAY: gui_varray_up(id); break;
729 case GUI_HSTACK: gui_hstack_up(id); break;
730 case GUI_VSTACK: gui_vstack_up(id); break;
731 case GUI_PAUSE: gui_paused_up(id); break;
732 default: gui_button_up(id); break;
733 }
734 }
735
736 /*---------------------------------------------------------------------------*/
737 /*
738 * The top-down layout pass distributes available area as computed
739 * during the bottom-up pass. Widgets use their area and position to
740 * initialize rendering state.
741 */
742
743 static void gui_widget_dn(int id, int x, int y, int w, int h);
744
745 static void gui_harray_dn(int id, int x, int y, int w, int h)
746 {
747 int jd, i = 0, c = 0;
748
749 widget[id].x = x;
750 widget[id].y = y;
751 widget[id].w = w;
752 widget[id].h = h;
753
754 /* Count children. */
755
756 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
757 c += 1;
758
759 /* Distribute horizontal space evenly to all children. */
760
761 for (jd = widget[id].car; jd; jd = widget[jd].cdr, i++)
762 {
763 int x0 = x + i * w / c;
764 int x1 = x + (i + 1) * w / c;
765
766 gui_widget_dn(jd, x0, y, x1 - x0, h);
767 }
768 }
769
770 static void gui_varray_dn(int id, int x, int y, int w, int h)
771 {
772 int jd, i = 0, c = 0;
773
774 widget[id].x = x;
775 widget[id].y = y;
776 widget[id].w = w;
777 widget[id].h = h;
778
779 /* Count children. */
780
781 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
782 c += 1;
783
784 /* Distribute vertical space evenly to all children. */
785
786 for (jd = widget[id].car; jd; jd = widget[jd].cdr, i++)
787 {
788 int y0 = y + i * h / c;
789 int y1 = y + (i + 1) * h / c;
790
791 gui_widget_dn(jd, x, y0, w, y1 - y0);
792 }
793 }
794
795 static void gui_hstack_dn(int id, int x, int y, int w, int h)
796 {
797 int jd, jx = x, jw = 0, c = 0;
798
799 widget[id].x = x;
800 widget[id].y = y;
801 widget[id].w = w;
802 widget[id].h = h;
803
804 /* Measure the total width requested by non-filler children. */
805
806 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
807 if (widget[jd].type == GUI_FILLER)
808 c += 1;
809 else
810 jw += widget[jd].w;
811
812 /* Give non-filler children their requested space. */
813 /* Distribute the rest evenly among filler children. */
814
815 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
816 {
817 if (widget[jd].type == GUI_FILLER)
818 gui_widget_dn(jd, jx, y, (w - jw) / c, h);
819 else
820 gui_widget_dn(jd, jx, y, widget[jd].w, h);
821
822 jx += widget[jd].w;
823 }
824 }
825
826 static void gui_vstack_dn(int id, int x, int y, int w, int h)
827 {
828 int jd, jy = y, jh = 0, c = 0;
829
830 widget[id].x = x;
831 widget[id].y = y;
832 widget[id].w = w;
833 widget[id].h = h;
834
835 /* Measure the total height requested by non-filler children. */
836
837 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
838 if (widget[jd].type == GUI_FILLER)
839 c += 1;
840 else
841 jh += widget[jd].h;
842
843 /* Give non-filler children their requested space. */
844 /* Distribute the rest evenly among filler children. */
845
846 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
847 {
848 if (widget[jd].type == GUI_FILLER)
849 gui_widget_dn(jd, x, jy, w, (h - jh) / c);
850 else
851 gui_widget_dn(jd, x, jy, w, widget[jd].h);
852
853 jy += widget[jd].h;
854 }
855 }
856
857 static void gui_filler_dn(int id, int x, int y, int w, int h)
858 {
859 /* Filler expands to whatever size it is given. */
860
861 widget[id].x = x;
862 widget[id].y = y;
863 widget[id].w = w;
864 widget[id].h = h;
865 }
866
867 static void gui_button_dn(int id, int x, int y, int w, int h)
868 {
869 /* Recall stored width and height for text rendering. */
870
871 int W = widget[id].x;
872 int H = widget[id].y;
873 int R = widget[id].rect;
874 int r = (widget[id].type == GUI_PAUSE ? radius * 4 : radius);
875
876 const float *c0 = widget[id].color0;
877 const float *c1 = widget[id].color1;
878
879 widget[id].x = x;
880 widget[id].y = y;
881 widget[id].w = w;
882 widget[id].h = h;
883
884 /* Create display lists for the text area and rounded rectangle. */
885
886 widget[id].text_obj = gui_list(-W / 2, -H / 2, W, H, c0, c1);
887 widget[id].rect_obj = gui_rect(-w / 2, -h / 2, w, h, R, r);
888 }
889
890 static void gui_widget_dn(int id, int x, int y, int w, int h)
891 {
892 if (id)
893 switch (widget[id].type)
894 {
895 case GUI_HARRAY: gui_harray_dn(id, x, y, w, h); break;
896 case GUI_VARRAY: gui_varray_dn(id, x, y, w, h); break;
897 case GUI_HSTACK: gui_hstack_dn(id, x, y, w, h); break;
898 case GUI_VSTACK: gui_vstack_dn(id, x, y, w, h); break;
899 case GUI_FILLER: gui_filler_dn(id, x, y, w, h); break;
900 case GUI_SPACE: gui_filler_dn(id, x, y, w, h); break;
901 default: gui_button_dn(id, x, y, w, h); break;
902 }
903 }
904
905 /*---------------------------------------------------------------------------*/
906 /*
907 * During GUI layout, we make a bottom-up pass to determine total area
908 * requirements for the widget tree. We position this area to the
909 * sides or center of the screen. Finally, we make a top-down pass to
910 * distribute this area to each widget.
911 */
912
913 void gui_layout(int id, int xd, int yd)
914 {
915 int x, y;
916
917 int w, W = config_get(CONFIG_WIDTH);
918 int h, H = config_get(CONFIG_HEIGHT);
919
920 gui_widget_up(id);
921
922 w = widget[id].w;
923 h = widget[id].h;
924
925 if (xd < 0) x = 0;
926 else if (xd > 0) x = (W - w);
927 else x = (W - w) / 2;
928
929 if (yd < 0) y = 0;
930 else if (yd > 0) y = (H - h);
931 else y = (H - h) / 2;
932
933 gui_widget_dn(id, x, y, w, h);
934 }
935
936 int gui_search(int id, int x, int y)
937 {
938 int jd, kd;
939
940 /* Search the hierarchy for the widget containing the given point. */
941
942 if (id && (widget[id].x <= x && x < widget[id].x + widget[id].w &&
943 widget[id].y <= y && y < widget[id].y + widget[id].h))
944 {
945 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
946 if ((kd = gui_search(jd, x, y)))
947 return kd;
948
949 if (widget[id].type == GUI_STATE)
950 return id;
951 }
952 return 0;
953 }
954
955 int gui_delete(int id)
956 {
957 if (id)
958 {
959 /* Recursively delete all subwidgets. */
960
961 gui_delete(widget[id].cdr);
962 gui_delete(widget[id].car);
963
964 /* Release any GL resources held by this widget. */
965
966 if (glIsTexture(widget[id].text_img))
967 glDeleteTextures(1, &widget[id].text_img);
968
969 if (glIsList(widget[id].text_obj))
970 glDeleteLists(widget[id].text_obj, 1);
971 if (glIsList(widget[id].rect_obj))
972 glDeleteLists(widget[id].rect_obj, 1);
973
974 /* Mark this widget unused. */
975
976 widget[id].type = GUI_FREE;
977 widget[id].text_img = 0;
978 widget[id].text_obj = 0;
979 widget[id].rect_obj = 0;
980 widget[id].cdr = 0;
981 widget[id].car = 0;
982 }
983 return 0;
984 }
985
986 /*---------------------------------------------------------------------------*/
987
988 static void gui_paint_rect(int id)
989 {
990 static const GLfloat back[4][4] = {
991 { 0.1f, 0.1f, 0.1f, 0.5f }, /* off and inactive */
992 { 0.3f, 0.3f, 0.3f, 0.5f }, /* off and active */
993 { 0.7f, 0.3f, 0.0f, 0.5f }, /* on and inactive */
994 { 1.0f, 0.7f, 0.3f, 0.5f }, /* on and active */
995 };
996
997 int jd;
998
999 switch (widget[id].type)
1000 {
1001 case GUI_IMAGE:
1002 case GUI_SPACE:
1003 case GUI_FILLER:
1004 break;
1005
1006 case GUI_HARRAY:
1007 case GUI_VARRAY:
1008 case GUI_HSTACK:
1009 case GUI_VSTACK:
1010
1011 /* Recursively paint all subwidgets. */
1012
1013 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1014 gui_paint_rect(jd);
1015
1016 break;
1017
1018 default:
1019
1020 /* Draw a leaf's background, colored by widget state. */
1021
1022 glPushMatrix();
1023 {
1024 int i = 0;
1025
1026 if (widget[id].type == GUI_STATE)
1027 i = (((widget[id].value) ? 2 : 0) +
1028 ((id == active) ? 1 : 0));
1029
1030 glTranslatef((GLfloat) (widget[id].x + widget[id].w / 2),
1031 (GLfloat) (widget[id].y + widget[id].h / 2), 0.f);
1032
1033 glColor4fv(back[i]);
1034 glCallList(widget[id].rect_obj);
1035 }
1036 glPopMatrix();
1037
1038 break;
1039 }
1040 }
1041
1042 /*---------------------------------------------------------------------------*/
1043
1044 static void gui_paint_text(int id);
1045
1046 static void gui_paint_array(int id)
1047 {
1048 int jd;
1049
1050 /* Recursively paint all subwidgets. */
1051
1052 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1053 gui_paint_text(jd);
1054 }
1055
1056 static void gui_paint_image(int id)
1057 {
1058 /* Draw the widget rect, textured using the image. */
1059
1060 glPushMatrix();
1061 {
1062 glTranslatef((GLfloat) (widget[id].x + widget[id].w / 2),
1063 (GLfloat) (widget[id].y + widget[id].h / 2), 0.f);
1064
1065 glBindTexture(GL_TEXTURE_2D, widget[id].text_img);
1066 glColor4fv(gui_wht);
1067 glCallList(widget[id].rect_obj);
1068 }
1069 glPopMatrix();
1070 }
1071
1072 static void gui_paint_count(int id)
1073 {
1074 int j, i = widget[id].size;
1075
1076 glPushMatrix();
1077 {
1078 glColor4fv(gui_wht);
1079
1080 /* Translate to the widget center, and apply the pulse scale. */
1081
1082 glTranslatef((GLfloat) (widget[id].x + widget[id].w / 2),
1083 (GLfloat) (widget[id].y + widget[id].h / 2), 0.f);
1084
1085 glScalef(widget[id].scale,
1086 widget[id].scale,
1087 widget[id].scale);
1088
1089 if (widget[id].value)
1090 {
1091 /* Translate left by half the total width of the rendered value. */
1092
1093 for (j = widget[id].value; j; j /= 10)
1094 glTranslatef((GLfloat) +digit_w[i][j % 10] / 2.0f, 0.0f, 0.0f);
1095
1096 glTranslatef((GLfloat) -digit_w[i][0] / 2.0f, 0.0f, 0.0f);
1097
1098 /* Render each digit, moving right after each. */
1099
1100 for (j = widget[id].value; j; j /= 10)
1101 {
1102 glBindTexture(GL_TEXTURE_2D, digit_text[i][j % 10]);
1103 glCallList(digit_list[i][j % 10]);
1104 glTranslatef((GLfloat) -digit_w[i][j % 10], 0.0f, 0.0f);
1105 }
1106 }
1107 else
1108 {
1109 /* If the value is zero, just display a zero in place. */
1110
1111 glBindTexture(GL_TEXTURE_2D, digit_text[i][0]);
1112 glCallList(digit_list[i][0]);
1113 }
1114 }
1115 glPopMatrix();
1116 }
1117
1118 static void gui_paint_clock(int id)
1119 {
1120 int i = widget[id].size;
1121 int mt = (widget[id].value / 6000) / 10;
1122 int mo = (widget[id].value / 6000) % 10;
1123 int st = ((widget[id].value % 6000) / 100) / 10;
1124 int so = ((widget[id].value % 6000) / 100) % 10;
1125 int ht = ((widget[id].value % 6000) % 100) / 10;
1126 int ho = ((widget[id].value % 6000) % 100) % 10;
1127
1128 GLfloat dx_large = (GLfloat) digit_w[i][0];
1129 GLfloat dx_small = (GLfloat) digit_w[i][0] * 0.75f;
1130
1131 glPushMatrix();
1132 {
1133 glColor4fv(gui_wht);
1134
1135 /* Translate to the widget center, and apply the pulse scale. */
1136
1137 glTranslatef((GLfloat) (widget[id].x + widget[id].w / 2),
1138 (GLfloat) (widget[id].y + widget[id].h / 2), 0.f);
1139
1140 glScalef(widget[id].scale,
1141 widget[id].scale,
1142 widget[id].scale);
1143
1144 /* Translate left by half the total width of the rendered value. */
1145
1146 if (mt > 0)
1147 glTranslatef(-2.25f * dx_large, 0.0f, 0.0f);
1148 else
1149 glTranslatef(-1.75f * dx_large, 0.0f, 0.0f);
1150
1151 /* Render the minutes counter. */
1152
1153 if (mt > 0)
1154 {
1155 glBindTexture(GL_TEXTURE_2D, digit_text[i][mt]);
1156 glCallList(digit_list[i][mt]);
1157 glTranslatef(dx_large, 0.0f, 0.0f);
1158 }
1159
1160 glBindTexture(GL_TEXTURE_2D, digit_text[i][mo]);
1161 glCallList(digit_list[i][mo]);
1162 glTranslatef(dx_small, 0.0f, 0.0f);
1163
1164 /* Render the colon. */
1165
1166 glBindTexture(GL_TEXTURE_2D, digit_text[i][10]);
1167 glCallList(digit_list[i][10]);
1168 glTranslatef(dx_small, 0.0f, 0.0f);
1169
1170 /* Render the seconds counter. */
1171
1172 glBindTexture(GL_TEXTURE_2D, digit_text[i][st]);
1173 glCallList(digit_list[i][st]);
1174 glTranslatef(dx_large, 0.0f, 0.0f);
1175
1176 glBindTexture(GL_TEXTURE_2D, digit_text[i][so]);
1177 glCallList(digit_list[i][so]);
1178 glTranslatef(dx_small, 0.0f, 0.0f);
1179
1180 /* Render hundredths counter half size. */
1181
1182 glScalef(0.5f, 0.5f, 1.0f);
1183
1184 glBindTexture(GL_TEXTURE_2D, digit_text[i][ht]);
1185 glCallList(digit_list[i][ht]);
1186 glTranslatef(dx_large, 0.0f, 0.0f);
1187
1188 glBindTexture(GL_TEXTURE_2D, digit_text[i][ho]);
1189 glCallList(digit_list[i][ho]);
1190 }
1191 glPopMatrix();
1192 }
1193
1194 static void gui_paint_label(int id)
1195 {
1196 /* Draw the widget text box, textured using the glyph. */
1197
1198 glPushMatrix();
1199 {
1200 glTranslatef((GLfloat) (widget[id].x + widget[id].w / 2),
1201 (GLfloat) (widget[id].y + widget[id].h / 2), 0.f);
1202
1203 glScalef(widget[id].scale,
1204 widget[id].scale,
1205 widget[id].scale);
1206
1207 glBindTexture(GL_TEXTURE_2D, widget[id].text_img);
1208 glCallList(widget[id].text_obj);
1209 }
1210 glPopMatrix();
1211 }
1212
1213 static void gui_paint_text(int id)
1214 {
1215 switch (widget[id].type)
1216 {
1217 case GUI_SPACE: break;
1218 case GUI_FILLER: break;
1219 case GUI_HARRAY: gui_paint_array(id); break;
1220 case GUI_VARRAY: gui_paint_array(id); break;
1221 case GUI_HSTACK: gui_paint_array(id); break;
1222 case GUI_VSTACK: gui_paint_array(id); break;
1223 case GUI_IMAGE: gui_paint_image(id); break;
1224 case GUI_COUNT: gui_paint_count(id); break;
1225 case GUI_CLOCK: gui_paint_clock(id); break;
1226 default: gui_paint_label(id); break;
1227 }
1228 }
1229
1230 void gui_paint(int id)
1231 {
1232 if (id)
1233 {
1234 glPushAttrib(GL_LIGHTING_BIT);
1235 glPushAttrib(GL_COLOR_BUFFER_BIT);
1236 glPushAttrib(GL_DEPTH_BUFFER_BIT);
1237 config_push_ortho();
1238 {
1239 glEnable(GL_BLEND);
1240 glEnable(GL_COLOR_MATERIAL);
1241 glDisable(GL_LIGHTING);
1242 glDisable(GL_DEPTH_TEST);
1243
1244 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1245
1246 glPushAttrib(GL_TEXTURE_BIT);
1247 {
1248 glDisable(GL_TEXTURE_2D);
1249 gui_paint_rect(id);
1250 }
1251 glPopAttrib();
1252
1253 gui_paint_text(id);
1254 }
1255 config_pop_matrix();
1256 glPopAttrib();
1257 glPopAttrib();
1258 glPopAttrib();
1259 }
1260 }
1261
1262 void gui_blank(void)
1263 {
1264 gui_paint(pause_id);
1265 }
1266
1267 /*---------------------------------------------------------------------------*/
1268
1269 void gui_dump(int id, int d)
1270 {
1271 int jd, i;
1272
1273 if (id)
1274 {
1275 char *type = "?";
1276
1277 switch (widget[id].type)
1278 {
1279 case GUI_HARRAY: type = "harray"; break;
1280 case GUI_VARRAY: type = "varray"; break;
1281 case GUI_HSTACK: type = "hstack"; break;
1282 case GUI_VSTACK: type = "vstack"; break;
1283 case GUI_FILLER: type = "filler"; break;
1284 case GUI_STATE: type = "state"; break;
1285 case GUI_IMAGE: type = "image"; break;
1286 case GUI_LABEL: type = "label"; break;
1287 case GUI_COUNT: type = "count"; break;
1288 case GUI_CLOCK: type = "clock"; break;
1289 }
1290
1291 for (i = 0; i < d; i++)
1292 printf(" ");
1293
1294 printf("%04d %s\n", id, type);
1295
1296 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1297 gui_dump(jd, d + 1);
1298 }
1299 }
1300
1301 void gui_pulse(int id, float k)
1302 {
1303 if (id) widget[id].scale = k;
1304 }
1305
1306 void gui_timer(int id, float dt)
1307 {
1308 int jd;
1309
1310 if (id)
1311 {
1312 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1313 gui_timer(jd, dt);
1314
1315 if (widget[id].scale - 1.0f < dt)
1316 widget[id].scale = 1.0f;
1317 else
1318 widget[id].scale -= dt;
1319 }
1320 }
1321
1322 int gui_point(int id, int x, int y)
1323 {
1324 /* Short-circuit check the current active widget. */
1325
1326 int jd = gui_search(active, x, y);
1327
1328 /* If not still active, search the hierarchy for a new active widget. */
1329
1330 if (jd == 0)
1331 jd = gui_search(id, x, y);
1332
1333 /* If the active widget has changed, return the new active id. */
1334
1335 if (jd == 0 || jd == active)
1336 return 0;
1337 else
1338 return active = jd;
1339 }
1340
1341 int gui_click(void)
1342 {
1343 return active;
1344 }
1345
1346 int gui_token(int id)
1347 {
1348 return id ? widget[id].token : 0;
1349 }
1350
1351 int gui_value(int id)
1352 {
1353 return id ? widget[id].value : 0;
1354 }
1355
1356 void gui_toggle(int id)
1357 {
1358 widget[id].value = widget[id].value ? 0 : 1;
1359 }
1360
1361 /*---------------------------------------------------------------------------*/
1362
1363 static int gui_vert_test(int id, int jd)
1364 {
1365 /* Determine whether widget id is in vertical contact with widget jd. */
1366
1367 if (id && widget[id].type == GUI_STATE &&
1368 jd && widget[jd].type == GUI_STATE)
1369 {
1370 int i0 = widget[id].x;
1371 int i1 = widget[id].x + widget[id].w;
1372 int j0 = widget[jd].x;
1373 int j1 = widget[jd].x + widget[jd].w;
1374
1375 /* Is widget id's top edge is in contact with jd's bottom edge? */
1376
1377 if (widget[id].y + widget[id].h == widget[jd].y)
1378 {
1379 /* Do widgets id and jd overlap horizontally? */
1380
1381 if (j0 <= i0 && i0 < j1) return 1;
1382 if (j0 < i1 && i1 <= j1) return 1;
1383 if (i0 <= j0 && j0 < i1) return 1;
1384 if (i0 < j1 && j1 <= i1) return 1;
1385 }
1386 }
1387 return 0;
1388 }
1389
1390 static int gui_horz_test(int id, int jd)
1391 {
1392 /* Determine whether widget id is in horizontal contact with widget jd. */
1393
1394 if (id && widget[id].type == GUI_STATE &&
1395 jd && widget[jd].type == GUI_STATE)
1396 {
1397 int i0 = widget[id].y;
1398 int i1 = widget[id].y + widget[id].h;
1399 int j0 = widget[jd].y;
1400 int j1 = widget[jd].y + widget[jd].h;
1401
1402 /* Is widget id's right edge in contact with jd's left edge? */
1403
1404 if (widget[id].x + widget[id].w == widget[jd].x)
1405 {
1406 /* Do widgets id and jd overlap vertically? */
1407
1408 if (j0 <= i0 && i0 < j1) return 1;
1409 if (j0 < i1 && i1 <= j1) return 1;
1410 if (i0 <= j0 && j0 < i1) return 1;
1411 if (i0 < j1 && j1 <= i1) return 1;
1412 }
1413 }
1414 return 0;
1415 }
1416
1417 /*---------------------------------------------------------------------------*/
1418
1419 static int gui_stick_L(int id, int dd)
1420 {
1421 int jd, kd;
1422
1423 /* Find a widget to the left of widget dd. */
1424
1425 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1426 if ((kd = gui_stick_L(jd, dd)))
1427 return kd;
1428
1429 return (gui_horz_test(id, dd)) ? id : 0;
1430 }
1431
1432 static int gui_stick_R(int id, int dd)
1433 {
1434 int jd, kd;
1435
1436 /* Find a widget to the right of widget dd. */
1437
1438 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1439 if ((kd = gui_stick_R(jd, dd)))
1440 return kd;
1441
1442 return (gui_horz_test(dd, id)) ? id : 0;
1443 }
1444
1445 static int gui_stick_D(int id, int dd)
1446 {
1447 int jd, kd;
1448
1449 /* Find a widget below widget dd. */
1450
1451 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1452 if ((kd = gui_stick_D(jd, dd)))
1453 return kd;
1454
1455 return (gui_vert_test(id, dd)) ? id : 0;
1456 }
1457
1458 static int gui_stick_U(int id, int dd)
1459 {
1460 int jd, kd;
1461
1462 /* Find a widget above widget dd. */
1463
1464 for (jd = widget[id].car; jd; jd = widget[jd].cdr)
1465 if ((kd = gui_stick_U(jd, dd)))
1466 return kd;
1467
1468 return (gui_vert_test(dd, id)) ? id : 0;
1469 }
1470
1471
1472 int gui_stick(int id, int x, int y)
1473 {
1474 /* Flag the axes to prevent uncontrolled scrolling. */
1475
1476 static int xflag = 1;
1477 static int yflag = 1;
1478
1479 int jd = 0;
1480
1481 /* Find a new active widget in the direction of joystick motion. */
1482
1483 if (-JOY_MID <= x && x <= +JOY_MID)
1484 xflag = 1;
1485 else if (x < -JOY_MID && xflag && (jd = gui_stick_L(id, active)))
1486 xflag = 0;
1487 else if (x > +JOY_MID && xflag && (jd = gui_stick_R(id, active)))
1488 xflag = 0;
1489
1490 if (-JOY_MID <= y && y <= +JOY_MID)
1491 yflag = 1;
1492 else if (y < -JOY_MID && yflag && (jd = gui_stick_U(id, active)))
1493 yflag = 0;
1494 else if (y > +JOY_MID && yflag && (jd = gui_stick_D(id, active)))
1495 yflag = 0;
1496
1497 /* If the active widget has changed, return the new active id. */
1498
1499 if (jd == 0 || jd == active)
1500 return 0;
1501 else
1502 return active = jd;
1503 }
1504
1505 /*---------------------------------------------------------------------------*/
An archive of every Neverball release/snapshot made until 1.4.0