packages: qemu-kvm/qemu-kvm-ncurses.patch (NEW), qemu-kvm/qemu-kvm-nosdlgui...

mguevara mguevara at pld-linux.org
Mon Mar 15 17:03:51 CET 2010


Author: mguevara                     Date: Mon Mar 15 16:03:51 2010 GMT
Module: packages                      Tag: HEAD
---- Log message:
- KVM enhanced QEMU; spec based on qemu.spec with some additions from
  fedora project

---- Files affected:
packages/qemu-kvm:
   qemu-kvm-ncurses.patch (NONE -> 1.1)  (NEW), qemu-kvm-nosdlgui.patch (NONE -> 1.1)  (NEW), qemu-kvm.spec (NONE -> 1.1)  (NEW)

---- Diffs:

================================================================
Index: packages/qemu-kvm/qemu-kvm-ncurses.patch
diff -u /dev/null packages/qemu-kvm/qemu-kvm-ncurses.patch:1.1
--- /dev/null	Mon Mar 15 17:03:51 2010
+++ packages/qemu-kvm/qemu-kvm-ncurses.patch	Mon Mar 15 17:03:46 2010
@@ -0,0 +1,22 @@
+--- qemu-0.12.2.a/configure	2010-02-02 17:41:58.000000000 +0100
++++ qemu-0.12.2.b/configure	2010-02-02 17:58:54.000000000 +0100
+@@ -1267,7 +1267,7 @@
+ if test "$curses" != "no" ; then
+   curses_found=no
+   cat > $TMPC << EOF
+-#include <curses.h>
++#include <ncurses/curses.h>
+ #ifdef __OpenBSD__
+ #define resize_term resizeterm
+ #endif
+--- qemu-0.12.2.a/curses.c	2010-02-02 18:29:18.000000000 +0100
++++ qemu-0.12.2.a/curses.c	2010-02-02 18:29:47.000000000 +0100
+@@ -21,7 +21,7 @@
+  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+  * THE SOFTWARE.
+  */
+-#include <curses.h>
++#include <ncurses/curses.h>
+ 
+ #ifndef _WIN32
+ #include <signal.h>

================================================================
Index: packages/qemu-kvm/qemu-kvm-nosdlgui.patch
diff -u /dev/null packages/qemu-kvm/qemu-kvm-nosdlgui.patch:1.1
--- /dev/null	Mon Mar 15 17:03:51 2010
+++ packages/qemu-kvm/qemu-kvm-nosdlgui.patch	Mon Mar 15 17:03:46 2010
@@ -0,0 +1,1075 @@
+diff -Nur qemu-0.7.0.orig/Makefile.target qemu-0.7.0.chng/Makefile.target
+--- qemu-0.7.0.orig/Makefile.target	2005-07-06 23:38:02.000000000 +0000
++++ qemu-0.7.0.chng/Makefile.target	2005-07-06 23:42:48.000000000 +0000
+@@ -392,7 +392,7 @@
+ endif
+ 
+ $(QEMU_SYSTEM): $(VL_OBJS) libqemu.a
+-	$(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS)
++	$(CC) $(VL_LDFLAGS) -o $@ $^ $(LIBS) $(SDL_LIBS) $(COCOA_LIBS) $(VL_LIBS) -L/usr/X11R6/lib -lX11 -lpthread
+ 
+ cocoa.o: cocoa.m
+ 	$(CC) $(CFLAGS) $(DEFINES) -c -o $@ $<
+--- qemu-0.7.1/sdl.c.orig	2005-07-24 20:52:08.000000000 +0200
++++ qemu-0.7.1/sdl.c	2005-08-23 01:47:48.000000000 +0200
+@@ -1,506 +1,614 @@
+ /*
+- * QEMU SDL display driver
+- * 
+- * Copyright (c) 2003 Fabrice Bellard
+- * 
+- * Permission is hereby granted, free of charge, to any person obtaining a copy
+- * of this software and associated documentation files (the "Software"), to deal
+- * in the Software without restriction, including without limitation the rights
+- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+- * copies of the Software, and to permit persons to whom the Software is
+- * furnished to do so, subject to the following conditions:
+- *
+- * The above copyright notice and this permission notice shall be included in
+- * all copies or substantial portions of the Software.
++ * Xlib interface for QEMU System Emulator
+  *
+- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
+- * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+- * THE SOFTWARE.
+- */
+-#include "vl.h"
++ * Copyright (c) 2004 Vladimit Oleynik <dzo at simtreas.ru>
++ * Used ideas from Bochs, SDL, PCEmu.
++*/
+ 
+-#include <SDL.h>
++#include <X11/Xlib.h>
++#include <X11/Xutil.h>
++#include <X11/keysym.h>
+ 
+-#ifndef _WIN32
+-#include <signal.h>
+-#endif
++/* hack, special for qemu */
++#define X_display_init sdl_display_init
++
++#define icon_width 40
++#define icon_height 32
++static unsigned char icon_bits[] = {
++  0x3e, 0x26, 0x00, 0x00, 0x00,
++  0x24, 0x04, 0x01, 0x00, 0x00,
++  0x04, 0x04, 0x01, 0x00, 0x00,
++  0x14, 0xb7, 0xb3, 0x06, 0x00,
++  0x9c, 0x24, 0x49, 0x05, 0x00,
++  0x94, 0x24, 0x49, 0x01, 0x00,
++  0x84, 0x24, 0x49, 0x01, 0x00,
++  0xa4, 0x24, 0x49, 0x01, 0x00,
++  0x3e, 0x27, 0x32, 0x03, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x08, 0x00, 0x77, 0x00, 0x00,
++  0x04, 0x00, 0x22, 0x00, 0x00,
++  0x04, 0x00, 0x14, 0x00, 0x00,
++  0xce, 0x1a, 0x14, 0x00, 0x00,
++  0x24, 0x15, 0x08, 0x00, 0x00,
++  0x24, 0x05, 0x14, 0x00, 0x00,
++  0x24, 0x05, 0x14, 0x00, 0x00,
++  0x24, 0x05, 0x22, 0x00, 0x00,
++  0xcc, 0x0c, 0x07, 0x00, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x00, 0x00, 0x00, 0x00, 0x00,
++  0x04, 0x00, 0x01, 0x00, 0x00,
++  0x04, 0x00, 0x01, 0x00, 0x00,
++  0xce, 0xb6, 0xb3, 0xb6, 0x0d,
++  0x24, 0x15, 0x49, 0x49, 0x09,
++  0xe4, 0x09, 0x79, 0x49, 0x09,
++  0x24, 0x08, 0x09, 0x49, 0x09,
++  0x24, 0x15, 0x49, 0x49, 0x09,
++  0xc8, 0x36, 0x32, 0x49, 0x0e,
++};
++
++#include "vl.h"
+ 
+-static SDL_Surface *screen;
+-static int gui_grab; /* if true, all keyboard/mouse events are grabbed */
+ static int last_vm_running;
+-static int gui_saved_grab;
+-static int gui_fullscreen;
+-static int gui_key_modifier_pressed;
+-static int gui_keysym;
+-static int gui_fullscreen_initial_grab;
+-static int gui_grab_code = KMOD_LALT | KMOD_LCTRL;
+-static uint8_t modifiers_state[256];
+ 
+-static void sdl_update(DisplayState *ds, int x, int y, int w, int h)
++static Display *qx_display;
++static int q_x_screen_num;
++static Window win;
++static GC gc;
++static XImage *ximage = NULL;
++static int     default_depth;
++static Visual  *default_visual;
++static int width, height;
++
++static void x_update(DisplayState *ds, int x, int y, int w, int h)
+ {
+-    //    printf("updating x=%d y=%d w=%d h=%d\n", x, y, w, h);
+-    SDL_UpdateRect(screen, x, y, w, h);
++    XPutImage(qx_display, win, gc, ximage, x, y, x, y, w, h);
++    XFlush(qx_display);
+ }
+ 
+-static void sdl_resize(DisplayState *ds, int w, int h)
++static int prev_x, prev_y;
++static int current_x, current_y;
++
++/* Move the cursor to a center window place */
++static void qXWarpPointer(void)
+ {
+-    int flags;
++	int x = width/2;
++	int y = height/2;
+ 
+-    //    printf("resizing to %d %d\n", w, h);
++	prev_x = current_x = x;
++	prev_y = current_y = y;
++	XWarpPointer(qx_display, None, win, 0, 0, 0, 0, x, y);
++}
+ 
+-    flags = SDL_HWSURFACE|SDL_ASYNCBLIT|SDL_HWACCEL;
+-    if (gui_fullscreen)
+-        flags |= SDL_FULLSCREEN;
+-    screen = SDL_SetVideoMode(w, h, 0, flags);
+-    if (!screen) {
+-        fprintf(stderr, "Could not open SDL display\n");
+-        exit(1);
++static void x_resize(DisplayState *ds, int w, int h)
++{
++    XSizeHints hints;
++    long supplied_return;
++
++    if ( XGetWMNormalHints(qx_display, win, &hints, &supplied_return) &&
++	 supplied_return & PMaxSize ) {
++      hints.max_width = hints.min_width = w;
++      hints.max_height = hints.min_height = h;
++      XSetWMNormalHints(qx_display, win, &hints);
+     }
+-    ds->data = screen->pixels;
+-    ds->linesize = screen->pitch;
+-    ds->depth = screen->format->BitsPerPixel;
+-    ds->width = w;
+-    ds->height = h;
++    if(ximage) {
++	XDestroyImage(ximage);
++//        free(ds->data);
++	XResizeWindow(qx_display, win, w, h);
++    }
++    ximage = XCreateImage(qx_display, default_visual,
++	     default_depth,          // depth of image (bitplanes)
++	     ZPixmap,
++	     0,                      // offset
++	     NULL,                   // malloc() space after
++	     w, h,                   // x & y size of image
++	     32,                     // # bits of padding
++	     0 );                    // bytes_per_line, let X11 calculate
++    if (!ximage) {
++	fprintf(stderr, "Could not XCreateImage()\n");
++	exit(1);
++    }
++    width = ds->width = w;
++    height = ds->height = h;
++    ds->depth = ximage->bits_per_pixel;
++    ds->linesize = ximage->bytes_per_line;
++    ds->data = (char *) malloc( (size_t) (ximage->bytes_per_line * h) );
++    if (!ds->data) {
++	fprintf(stderr, "Could not malloc Image data\n");
++	exit(1);
++    }
++    ximage->data = ds->data;
++    qXWarpPointer();
++    XFlush(qx_display);
+ }
+ 
+-/* generic keyboard conversion */
++static int gui_grab;
+ 
+-#include "sdl_keysym.h"
+-#include "keymaps.c"
++static void x_SetCaption(void)
++{
++	char *title, *icon;
++	XTextProperty titleprop, iconprop;
+ 
+-static kbd_layout_t *kbd_layout = NULL;
++	title = icon = "QEMU";
++	if (!vm_running && !gui_grab)
++		title = "QEMU [Stopped]";
++	if (vm_running && gui_grab)
++		title = "QEMU - Press Ctrl-Shift to exit grab";
++	if (!vm_running && gui_grab)
++		title = "QEMU [Stopped] - Press Ctrl-Shift to exit grab";
+ 
+-static uint8_t sdl_keyevent_to_keycode_generic(const SDL_KeyboardEvent *ev)
+-{
+-    int keysym;
+-    /* workaround for X11+SDL bug with AltGR */
+-    keysym = ev->keysym.sym;
+-    if (keysym == 0 && ev->keysym.scancode == 113)
+-        keysym = SDLK_MODE;
+-    return keysym2scancode(kbd_layout, keysym);
++	XStringListToTextProperty(&title, 1, &titleprop);
++	XSetWMName(qx_display, win, &titleprop);
++	XFree(titleprop.value);
++
++	XStringListToTextProperty(&icon, 1, &iconprop);
++	XSetWMIconName(qx_display, win, &iconprop);
++	XFree(iconprop.value);
++	XSync(qx_display, /* no discard */ 0);
+ }
+ 
+-/* specific keyboard conversions from scan codes */
++static void trigger_mouse_grab(void)
++{
++  gui_grab ^= 1;
++  if (gui_grab) {
++      /* disable cursor */
++      static Cursor cursor;
++      static int cursor_created;
+ 
+-#if defined(_WIN32)
++#define shape_width 16
++#define shape_height 16
++#define mask_width 16
++#define mask_height 16
+ 
+-static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
+-{
+-    return ev->keysym.scancode;
+-}
++      static unsigned int shape_bits[(16*16)/32];
++      static unsigned int mask_bits[(16*16)/32];
+ 
+-#else
++      if (!cursor_created) {
++	    Pixmap shape, mask;
++	    XColor white, black;
++	    Colormap default_cmap;
+ 
+-static const uint8_t x_keycode_to_pc_keycode[61] = {
+-   0xc7,      /*  97  Home   */
+-   0xc8,      /*  98  Up     */
+-   0xc9,      /*  99  PgUp   */
+-   0xcb,      /* 100  Left   */
+-   0x4c,        /* 101  KP-5   */
+-   0xcd,      /* 102  Right  */
+-   0xcf,      /* 103  End    */
+-   0xd0,      /* 104  Down   */
+-   0xd1,      /* 105  PgDn   */
+-   0xd2,      /* 106  Ins    */
+-   0xd3,      /* 107  Del    */
+-   0x9c,      /* 108  Enter  */
+-   0x9d,      /* 109  Ctrl-R */
+-   0x0,       /* 110  Pause  */
+-   0xb7,      /* 111  Print  */
+-   0xb5,      /* 112  Divide */
+-   0xb8,      /* 113  Alt-R  */
+-   0xc6,      /* 114  Break  */   
+-   0x0,         /* 115 */
+-   0x0,         /* 116 */
+-   0x0,         /* 117 */
+-   0x0,         /* 118 */
+-   0x0,         /* 119 */
+-   0x70,         /* 120 Hiragana_Katakana */
+-   0x0,         /* 121 */
+-   0x0,         /* 122 */
+-   0x73,         /* 123 backslash */
+-   0x0,         /* 124 */
+-   0x0,         /* 125 */
+-   0x0,         /* 126 */
+-   0x0,         /* 127 */
+-   0x0,         /* 128 */
+-   0x79,         /* 129 Henkan */
+-   0x0,         /* 130 */
+-   0x7b,         /* 131 Muhenkan */
+-   0x0,         /* 132 */
+-   0x7d,         /* 133 Yen */
+-   0x0,         /* 134 */
+-   0x0,         /* 135 */
+-   0x47,         /* 136 KP_7 */
+-   0x48,         /* 137 KP_8 */
+-   0x49,         /* 138 KP_9 */
+-   0x4b,         /* 139 KP_4 */
+-   0x4c,         /* 140 KP_5 */
+-   0x4d,         /* 141 KP_6 */
+-   0x4f,         /* 142 KP_1 */
+-   0x50,         /* 143 KP_2 */
+-   0x51,         /* 144 KP_3 */
+-   0x52,         /* 145 KP_0 */
+-   0x53,         /* 146 KP_. */
+-   0x47,         /* 147 KP_HOME */
+-   0x48,         /* 148 KP_UP */
+-   0x49,         /* 149 KP_PgUp */
+-   0x4b,         /* 150 KP_Left */
+-   0x4c,         /* 151 KP_ */
+-   0x4d,         /* 152 KP_Right */
+-   0x4f,         /* 153 KP_End */
+-   0x50,         /* 154 KP_Down */
+-   0x51,         /* 155 KP_PgDn */
+-   0x52,         /* 156 KP_Ins */
+-   0x53,         /* 157 KP_Del */
+-};
++	    default_cmap = DefaultColormap(qx_display, q_x_screen_num);
+ 
+-static uint8_t sdl_keyevent_to_keycode(const SDL_KeyboardEvent *ev)
+-{
+-    int keycode;
++	    shape = XCreatePixmapFromBitmapData(qx_display,
++						RootWindow(qx_display,q_x_screen_num),
++						(char*)shape_bits,
++						shape_width, shape_height,
++						1, 0, 1);
++	    mask =  XCreatePixmapFromBitmapData(qx_display,
++						RootWindow(qx_display,q_x_screen_num),
++						(char*)mask_bits,
++						mask_width, mask_height,
++						1, 0, 1);
++	    XParseColor(qx_display, default_cmap, "black", &black);
++	    XParseColor(qx_display, default_cmap, "white", &white);
++	    cursor = XCreatePixmapCursor(qx_display, shape, mask,
++					 &white, &black, 1, 1);
++	    cursor_created = 1;
++      }
++      XDefineCursor(qx_display, win, cursor);
+ 
+-    keycode = ev->keysym.scancode;
++      /* grab pointer and keyboard */
+ 
+-    if (keycode < 9) {
+-        keycode = 0;
+-    } else if (keycode < 97) {
+-        keycode -= 8; /* just an offset */
+-    } else if (keycode < 158) {
+-        /* use conversion table */
+-        keycode = x_keycode_to_pc_keycode[keycode - 97];
+-    } else {
+-        keycode = 0;
+-    }
+-    return keycode;
++//    if ( flags & FULLSCREEN ) {
++//      /* Unbind the mouse from the fullscreen window */
++//      XUngrabPointer(qx_display, CurrentTime);
++//    }
++      /* Try to grab the mouse */
++      while ( 1 ) {
++	int result = XGrabPointer(qx_display, win, True, 0,
++					GrabModeAsync, GrabModeAsync,
++					win, None, CurrentTime);
++	if (result == GrabSuccess)
++		break;
++      }
++      /* Now grab the keyboard */
++      XGrabKeyboard(qx_display, win, True,
++			GrabModeAsync, GrabModeAsync, CurrentTime);
++
++      /* Raise the window if we grab the mouse */
++//    if ( !(flags & FULLSCREEN) )
++	XRaiseWindow(qx_display, win);
++      qXWarpPointer();
++  } else {
++    /* enable cursor */
++    XUndefineCursor(qx_display, win);
++    /* ungrab pointer and keyboard */
++    XUngrabPointer(qx_display, CurrentTime);
++    XUngrabKeyboard(qx_display, CurrentTime);
++  }
++  x_SetCaption();
+ }
+ 
+-#endif
++static unsigned mouse_button_state;
+ 
+-static void reset_keys(void)
++static void send_keyboard_mouse_status(void)
+ {
+-    int i;
+-    for(i = 0; i < 256; i++) {
+-        if (modifiers_state[i]) {
+-            if (i & 0x80)
+-                kbd_put_keycode(0xe0);
+-            kbd_put_keycode(i | 0x80);
+-            modifiers_state[i] = 0;
+-        }
++    int dx, dy;
++
++    dx = current_x - prev_x;
++    dy = -(current_y - prev_y);
++    kbd_mouse_event(dx, -dy, 0, mouse_button_state);
++    if(current_x <= 1 || current_x >= (width-1) || current_y <= 1 || current_y >= (height-1)) {
++	qXWarpPointer();
++    } else {
++	prev_x = current_x;
++	prev_y = current_y;
+     }
+ }
+ 
+-static void sdl_process_key(SDL_KeyboardEvent *ev)
++static const unsigned char scan_table1[] =
+ {
+-    int keycode, v;
++    0x39, 0x02,
++#ifdef KBUK             /* double quotes, hash symbol */
++    0x03, 0x2b,
++#else
++    0x28, 0x04,
++#endif
++    0x05, 0x06, 0x08, 0x28,
++    0x0a, 0x0b, 0x09, 0x0d, 0x33, 0x0c, 0x34, 0x35,
++    0x0b, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
++    0x09, 0x0a, 0x27, 0x27, 0x33, 0x0d, 0x34, 0x35,
++#ifdef KBUK             /* at symbol */
++    0x28,
++#else
++    0x03,
++#endif
++    0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22,
++    0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18,
++    0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11,
++    0x2d, 0x15, 0x2c, 0x1a,
++#ifdef KBUK             /* backslash */
++    0x56,
++#else
++    0x2b,
++#endif
++    0x1b, 0x07, 0x0c,
++    0x29, 0x1e, 0x30, 0x2e, 0x20, 0x12, 0x21, 0x22,
++    0x23, 0x17, 0x24, 0x25, 0x26, 0x32, 0x31, 0x18,
++    0x19, 0x10, 0x13, 0x1f, 0x14, 0x16, 0x2f, 0x11,
++    0x2d, 0x15, 0x2c, 0x1a,
++#ifdef KBUK             /* vertical bar */
++    0x56,
++#else
++    0x2b,
++#endif
+ 
+-    if (ev->keysym.sym == SDLK_PAUSE) {
+-        /* specific case */
+-        v = 0;
+-        if (ev->type == SDL_KEYUP)
+-            v |= 0x80;
+-        kbd_put_keycode(0xe1);
+-        kbd_put_keycode(0x1d | v);
+-        kbd_put_keycode(0x45 | v);
+-        return;
+-    }
++    0x1b,
+ 
+-    if (kbd_layout) {
+-        keycode = sdl_keyevent_to_keycode_generic(ev);
+-    } else {
+-        keycode = sdl_keyevent_to_keycode(ev);
+-    }
++#ifdef KBUK             /* tilde */
++    0x2b,
++#else
++    0x29,
++#endif
++};
+ 
+-    switch(keycode) {
+-    case 0x00:
+-        /* sent when leaving window: reset the modifiers state */
+-        reset_keys();
+-        return;
+-    case 0x2a:                          /* Left Shift */
+-    case 0x36:                          /* Right Shift */
+-    case 0x1d:                          /* Left CTRL */
+-    case 0x9d:                          /* Right CTRL */
+-    case 0x38:                          /* Left ALT */
+-    case 0xb8:                         /* Right ALT */
+-        if (ev->type == SDL_KEYUP)
+-            modifiers_state[keycode] = 0;
+-        else
+-            modifiers_state[keycode] = 1;
+-        break;
+-    case 0x45: /* num lock */
+-    case 0x3a: /* caps lock */
+-        /* SDL does not send the key up event, so we generate it */
+-        kbd_put_keycode(keycode);
+-        kbd_put_keycode(keycode | 0x80);
+-        return;
+-    }
+ 
+-    /* now send the key code */
+-    if (keycode & 0x80)
+-        kbd_put_keycode(0xe0);
+-    if (ev->type == SDL_KEYUP)
+-        kbd_put_keycode(keycode | 0x80);
+-    else
+-        kbd_put_keycode(keycode & 0x7f);
+-}
++static const struct {
++    KeySym key;
++    unsigned scan_code;
++} scan_table2[] = {
++    { XK_BackSpace,     0x0e },
++    { XK_Tab,           0x0f },
++    { XK_Return,        0x1c },
++    { XK_Escape,        0x01 },
++    { XK_Delete,        0x53e0 },
+ 
+-static void sdl_update_caption(void)
+-{
+-    char buf[1024];
+-    strcpy(buf, "QEMU");
+-    if (!vm_running) {
+-        strcat(buf, " [Stopped]");
+-    }
+-    if (gui_grab) {
+-        strcat(buf, " - Press Ctrl-Alt to exit grab");
+-    }
+-    SDL_WM_SetCaption(buf, "QEMU");
+-}
++    { XK_Home,          0x47e0 },
++    { XK_Left,          0x4be0 },
++    { XK_Up,            0x48e0 },
++    { XK_Right,         0x4de0 },
++    { XK_Down,          0x50e0 },
++    { XK_Prior,         0x49e0 },
++    { XK_Next,          0x51e0 },
++    { XK_End,           0x4fe0 },
++    { XK_Insert,        0x52e0 },
++    { XK_Num_Lock,      0x45 },
+ 
+-static void sdl_grab_start(void)
+-{
+-    SDL_ShowCursor(0);
+-    SDL_WM_GrabInput(SDL_GRAB_ON);
+-    /* dummy read to avoid moving the mouse */
+-    SDL_GetRelativeMouseState(NULL, NULL);
+-    gui_grab = 1;
+-    sdl_update_caption();
+-}
++/* This block of codes is for Sun Type 4 keyboards... */
+ 
+-static void sdl_grab_end(void)
+-{
+-    SDL_WM_GrabInput(SDL_GRAB_OFF);
+-    SDL_ShowCursor(1);
+-    gui_grab = 0;
+-    sdl_update_caption();
+-}
++    { XK_F27,           0x47e0 },       /* Home/R7/F27 */
<<Diff was trimmed, longer than 597 lines>>


More information about the pld-cvs-commit mailing list