![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to sdlgui.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / gui-sdl|
Return to sdlgui.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / gui-sdl |
1.1 root 1: /*
2: Hatari - sdlgui.c
3:
4: This file is distributed under the GNU Public License, version 2 or at
5: your option any later version. Read the file gpl.txt for details.
6:
7: A tiny graphical user interface for Hatari.
8: */
9: char SDLGui_rcsid[] = "Hatari $Id: sdlgui.c,v 1.6 2004/06/18 18:07:16 thothy Exp $";
10:
11: #include <SDL.h>
12: #include <ctype.h>
13: #include <string.h>
14:
15: #include "main.h"
16: #include "memAlloc.h"
17: #include "screen.h"
18: #include "sdlgui.h"
19:
20: #include "font5x8.h"
21: #include "font10x16.h"
22:
23:
24: static SDL_Surface *pSmallFontGfx = NULL; /* The small font graphics */
25: static SDL_Surface *pBigFontGfx = NULL; /* The big font graphics */
26: static SDL_Surface *fontgfx = NULL; /* The actual font graphics */
27: static int fontwidth, fontheight; /* Width & height of the actual font */
28:
29:
30:
31: /*-----------------------------------------------------------------------*/
32: /*
33: Load an 1 plane XBM into a 8 planes SDL_Surface.
34: */
35: static SDL_Surface *SDLGui_LoadXBM(int w, int h, Uint8 *srcbits)
36: {
37: SDL_Surface *bitmap;
38: Uint8 *dstbits;
39: int x, y, srcpitch;
40: int mask;
41:
42: /* Allocate the bitmap */
43: bitmap = SDL_CreateRGBSurface(SDL_SWSURFACE, w, h, 8, 0, 0, 0, 0);
44: if (bitmap == NULL)
45: {
46: fprintf(stderr, "Couldn't allocate bitmap: %s", SDL_GetError());
47: return(NULL);
48: }
49:
50: srcpitch = ((w + 7) / 8);
51: dstbits = (Uint8 *)bitmap->pixels;
52: mask = 1;
53:
54: /* Copy the pixels */
55: for (y = 0 ; y < h ; y++)
56: {
57: for (x = 0 ; x < w ; x++)
58: {
59: dstbits[x] = (srcbits[x / 8] & mask) ? 1 : 0;
60: mask <<= 1;
61: mask |= (mask >> 8);
62: mask &= 0xFF;
63: }
64: dstbits += bitmap->pitch;
65: srcbits += srcpitch;
66: }
67:
68: return(bitmap);
69: }
70:
71:
72: /*-----------------------------------------------------------------------*/
73: /*
74: Initialize the GUI.
75: */
76: int SDLGui_Init(void)
77: {
78: SDL_Color blackWhiteColors[2] = {{255, 255, 255, 0}, {0, 0, 0, 0}};
79:
80: /* Initialize the font graphics: */
81: pSmallFontGfx = SDLGui_LoadXBM(font5x8_width, font5x8_height, font5x8_bits);
82: pBigFontGfx = SDLGui_LoadXBM(font10x16_width, font10x16_height, font10x16_bits);
83: if (pSmallFontGfx == NULL || pBigFontGfx == NULL)
84: {
85: fprintf(stderr, "Error: Can not init font graphics!\n");
86: return -1;
87: }
88:
89: /* Set color palette of the font graphics: */
90: SDL_SetColors(pSmallFontGfx, blackWhiteColors, 0, 2);
91: SDL_SetColors(pBigFontGfx, blackWhiteColors, 0, 2);
92:
93: /* Set font color 0 as transparent: */
94: SDL_SetColorKey(pSmallFontGfx, (SDL_SRCCOLORKEY|SDL_RLEACCEL), 0);
95: SDL_SetColorKey(pBigFontGfx, (SDL_SRCCOLORKEY|SDL_RLEACCEL), 0);
96:
97: return 0;
98: }
99:
100:
101: /*-----------------------------------------------------------------------*/
102: /*
103: Uninitialize the GUI.
104: */
105: int SDLGui_UnInit(void)
106: {
107: if (pSmallFontGfx)
108: {
109: SDL_FreeSurface(pSmallFontGfx);
110: pSmallFontGfx = NULL;
111: }
112:
113: if (pBigFontGfx)
114: {
115: SDL_FreeSurface(pBigFontGfx);
116: pBigFontGfx = NULL;
117: }
118:
119: return 0;
120: }
121:
122:
123: /*-----------------------------------------------------------------------*/
124: /*
125: Prepare the font to suit the actual resolution.
126: */
127: int SDLGui_PrepareFont(void)
128: {
129: /* Decide which font to use - small or big one: */
130: if (sdlscrn->w >= 640 && sdlscrn->h >= 400 && pBigFontGfx != NULL)
131: {
132: fontgfx = pBigFontGfx;
133: }
134: else
135: {
136: fontgfx = pSmallFontGfx;
137: }
138:
139: if (fontgfx == NULL)
140: {
141: fprintf(stderr, "Error: A problem with the font occured!\n");
142: return -1;
143: }
144:
145: /* Get the font width and height: */
146: fontwidth = fontgfx->w/16;
147: fontheight = fontgfx->h/16;
148:
149: return 0;
150: }
151:
152:
153: /*-----------------------------------------------------------------------*/
154: /*
155: Center a dialog so that it appears in the middle of the screen.
156: Note: We only store the coordinates in the root box of the dialog,
157: all other objects in the dialog are positioned relatively to this one.
158: */
159: void SDLGui_CenterDlg(SGOBJ *dlg)
160: {
161: dlg[0].x = (sdlscrn->w/fontwidth-dlg[0].w)/2;
162: dlg[0].y = (sdlscrn->h/fontheight-dlg[0].h)/2;
163: }
164:
165:
166: /*-----------------------------------------------------------------------*/
167: /*
168: Draw a text string.
169: */
170: static void SDLGui_Text(int x, int y, const char *txt)
171: {
172: int i;
173: char c;
174: SDL_Rect sr, dr;
175:
176: for(i=0; txt[i]!=0; i++)
177: {
178: c = txt[i];
179: sr.x=fontwidth*(c%16); sr.y=fontheight*(c/16);
180: sr.w=fontwidth; sr.h=fontheight;
181: dr.x=x+i*fontwidth; dr.y=y;
182: dr.w=fontwidth; dr.h=fontheight;
183: SDL_BlitSurface(fontgfx, &sr, sdlscrn, &dr);
184: }
185: }
186:
187:
188: /*-----------------------------------------------------------------------*/
189: /*
190: Draw a dialog text object.
191: */
192: static void SDLGui_DrawText(SGOBJ *tdlg, int objnum)
193: {
194: int x, y;
195: x = (tdlg[0].x+tdlg[objnum].x)*fontwidth;
196: y = (tdlg[0].y+tdlg[objnum].y)*fontheight;
197: SDLGui_Text(x, y, tdlg[objnum].txt);
198: }
199:
200:
201: /*-----------------------------------------------------------------------*/
202: /*
203: Draw a edit field object.
204: */
205: static void SDLGui_DrawEditField(SGOBJ *edlg, int objnum)
206: {
207: int x, y;
208: SDL_Rect rect;
209:
210: x = (edlg[0].x+edlg[objnum].x)*fontwidth;
211: y = (edlg[0].y+edlg[objnum].y)*fontheight;
212: SDLGui_Text(x, y, edlg[objnum].txt);
213:
214: rect.x = x; rect.y = y + edlg[objnum].h * fontheight;
215: rect.w = edlg[objnum].w * fontwidth; rect.h = 1;
216: SDL_FillRect(sdlscrn, &rect, SDL_MapRGB(sdlscrn->format,160,160,160));
217: }
218:
219:
220: /*-----------------------------------------------------------------------*/
221: /*
222: Draw a dialog box object.
223: */
224: static void SDLGui_DrawBox(SGOBJ *bdlg, int objnum)
225: {
226: SDL_Rect rect;
227: int x, y, w, h, offset;
228: Uint32 grey = SDL_MapRGB(sdlscrn->format,192,192,192);
229: Uint32 upleftc, downrightc;
230:
231: x = bdlg[objnum].x*fontwidth;
232: y = bdlg[objnum].y*fontheight;
233: if(objnum>0) /* Since the root object is a box, too, */
234: { /* we have to look for it now here and only */
235: x += bdlg[0].x*fontwidth; /* add its absolute coordinates if we need to */
236: y += bdlg[0].y*fontheight;
237: }
238: w = bdlg[objnum].w*fontwidth;
239: h = bdlg[objnum].h*fontheight;
240:
241: if( bdlg[objnum].state&SG_SELECTED )
242: {
243: upleftc = SDL_MapRGB(sdlscrn->format,128,128,128);
244: downrightc = SDL_MapRGB(sdlscrn->format,255,255,255);
245: }
246: else
247: {
248: upleftc = SDL_MapRGB(sdlscrn->format,255,255,255);
249: downrightc = SDL_MapRGB(sdlscrn->format,128,128,128);
250: }
251:
252: /* The root box should be bigger than the screen, so we disable the offset there: */
253: if (objnum != 0)
254: offset = 1;
255: else
256: offset = 0;
257:
258: /* Draw background: */
259: rect.x = x; rect.y = y;
260: rect.w = w; rect.h = h;
261: SDL_FillRect(sdlscrn, &rect, grey);
262:
263: /* Draw upper border: */
264: rect.x = x; rect.y = y - offset;
265: rect.w = w; rect.h = 1;
266: SDL_FillRect(sdlscrn, &rect, upleftc);
267:
268: /* Draw left border: */
269: rect.x = x - offset; rect.y = y;
270: rect.w = 1; rect.h = h;
271: SDL_FillRect(sdlscrn, &rect, upleftc);
272:
273: /* Draw bottom border: */
274: rect.x = x; rect.y = y + h - 1 + offset;
275: rect.w = w; rect.h = 1;
276: SDL_FillRect(sdlscrn, &rect, downrightc);
277:
278: /* Draw right border: */
279: rect.x = x + w - 1 + offset; rect.y = y;
280: rect.w = 1; rect.h = h;
281: SDL_FillRect(sdlscrn, &rect, downrightc);
282: }
283:
284:
285: /*-----------------------------------------------------------------------*/
286: /*
287: Draw a normal button.
288: */
289: static void SDLGui_DrawButton(SGOBJ *bdlg, int objnum)
290: {
291: int x,y;
292:
293: SDLGui_DrawBox(bdlg, objnum);
294:
295: x = (bdlg[0].x+bdlg[objnum].x+(bdlg[objnum].w-strlen(bdlg[objnum].txt))/2)*fontwidth;
296: y = (bdlg[0].y+bdlg[objnum].y+(bdlg[objnum].h-1)/2)*fontheight;
297:
298: if( bdlg[objnum].state&SG_SELECTED )
299: {
300: x+=1;
301: y+=1;
302: }
303: SDLGui_Text(x, y, bdlg[objnum].txt);
304: }
305:
306:
307: /*-----------------------------------------------------------------------*/
308: /*
309: Draw a dialog radio button object.
310: */
311: static void SDLGui_DrawRadioButton(SGOBJ *rdlg, int objnum)
312: {
313: char str[80];
314: int x, y;
315:
316: x = (rdlg[0].x+rdlg[objnum].x)*fontwidth;
317: y = (rdlg[0].y+rdlg[objnum].y)*fontheight;
318:
319: if( rdlg[objnum].state&SG_SELECTED )
320: str[0]=SGRADIOBUTTON_SELECTED;
321: else
322: str[0]=SGRADIOBUTTON_NORMAL;
323: str[1]=' ';
324: strcpy(&str[2], rdlg[objnum].txt);
325:
326: SDLGui_Text(x, y, str);
327: }
328:
329:
330: /*-----------------------------------------------------------------------*/
331: /*
332: Draw a dialog check box object.
333: */
334: static void SDLGui_DrawCheckBox(SGOBJ *cdlg, int objnum)
335: {
336: char str[80];
337: int x, y;
338:
339: x = (cdlg[0].x+cdlg[objnum].x)*fontwidth;
340: y = (cdlg[0].y+cdlg[objnum].y)*fontheight;
341:
342: if( cdlg[objnum].state&SG_SELECTED )
343: str[0]=SGCHECKBOX_SELECTED;
344: else
345: str[0]=SGCHECKBOX_NORMAL;
346: str[1]=' ';
347: strcpy(&str[2], cdlg[objnum].txt);
348:
349: SDLGui_Text(x, y, str);
350: }
351:
352:
353: /*-----------------------------------------------------------------------*/
354: /*
355: Draw a dialog popup button object.
356: */
357: static void SDLGui_DrawPopupButton(SGOBJ *pdlg, int objnum)
358: {
359: int x, y, w, h;
360: const char *downstr = "\x02";
361:
362: SDLGui_DrawBox(pdlg, objnum);
363:
364: x = (pdlg[0].x+pdlg[objnum].x)*fontwidth;
365: y = (pdlg[0].y+pdlg[objnum].y)*fontheight;
366: w = pdlg[objnum].w*fontwidth;
367: h = pdlg[objnum].h*fontheight;
368:
369: SDLGui_Text(x, y, pdlg[objnum].txt);
370: SDLGui_Text(x+w-fontwidth, y, downstr);
371: }
372:
373:
374: /*-----------------------------------------------------------------------*/
375: /*
376: Let the user insert text into an edit field object.
377: NOTE: The dlg[objnum].txt must point to an an array that is big enough
378: for dlg[objnum].w characters!
379: */
380: static void SDLGui_EditField(SGOBJ *dlg, int objnum)
381: {
382: int cursorPos; /* Position of the cursor in the edit field */
383: int blinkState = 0; /* Used for cursor blinking */
384: BOOL bStopEditing = FALSE; /* TRUE if user wants to exit the edit field */
385: char *txt; /* Shortcut for dlg[objnum].txt */
386: SDL_Rect rect;
387: Uint32 grey, cursorCol;
388: SDL_Event event;
389:
390: grey = SDL_MapRGB(sdlscrn->format,192,192,192);
391: cursorCol = SDL_MapRGB(sdlscrn->format,128,128,128);
392:
393: rect.x = (dlg[0].x + dlg[objnum].x) * fontwidth;
394: rect.y = (dlg[0].y + dlg[objnum].y) * fontheight;
395: rect.w = (dlg[objnum].w + 1) * fontwidth - 1;
396: rect.h = dlg[objnum].h * fontheight;
397:
398: txt = dlg[objnum].txt;
399: cursorPos = strlen(txt);
400:
401: do
402: {
403: /* Look for events */
404: if(SDL_PollEvent(&event) == 0)
405: {
406: /* No event: Wait some time for cursor blinking */
407: SDL_Delay(250);
408: blinkState ^= 1;
409: }
410: else
411: {
412: int keysym;
413:
414: /* Handle events */
415: do
416: {
417: switch(event.type)
418: {
419: case SDL_QUIT: /* User wants to quit */
420: bQuitProgram = TRUE;
421: bStopEditing = TRUE;
422: break;
423: case SDL_MOUSEBUTTONDOWN: /* Mouse pressed -> stop editing */
424: bStopEditing = TRUE;
425: break;
426: case SDL_KEYDOWN: /* Key pressed */
427: keysym = event.key.keysym.sym;
428: switch(keysym)
429: {
430: case SDLK_RETURN:
431: case SDLK_KP_ENTER:
432: bStopEditing = TRUE;
433: break;
434: case SDLK_LEFT:
435: if(cursorPos > 0)
436: cursorPos -= 1;
437: break;
438: case SDLK_RIGHT:
439: if(cursorPos < strlen(txt))
440: cursorPos += 1;
441: break;
442: case SDLK_BACKSPACE:
443: if(cursorPos > 0)
444: {
445: memmove(&txt[cursorPos-1], &txt[cursorPos], strlen(&txt[cursorPos])+1);
446: cursorPos -= 1;
447: }
448: break;
449: case SDLK_DELETE:
450: if(cursorPos < strlen(txt))
451: memmove(&txt[cursorPos], &txt[cursorPos+1], strlen(&txt[cursorPos+1])+1);
452: break;
453: default:
454: /* If it is a "good" key then insert it into the text field */
455: if(keysym >= 32 && keysym < 256)
456: {
457: if(strlen(txt) < dlg[objnum].w)
458: {
459: memmove(&txt[cursorPos+1], &txt[cursorPos], strlen(&txt[cursorPos])+1);
460: if(event.key.keysym.mod & (KMOD_LSHIFT|KMOD_RSHIFT))
461: txt[cursorPos] = toupper(keysym);
462: else
463: txt[cursorPos] = keysym;
464: cursorPos += 1;
465: }
466: }
467: break;
468: }
469: break;
470: }
471: }
472: while(SDL_PollEvent(&event));
473:
474: blinkState = 1;
475: }
476:
477: /* Redraw the text field: */
478: SDL_FillRect(sdlscrn, &rect, grey); /* Draw background */
479: /* Draw the cursor: */
480: if(blinkState && !bStopEditing)
481: {
482: SDL_Rect cursorrect;
483: cursorrect.x = rect.x + cursorPos * fontwidth; cursorrect.y = rect.y;
484: cursorrect.w = fontwidth; cursorrect.h = rect.h;
485: SDL_FillRect(sdlscrn, &cursorrect, cursorCol);
486: }
487: SDLGui_Text(rect.x, rect.y, dlg[objnum].txt); /* Draw text */
488: SDL_UpdateRects(sdlscrn, 1, &rect);
489: }
490: while(!bStopEditing);
491: }
492:
493:
494: /*-----------------------------------------------------------------------*/
495: /*
496: Draw a whole dialog.
497: */
498: static void SDLGui_DrawDialog(SGOBJ *dlg)
499: {
500: int i;
501: for(i=0; dlg[i].type!=-1; i++ )
502: {
503: switch( dlg[i].type )
504: {
505: case SGBOX:
506: SDLGui_DrawBox(dlg, i);
507: break;
508: case SGTEXT:
509: SDLGui_DrawText(dlg, i);
510: break;
511: case SGEDITFIELD:
512: SDLGui_DrawEditField(dlg, i);
513: break;
514: case SGBUTTON:
515: SDLGui_DrawButton(dlg, i);
516: break;
517: case SGRADIOBUT:
518: SDLGui_DrawRadioButton(dlg, i);
519: break;
520: case SGCHECKBOX:
521: SDLGui_DrawCheckBox(dlg, i);
522: break;
523: case SGPOPUP:
524: SDLGui_DrawPopupButton(dlg, i);
525: break;
526: }
527: }
528: SDL_UpdateRect(sdlscrn, 0,0,0,0);
529: }
530:
531:
532: /*-----------------------------------------------------------------------*/
533: /*
534: Search an object at a certain position.
535: */
536: static int SDLGui_FindObj(SGOBJ *dlg, int fx, int fy)
537: {
538: int len, i;
539: int ob = -1;
540: int xpos, ypos;
541:
542: len = 0;
543: while( dlg[len].type!=-1) len++;
544:
545: xpos = fx/fontwidth;
546: ypos = fy/fontheight;
547: /* Now search for the object: */
548: for(i=len; i>0; i--)
549: {
550: if(xpos>=dlg[0].x+dlg[i].x && ypos>=dlg[0].y+dlg[i].y
551: && xpos<dlg[0].x+dlg[i].x+dlg[i].w && ypos<dlg[0].y+dlg[i].y+dlg[i].h)
552: {
553: ob = i;
554: break;
555: }
556: }
557:
558: return ob;
559: }
560:
561:
562: /*-----------------------------------------------------------------------*/
563: /*
564: Show and process a dialog. Returns the button number that has been
565: pressed or -1 if something went wrong.
566: */
567: int SDLGui_DoDialog(SGOBJ *dlg)
568: {
569: int obj=0;
570: int oldbutton=0;
571: int retbutton=0;
572: int i, j, b;
573: SDL_Event evnt;
574: SDL_Rect rct;
575: Uint32 grey;
576: SDL_Surface *pBgSurface;
577: SDL_Rect dlgrect, bgrect;
578:
579: grey = SDL_MapRGB(sdlscrn->format,192,192,192);
580:
581: dlgrect.x = dlg[0].x * fontwidth;
582: dlgrect.y = dlg[0].y * fontheight;
583: dlgrect.w = dlg[0].w * fontwidth;
584: dlgrect.h = dlg[0].h * fontheight;
585:
586: bgrect.x = bgrect.y = 0;
587: bgrect.w = dlgrect.w;
588: bgrect.h = dlgrect.h;
589:
590: /* Save background */
591: pBgSurface = SDL_CreateRGBSurface(SDL_SWSURFACE, dlgrect.w, dlgrect.h, sdlscrn->format->BitsPerPixel,
592: sdlscrn->format->Rmask, sdlscrn->format->Gmask, sdlscrn->format->Bmask, sdlscrn->format->Amask);
593: if (sdlscrn->format->palette != NULL)
594: {
595: SDL_SetColors(pBgSurface, sdlscrn->format->palette->colors, 0, sdlscrn->format->palette->ncolors-1);
596: }
597:
598: if (pBgSurface != NULL)
599: {
600: SDL_BlitSurface(sdlscrn, &dlgrect, pBgSurface, &bgrect);
601: }
602: else
603: {
604: fprintf(stderr, "SDLGUI_DoDialog: CreateRGBSurface failed: %s\n", SDL_GetError());
605: }
606:
607: /* (Re-)draw the dialog */
608: SDLGui_DrawDialog(dlg);
609:
610: /* Is the left mouse button still pressed? Yes -> Handle TOUCHEXIT objects here */
611: SDL_PumpEvents();
612: b = SDL_GetMouseState(&i, &j);
613: obj = SDLGui_FindObj(dlg, i, j);
614: if(obj>0 && (dlg[obj].flags&SG_TOUCHEXIT) )
615: {
616: oldbutton = obj;
617: if( b&SDL_BUTTON(1) )
618: {
619: dlg[obj].state |= SG_SELECTED;
620: retbutton = obj;
621: }
622: }
623:
624: /* The main loop */
625: while(retbutton==0 && !bQuitProgram)
626: {
627: if( SDL_WaitEvent(&evnt)==1 ) /* Wait for events */
628: switch(evnt.type)
629: {
630: case SDL_KEYDOWN:
631: break;
632: case SDL_QUIT:
633: bQuitProgram = TRUE;
634: break;
635: case SDL_MOUSEBUTTONDOWN:
636: obj = SDLGui_FindObj(dlg, evnt.button.x, evnt.button.y);
637: if(obj>0)
638: {
639: if(dlg[obj].type==SGBUTTON)
640: {
641: dlg[obj].state |= SG_SELECTED;
642: SDLGui_DrawButton(dlg, obj);
643: SDL_UpdateRect(sdlscrn, (dlg[0].x+dlg[obj].x)*fontwidth-2, (dlg[0].y+dlg[obj].y)*fontheight-2,
644: dlg[obj].w*fontwidth+4, dlg[obj].h*fontheight+4);
645: oldbutton=obj;
646: }
647: if( dlg[obj].flags&SG_TOUCHEXIT )
648: {
649: dlg[obj].state |= SG_SELECTED;
650: retbutton = obj;
651: }
652: }
653: break;
654: case SDL_MOUSEBUTTONUP:
655: obj = SDLGui_FindObj(dlg, evnt.button.x, evnt.button.y);
656: if(obj>0)
657: {
658: switch(dlg[obj].type)
659: {
660: case SGBUTTON:
661: if(oldbutton==obj)
662: retbutton=obj;
663: break;
664: case SGEDITFIELD:
665: SDLGui_EditField(dlg, obj);
666: break;
667: case SGRADIOBUT:
668: for(i=obj-1; i>0 && dlg[i].type==SGRADIOBUT; i--)
669: {
670: dlg[i].state &= ~SG_SELECTED; /* Deselect all radio buttons in this group */
671: rct.x = (dlg[0].x+dlg[i].x)*fontwidth;
672: rct.y = (dlg[0].y+dlg[i].y)*fontheight;
673: rct.w = fontwidth; rct.h = fontheight;
674: SDL_FillRect(sdlscrn, &rct, grey); /* Clear old */
675: SDLGui_DrawRadioButton(dlg, i);
676: SDL_UpdateRects(sdlscrn, 1, &rct);
677: }
678: for(i=obj+1; dlg[i].type==SGRADIOBUT; i++)
679: {
680: dlg[i].state &= ~SG_SELECTED; /* Deselect all radio buttons in this group */
681: rct.x = (dlg[0].x+dlg[i].x)*fontwidth;
682: rct.y = (dlg[0].y+dlg[i].y)*fontheight;
683: rct.w = fontwidth; rct.h = fontheight;
684: SDL_FillRect(sdlscrn, &rct, grey); /* Clear old */
685: SDLGui_DrawRadioButton(dlg, i);
686: SDL_UpdateRects(sdlscrn, 1, &rct);
687: }
688: dlg[obj].state |= SG_SELECTED; /* Select this radio button */
689: rct.x = (dlg[0].x+dlg[obj].x)*fontwidth;
690: rct.y = (dlg[0].y+dlg[obj].y)*fontheight;
691: rct.w = fontwidth; rct.h = fontheight;
692: SDL_FillRect(sdlscrn, &rct, grey); /* Clear old */
693: SDLGui_DrawRadioButton(dlg, obj);
694: SDL_UpdateRects(sdlscrn, 1, &rct);
695: break;
696: case SGCHECKBOX:
697: dlg[obj].state ^= SG_SELECTED;
698: rct.x = (dlg[0].x+dlg[obj].x)*fontwidth;
699: rct.y = (dlg[0].y+dlg[obj].y)*fontheight;
700: rct.w = fontwidth; rct.h = fontheight;
701: SDL_FillRect(sdlscrn, &rct, grey); /* Clear old */
702: SDLGui_DrawCheckBox(dlg, obj);
703: SDL_UpdateRects(sdlscrn, 1, &rct);
704: break;
705: case SGPOPUP:
706: dlg[obj].state |= SG_SELECTED;
707: SDLGui_DrawPopupButton(dlg, obj);
708: SDL_UpdateRect(sdlscrn, (dlg[0].x+dlg[obj].x)*fontwidth-2, (dlg[0].y+dlg[obj].y)*fontheight-2,
709: dlg[obj].w*fontwidth+4, dlg[obj].h*fontheight+4);
710: retbutton=obj;
711: break;
712: }
713: }
714: if(oldbutton>0)
715: {
716: dlg[oldbutton].state &= ~SG_SELECTED;
717: SDLGui_DrawButton(dlg, oldbutton);
718: SDL_UpdateRect(sdlscrn, (dlg[0].x+dlg[oldbutton].x)*fontwidth-2, (dlg[0].y+dlg[oldbutton].y)*fontheight-2,
719: dlg[oldbutton].w*fontwidth+4, dlg[oldbutton].h*fontheight+4);
720: oldbutton = 0;
721: }
722: if( dlg[obj].flags&SG_EXIT )
723: {
724: retbutton = obj;
725: }
726: break;
727: }
728: }
729:
730: /* Restore background */
731: if (pBgSurface)
732: {
733: SDL_BlitSurface(pBgSurface, &bgrect, sdlscrn, &dlgrect);
734: SDL_FreeSurface(pBgSurface);
735: }
736:
737: if(bQuitProgram)
738: retbutton = -1;
739:
740: return retbutton;
741: }
742:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.