void iphone_controls::read_controls()
{
active_mice.clear();
#if defined(TARGET_OS_HARMATTAN) || defined(TARGET_BLACKBERRY) || defined(__ANDROID__)
// there is no SDL_Get_NumMice and SDL_SelectMouse support on
// Harmattan, so all_mice has been updated via calls to handle_event
const int nmice = all_mice.size();
#else
const int nmice = SDL_GetNumMice();
if(all_mice.size() > nmice) {
all_mice.resize(nmice);
}
for(int i = 0; i < nmice; i++) {
int x, y;
SDL_SelectMouse(i);
Uint8 button_state = SDL_GetMouseState(&x, &y);
translate_mouse_coords(&x, &y);
if(all_mice.size() == i) {
all_mice.push_back(Mouse());
all_mice[i].active = false;
}
if(!all_mice[i].active) {
all_mice[i].starting_x = x;
all_mice[i].starting_y = y;
}
all_mice[i].x = x;
all_mice[i].y = y;
all_mice[i].active = button_state & SDL_BUTTON(SDL_BUTTON_LEFT);
}
#endif
for(int i = 0; i < nmice; i++) {
if(all_mice[i].active) {
active_mice.push_back(all_mice[i]);
}
}
}
static void
X11_DispatchEvent(_THIS)
{
SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata;
SDL_WindowData *data;
XEvent xevent;
int i;
SDL_zero(xevent); /* valgrind fix. --ryan. */
XNextEvent(videodata->display, &xevent);
/* filter events catchs XIM events and sends them to the correct
handler */
if (XFilterEvent(&xevent, None) == True) {
#if 0
printf("Filtered event type = %d display = %d window = %d\n",
xevent.type, xevent.xany.display, xevent.xany.window);
#endif
return;
}
/* Send a SDL_SYSWMEVENT if the application wants them */
if (SDL_ProcessEvents[SDL_SYSWMEVENT] == SDL_ENABLE) {
SDL_SysWMmsg wmmsg;
SDL_VERSION(&wmmsg.version);
wmmsg.subsystem = SDL_SYSWM_X11;
wmmsg.event.xevent = xevent;
SDL_SendSysWMEvent(&wmmsg);
}
data = NULL;
if (videodata && videodata->windowlist) {
for (i = 0; i < videodata->numwindows; ++i) {
if ((videodata->windowlist[i] != NULL) &&
(videodata->windowlist[i]->window == xevent.xany.window)) {
data = videodata->windowlist[i];
break;
}
}
}
if (!data) {
return;
}
#if 0
printf("type = %d display = %d window = %d\n",
xevent.type, xevent.xany.display, xevent.xany.window);
#endif
switch (xevent.type) {
/* Gaining mouse coverage? */
case EnterNotify:{
#ifdef DEBUG_XEVENTS
printf("EnterNotify! (%d,%d,%d)\n",
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.mode);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
#if 1
/* FIXME: Should we reset data for all mice? */
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse = SDL_GetMouse(i);
SDL_SetMouseFocus(mouse->id, data->windowID);
}
#endif
}
break;
/* Losing mouse coverage? */
case LeaveNotify:{
#ifdef DEBUG_XEVENTS
printf("LeaveNotify! (%d,%d,%d)\n",
xevent.xcrossing.x,
xevent.xcrossing.y,
xevent.xcrossing.mode);
if (xevent.xcrossing.mode == NotifyGrab)
printf("Mode: NotifyGrab\n");
if (xevent.xcrossing.mode == NotifyUngrab)
printf("Mode: NotifyUngrab\n");
#endif
if (xevent.xcrossing.detail != NotifyInferior) {
#if 1
/* FIXME: Should we reset data for all mice? */
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse = SDL_GetMouse(i);
SDL_SetMouseFocus(mouse->id, 0);
}
#endif
}
}
break;
/* Gaining input focus? */
case FocusIn:{
#ifdef DEBUG_XEVENTS
printf("FocusIn!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, data->windowID);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XSetICFocus(data->ic);
}
#endif
}
break;
/* Losing input focus? */
case FocusOut:{
#ifdef DEBUG_XEVENTS
printf("FocusOut!\n");
#endif
SDL_SetKeyboardFocus(videodata->keyboard, 0);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
XUnsetICFocus(data->ic);
}
#endif
}
break;
/* Generated upon EnterWindow and FocusIn */
case KeymapNotify:{
#ifdef DEBUG_XEVENTS
printf("KeymapNotify!\n");
#endif
/* FIXME:
X11_SetKeyboardState(SDL_Display, xevent.xkeymap.key_vector);
*/
}
break;
/* Has the keyboard layout changed? */
case MappingNotify:{
#ifdef DEBUG_XEVENTS
printf("MappingNotify!\n");
#endif
X11_UpdateKeymap(_this);
}
break;
/* Key press? */
case KeyPress:{
KeyCode keycode = xevent.xkey.keycode;
KeySym keysym = NoSymbol;
char text[SDL_TEXTINPUTEVENT_TEXT_SIZE];
Status status = 0;
#ifdef DEBUG_XEVENTS
printf("KeyPress (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
SDL_SendKeyboardKey(videodata->keyboard, SDL_PRESSED,
videodata->key_layout[keycode]);
#if 0
if (videodata->key_layout[keycode] == SDLK_UNKNOWN) {
int min_keycode, max_keycode;
XDisplayKeycodes(videodata->display, &min_keycode,
&max_keycode);
keysym = XKeycodeToKeysym(videodata->display, keycode, 0);
fprintf(stderr,
"The key you just pressed is not recognized by SDL. To help get this fixed, please report this to the SDL mailing list <*****@*****.**> X11 KeyCode %d (%d), X11 KeySym 0x%X (%s).\n",
keycode, keycode - min_keycode, keysym,
XKeysymToString(keysym));
}
#endif
/* */
SDL_zero(text);
#ifdef X_HAVE_UTF8_STRING
if (data->ic) {
Xutf8LookupString(data->ic, &xevent.xkey, text, sizeof(text),
&keysym, &status);
}
#else
XLookupString(&xevent.xkey, text, sizeof(text), &keysym, NULL);
#endif
if (*text) {
SDL_SendKeyboardText(videodata->keyboard, text);
}
}
break;
/* Key release? */
case KeyRelease:{
KeyCode keycode = xevent.xkey.keycode;
#ifdef DEBUG_XEVENTS
printf("KeyRelease (X11 keycode = 0x%X)\n", xevent.xkey.keycode);
#endif
SDL_SendKeyboardKey(videodata->keyboard, SDL_RELEASED,
videodata->key_layout[keycode]);
}
break;
/* Have we been iconified? */
case UnmapNotify:{
#ifdef DEBUG_XEVENTS
printf("UnmapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_HIDDEN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MINIMIZED, 0,
0);
}
break;
/* Have we been restored? */
case MapNotify:{
#ifdef DEBUG_XEVENTS
printf("MapNotify!\n");
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_SHOWN, 0, 0);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESTORED, 0,
0);
}
break;
/* Have we been resized or moved? */
case ConfigureNotify:{
#ifdef DEBUG_XEVENTS
printf("ConfigureNotify! (resize: %dx%d)\n",
xevent.xconfigure.width, xevent.xconfigure.height);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_MOVED,
xevent.xconfigure.x, xevent.xconfigure.y);
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_RESIZED,
xevent.xconfigure.width,
xevent.xconfigure.height);
}
break;
/* Have we been requested to quit (or another client message?) */
case ClientMessage:{
if ((xevent.xclient.format == 32) &&
(xevent.xclient.data.l[0] == videodata->WM_DELETE_WINDOW)) {
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_CLOSE, 0,
0);
}
}
break;
/* Do we need to refresh ourselves? */
case Expose:{
#ifdef DEBUG_XEVENTS
printf("Expose (count = %d)\n", xevent.xexpose.count);
#endif
SDL_SendWindowEvent(data->windowID, SDL_WINDOWEVENT_EXPOSED, 0,
0);
}
break;
default:{
for (i = 0; i < SDL_GetNumMice(); ++i) {
SDL_Mouse *mouse;
#if SDL_VIDEO_DRIVER_X11_XINPUT
X11_MouseData *data;
#endif
mouse = SDL_GetMouse(i);
if (!mouse->driverdata) {
switch (xevent.type) {
case MotionNotify:
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", xevent.xmotion.x,
xevent.xmotion.y);
#endif
SDL_SendMouseMotion(mouse->id, 0, xevent.xmotion.x,
xevent.xmotion.y, 0);
break;
case ButtonPress:
SDL_SendMouseButton(mouse->id, SDL_PRESSED,
xevent.xbutton.button);
break;
case ButtonRelease:
SDL_SendMouseButton(mouse->id, SDL_RELEASED,
xevent.xbutton.button);
break;
}
continue;
}
#if SDL_VIDEO_DRIVER_X11_XINPUT
data = (X11_MouseData *) mouse->driverdata;
if (xevent.type == data->motion) {
XDeviceMotionEvent *move =
(XDeviceMotionEvent *) & xevent;
#ifdef DEBUG_MOTION
printf("X11 motion: %d,%d\n", move->x, move->y);
#endif
SDL_SendMouseMotion(move->deviceid, 0, move->x, move->y,
move->axis_data[2]);
return;
}
if (xevent.type == data->button_pressed) {
XDeviceButtonPressedEvent *pressed =
(XDeviceButtonPressedEvent *) & xevent;
SDL_SendMouseButton(pressed->deviceid, SDL_PRESSED,
pressed->button);
return;
}
if (xevent.type == data->button_released) {
XDeviceButtonReleasedEvent *released =
(XDeviceButtonReleasedEvent *) & xevent;
SDL_SendMouseButton(released->deviceid, SDL_RELEASED,
released->button);
return;
}
if (xevent.type == data->proximity_in) {
XProximityNotifyEvent *proximity =
(XProximityNotifyEvent *) & xevent;
SDL_SendProximity(proximity->deviceid, proximity->x,
proximity->y, SDL_PROXIMITYIN);
return;
}
if (xevent.type == data->proximity_out) {
XProximityNotifyEvent *proximity =
(XProximityNotifyEvent *) & xevent;
SDL_SendProximity(proximity->deviceid, proximity->x,
proximity->y, SDL_PROXIMITYOUT);
return;
}
#endif
}
#ifdef DEBUG_XEVENTS
printf("Unhandled event %d\n", xevent.type);
#endif
}
break;
}
}
variant playable_custom_object::get_player_value_by_slot(int slot) const
{
switch(slot) {
case CUSTOM_OBJECT_PLAYER_DIFFICULTY: {
if(preferences::force_difficulty() != INT_MIN) {
return variant(preferences::force_difficulty());
}
return variant(difficulty_);
}
case CUSTOM_OBJECT_PLAYER_CAN_INTERACT: {
return variant(can_interact_);
}
case CUSTOM_OBJECT_PLAYER_UNDERWATER_CONTROLS: {
return variant(underwater_controls_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_MOD_KEY: {
return variant(SDL_GetModState());
}
case CUSTOM_OBJECT_PLAYER_CTRL_KEYS: {
std::vector<variant> result;
if(level_runner::get_current() && level_runner::get_current()->get_debug_console() && level_runner::get_current()->get_debug_console()->has_keyboard_focus()) {
//the debug console is stealing all keystrokes.
return variant(&result);
}
#if !TARGET_OS_IPHONE && !TARGET_IPHONE_SIMULATOR
int ary_length;
const Uint8* key_state = SDL_GetKeyboardState(&ary_length);
#ifndef NO_EDITOR
if(level_runner::get_current()) {
const editor* e = level_runner::get_current()->get_editor();
if(e && e->has_keyboard_focus()) {
//the editor has the focus, so we tell the game there
//are no keys pressed.
ary_length = 0;
}
}
#endif
for(int count = 0; count < ary_length; ++count) {
if(key_state[count]) { //Returns only keys that are down so the list that ffl has to deal with is small.
SDL_Keycode k = SDL_GetKeyFromScancode(SDL_Scancode(count));
if(k < 128 && util::c_isprint(k)) {
std::string str(1,k);
result.push_back(variant(str));
} else {
result.push_back(variant(k));
}
}
}
#endif
return variant(&result);
}
case CUSTOM_OBJECT_PLAYER_CTRL_MICE: {
std::vector<variant> result;
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
const int nmice = SDL_GetNumMice();
#else
const int nmice = 1;
#endif
for(int n = 0; n != nmice; ++n) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
SDL_SelectMouse(n);
#endif
std::vector<variant> info;
int x, y;
Uint8 button_state = input::sdl_get_mouse_state(&x, &y);
translate_mouse_coords(&x, &y);
info.push_back(variant(x));
info.push_back(variant(y));
if(button_state & SDL_BUTTON(SDL_BUTTON_LEFT)) {
info.push_back(variant("left"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_RIGHT)) {
info.push_back(variant("right"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_MIDDLE)) {
info.push_back(variant("middle"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_X1)) { //these aren't tested
info.push_back(variant("x1"));
}
if(button_state & SDL_BUTTON(SDL_BUTTON_X2)) {
info.push_back(variant("x2"));
}
result.push_back(variant(&info));
}
return variant(&result);
}
case CUSTOM_OBJECT_PLAYER_CTRL_TILT: {
return variant(-joystick::iphone_tilt());
}
case CUSTOM_OBJECT_PLAYER_CTRL_X: {
return variant(underwater_ctrl_x_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_Y: {
return variant(underwater_ctrl_y_);
}
case CUSTOM_OBJECT_PLAYER_CTRL_REVERSE_AB: {
return variant::from_bool(reverse_ab_);
}
case CUSTOM_OBJECT_PLAYER_CONTROL_SCHEME: {
return variant(preferences::control_scheme());
}
case CUSTOM_OBJECT_PLAYER_VERTICAL_LOOK: {
return variant(vertical_look_);
}
case CUSTOM_OBJECT_PLAYER_CONTROL_LOCK: {
std::vector<variant> result;
const unsigned char* locked_control_frame = controls::get_local_control_lock();
if (locked_control_frame == nullptr) {
return variant();
}
for(int i = 0; i < 8; ++i){
if((*locked_control_frame & (0x01 << i)) ){
result.push_back( variant(ctrl[i]) );
} else {
//this key isn't pressed
}
}
return variant(&result);
}
}
ASSERT_LOG(false, "unknown slot in get_player_value_by_slot: " << slot);
}
if(count < 128 && util::c_isprint(count)) {
std::string str(1,count);
result.push_back(variant(str));
} else {
result.push_back(variant(count));
}
}
}
#endif
return variant(&result);
} else if(key == "ctrl_mice") {
std::vector<variant> result;
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
const int nmice = SDL_GetNumMice();
#else
const int nmice = 1;
#endif
for(int n = 0; n != nmice; ++n) {
#if TARGET_OS_IPHONE || TARGET_IPHONE_SIMULATOR
SDL_SelectMouse(n);
#endif
std::vector<variant> info;
int x, y;
Uint8 button_state = SDL_GetMouseState(&x, &y);
translate_mouse_coords(&x, &y);
info.push_back(variant(x));
info.push_back(variant(y));
