Support SDL_ActiveEvent

libraries/SDL-1.2.14/nacl-SDL-1.2.14.patch

 diff -urN SDL-1.2.14/build-scripts/config.sub SDL-1.2.14-nacl/build-scripts/config.sub
 --- SDL-1.2.14/build-scripts/config.sub 2009-10-13 03:07:12.000000000 +0400
 +++ SDL-1.2.14-nacl/build-scripts/config.sub    2012-01-16 12:16:39.460269192 +0400
 @@ -318,6 +318,14 @@
         i*86 | x86_64)
           basic_machine=$basic_machine-pc
           ;;
 +       nacl64*)
 +         basic_machine=x86_64-pc
 +         os=-nacl
@@ skipping 80 matching lines @@
 @@ -265,6 +266,7 @@
  #undef SDL_VIDEO_DRIVER_GEM
  #undef SDL_VIDEO_DRIVER_GGI
  #undef SDL_VIDEO_DRIVER_IPOD
 +#undef SDL_VIDEO_DRIVER_NACL
  #undef SDL_VIDEO_DRIVER_NANOX
  #undef SDL_VIDEO_DRIVER_OS2FS
  #undef SDL_VIDEO_DRIVER_PHOTON
 diff -urN SDL-1.2.14/include/SDL_nacl.h SDL-1.2.14-nacl/include/SDL_nacl.h
 --- SDL-1.2.14/include/SDL_nacl.h       1970-01-01 03:00:00.000000000 +0300
-+++ SDL-1.2.14-nacl/include/SDL_nacl.h  2012-01-16 12:16:39.460269192 +0400
-@@ -0,0 +1,22 @@
++++ SDL-1.2.14-nacl/include/SDL_nacl.h  2012-03-25 08:05:23.160195017 +0400
+@@ -0,0 +1,24 @@
 +#ifndef _SDL_nacl_h
 +#define _SDL_nacl_h
 +
 +#include "begin_code.h"
 +#include <ppapi/cpp/input_event.h>
 +
 +/* Set up for C function definitions, even when using C++ */
 +#ifdef __cplusplus
 +extern "C" {
 +#endif
 +
 +#include <ppapi/c/ppp_instance.h>
 +void SDL_NACL_SetInstance(PP_Instance instance, int width, int height);
 +void SDL_NACL_PushEvent(const pp::InputEvent& ppevent);
++void SDL_NACL_SetHasFocus(bool has_focus);
++void SDL_NACL_SetPageVisible(bool is_visible);
 +
 +/* Ends C function definitions when using C++ */
 +#ifdef __cplusplus
 +}
 +#endif
 +#include "close_code.h"
 +
 +#endif /* _SDL_nacl_h */
 diff -urN SDL-1.2.14/include/SDL_platform.h SDL-1.2.14-nacl/include/SDL_platform.h
 --- SDL-1.2.14/include/SDL_platform.h   2009-10-13 03:07:19.000000000 +0400
@@ skipping 284 matching lines @@
         for ( i=0; sig_list[i]; ++i ) {
                 sigaddset(&mask, sig_list[i]);
         }
         pthread_sigmask(SIG_BLOCK, &mask, 0);
 +#endif
  
  #ifdef PTHREAD_CANCEL_ASYNCHRONOUS
         /* Allow ourselves to be asynchronously cancelled */
 diff -urN SDL-1.2.14/src/video/nacl/eventqueue.h SDL-1.2.14-nacl/src/video/nacl/eventqueue.h
 --- SDL-1.2.14/src/video/nacl/eventqueue.h      1970-01-01 03:00:00.000000000 +0300
-+++ SDL-1.2.14-nacl/src/video/nacl/eventqueue.h 2012-01-16 12:16:39.470269368 +0400
-@@ -0,0 +1,43 @@
++++ SDL-1.2.14-nacl/src/video/nacl/eventqueue.h 2012-03-25 09:10:10.058485979 +0400
+@@ -0,0 +1,40 @@
 +#ifndef _SDL_nacl_eventqueue_h
 +#define _SDL_nacl_eventqueue_h
 +
 +#include "SDL_mutex.h"
 +
 +#include <queue>
-+#include <ppapi/c/pp_input_event.h>
-+
-+struct SDL_NACL_Event;
 +
 +class EventQueue {
 +public:
 +  EventQueue() {
 +    mu_ = SDL_CreateMutex();
 +  }
 +
 +  ~EventQueue() {
 +    SDL_DestroyMutex(mu_);
 +  }
 +
-+  SDL_NACL_Event* PopEvent() {
++  SDL_Event* PopEvent() {
 +    SDL_LockMutex(mu_);
-+    SDL_NACL_Event* event = NULL;
++    SDL_Event* event = NULL;
 +    if (!queue_.empty()) {
 +      event = queue_.front();
 +      queue_.pop();
 +    }
 +    SDL_UnlockMutex(mu_);
 +    return event;
 +  }
 +
-+   void PushEvent(SDL_NACL_Event* event) {
++   void PushEvent(SDL_Event* event) {
 +    SDL_LockMutex(mu_);
 +    queue_.push(event);
 +    SDL_UnlockMutex(mu_);
 +   } 
 +
 +private:
-+  std::queue<SDL_NACL_Event*> queue_;
++  std::queue<SDL_Event*> queue_;
 +  SDL_mutex* mu_;
 +};
 +
 +#endif // _SDL_nacl_eventqueue_h
 diff -urN SDL-1.2.14/src/video/nacl/MainThreadRunner.cc SDL-1.2.14-nacl/src/video/nacl/MainThreadRunner.cc
 --- SDL-1.2.14/src/video/nacl/MainThreadRunner.cc       1970-01-01 03:00:00.000000000 +0300
 +++ SDL-1.2.14-nacl/src/video/nacl/MainThreadRunner.cc  2012-03-21 03:17:01.150449516 +0400
 @@ -0,0 +1,227 @@
 +/*
 + * Copyright (c) 2012 The Native Client Authors. All rights reserved.
@@ skipping 323 matching lines @@
 + public:
 +  virtual ~MainThreadJob() {}
 +  virtual void Run(MainThreadRunner::JobEntry *entry) = 0;
 +};
 +
 +// MainThreadRunner executes MainThreadJobs asynchronously
 +
 +#endif  // LIBRARIES_NACL_MOUNTS_BASE_MAINTHREADRUNNER_H_
 diff -urN SDL-1.2.14/src/video/nacl/SDL_naclevents.cc SDL-1.2.14-nacl/src/video/nacl/SDL_naclevents.cc
 --- SDL-1.2.14/src/video/nacl/SDL_naclevents.cc 1970-01-01 03:00:00.000000000 +0300
-+++ SDL-1.2.14-nacl/src/video/nacl/SDL_naclevents.cc    2012-01-16 12:20:38.794463980 +0400
-@@ -0,0 +1,282 @@
++++ SDL-1.2.14-nacl/src/video/nacl/SDL_naclevents.cc    2012-03-27 05:28:18.539656031 +0400
+@@ -0,0 +1,307 @@
 +#include "SDL_config.h"
 +
 +#include "SDL_nacl.h"
 +
 +extern "C" {
 +#include "SDL.h"
 +#include "../../events/SDL_sysevents.h"
 +#include "../../events/SDL_events_c.h"
 +}
 +
 +#include "SDL_naclevents_c.h"
 +#include "eventqueue.h"
 +#include <ppapi/cpp/input_event.h>
 +#include <ppapi/cpp/point.h>
 +#include <ppapi/cpp/var.h>
 +
 +#include <math.h>
 +
 +static EventQueue event_queue;
 +
-+struct SDL_NACL_Event {
-+  PP_InputEvent_Type type;
-+  Uint8 button;
-+  SDL_keysym keysym;
-+  int32_t x, y;
-+  int32_t wheel_clicks_x;
-+  int32_t wheel_clicks_y;
-+};
-+
 +static Uint8 translateButton(int32_t button) {
 +  switch (button) {
 +    case PP_INPUTEVENT_MOUSEBUTTON_LEFT:
 +      return SDL_BUTTON_LEFT;
 +    case PP_INPUTEVENT_MOUSEBUTTON_MIDDLE:
 +      return SDL_BUTTON_MIDDLE;
 +    case PP_INPUTEVENT_MOUSEBUTTON_RIGHT:
 +      return SDL_BUTTON_RIGHT;
 +    case PP_INPUTEVENT_MOUSEBUTTON_NONE:
 +    default:
@@ skipping 123 matching lines @@
 +      return SDLK_PERIOD;
 +    case 191:
 +      return SDLK_SLASH;
 +    case 192:
 +      return SDLK_BACKQUOTE;
 +    default:
 +      return SDLK_UNKNOWN;
 +  }
 +}
 +
++static SDL_Event *copyEvent(SDL_Event *event) {
++  SDL_Event *event_copy = (SDL_Event*)malloc(sizeof(SDL_Event));
++  *event_copy = *event;
++  return event_copy;
++}
++
 +void SDL_NACL_PushEvent(const pp::InputEvent& ppevent) {
 +  static Uint8 last_scancode = 0;
 +  SDL_keysym keysym;
-+  struct SDL_NACL_Event* event =
-+    (struct SDL_NACL_Event*)malloc(sizeof(struct SDL_NACL_Event));
 +  static double wheel_clicks_x;
 +  static double wheel_clicks_y;
-+  event->type = ppevent.GetType();
++  SDL_Event event;
++  PP_InputEvent_Type type = ppevent.GetType();
 +
 +  pp::InputEvent *input_event = const_cast<pp::InputEvent*>(&ppevent);
 +
-+  if (event->type == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
-+      event->type == PP_INPUTEVENT_TYPE_MOUSEUP) {
++  if (type == PP_INPUTEVENT_TYPE_MOUSEDOWN ||
++      type == PP_INPUTEVENT_TYPE_MOUSEUP) {
 +    pp::MouseInputEvent *mouse_event =
 +      reinterpret_cast<pp::MouseInputEvent*>(input_event);
-+    event->button = translateButton(mouse_event->GetButton());
-+  } else if (event->type == PP_INPUTEVENT_TYPE_WHEEL) {
++    event.type = (type == PP_INPUTEVENT_TYPE_MOUSEUP) ? SDL_MOUSEBUTTONUP : SDL_MOUSEBUTTONDOWN;
++    event.button.button = translateButton(mouse_event->GetButton());
++    event.button.x = mouse_event->GetPosition().x();
++    event.button.y = mouse_event->GetPosition().y();
++    event_queue.PushEvent(copyEvent(&event));
++  } else if (type == PP_INPUTEVENT_TYPE_WHEEL) {
 +    pp::WheelInputEvent *wheel_event =
 +      reinterpret_cast<pp::WheelInputEvent*>(input_event);
 +    wheel_clicks_x += wheel_event->GetTicks().x();
 +    wheel_clicks_y += wheel_event->GetTicks().y();
-+    event->wheel_clicks_x = trunc(wheel_clicks_x);
-+    event->wheel_clicks_y = trunc(wheel_clicks_y);
-+    if (event->wheel_clicks_x == 0 && event->wheel_clicks_y == 0) {
-+      free(event);
-+      return;
++    int sdl_wheel_clicks_x = trunc(wheel_clicks_x);
++    int sdl_wheel_clicks_y = trunc(wheel_clicks_y);
++    event.button.x = event.button.y = 0;
++    event.button.button = (sdl_wheel_clicks_x > 0) ? SDL_BUTTON_X1 : SDL_BUTTON_X2;
++    for (int i = 0; i < abs(sdl_wheel_clicks_x); i++) {
++      event.type = SDL_MOUSEBUTTONDOWN;
++      event_queue.PushEvent(copyEvent(&event));
++      event.type = SDL_MOUSEBUTTONUP;
++      event_queue.PushEvent(copyEvent(&event));
 +    }
-+    wheel_clicks_x -= event->wheel_clicks_x;
-+    wheel_clicks_y -= event->wheel_clicks_y;
-+  } else if (event->type == PP_INPUTEVENT_TYPE_MOUSEMOVE) {
++    event.button.button = (sdl_wheel_clicks_y > 0) ? SDL_BUTTON_WHEELUP : SDL_BUTTON_WHEELDOWN;
++    for (int i = 0; i < abs(sdl_wheel_clicks_y); i++) {
++      event.type = SDL_MOUSEBUTTONDOWN;
++      event_queue.PushEvent(copyEvent(&event));
++      event.type = SDL_MOUSEBUTTONUP;
++      event_queue.PushEvent(copyEvent(&event));
++    }
++    wheel_clicks_x -= sdl_wheel_clicks_x;
++    wheel_clicks_y -= sdl_wheel_clicks_y;
++  } else if (type == PP_INPUTEVENT_TYPE_MOUSEMOVE) {
 +    pp::MouseInputEvent *mouse_event =
 +      reinterpret_cast<pp::MouseInputEvent*>(input_event);
-+    event->x = mouse_event->GetPosition().x();
-+    event->y = mouse_event->GetPosition().y();
-+  } else if (event->type == PP_INPUTEVENT_TYPE_KEYDOWN ||
-+             event->type == PP_INPUTEVENT_TYPE_KEYUP ||
-+             event->type == PP_INPUTEVENT_TYPE_CHAR) {
++    event.type = SDL_MOUSEMOTION;
++    event.motion.x = mouse_event->GetPosition().x();
++    event.motion.y = mouse_event->GetPosition().y();
++    event_queue.PushEvent(copyEvent(&event));
++  } else if (type == PP_INPUTEVENT_TYPE_KEYDOWN ||
++             type == PP_INPUTEVENT_TYPE_KEYUP ||
++             type == PP_INPUTEVENT_TYPE_CHAR) {
 +    // PPAPI sends us separate events for KEYDOWN and CHAR; the first one
 +    // contains only the keycode, the second one - only the unicode text.
 +    // SDL wants both in SDL_PRESSED event :(
 +    // For now, ignore the keydown event for printable ascii (32-126) as we
 +    // know we'll get a char event and can set sym directly. For everything
 +    // else, risk sending an extra SDL_PRESSED with unicode text and zero
 +    // keycode for scancode / sym.
 +    // It seems that SDL 1.3 is better in this regard.
 +    pp::KeyboardInputEvent *keyboard_event =
 +      reinterpret_cast<pp::KeyboardInputEvent*>(input_event);
 +    keysym.scancode = keyboard_event->GetKeyCode();
 +    keysym.unicode = keyboard_event->GetCharacterText().AsString()[0];
 +    keysym.sym = translateKey(keysym.scancode);
-+    if (event->type == PP_INPUTEVENT_TYPE_KEYDOWN) {
++    if (type == PP_INPUTEVENT_TYPE_KEYDOWN) {
++      event.type = SDL_KEYDOWN;
 +      last_scancode = keysym.scancode;
 +      if (keysym.sym >= ' ' &&  keysym.sym <= 126) {
-+        free(event);
 +        return;
 +      }
-+    } else if (event->type == PP_INPUTEVENT_TYPE_CHAR) {
++    } else if (type == PP_INPUTEVENT_TYPE_CHAR) {
++      event.type = SDL_KEYDOWN;
 +      if (keysym.sym >= ' ' &&  keysym.sym <= 126) {
 +        keysym.scancode = translateAscii(keysym.unicode);
 +        keysym.sym = translateKey(keysym.scancode);
 +      } else if (last_scancode) {
 +        keysym.scancode = last_scancode;
 +        keysym.sym = translateKey(keysym.scancode);
 +      }
 +    } else {  // event->type == PP_INPUTEVENT_TYPE_KEYUP
++      event.type = SDL_KEYUP;
 +      last_scancode = 0;
 +    }
 +    keysym.mod = KMOD_NONE;
-+    event->keysym = keysym;
-+  } else {
-+    free(event);
-+    return;
++    event.key.keysym = keysym;
++    event_queue.PushEvent(copyEvent(&event));
++  } else if (type == PP_INPUTEVENT_TYPE_MOUSEENTER ||
++             type == PP_INPUTEVENT_TYPE_MOUSELEAVE) {
++    event.type = SDL_ACTIVEEVENT;
++    event.active.gain = (type == PP_INPUTEVENT_TYPE_MOUSEENTER) ? 1 : 0;
++    event.active.state = SDL_APPMOUSEFOCUS;
++    event_queue.PushEvent(copyEvent(&event));
 +  }
-+  event_queue.PushEvent(event);
++}
++
++void SDL_NACL_SetHasFocus(bool has_focus) {
++  SDL_Event event;
++  event.type = SDL_ACTIVEEVENT;
++  event.active.gain = has_focus ? 1 : 0;
++  event.active.state = SDL_APPINPUTFOCUS;
++  event_queue.PushEvent(copyEvent(&event));
++}
++
++void SDL_NACL_SetPageVisible(bool is_visible) {
++  SDL_Event event;
++  event.type = SDL_ACTIVEEVENT;
++  event.active.gain = is_visible ? 1 : 0;
++  event.active.state = SDL_APPACTIVE;
++  event_queue.PushEvent(copyEvent(&event));
 +}
 +
 +void NACL_PumpEvents(_THIS) {
-+  SDL_NACL_Event* event;
++  SDL_Event* event;
 +  while (event = event_queue.PopEvent()) {
-+    if (event->type == PP_INPUTEVENT_TYPE_MOUSEDOWN) {
-+      SDL_PrivateMouseButton(SDL_PRESSED, event->button, 0, 0);
-+    } else if (event->type == PP_INPUTEVENT_TYPE_MOUSEUP) {
-+      SDL_PrivateMouseButton(SDL_RELEASED, event->button, 0, 0);
-+    } else if (event->type == PP_INPUTEVENT_TYPE_WHEEL) {
-+      Uint8 button = event->wheel_clicks_x > 0 ? SDL_BUTTON_X1 : SDL_BUTTON_X2;
-+      int count = abs(event->wheel_clicks_x);
-+      while (count--) {
-+        SDL_PrivateMouseButton(SDL_PRESSED, button, 0, 0);
-+        SDL_PrivateMouseButton(SDL_RELEASED, button, 0, 0);
-+      }
-+      button = event->wheel_clicks_y > 0 ? SDL_BUTTON_WHEELUP : SDL_BUTTON_WHEELDOWN;
-+      count = abs(event->wheel_clicks_y);
-+      while (count--) {
-+        SDL_PrivateMouseButton(SDL_PRESSED, button, 0, 0);
-+        SDL_PrivateMouseButton(SDL_RELEASED, button, 0, 0);
-+      }
-+    } else if (event->type == PP_INPUTEVENT_TYPE_MOUSEMOVE) {
-+      SDL_PrivateMouseMotion(0, 0, event->x, event->y);
-+    } else if (event->type == PP_INPUTEVENT_TYPE_KEYDOWN || event->type == PP_INPUTEVENT_TYPE_CHAR) {
-+      SDL_PrivateKeyboard(SDL_PRESSED, &event->keysym);
-+    } else if (event->type == PP_INPUTEVENT_TYPE_KEYUP) {
-+      SDL_PrivateKeyboard(SDL_RELEASED, &event->keysym);
++    if (event->type == SDL_MOUSEBUTTONDOWN) {
++      SDL_PrivateMouseButton(SDL_PRESSED, event->button.button,
++                             event->button.x, event->button.y);
++    } else if (event->type == SDL_MOUSEBUTTONUP) {
++      SDL_PrivateMouseButton(SDL_RELEASED, event->button.button,
++                             event->button.x, event->button.y);
++    } else if (event->type == SDL_MOUSEMOTION) {
++      SDL_PrivateMouseMotion(0, 0, event->motion.x, event->motion.y);
++    } else if (event->type == SDL_KEYDOWN) {
++      SDL_PrivateKeyboard(SDL_PRESSED, &event->key.keysym);
++    } else if (event->type == SDL_KEYUP) {
++      SDL_PrivateKeyboard(SDL_RELEASED, &event->key.keysym);
++    } else if (event->type == SDL_ACTIVEEVENT) {
++      SDL_PrivateAppActive(event->active.gain, event->active.state);
 +    }
 +    free(event);
 +  }
 +}
 +
 +void NACL_InitOSKeymap(_THIS) {
 +  /* do nothing. */
 +}
 diff -urN SDL-1.2.14/src/video/nacl/SDL_naclevents_c.h SDL-1.2.14-nacl/src/video/nacl/SDL_naclevents_c.h
 --- SDL-1.2.14/src/video/nacl/SDL_naclevents_c.h        1970-01-01 03:00:00.000000000 +0300
@@ skipping 452 matching lines @@
 @@ -33,6 +33,9 @@
  
  /* Available video drivers */
  static VideoBootStrap *bootstrap[] = {
 +#if SDL_VIDEO_DRIVER_NACL
 +       &NACL_bootstrap,
 +#endif
  #if SDL_VIDEO_DRIVER_QUARTZ
         &QZ_bootstrap,
  #endif