gui/sdl/sdl.cpp

   1 //
   2 //   Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Free Software
   3 //   Foundation, Inc
   4 //
   5 // This program is free software; you can redistribute it and/or modify
   6 // it under the terms of the GNU General Public License as published by
   7 // the Free Software Foundation; either version 3 of the License, or
   8 // (at your option) any later version.
   9 //
  10 // This program is distributed in the hope that it will be useful,
  11 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13 // GNU General Public License for more details.
  14 //
  15 // You should have received a copy of the GNU General Public License
  16 // along with this program; if not, write to the Free Software
  17 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  18
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "gnashconfig.h"
  22 #endif
  23
  24 #include <cstdio>
  25
  26 #include "log.h"
  27 #include "sdlsup.h"
  28 #include "Range2d.h" // for Intersection of inv bounds
  29 #include "Renderer.h" // for setInvalidatedRegions
  30 #include "RunResources.h"
  31
  32 using namespace std;
  33
  34 namespace gnash
  35 {
  36
  37 SDLGui::SDLGui(unsigned long xid, float scale, bool loop, RunResources& r)
  38  : Gui(xid, scale, loop, r),
  39    _timeout(0),
  40    _core_trap(true)
  41 {
  42 }
  43
  44 SDLGui::~SDLGui()
  45 {
  46 }
  47
  48 bool
  49 SDLGui::run()
  50 {
  51     int x_old = -1;
  52     int y_old = -1;
  53     int button_state_old = -1;
  54
  55     Uint32 movie_time = 0;// SDL_GetTicks(); // what time it should be in the movie
  56
  57     SDL_Event   event;
  58     while (true)
  59     {
  60         if (_timeout && SDL_GetTicks() >= _timeout)
  61         {
  62             break;
  63         }
  64
  65         while (SDL_PollEvent(&event))
  66         {
  67             switch (event.type)
  68             {
  69             case SDL_MOUSEMOTION:
  70                 // SDL can generate MOUSEMOTION events even without mouse movement
  71                 if (event.motion.x == x_old && event.motion.y == y_old) { break; }
  72                 x_old = event.motion.x;
  73                 y_old = event.motion.y;
  74                 notifyMouseMove(x_old, y_old);
  75                 break;
  76
  77             case SDL_MOUSEBUTTONDOWN:
  78             case SDL_MOUSEBUTTONUP:
  79             {
  80                 if (event.button.state == SDL_PRESSED) {
  81                     // multiple events will be fired while the mouse is held down
  82                     // we are interested only in a change in the mouse state:
  83                     if (event.button.button == button_state_old) { break; }
  84                     notifyMouseClick(true);
  85                     button_state_old = event.button.button;
  86                 } else {
  87                     notifyMouseClick(false);
  88                     button_state_old = -1;
  89                 }
  90                 break;
  91             }
  92             case SDL_KEYDOWN:
  93             {
  94                 if (event.key.keysym.sym == SDLK_ESCAPE)
  95                 {
  96                     return true;
  97                 }
  98                 key_event(&event.key, true);
  99                 break;
 100             }
 101             case SDL_KEYUP:
 102             {
 103                 key_event(&event.key, false);
 104                 break;
 105             }
 106             case SDL_VIDEORESIZE:
 107                 resize_event();
 108                 break;
 109
 110             case SDL_VIDEOEXPOSE:
 111                 expose_event();
 112                 break;
 113
 114             case SDL_QUIT:
 115                 return true;
 116                 break;
 117             }
 118         }
 119
 120         // Wait until real time catches up with movie time.
 121         int delay = movie_time - SDL_GetTicks();
 122         if (delay > 0)
 123         {
 124             SDL_Delay(delay);
 125         }
 126
 127         Gui::advance_movie(this);
 128         movie_time += _interval;        // Time next frame should be displayed
 129     }
 130     return false;
 131 }
 132
 133
 134 void
 135 SDLGui::setTimeout(unsigned int timeout)
 136 {
 137     _timeout = timeout;
 138 }
 139
 140 bool
 141 SDLGui::init(int argc, char **argv[])
 142 {
 143
 144     disableCoreTrap();
 145
 146     if (_xid) {
 147         char SDL_windowhack[32];
 148         snprintf (SDL_windowhack, sizeof(SDL_windowhack), "SDL_WINDOWID=%ld", _xid);
 149         putenv (SDL_windowhack);
 150     }
 151
 152     // Initialize the SDL subsystems we're using. Linux
 153     // and Darwin use Pthreads for SDL threads, Win32
 154     // doesn't. Otherwise the SDL event loop just polls.
 155     if (SDL_Init(SDL_INIT_VIDEO)) {
 156         fprintf(stderr, "Unable to init SDL: %s\n", SDL_GetError());
 157         exit(EXIT_FAILURE);
 158     }
 159
 160     atexit(SDL_Quit);
 161
 162     SDL_EnableKeyRepeat(250, 33);
 163
 164     _glue.init(argc, argv);
 165
 166     _renderer.reset(_glue.createRenderHandler(32));
 167     if ( ! _renderer ) return false;
 168
 169     return true;
 170 }
 171
 172
 173 bool
 174 SDLGui::createWindow(const char *title, int width, int height,
 175                      int /*xPosition*/, int /*yPosition*/)
 176 {
 177     _width = width;
 178     _height = height;
 179
 180     boost::uint32_t sdl_flags = 0;
 181
 182     if (!_core_trap) {
 183         sdl_flags |= SDL_INIT_NOPARACHUTE;
 184     }
 185
 186     if (_xid) {
 187         sdl_flags |= SDL_NOFRAME;
 188     }
 189
 190     _glue.prepDrawingArea(_width, _height, sdl_flags);
 191
 192     _runResources.setRenderer(_renderer);
 193
 194     SDL_WM_SetCaption( title, title);
 195
 196     return false;
 197 }
 198
 199 void
 200 SDLGui::disableCoreTrap()
 201 {
 202     _core_trap = false;
 203 }
 204
 205 /* public, overridden */
 206 void
 207 SDLGui::setInvalidatedRegions(const InvalidatedRanges& ranges)
 208 {
 209     _glue.setInvalidatedRegions(ranges);
 210 }
 211
 212 void
 213 SDLGui::renderBuffer()
 214 {
 215     _glue.render();
 216 }
 217
 218 void
 219 SDLGui::setInterval(unsigned int interval)
 220 {
 221     _interval = interval;
 222 }
 223
 224 bool
 225 SDLGui::createMenu()
 226 {
 227     return false;
 228 }
 229
 230 bool
 231 SDLGui::setupEvents()
 232 {
 233     return false;
 234 }
 235
 236 key::code
 237 SDLGui::sdl_to_gnash_key(SDL_KeyboardEvent * key)
 238 {
 239   gnash::key::code c(gnash::key::INVALID);
 240
 241   // TODO: take care of CAPS_LOCK and NUM_LOCK and SHIFT
 242   // int mod = key->keysym.mod;
 243   int code = key->keysym.sym;
 244
 245   if(code>= 32 && code <= 127) {
 246     c = (gnash::key::code)(code);
 247   }else if(code >= SDLK_KP0 && code <= SDLK_KP9) {
 248     c = (gnash::key::code)(code - SDLK_KP0 + gnash::key::KP_0);
 249   }else if(code >= SDLK_F1 && code <= SDLK_F15) {
 250     c = (gnash::key::code)(code - SDLK_F1 + gnash::key::F1);
 251   }else
 252   {
 253     switch(code) {
 254       case SDLK_UP:       c = gnash::key::UP;       break;
 255       case SDLK_DOWN:     c = gnash::key::DOWN;     break;
 256       case SDLK_RIGHT:    c = gnash::key::RIGHT;    break;
 257       case SDLK_LEFT:     c = gnash::key::LEFT;     break;
 258       case SDLK_INSERT:   c = gnash::key::INSERT;   break;
 259       case SDLK_HOME:     c = gnash::key::HOME;     break;
 260       case SDLK_END:      c = gnash::key::END;      break;
 261       case SDLK_PAGEUP:   c = gnash::key::PGUP;     break;
 262       case SDLK_PAGEDOWN: c = gnash::key::PGDN;     break;
 263       case SDLK_RSHIFT:
 264       case SDLK_LSHIFT:   c = gnash::key::SHIFT;    break;
 265       case SDLK_RCTRL:
 266       case SDLK_LCTRL:    c = gnash::key::CONTROL;  break;
 267       case SDLK_RALT:
 268       case SDLK_LALT:     c = gnash::key::ALT;      break;
 269       default: c = gnash::key::INVALID; break;
 270     }
 271   }
 272
 273   return c;
 274 }
 275
 276 int
 277 SDLGui::sdl_to_gnash_modifier(int state)
 278 {
 279   int modifier = gnash::key::GNASH_MOD_NONE;
 280
 281   if (state & KMOD_SHIFT) {
 282       modifier = modifier | gnash::key::GNASH_MOD_SHIFT;
 283     }
 284     if (state & KMOD_CTRL) {
 285       modifier = modifier | gnash::key::GNASH_MOD_CONTROL;
 286     }
 287     if (state & KMOD_ALT) {
 288       modifier = modifier | gnash::key::GNASH_MOD_ALT;
 289     }
 290
 291     return modifier;
 292 }
 293
 294 void SDLGui::key_event(SDL_KeyboardEvent* key, bool down)
 295 // For forwarding SDL key events.
 296 {
 297     gnash::key::code c = sdl_to_gnash_key(key);
 298
 299     if (c != gnash::key::INVALID)
 300     {
 301         int mod = sdl_to_gnash_modifier(key->keysym.mod);
 302
 303         notify_key_event(c, mod, down);
 304     }
 305 }
 306
 307 void
 308 SDLGui::resize_event()
 309 {
 310     log_debug("got resize_event ");
 311 }
 312
 313 void
 314 SDLGui::expose_event()
 315 {
 316     // TODO: implement and use setInvalidatedRegion instead?
 317     renderBuffer();
 318 }
 319
 320 } // namespace gnash
 321