--- gvpe/src/callback.h	2005/03/03 16:54:34	1.5
+++ gvpe/src/callback.h	2006/01/14 11:21:12	1.9
@@ -1,13 +1,10 @@
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
-// THIS IS A GENERATED FILE, RUN callback.pl to regenerate it
+// THIS IS A GENERATED FILE: RUN callback.pl to regenerate it
+// THIS IS A GENERATED FILE: callback.pl is part of the GVPE
+// THIS IS A GENERATED FILE: distribution.
 
 /*
     callback.h -- C++ callback mechanism
-    Copyright (C) 2003-2005 Marc Lehmann <gvpe@schmorp.de>
+    Copyright (C) 2003-2006 Marc Lehmann <pcg@goof.com>
  
     This file is part of GVPE.
 
@@ -23,7 +20,7 @@
  
     You should have received a copy of the GNU General Public License
     along with gvpe; if not, write to the Free Software
-    Foundation, Inc. 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+    Foundation, Inc. 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
 #ifndef CALLBACK_H__
@@ -38,13 +35,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)()) = 0;
+    virtual R call (void *obj, R (object::*meth)()) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)())
+    virtual R call (void *obj, R (object::*meth)()) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)()>(meth)))
           ();
       }
   };
@@ -53,7 +50,7 @@
 
 public:
   template<class O1, class O2>
-  callback0 (O1 *object, R (O2::*method)())
+  explicit callback0 (O1 *object, R (O2::*method)())
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -81,13 +78,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1), A1 a1) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1), A1 a1)
+    virtual R call (void *obj, R (object::*meth)(A1), A1 a1) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1)>(meth)))
           (a1);
       }
   };
@@ -96,7 +93,7 @@
 
 public:
   template<class O1, class O2>
-  callback1 (O1 *object, R (O2::*method)(A1))
+  explicit callback1 (O1 *object, R (O2::*method)(A1))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -124,13 +121,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2)
+    virtual R call (void *obj, R (object::*meth)(A1, A2), A1 a1, A2 a2) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2)>(meth)))
           (a1, a2);
       }
   };
@@ -139,7 +136,7 @@
 
 public:
   template<class O1, class O2>
-  callback2 (O1 *object, R (O2::*method)(A1, A2))
+  explicit callback2 (O1 *object, R (O2::*method)(A1, A2))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -167,13 +164,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3)
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3), A1 a1, A2 a2, A3 a3) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3)>(meth)))
           (a1, a2, a3);
       }
   };
@@ -182,7 +179,7 @@
 
 public:
   template<class O1, class O2>
-  callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
+  explicit callback3 (O1 *object, R (O2::*method)(A1, A2, A3))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -210,13 +207,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4)
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4), A1 a1, A2 a2, A3 a3, A4 a4) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4)>(meth)))
           (a1, a2, a3, a4);
       }
   };
@@ -225,7 +222,7 @@
 
 public:
   template<class O1, class O2>
-  callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
+  explicit callback4 (O1 *object, R (O2::*method)(A1, A2, A3, A4))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -253,13 +250,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5)
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5)>(meth)))
           (a1, a2, a3, a4, a5);
       }
   };
@@ -268,7 +265,7 @@
 
 public:
   template<class O1, class O2>
-  callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
+  explicit callback5 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -296,13 +293,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6)
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6)>(meth)))
           (a1, a2, a3, a4, a5, a6);
       }
   };
@@ -311,7 +308,7 @@
 
 public:
   template<class O1, class O2>
-  callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
+  explicit callback6 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);
@@ -339,13 +336,13 @@
 
   /* a proxy is a kind of recipe on how to call a specific class method	*/
   struct proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) = 0;
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const = 0;
   };
   template<class O1, class O2>
   struct proxy : proxy_base {
-    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7)
+    virtual R call (void *obj, R (object::*meth)(A1, A2, A3, A4, A5, A6, A7), A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
       {
-        ((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
+        return (R)((reinterpret_cast<O1 *>(obj)) ->* (reinterpret_cast<R (O2::*)(A1, A2, A3, A4, A5, A6, A7)>(meth)))
           (a1, a2, a3, a4, a5, a6, a7);
       }
   };
@@ -354,7 +351,7 @@
 
 public:
   template<class O1, class O2>
-  callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
+  explicit callback7 (O1 *object, R (O2::*method)(A1, A2, A3, A4, A5, A6, A7))
     {
       static proxy<O1,O2> p;
       obj  = reinterpret_cast<void *>(object);