static void toggle_full_screen(DisplayState *ds)
{
gui_fullscreen = !gui_fullscreen;
if (gui_fullscreen) {
gui_saved_width = real_screen->w;
gui_saved_height = real_screen->h;
gui_saved_scaling = scaling_active;
do_sdl_resize(ds_get_width(ds), ds_get_height(ds),
ds_get_bits_per_pixel(ds));
scaling_active = 0;
gui_saved_grab = gui_grab;
sdl_grab_start();
} else {
if (gui_saved_scaling) {
sdl_scale(ds, gui_saved_width, gui_saved_height);
} else {
do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
}
if (!gui_saved_grab || !is_graphic_console()) {
sdl_grab_end();
}
}
vga_hw_invalidate();
vga_hw_update();
}
static void curses_resize(DisplayState *ds)
{
if (ds_get_width(ds) == gwidth && ds_get_height(ds) == gheight)
return;
gwidth = ds_get_width(ds);
gheight = ds_get_height(ds);
curses_calc_pad();
ds->surface->width = width * FONT_WIDTH;
ds->surface->height = height * FONT_HEIGHT;
}
/*
* Send a mouse event from the client to the guest OS
*
* The QEMU mouse can be in either relative, or absolute mode.
* Movement is sent separately from button state, which has to
* be encoded as virtual key events. We also don't actually get
* given any button up/down events, so have to track changes in
* the button state.
*/
static void xenfb_mouse_event(void *opaque,
int dx, int dy, int dz, int button_state)
{
struct XenInput *xenfb = opaque;
int dw = ds_get_width(xenfb->c.ds);
int dh = ds_get_height(xenfb->c.ds);
int i;
if (xenfb->abs_pointer_wanted)
xenfb_send_position(xenfb,
dx * (dw - 1) / 0x7fff,
dy * (dh - 1) / 0x7fff,
dz);
else
xenfb_send_motion(xenfb, dx, dy, dz);
for (i = 0 ; i < 8 ; i++) {
int lastDown = xenfb->button_state & (1 << i);
int down = button_state & (1 << i);
if (down == lastDown)
continue;
if (xenfb_send_key(xenfb, down, BTN_LEFT+i) < 0)
return;
}
xenfb->button_state = button_state;
}
static void sdl_setdata(DisplayState *ds)
{
if (guest_screen != NULL) SDL_FreeSurface(guest_screen);
guest_screen = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), ds_get_width(ds), ds_get_height(ds),
ds_get_bits_per_pixel(ds), ds_get_linesize(ds),
ds->surface->pf.rmask, ds->surface->pf.gmask,
ds->surface->pf.bmask, ds->surface->pf.amask);
}
static void sdl_resize(DisplayState *ds)
{
if (!scaling_active) {
do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
} else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds)) {
do_sdl_resize(real_screen->w, real_screen->h,
ds_get_bits_per_pixel(ds));
}
sdl_setdata(ds);
}
static void qemu_spice_create_update(SimpleSpiceDisplay *ssd)
{
static const int blksize = 32;
int blocks = (ds_get_width(ssd->ds) + blksize - 1) / blksize;
int dirty_top[blocks];
int y, yoff, x, xoff, blk, bw;
int bpp = ds_get_bytes_per_pixel(ssd->ds);
uint8_t *guest, *mirror;
if (qemu_spice_rect_is_empty(&ssd->dirty)) {
return;
};
if (ssd->conv == NULL) {
PixelFormat dst = qemu_default_pixelformat(32);
ssd->conv = qemu_pf_conv_get(&dst, &ssd->ds->surface->pf);
assert(ssd->conv);
}
if (ssd->ds_mirror == NULL) {
int size = ds_get_height(ssd->ds) * ds_get_linesize(ssd->ds);
ssd->ds_mirror = g_malloc0(size);
}
for (blk = 0; blk < blocks; blk++) {
dirty_top[blk] = -1;
}
guest = ds_get_data(ssd->ds);
mirror = ssd->ds_mirror;
for (y = ssd->dirty.top; y < ssd->dirty.bottom; y++) {
yoff = y * ds_get_linesize(ssd->ds);
for (x = ssd->dirty.left; x < ssd->dirty.right; x += blksize) {
xoff = x * bpp;
blk = x / blksize;
bw = MIN(blksize, ssd->dirty.right - x);
if (memcmp(guest + yoff + xoff,
mirror + yoff + xoff,
bw * bpp) == 0) {
if (dirty_top[blk] != -1) {
QXLRect update = {
.top = dirty_top[blk],
.bottom = y,
.left = x,
.right = x + bw,
};
qemu_spice_create_one_update(ssd, &update);
dirty_top[blk] = -1;
}
} else {
if (dirty_top[blk] == -1) {
dirty_top[blk] = y;
}
}
}
}
static void opengl_setdata(DisplayState *ds)
{
glEnable(GL_TEXTURE_RECTANGLE_ARB);
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_REPLACE);
glClearColor(0, 0, 0, 0);
glDisable(GL_BLEND);
glDisable(GL_LIGHTING);
glDisable(GL_DEPTH_TEST);
glDepthMask(GL_FALSE);
glDisable(GL_CULL_FACE);
glViewport( 0, 0, real_screen->w, real_screen->h);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0, real_screen->w, real_screen->h, 0, -1,1);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glClear(GL_COLOR_BUFFER_BIT);
if (texture_ref) {
glDeleteTextures(1, &texture_ref);
texture_ref = 0;
}
glGenTextures(1, &texture_ref);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture_ref);
glPixelStorei(GL_UNPACK_LSB_FIRST, 1);
switch (ds_get_bits_per_pixel(ds)) {
case 16:
tex_format = GL_RGB;
tex_type = GL_UNSIGNED_SHORT_5_6_5;
break;
case 24:
tex_format = GL_BGR;
tex_type = GL_UNSIGNED_BYTE;
break;
case 32:
if (bgr == (ds->surface->pf.rshift < ds->surface->pf.bshift)) {
tex_format = GL_BGRA;
tex_type = GL_UNSIGNED_BYTE;
} else {
tex_format = GL_RGBA;
tex_type = GL_UNSIGNED_BYTE;
}
break;
}
glPixelStorei(GL_UNPACK_ROW_LENGTH, (ds_get_linesize(ds) / ds_get_bytes_per_pixel(ds)));
glTexImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, gl_format, ds_get_width(ds), ds_get_height(ds), 0, tex_format, tex_type, ds_get_data(ds));
glTexParameterf(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_PRIORITY, 1.0);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_RECTANGLE_ARB, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
}
static void opengl_update(DisplayState *ds, int x, int y, int w, int h)
{
int bpp = ds_get_bytes_per_pixel(ds);
GLvoid *pixels = ds_get_data(ds) + y * ds_get_linesize(ds) + x * bpp;
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, texture_ref);
glPixelStorei(GL_UNPACK_ROW_LENGTH, ds_get_linesize(ds) / bpp);
glTexSubImage2D(GL_TEXTURE_RECTANGLE_ARB, 0, x, y, w, h, tex_format, tex_type, pixels);
glBegin(GL_QUADS);
glTexCoord2d(0, 0);
glVertex2d(0, 0);
glTexCoord2d(ds_get_width(ds), 0);
glVertex2d(real_screen->w, 0);
glTexCoord2d(ds_get_width(ds), ds_get_height(ds));
glVertex2d(real_screen->w, real_screen->h);
glTexCoord2d(0, ds_get_height(ds));
glVertex2d(0, real_screen->h);
glEnd();
glBindTexture(GL_TEXTURE_RECTANGLE_ARB, 0);
SDL_GL_SwapBuffers();
}
void qemu_spice_create_host_primary(SimpleSpiceDisplay *ssd)
{
QXLDevSurfaceCreate surface;
memset(&surface, 0, sizeof(surface));
dprint(1, "%s: %dx%d\n", __FUNCTION__,
ds_get_width(ssd->ds), ds_get_height(ssd->ds));
surface.format = SPICE_SURFACE_FMT_32_xRGB;
surface.width = ds_get_width(ssd->ds);
surface.height = ds_get_height(ssd->ds);
surface.stride = -surface.width * 4;
surface.mouse_mode = true;
surface.flags = 0;
surface.type = 0;
surface.mem = (uintptr_t)ssd->buf;
surface.group_id = MEMSLOT_GROUP_HOST;
qemu_spice_create_primary_surface(ssd, 0, &surface, QXL_SYNC);
}
static void sdl_resize(DisplayState *ds)
{
if (!allocator) {
do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
sdl_setdata(ds);
} else {
if (guest_screen != NULL) {
SDL_FreeSurface(guest_screen);
guest_screen = NULL;
}
}
}
static void sdl_scale(DisplayState *ds, int width, int height)
{
int bpp = real_screen->format->BitsPerPixel;
if (bpp != 16 && bpp != 32) {
bpp = 32;
}
do_sdl_resize(width, height, bpp);
scaling_active = 1;
if (!is_buffer_shared(ds->surface)) {
ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds),
ds_get_height(ds));
dpy_gfx_resize(ds);
}
}
static void sdl_resize(DisplayState *ds)
{
if (!allocator) {
if (!scaling_active)
do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds))
do_sdl_resize(real_screen->w, real_screen->h, ds_get_bits_per_pixel(ds));
sdl_setdata(ds);
} else {
if (guest_screen != NULL) {
SDL_FreeSurface(guest_screen);
guest_screen = NULL;
}
}
}
static void handle_keydown(DisplayState *ds, SDL_Event *ev)
{
int mod_state;
int keycode;
if (alt_grab) {
mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
(gui_grab_code | KMOD_LSHIFT);
} else if (ctrl_grab) {
mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
} else {
mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code;
}
gui_key_modifier_pressed = mod_state;
if (gui_key_modifier_pressed) {
keycode = sdl_keyevent_to_keycode(&ev->key);
switch (keycode) {
case 0x21: /* 'f' key on US keyboard */
toggle_full_screen(ds);
gui_keysym = 1;
break;
case 0x16: /* 'u' key on US keyboard */
if (scaling_active) {
scaling_active = 0;
sdl_resize(ds);
vga_hw_invalidate();
vga_hw_update();
}
gui_keysym = 1;
break;
case 0x02 ... 0x0a: /* '1' to '9' keys */
/* Reset the modifiers sent to the current console */
reset_keys();
console_select(keycode - 0x02);
gui_keysym = 1;
if (gui_fullscreen) {
break;
}
if (!is_graphic_console()) {
/* release grab if going to a text console */
if (gui_grab) {
sdl_grab_end();
} else if (absolute_enabled) {
sdl_show_cursor();
}
} else if (absolute_enabled) {
sdl_hide_cursor();
absolute_mouse_grab();
}
break;
case 0x1b: /* '+' */
case 0x35: /* '-' */
if (!gui_fullscreen) {
int width = MAX(real_screen->w + (keycode == 0x1b ? 50 : -50),
160);
int height = (ds_get_height(ds) * width) / ds_get_width(ds);
sdl_scale(ds, width, height);
vga_hw_invalidate();
vga_hw_update();
gui_keysym = 1;
}
default:
break;
}
} else if (!is_graphic_console()) {
static void sdl_refresh(DisplayState *ds)
{
SDL_Event ev1, *ev = &ev1;
int mod_state;
int buttonstate = SDL_GetMouseState(NULL, NULL);
if (last_vm_running != vm_running) {
last_vm_running = vm_running;
sdl_update_caption();
}
vga_hw_update();
SDL_EnableUNICODE(!is_graphic_console());
while (SDL_PollEvent(ev)) {
switch (ev->type) {
case SDL_VIDEOEXPOSE:
sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
break;
case SDL_KEYDOWN:
case SDL_KEYUP:
if (ev->type == SDL_KEYDOWN) {
if (alt_grab) {
mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
(gui_grab_code | KMOD_LSHIFT);
} else if (ctrl_grab) {
mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
} else {
mod_state = (SDL_GetModState() & gui_grab_code) ==
gui_grab_code;
}
gui_key_modifier_pressed = mod_state;
if (gui_key_modifier_pressed) {
int keycode;
keycode = sdl_keyevent_to_keycode(&ev->key);
switch(keycode) {
case 0x21: /* 'f' key on US keyboard */
toggle_full_screen(ds);
gui_keysym = 1;
break;
case 0x16: /* 'u' key on US keyboard */
scaling_active = 0;
sdl_resize(ds);
vga_hw_invalidate();
vga_hw_update();
break;
case 0x02 ... 0x0a: /* '1' to '9' keys */
/* Reset the modifiers sent to the current console */
reset_keys();
console_select(keycode - 0x02);
if (!is_graphic_console()) {
/* display grab if going to a text console */
if (gui_grab)
sdl_grab_end();
}
gui_keysym = 1;
break;
default:
break;
}
} else if (!is_graphic_console()) {
int keysym;
keysym = 0;
if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
switch(ev->key.keysym.sym) {
case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
default: break;
}
} else {
switch(ev->key.keysym.sym) {
case SDLK_UP: keysym = QEMU_KEY_UP; break;
case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
case SDLK_END: keysym = QEMU_KEY_END; break;
case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
default: break;
}
}
if (keysym) {
kbd_put_keysym(keysym);
} else if (ev->key.keysym.unicode != 0) {
kbd_put_keysym(ev->key.keysym.unicode);
}
}
} else if (ev->type == SDL_KEYUP) {
if (!alt_grab) {
mod_state = (ev->key.keysym.mod & gui_grab_code);
} else {
mod_state = (ev->key.keysym.mod &
(gui_grab_code | KMOD_LSHIFT));
}
if (!mod_state) {
if (gui_key_modifier_pressed) {
gui_key_modifier_pressed = 0;
if (gui_keysym == 0) {
/* exit/enter grab if pressing Ctrl-Alt */
if (!gui_grab) {
/* if the application is not active,
do not try to enter grab state. It
prevents
'SDL_WM_GrabInput(SDL_GRAB_ON)'
from blocking all the application
(SDL bug). */
if (SDL_GetAppState() & SDL_APPACTIVE)
sdl_grab_start();
} else {
sdl_grab_end();
}
/* SDL does not send back all the
modifiers key, so we must correct it */
reset_keys();
break;
}
gui_keysym = 0;
}
}
}
if (is_graphic_console() && !gui_keysym)
sdl_process_key(&ev->key);
break;
case SDL_QUIT:
if (!no_quit)
qemu_system_shutdown_request();
break;
case SDL_MOUSEMOTION:
if (gui_grab || kbd_mouse_is_absolute() ||
absolute_enabled) {
sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
ev->motion.x, ev->motion.y, ev->motion.state);
}
break;
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
{
SDL_MouseButtonEvent *bev = &ev->button;
if (!gui_grab && !kbd_mouse_is_absolute()) {
if (ev->type == SDL_MOUSEBUTTONDOWN &&
(bev->button == SDL_BUTTON_LEFT)) {
/* start grabbing all events */
sdl_grab_start();
}
} else {
int dz;
dz = 0;
if (ev->type == SDL_MOUSEBUTTONDOWN) {
buttonstate |= SDL_BUTTON(bev->button);
} else {
buttonstate &= ~SDL_BUTTON(bev->button);
}
#ifdef SDL_BUTTON_WHEELUP
if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
dz = -1;
} else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
dz = 1;
}
#endif
sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
}
}
break;
case SDL_ACTIVEEVENT:
if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
!ev->active.gain && !gui_fullscreen_initial_grab) {
sdl_grab_end();
}
if (ev->active.state & SDL_APPACTIVE) {
if (ev->active.gain) {
/* Back to default interval */
dcl->gui_timer_interval = 0;
dcl->idle = 0;
} else {
/* Sleeping interval */
dcl->gui_timer_interval = 500;
dcl->idle = 1;
}
}
break;
case SDL_VIDEORESIZE:
{
SDL_ResizeEvent *rev = &ev->resize;
int bpp = real_screen->format->BitsPerPixel;
if (bpp != 16 && bpp != 32)
bpp = 32;
do_sdl_resize(rev->w, rev->h, bpp);
scaling_active = 1;
if (!is_buffer_shared(ds->surface)) {
ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds), ds_get_height(ds));
dpy_resize(ds);
}
vga_hw_invalidate();
vga_hw_update();
break;
}
default:
break;
}
static void handle_keydown(DisplayState *ds, SDL_Event *ev)
{
int mod_state;
int keycode;
if (alt_grab) {
// LOGV("Found alt grab\n");
mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
(gui_grab_code | KMOD_LSHIFT);
} else if (ctrl_grab) {
// LOGV("Found ctrl grab\n");
mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
} else {
// LOGV("Default grab\n");
mod_state = (SDL_GetModState() & gui_grab_code) == gui_grab_code;
}
gui_key_modifier_pressed = mod_state;
if (gui_key_modifier_pressed) {
keycode = sdl_keyevent_to_keycode(&ev->key);
// LOGV("Found modifier pressed for key/keycode = %d/%d\n", ev->key.keysym.sym, keycode);
switch (keycode) {
case 1: /* 'f' key on US keyboard */
LOGV("Keycode Pressed 'f' Fullscreen\n");
toggle_full_screen(ds);
gui_keysym = 1;
break;
case 16: /* 'u' key on US keyboard */
LOGV("Keycode Pressed 'u' unset Scale\n");
if (scaling_active) {
LOGV("Found scaling active Unsetting...\n");
scaling_active = 0;
sdl_resize(ds);
vga_hw_invalidate();
vga_hw_update();
reset_keys();
}
gui_keysym = 1;
break;
case 22 ... 23: /* '1' to '9' keys */ //MK hack
/* Reset the modifiers sent to the current console */
LOGV("Keycode Pressed '1-9' console\n");
reset_keys();
console_select(keycode - 22);
gui_keysym = 1;
// if (gui_fullscreen) {
// LOGV("Found fullscreen breaking...\n");
// break;
// }
if (!is_graphic_console()) {
/* release grab if going to a text console */
LOGV("Found text console releasing grab...\n");
if (gui_grab) {
LOGV("Found grab, grab ending...\n");
sdl_grab_end();
} else if (absolute_enabled) {
LOGV("Found absolute_enabled, show cursor...\n");
sdl_show_cursor();
}
} else if (absolute_enabled) {
LOGV("Found absolute_enabled, hiding cursor and grabing mouse...\n");
sdl_hide_cursor();
absolute_mouse_grab();
}
break;
case 24: /* '4' Zoom In */
case 25: /* '3' Zoom Out*/
LOGV("Keycode Pressed '3/4' Zoom\n");
// if (!gui_fullscreen) {
{
int width = MAX(real_screen->w + (keycode == 25 ? 50 : -50),
160);
int height = (ds_get_height(ds) * width) / ds_get_width(ds);
LOGV("Found no fullscreen, scaling to: %dx%d \n", width, height);
sdl_scale(ds, width, height);
vga_hw_invalidate();
vga_hw_update();
reset_keys();
gui_keysym = 1;
}
// }
break;
case 26: /* Fit to Screen */
LOGV("Keycode Pressed '5' Fit to Screen\n");
// if (!gui_fullscreen) {
{
int width;
int height;
AndroidGetWindowSize(&width, &height);
LOGV("Got Android window size=%dx%d", width, height);
LOGV("Got VM resolution=%dx%d", ds_get_width(ds), ds_get_height(ds));
float aspectRatio = (float) ds_get_height(ds) / (float) ds_get_width(ds);
LOGV("Got aspectRatio=%f", aspectRatio);
int new_width = (int) (height / aspectRatio);
if(new_width > width){
LOGV("Width is overrun, modifying height");
new_width = width;
height = width * aspectRatio;
}
LOGV("Found no fullscreen, Fit To Screen: %dx%d \n", new_width, height);
sdl_scale(ds, new_width, height);
vga_hw_invalidate();
vga_hw_update();
reset_keys();
gui_keysym = 1;
}
// }
break;
case 27: /* Stretch to Screen */
LOGV("Keycode Pressed '6' Fit to Screen\n");
// if (!gui_fullscreen) {
{
int width;
int height;
AndroidGetWindowSize(&width, &height);
LOGV("Found no fullscreen, Fit To Screen: %dx%d \n", width, height);
sdl_scale(ds, width, height);
vga_hw_invalidate();
vga_hw_update();
reset_keys();
gui_keysym = 1;
}
// }
break;
default:
LOGV("Default\n");
break;
}
} else if (!is_graphic_console()) {
