static void FocusAllKeyboards(_THIS, SDL_Window *window) { #if USE_MULTI_API SDL_DFB_DEVICEDATA(_this); int index; for (index = 0; index < devdata->num_keyboard; index++) SDL_SetKeyboardFocus(index, id); #else SDL_SetKeyboardFocus(window); #endif }
static void HandleWindow(MirWindowEvent const* event, SDL_Window* window) { MirWindowAttrib attrib = MIR_mir_window_event_get_attribute(event); int value = MIR_mir_window_event_get_attribute_value(event); if (attrib == mir_window_attrib_focus) { if (value == mir_window_focus_state_focused) { SDL_SetKeyboardFocus(window); } else if (value == mir_window_focus_state_unfocused) { SDL_SetKeyboardFocus(NULL); } } }
static void CheckKeyboardFocus(SDL_Window* sdl_window) { SDL_Window* keyboard_window = SDL_GetKeyboardFocus(); if (keyboard_window != sdl_window) SDL_SetKeyboardFocus(sdl_window); }
int Android_CreateWindow(_THIS, SDL_Window * window) { SDL_WindowData *data; if (Android_Window) { return SDL_SetError("Android only supports one window"); } Android_PauseSem = SDL_CreateSemaphore(0); Android_ResumeSem = SDL_CreateSemaphore(0); /* Adjust the window data to match the screen */ window->x = 0; window->y = 0; window->w = Android_ScreenWidth; window->h = Android_ScreenHeight; window->flags &= ~SDL_WINDOW_RESIZABLE; /* window is NEVER resizeable */ window->flags |= SDL_WINDOW_FULLSCREEN; /* window is always fullscreen */ window->flags &= ~SDL_WINDOW_HIDDEN; window->flags |= SDL_WINDOW_SHOWN; /* only one window on Android */ window->flags |= SDL_WINDOW_INPUT_FOCUS; /* always has input focus */ /* One window, it always has focus */ SDL_SetMouseFocus(window); SDL_SetKeyboardFocus(window); data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data)); if (!data) { return SDL_OutOfMemory(); } data->native_window = Android_JNI_GetNativeWindow(); if (!data->native_window) { SDL_free(data); return SDL_SetError("Could not fetch native window"); } /* Do not create EGLSurface for Vulkan window since it will then make the window incompatible with vkCreateAndroidSurfaceKHR */ if ((window->flags & SDL_WINDOW_VULKAN) == 0) { data->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) data->native_window); if (data->egl_surface == EGL_NO_SURFACE) { ANativeWindow_release(data->native_window); SDL_free(data); return SDL_SetError("Could not create GLES window surface"); } } window->driverdata = data; Android_Window = window; return 0; }
void VIVANTE_ShowWindow(_THIS, SDL_Window * window) { #if SDL_VIDEO_DRIVER_VIVANTE_VDK SDL_WindowData *data = window->driverdata; vdkShowWindow(data->native_window); #endif SDL_SetMouseFocus(window); SDL_SetKeyboardFocus(window); }
static void X11_DispatchFocusOut(SDL_WindowData *data) { #ifdef DEBUG_XEVENTS printf("window %p: Dispatching FocusOut\n", data); #endif SDL_SetKeyboardFocus(NULL); #ifdef X_HAVE_UTF8_STRING if (data->ic) { XUnsetICFocus(data->ic); } #endif }
int N3DS_CreateWindow(_THIS, SDL_Window * window) { SDL_WindowData *wdata; /* Allocate window internal data */ wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData)); if (wdata == NULL) { return SDL_OutOfMemory(); } /* Setup driver data for this window */ window->driverdata = wdata; /* Set the keyboard focus */ SDL_SetKeyboardFocus(window); /* Window has been successfully created */ return 0; }
int FB_CreateWindow(_THIS, SDL_Window * window) { SDL_WindowData *wdata; SDL_VideoDisplay *display; /* Allocate window internal data */ wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData)); if (wdata == NULL) { return SDL_OutOfMemory(); } display = SDL_GetDisplayForWindow(window); /* Windows have one size for now */ window->w = display->desktop_mode.w; window->h = display->desktop_mode.h; /* OpenGL ES is the law here, buddy */ window->flags |= SDL_WINDOW_OPENGL; if (!_this->egl_data) { if (SDL_GL_LoadLibrary(NULL) < 0) { return -1; } } wdata->egl_surface = SDL_EGL_CreateSurface(_this, 0); if (wdata->egl_surface == EGL_NO_SURFACE) { return SDL_SetError("Could not create GLES window surface"); } /* Setup driver data for this window */ window->driverdata = wdata; /* One window, it always has focus */ SDL_SetMouseFocus(window); SDL_SetKeyboardFocus(window); /* Window has been successfully created */ return 0; }
static void keyboard_handle_enter(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface, struct wl_array *keys) { struct SDL_WaylandInput *input = data; SDL_WindowData *window; if (!surface) { /* enter event for a window we've just destroyed */ return; } window = wl_surface_get_user_data(surface); if (window) { input->keyboard_focus = window; window->keyboard_device = input; SDL_SetKeyboardFocus(window->sdlwindow); } }
static int SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_WindowData *data; /* Allocate the window data */ data = (SDL_WindowData *) SDL_calloc(1, sizeof(*data)); if (!data) { return SDL_OutOfMemory(); } data->window = window; data->hwnd = hwnd; data->hdc = GetDC(hwnd); data->created = created; data->mouse_button_flags = 0; data->videodata = videodata; window->driverdata = data; /* Associate the data with the window */ if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) { ReleaseDC(hwnd, data->hdc); SDL_free(data); return WIN_SetError("SetProp() failed"); } /* Set up the window proc function */ #ifdef GWLP_WNDPROC data->wndproc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC); if (data->wndproc == WIN_WindowProc) { data->wndproc = NULL; } else { SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc); } #else data->wndproc = (WNDPROC) GetWindowLong(hwnd, GWL_WNDPROC); if (data->wndproc == WIN_WindowProc) { data->wndproc = NULL; } else { SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR) WIN_WindowProc); } #endif /* Fill in the SDL window with the window data */ { RECT rect; if (GetClientRect(hwnd, &rect)) { int w = rect.right; int h = rect.bottom; if ((window->w && window->w != w) || (window->h && window->h != h)) { /* We tried to create a window larger than the desktop and Windows didn't allow it. Override! */ WIN_SetWindowPositionInternal(_this, window, SWP_NOCOPYBITS | SWP_NOZORDER | SWP_NOACTIVATE); } else { window->w = w; window->h = h; } } } { POINT point; point.x = 0; point.y = 0; if (ClientToScreen(hwnd, &point)) { window->x = point.x; window->y = point.y; } } { DWORD style = GetWindowLong(hwnd, GWL_STYLE); if (style & WS_VISIBLE) { window->flags |= SDL_WINDOW_SHOWN; } else { window->flags &= ~SDL_WINDOW_SHOWN; } if (style & (WS_BORDER | WS_THICKFRAME)) { window->flags &= ~SDL_WINDOW_BORDERLESS; } else { window->flags |= SDL_WINDOW_BORDERLESS; } if (style & WS_THICKFRAME) { window->flags |= SDL_WINDOW_RESIZABLE; } else { window->flags &= ~SDL_WINDOW_RESIZABLE; } #ifdef WS_MAXIMIZE if (style & WS_MAXIMIZE) { window->flags |= SDL_WINDOW_MAXIMIZED; } else #endif { window->flags &= ~SDL_WINDOW_MAXIMIZED; } #ifdef WS_MINIMIZE if (style & WS_MINIMIZE) { window->flags |= SDL_WINDOW_MINIMIZED; } else #endif { window->flags &= ~SDL_WINDOW_MINIMIZED; } } if (GetFocus() == hwnd) { window->flags |= SDL_WINDOW_INPUT_FOCUS; SDL_SetKeyboardFocus(data->window); if (window->flags & SDL_WINDOW_INPUT_GRABBED) { RECT rect; GetClientRect(hwnd, &rect); ClientToScreen(hwnd, (LPPOINT) & rect); ClientToScreen(hwnd, (LPPOINT) & rect + 1); ClipCursor(&rect); } } /* Enable multi-touch */ if (videodata->RegisterTouchWindow) { videodata->RegisterTouchWindow(hwnd, (TWF_FINETOUCH|TWF_WANTPALM)); } /* Enable dropping files */ DragAcceptFiles(hwnd, TRUE); /* All done! */ return 0; }
static void X11_DispatchEvent(_THIS) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; Display *display = videodata->display; SDL_WindowData *data; XEvent xevent; int i; SDL_zero(xevent); /* valgrind fix. --ryan. */ XNextEvent(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_GetEventState(SDL_SYSWMEVENT) == SDL_ENABLE) { SDL_SysWMmsg wmmsg; SDL_VERSION(&wmmsg.version); wmmsg.subsystem = SDL_SYSWM_X11; wmmsg.x11.event = 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]->xwindow == 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 SDL_SetMouseFocus(data->window); } 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.mode != NotifyGrab && xevent.xcrossing.mode != NotifyUngrab && xevent.xcrossing.detail != NotifyInferior) { SDL_SetMouseFocus(NULL); } } break; /* Gaining input focus? */ case FocusIn:{ #ifdef DEBUG_XEVENTS printf("FocusIn!\n"); #endif SDL_SetKeyboardFocus(data->window); #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(NULL); #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; SDL_scancode scancode; 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(SDL_PRESSED, videodata->key_layout[keycode]); #if 1 if (videodata->key_layout[keycode] == SDLK_UNKNOWN) { int min_keycode, max_keycode; XDisplayKeycodes(display, &min_keycode, &max_keycode); keysym = XKeycodeToKeysym(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%lX (%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(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 if (X11_KeyRepeat(display, &xevent)) { /* We're about to get a repeated key down, ignore the key up */ break; } SDL_SendKeyboardKey(SDL_RELEASED, videodata->key_layout[keycode]); } break; /* Have we been iconified? */ case UnmapNotify:{ #ifdef DEBUG_XEVENTS printf("UnmapNotify!\n"); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_HIDDEN, 0, 0); SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_MINIMIZED, 0, 0); } break; /* Have we been restored? */ case MapNotify:{ #ifdef DEBUG_XEVENTS printf("MapNotify!\n"); #endif SDL_SendWindowEvent(data->window, SDL_WINDOWEVENT_SHOWN, 0, 0); SDL_SendWindowEvent(data->window, 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->window, SDL_WINDOWEVENT_MOVED, xevent.xconfigure.x, xevent.xconfigure.y); SDL_SendWindowEvent(data->window, 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->window, 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->window, SDL_WINDOWEVENT_EXPOSED, 0, 0); } break; case MotionNotify:{ #ifdef DEBUG_MOTION printf("X11 motion: %d,%d\n", xevent.xmotion.x, xevent.xmotion.y); #endif SDL_SendMouseMotion(data->window, 0, xevent.xmotion.x, xevent.xmotion.y); } break; case ButtonPress:{ SDL_SendMouseButton(data->window, SDL_PRESSED, xevent.xbutton.button); } break; case ButtonRelease:{ SDL_SendMouseButton(data->window, SDL_RELEASED, xevent.xbutton.button); } break; case PropertyNotify:{ #ifdef DEBUG_XEVENTS unsigned char *propdata; int status, real_format; Atom real_type; unsigned long items_read, items_left, i; char *name = XGetAtomName(display, xevent.xproperty.atom); if (name) { printf("PropertyNotify: %s %s\n", name, (xevent.xproperty.state == PropertyDelete) ? "deleted" : "changed"); XFree(name); } status = XGetWindowProperty(display, data->xwindow, xevent.xproperty.atom, 0L, 8192L, False, AnyPropertyType, &real_type, &real_format, &items_read, &items_left, &propdata); if (status == Success && items_read > 0) { if (real_type == XA_INTEGER) { int *values = (int *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_type == XA_CARDINAL) { if (real_format == 32) { Uint32 *values = (Uint32 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 16) { Uint16 *values = (Uint16 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } else if (real_format == 8) { Uint8 *values = (Uint8 *)propdata; printf("{"); for (i = 0; i < items_read; i++) { printf(" %d", values[i]); } printf(" }\n"); } } else if (real_type == XA_STRING || real_type == videodata->UTF8_STRING) { printf("{ \"%s\" }\n", propdata); } else if (real_type == XA_ATOM) { Atom *atoms = (Atom *)propdata; printf("{"); for (i = 0; i < items_read; i++) { char *name = XGetAtomName(display, atoms[i]); if (name) { printf(" %s", name); XFree(name); } } printf(" }\n"); } else { char *name = XGetAtomName(display, real_type); printf("Unknown type: %ld (%s)\n", real_type, name ? name : "UNKNOWN"); if (name) { XFree(name); } } } #endif } break; /* Copy the selection from XA_CUT_BUFFER0 to the requested property */ case SelectionRequest: { XSelectionRequestEvent *req; XEvent sevent; int seln_format; unsigned long nbytes; unsigned long overflow; unsigned char *seln_data; req = &xevent.xselectionrequest; #ifdef DEBUG_XEVENTS printf("SelectionRequest (requestor = %ld, target = %ld)\n", req->requestor, req->target); #endif SDL_zero(sevent); sevent.xany.type = SelectionNotify; sevent.xselection.selection = req->selection; sevent.xselection.target = None; sevent.xselection.property = None; sevent.xselection.requestor = req->requestor; sevent.xselection.time = req->time; if (XGetWindowProperty(display, DefaultRootWindow(display), XA_CUT_BUFFER0, 0, INT_MAX/4, False, req->target, &sevent.xselection.target, &seln_format, &nbytes, &overflow, &seln_data) == Success) { if (sevent.xselection.target == req->target) { XChangeProperty(display, req->requestor, req->property, sevent.xselection.target, seln_format, PropModeReplace, seln_data, nbytes); sevent.xselection.property = req->property; } XFree(seln_data); } XSendEvent(display, req->requestor, False, 0, &sevent); XSync(display, False); } break; case SelectionNotify: { #ifdef DEBUG_XEVENTS printf("SelectionNotify (requestor = %ld, target = %ld)\n", xevent.xselection.requestor, xevent.xselection.target); #endif videodata->selection_waiting = SDL_FALSE; } break; default:{ #ifdef DEBUG_XEVENTS printf("Unhandled event %d\n", xevent.type); #endif } break; } }
static int SetupWindowData(_THIS, SDL_Window * window, HWND hwnd, SDL_bool created) { SDL_VideoData *videodata = (SDL_VideoData *) _this->driverdata; SDL_VideoDisplay *display = SDL_GetDisplayForWindow(window); SDL_WindowData *data; /* Allocate the window data */ data = (SDL_WindowData *) SDL_malloc(sizeof(*data)); if (!data) { SDL_OutOfMemory(); return -1; } data->window = window; data->hwnd = hwnd; data->hdc = GetDC(hwnd); data->created = created; data->mouse_pressed = SDL_FALSE; data->videodata = videodata; /* Associate the data with the window */ if (!SetProp(hwnd, TEXT("SDL_WindowData"), data)) { ReleaseDC(hwnd, data->hdc); SDL_free(data); WIN_SetError("SetProp() failed"); return -1; } /* Set up the window proc function */ #ifdef GWLP_WNDPROC data->wndproc = (WNDPROC) GetWindowLongPtr(hwnd, GWLP_WNDPROC); if (data->wndproc == WIN_WindowProc) { data->wndproc = NULL; } else { SetWindowLongPtr(hwnd, GWLP_WNDPROC, (LONG_PTR) WIN_WindowProc); } #else data->wndproc = (WNDPROC) GetWindowLong(hwnd, GWL_WNDPROC); if (data->wndproc == WIN_WindowProc) { data->wndproc = NULL; } else { SetWindowLong(hwnd, GWL_WNDPROC, (LONG_PTR) WIN_WindowProc); } #endif /* Fill in the SDL window with the window data */ { POINT point; point.x = 0; point.y = 0; if (ClientToScreen(hwnd, &point)) { window->x = point.x; window->y = point.y; } } { RECT rect; if (GetClientRect(hwnd, &rect)) { window->w = rect.right; window->h = rect.bottom; } } { DWORD style = GetWindowLong(hwnd, GWL_STYLE); if (style & WS_VISIBLE) { window->flags |= SDL_WINDOW_SHOWN; } else { window->flags &= ~SDL_WINDOW_SHOWN; } if (style & (WS_BORDER | WS_THICKFRAME)) { window->flags &= ~SDL_WINDOW_BORDERLESS; } else { window->flags |= SDL_WINDOW_BORDERLESS; } if (style & WS_THICKFRAME) { window->flags |= SDL_WINDOW_RESIZABLE; } else { window->flags &= ~SDL_WINDOW_RESIZABLE; } #ifdef WS_MAXIMIZE if (style & WS_MAXIMIZE) { window->flags |= SDL_WINDOW_MAXIMIZED; } else #endif { window->flags &= ~SDL_WINDOW_MAXIMIZED; } #ifdef WS_MINIMIZE if (style & WS_MINIMIZE) { window->flags |= SDL_WINDOW_MINIMIZED; } else #endif { window->flags &= ~SDL_WINDOW_MINIMIZED; } } if (GetFocus() == hwnd) { window->flags |= SDL_WINDOW_INPUT_FOCUS; SDL_SetKeyboardFocus(data->window); if (window->flags & SDL_WINDOW_INPUT_GRABBED) { RECT rect; GetClientRect(hwnd, &rect); ClientToScreen(hwnd, (LPPOINT) & rect); ClientToScreen(hwnd, (LPPOINT) & rect + 1); ClipCursor(&rect); } } /* Enable multi-touch */ if (videodata->RegisterTouchWindow) { videodata->RegisterTouchWindow(hwnd, (TWF_FINETOUCH|TWF_WANTPALM)); } /* All done! */ window->driverdata = data; return 0; }
int MIR_CreateWindow(_THIS, SDL_Window* window) { MIR_Window* mir_window; MIR_Data* mir_data; MirPixelFormat pixel_format; MirBufferUsage buffer_usage; MirSurfaceSpec* spec; mir_window = SDL_calloc(1, sizeof(MIR_Window)); if (!mir_window) return SDL_OutOfMemory(); mir_data = _this->driverdata; window->driverdata = mir_window; if (window->x == SDL_WINDOWPOS_UNDEFINED) window->x = 0; if (window->y == SDL_WINDOWPOS_UNDEFINED) window->y = 0; mir_window->mir_data = mir_data; mir_window->sdl_window = window; if (window->flags & SDL_WINDOW_OPENGL) { pixel_format = MIR_mir_connection_get_egl_pixel_format(mir_data->connection, _this->egl_data->egl_display, _this->egl_data->egl_config); } else { pixel_format = FindValidPixelFormat(mir_data); } mir_data->pixel_format = pixel_format; if (pixel_format == mir_pixel_format_invalid) { return SDL_SetError("Failed to find a valid pixel format."); } buffer_usage = mir_buffer_usage_hardware; if (mir_data->software) buffer_usage = mir_buffer_usage_software; spec = MIR_mir_connection_create_spec_for_normal_surface(mir_data->connection, window->w, window->h, pixel_format); MIR_mir_surface_spec_set_buffer_usage(spec, buffer_usage); MIR_mir_surface_spec_set_name(spec, "Mir surface"); if (window->flags & SDL_WINDOW_INPUT_FOCUS) SDL_SetKeyboardFocus(window); mir_window->surface = MIR_mir_surface_create_sync(spec); MIR_mir_surface_set_event_handler(mir_window->surface, MIR_HandleEvent, window); MIR_mir_surface_spec_release(spec); if (!MIR_mir_surface_is_valid(mir_window->surface)) { return SDL_SetError("Failed to created a mir surface: %s", MIR_mir_surface_get_error_message(mir_window->surface)); } if (window->flags & SDL_WINDOW_OPENGL) { EGLNativeWindowType egl_native_window = (EGLNativeWindowType)MIR_mir_buffer_stream_get_egl_native_window( MIR_mir_surface_get_buffer_stream(mir_window->surface)); mir_window->egl_surface = SDL_EGL_CreateSurface(_this, egl_native_window); if (mir_window->egl_surface == EGL_NO_SURFACE) { return SDL_SetError("Failed to created a window surface %p", _this->egl_data->egl_display); } } else { mir_window->egl_surface = EGL_NO_SURFACE; } mir_data->current_window = mir_window; return 0; }
static void keyboard_handle_leave(void *data, struct wl_keyboard *keyboard, uint32_t serial, struct wl_surface *surface) { SDL_SetKeyboardFocus(NULL); }
int RPI_CreateWindow(_THIS, SDL_Window * window) { SDL_WindowData *wdata; SDL_VideoDisplay *display; SDL_DisplayData *displaydata; VC_RECT_T dst_rect; VC_RECT_T src_rect; VC_DISPMANX_ALPHA_T dispman_alpha; DISPMANX_UPDATE_HANDLE_T dispman_update; /* Disable alpha, otherwise the app looks composed with whatever dispman is showing (X11, console,etc) */ dispman_alpha.flags = DISPMANX_FLAGS_ALPHA_FIXED_ALL_PIXELS; dispman_alpha.opacity = 0xFF; dispman_alpha.mask = 0; /* Allocate window internal data */ wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData)); if (wdata == NULL) { return SDL_OutOfMemory(); } display = SDL_GetDisplayForWindow(window); displaydata = (SDL_DisplayData *) display->driverdata; /* Windows have one size for now */ window->w = display->desktop_mode.w; window->h = display->desktop_mode.h; /* OpenGL ES is the law here, buddy */ window->flags |= SDL_WINDOW_OPENGL; /* Create a dispman element and associate a window to it */ dst_rect.x = 0; dst_rect.y = 0; dst_rect.width = window->w; dst_rect.height = window->h; src_rect.x = 0; src_rect.y = 0; src_rect.width = window->w << 16; src_rect.height = window->h << 16; dispman_update = vc_dispmanx_update_start( 0 ); wdata->dispman_window.element = vc_dispmanx_element_add ( dispman_update, displaydata->dispman_display, SDL_RPI_VIDEOLAYER /* layer */, &dst_rect, 0/*src*/, &src_rect, DISPMANX_PROTECTION_NONE, &dispman_alpha /*alpha*/, 0/*clamp*/, 0/*transform*/); wdata->dispman_window.width = window->w; wdata->dispman_window.height = window->h; vc_dispmanx_update_submit_sync( dispman_update ); if (!_this->egl_data) { if (SDL_GL_LoadLibrary(NULL) < 0) { return -1; } } wdata->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) &wdata->dispman_window); if (wdata->egl_surface == EGL_NO_SURFACE) { return SDL_SetError("Could not create GLES window surface"); } /* Setup driver data for this window */ window->driverdata = wdata; /* One window, it always has focus */ SDL_SetMouseFocus(window); SDL_SetKeyboardFocus(window); /* Window has been successfully created */ return 0; }
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; } }
int KMSDRM_CreateWindow(_THIS, SDL_Window * window) { SDL_WindowData *wdata; SDL_VideoDisplay *display; SDL_VideoData *vdata = ((SDL_VideoData *)_this->driverdata); Uint32 surface_fmt, surface_flags; /* Allocate window internal data */ wdata = (SDL_WindowData *) SDL_calloc(1, sizeof(SDL_WindowData)); if (wdata == NULL) { SDL_OutOfMemory(); goto error; } wdata->waiting_for_flip = SDL_FALSE; display = SDL_GetDisplayForWindow(window); /* Windows have one size for now */ window->w = display->desktop_mode.w; window->h = display->desktop_mode.h; /* Maybe you didn't ask for a fullscreen OpenGL window, but that's what you get */ window->flags |= (SDL_WINDOW_FULLSCREEN | SDL_WINDOW_OPENGL); surface_fmt = GBM_FORMAT_XRGB8888; surface_flags = GBM_BO_USE_SCANOUT | GBM_BO_USE_RENDERING; if (!KMSDRM_gbm_device_is_format_supported(vdata->gbm, surface_fmt, surface_flags)) { SDL_LogWarn(SDL_LOG_CATEGORY_VIDEO, "GBM surface format not supported. Trying anyway."); } wdata->gs = KMSDRM_gbm_surface_create(vdata->gbm, window->w, window->h, surface_fmt, surface_flags); #if SDL_VIDEO_OPENGL_EGL if (!_this->egl_data) { if (SDL_GL_LoadLibrary(NULL) < 0) { goto error; } } wdata->egl_surface = SDL_EGL_CreateSurface(_this, (NativeWindowType) wdata->gs); if (wdata->egl_surface == EGL_NO_SURFACE) { SDL_SetError("Could not create EGL window surface"); goto error; } #endif /* SDL_VIDEO_OPENGL_EGL */ /* In case we want low-latency, double-buffer video, we take note here */ wdata->double_buffer = SDL_FALSE; if (SDL_GetHintBoolean(SDL_HINT_VIDEO_DOUBLE_BUFFER, SDL_FALSE)) { wdata->double_buffer = SDL_TRUE; } /* Window is created, but we have yet to set up CRTC to one of the GBM buffers if we want drmModePageFlip to work, and we can't do it until EGL is completely setup, because we need to do eglSwapBuffers so we can get a valid GBM buffer object to call drmModeSetCrtc on it. */ wdata->crtc_ready = SDL_FALSE; /* Setup driver data for this window */ window->driverdata = wdata; /* One window, it always has focus */ SDL_SetMouseFocus(window); SDL_SetKeyboardFocus(window); /* Window has been successfully created */ return 0; error: if (wdata != NULL) { #if SDL_VIDEO_OPENGL_EGL if (wdata->egl_surface != EGL_NO_SURFACE) SDL_EGL_DestroySurface(_this, wdata->egl_surface); #endif /* SDL_VIDEO_OPENGL_EGL */ if (wdata->gs != NULL) KMSDRM_gbm_surface_destroy(wdata->gs); SDL_free(wdata); } return -1; }