Annotation of qemu/sdl.c, revision 1.1.1.11

1.1       root        1: /*
                      2:  * QEMU SDL display driver
1.1.1.6   root        3:  *
1.1       root        4:  * Copyright (c) 2003 Fabrice Bellard
1.1.1.6   root        5:  *
1.1       root        6:  * Permission is hereby granted, free of charge, to any person obtaining a copy
                      7:  * of this software and associated documentation files (the "Software"), to deal
                      8:  * in the Software without restriction, including without limitation the rights
                      9:  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
                     10:  * copies of the Software, and to permit persons to whom the Software is
                     11:  * furnished to do so, subject to the following conditions:
                     12:  *
                     13:  * The above copyright notice and this permission notice shall be included in
                     14:  * all copies or substantial portions of the Software.
                     15:  *
                     16:  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
                     17:  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
                     18:  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
                     19:  * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
                     20:  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
                     21:  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
                     22:  * THE SOFTWARE.
                     23:  */
                     24: #include <SDL.h>
1.1.1.8   root       25: #include <SDL_syswm.h>
1.1       root       26: 
                     27: #ifndef _WIN32
                     28: #include <signal.h>
                     29: #endif
                     30: 
1.1.1.10  root       31: #include "qemu-common.h"
                     32: #include "console.h"
                     33: #include "sysemu.h"
                     34: #include "x_keymap.h"
                     35: #include "sdl_zoom.h"
                     36: 
1.1.1.7   root       37: static DisplayChangeListener *dcl;
                     38: static SDL_Surface *real_screen;
                     39: static SDL_Surface *guest_screen = NULL;
1.1       root       40: static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
                     41: static int last_vm_running;
                     42: static int gui_saved_grab;
                     43: static int gui_fullscreen;
1.1.1.6   root       44: static int gui_noframe;
1.1       root       45: static int gui_key_modifier_pressed;
                     46: static int gui_keysym;
                     47: static int gui_fullscreen_initial_grab;
                     48: static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
                     49: static uint8_t modifiers_state[256];
1.1.1.3   root       50: static int width, height;
                     51: static SDL_Cursor *sdl_cursor_normal;
                     52: static SDL_Cursor *sdl_cursor_hidden;
                     53: static int absolute_enabled = 0;
1.1.1.6   root       54: static int guest_cursor = 0;
                     55: static int guest_x, guest_y;
1.1.1.10  root       56: static SDL_Cursor *guest_sprite = NULL;
                     57: static uint8_t allocator;
                     58: static SDL_PixelFormat host_format;
                     59: static int scaling_active = 0;
1.1       root       60: 
                     61: static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
                     62: {
1.1.1.10  root       63:     //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
1.1.1.7   root       64:     SDL_Rect rec;
                     65:     rec.x = x;
                     66:     rec.y = y;
                     67:     rec.w = w;
                     68:     rec.h = h;
                     69: 
1.1.1.10  root       70:     if (guest_screen) {
                     71:         if (!scaling_active) {
                     72:             SDL_BlitSurface(guest_screen, &rec, real_screen, &rec);
                     73:         } else {
                     74:             if (sdl_zoom_blit(guest_screen, real_screen, SMOOTHING_ON, &rec) < 0) {
                     75:                 fprintf(stderr, "Zoom blit failed\n");
                     76:                 exit(1);
                     77:             }
                     78:         }
                     79:     } 
                     80:     SDL_UpdateRect(real_screen, rec.x, rec.y, rec.w, rec.h);
1.1.1.7   root       81: }
                     82: 
                     83: static void sdl_setdata(DisplayState *ds)
                     84: {
                     85:     SDL_Rect rec;
                     86:     rec.x = 0;
                     87:     rec.y = 0;
                     88:     rec.w = real_screen->w;
                     89:     rec.h = real_screen->h;
                     90: 
                     91:     if (guest_screen != NULL) SDL_FreeSurface(guest_screen);
                     92: 
                     93:     guest_screen = SDL_CreateRGBSurfaceFrom(ds_get_data(ds), ds_get_width(ds), ds_get_height(ds),
                     94:                                             ds_get_bits_per_pixel(ds), ds_get_linesize(ds),
                     95:                                             ds->surface->pf.rmask, ds->surface->pf.gmask,
                     96:                                             ds->surface->pf.bmask, ds->surface->pf.amask);
1.1       root       97: }
                     98: 
1.1.1.10  root       99: static void do_sdl_resize(int new_width, int new_height, int bpp)
1.1       root      100: {
                    101:     int flags;
                    102: 
                    103:     //    printf("resizing to %d %d\n", w, h);
                    104: 
1.1.1.10  root      105:     flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL|SDL_RESIZABLE;
1.1       root      106:     if (gui_fullscreen)
                    107:         flags |= SDL_FULLSCREEN;
1.1.1.6   root      108:     if (gui_noframe)
                    109:         flags |= SDL_NOFRAME;
1.1.1.2   root      110: 
1.1.1.10  root      111:     width = new_width;
                    112:     height = new_height;
                    113:     real_screen = SDL_SetVideoMode(width, height, bpp, flags);
1.1.1.7   root      114:     if (!real_screen) {
1.1       root      115:         fprintf(stderr, "Could not open SDL display\n");
                    116:         exit(1);
                    117:     }
1.1.1.10  root      118: }
                    119: 
                    120: static void sdl_resize(DisplayState *ds)
                    121: {
                    122:     if  (!allocator) {
                    123:         if (!scaling_active)
                    124:             do_sdl_resize(ds_get_width(ds), ds_get_height(ds), 0);
                    125:         else if (real_screen->format->BitsPerPixel != ds_get_bits_per_pixel(ds))
                    126:             do_sdl_resize(real_screen->w, real_screen->h, ds_get_bits_per_pixel(ds));
                    127:         sdl_setdata(ds);
                    128:     } else {
                    129:         if (guest_screen != NULL) {
                    130:             SDL_FreeSurface(guest_screen);
                    131:             guest_screen = NULL;
                    132:         }
                    133:     }
                    134: }
                    135: 
                    136: static PixelFormat sdl_to_qemu_pixelformat(SDL_PixelFormat *sdl_pf)
                    137: {
                    138:     PixelFormat qemu_pf;
                    139: 
                    140:     memset(&qemu_pf, 0x00, sizeof(PixelFormat));
                    141: 
                    142:     qemu_pf.bits_per_pixel = sdl_pf->BitsPerPixel;
                    143:     qemu_pf.bytes_per_pixel = sdl_pf->BytesPerPixel;
                    144:     qemu_pf.depth = (qemu_pf.bits_per_pixel) == 32 ? 24 : (qemu_pf.bits_per_pixel);
                    145: 
                    146:     qemu_pf.rmask = sdl_pf->Rmask;
                    147:     qemu_pf.gmask = sdl_pf->Gmask;
                    148:     qemu_pf.bmask = sdl_pf->Bmask;
                    149:     qemu_pf.amask = sdl_pf->Amask;
                    150: 
                    151:     qemu_pf.rshift = sdl_pf->Rshift;
                    152:     qemu_pf.gshift = sdl_pf->Gshift;
                    153:     qemu_pf.bshift = sdl_pf->Bshift;
                    154:     qemu_pf.ashift = sdl_pf->Ashift;
                    155: 
                    156:     qemu_pf.rbits = 8 - sdl_pf->Rloss;
                    157:     qemu_pf.gbits = 8 - sdl_pf->Gloss;
                    158:     qemu_pf.bbits = 8 - sdl_pf->Bloss;
                    159:     qemu_pf.abits = 8 - sdl_pf->Aloss;
                    160: 
                    161:     qemu_pf.rmax = ((1 << qemu_pf.rbits) - 1);
                    162:     qemu_pf.gmax = ((1 << qemu_pf.gbits) - 1);
                    163:     qemu_pf.bmax = ((1 << qemu_pf.bbits) - 1);
                    164:     qemu_pf.amax = ((1 << qemu_pf.abits) - 1);
                    165: 
                    166:     return qemu_pf;
                    167: }
                    168: 
                    169: static DisplaySurface* sdl_create_displaysurface(int width, int height)
                    170: {
                    171:     DisplaySurface *surface = (DisplaySurface*) qemu_mallocz(sizeof(DisplaySurface));
                    172:     if (surface == NULL) {
                    173:         fprintf(stderr, "sdl_create_displaysurface: malloc failed\n");
                    174:         exit(1);
                    175:     }
                    176: 
                    177:     surface->width = width;
                    178:     surface->height = height;
                    179:     
                    180:     if (scaling_active) {
                    181:         if (host_format.BytesPerPixel != 2 && host_format.BytesPerPixel != 4) {
                    182:             surface->linesize = width * 4;
                    183:             surface->pf = qemu_default_pixelformat(32);
                    184:         } else {
                    185:             surface->linesize = width * host_format.BytesPerPixel;
                    186:             surface->pf = sdl_to_qemu_pixelformat(&host_format);
                    187:         }
1.1.1.11! root      188: #ifdef HOST_WORDS_BIGENDIAN
1.1.1.10  root      189:         surface->flags = QEMU_ALLOCATED_FLAG | QEMU_BIG_ENDIAN_FLAG;
                    190: #else
                    191:         surface->flags = QEMU_ALLOCATED_FLAG;
                    192: #endif
                    193:         surface->data = (uint8_t*) qemu_mallocz(surface->linesize * surface->height);
                    194: 
                    195:         return surface;
                    196:     }
                    197: 
                    198:     if (host_format.BitsPerPixel == 16)
                    199:         do_sdl_resize(width, height, 16);
                    200:     else
                    201:         do_sdl_resize(width, height, 32);
                    202: 
                    203:     surface->pf = sdl_to_qemu_pixelformat(real_screen->format);
                    204:     surface->linesize = real_screen->pitch;
                    205:     surface->data = real_screen->pixels;
                    206: 
1.1.1.11! root      207: #ifdef HOST_WORDS_BIGENDIAN
1.1.1.10  root      208:     surface->flags = QEMU_REALPIXELS_FLAG | QEMU_BIG_ENDIAN_FLAG;
                    209: #else
                    210:     surface->flags = QEMU_REALPIXELS_FLAG;
                    211: #endif
                    212:     allocator = 1;
                    213: 
                    214:     return surface;
                    215: }
                    216: 
                    217: static void sdl_free_displaysurface(DisplaySurface *surface)
                    218: {
                    219:     allocator = 0;
                    220:     if (surface == NULL)
                    221:         return;
1.1.1.2   root      222: 
1.1.1.10  root      223:     if (surface->flags & QEMU_ALLOCATED_FLAG)
                    224:         qemu_free(surface->data);
                    225:     qemu_free(surface);
                    226: }
                    227: 
                    228: static DisplaySurface* sdl_resize_displaysurface(DisplaySurface *surface, int width, int height)
                    229: {
                    230:     sdl_free_displaysurface(surface);
                    231:     return sdl_create_displaysurface(width, height);
1.1       root      232: }
                    233: 
                    234: /* generic keyboard conversion */
                    235: 
                    236: #include "sdl_keysym.h"
                    237: 
                    238: static kbd_layout_t *kbd_layout = NULL;
                    239: 
                    240: static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
                    241: {
                    242:     int keysym;
                    243:     /* workaround for X11+SDL bug with AltGR */
                    244:     keysym = ev->keysym.sym;
                    245:     if (keysym == 0 && ev->keysym.scancode == 113)
                    246:         keysym = SDLK_MODE;
1.1.1.5   root      247:     /* For Japanese key '\' and '|' */
                    248:     if (keysym == 92 && ev->keysym.scancode == 133) {
                    249:         keysym = 0xa5;
                    250:     }
1.1       root      251:     return keysym2scancode(kbd_layout, keysym);
                    252: }
                    253: 
                    254: /* specific keyboard conversions from scan codes */
                    255: 
                    256: #if defined(_WIN32)
                    257: 
                    258: static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
                    259: {
                    260:     return ev->keysym.scancode;
                    261: }
                    262: 
                    263: #else
                    264: 
1.1.1.7   root      265: #if defined(SDL_VIDEO_DRIVER_X11)
                    266: #include <X11/XKBlib.h>
                    267: 
                    268: static int check_for_evdev(void)
                    269: {
                    270:     SDL_SysWMinfo info;
1.1.1.10  root      271:     XkbDescPtr desc = NULL;
1.1.1.7   root      272:     int has_evdev = 0;
1.1.1.10  root      273:     char *keycodes = NULL;
1.1.1.7   root      274: 
                    275:     SDL_VERSION(&info.version);
1.1.1.10  root      276:     if (!SDL_GetWMInfo(&info)) {
1.1.1.7   root      277:         return 0;
1.1.1.10  root      278:     }
1.1.1.7   root      279:     desc = XkbGetKeyboard(info.info.x11.display,
                    280:                           XkbGBN_AllComponentsMask,
                    281:                           XkbUseCoreKbd);
1.1.1.10  root      282:     if (desc && desc->names) {
                    283:         keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes);
                    284:         if (keycodes == NULL) {
                    285:             fprintf(stderr, "could not lookup keycode name\n");
                    286:         } else if (strstart(keycodes, "evdev", NULL)) {
                    287:             has_evdev = 1;
                    288:         } else if (!strstart(keycodes, "xfree86", NULL)) {
                    289:             fprintf(stderr, "unknown keycodes `%s', please report to "
                    290:                     "qemu-devel@nongnu.org\n", keycodes);
                    291:         }
                    292:     }
1.1.1.7   root      293: 
1.1.1.10  root      294:     if (desc) {
                    295:         XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True);
                    296:     }
                    297:     if (keycodes) {
                    298:         XFree(keycodes);
                    299:     }
1.1.1.7   root      300:     return has_evdev;
                    301: }
                    302: #else
                    303: static int check_for_evdev(void)
                    304: {
                    305:        return 0;
                    306: }
                    307: #endif
                    308: 
1.1       root      309: static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
                    310: {
                    311:     int keycode;
1.1.1.7   root      312:     static int has_evdev = -1;
                    313: 
                    314:     if (has_evdev == -1)
                    315:         has_evdev = check_for_evdev();
1.1       root      316: 
                    317:     keycode = ev->keysym.scancode;
                    318: 
                    319:     if (keycode < 9) {
                    320:         keycode = 0;
                    321:     } else if (keycode < 97) {
                    322:         keycode -= 8; /* just an offset */
1.1.1.7   root      323:     } else if (keycode < 158) {
1.1       root      324:         /* use conversion table */
1.1.1.7   root      325:         if (has_evdev)
                    326:             keycode = translate_evdev_keycode(keycode - 97);
                    327:         else
                    328:             keycode = translate_xfree86_keycode(keycode - 97);
                    329:     } else if (keycode == 208) { /* Hiragana_Katakana */
                    330:         keycode = 0x70;
                    331:     } else if (keycode == 211) { /* backslash */
                    332:         keycode = 0x73;
1.1       root      333:     } else {
                    334:         keycode = 0;
                    335:     }
                    336:     return keycode;
                    337: }
                    338: 
                    339: #endif
                    340: 
                    341: static void reset_keys(void)
                    342: {
                    343:     int i;
                    344:     for(i = 0; i < 256; i++) {
                    345:         if (modifiers_state[i]) {
                    346:             if (i & 0x80)
                    347:                 kbd_put_keycode(0xe0);
                    348:             kbd_put_keycode(i | 0x80);
                    349:             modifiers_state[i] = 0;
                    350:         }
                    351:     }
                    352: }
                    353: 
                    354: static void sdl_process_key(SDL_KeyboardEvent *ev)
                    355: {
                    356:     int keycode, v;
                    357: 
                    358:     if (ev->keysym.sym == SDLK_PAUSE) {
                    359:         /* specific case */
                    360:         v = 0;
                    361:         if (ev->type == SDL_KEYUP)
                    362:             v |= 0x80;
                    363:         kbd_put_keycode(0xe1);
                    364:         kbd_put_keycode(0x1d | v);
                    365:         kbd_put_keycode(0x45 | v);
                    366:         return;
                    367:     }
                    368: 
                    369:     if (kbd_layout) {
                    370:         keycode = sdl_keyevent_to_keycode_generic(ev);
                    371:     } else {
                    372:         keycode = sdl_keyevent_to_keycode(ev);
                    373:     }
                    374: 
                    375:     switch(keycode) {
                    376:     case 0x00:
                    377:         /* sent when leaving window: reset the modifiers state */
                    378:         reset_keys();
                    379:         return;
                    380:     case 0x2a:                          /* Left Shift */
                    381:     case 0x36:                          /* Right Shift */
                    382:     case 0x1d:                          /* Left CTRL */
                    383:     case 0x9d:                          /* Right CTRL */
                    384:     case 0x38:                          /* Left ALT */
                    385:     case 0xb8:                         /* Right ALT */
                    386:         if (ev->type == SDL_KEYUP)
                    387:             modifiers_state[keycode] = 0;
                    388:         else
                    389:             modifiers_state[keycode] = 1;
                    390:         break;
                    391:     case 0x45: /* num lock */
                    392:     case 0x3a: /* caps lock */
                    393:         /* SDL does not send the key up event, so we generate it */
                    394:         kbd_put_keycode(keycode);
                    395:         kbd_put_keycode(keycode | 0x80);
                    396:         return;
                    397:     }
                    398: 
                    399:     /* now send the key code */
                    400:     if (keycode & 0x80)
                    401:         kbd_put_keycode(0xe0);
                    402:     if (ev->type == SDL_KEYUP)
                    403:         kbd_put_keycode(keycode | 0x80);
                    404:     else
                    405:         kbd_put_keycode(keycode & 0x7f);
                    406: }
                    407: 
                    408: static void sdl_update_caption(void)
                    409: {
1.1.1.11! root      410:     char win_title[1024];
        !           411:     char icon_title[1024];
1.1.1.6   root      412:     const char *status = "";
                    413: 
                    414:     if (!vm_running)
                    415:         status = " [Stopped]";
                    416:     else if (gui_grab) {
1.1.1.11! root      417:         if (alt_grab)
1.1.1.6   root      418:             status = " - Press Ctrl-Alt-Shift to exit grab";
1.1.1.11! root      419:         else if (ctrl_grab)
        !           420:             status = " - Press Right-Ctrl to exit grab";
        !           421:         else
        !           422:             status = " - Press Ctrl-Alt to exit grab";
1.1       root      423:     }
1.1.1.6   root      424: 
1.1.1.11! root      425:     if (qemu_name) {
        !           426:         snprintf(win_title, sizeof(win_title), "QEMU (%s)%s", qemu_name, status);
        !           427:         snprintf(icon_title, sizeof(icon_title), "QEMU (%s)", qemu_name);
        !           428:     } else {
        !           429:         snprintf(win_title, sizeof(win_title), "QEMU%s", status);
        !           430:         snprintf(icon_title, sizeof(icon_title), "QEMU");
        !           431:     }
1.1.1.6   root      432: 
1.1.1.11! root      433:     SDL_WM_SetCaption(win_title, icon_title);
1.1       root      434: }
                    435: 
1.1.1.3   root      436: static void sdl_hide_cursor(void)
                    437: {
1.1.1.6   root      438:     if (!cursor_hide)
                    439:         return;
                    440: 
1.1.1.4   root      441:     if (kbd_mouse_is_absolute()) {
                    442:         SDL_ShowCursor(1);
                    443:         SDL_SetCursor(sdl_cursor_hidden);
                    444:     } else {
                    445:         SDL_ShowCursor(0);
                    446:     }
1.1.1.3   root      447: }
                    448: 
                    449: static void sdl_show_cursor(void)
                    450: {
1.1.1.6   root      451:     if (!cursor_hide)
                    452:         return;
                    453: 
1.1.1.3   root      454:     if (!kbd_mouse_is_absolute()) {
1.1.1.4   root      455:         SDL_ShowCursor(1);
1.1.1.6   root      456:         if (guest_cursor &&
                    457:                 (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
                    458:             SDL_SetCursor(guest_sprite);
                    459:         else
                    460:             SDL_SetCursor(sdl_cursor_normal);
1.1.1.3   root      461:     }
                    462: }
                    463: 
1.1       root      464: static void sdl_grab_start(void)
                    465: {
1.1.1.6   root      466:     if (guest_cursor) {
                    467:         SDL_SetCursor(guest_sprite);
1.1.1.7   root      468:         if (!kbd_mouse_is_absolute() && !absolute_enabled)
                    469:             SDL_WarpMouse(guest_x, guest_y);
1.1.1.6   root      470:     } else
                    471:         sdl_hide_cursor();
1.1.1.7   root      472: 
                    473:     if (SDL_WM_GrabInput(SDL_GRAB_ON) == SDL_GRAB_ON) {
                    474:         gui_grab = 1;
                    475:         sdl_update_caption();
                    476:     } else
                    477:         sdl_show_cursor();
1.1       root      478: }
                    479: 
                    480: static void sdl_grab_end(void)
                    481: {
                    482:     SDL_WM_GrabInput(SDL_GRAB_OFF);
                    483:     gui_grab = 0;
1.1.1.6   root      484:     sdl_show_cursor();
1.1       root      485:     sdl_update_caption();
                    486: }
                    487: 
1.1.1.7   root      488: static void sdl_send_mouse_event(int dx, int dy, int dz, int x, int y, int state)
1.1       root      489: {
1.1.1.7   root      490:     int buttons;
1.1       root      491:     buttons = 0;
                    492:     if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
                    493:         buttons |= MOUSE_EVENT_LBUTTON;
                    494:     if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
                    495:         buttons |= MOUSE_EVENT_RBUTTON;
                    496:     if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
                    497:         buttons |= MOUSE_EVENT_MBUTTON;
1.1.1.3   root      498: 
                    499:     if (kbd_mouse_is_absolute()) {
                    500:        if (!absolute_enabled) {
                    501:            sdl_hide_cursor();
                    502:            if (gui_grab) {
                    503:                sdl_grab_end();
                    504:            }
                    505:            absolute_enabled = 1;
                    506:        }
                    507: 
1.1.1.7   root      508:        dx = x * 0x7FFF / (width - 1);
                    509:        dy = y * 0x7FFF / (height - 1);
1.1.1.5   root      510:     } else if (absolute_enabled) {
                    511:        sdl_show_cursor();
                    512:        absolute_enabled = 0;
1.1.1.6   root      513:     } else if (guest_cursor) {
1.1.1.7   root      514:         x -= guest_x;
                    515:         y -= guest_y;
                    516:         guest_x += x;
                    517:         guest_y += y;
                    518:         dx = x;
                    519:         dy = y;
1.1.1.3   root      520:     }
                    521: 
1.1       root      522:     kbd_mouse_event(dx, dy, dz, buttons);
                    523: }
                    524: 
                    525: static void toggle_full_screen(DisplayState *ds)
                    526: {
                    527:     gui_fullscreen = !gui_fullscreen;
                    528:     if (gui_fullscreen) {
1.1.1.10  root      529:         scaling_active = 0;
1.1       root      530:         gui_saved_grab = gui_grab;
                    531:         sdl_grab_start();
                    532:     } else {
                    533:         if (!gui_saved_grab)
                    534:             sdl_grab_end();
                    535:     }
1.1.1.3   root      536:     vga_hw_invalidate();
                    537:     vga_hw_update();
1.1       root      538: }
                    539: 
                    540: static void sdl_refresh(DisplayState *ds)
                    541: {
                    542:     SDL_Event ev1, *ev = &ev1;
                    543:     int mod_state;
1.1.1.7   root      544:     int buttonstate = SDL_GetMouseState(NULL, NULL);
1.1.1.6   root      545: 
1.1       root      546:     if (last_vm_running != vm_running) {
                    547:         last_vm_running = vm_running;
                    548:         sdl_update_caption();
                    549:     }
                    550: 
1.1.1.3   root      551:     vga_hw_update();
1.1.1.7   root      552:     SDL_EnableUNICODE(!is_graphic_console());
1.1       root      553: 
                    554:     while (SDL_PollEvent(ev)) {
                    555:         switch (ev->type) {
                    556:         case SDL_VIDEOEXPOSE:
1.1.1.7   root      557:             sdl_update(ds, 0, 0, real_screen->w, real_screen->h);
1.1       root      558:             break;
                    559:         case SDL_KEYDOWN:
                    560:         case SDL_KEYUP:
                    561:             if (ev->type == SDL_KEYDOWN) {
1.1.1.11! root      562:                 if (alt_grab) {
1.1.1.6   root      563:                     mod_state = (SDL_GetModState() & (gui_grab_code | KMOD_LSHIFT)) ==
                    564:                                 (gui_grab_code | KMOD_LSHIFT);
1.1.1.11! root      565:                 } else if (ctrl_grab) {
        !           566:                     mod_state = (SDL_GetModState() & KMOD_RCTRL) == KMOD_RCTRL;
        !           567:                 } else {
        !           568:                     mod_state = (SDL_GetModState() & gui_grab_code) ==
        !           569:                                 gui_grab_code;
1.1.1.6   root      570:                 }
1.1       root      571:                 gui_key_modifier_pressed = mod_state;
                    572:                 if (gui_key_modifier_pressed) {
                    573:                     int keycode;
                    574:                     keycode = sdl_keyevent_to_keycode(&ev->key);
                    575:                     switch(keycode) {
                    576:                     case 0x21: /* 'f' key on US keyboard */
                    577:                         toggle_full_screen(ds);
                    578:                         gui_keysym = 1;
                    579:                         break;
1.1.1.11! root      580:                     case 0x16: /* 'u' key on US keyboard */
        !           581:                         scaling_active = 0;
        !           582:                         sdl_resize(ds);
        !           583:                         vga_hw_invalidate();
        !           584:                         vga_hw_update();
        !           585:                         break;
1.1.1.6   root      586:                     case 0x02 ... 0x0a: /* '1' to '9' keys */
1.1.1.5   root      587:                         /* Reset the modifiers sent to the current console */
                    588:                         reset_keys();
1.1       root      589:                         console_select(keycode - 0x02);
1.1.1.3   root      590:                         if (!is_graphic_console()) {
1.1       root      591:                             /* display grab if going to a text console */
                    592:                             if (gui_grab)
                    593:                                 sdl_grab_end();
                    594:                         }
                    595:                         gui_keysym = 1;
                    596:                         break;
                    597:                     default:
                    598:                         break;
                    599:                     }
1.1.1.3   root      600:                 } else if (!is_graphic_console()) {
1.1       root      601:                     int keysym;
                    602:                     keysym = 0;
                    603:                     if (ev->key.keysym.mod & (KMOD_LCTRL | KMOD_RCTRL)) {
                    604:                         switch(ev->key.keysym.sym) {
                    605:                         case SDLK_UP: keysym = QEMU_KEY_CTRL_UP; break;
                    606:                         case SDLK_DOWN: keysym = QEMU_KEY_CTRL_DOWN; break;
                    607:                         case SDLK_LEFT: keysym = QEMU_KEY_CTRL_LEFT; break;
                    608:                         case SDLK_RIGHT: keysym = QEMU_KEY_CTRL_RIGHT; break;
                    609:                         case SDLK_HOME: keysym = QEMU_KEY_CTRL_HOME; break;
                    610:                         case SDLK_END: keysym = QEMU_KEY_CTRL_END; break;
                    611:                         case SDLK_PAGEUP: keysym = QEMU_KEY_CTRL_PAGEUP; break;
                    612:                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_CTRL_PAGEDOWN; break;
                    613:                         default: break;
                    614:                         }
                    615:                     } else {
                    616:                         switch(ev->key.keysym.sym) {
                    617:                         case SDLK_UP: keysym = QEMU_KEY_UP; break;
                    618:                         case SDLK_DOWN: keysym = QEMU_KEY_DOWN; break;
                    619:                         case SDLK_LEFT: keysym = QEMU_KEY_LEFT; break;
                    620:                         case SDLK_RIGHT: keysym = QEMU_KEY_RIGHT; break;
                    621:                         case SDLK_HOME: keysym = QEMU_KEY_HOME; break;
                    622:                         case SDLK_END: keysym = QEMU_KEY_END; break;
                    623:                         case SDLK_PAGEUP: keysym = QEMU_KEY_PAGEUP; break;
                    624:                         case SDLK_PAGEDOWN: keysym = QEMU_KEY_PAGEDOWN; break;
1.1.1.6   root      625:                         case SDLK_BACKSPACE: keysym = QEMU_KEY_BACKSPACE; break;
                    626:                         case SDLK_DELETE: keysym = QEMU_KEY_DELETE; break;
1.1       root      627:                         default: break;
                    628:                         }
                    629:                     }
                    630:                     if (keysym) {
                    631:                         kbd_put_keysym(keysym);
                    632:                     } else if (ev->key.keysym.unicode != 0) {
                    633:                         kbd_put_keysym(ev->key.keysym.unicode);
                    634:                     }
                    635:                 }
                    636:             } else if (ev->type == SDL_KEYUP) {
1.1.1.6   root      637:                 if (!alt_grab) {
                    638:                     mod_state = (ev->key.keysym.mod & gui_grab_code);
                    639:                 } else {
                    640:                     mod_state = (ev->key.keysym.mod &
                    641:                                  (gui_grab_code | KMOD_LSHIFT));
                    642:                 }
1.1       root      643:                 if (!mod_state) {
                    644:                     if (gui_key_modifier_pressed) {
1.1.1.3   root      645:                         gui_key_modifier_pressed = 0;
1.1       root      646:                         if (gui_keysym == 0) {
                    647:                             /* exit/enter grab if pressing Ctrl-Alt */
1.1.1.4   root      648:                             if (!gui_grab) {
                    649:                                 /* if the application is not active,
                    650:                                    do not try to enter grab state. It
                    651:                                    prevents
                    652:                                    'SDL_WM_GrabInput(SDL_GRAB_ON)'
                    653:                                    from blocking all the application
                    654:                                    (SDL bug). */
                    655:                                 if (SDL_GetAppState() & SDL_APPACTIVE)
                    656:                                     sdl_grab_start();
                    657:                             } else {
1.1       root      658:                                 sdl_grab_end();
1.1.1.4   root      659:                             }
1.1       root      660:                             /* SDL does not send back all the
                    661:                                modifiers key, so we must correct it */
                    662:                             reset_keys();
                    663:                             break;
                    664:                         }
                    665:                         gui_keysym = 0;
                    666:                     }
                    667:                 }
                    668:             }
1.1.1.6   root      669:             if (is_graphic_console() && !gui_keysym)
1.1       root      670:                 sdl_process_key(&ev->key);
                    671:             break;
                    672:         case SDL_QUIT:
1.1.1.7   root      673:             if (!no_quit)
1.1.1.6   root      674:                 qemu_system_shutdown_request();
1.1       root      675:             break;
                    676:         case SDL_MOUSEMOTION:
1.1.1.5   root      677:             if (gui_grab || kbd_mouse_is_absolute() ||
                    678:                 absolute_enabled) {
1.1.1.7   root      679:                 sdl_send_mouse_event(ev->motion.xrel, ev->motion.yrel, 0,
                    680:                        ev->motion.x, ev->motion.y, ev->motion.state);
1.1       root      681:             }
                    682:             break;
                    683:         case SDL_MOUSEBUTTONDOWN:
                    684:         case SDL_MOUSEBUTTONUP:
                    685:             {
                    686:                 SDL_MouseButtonEvent *bev = &ev->button;
1.1.1.3   root      687:                 if (!gui_grab && !kbd_mouse_is_absolute()) {
1.1       root      688:                     if (ev->type == SDL_MOUSEBUTTONDOWN &&
1.1.1.7   root      689:                         (bev->button == SDL_BUTTON_LEFT)) {
1.1       root      690:                         /* start grabbing all events */
                    691:                         sdl_grab_start();
                    692:                     }
                    693:                 } else {
                    694:                     int dz;
                    695:                     dz = 0;
1.1.1.7   root      696:                     if (ev->type == SDL_MOUSEBUTTONDOWN) {
                    697:                         buttonstate |= SDL_BUTTON(bev->button);
                    698:                     } else {
                    699:                         buttonstate &= ~SDL_BUTTON(bev->button);
                    700:                     }
1.1       root      701: #ifdef SDL_BUTTON_WHEELUP
1.1.1.3   root      702:                     if (bev->button == SDL_BUTTON_WHEELUP && ev->type == SDL_MOUSEBUTTONDOWN) {
1.1       root      703:                         dz = -1;
1.1.1.3   root      704:                     } else if (bev->button == SDL_BUTTON_WHEELDOWN && ev->type == SDL_MOUSEBUTTONDOWN) {
1.1       root      705:                         dz = 1;
                    706:                     }
1.1.1.6   root      707: #endif
1.1.1.7   root      708:                     sdl_send_mouse_event(0, 0, dz, bev->x, bev->y, buttonstate);
1.1       root      709:                 }
                    710:             }
                    711:             break;
                    712:         case SDL_ACTIVEEVENT:
1.1.1.3   root      713:             if (gui_grab && ev->active.state == SDL_APPINPUTFOCUS &&
                    714:                 !ev->active.gain && !gui_fullscreen_initial_grab) {
1.1       root      715:                 sdl_grab_end();
                    716:             }
1.1.1.7   root      717:             if (ev->active.state & SDL_APPACTIVE) {
                    718:                 if (ev->active.gain) {
                    719:                     /* Back to default interval */
                    720:                     dcl->gui_timer_interval = 0;
                    721:                     dcl->idle = 0;
                    722:                 } else {
                    723:                     /* Sleeping interval */
                    724:                     dcl->gui_timer_interval = 500;
                    725:                     dcl->idle = 1;
                    726:                 }
                    727:             }
1.1       root      728:             break;
1.1.1.10  root      729:        case SDL_VIDEORESIZE:
                    730:         {
                    731:            SDL_ResizeEvent *rev = &ev->resize;
                    732:             int bpp = real_screen->format->BitsPerPixel;
                    733:             if (bpp != 16 && bpp != 32)
                    734:                 bpp = 32;
                    735:             do_sdl_resize(rev->w, rev->h, bpp);
                    736:             scaling_active = 1;
                    737:             if (!is_buffer_shared(ds->surface)) {
                    738:                 ds->surface = qemu_resize_displaysurface(ds, ds_get_width(ds), ds_get_height(ds));
                    739:                 dpy_resize(ds);
                    740:             }
                    741:             vga_hw_invalidate();
                    742:             vga_hw_update();
                    743:             break;
                    744:         }
1.1       root      745:         default:
                    746:             break;
                    747:         }
                    748:     }
                    749: }
                    750: 
1.1.1.6   root      751: static void sdl_fill(DisplayState *ds, int x, int y, int w, int h, uint32_t c)
                    752: {
                    753:     SDL_Rect dst = { x, y, w, h };
1.1.1.7   root      754:     SDL_FillRect(real_screen, &dst, c);
1.1.1.6   root      755: }
                    756: 
                    757: static void sdl_mouse_warp(int x, int y, int on)
                    758: {
                    759:     if (on) {
                    760:         if (!guest_cursor)
                    761:             sdl_show_cursor();
                    762:         if (gui_grab || kbd_mouse_is_absolute() || absolute_enabled) {
                    763:             SDL_SetCursor(guest_sprite);
1.1.1.7   root      764:             if (!kbd_mouse_is_absolute() && !absolute_enabled)
                    765:                 SDL_WarpMouse(x, y);
1.1.1.6   root      766:         }
                    767:     } else if (gui_grab)
                    768:         sdl_hide_cursor();
                    769:     guest_cursor = on;
                    770:     guest_x = x, guest_y = y;
                    771: }
                    772: 
                    773: static void sdl_mouse_define(int width, int height, int bpp,
                    774:                              int hot_x, int hot_y,
                    775:                              uint8_t *image, uint8_t *mask)
                    776: {
                    777:     uint8_t sprite[256], *line;
                    778:     int x, y, dst, bypl, src = 0;
                    779:     if (guest_sprite)
                    780:         SDL_FreeCursor(guest_sprite);
                    781: 
                    782:     memset(sprite, 0, 256);
                    783:     bypl = ((width * bpp + 31) >> 5) << 2;
                    784:     for (y = 0, dst = 0; y < height; y ++, image += bypl) {
                    785:         line = image;
                    786:         for (x = 0; x < width; x ++, dst ++) {
                    787:             switch (bpp) {
1.1.1.10  root      788:             case 32:
                    789:                 src = *(line ++); src |= *(line ++); src |= *(line ++); line++;
                    790:                 break;
1.1.1.6   root      791:             case 24:
                    792:                 src = *(line ++); src |= *(line ++); src |= *(line ++);
                    793:                 break;
                    794:             case 16:
                    795:             case 15:
                    796:                 src = *(line ++); src |= *(line ++);
                    797:                 break;
                    798:             case 8:
                    799:                 src = *(line ++);
                    800:                 break;
                    801:             case 4:
                    802:                 src = 0xf & (line[x >> 1] >> ((x & 1)) << 2);
                    803:                 break;
                    804:             case 2:
                    805:                 src = 3 & (line[x >> 2] >> ((x & 3)) << 1);
                    806:                 break;
                    807:             case 1:
                    808:                 src = 1 & (line[x >> 3] >> (x & 7));
                    809:                 break;
                    810:             }
                    811:             if (!src)
                    812:                 sprite[dst >> 3] |= (1 << (~dst & 7)) & mask[dst >> 3];
                    813:         }
                    814:     }
                    815:     guest_sprite = SDL_CreateCursor(sprite, mask, width, height, hot_x, hot_y);
                    816: 
                    817:     if (guest_cursor &&
                    818:             (gui_grab || kbd_mouse_is_absolute() || absolute_enabled))
                    819:         SDL_SetCursor(guest_sprite);
                    820: }
                    821: 
                    822: static void sdl_cleanup(void)
1.1       root      823: {
1.1.1.6   root      824:     if (guest_sprite)
                    825:         SDL_FreeCursor(guest_sprite);
1.1.1.10  root      826:     SDL_QuitSubSystem(SDL_INIT_VIDEO);
1.1       root      827: }
                    828: 
1.1.1.6   root      829: void sdl_display_init(DisplayState *ds, int full_screen, int no_frame)
1.1       root      830: {
                    831:     int flags;
1.1.1.3   root      832:     uint8_t data = 0;
1.1.1.10  root      833:     DisplayAllocator *da;
                    834:     const SDL_VideoInfo *vi;
1.1       root      835: 
                    836: #if defined(__APPLE__)
                    837:     /* always use generic keymaps */
                    838:     if (!keyboard_layout)
                    839:         keyboard_layout = "en-us";
                    840: #endif
                    841:     if(keyboard_layout) {
1.1.1.10  root      842:         kbd_layout = init_keyboard_layout(name2keysym, keyboard_layout);
1.1       root      843:         if (!kbd_layout)
                    844:             exit(1);
                    845:     }
                    846: 
1.1.1.6   root      847:     if (no_frame)
                    848:         gui_noframe = 1;
                    849: 
1.1       root      850:     flags = SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE;
                    851:     if (SDL_Init (flags)) {
                    852:         fprintf(stderr, "Could not initialize SDL - exiting\n");
                    853:         exit(1);
                    854:     }
1.1.1.10  root      855:     vi = SDL_GetVideoInfo();
                    856:     host_format = *(vi->vfmt);
1.1       root      857: 
1.1.1.7   root      858:     dcl = qemu_mallocz(sizeof(DisplayChangeListener));
                    859:     dcl->dpy_update = sdl_update;
                    860:     dcl->dpy_resize = sdl_resize;
                    861:     dcl->dpy_refresh = sdl_refresh;
                    862:     dcl->dpy_setdata = sdl_setdata;
                    863:     dcl->dpy_fill = sdl_fill;
1.1.1.6   root      864:     ds->mouse_set = sdl_mouse_warp;
                    865:     ds->cursor_define = sdl_mouse_define;
1.1.1.7   root      866:     register_displaychangelistener(ds, dcl);
1.1       root      867: 
1.1.1.10  root      868:     da = qemu_mallocz(sizeof(DisplayAllocator));
                    869:     da->create_displaysurface = sdl_create_displaysurface;
                    870:     da->resize_displaysurface = sdl_resize_displaysurface;
                    871:     da->free_displaysurface = sdl_free_displaysurface;
                    872:     if (register_displayallocator(ds, da) == da) {
                    873:         DisplaySurface *surf;
                    874:         surf = sdl_create_displaysurface(ds_get_width(ds), ds_get_height(ds));
                    875:         defaultallocator_free_displaysurface(ds->surface);
                    876:         ds->surface = surf;
                    877:         dpy_resize(ds);
                    878:     }
                    879: 
1.1       root      880:     sdl_update_caption();
                    881:     SDL_EnableKeyRepeat(250, 50);
                    882:     gui_grab = 0;
                    883: 
1.1.1.3   root      884:     sdl_cursor_hidden = SDL_CreateCursor(&data, &data, 8, 1, 0, 0);
                    885:     sdl_cursor_normal = SDL_GetCursor();
                    886: 
1.1       root      887:     atexit(sdl_cleanup);
                    888:     if (full_screen) {
                    889:         gui_fullscreen = 1;
                    890:         gui_fullscreen_initial_grab = 1;
                    891:         sdl_grab_start();
                    892:     }
                    893: }

unix.superglobalmegacorp.com