]> git.mxchange.org Git - flightgear.git/blob - src/Main/fg_os_sdl.cxx
Fix a misuse of a return value that lead to an error message being displayed
[flightgear.git] / src / Main / fg_os_sdl.cxx
1 #include <stdlib.h>
2
3 #include <simgear/compiler.h>
4 #include <simgear/structure/exception.hxx>
5 #include <simgear/debug/logstream.hxx>
6
7 #include <SDL/SDL.h>
8 #include <plib/pu.h>
9
10 #include "fg_os.hxx"
11
12 //
13 // fg_os callback registration APIs
14 //
15
16 static fgIdleHandler IdleHandler = 0;
17 static fgDrawHandler DrawHandler = 0;
18 static fgWindowResizeHandler WindowResizeHandler = 0;
19 static fgKeyHandler KeyHandler = 0;
20 static fgMouseClickHandler MouseClickHandler = 0;
21 static fgMouseMotionHandler MouseMotionHandler = 0;
22
23 static int CurrentModifiers = 0;
24 static int CurrentMouseX = 0;
25 static int CurrentMouseY = 0;
26 static int CurrentMouseCursor = MOUSE_CURSOR_POINTER;
27 static bool NeedRedraw = false;
28 static int VidMask = SDL_OPENGL|SDL_RESIZABLE;
29
30 void fgRegisterIdleHandler(fgIdleHandler func)
31 {
32     IdleHandler = func;
33 }
34
35 void fgRegisterDrawHandler(fgDrawHandler func)
36 {
37     DrawHandler = func;
38     NeedRedraw = true;
39 }
40
41 void fgRegisterWindowResizeHandler(fgWindowResizeHandler func)
42 {
43     WindowResizeHandler = func;
44 }
45
46 void fgRegisterKeyHandler(fgKeyHandler func)
47 {
48     KeyHandler = func;
49 }
50
51 void fgRegisterMouseClickHandler(fgMouseClickHandler func)
52 {
53     MouseClickHandler = func;
54 }
55
56 void fgRegisterMouseMotionHandler(fgMouseMotionHandler func)
57 {
58     MouseMotionHandler = func;
59 }
60
61 //
62 // fg_os implementation
63 //
64 static void initCursors();
65
66 void fgOSOpenWindow(int w, int h, int bpp,
67                     bool alpha, bool stencil, bool fullscreen)
68 {
69     int cbits = (bpp <= 16) ?  5 :  8;
70     int zbits = (bpp <= 16) ? 16 : 24;
71
72     if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_NOPARACHUTE) == -1)
73         throw sg_throwable(string("Failed to initialize SDL: ")
74                            + SDL_GetError());
75     atexit(SDL_Quit);
76
77     SDL_WM_SetCaption("FlightGear", "FlightGear");
78
79     SDL_GL_SetAttribute(SDL_GL_RED_SIZE, cbits);
80     SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, cbits);
81     SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, cbits);
82     if(alpha)
83         SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
84     if(bpp > 16 && stencil)
85         SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
86     SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, zbits);
87     SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
88
89     if(fullscreen) {
90         VidMask |= SDL_FULLSCREEN;
91     }
92     if (SDL_SetVideoMode(w, h, 16, VidMask) == 0)
93         throw sg_throwable(string("Failed to set SDL video mode: ")
94                                    + SDL_GetError());
95
96     // This enables keycode translation (e.g. capital letters when
97     // shift is pressed, as well as i18n input methods).  Eventually,
98     // we may want to port the input maps to specify <mod-shift>
99     // explicitly, and will turn this off.
100     SDL_EnableUNICODE(1);
101     SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL);
102
103     initCursors();
104     fgSetMouseCursor(MOUSE_CURSOR_POINTER);
105
106     // FIXME: we may not get what we asked for (especially in full
107     // screen modes), so these need to be propagated back to the
108     // property tree for the rest of the code to inspect...
109     //
110     // SDL_Surface* screen = SDL_GetVideoSurface();
111     // int realw = screen->w;
112     // int realh = screen->h;
113 }
114
115 static void handleKey(int key, int raw, int keyup)
116 {
117     int modmask = 0;
118     switch(key) {
119     case SDLK_RSHIFT: modmask = KEYMOD_SHIFT; break;
120     case SDLK_LSHIFT: modmask = KEYMOD_SHIFT; break;
121     case SDLK_RCTRL:  modmask = KEYMOD_CTRL;  break;
122     case SDLK_LCTRL:  modmask = KEYMOD_CTRL;  break;
123     case SDLK_RALT:   modmask = KEYMOD_ALT;   break;
124     case SDLK_LALT:   modmask = KEYMOD_ALT;   break;
125
126     case SDLK_LEFT:     key = PU_KEY_LEFT;      break;
127     case SDLK_UP:       key = PU_KEY_UP;        break;
128     case SDLK_RIGHT:    key = PU_KEY_RIGHT;     break;
129     case SDLK_DOWN:     key = PU_KEY_DOWN;      break;
130     case SDLK_PAGEUP:   key = PU_KEY_PAGE_UP;   break;
131     case SDLK_PAGEDOWN: key = PU_KEY_PAGE_DOWN; break;
132     case SDLK_HOME:     key = PU_KEY_HOME;      break;
133     case SDLK_END:      key = PU_KEY_END;       break;
134     case SDLK_INSERT:   key = PU_KEY_INSERT;    break;
135     case SDLK_F1:       key = PU_KEY_F1;        break;
136     case SDLK_F2:       key = PU_KEY_F2;        break;
137     case SDLK_F3:       key = PU_KEY_F3;        break;
138     case SDLK_F4:       key = PU_KEY_F4;        break;
139     case SDLK_F5:       key = PU_KEY_F5;        break;
140     case SDLK_F6:       key = PU_KEY_F6;        break;
141     case SDLK_F7:       key = PU_KEY_F7;        break;
142     case SDLK_F8:       key = PU_KEY_F8;        break;
143     case SDLK_F9:       key = PU_KEY_F9;        break;
144     case SDLK_F10:      key = PU_KEY_F10;       break;
145     case SDLK_F11:      key = PU_KEY_F11;       break;
146     case SDLK_F12:      key = PU_KEY_F12;       break;
147     }
148
149     // Keypad codes.  This is a situation where we *don't* want the
150     // Unicode cooking for our input.  Oddly, neither PUI nor Glut
151     // define these anywhere, so I lifted the numbers out of
152     // FlightGear's keyboard.xml.  Some unused code are therefore
153     // missing.
154     switch(raw) {
155     case SDLK_KP0:      key = 364; break;
156     case SDLK_KP1:      key = 363; break;
157     case SDLK_KP2:      key = 359; break;
158     case SDLK_KP3:      key = 361; break;
159     case SDLK_KP4:      key = 356; break;
160     case SDLK_KP5:      key = 309; break;
161     case SDLK_KP6:      key = 358; break;
162     case SDLK_KP7:      key = 362; break;
163     case SDLK_KP8:      key = 357; break;
164     case SDLK_KP9:      key = 360; break;
165     case SDLK_KP_ENTER: key = 269; break;
166     }
167
168     int keymod = 0;
169     if(keyup) {
170         CurrentModifiers &= ~modmask;
171         keymod = CurrentModifiers | KEYMOD_RELEASED;
172     } else {
173         CurrentModifiers |= modmask;
174         keymod = CurrentModifiers & ~KEYMOD_RELEASED;
175     }
176     if(modmask == 0 && KeyHandler)
177         (*KeyHandler)(key, keymod, CurrentMouseX, CurrentMouseY);
178 }
179
180 // FIXME: Integrate with existing fgExit() in util.cxx.
181 void fgOSExit(int code)
182 {
183     exit(code);
184 }
185
186 void fgOSMainLoop()
187 {
188     while(1) {
189         SDL_Event e;
190         int key;
191         while(SDL_PollEvent(&e)) {
192             switch(e.type) {
193             case SDL_QUIT:
194                 fgOSExit(0);
195                 break;
196             case SDL_KEYDOWN:
197             case SDL_KEYUP:
198                 key = e.key.keysym.unicode;
199                 if(key == 0) key = e.key.keysym.sym;
200                 handleKey(key, e.key.keysym.sym, e.key.state == SDL_RELEASED);
201                 break;
202             case SDL_MOUSEBUTTONDOWN:
203             case SDL_MOUSEBUTTONUP:
204                 // Note offset: SDL uses buttons 1,2,3 not 0,1,2
205                 CurrentMouseX = e.button.x;
206                 CurrentMouseY = e.button.y;
207                 if(MouseClickHandler)
208                     (*MouseClickHandler)(e.button.button - 1,
209                                          e.button.state == SDL_RELEASED,
210                                          e.button.x, e.button.y);
211                 break;
212             case SDL_MOUSEMOTION:
213                 CurrentMouseX = e.motion.x;
214                 CurrentMouseY = e.motion.y;
215                 if(MouseMotionHandler)
216                     (*MouseMotionHandler)(e.motion.x, e.motion.y);
217                 break;
218             case SDL_VIDEORESIZE:
219                 if (SDL_SetVideoMode(e.resize.w, e.resize.h, 16, VidMask) == 0)
220                     throw sg_throwable(string("Failed to set SDL video mode: ")
221                             + SDL_GetError());
222
223                 if (WindowResizeHandler)
224                     (*WindowResizeHandler)(e.resize.w, e.resize.h);
225                 break;
226             }
227         }
228         if(IdleHandler) (*IdleHandler)();
229         if(NeedRedraw && DrawHandler) {
230             (*DrawHandler)();
231             SDL_GL_SwapBuffers();
232             NeedRedraw = false;
233         }
234     }
235 }
236
237 int fgGetKeyModifiers()
238 {
239     return CurrentModifiers;
240 }
241
242 void fgWarpMouse(int x, int y)
243 {
244     SDL_WarpMouse(x, y);
245 }
246
247 void fgRequestRedraw()
248 {
249     NeedRedraw = true;
250 }
251
252 void fgOSInit(int* argc, char** argv)
253 {
254     // Nothing to do here.  SDL has no command line options.
255 }
256
257 void fgOSFullScreen()
258 {
259     // Noop.  SDL must set fullscreen at window open time and cannot
260     // change modes.
261 }
262
263 static struct cursor_rec {
264     int name;
265     SDL_Cursor* sdlCursor;
266     int w;
267     int h;
268     int hotx;
269     int hoty;
270     char *img[32]; // '.' == white, '#' == black, ' ' == transparent
271 } cursors[] = {
272     { MOUSE_CURSOR_POINTER, 0, // must be first!
273       10, 16, 1, 1,
274       { "..        ",
275         ".#.       ",
276         ".##.      ",
277         ".###.     ",
278         ".####.    ",
279         ".#####.   ",
280         ".######.  ",
281         ".#######. ",
282         ".########.",
283         ".#####....",
284         ".##.##.   ",
285         ".#. .##.  ",
286         "..  .##.  ",
287         "     .##. ",
288         "     .##. ",
289         "      ..  " } },
290     { MOUSE_CURSOR_CROSSHAIR, 0,
291       17, 17, 8, 8,
292       { "       ...       ",
293         "       .#.       ",
294         "       .#.       ",
295         "       .#.       ",
296         "       .#.       ",
297         "       .#.       ",
298         "       .#.       ",
299         "........#........",
300         ".#######.#######.",
301         "........#........",
302         "       .#.       ",
303         "       .#.       ",
304         "       .#.       ",
305         "       .#.       ",
306         "       .#.       ",
307         "       .#.       ",
308         "       ...       " } },
309     { MOUSE_CURSOR_WAIT, 0,
310       16, 16, 7, 7,
311       { "  .########.    ",
312         "  .########.    ",
313         "  .########.    ",
314         " .##########.   ",
315         ".##....#...##.  ",
316         "##.....#....##..",
317         "#......#.....###",
318         "#.....###....###",
319         "#.....###....###",
320         "#....#.......###",
321         "##..#.......##..",
322         ".##........##.  ",
323         " .##########.   ",
324         "  .########.    ",
325         "  .########.    ",
326         "  .########.    " } },
327     { MOUSE_CURSOR_LEFTRIGHT, 0,
328       17, 9, 8, 4,
329       { "    ..     ..    ",
330         "   .#.     .#.   ",
331         "  .##.......##.  ",
332         " .#############. ",
333         ".####.......####.",
334         " .#############. ",
335         "  .##.......##.  ",
336         "   .#.     .#.   ",
337         "    ..     ..    " } },
338     { MOUSE_CURSOR_NONE, 0, // must come last!
339       1, 1, 0, 0, { " " } },
340 };
341
342 #define NCURSORS (sizeof(cursors)/sizeof(struct cursor_rec))
343
344 void fgSetMouseCursor(int cursor)
345 {
346     if(cursor == MOUSE_CURSOR_NONE) {
347         SDL_ShowCursor(SDL_DISABLE);
348         return;
349     }
350     SDL_ShowCursor(SDL_ENABLE);
351     for(unsigned int i=0; i<NCURSORS; i++) {
352         if(cursor == cursors[i].name) {
353             CurrentMouseCursor = cursor;
354             SDL_SetCursor(cursors[i].sdlCursor);
355             return;
356         }
357     }
358     // Default to pointer
359     CurrentMouseCursor = MOUSE_CURSOR_POINTER;
360     SDL_SetCursor(cursors[0].sdlCursor);
361 }
362
363 int fgGetMouseCursor()
364 {
365     return CurrentMouseCursor;
366 }
367
368 static void initCursors()
369 {
370     unsigned char mask[128], img[128];
371     for(unsigned int i=0; i<NCURSORS; i++) {
372         if(cursors[i].name == MOUSE_CURSOR_NONE) break;
373         for(int j=0; j<128; j++) mask[j] = img[j] = 0;
374         for(int y=0; y<cursors[i].h; y++) {
375             for(int x=0; x<cursors[i].w; x++) {
376                 int byte = (4 * y) + (x >> 3);
377                 int bit = 1 << (7 - (x & 7));
378                 int pix = cursors[i].img[y][x];
379                 if(pix != ' ') { mask[byte] |= bit; }
380                 if(pix == '#') { img[byte] |= bit; }
381             }
382         }
383         cursors[i].sdlCursor = SDL_CreateCursor(img, mask, 32, 32, 
384                                                 cursors[i].hotx,
385                                                 cursors[i].hoty);
386     }
387 }