NEWT Add: add<type>Listener(int index, <type>Listener l) ; get<type>Listener(int index) ; NEWTEvent attachments

NEWT Add:
    add<type>Listener(int index, <type>Listener l) ;
    get<type>Listener(int index) ;

    NEWTEvent attachments for listener to listener communication
    via object passing. This methodology is similar to the 'Atom'
    attachment of native systems.
    It is preferred to a 'consume()/isConsumed()' pattern,
    since it is less flexible and would 'endanger' system events.

TODO: <type>Listener[] get<type>Listeners() doesn't work and was always buggy.

8 files changed, 527 insertions, 36 deletions

diff --git a/src/junit/com/jogamp/test/junit/newt/TestListenerCom01AWT.java b/src/junit/com/jogamp/test/junit/newt/TestListenerCom01AWT.java
new file mode 100755
index 000000000..b661d02f3
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/TestListenerCom01AWT.java
@@ -0,0 +1,173 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.newt;
+
+import java.lang.reflect.*;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.BeforeClass;
+import org.junit.After;
+import org.junit.AfterClass;
+import org.junit.Test;
+
+import java.awt.Button;
+import java.awt.BorderLayout;
+import java.awt.Canvas;
+import java.awt.Frame;
+
+import javax.media.opengl.*;
+import javax.media.nativewindow.*;
+
+import com.jogamp.opengl.util.Animator;
+import com.jogamp.newt.*;
+import com.jogamp.newt.event.*;
+import com.jogamp.newt.opengl.*;
+import com.jogamp.newt.awt.NewtCanvasAWT;
+
+import java.io.IOException;
+
+import com.jogamp.test.junit.util.*;
+import com.jogamp.test.junit.jogl.demos.es1.RedSquare;
+import com.jogamp.test.junit.jogl.demos.gl2.gears.Gears;
+
+public class TestListenerCom01AWT {
+    static int width, height;
+    static long durationPerTest = 500;
+    static long waitReparent = 300;
+    static boolean verbose = false;
+
+    @BeforeClass
+    public static void initClass() {
+        width  = 640;
+        height = 480;
+    }
+
+    @Test
+    public void testListenerStringPassingAndOrder() throws InterruptedException {
+        // setup NEWT GLWindow ..
+        GLWindow glWindow = GLWindow.create(new GLCapabilities(null));
+        Assert.assertNotNull(glWindow);
+        glWindow.setTitle("NEWT - CHILD");
+
+        System.out.println("durationPerTest "+durationPerTest);
+
+        GLEventListener demo = new Gears();
+        setDemoFields(demo, glWindow, false);
+        glWindow.addGLEventListener(demo);
+
+        WindowEventCom1 wl1 = new WindowEventCom1();
+        WindowEventCom2 wl2 = new WindowEventCom2();
+        WindowEventCom3 wl3 = new WindowEventCom3();
+
+        // TraceWindowAdapter wlT = new TraceWindowAdapter();
+        // glWindow.addWindowListener(0, wlT);
+        // Assert.assertEquals(wlT, glWindow.getWindowListener(0));
+
+        glWindow.addWindowListener(0, wl3);
+        glWindow.addWindowListener(0, wl2);
+        glWindow.addWindowListener(0, wl1);
+
+        Assert.assertEquals(wl1, glWindow.getWindowListener(0));
+        Assert.assertEquals(wl2, glWindow.getWindowListener(1));
+        Assert.assertEquals(wl3, glWindow.getWindowListener(2));
+
+        // attach NEWT GLWindow to AWT Canvas
+        NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow);
+        Frame frame = new Frame("AWT Parent Frame");
+        frame.add(newtCanvasAWT);
+        frame.setSize(width, height);
+        frame.setVisible(true);
+
+        Animator animator1 = new Animator(glWindow);
+        animator1.start();
+        while(animator1.isAnimating() && animator1.getDuration()<durationPerTest) {
+            Thread.sleep(100);
+            width+=10; height+=10;
+            frame.setSize(width, height);
+        }
+        animator1.stop();
+        Assert.assertEquals(false, animator1.isAnimating());
+
+        frame.dispose();
+        glWindow.destroy(true);
+    }
+
+    public static void setDemoFields(GLEventListener demo, GLWindow glWindow, boolean debug) {
+        Assert.assertNotNull(demo);
+        Assert.assertNotNull(glWindow);
+        Window window = glWindow.getInnerWindow();
+        if(debug) {
+            MiscUtils.setFieldIfExists(demo, "glDebug", true);
+            MiscUtils.setFieldIfExists(demo, "glTrace", true);
+        }
+        if(!MiscUtils.setFieldIfExists(demo, "window", window)) {
+            MiscUtils.setFieldIfExists(demo, "glWindow", glWindow);
+        }
+    }
+
+    static int atoi(String a) {
+        int i=0;
+        try {
+            durationPerTest = Integer.parseInt(a);
+        } catch (Exception ex) { ex.printStackTrace(); }
+        return i;
+    }
+
+    public static void main(String args[]) throws IOException {
+        verbose = true;
+        for(int i=0; i<args.length; i++) {
+            if(args[i].equals("-time")) {
+                durationPerTest = atoi(args[++i]);
+            } else if(args[i].equals("-wait")) {
+                waitReparent = atoi(args[++i]);
+            }
+        }
+        String tstname = TestListenerCom01AWT.class.getName();
+        org.apache.tools.ant.taskdefs.optional.junit.JUnitTestRunner.main(new String[] {
+            tstname,
+            "filtertrace=true",
+            "haltOnError=false",
+            "haltOnFailure=false",
+            "showoutput=true",
+            "outputtoformatters=true",
+            "logfailedtests=true",
+            "logtestlistenerevents=true",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.PlainJUnitResultFormatter",
+            "formatter=org.apache.tools.ant.taskdefs.optional.junit.XMLJUnitResultFormatter,TEST-"+tstname+".xml" } );
+    }
+
+}
diff --git a/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java b/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java
index 2c695f788..39659d763 100755
--- a/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java
+++ b/src/junit/com/jogamp/test/junit/newt/TestParenting01AWT.java
@@ -94,7 +94,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
         Assert.assertNotNull(newtCanvasAWT);
@@ -106,7 +105,6 @@ public class TestParenting01AWT {
         Assert.assertNotNull(frame);
         frame.add(newtCanvasAWT);
         frame.setSize(width, height);
-        // frame.pack();
 
         // visible test
         frame.setVisible(true);
@@ -152,7 +150,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
         Assert.assertNotNull(newtCanvasAWT);
@@ -169,7 +166,6 @@ public class TestParenting01AWT {
 
         frame.add(newtCanvasAWT);
         Assert.assertEquals(newtCanvasAWT.getNativeWindow(),glWindow1.getParentNativeWindow());
-        // frame.pack();
 
         Animator animator1 = new Animator(glWindow1);
         animator1.start();
@@ -194,7 +190,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
 
@@ -206,7 +201,6 @@ public class TestParenting01AWT {
         frame.setVisible(true);
 
         frame.add(newtCanvasAWT);
-        // frame.pack();
 
         Animator animator1 = new Animator(glWindow1);
         animator1.start();
@@ -231,7 +225,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
 
@@ -242,7 +235,6 @@ public class TestParenting01AWT {
 
         frame.add(newtCanvasAWT);
         Assert.assertEquals(newtCanvasAWT.getNativeWindow(),glWindow1.getParentNativeWindow());
-        // frame.pack();
 
         Animator animator1 = new Animator(glWindow1);
         animator1.start();
@@ -283,7 +275,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
 
@@ -299,7 +290,6 @@ public class TestParenting01AWT {
 
         frame.add(newtCanvasAWT, BorderLayout.CENTER);
         Assert.assertEquals(newtCanvasAWT.getNativeWindow(),glWindow1.getParentNativeWindow());
-        // frame.pack();
 
         Animator animator1 = new Animator(glWindow1);
         animator1.start();
@@ -340,7 +330,6 @@ public class TestParenting01AWT {
         GLEventListener demo1 = new RedSquare();
         setDemoFields(demo1, glWindow1, false);
         glWindow1.addGLEventListener(demo1);
-        // glWindow1.setSize(600, 300);
 
         NewtCanvasAWT newtCanvasAWT = new NewtCanvasAWT(glWindow1);
 
@@ -366,7 +355,6 @@ public class TestParenting01AWT {
 
         frame1.add(newtCanvasAWT, BorderLayout.CENTER);
         Assert.assertEquals(newtCanvasAWT.getNativeWindow(),glWindow1.getParentNativeWindow());
-        // frame1.pack();
 
         Animator animator1 = new Animator(glWindow1);
         animator1.start();
@@ -378,12 +366,10 @@ public class TestParenting01AWT {
                 case 0:
                     frame1.remove(newtCanvasAWT);
                     frame2.add(newtCanvasAWT, BorderLayout.CENTER);
-                    //frame2.pack();
                     break;
                 case 1:
                     frame2.remove(newtCanvasAWT);
                     frame1.add(newtCanvasAWT, BorderLayout.CENTER);
-                    //frame1.pack();
                     break;
             }
             state++;
diff --git a/src/junit/com/jogamp/test/junit/newt/WindowEventCom1.java b/src/junit/com/jogamp/test/junit/newt/WindowEventCom1.java
new file mode 100644
index 000000000..fa6ad0e92
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/WindowEventCom1.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.newt;
+
+import com.jogamp.newt.event.*;
+
+class WindowEventCom1 extends WindowAdapter {
+
+    public void windowResized(WindowEvent e) {
+        e.setAttachment(new String("WindowEventCom1.windowResized: "+e));
+    }
+    public void windowMoved(WindowEvent e) {
+        e.setAttachment(new String("WindowEventCom1.windowMoved: "+e));
+    }
+}
+
diff --git a/src/junit/com/jogamp/test/junit/newt/WindowEventCom2.java b/src/junit/com/jogamp/test/junit/newt/WindowEventCom2.java
new file mode 100644
index 000000000..9c6820831
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/WindowEventCom2.java
@@ -0,0 +1,52 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.newt;
+
+import com.jogamp.newt.event.*;
+
+class WindowEventCom2 extends WindowAdapter {
+
+    public void windowResized(WindowEvent e) {
+        String str = (String) e.getAttachment();
+        if(null==str) {
+            e.setAttachment(new String("WindowEventCom2.windowResized: "+e));
+        }
+    }
+    public void windowMoved(WindowEvent e) {
+        String str = (String) e.getAttachment();
+        if(null==str) {
+            e.setAttachment(new String("WindowEventCom2.windowMoved: "+e));
+        }
+    }
+}
+
diff --git a/src/junit/com/jogamp/test/junit/newt/WindowEventCom3.java b/src/junit/com/jogamp/test/junit/newt/WindowEventCom3.java
new file mode 100644
index 000000000..247393e92
--- /dev/null
+++ b/src/junit/com/jogamp/test/junit/newt/WindowEventCom3.java
@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2010 Sven Gothel. All Rights Reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ * 
+ * - Redistribution of source code must retain the above copyright
+ *   notice, this list of conditions and the following disclaimer.
+ * 
+ * - Redistribution in binary form must reproduce the above copyright
+ *   notice, this list of conditions and the following disclaimer in the
+ *   documentation and/or other materials provided with the distribution.
+ * 
+ * Neither the name Sven Gothel or the names of
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ * 
+ * This software is provided "AS IS," without a warranty of any kind. ALL
+ * EXPRESS OR IMPLIED CONDITIONS, REPRESENTATIONS AND WARRANTIES,
+ * INCLUDING ANY IMPLIED WARRANTY OF MERCHANTABILITY, FITNESS FOR A
+ * PARTICULAR PURPOSE OR NON-INFRINGEMENT, ARE HEREBY EXCLUDED. SUN
+ * MICROSYSTEMS, INC. ("SUN") AND ITS LICENSORS SHALL NOT BE LIABLE FOR
+ * ANY DAMAGES SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR
+ * DISTRIBUTING THIS SOFTWARE OR ITS DERIVATIVES. IN NO EVENT WILL SUN OR
+ * ITS LICENSORS BE LIABLE FOR ANY LOST REVENUE, PROFIT OR DATA, OR FOR
+ * DIRECT, INDIRECT, SPECIAL, CONSEQUENTIAL, INCIDENTAL OR PUNITIVE
+ * DAMAGES, HOWEVER CAUSED AND REGARDLESS OF THE THEORY OF LIABILITY,
+ * ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
+ * SVEN GOTHEL HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
+ */
+
+package com.jogamp.test.junit.newt;
+
+import com.jogamp.newt.event.*;
+
+class WindowEventCom3 extends WindowAdapter {
+
+    public void windowResized(WindowEvent e) {
+        String str = (String) e.getAttachment();
+        System.out.println("WindowEventCom3.windowResized: "+str);
+    }
+    public void windowMoved(WindowEvent e) {
+        String str = (String) e.getAttachment();
+        System.out.println("WindowEventCom3.windowMoved: "+str);
+    }
+}
+
diff --git a/src/newt/classes/com/jogamp/newt/Window.java b/src/newt/classes/com/jogamp/newt/Window.java
index 89c1bd146..9e338c94b 100755
--- a/src/newt/classes/com/jogamp/newt/Window.java
+++ b/src/newt/classes/com/jogamp/newt/Window.java
@@ -42,6 +42,7 @@ import javax.media.nativewindow.*;
 import com.jogamp.nativewindow.impl.RecursiveToolkitLock;
 
 import java.util.ArrayList;
+import java.util.List;
 import java.util.Iterator;
 import java.lang.reflect.Method;
 
@@ -974,13 +975,36 @@ public abstract class Window implements NativeWindow
 
     private ArrayList surfaceUpdatedListeners = new ArrayList();
 
+    /** 
+     * Appends the given {@link com.jogamp.newt.event.SurfaceUpdatedListener} to the end of 
+     * the list.
+     */
     public void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
+        getInnerWindow().addSurfaceUpdatedListener(-1, l);
+    }
+
+    /** 
+     * Inserts the given {@link com.jogamp.newt.event.SurfaceUpdatedListener} at the 
+     * specified position in the list.<br>
+
+     * @param index Position where the listener will be inserted. 
+     *              Should be within (0 <= index && index <= size()).
+     *              An index value of -1 is interpreted as the end of the list, size().
+     * @param l The listener object to be inserted
+     * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+     */
+    public void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l) 
+        throws IndexOutOfBoundsException
+    {
         if(l == null) {
             return;
         }
         synchronized(surfaceUpdatedListeners) {
+            if(0>index) { 
+                index = surfaceUpdatedListeners.size(); 
+            }
             ArrayList newSurfaceUpdatedListeners = (ArrayList) surfaceUpdatedListeners.clone();
-            newSurfaceUpdatedListeners.add(l);
+            newSurfaceUpdatedListeners.add(index, l);
             surfaceUpdatedListeners = newSurfaceUpdatedListeners;
         }
     }
@@ -1002,7 +1026,16 @@ public abstract class Window implements NativeWindow
         }
     }
 
-    public SurfaceUpdatedListener[] getSurfaceUpdatedListener() {
+    public SurfaceUpdatedListener getSurfaceUpdatedListener(int index) {
+        synchronized(surfaceUpdatedListeners) {
+            if(0>index) { 
+                index = surfaceUpdatedListeners.size()-1; 
+            }
+            return (SurfaceUpdatedListener) surfaceUpdatedListeners.get(index);
+        }
+    }
+
+    public SurfaceUpdatedListener[] getSurfaceUpdatedListeners() {
         synchronized(surfaceUpdatedListeners) {
             return (SurfaceUpdatedListener[]) surfaceUpdatedListeners.toArray();
         }
@@ -1088,13 +1121,34 @@ public abstract class Window implements NativeWindow
     }
 
 
+    /** 
+     * Appends the given {@link com.jogamp.newt.event.MouseListener} to the end of 
+     * the list.
+     */
     public void addMouseListener(MouseListener l) {
+        getInnerWindow().addMouseListener(-1, l);
+    }
+
+    /** 
+     * Inserts the given {@link com.jogamp.newt.event.MouseListener} at the 
+     * specified position in the list.<br>
+
+     * @param index Position where the listener will be inserted. 
+     *              Should be within (0 <= index && index <= size()).
+     *              An index value of -1 is interpreted as the end of the list, size().
+     * @param l The listener object to be inserted
+     * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+     */
+    public void addMouseListener(int index, MouseListener l) {
         if(l == null) {
             return;
         }
         synchronized(mouseListeners) {
+            if(0>index) { 
+                index = mouseListeners.size(); 
+            }
             ArrayList newMouseListeners = (ArrayList) mouseListeners.clone();
-            newMouseListeners.add(l);
+            newMouseListeners.add(index, l);
             mouseListeners = newMouseListeners;
         }
     }
@@ -1110,6 +1164,15 @@ public abstract class Window implements NativeWindow
         }
     }
 
+    public MouseListener getWindowListener(int index) {
+        synchronized(mouseListeners) {
+            if(0>index) { 
+                index = mouseListeners.size()-1; 
+            }
+            return (MouseListener) mouseListeners.get(index);
+        }
+    }
+
     public MouseListener[] getMouseListeners() {
         synchronized(mouseListeners) {
             return (MouseListener[]) mouseListeners.toArray();
@@ -1168,13 +1231,34 @@ public abstract class Window implements NativeWindow
                          modifiers, keyCode, keyChar) );
     }
 
+    /** 
+     * Appends the given {@link com.jogamp.newt.event.KeyListener} to the end of 
+     * the list.
+     */
     public void addKeyListener(KeyListener l) {
+        getInnerWindow().addKeyListener(-1, l);
+    }
+
+    /** 
+     * Inserts the given {@link com.jogamp.newt.event.KeyListener} at the 
+     * specified position in the list.<br>
+
+     * @param index Position where the listener will be inserted. 
+     *              Should be within (0 <= index && index <= size()).
+     *              An index value of -1 is interpreted as the end of the list, size().
+     * @param l The listener object to be inserted
+     * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+     */
+    public void addKeyListener(int index, KeyListener l) {
         if(l == null) {
             return;
         }
         synchronized(keyListeners) {
+            if(0>index) { 
+                index = keyListeners.size(); 
+            }
             ArrayList newKeyListeners = (ArrayList) keyListeners.clone();
-            newKeyListeners.add(l);
+            newKeyListeners.add(index, l);
             keyListeners = newKeyListeners;
         }
     }
@@ -1190,6 +1274,15 @@ public abstract class Window implements NativeWindow
         }
     }
 
+    public KeyListener getKeyListener(int index) {
+        synchronized(keyListeners) {
+            if(0>index) { 
+                index = keyListeners.size()-1; 
+            }
+            return (KeyListener) keyListeners.get(index);
+        }
+    }
+
     public KeyListener[] getKeyListeners() {
         synchronized(keyListeners) {
             return (KeyListener[]) keyListeners.toArray();
@@ -1235,13 +1328,36 @@ public abstract class Window implements NativeWindow
 
     private ArrayList windowListeners = new ArrayList();
 
+    /** 
+     * Appends the given {@link com.jogamp.newt.event.WindowListener} to the end of 
+     * the list.
+     */
     public void addWindowListener(WindowListener l) {
+        getInnerWindow().addWindowListener(-1, l);
+    }
+
+    /** 
+     * Inserts the given {@link com.jogamp.newt.event.WindowListener} at the 
+     * specified position in the list.<br>
+
+     * @param index Position where the listener will be inserted. 
+     *              Should be within (0 <= index && index <= size()).
+     *              An index value of -1 is interpreted as the end of the list, size().
+     * @param l The listener object to be inserted
+     * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+     */
+    public void addWindowListener(int index, WindowListener l) 
+        throws IndexOutOfBoundsException
+    {
         if(l == null) {
             return;
         }
         synchronized(windowListeners) {
+            if(0>index) { 
+                index = windowListeners.size(); 
+            }
             ArrayList newWindowListeners = (ArrayList) windowListeners.clone();
-            newWindowListeners.add(l);
+            newWindowListeners.add(index, l);
             windowListeners = newWindowListeners;
         }
     }
@@ -1257,6 +1373,15 @@ public abstract class Window implements NativeWindow
         }
     }
 
+    public WindowListener getWindowListener(int index) {
+        synchronized(windowListeners) {
+            if(0>index) { 
+                index = windowListeners.size()-1; 
+            }
+            return (WindowListener) windowListeners.get(index);
+        }
+    }
+
     public WindowListener[] getWindowListeners() {
         synchronized(windowListeners) {
             return (WindowListener[]) windowListeners.toArray();
@@ -1304,13 +1429,34 @@ public abstract class Window implements NativeWindow
 
     private ArrayList paintListeners = new ArrayList();
 
+    /** 
+     * Appends the given {@link com.jogamp.newt.event.PaintListener} to the end of 
+     * the list.
+     */
     public void addPaintListener(PaintListener l) {
+        getInnerWindow().addPaintListener(-1, l);
+    }
+
+    /** 
+     * Inserts the given {@link com.jogamp.newt.event.PaintListener} at the 
+     * specified position in the list.<br>
+
+     * @param index Position where the listener will be inserted. 
+     *              Should be within (0 <= index && index <= size()).
+     *              An index value of -1 is interpreted as the end of the list, size().
+     * @param l The listener object to be inserted
+     * @throws IndexOutOfBoundsException If the index is not within (0 <= index && index <= size()), or -1
+     */
+    public void addPaintListener(int index, PaintListener l) {
         if(l == null) {
             return;
         }
         synchronized(paintListeners) {
+            if(0>index) { 
+                index = paintListeners.size(); 
+            }
             ArrayList newPaintListeners = (ArrayList) paintListeners.clone();
-            newPaintListeners.add(l);
+            newPaintListeners.add(index, l);
             paintListeners = newPaintListeners;
         }
     }
@@ -1326,6 +1472,15 @@ public abstract class Window implements NativeWindow
         }
     }
 
+    public PaintListener getPaintListener(int index) {
+        synchronized(paintListeners) {
+            if(0>index) { 
+                index = paintListeners.size()-1; 
+            }
+            return (PaintListener) paintListeners.get(index);
+        }
+    }
+
     protected void sendPaintEvent(int eventType, int x, int y, int w, int h) {
         sendPaintEvent( new PaintEvent(eventType, this, System.currentTimeMillis(), x, y, w, h) );
     }
diff --git a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
index 1be3dcb3f..2cb2c5177 100644
--- a/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
+++ b/src/newt/classes/com/jogamp/newt/event/NEWTEvent.java
@@ -45,6 +45,7 @@ public class NEWTEvent extends java.util.EventObject {
     private boolean isSystemEvent;
     private int eventType;
     private long when;
+    private Object attachment;
 
     static final boolean DEBUG = false;
 
@@ -105,6 +106,7 @@ public class NEWTEvent extends java.util.EventObject {
         this.isSystemEvent = evaluateIsSystemEvent(this, new Throwable());
         this.eventType = eventType;
         this.when = when;
+        this.attachment=null;
     }
 
     /** Indicates whether this event was produced by the system or
@@ -123,6 +125,25 @@ public class NEWTEvent extends java.util.EventObject {
         return when;
     }
 
+    /** 
+     * Attach the passed object to this event.<br>
+     * If an object was previously attached, it will replaced.<br>
+     * Attachments to NEWT events allow users to pass on information
+     * from one custom listener to another, ie custom listener to listener 
+     * communication.
+     * @param attachment User application specific object
+     */
+    public final void setAttachment(Object attachment) {
+        this.attachment=attachment;
+    }
+
+    /** 
+     * @return The user application specific attachment, or null
+     */
+    public final Object getAttachment() {
+        return attachment;
+    }
+
     public String toString() {
         return "NEWTEvent[sys:"+isSystemEvent()+", source:"+getSource().getClass().getName()+", when:"+getWhen()+" d "+(System.currentTimeMillis()-getWhen())+"ms]";
     }
diff --git a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
index 7a223026e..1807201a4 100644
--- a/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
+++ b/src/newt/classes/com/jogamp/newt/opengl/GLWindow.java
@@ -373,8 +373,8 @@ public class GLWindow extends Window implements GLAutoDrawable {
         window.sendEvent(e);
     }
 
-    public void addSurfaceUpdatedListener(SurfaceUpdatedListener l) {
-        window.addSurfaceUpdatedListener(l);
+    public void addSurfaceUpdatedListener(int index, SurfaceUpdatedListener l) {
+        window.addSurfaceUpdatedListener(index, l);
     }
     public void removeSurfaceUpdatedListener(SurfaceUpdatedListener l) {
         window.removeSurfaceUpdatedListener(l);
@@ -382,45 +382,51 @@ public class GLWindow extends Window implements GLAutoDrawable {
     public void removeAllSurfaceUpdatedListener() {
         window.removeAllSurfaceUpdatedListener();
     }
-    public SurfaceUpdatedListener[] getSurfaceUpdatedListener() {
-        return window.getSurfaceUpdatedListener();
+    public SurfaceUpdatedListener getSurfaceUpdatedListener(int index) {
+        return window.getSurfaceUpdatedListener(index);
+    }
+    public SurfaceUpdatedListener[] getSurfaceUpdatedListeners() {
+        return window.getSurfaceUpdatedListeners();
     }
     public void surfaceUpdated(Object updater, NativeWindow window0, long when) { 
         window.surfaceUpdated(updater, window, when);
     }
 
-    public void addMouseListener(MouseListener l) {
-        window.addMouseListener(l);
+    public void addMouseListener(int index, MouseListener l) {
+        window.addMouseListener(index, l);
     }
-
     public void removeMouseListener(MouseListener l) {
         window.removeMouseListener(l);
     }
-
+    public MouseListener getMouseListener(int index) {
+        return window.getMouseListener(index);
+    }
     public MouseListener[] getMouseListeners() {
         return window.getMouseListeners();
     }
 
-    public void addKeyListener(KeyListener l) {
-        window.addKeyListener(l);
+    public void addKeyListener(int index, KeyListener l) {
+        window.addKeyListener(index, l);
     }
-
     public void removeKeyListener(KeyListener l) {
         window.removeKeyListener(l);
     }
-
+    public KeyListener getKeyListener(int index) {
+        return window.getKeyListener(index);
+    }
     public KeyListener[] getKeyListeners() {
         return window.getKeyListeners();
     }
 
-    public void addWindowListener(WindowListener l) {
-        window.addWindowListener(l);
+    public void addWindowListener(int index, WindowListener l) {
+        window.addWindowListener(index, l);
     }
-
     public void removeWindowListener(WindowListener l) {
         window.removeWindowListener(l);
     }
-
+    public WindowListener getWindowListener(int index) {
+        return window.getWindowListener(index);
+    }
     public WindowListener[] getWindowListeners() {
         return window.getWindowListeners();
     }
@@ -473,6 +479,10 @@ public class GLWindow extends Window implements GLAutoDrawable {
         helper.addGLEventListener(listener);
     }
 
+    public void addGLEventListener(int index, GLEventListener listener) {
+        helper.addGLEventListener(index, listener);
+    }
+
     public void removeGLEventListener(GLEventListener listener) {
         helper.removeGLEventListener(listener);
     }