GlueGen JavaCallback: Add optional custom 'Callback-UserParamClass` for non-compound `UserParam` types to have more clarity in resulting API

7 files changed, 376 insertions, 336 deletions

diff --git a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java
index 05192d3..dbd38aa 100644
--- a/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java
+++ b/src/java/com/jogamp/gluegen/JavaCallbackEmitter.java
@@ -55,6 +55,7 @@ public final class JavaCallbackEmitter {
     final boolean userParamIsMappedToID;
     final String userParamIDMapInstanceName;
 
+    final String userParamClassName;
     final boolean customKeyClass;
     final String KeyClassName;
     final boolean useDataMap;
@@ -98,9 +99,17 @@ public final class JavaCallbackEmitter {
             userParamIDMapInstanceName = null;
         }
 
-        if( null != javaCallback.setFuncKeyClassName ) {
+        if( userParamIsCompound ) {
+            userParamClassName = setFuncUserParamTypeName;
+        } else if( null != javaCallback.userParamClassName ) {
+            userParamClassName = javaCallback.userParamClassName;
+        } else {
+            userParamClassName = "Object";
+        }
+
+        if( null != javaCallback.customKeyClassName ) {
             customKeyClass = true;;
-            KeyClassName = javaCallback.setFuncKeyClassName;
+            KeyClassName = javaCallback.customKeyClassName;
             useDataMap = true;
         } else {
             customKeyClass = false;
@@ -127,7 +136,7 @@ public final class JavaCallbackEmitter {
                 unit.emitln("  public "+info.cbFuncTypeName+" get"+capIfaceName+"("+KeyClassName+" key);");
                 unit.emitln();
                 emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for ");
-                unit.emitln("  public Object get"+capIfaceName+"UserParam("+KeyClassName+" key);");
+                unit.emitln("  public "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key);");
                 unit.emitln();
                 emitJavaBriefAPIDoc(unit, "Releases all callback data ", "mapped via ", "", "skipping toolkit API. Favor passing `null` callback ref to ");
                 unit.emitln("  public int releaseAll"+capIfaceName+"();");
@@ -143,7 +152,7 @@ public final class JavaCallbackEmitter {
                 unit.emitln("  public "+info.cbFuncTypeName+" get"+capIfaceName+"();");
                 unit.emitln();
                 emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for ");
-                unit.emitln("  public Object get"+capIfaceName+"UserParam();");
+                unit.emitln("  public "+userParamClassName+" get"+capIfaceName+"UserParam();");
                 unit.emitln();
                 emitJavaBriefAPIDoc(unit, "Releases callback data ", "", "", "skipping toolkit API. Favor passing `null` callback ref to ");
                 unit.emitln("  public void release"+capIfaceName+"();");
@@ -181,7 +190,7 @@ public final class JavaCallbackEmitter {
                 unit.emitln();
 
                 emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for ");
-                unit.emitln("  public final Object get"+capIfaceName+"UserParam("+KeyClassName+" key) {");
+                unit.emitln("  public final "+userParamClassName+" get"+capIfaceName+"UserParam("+KeyClassName+" key) {");
                 unit.emitln("    synchronized( "+lockInstanceName+" ) {");
                 unit.emitln("      final "+DataClassName+" value = "+dataMapInstanceName+".get(key);");
                 unit.emitln("      return null != value ? value.param : null;");
@@ -234,7 +243,7 @@ public final class JavaCallbackEmitter {
                 unit.emitln();
 
                 emitJavaBriefAPIDoc(unit, "Returns user-param ", "mapped to ", "", "for ");
-                unit.emitln("  public final Object get"+capIfaceName+"UserParam() {");
+                unit.emitln("  public final "+userParamClassName+" get"+capIfaceName+"UserParam() {");
                 unit.emitln("    synchronized( "+lockInstanceName+" ) {");
                 unit.emitln("      final "+DataClassName+" value = "+dataInstanceName+";");
                 unit.emitln("      return null != value ? value.param : null;");
@@ -524,12 +533,12 @@ public final class JavaCallbackEmitter {
             unit.emitln("    final "+origUserParamJType[0]+" "+info.cbFuncUserParamName+" = "+origUserParamJType[0]+".derefPointer(nativeUserParam);");
             useParamLocal[0] = true;
         } else if( userParamIsMappedToID && userParamIsKey ) {
-            unit.emitln("    final Object "+info.cbFuncUserParamName+";");
+            unit.emitln("    final "+userParamClassName+" "+info.cbFuncUserParamName+";");
         }
         unit.emitln("    final "+DataClassName+" value;");
         unit.emitln("    synchronized( "+lockInstanceName+" ) {");
         if( userParamIsMappedToID && userParamIsKey && !mapNativePtrToCompound[0] ) {
-            unit.emitln("      "+info.cbFuncUserParamName+" = "+userParamIDMapInstanceName+".get(nativeUserParam);");
+            unit.emitln("      "+info.cbFuncUserParamName+" = ("+userParamClassName+") "+userParamIDMapInstanceName+".get(nativeUserParam);");
             useParamLocal[0] = true;
         }
         if( useDataMap ) {
diff --git a/src/java/com/jogamp/gluegen/JavaConfiguration.java b/src/java/com/jogamp/gluegen/JavaConfiguration.java
index e530e0c..f5242b8 100644
--- a/src/java/com/jogamp/gluegen/JavaConfiguration.java
+++ b/src/java/com/jogamp/gluegen/JavaConfiguration.java
@@ -192,19 +192,23 @@ public class JavaConfiguration {
       final String setFuncName;
       final int setFuncUserParamIdx; // optional
       final List<Integer> cbFuncKeyIndices = new ArrayList<Integer>();
-      final String setFuncKeyClassName; // optional
+      final String userParamClassName; // optional
+      final String customKeyClassName; // optional
       final List<Integer> setFuncKeyIndices = new ArrayList<Integer>();
-      JavaCallbackDef(final String cbFuncTypeName, final int cbFuncUserParamIdx, final String setFuncName, final int setFuncUserParamIdx, final String setFuncKeyClassName) {
+      JavaCallbackDef(final String cbFuncTypeName, final int cbFuncUserParamIdx, final String setFuncName, final int setFuncUserParamIdx,
+                      final String userParamClassName, final String customKeyClassName) {
           this.cbFuncTypeName = cbFuncTypeName;
           this.cbFuncUserParamIdx = cbFuncUserParamIdx;
           this.setFuncName = setFuncName;
           this.setFuncUserParamIdx = setFuncUserParamIdx;
-          this.setFuncKeyClassName = setFuncKeyClassName;
+          this.userParamClassName = userParamClassName;
+          this.customKeyClassName = customKeyClassName;
       }
       @Override
       public String toString() {
-          return String.format("JavaCallbackDef[cbFunc[type %s, userParamIdx %d, keys %s], set[%s, keys %s, userParamIdx %d, KeyClass %s]]",
-                  cbFuncTypeName, cbFuncUserParamIdx, cbFuncKeyIndices.toString(), setFuncName, setFuncKeyIndices.toString(), setFuncUserParamIdx, setFuncKeyClassName);
+          return String.format("JavaCallbackDef[cbFunc[type %s, userParamIdx %d, keys %s], set[%s, keys %s, userParamIdx %d], Class[UserParam %s, Key %s]]",
+                  cbFuncTypeName, cbFuncUserParamIdx, cbFuncKeyIndices.toString(), setFuncName, setFuncKeyIndices.toString(), setFuncUserParamIdx,
+                  userParamClassName, customKeyClassName);
       }
     }
     private final List<JavaCallbackDef> javaCallbackList = new ArrayList<JavaCallbackDef>();
@@ -1696,13 +1700,26 @@ public class JavaConfiguration {
       final int setFuncUserParamIdx = Integer.parseInt(tok.nextToken());
       final String cbFuncTypeName = tok.nextToken();
       final int cbFuncUserParamIdx = Integer.parseInt(tok.nextToken());
-      final String cbFuncKeyClassName;
+      final String userParamClassName;
+      final String customKeyClassName;
       if( tok.hasMoreTokens() ) {
-          cbFuncKeyClassName = tok.nextToken();
+          final String s = tok.nextToken();
+          if( s.length() == 0 || s.equals("null") ) {
+              userParamClassName = null;
+          } else {
+              userParamClassName = s;
+          }
+          if( tok.hasMoreTokens() ) {
+              customKeyClassName = tok.nextToken();
+          } else {
+              customKeyClassName = null;
+          }
       } else {
-          cbFuncKeyClassName = null;
+          userParamClassName = null;
+          customKeyClassName = null;
       }
-      final JavaCallbackDef jcd = new JavaCallbackDef(cbFuncTypeName, cbFuncUserParamIdx, setFuncName, setFuncUserParamIdx, cbFuncKeyClassName);
+      final JavaCallbackDef jcd = new JavaCallbackDef(cbFuncTypeName, cbFuncUserParamIdx, setFuncName, setFuncUserParamIdx,
+                                                      userParamClassName, customKeyClassName);
       javaCallbackList.add(jcd);
       javaCallbackSetFuncToDef.put(setFuncName, jcd);
     } catch (final NoSuchElementException e) {
@@ -2408,15 +2425,17 @@ public class JavaConfiguration {
 
       final String setFuncName;
       final List<Integer> setFuncKeyIndices;
-      final String setFuncKeyClassName;
       final int setFuncUserParamIdx;
+      final String userParamClassName; // optional
+      final String customKeyClassName; // optional
       boolean setFuncProcessed;
       int setFuncCBParamIdx;
       boolean keyClassEmitted;
 
       public JavaCallbackInfo(final String cbFuncTypeName, final String cbSimpleClazzName, final String cbFQClazzName, final String staticCBMethodSignature,
                               final FunctionType cbFuncType, final MethodBinding cbFuncBinding, final int cbFuncUserParamIdx, final List<Integer> cbFuncKeyIndices,
-                              final String setFuncName, final int setFuncUserParamIdx, final List<Integer> setFuncKeyIndices, final String setFuncKeyClassName) {
+                              final String setFuncName, final int setFuncUserParamIdx, final List<Integer> setFuncKeyIndices,
+                              final String userParamClassName, final String customKeyClassName) {
           this.cbFuncTypeName = cbFuncTypeName;
           this.cbSimpleClazzName = cbSimpleClazzName;
           this.cbFQClazzName = cbFQClazzName;
@@ -2443,8 +2462,9 @@ public class JavaConfiguration {
           }
           this.setFuncName = setFuncName;
           this.setFuncKeyIndices = setFuncKeyIndices;
-          this.setFuncKeyClassName = setFuncKeyClassName;
           this.setFuncUserParamIdx = setFuncUserParamIdx;
+          this.userParamClassName = userParamClassName;
+          this.customKeyClassName = customKeyClassName;
           this.setFuncProcessed = false;
           this.setFuncCBParamIdx = -1;
           this.keyClassEmitted = false;
@@ -2479,11 +2499,11 @@ public class JavaConfiguration {
 
       @Override
       public String toString() {
-          return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s, KeyClass '%s'], %s]",
+          return String.format("JavaCallbackInfo[cbFunc[%s%s, userParam[idx %d, '%s', %s, keys %s], set[%s(ok %b, cbIdx %d, upIdx %d, keys %s], Class[UserParam '%s', Key '%s'], %s]",
                   cbFuncTypeName, staticCBMethodSignature,
                   cbFuncUserParamIdx, cbFuncUserParamName, cbFuncUserParamType.getSignature(null).toString(), cbFuncKeyIndices.toString(),
                   setFuncName, setFuncProcessed, setFuncCBParamIdx, setFuncUserParamIdx,
-                  setFuncKeyIndices.toString(), setFuncKeyClassName,
+                  setFuncKeyIndices.toString(), userParamClassName, customKeyClassName,
                   cbFuncType.toString(cbFuncTypeName, false, true));
       }
   }
diff --git a/src/java/com/jogamp/gluegen/JavaEmitter.java b/src/java/com/jogamp/gluegen/JavaEmitter.java
index 88cff27..576e9bc 100644
--- a/src/java/com/jogamp/gluegen/JavaEmitter.java
+++ b/src/java/com/jogamp/gluegen/JavaEmitter.java
@@ -1474,14 +1474,15 @@ public class JavaEmitter implements GlueEmitter {
           }
           final JavaCallbackInfo jcbi1 = new JavaCallbackInfo(jcbd.cbFuncTypeName, cbSimpleClazzName, cbFQClazzName, jcbi0.staticCBMethodSignature,
                                                               funcType, jcbi0.cbFuncBinding, jcbi0.cbFuncUserParamIdx, jcbd.cbFuncKeyIndices,
-                                                              jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, jcbd.setFuncKeyClassName);
+                                                              jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices,
+                                                              jcbd.userParamClassName, jcbd.customKeyClassName);
           cfg.setFuncToJavaCallbackMap.put(jcbd.setFuncName, jcbi1);
           LOG.log(INFO, "JavaCallbackInfo: Reusing {0} -> {1}", jcbd.setFuncName, jcbi0);
       } else {
           final StringBuilder cbMethodSignature = new StringBuilder();
           javaUnit.emitln("  /** JavaCallback interface: "+jcbd.cbFuncTypeName+" -> "+funcType.toString(jcbd.cbFuncTypeName, false, true)+" */");
           javaUnit.emitln("  public static interface "+cbSimpleClazzName+" {");
-          final List<MethodBinding> mbs = generateFunctionInterfaceCode(javaUnit, funcSym, jcbd.cbFuncUserParamIdx, cbMethodSignature);
+          final List<MethodBinding> mbs = generateFunctionInterfaceCode(javaUnit, funcSym, jcbd, cbMethodSignature);
           javaUnit.emitln("  }");
           javaUnit.emitln();
           if( 1 != mbs.size() ) {
@@ -1494,7 +1495,8 @@ public class JavaEmitter implements GlueEmitter {
           }
           final JavaCallbackInfo jcbi1 = new JavaCallbackInfo(jcbd.cbFuncTypeName, cbSimpleClazzName, cbFQClazzName, cbMethodSignature.toString(),
                                                               funcType, cbFuncBinding, jcbd.cbFuncUserParamIdx, jcbd.cbFuncKeyIndices,
-                                                              jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices, jcbd.setFuncKeyClassName);
+                                                              jcbd.setFuncName, jcbd.setFuncUserParamIdx, jcbd.setFuncKeyIndices,
+                                                              jcbd.userParamClassName, jcbd.customKeyClassName);
           cfg.setFuncToJavaCallbackMap.put(jcbd.setFuncName, jcbi1);
           javaCallbackInterfaceMap.put(cbFQClazzName, jcbi1);
           LOG.log(INFO, "JavaCallbackInfo: Added {0} -> {1}", jcbd.setFuncName, jcbi1);
@@ -1502,15 +1504,23 @@ public class JavaEmitter implements GlueEmitter {
   }
   private final Map<String, JavaCallbackInfo> javaCallbackInterfaceMap = new HashMap<String, JavaCallbackInfo>();
 
-  private List<MethodBinding> generateFunctionInterfaceCode(final JavaCodeUnit javaUnit, final FunctionSymbol funcSym, final int userParamIdx, final StringBuilder methodSignature)  {
+  private List<MethodBinding> generateFunctionInterfaceCode(final JavaCodeUnit javaUnit, final FunctionSymbol funcSym, final JavaCallbackDef jcbd, final StringBuilder methodSignature)  {
       // Emit method call and associated native code
       MethodBinding mb = bindFunction(funcSym, true  /* forInterface */, machDescJava, null, null);
 
       // Replace optional userParam argument 'void*' with Object
+      final int userParamIdx = jcbd.cbFuncUserParamIdx;
       if( 0 <= userParamIdx && userParamIdx < mb.getNumArguments() ) {
           final JavaType t = mb.getJavaArgumentType(userParamIdx);
           if ( t.isCVoidPointerType() ) {
-              mb = mb.replaceJavaArgumentType(userParamIdx, JavaType.forObjectClass());
+              final JavaType mappedType;
+              if( null != jcbd.userParamClassName ) {
+                  mappedType = JavaType.createForNamedClass( jcbd.userParamClassName );
+                  mb = mb.replaceJavaArgumentType(userParamIdx, JavaType.forObjectClass());
+              } else {
+                  mappedType = JavaType.forObjectClass();
+              }
+              mb = mb.replaceJavaArgumentType(userParamIdx, mappedType);
           }
       }
       // Produce the method signature
@@ -3124,6 +3134,8 @@ public class JavaEmitter implements GlueEmitter {
           if( cArgType.getTargetType().isVoid() ) {
               if( jcbi.cbFuncUserParamType.isCompound() ) {
                   mappedType = JavaType.createForClass(long.class);
+              } else if( null != jcbi.userParamClassName ) {
+                  mappedType = JavaType.createForNamedClass( jcbi.userParamClassName );
               } else {
                   mappedType = JavaType.forObjectClass();
               }
diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java b/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java
index 90e01df..09b51c7 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java
+++ b/src/junit/com/jogamp/gluegen/test/junit/generation/Test4JavaCallback.java
@@ -80,6 +80,27 @@ public class Test4JavaCallback extends BaseClass {
         dynamicLookupHelper = null;
     }
 
+    private static class MyUserParam01 {
+        final long i;
+        long j;
+        public MyUserParam01(final long i) { this.i = i; j=0; }
+
+        @Override
+        public boolean equals(final Object o) {
+            if( this == o ) {
+                return true;
+            }
+            if( !(o instanceof MyUserParam01) ) {
+                return false;
+            }
+            return false; // we require identity!
+        }
+        @Override
+        public int hashCode() {
+            return System.identityHashCode(this); // we require identity!
+        }
+    }
+
     /**
      * Test Bindingtest2 with T2_CallbackFunc JavaCallback
      */
@@ -169,17 +190,21 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(1+42+10+404+10, myUserParam01.j);
         }
     }
-    private static class MyUserParam01 {
+
+    public static class ALCcontext {
         final long i;
         long j;
-        public MyUserParam01(final long i) { this.i = i; j=0; }
+        int buffer;
+        boolean throwPreAction, throwPostAction;
+        public ALCcontext(final long i) { this.i = i; j=0; buffer=0; throwPreAction=false; throwPostAction=false; }
+        public ALCcontext() { this.i = 0; j=0; buffer=0; throwPreAction=false; throwPostAction=false; }
 
         @Override
         public boolean equals(final Object o) {
             if( this == o ) {
                 return true;
             }
-            if( !(o instanceof MyUserParam01) ) {
+            if( !(o instanceof ALCcontext) ) {
                 return false;
             }
             return false; // we require identity!
@@ -190,6 +215,7 @@ public class Test4JavaCallback extends BaseClass {
         }
     }
 
+
     /**
      * Test Bindingtest2 with ALBUFFERCALLBACKTYPESOFT JavaCallback via alBufferCallback1()
      * using the default AlBufferCallback1Key class.
@@ -201,23 +227,21 @@ public class Test4JavaCallback extends BaseClass {
         final long[] id_res = { -1 };
         final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                final long res = sampledata + numbytes + myUserParam.i;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                final long res = sampledata + numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;
-                myUserParam.buffer = buffer;
+                context.j = res;
+                context.buffer = buffer;
                 System.err.println("chapter02.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
             }
         };
         final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                final long res = sampledata * numbytes + myUserParam.i;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                final long res = sampledata * numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;
-                myUserParam.buffer = buffer;
+                context.j = res;
+                context.buffer = buffer;
                 System.err.println("chapter02.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
             }
         };
@@ -227,26 +251,26 @@ public class Test4JavaCallback extends BaseClass {
         final AlBufferCallback0Key buffer1Key = new AlBufferCallback0Key(buffer1);
         final AlBufferCallback0Key buffer2Key = new AlBufferCallback0Key(buffer2);
         final AlBufferCallback0Key buffer3Key = new AlBufferCallback0Key(buffer3);
-        final MyUserParam02 myUserParam01 = new MyUserParam02( 1);
-        final MyUserParam02 myUserParam02 = new MyUserParam02( 2);
-        Assert.assertEquals( 1, myUserParam01.i);
-        Assert.assertEquals( 0, myUserParam01.j);
-        Assert.assertEquals( 0, myUserParam01.buffer);
-        Assert.assertEquals( 2, myUserParam02.i);
-        Assert.assertEquals( 0, myUserParam02.j);
-        Assert.assertEquals( 0, myUserParam02.buffer);
+        final ALCcontext context01 = new ALCcontext( 1);
+        final ALCcontext context02 = new ALCcontext( 2);
+        Assert.assertEquals( 1, context01.i);
+        Assert.assertEquals( 0, context01.j);
+        Assert.assertEquals( 0, context01.buffer);
+        Assert.assertEquals( 2, context02.i);
+        Assert.assertEquals( 0, context02.j);
+        Assert.assertEquals( 0, context02.buffer);
 
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
         Assert.assertEquals(0,     bt2.getAlBufferCallback0Keys().size());
 
-        // 1st mapping: buffer1 -> myCallback01, myUserParam01
-        bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, myUserParam01);
+        // 1st mapping: buffer1 -> myCallback01, context01
+        bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, context01);
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
@@ -260,13 +284,13 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(false, keys.contains(buffer3Key));
         }
 
-        // 2nd mapping: buffer2 -> myCallback02, myUserParam02
-        bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, myUserParam02);
+        // 2nd mapping: buffer2 -> myCallback02, context02
+        bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, context02);
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
-        Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
         Assert.assertEquals(myCallback02,  bt2.getAlBufferCallback0(buffer2Key));
@@ -283,76 +307,76 @@ public class Test4JavaCallback extends BaseClass {
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01
+                    bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals(10+100+1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(       0, myUserParam02.j);
-            Assert.assertEquals(       0, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(       0, context02.j);
+            Assert.assertEquals(       0, context02.buffer);
         }
         {
-            bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02
+            bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02
             Assert.assertEquals(10*100+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
-        // Switch the callback function for buffer2 -> myCallback01, myUserParam02
-        bt2.alBufferCallback0(buffer2, 0, 0, myCallback01, myUserParam02);
+        // Switch the callback function for buffer2 -> myCallback01, context02
+        bt2.alBufferCallback0(buffer2, 0, 0, myCallback01, context02);
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
-        Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0(buffer3Key));
 
         {
-            bt2.alBufferCallback0Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01
+            bt2.alBufferCallback0Inject(buffer1, 11, 101); // buffer1 -> myCallback01, context01
             Assert.assertEquals(11+101+1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(11+101+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(11+101+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
         {
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback0Inject(buffer2,  1,  10); // buffer2 -> myCallback01, myUserParam02
+                    bt2.alBufferCallback0Inject(buffer2,  1,  10); // buffer2 -> myCallback01, context02
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals( 1+ 10+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(11+101+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals( 1+ 10+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(11+101+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals( 1+ 10+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
         // Just release the buffer2 callback and mapped resources
-        bt2.alBufferCallback0(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key!
+        bt2.alBufferCallback0(buffer2, 0, 0, null, context02); // usrptr is not key, only buffer is key!
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
@@ -366,13 +390,13 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(false, keys.contains(buffer3Key));
         }
 
-        // Switch the callback function for buffer2 -> myCallback01, myUserParam02
+        // Switch the callback function for buffer2 -> myCallback01, context02
         {
             // pre-condition
             Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
             Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
             Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-            Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+            Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
             Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
             Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
             Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
@@ -380,13 +404,13 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(null,          bt2.getAlBufferCallback0(buffer3Key));
             Assert.assertEquals(1,             bt2.getAlBufferCallback0Keys().size());
         }
-        bt2.alBufferCallback0(buffer1, 0, 0, myCallback02, myUserParam02);
+        bt2.alBufferCallback0(buffer1, 0, 0, myCallback02, context02);
         {
             // post-state
             Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
             Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
             Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-            Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer1Key));
+            Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer1Key));
             Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
             Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
             Assert.assertEquals(myCallback02,  bt2.getAlBufferCallback0(buffer1Key));
@@ -394,18 +418,18 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(null,          bt2.getAlBufferCallback0(buffer3Key));
         }
         {
-            myUserParam01.j = 0;
-            myUserParam01.buffer = 0;
-            myUserParam02.j = 0;
-            myUserParam02.buffer = 0;
-            bt2.alBufferCallback0Inject(buffer1, 2, 10); // buffer1 -> myCallback01, myUserParam01
+            context01.j = 0;
+            context01.buffer = 0;
+            context02.j = 0;
+            context02.buffer = 0;
+            bt2.alBufferCallback0Inject(buffer1, 2, 10); // buffer1 -> myCallback01, context01
             Assert.assertEquals(  2*10+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(       0, myUserParam01.j);
-            Assert.assertEquals(       0, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(  2*10+2, myUserParam02.j);
-            Assert.assertEquals(       1, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(       0, context01.j);
+            Assert.assertEquals(       0, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(  2*10+2, context02.j);
+            Assert.assertEquals(       1, context02.buffer);
         }
 
         // Just release the buffer1 callback and mapped resources
@@ -429,18 +453,18 @@ public class Test4JavaCallback extends BaseClass {
 
         {
             id_res[0] = 0;
-            myUserParam01.j = 0;
-            myUserParam01.buffer = 0;
-            myUserParam02.j = 0;
-            myUserParam02.buffer = 0;
+            context01.j = 0;
+            context01.buffer = 0;
+            context02.j = 0;
+            context02.buffer = 0;
             bt2.alBufferCallback0Inject(buffer2,  1,  10); // unmapped, no change in data
             Assert.assertEquals(       0, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(       0, myUserParam01.j);
-            Assert.assertEquals(       0, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(       0, myUserParam02.j);
-            Assert.assertEquals(       0, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(       0, context01.j);
+            Assert.assertEquals(       0, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(       0, context02.j);
+            Assert.assertEquals(       0, context02.buffer);
         }
     }
 
@@ -455,23 +479,21 @@ public class Test4JavaCallback extends BaseClass {
         final long[] id_res = { -1 };
         final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                final long res = sampledata + numbytes + myUserParam.i;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                final long res = sampledata + numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;;
-                myUserParam.buffer = buffer;
+                context.j = res;;
+                context.buffer = buffer;
                 System.err.println("chapter03.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
             }
         };
         final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                final long res = sampledata * numbytes + myUserParam.i;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                final long res = sampledata * numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;
-                myUserParam.buffer = buffer;
+                context.j = res;
+                context.buffer = buffer;
                 System.err.println("chapter03.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
             }
         };
@@ -481,26 +503,26 @@ public class Test4JavaCallback extends BaseClass {
         final CustomAlBufferCallback1Key buffer1Key = new CustomAlBufferCallback1Key(buffer1);
         final CustomAlBufferCallback1Key buffer2Key = new CustomAlBufferCallback1Key(buffer2);
         final CustomAlBufferCallback1Key buffer3Key = new CustomAlBufferCallback1Key(buffer3);
-        final MyUserParam02 myUserParam01 = new MyUserParam02( 1);
-        final MyUserParam02 myUserParam02 = new MyUserParam02( 2);
-        Assert.assertEquals( 1, myUserParam01.i);
-        Assert.assertEquals( 0, myUserParam01.j);
-        Assert.assertEquals( 0, myUserParam01.buffer);
-        Assert.assertEquals( 2, myUserParam02.i);
-        Assert.assertEquals( 0, myUserParam02.j);
-        Assert.assertEquals( 0, myUserParam02.buffer);
+        final ALCcontext context01 = new ALCcontext( 1);
+        final ALCcontext context02 = new ALCcontext( 2);
+        Assert.assertEquals( 1, context01.i);
+        Assert.assertEquals( 0, context01.j);
+        Assert.assertEquals( 0, context01.buffer);
+        Assert.assertEquals( 2, context02.i);
+        Assert.assertEquals( 0, context02.j);
+        Assert.assertEquals( 0, context02.buffer);
 
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key));
         Assert.assertEquals(0,     bt2.getAlBufferCallback1Keys().size());
 
-        // 1st mapping: buffer1 -> myCallback01, myUserParam01
-        bt2.alBufferCallback1(myUserParam01, buffer1, 0, 0, myCallback01);
+        // 1st mapping: buffer1 -> myCallback01, context01
+        bt2.alBufferCallback1(context01, buffer1, 0, 0, myCallback01);
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback1(buffer1Key));
@@ -514,13 +536,13 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(false, keys.contains(buffer3Key));
         }
 
-        // 2nd mapping: buffer2 -> myCallback02, myUserParam02
-        bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, myCallback02);
+        // 2nd mapping: buffer2 -> myCallback02, context02
+        bt2.alBufferCallback1(context02, buffer2, 0, 0, myCallback02);
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer1Key));
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key));
-        Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key));
+        Assert.assertEquals(context02, bt2.getAlBufferCallback1UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback1(buffer1Key));
         Assert.assertEquals(myCallback02,  bt2.getAlBufferCallback1(buffer2Key));
@@ -534,40 +556,40 @@ public class Test4JavaCallback extends BaseClass {
         }
 
         {
-            bt2.alBufferCallback1Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01
+            bt2.alBufferCallback1Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01
             Assert.assertEquals(10+100+1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(       0, myUserParam02.j);
-            Assert.assertEquals(       0, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(       0, context02.j);
+            Assert.assertEquals(       0, context02.buffer);
         }
         {
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback1Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02
+                    bt2.alBufferCallback1Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals(10*100+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
-        // Switch the callback function for buffer2 -> myCallback01, myUserParam02
-        bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, myCallback01);
+        // Switch the callback function for buffer2 -> myCallback01, context02
+        bt2.alBufferCallback1(context02, buffer2, 0, 0, myCallback01);
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer1Key));
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key));
-        Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback1UserParam(buffer2Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key));
+        Assert.assertEquals(context02, bt2.getAlBufferCallback1UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback1(buffer1Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback1(buffer2Key));
@@ -577,36 +599,36 @@ public class Test4JavaCallback extends BaseClass {
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback1Inject(buffer1, 11, 101); // buffer1 -> myCallback01, myUserParam01
+                    bt2.alBufferCallback1Inject(buffer1, 11, 101); // buffer1 -> myCallback01, context01
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals(11+101+1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(11+101+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(11+101+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
         {
-            bt2.alBufferCallback1Inject(buffer2,  1,  10); // buffer2 -> myCallback01, myUserParam02
+            bt2.alBufferCallback1Inject(buffer2,  1,  10); // buffer2 -> myCallback01, context02
             Assert.assertEquals( 1+ 10+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(11+101+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals( 1+ 10+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(11+101+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals( 1+ 10+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
         // Just release the buffer2 callback and mapped resources
-        bt2.alBufferCallback1(myUserParam02, buffer2, 0, 0, null); // usrptr is not key, only buffer is key!
+        bt2.alBufferCallback1(context02, buffer2, 0, 0, null); // usrptr is not key, only buffer is key!
         Assert.assertEquals(true,  bt2.isAlBufferCallback1Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback1Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback1UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback1UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback1UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback1(buffer1Key));
@@ -642,34 +664,12 @@ public class Test4JavaCallback extends BaseClass {
         {
             bt2.alBufferCallback1Inject(buffer2,  1,  10); // unmapped, no change in data
             Assert.assertEquals( 1+ 10+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(11+101+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals( 1+ 10+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
-        }
-    }
-    private static class MyUserParam02 {
-        final long i;
-        long j;
-        int buffer;
-        boolean throwPreAction, throwPostAction;
-        public MyUserParam02(final long i) { this.i = i; j=0; buffer=0; throwPreAction=false; throwPostAction=false; }
-
-        @Override
-        public boolean equals(final Object o) {
-            if( this == o ) {
-                return true;
-            }
-            if( !(o instanceof MyUserParam02) ) {
-                return false;
-            }
-            return false; // we require identity!
-        }
-        @Override
-        public int hashCode() {
-            return System.identityHashCode(this); // we require identity!
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(11+101+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals( 1+ 10+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
     }
 
@@ -684,38 +684,36 @@ public class Test4JavaCallback extends BaseClass {
         final long[] id_res = { -1 };
         final ALBUFFERCALLBACKTYPESOFT myCallback01 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                if( myUserParam.throwPreAction ) {
-                    myUserParam.throwPreAction = false;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                if( context.throwPreAction ) {
+                    context.throwPreAction = false;
                     throw new RuntimeException("Exception test.pre: chapter04.myCallback01");
                 }
-                final long res = sampledata + numbytes + myUserParam.i;
+                final long res = sampledata + numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;
-                myUserParam.buffer = buffer;
+                context.j = res;
+                context.buffer = buffer;
                 System.err.println("chapter04.myCallback01: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
-                if( myUserParam.throwPostAction ) {
-                    myUserParam.throwPostAction = false;
+                if( context.throwPostAction ) {
+                    context.throwPostAction = false;
                     throw new RuntimeException("Exception test.post: chapter04.myCallback01");
                 }
             }
         };
         final ALBUFFERCALLBACKTYPESOFT myCallback02 = new ALBUFFERCALLBACKTYPESOFT() {
             @Override
-            public void callback(final int buffer, final Object userptr, final int sampledata, final int numbytes) {
-                final MyUserParam02 myUserParam = (MyUserParam02)userptr;
-                if( myUserParam.throwPreAction ) {
-                    myUserParam.throwPreAction = false;
+            public void callback(final int buffer, final ALCcontext context, final int sampledata, final int numbytes) {
+                if( context.throwPreAction ) {
+                    context.throwPreAction = false;
                     throw new RuntimeException("Exception test.pre: chapter04.myCallback02");
                 }
-                final long res = sampledata * numbytes + myUserParam.i;
+                final long res = sampledata * numbytes + context.i;
                 id_res[0] = res;
-                myUserParam.j = res;
-                myUserParam.buffer = buffer;
+                context.j = res;
+                context.buffer = buffer;
                 System.err.println("chapter04.myCallback02: buffer "+buffer+", sampledata "+sampledata+", numbytes "+numbytes);
-                if( myUserParam.throwPostAction ) {
-                    myUserParam.throwPostAction = false;
+                if( context.throwPostAction ) {
+                    context.throwPostAction = false;
                     throw new RuntimeException("Exception test.post: chapter04.myCallback02");
                 }
             }
@@ -726,26 +724,26 @@ public class Test4JavaCallback extends BaseClass {
         final AlBufferCallback0Key buffer1Key = new AlBufferCallback0Key(buffer1);
         final AlBufferCallback0Key buffer2Key = new AlBufferCallback0Key(buffer2);
         final AlBufferCallback0Key buffer3Key = new AlBufferCallback0Key(buffer3);
-        final MyUserParam02 myUserParam01 = new MyUserParam02( 1);
-        final MyUserParam02 myUserParam02 = new MyUserParam02( 2);
-        Assert.assertEquals( 1, myUserParam01.i);
-        Assert.assertEquals( 0, myUserParam01.j);
-        Assert.assertEquals( 0, myUserParam01.buffer);
-        Assert.assertEquals( 2, myUserParam02.i);
-        Assert.assertEquals( 0, myUserParam02.j);
-        Assert.assertEquals( 0, myUserParam02.buffer);
+        final ALCcontext context01 = new ALCcontext( 1);
+        final ALCcontext context02 = new ALCcontext( 2);
+        Assert.assertEquals( 1, context01.i);
+        Assert.assertEquals( 0, context01.j);
+        Assert.assertEquals( 0, context01.buffer);
+        Assert.assertEquals( 2, context02.i);
+        Assert.assertEquals( 0, context02.j);
+        Assert.assertEquals( 0, context02.buffer);
 
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
         Assert.assertEquals(0,     bt2.getAlBufferCallback0Keys().size());
 
-        // 1st mapping: buffer1 -> myCallback01, myUserParam01
-        bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, myUserParam01);
+        // 1st mapping: buffer1 -> myCallback01, context01
+        bt2.alBufferCallback0(buffer1, 0, 0, myCallback01, context01);
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
@@ -759,13 +757,13 @@ public class Test4JavaCallback extends BaseClass {
             Assert.assertEquals(false, keys.contains(buffer3Key));
         }
 
-        // 2nd mapping: buffer2 -> myCallback02, myUserParam02
-        bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, myUserParam02);
+        // 2nd mapping: buffer2 -> myCallback02, context02
+        bt2.alBufferCallback0(buffer2, 0, 0, myCallback02, context02);
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
-        Assert.assertEquals(myUserParam02, bt2.getAlBufferCallback0UserParam(buffer2Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context02, bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
         Assert.assertEquals(myCallback02,  bt2.getAlBufferCallback0(buffer2Key));
@@ -782,75 +780,75 @@ public class Test4JavaCallback extends BaseClass {
         // Continuous program flow
         id_res[0] = -1;
         {
-            myUserParam01.throwPostAction = true;
-            bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, myUserParam01
+            context01.throwPostAction = true;
+            bt2.alBufferCallback0Inject(buffer1, 10, 100); // buffer1 -> myCallback01, context01
             Assert.assertEquals(10+100+1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(       0, myUserParam02.j);
-            Assert.assertEquals(       0, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(       0, context02.j);
+            Assert.assertEquals(       0, context02.buffer);
         }
         {
-            myUserParam02.throwPostAction = true;
+            context02.throwPostAction = true;
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, myUserParam02
+                    bt2.alBufferCallback0Inject(buffer2, 10, 100); // buffer2 -> myCallback02, context02
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals(10*100+2, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
         // Exception text pre action, i.e. result NOT as expected (unchanged)
         // Continuous program flow
         id_res[0] = -1;
         {
-            myUserParam01.throwPreAction = true;
-            bt2.alBufferCallback0Inject(buffer1, 20, 200); // buffer1 -> myCallback01, myUserParam01
+            context01.throwPreAction = true;
+            bt2.alBufferCallback0Inject(buffer1, 20, 200); // buffer1 -> myCallback01, context01
             Assert.assertEquals(      -1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
         {
-            myUserParam02.throwPreAction = true;
+            context02.throwPreAction = true;
             final Thread thread = new Thread(new Runnable() {
                 @Override
                 public void run() {
-                    bt2.alBufferCallback0Inject(buffer2, 20, 200); // buffer2 -> myCallback02, myUserParam02
+                    bt2.alBufferCallback0Inject(buffer2, 20, 200); // buffer2 -> myCallback02, context02
                 }
             });
             thread.start();
             thread.join();
             Assert.assertEquals(      -1, id_res[0]);
-            Assert.assertEquals(       1, myUserParam01.i);
-            Assert.assertEquals(10+100+1, myUserParam01.j);
-            Assert.assertEquals(       1, myUserParam01.buffer);
-            Assert.assertEquals(       2, myUserParam02.i);
-            Assert.assertEquals(10*100+2, myUserParam02.j);
-            Assert.assertEquals(       2, myUserParam02.buffer);
+            Assert.assertEquals(       1, context01.i);
+            Assert.assertEquals(10+100+1, context01.j);
+            Assert.assertEquals(       1, context01.buffer);
+            Assert.assertEquals(       2, context02.i);
+            Assert.assertEquals(10*100+2, context02.j);
+            Assert.assertEquals(       2, context02.buffer);
         }
 
         // Just release the buffer2 callback and mapped resources
         bt2.releaseAlBufferCallback0(buffer2Key);
-        // bt2.alBufferCallback0(buffer2, 0, 0, null, myUserParam02); // usrptr is not key, only buffer is key!
+        // bt2.alBufferCallback0(buffer2, 0, 0, null, context02); // usrptr is not key, only buffer is key!
         Assert.assertEquals(true,  bt2.isAlBufferCallback0Mapped(buffer1Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer2Key));
         Assert.assertEquals(false, bt2.isAlBufferCallback0Mapped(buffer3Key));
-        Assert.assertEquals(myUserParam01, bt2.getAlBufferCallback0UserParam(buffer1Key));
+        Assert.assertEquals(context01, bt2.getAlBufferCallback0UserParam(buffer1Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer2Key));
         Assert.assertEquals(null,          bt2.getAlBufferCallback0UserParam(buffer3Key));
         Assert.assertEquals(myCallback01,  bt2.getAlBufferCallback0(buffer1Key));
@@ -897,12 +895,12 @@ public class Test4JavaCallback extends BaseClass {
         id_res[0] = -1;
         bt2.alBufferCallback0Inject(buffer2,  1,  10);
         Assert.assertEquals(      -1, id_res[0]);
-        Assert.assertEquals(       1, myUserParam01.i);
-        Assert.assertEquals(10+100+1, myUserParam01.j);
-        Assert.assertEquals(       1, myUserParam01.buffer);
-        Assert.assertEquals(       2, myUserParam02.i);
-        Assert.assertEquals(10*100+2, myUserParam02.j);
-        Assert.assertEquals(       2, myUserParam02.buffer);
+        Assert.assertEquals(       1, context01.i);
+        Assert.assertEquals(10+100+1, context01.j);
+        Assert.assertEquals(       1, context01.buffer);
+        Assert.assertEquals(       2, context02.i);
+        Assert.assertEquals(10*100+2, context02.j);
+        Assert.assertEquals(       2, context02.buffer);
     }
 
     public static class CustomAlBufferCallback1Key {
@@ -943,30 +941,30 @@ public class Test4JavaCallback extends BaseClass {
         final String[] msg_res = { null };
         final ALEVENTPROCSOFT myCallback01 = new ALEVENTPROCSOFT() {
             @Override
-            public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) {
+            public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) {
                 id_res[0] = object;
                 msg_res[0] = message;
                 System.err.println("chapter05a.myCallback01: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+
-                        Integer.toHexString(System.identityHashCode(userParam)));
+                        Integer.toHexString(System.identityHashCode(context)));
             }
         };
         final ALEVENTPROCSOFT myCallback02 = new ALEVENTPROCSOFT() {
             @Override
-            public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) {
+            public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) {
                 id_res[0] = 1000 * object;
                 msg_res[0] = message;
                 System.err.println("chapter05a.myCallback02: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+
-                        Integer.toHexString(System.identityHashCode(userParam)));
+                        Integer.toHexString(System.identityHashCode(context)));
             }
         };
-        final Object myUserParam01 = new Object();
-        final Object myUserParam02 = new Object();
-        final AlEventCallback0Key myKey01 = new AlEventCallback0Key(myUserParam01);
-        final AlEventCallback0Key myKey02 = new AlEventCallback0Key(myUserParam02);
+        final ALCcontext context01 = new ALCcontext();
+        final ALCcontext context02 = new ALCcontext();
+        final AlEventCallback0Key myKey01 = new AlEventCallback0Key(context01);
+        final AlEventCallback0Key myKey02 = new AlEventCallback0Key(context02);
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02));
 
-        bt2.alEventCallback0(myCallback01, myUserParam01);
+        bt2.alEventCallback0(myCallback01, context01);
         Assert.assertEquals(true,  bt2.isAlEventCallback0Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02));
         {
@@ -984,7 +982,7 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo1 = "First message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback0Inject(myUserParam01, 0, 1, 0, msgNo1);
+            bt2.alEventCallback0Inject(context01, 0, 1, 0, msgNo1);
             Assert.assertEquals(     1, id_res[0]);
             Assert.assertEquals(msgNo1, msg_res[0]);
         }
@@ -992,19 +990,19 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo2 = "Second message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback0Inject(myUserParam02, 0, 2, 0, msgNo2);
+            bt2.alEventCallback0Inject(context02, 0, 2, 0, msgNo2);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback0Inject(myUserParam01, 0, 2, 0, msgNo2);
+            bt2.alEventCallback0Inject(context01, 0, 2, 0, msgNo2);
             Assert.assertEquals(     2, id_res[0]);
             Assert.assertEquals(  msgNo2, msg_res[0]);
         }
 
         // Switch the callback function
-        // The previously mapped myCallback01 (myUserParam01) gets released
-        // and remapped to myCallback02 + ( myUserParam01 )(key)
-        bt2.alEventCallback0(myCallback02, myUserParam01);
+        // The previously mapped myCallback01 (context01) gets released
+        // and remapped to myCallback02 + ( context01 )(key)
+        bt2.alEventCallback0(myCallback02, context01);
         Assert.assertEquals(true,  bt2.isAlEventCallback0Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02));
         {
@@ -1020,22 +1018,22 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo3 = "Third message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback0Inject(myUserParam02, 0, 3, 0, msgNo3);
+            bt2.alEventCallback0Inject(context02, 0, 3, 0, msgNo3);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback0Inject(myUserParam01, 0, 3, 0, msgNo3);
+            bt2.alEventCallback0Inject(context01, 0, 3, 0, msgNo3);
             Assert.assertEquals(    3000, id_res[0]);
             Assert.assertEquals(  msgNo3, msg_res[0]);
         }
 
         // Fake release (wrong key)
-        bt2.alEventCallback0(null, myUserParam02);
+        bt2.alEventCallback0(null, context02);
         Assert.assertEquals(true,  bt2.isAlEventCallback0Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02));
 
-        // Just release the callback and mapped myUserParam01
-        bt2.alEventCallback0(null, myUserParam01);
+        // Just release the callback and mapped context01
+        bt2.alEventCallback0(null, context01);
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback0Mapped(myKey02));
         Assert.assertEquals(0, bt2.getAlEventCallback0Keys().size());
@@ -1044,11 +1042,11 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo4 = "Forth message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback0Inject(myUserParam01, 0, 4, 0, msgNo4);
+            bt2.alEventCallback0Inject(context01, 0, 4, 0, msgNo4);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback0Inject(myUserParam02, 0, 4, 0, msgNo4);
+            bt2.alEventCallback0Inject(context02, 0, 4, 0, msgNo4);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
         }
@@ -1066,30 +1064,30 @@ public class Test4JavaCallback extends BaseClass {
         final String[] msg_res = { null };
         final ALEVENTPROCSOFT myCallback01 = new ALEVENTPROCSOFT() {
             @Override
-            public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) {
+            public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) {
                 id_res[0] = object;
                 msg_res[0] = message;
                 System.err.println("chapter05.myCallback01: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+
-                        Integer.toHexString(System.identityHashCode(userParam)));
+                        Integer.toHexString(System.identityHashCode(context)));
             }
         };
         final ALEVENTPROCSOFT myCallback02 = new ALEVENTPROCSOFT() {
             @Override
-            public void callback(final int eventType, final int object, final int param, final int length, final String message, final Object userParam) {
+            public void callback(final int eventType, final int object, final int param, final int length, final String message, final ALCcontext context) {
                 id_res[0] = 1000 * object;
                 msg_res[0] = message;
                 System.err.println("chapter05.myCallback02: type "+eventType+", obj "+object+", param "+param+", '"+message+"', userParam 0x"+
-                        Integer.toHexString(System.identityHashCode(userParam)));
+                        Integer.toHexString(System.identityHashCode(context)));
             }
         };
-        final Object myUserParam01 = new Object();
-        final Object myUserParam02 = new Object();
-        final AlEventCallback1Key myKey01 = new AlEventCallback1Key(1, myUserParam01);
-        final AlEventCallback1Key myKey02 = new AlEventCallback1Key(2, myUserParam02);
+        final ALCcontext context01 = new ALCcontext();
+        final ALCcontext context02 = new ALCcontext();
+        final AlEventCallback1Key myKey01 = new AlEventCallback1Key(1, context01);
+        final AlEventCallback1Key myKey02 = new AlEventCallback1Key(2, context02);
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
 
-        bt2.alEventCallback1(1, myCallback01, myUserParam01);
+        bt2.alEventCallback1(1, myCallback01, context01);
         Assert.assertEquals(true,  bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
         {
@@ -1107,7 +1105,7 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo1 = "First message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo1);
+            bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo1);
             Assert.assertEquals(     1, id_res[0]);
             Assert.assertEquals(msgNo1, msg_res[0]);
         }
@@ -1115,23 +1113,23 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo2 = "Second message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback1Inject(myUserParam02, 0, 2, 0, msgNo2);
+            bt2.alEventCallback1Inject(context02, 0, 2, 0, msgNo2);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback1Inject(myUserParam01, 0, 2, 0, msgNo2);
+            bt2.alEventCallback1Inject(context01, 0, 2, 0, msgNo2);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo2);
+            bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo2);
             Assert.assertEquals(     1, id_res[0]);
             Assert.assertEquals(  msgNo2, msg_res[0]);
         }
 
         // Switch the callback function
-        // The previously mapped myCallback01 (1, myUserParam01) gets released
-        // and remapped to myCallback02 + ( 1, myUserParam01 )(key)
-        bt2.alEventCallback1(1, myCallback02, myUserParam01);
+        // The previously mapped myCallback01 (1, context01) gets released
+        // and remapped to myCallback02 + ( 1, context01 )(key)
+        bt2.alEventCallback1(1, myCallback02, context01);
         Assert.assertEquals(true,  bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
         {
@@ -1147,30 +1145,30 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo3 = "Third message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback1Inject(myUserParam02, 0, 2, 0, msgNo3);
+            bt2.alEventCallback1Inject(context02, 0, 2, 0, msgNo3);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback1Inject(myUserParam01, 0, 2, 0, msgNo3);
+            bt2.alEventCallback1Inject(context01, 0, 2, 0, msgNo3);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback1Inject(myUserParam01, 0, 1, 0, msgNo3);
+            bt2.alEventCallback1Inject(context01, 0, 1, 0, msgNo3);
             Assert.assertEquals(    1000, id_res[0]);
             Assert.assertEquals(  msgNo3, msg_res[0]);
         }
 
         // Fake release (wrong key)
-        bt2.alEventCallback1(2, null, myUserParam02);
+        bt2.alEventCallback1(2, null, context02);
         Assert.assertEquals(true,  bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
 
-        bt2.alEventCallback1(2, null, myUserParam01);
+        bt2.alEventCallback1(2, null, context01);
         Assert.assertEquals(true,  bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
 
-        // Just release the callback and mapped myUserParam01
-        bt2.alEventCallback1(1, null, myUserParam01);
+        // Just release the callback and mapped context01
+        bt2.alEventCallback1(1, null, context01);
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey01));
         Assert.assertEquals(false, bt2.isAlEventCallback1Mapped(myKey02));
         Assert.assertEquals(0, bt2.getAlEventCallback1Keys().size());
@@ -1179,11 +1177,11 @@ public class Test4JavaCallback extends BaseClass {
             final String msgNo4 = "Forth message";
             id_res[0] = -1;
             msg_res[0] = null;
-            bt2.alEventCallback1Inject(myUserParam01, 0, 4, 0, msgNo4);
+            bt2.alEventCallback1Inject(context01, 0, 4, 0, msgNo4);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
 
-            bt2.alEventCallback1Inject(myUserParam02, 0, 4, 0, msgNo4);
+            bt2.alEventCallback1Inject(context02, 0, 4, 0, msgNo4);
             Assert.assertEquals(    -1, id_res[0]);
             Assert.assertEquals(  null, msg_res[0]);
         }
diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub
index 28d46a6..2242d4c 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub
+++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaIfCode.java.stub
@@ -1,4 +1,4 @@
-  public void alEventCallback0Inject(Object userParam, int eventType, int object, int param, String message);
+  public void alEventCallback0Inject(ALCcontext userParam, int eventType, int object, int param, String message);
 
-  public void alEventCallback1Inject(Object userParam, int eventType, int object, int param, String message);
+  public void alEventCallback1Inject(ALCcontext userParam, int eventType, int object, int param, String message);
 
diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub
index 6643108..9d58e02 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub
+++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2-CustomJavaImplCode.java.stub
@@ -1,10 +1,10 @@
-  public void alEventCallback0Inject(Object userParam, int eventType, int object, int param, String message)  {
-    final Object userParam2;
+  public void alEventCallback0Inject(ALCcontext userParam, int eventType, int object, int param, String message)  {
+    final ALCcontext userParam2;
     final AlEventCallback0Data value;
     synchronized( alEventCallback0Lock ) {
       final AlEventCallback0Data value0 = alEventCallback0DataMap.get( new AlEventCallback0Key( userParam ) );
       if( null != value0 ) {
-        userParam2 = alEventCallback0UserObjIDMap.get(value0.paramID);
+        userParam2 = (ALCcontext) alEventCallback0UserObjIDMap.get(value0.paramID);
         if( userParam != userParam2 ) {
             throw new InternalError("Impl issue-1: Arg userParam "+userParam+" != "+userParam2);
         }
@@ -21,13 +21,13 @@
     value.func.callback(eventType, object, param, message.length(), message, userParam2);
   }
 
-  public void alEventCallback1Inject(Object userParam, int eventType, int object, int param, String message)  {
-    final Object userParam2;
+  public void alEventCallback1Inject(ALCcontext userParam, int eventType, int object, int param, String message)  {
+    final ALCcontext userParam2;
     final AlEventCallback1Data value;
     synchronized( alEventCallback1Lock ) {
       final AlEventCallback1Data value0 = alEventCallback1DataMap.get( new AlEventCallback1Key( object, userParam ) );
       if( null != value0 ) {
-        userParam2 = alEventCallback1UserObjIDMap.get(value0.paramID);
+        userParam2 = (ALCcontext) alEventCallback1UserObjIDMap.get(value0.paramID);
         if( userParam != userParam2 ) {
             throw new InternalError("Impl issue-1: Arg userParam "+userParam+" != "+userParam2);
         }
diff --git a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg
index 3a1c7b3..fdad264 100644
--- a/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg
+++ b/src/junit/com/jogamp/gluegen/test/junit/generation/test2.cfg
@@ -94,10 +94,10 @@ JavaCallbackDef  MessageCallback01 1 T2_CallbackFunc01 2
 #   - `Set<AlBufferCallback0Key> getAlBufferCallback0Keys()` returns set of Key { int buffer }
 #   - `boolean isAlBufferCallback0Mapped(AlBufferCallback0Key)` queries whether `alBufferCallback0` is mapped to `buffer`.
 #   - `ALBUFFERCALLBACKTYPESOFT getAlBufferCallback0(AlBufferCallback0Key)` returns the `buffer` mapped ALEVENTPROCSOFT, null if not mapped
-#   - `Object getAlBufferCallback0UserParam(AlBufferCallback0Key)` returns the `buffer` mapped `userptr` object, null if not mapped
+#   - `ALCcontext getAlBufferCallback0UserParam(AlBufferCallback0Key)` returns the `buffer` mapped `userptr` object, null if not mapped
 #   - `void releaseAllAlBufferCallback0()` releases all callback data mapped via Key { int buffer } skipping toolkit API. Favor passing `null` callback ref to `alBufferCallback0(..)`
 #   - `void releaseAlBufferCallback0(AlBufferCallback0Key)` releases callback data mapped to Key { int buffer } skipping toolkit API. Favor passing `null` callback ref to `alBufferCallback0(..)`
-JavaCallbackDef  alBufferCallback0 4 ALBUFFERCALLBACKTYPESOFT 1
+JavaCallbackDef  alBufferCallback0 4 ALBUFFERCALLBACKTYPESOFT 1 ALCcontext
 JavaCallbackKey  alBufferCallback0 0 ALBUFFERCALLBACKTYPESOFT 0
 #
 # End JavaCallback
@@ -126,8 +126,8 @@ JavaCallbackKey  alBufferCallback0 0 ALBUFFERCALLBACKTYPESOFT 0
 #   Explicit maintenance methods are generated, passing the keys as paramters
 #   - `boolean isAlBufferCallback1Mapped(int buffer)` queries whether `alBufferCallback1` is mapped to `buffer`.
 #   - `ALBUFFERCALLBACKTYPESOFT getAlBufferCallback1(int buffer)` returns the `buffer` mapped ALEVENTPROCSOFT, null if not mapped
-#   - `Object getAlBufferCallback1UserParam(int buffer)` returns the `buffer` mapped `userptr` object, null if not mapped
-JavaCallbackDef  alBufferCallback1 0 ALBUFFERCALLBACKTYPESOFT 1 com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomAlBufferCallback1Key
+#   - `ALCcontext getAlBufferCallback1UserParam(int buffer)` returns the `buffer` mapped `userptr` object, null if not mapped
+JavaCallbackDef  alBufferCallback1 0 ALBUFFERCALLBACKTYPESOFT 1 ALCcontext com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomAlBufferCallback1Key
 JavaCallbackKey  alBufferCallback1 1 ALBUFFERCALLBACKTYPESOFT 0
 #
 # End JavaCallback
@@ -146,7 +146,7 @@ ArgumentIsPascalString ALEVENTPROCSOFT 3 4
 #   and marks `ALEVENTPROCSOFT`s 6th argument (index 5) as the mandatory user-param.
 #
 #   This callback uses 'Object userParam' as its key (for a context), similar to `AL_SOFT_events` context binding.
-JavaCallbackDef  alEventCallback0 1 ALEVENTPROCSOFT 5
+JavaCallbackDef  alEventCallback0 1 ALEVENTPROCSOFT 5 ALCcontext
 JavaCallbackKey  alEventCallback0 1 ALEVENTPROCSOFT 5
 #
 # End JavaCallback
@@ -154,7 +154,7 @@ JavaCallbackKey  alEventCallback0 1 ALEVENTPROCSOFT 5
 # Begin JavaCallback.
 #
 # void alEventCallback1(int object /* key */, ALEVENTPROCSOFT callback, void *userParam /* key */);
-JavaCallbackDef  alEventCallback1 2 ALEVENTPROCSOFT 5
+JavaCallbackDef  alEventCallback1 2 ALEVENTPROCSOFT 5 ALCcontext
 JavaCallbackKey  alEventCallback1 0 2 ALEVENTPROCSOFT 1 5
 
 #
@@ -168,7 +168,7 @@ IncludeAs CustomJavaCode Bindingtest2Impl test2-CustomJavaImplCode.java.stub
 # typedef void ( * T2_CallbackFunc11)(size_t id, const T2_Callback11UserType* usrParam);
 # void MessageCallback11a(size_t id /* key */, T2_CallbackFunc11 cbFunc, const T2_Callback11UserType* usrParam);
 # void MessageCallback11aInject(size_t id);
-#JavaCallbackDef  MessageCallback11a T2_CallbackFunc11 1 com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomMessageCallback11Key
+#JavaCallbackDef  MessageCallback11a T2_CallbackFunc11 1 Object com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.CustomMessageCallback11Key
 JavaCallbackDef  MessageCallback11a 2 T2_CallbackFunc11 1
 JavaCallbackKey  MessageCallback11a 0 T2_CallbackFunc11 0
 #
@@ -187,6 +187,7 @@ Import com.jogamp.gluegen.test.junit.generation.T2_InitializeOptions
 Import com.jogamp.gluegen.test.junit.generation.T2_ThreadAffinity
 Import com.jogamp.gluegen.test.junit.generation.T2_UserData
 Import com.jogamp.gluegen.test.junit.generation.T2_Callback11UserType
+Import com.jogamp.gluegen.test.junit.generation.Test4JavaCallback.ALCcontext
 
 CustomJavaCode Bindingtest2Impl  private static Bindingtest2ProcAddressTable _table = new Bindingtest2ProcAddressTable();
 CustomJavaCode Bindingtest2Impl  public static void resetProcAddressTable(DynamicLookupHelper lookup) {