java-game-lib-cvs Mailing List for Lightweight Java Game Library

Revision: 2818
          http://svn.sourceforge.net/java-game-lib/?rev=2818&view=rev
Author:   elias_naur
Date:     2007-05-13 15:01:48 -0700 (Sun, 13 May 2007)

Log Message:
-----------
Implemented Keyboard.enableRepeatEvents(), Keyboard.areRepeatEventsEnabled() and Keyboard.isEventRepeat() to control repeat event reporting. Added repeat key test to KeyboardTest

Modified Paths:
--------------
    trunk/LWJGL/src/java/org/lwjgl/input/Keyboard.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsDisplay.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsKeyboard.java
    trunk/LWJGL/src/java/org/lwjgl/test/input/KeyboardTest.java

Modified: trunk/LWJGL/src/java/org/lwjgl/input/Keyboard.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/input/Keyboard.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/input/Keyboard.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -57,7 +57,7 @@
  */
 public class Keyboard {
 	/** Internal use - event size in bytes */
-	public static final int EVENT_SIZE = 4 + 1 + 4 + 8;
+	public static final int EVENT_SIZE = 4 + 1 + 4 + 8 + 1;
 
 	/**
 	 * The special character meaning that no
@@ -239,6 +239,9 @@
 	/** Has the keyboard been created? */
 	private static boolean created;
 
+	/** Are repeat events enabled? */
+	private static boolean repeat_enabled;
+
 	/** The keys status from the last poll */
 	private static final ByteBuffer keyDownBuffer = BufferUtils.createByteBuffer(KEYBOARD_SIZE);
 
@@ -249,18 +252,12 @@
 	 */
 	private static ByteBuffer readBuffer;
 
-	/** The current keyboard character being examined */
-	private static int eventCharacter;
+	/** current event */
+	private static KeyEvent current_event = new KeyEvent();
 
-	/** The current keyboard event key being examined */
-	private static int eventKey;
+	/** scratch event */
+	private static KeyEvent tmp_event = new KeyEvent();
 
-	/** The current state of the key being examined in the event queue */
-	private static boolean eventState;
-	
-	/** The current event time */
-	private static long eventNanos;
-
 	/** One time initialization */
 	private static boolean initialized;
 
@@ -318,9 +315,7 @@
 		readBuffer.limit(0);
 		for (int i = 0; i < keyDownBuffer.remaining(); i++)
 			keyDownBuffer.put(i, (byte)0);
-		eventCharacter = 0;
-		eventKey = 0;
-		eventState = false;
+		current_event.reset();
 	}
 
 	/**
@@ -432,7 +427,12 @@
 		synchronized (OpenGLPackageAccess.global_lock) {
 			if (!created)
 				throw new IllegalStateException("Keyboard must be created before you can read events");
-			return readBuffer.remaining()/EVENT_SIZE;
+			int old_position = readBuffer.position();
+			int num_events = 0;
+			while (readNext(tmp_event) && (!tmp_event.repeat || repeat_enabled))
+				num_events++;
+			readBuffer.position(old_position);
+			return num_events;
 		}
 	}
 
@@ -452,19 +452,48 @@
 			if (!created)
 				throw new IllegalStateException("Keyboard must be created before you can read events");
 
-			if (readBuffer.hasRemaining()) {
-				eventKey = readBuffer.getInt() & 0xFF;
-				eventState = readBuffer.get() != 0;
-				eventCharacter = readBuffer.getInt();
-				eventNanos = readBuffer.getLong();
-				return true;
-			} else {
-				return false;
-			}
+			boolean result;
+			while ((result = readNext(current_event)) && current_event.repeat && !repeat_enabled)
+				;
+			return result;
 		}
 	}
 
 	/**
+     * Controls whether repeat events are reported or not. If repeat events
+	 * are enabled, key down events are reported when a key is pressed and held for
+	 * a OS dependent amount of time. To distinguish a repeat event from a normal event,
+	 * use isRepeatEvent().
+	 *
+	 * @see org.lwjgl.input.Keyboard#getEventKey()
+	 */
+	public static synchronized void enableRepeatEvents(boolean enable) {
+		repeat_enabled = enable;
+	}
+
+	/**
+     * Check whether repeat events are currently reported or not.
+	 *
+	 * @return true is repeat events are reported, false if not.
+	 * @see org.lwjgl.input.Keyboard#getEventKey()
+	 */
+	public static synchronized boolean areRepeatEventsEnabled() {
+		return repeat_enabled;
+	}
+
+	private static boolean readNext(KeyEvent event) {
+		if (readBuffer.hasRemaining()) {
+			event.key = readBuffer.getInt() & 0xFF;
+			event.state = readBuffer.get() != 0;
+			event.character = readBuffer.getInt();
+			event.nanos = readBuffer.getLong();
+			event.repeat = readBuffer.get() == 1;
+			return true;
+		} else
+			return false;
+	}
+
+	/**
 	 * @return Number of keys on this keyboard
 	 */
 	public static synchronized int getKeyCount() {
@@ -478,7 +507,7 @@
 	 */
 	public static synchronized char getEventCharacter() {
 		synchronized (OpenGLPackageAccess.global_lock) {
-			return (char)eventCharacter;
+			return (char)current_event.character;
 		}
 	}
 
@@ -491,7 +520,7 @@
 	 */
 	public static synchronized int getEventKey() {
 		synchronized (OpenGLPackageAccess.global_lock) {
-			return eventKey;
+			return current_event.key;
 		}
 	}
 
@@ -503,7 +532,7 @@
 	 */
 	public static synchronized boolean getEventKeyState() {
 		synchronized (OpenGLPackageAccess.global_lock) {
-			return eventState;
+			return current_event.state;
 		}
 	}
 
@@ -516,7 +545,42 @@
 	 */
 	public static synchronized long getEventNanoseconds() {
 		synchronized (OpenGLPackageAccess.global_lock) {
-			return eventNanos;
+			return current_event.nanos;
 		}
 	}
+
+	/**
+	 * @see org.lwjgl.input.Keyboard#enableRepeatEvents()
+	 * @return true if the current event is a repeat event, false if
+	 * the current event is not a repeat even or if repeat events are disabled.
+	 */
+	public static synchronized boolean isRepeatEvent() {
+		synchronized (OpenGLPackageAccess.global_lock) {
+			return current_event.repeat;
+		}
+	}
+
+	private final static class KeyEvent {
+		/** The current keyboard character being examined */
+		private int character;
+
+		/** The current keyboard event key being examined */
+		private int key;
+
+		/** The current state of the key being examined in the event queue */
+		private boolean state;
+
+		/** The current event time */
+		private long nanos;
+
+		/** Is the current event a repeated event? */
+		private boolean repeat;
+
+		private void reset() {
+			character = 0;
+			key = 0;
+			state = false;
+			repeat = false;
+		}
+	}
 }

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -264,9 +264,9 @@
 		//component.removeKeyListener(this);
 	}
 
-	private void putKeyboardEvent(int key_code, byte state, int character, long nanos) {
+	private void putKeyboardEvent(int key_code, byte state, int character, long nanos, boolean repeat) {
 		event.clear();
-		event.putInt(key_code).put(state).putInt(character).putLong(nanos);
+		event.putInt(key_code).put(state).putInt(character).putLong(nanos).put(repeat ? (byte)1 : (byte)0);
 		event.flip();
 		putEvent(event);
 	}
@@ -287,15 +287,16 @@
 		if (character == KeyEvent.CHAR_UNDEFINED)
 			character = Keyboard.CHAR_NONE;
 		if (state == 1) {
+			boolean repeat = false;
 			if (has_deferred_event) {
 				if ((nanos == deferred_nanos && deferred_key_code == key_code &&
 						deferred_key_location == key_location)) {
 					has_deferred_event = false;
-					return; // Ignore repeated key down, key up event pair
-				}
-				flushDeferredEvent();
+					repeat = true; // Repeat event
+				} else
+					flushDeferredEvent();
 			}
-			putKeyEvent(key_code, key_location, state, character, nanos);
+			putKeyEvent(key_code, key_location, state, character, nanos, repeat);
 		} else {
 			flushDeferredEvent();
 			has_deferred_event = true;
@@ -309,19 +310,19 @@
 
 	private void flushDeferredEvent() {
 		if (has_deferred_event) {
-			putKeyEvent(deferred_key_code, deferred_key_location, deferred_key_state, deferred_character, deferred_nanos);
+			putKeyEvent(deferred_key_code, deferred_key_location, deferred_key_state, deferred_character, deferred_nanos, false);
 			has_deferred_event = false;
 		}
 	}
 
-	private void putKeyEvent(int key_code, int key_location, byte state, int character, long nanos) {
+	private void putKeyEvent(int key_code, int key_location, byte state, int character, long nanos, boolean repeat) {
 		int key_code_mapped = getMappedKeyCode(key_code, key_location);
 		/* Ignore repeating presses */
 		if ( key_states[key_code_mapped] == state )
-			return;
+			repeat = true;
 		key_states[key_code_mapped] = state;
 		int key_int_char = character & 0xffff;
-		putKeyboardEvent(key_code_mapped, state, key_int_char, nanos);
+		putKeyboardEvent(key_code_mapped, state, key_int_char, nanos, repeat);
 	}
 
 	private int getMappedKeyCode(int key_code, int position) {

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -75,7 +75,7 @@
 	private final CharBuffer char_buffer = CharBuffer.allocate(KEYBOARD_BUFFER_SIZE);
 
 	// Deferred key released event, to detect key repeat
-	private boolean has_deferred_event = true;
+	private boolean has_deferred_event;
 	private int deferred_keycode;
 	private int deferred_event_keycode;
 	private long deferred_nanos;
@@ -169,9 +169,9 @@
 		keyDownBuffer.position(old_position);
 	}
 
-	private void putKeyboardEvent(int keycode, byte state, int ch, long nanos) {
+	private void putKeyboardEvent(int keycode, byte state, int ch, long nanos, boolean repeat) {
 		tmp_event.clear();
-		tmp_event.putInt(keycode).put(state).putInt(ch).putLong(nanos);
+		tmp_event.putInt(keycode).put(state).putInt(ch).putLong(nanos).put(repeat ? (byte)1 : (byte)0);
 		tmp_event.flip();
 		event_queue.putEvent(tmp_event);
 	}
@@ -211,20 +211,20 @@
 			return lookupStringISO88591(event_ptr, translation_buffer);
 	}
 
-	private void translateEvent(long event_ptr, int keycode, byte key_state, long nanos) {
+	private void translateEvent(long event_ptr, int keycode, byte key_state, long nanos, boolean repeat) {
 		int num_chars, i;
 		int ch;
 
 		num_chars = lookupString(event_ptr, temp_translation_buffer);
 		if (num_chars > 0) {
 			ch = temp_translation_buffer[0];
-			putKeyboardEvent(keycode, key_state, ch, nanos);
+			putKeyboardEvent(keycode, key_state, ch, nanos, repeat);
 			for (i = 1; i < num_chars; i++) {
 				ch = temp_translation_buffer[i];
-				putKeyboardEvent(0, (byte)0, ch, nanos);
+				putKeyboardEvent(0, (byte)0, ch, nanos, repeat);
 			}
 		} else {
-			putKeyboardEvent(keycode, key_state, 0, nanos);
+			putKeyboardEvent(keycode, key_state, 0, nanos, repeat);
 		}
 	}
 
@@ -305,14 +305,15 @@
 		key_down_buffer[keycode] = key_state;
 		long nanos = millis*1000000;
 		if (event_type == LinuxEvent.KeyPress) {
+			boolean repeat = false;
 			if (has_deferred_event) {
 				if (nanos == deferred_nanos && event_keycode == deferred_event_keycode) {
 					has_deferred_event = false;
-					return; // Repeated event, ignore it
-				}
-				flushDeferredEvent();
+					repeat = true; // Repeated event
+				} else
+					flushDeferredEvent();
 			}
-			translateEvent(event_ptr, keycode, key_state, nanos);
+			translateEvent(event_ptr, keycode, key_state, nanos, repeat);
 		} else {
 			flushDeferredEvent();
 			has_deferred_event = true;
@@ -325,7 +326,7 @@
 
 	private void flushDeferredEvent() {
 		if (has_deferred_event) {
-			putKeyboardEvent(deferred_keycode, deferred_key_state, 0, deferred_nanos);
+			putKeyboardEvent(deferred_keycode, deferred_key_state, 0, deferred_nanos, false);
 			has_deferred_event = false;
 		}
 	}

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsDisplay.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsDisplay.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsDisplay.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -608,12 +608,11 @@
 	private void handleKeyButton(long wParam, long lParam, long millis) {
 		byte previous_state = (byte)((lParam >>> 30) & 0x1);
 		byte state = (byte)(1 - ((lParam >>> 31) & 0x1));
-		if (state == previous_state)
-			return; // Auto-repeat message
+		boolean repeat = state == previous_state; // Repeat message
 		byte extended = (byte)((lParam >>> 24) & 0x1);
 		int scan_code = (int)((lParam >>> 16) & 0xFF);
 		if (keyboard != null)
-			keyboard.handleKey((int)wParam, scan_code, extended != 0, state, millis);
+			keyboard.handleKey((int)wParam, scan_code, extended != 0, state, millis, repeat);
 	}
 
 	private static int transformY(long hwnd, int y) {

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsKeyboard.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsKeyboard.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/WindowsKeyboard.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -63,6 +63,7 @@
 	private byte retained_state;
 	private int retained_char;
 	private long retained_millis;
+	private boolean retained_repeat;
 
 	public WindowsKeyboard(long hwnd) throws LWJGLException {
 		this.hwnd = hwnd;
@@ -97,9 +98,9 @@
 	private static native int GetKeyboardState(ByteBuffer lpKeyState);
 	private static native int GetKeyState(int virt_key);
 
-	private void putEvent(int keycode, byte state, int ch, long millis) {
+	private void putEvent(int keycode, byte state, int ch, long millis, boolean repeat) {
 		tmp_event.clear();
-		tmp_event.putInt(keycode).put(state).putInt(ch).putLong(millis*1000000);
+		tmp_event.putInt(keycode).put(state).putInt(ch).putLong(millis*1000000).put(repeat ? (byte)1 : (byte)0);
 		tmp_event.flip();
 		event_queue.putEvent(tmp_event);
 	}
@@ -144,11 +145,11 @@
 	private void flushRetained() {
 		if (has_retained_event) {
 			has_retained_event = false;
-			putEvent(retained_key_code, retained_state, retained_char, retained_millis);
+			putEvent(retained_key_code, retained_state, retained_char, retained_millis, retained_repeat);
 		}
 	}
 
-	public void handleKey(int virt_key, int scan_code, boolean extended, byte event_state, long millis) {
+	public void handleKey(int virt_key, int scan_code, boolean extended, byte event_state, long millis, boolean repeat) {
 		virt_key = translateExtended(virt_key, scan_code, event_state, extended);
 		flushRetained();
 		has_retained_event = true;
@@ -159,12 +160,13 @@
 		retained_state = event_state;
 		retained_millis = millis;
 		retained_char = 0;
+		retained_repeat = repeat;
 //		translate(virt_key, event_state, millis*1000000);
 	}
 
 	public void handleChar(int event_char, long millis) {
 		if (!has_retained_event) {
-			putEvent(0, (byte)0, event_char, millis);
+			putEvent(0, (byte)0, event_char, millis, false);
 		} else
 			retained_char = event_char;
 	}

Modified: trunk/LWJGL/src/java/org/lwjgl/test/input/KeyboardTest.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/test/input/KeyboardTest.java	2007-05-13 21:11:53 UTC (rev 2817)
+++ trunk/LWJGL/src/java/org/lwjgl/test/input/KeyboardTest.java	2007-05-13 22:01:48 UTC (rev 2818)
@@ -152,7 +152,11 @@
         System.out.println("Pressed:" + Keyboard.getEventKeyState());
         System.out.println("Key character code: " + character_code);
         System.out.println("Key character: " + Keyboard.getEventCharacter());
+        System.out.println("Repeat event: " + Keyboard.isRepeatEvent());
         
+        if (Keyboard.getEventKey() == Keyboard.KEY_R && Keyboard.getEventKeyState()) {
+          Keyboard.enableRepeatEvents(!Keyboard.areRepeatEventsEnabled());
+        }
         if (Keyboard.getEventKey() == Keyboard.KEY_ESCAPE) {
           return;
         }


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2817
          http://svn.sourceforge.net/java-game-lib/?rev=2817&view=rev
Author:   elias_naur
Date:     2007-05-13 14:11:53 -0700 (Sun, 13 May 2007)

Log Message:
-----------
Use event timestamp to detect key repeat events in KeyboardEventQueue

Modified Paths:
--------------
    trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxAWTInput.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java
    trunk/LWJGL/src/native/linux/org_lwjgl_opengl_Display.c

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java	2007-05-13 20:13:37 UTC (rev 2816)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/KeyboardEventQueue.java	2007-05-13 21:11:53 UTC (rev 2817)
@@ -53,6 +53,13 @@
 
 	private final Component component;
 
+	private boolean has_deferred_event;
+	private long deferred_nanos;
+	private int deferred_key_code;
+	private int deferred_key_location;
+	private byte deferred_key_state;
+	private int deferred_character;
+
 	static {
 		KEY_MAP[KeyEvent.VK_0] = Keyboard.KEY_0;
 		KEY_MAP[KeyEvent.VK_1] = Keyboard.KEY_1;
@@ -265,14 +272,50 @@
 	}
 
 	public synchronized void poll(ByteBuffer key_down_buffer) {
+		flushDeferredEvent();
 		int old_position = key_down_buffer.position();
 		key_down_buffer.put(key_states);
 		key_down_buffer.position(old_position);
 	}
 
-	private synchronized void handleKey(int key_code_mapped, byte state, int character, long nanos) {
-		if ( character == KeyEvent.CHAR_UNDEFINED )
+	public synchronized void copyEvents(ByteBuffer dest) {
+		flushDeferredEvent();
+		super.copyEvents(dest);
+	}
+
+	private synchronized void handleKey(int key_code, int key_location, byte state, int character, long nanos) {
+		if (character == KeyEvent.CHAR_UNDEFINED)
 			character = Keyboard.CHAR_NONE;
+		if (state == 1) {
+			if (has_deferred_event) {
+				if ((nanos == deferred_nanos && deferred_key_code == key_code &&
+						deferred_key_location == key_location)) {
+					has_deferred_event = false;
+					return; // Ignore repeated key down, key up event pair
+				}
+				flushDeferredEvent();
+			}
+			putKeyEvent(key_code, key_location, state, character, nanos);
+		} else {
+			flushDeferredEvent();
+			has_deferred_event = true;
+			deferred_nanos = nanos;
+			deferred_key_code = key_code;
+			deferred_key_location = key_location;
+			deferred_key_state = state;
+			deferred_character = character;
+		}
+	}
+
+	private void flushDeferredEvent() {
+		if (has_deferred_event) {
+			putKeyEvent(deferred_key_code, deferred_key_location, deferred_key_state, deferred_character, deferred_nanos);
+			has_deferred_event = false;
+		}
+	}
+
+	private void putKeyEvent(int key_code, int key_location, byte state, int character, long nanos) {
+		int key_code_mapped = getMappedKeyCode(key_code, key_location);
 		/* Ignore repeating presses */
 		if ( key_states[key_code_mapped] == state )
 			return;
@@ -306,11 +349,11 @@
 	}
 
 	public void keyPressed(KeyEvent e) {
-		handleKey(getMappedKeyCode(e.getKeyCode(), e.getKeyLocation()), (byte)1, e.getKeyChar(), e.getWhen()*1000000);
+		handleKey(e.getKeyCode(), e.getKeyLocation(), (byte)1, e.getKeyChar(), e.getWhen()*1000000);
 	}
 
 	public void keyReleased(KeyEvent e) {
-		handleKey(getMappedKeyCode(e.getKeyCode(), e.getKeyLocation()), (byte)0, Keyboard.CHAR_NONE, e.getWhen()*1000000);
+		handleKey(e.getKeyCode(), e.getKeyLocation(), (byte)0, Keyboard.CHAR_NONE, e.getWhen()*1000000);
 	}
 
 	public void keyTyped(KeyEvent e) {

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxAWTInput.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxAWTInput.java	2007-05-13 20:13:37 UTC (rev 2816)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxAWTInput.java	2007-05-13 21:11:53 UTC (rev 2817)
@@ -92,7 +92,6 @@
 		if (input_grabbed) {
 //			LinuxDisplay.nUngrabKeyboard(display);
 			LinuxDisplay.nUngrabPointer(display);
-			LinuxDisplay.nSetRepeatMode(display, LinuxDisplay.AutoRepeatModeDefault);
 			input_grabbed = false;
 		}
 	}
@@ -100,7 +99,6 @@
 	private void grabInput(long window) {
 		if (!input_grabbed) {
 //			int res1 = LinuxDisplay.nGrabKeyboard(display, window);
-			LinuxDisplay.nSetRepeatMode(display, LinuxDisplay.AutoRepeatModeOff);
 			int res2 = LinuxDisplay.nGrabPointer(display, window, blank_cursor);
 			if (/*res1 == LinuxDisplay.GrabSuccess && */res2 == LinuxDisplay.GrabSuccess)
 				input_grabbed = true;

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java	2007-05-13 20:13:37 UTC (rev 2816)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java	2007-05-13 21:11:53 UTC (rev 2817)
@@ -789,7 +789,6 @@
 			}
 		}
 	}
-	static native void nSetRepeatMode(long display, int mode);
 
 	public void grabMouse(boolean new_grab) {
 		lockAWT();

Modified: trunk/LWJGL/src/native/linux/org_lwjgl_opengl_Display.c
===================================================================
--- trunk/LWJGL/src/native/linux/org_lwjgl_opengl_Display.c	2007-05-13 20:13:37 UTC (rev 2816)
+++ trunk/LWJGL/src/native/linux/org_lwjgl_opengl_Display.c	2007-05-13 21:11:53 UTC (rev 2817)
@@ -469,13 +469,6 @@
 	return win;
 }
 
-JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nSetRepeatMode(JNIEnv *env, jclass unused, jlong display_ptr, jint mode) {
-	Display *disp = (Display *)(intptr_t)display_ptr;
-	XKeyboardControl repeat_mode;
-	repeat_mode.auto_repeat_mode = mode;
-	XChangeKeyboardControl(disp, KBAutoRepeatMode, &repeat_mode);
-}
-
 JNIEXPORT void JNICALL Java_org_lwjgl_opengl_LinuxDisplay_nIconifyWindow(JNIEnv *env, jclass unused, jlong display_ptr, jlong window_ptr, jint screen) {
 	Display *disp = (Display *)(intptr_t)display_ptr;
 	Window win = (Window)window_ptr;


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.

Revision: 2816
          http://svn.sourceforge.net/java-game-lib/?rev=2816&view=rev
Author:   elias_naur
Date:     2007-05-13 13:13:37 -0700 (Sun, 13 May 2007)

Log Message:
-----------
use timestamp matching hack to detect key repeat events instead of globally disabling keyboard repeating

Modified Paths:
--------------
    trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java
    trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java	2007-05-01 18:13:29 UTC (rev 2815)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxDisplay.java	2007-05-13 20:13:37 UTC (rev 2816)
@@ -404,7 +404,6 @@
 					minimized = false;
 					dirty = true;
 					updateInputGrab();
-					nSetRepeatMode(getDisplay(), AutoRepeatModeOff);
 				} finally {
 					peer_info.unlock();
 				}
@@ -435,7 +434,6 @@
 			blank_cursor = None;
 			ungrabKeyboard();
 			nDestroyWindow(getDisplay(), getWindow());
-			nSetRepeatMode(getDisplay(), AutoRepeatModeDefault);
 			decDisplay();
 		} finally {
 			unlockAWT();
@@ -764,7 +762,6 @@
 		if (isLegacyFullscreen() || input_released)
 			return;
 		input_released = true;
-		nSetRepeatMode(getDisplay(), AutoRepeatModeDefault);
 		updateInputGrab();
 		if (current_window_mode == FULLSCREEN_NETWM) {
 			nIconifyWindow(getDisplay(), getWindow(), getDefaultScreen());
@@ -782,7 +779,6 @@
 		if (isLegacyFullscreen() || !input_released)
 			return;
 		input_released = false;
-		nSetRepeatMode(getDisplay(), AutoRepeatModeOff);
 		updateInputGrab();
 		if (current_window_mode == FULLSCREEN_NETWM) {
 			try {

Modified: trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java
===================================================================
--- trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java	2007-05-01 18:13:29 UTC (rev 2815)
+++ trunk/LWJGL/src/java/org/lwjgl/opengl/LinuxKeyboard.java	2007-05-13 20:13:37 UTC (rev 2816)
@@ -47,8 +47,6 @@
 
 final class LinuxKeyboard {
 	private static final int LockMapIndex                      = 1;
-	private static final int KeyPress = 2;
-	private static final int KeyRelease = 3;
 	private static final long NoSymbol = 0;
 	private static final long ShiftMask = 1 << 0;
 	private static final long LockMask = 1 << 1;
@@ -76,6 +74,13 @@
 	private final CharsetDecoder utf8_decoder = Charset.forName("UTF-8").newDecoder();
 	private final CharBuffer char_buffer = CharBuffer.allocate(KEYBOARD_BUFFER_SIZE);
 
+	// Deferred key released event, to detect key repeat
+	private boolean has_deferred_event = true;
+	private int deferred_keycode;
+	private int deferred_event_keycode;
+	private long deferred_nanos;
+	private byte deferred_key_state;
+
 	public LinuxKeyboard(long display, long window) {
 		long modifier_map = getModifierMapping(display);
 		int tmp_numlock_mask = 0;
@@ -153,10 +158,12 @@
 	private static native void closeIM(long xim);
 
 	public void read(ByteBuffer buffer) {
+		flushDeferredEvent();
 		event_queue.copyEvents(buffer);
 	}
 
 	public void poll(ByteBuffer keyDownBuffer) {
+		flushDeferredEvent();
 		int old_position = keyDownBuffer.position();
 		keyDownBuffer.put(key_down_buffer);
 		keyDownBuffer.position(old_position);
@@ -204,14 +211,10 @@
 			return lookupStringISO88591(event_ptr, translation_buffer);
 	}
 
-	private void translateEvent(long event_ptr, int event_type, int keycode, byte key_state, long nanos) {
+	private void translateEvent(long event_ptr, int keycode, byte key_state, long nanos) {
 		int num_chars, i;
 		int ch;
 
-		if (event_type == KeyRelease) {
-			putKeyboardEvent(keycode, key_state, 0, nanos);
-			return;
-		}
 		num_chars = lookupString(event_ptr, temp_translation_buffer);
 		if (num_chars > 0) {
 			ch = temp_translation_buffer[0];
@@ -287,9 +290,9 @@
 
 	private byte getKeyState(int event_type) {
 		switch (event_type) {
-			case KeyPress:
+			case LinuxEvent.KeyPress:
 				return 1;
-			case KeyRelease:
+			case LinuxEvent.KeyRelease:
 				return 0;
 			default:
 				throw new IllegalArgumentException("Unknown event_type: " + event_type);
@@ -300,9 +303,33 @@
 		int keycode = getKeycode(event_ptr, event_state);
 		byte key_state = getKeyState(event_type);
 		key_down_buffer[keycode] = key_state;
-		translateEvent(event_ptr, event_type, keycode, key_state, millis*1000000);
+		long nanos = millis*1000000;
+		if (event_type == LinuxEvent.KeyPress) {
+			if (has_deferred_event) {
+				if (nanos == deferred_nanos && event_keycode == deferred_event_keycode) {
+					has_deferred_event = false;
+					return; // Repeated event, ignore it
+				}
+				flushDeferredEvent();
+			}
+			translateEvent(event_ptr, keycode, key_state, nanos);
+		} else {
+			flushDeferredEvent();
+			has_deferred_event = true;
+			deferred_keycode = keycode;
+			deferred_event_keycode = event_keycode;
+			deferred_nanos = nanos;
+			deferred_key_state = key_state;
+		}
 	}
 
+	private void flushDeferredEvent() {
+		if (has_deferred_event) {
+			putKeyboardEvent(deferred_keycode, deferred_key_state, 0, deferred_nanos);
+			has_deferred_event = false;
+		}
+	}
+
 	public boolean filterEvent(LinuxEvent event) {
 		switch (event.getType()) {
 			case LinuxEvent.KeyPress: /* Fall through */


This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.