diff -Naur openvrml-0.14.3-a/src/libopenvrml/openvrml/ScriptJDK.cpp openvrml-0.14.3-b/src/libopenvrml/openvrml/ScriptJDK.cpp
--- src/libopenvrml/openvrml/ScriptJDK.cpp	2005-11-16 08:21:44.000000000 +0000
+++ src/libopenvrml/openvrml/ScriptJDK.cpp	2005-11-16 08:21:44.000000000 +0000
@@ -393,7 +393,7 @@
  */
 void ScriptJDK::initialize(const double timestamp)
 {
-  const sftime arg(timestamp);
+  const openvrml::sftime arg(timestamp);
   const field_value * argv[] = { &arg };
   this->activate(timestamp, "initialize", 1, argv);
 }
@@ -409,7 +409,7 @@
                               const field_value & value,
                               const double timestamp)
 {
-  const sftime timestampArg(timestamp);
+  const openvrml::sftime timestampArg(timestamp);
   const field_value * argv[] = { &value, &timestampArg };
   this->activate(timestamp, id, 2, argv);
 }
@@ -421,7 +421,7 @@
  */
 void ScriptJDK::events_processed(const double timestamp)
 {
-  const sftime arg(timestamp);
+  const openvrml::sftime arg(timestamp);
   const field_value * argv[] = { &arg };
   this->activate(timestamp, "eventsProcessed", 1, argv);
 }
@@ -434,7 +434,7 @@
  */
 void ScriptJDK::shutdown(const double timestamp)
 {
-  const sftime arg(timestamp);
+  const openvrml::sftime arg(timestamp);
   const field_value * argv[] = { &arg };
   this->activate(timestamp, "shutdown", 1, argv);
 }
@@ -507,45 +507,45 @@
     case field_value::invalid_type_id:
       return NULL;
     case field_value::sfbool_id:
-      return new sfbool;
+      return new openvrml::sfbool;
     case field_value::sfcolor_id:
-      return new sfcolor;
+      return new openvrml::sfcolor;
     case field_value::sffloat_id:
-      return new sffloat;
+      return new openvrml::sffloat;
     case field_value::sfimage_id:
       return new sfimage;
     case field_value::sfint32_id:
-      return new sfint32;
+      return new openvrml::sfint32;
     case field_value::sfnode_id:
       return new sfnode;
     case field_value::sfrotation_id:
-      return new sfrotation;
+      return new openvrml::sfrotation;
     case field_value::sfstring_id:
       return new sfstring;
     case field_value::sftime_id:
-      return new sftime;
+      return new openvrml::sftime;
     case field_value::sfvec2f_id:
-      return new sfvec2f;
+      return new openvrml::sfvec2f;
     case field_value::sfvec3f_id:
-      return new sfvec3f;
+      return new openvrml::sfvec3f;
     case field_value::mfcolor_id:
-      return new mfcolor;
+      return new openvrml::mfcolor;
     case field_value::mffloat_id:
-      return new mffloat;
+      return new openvrml::mffloat;
     case field_value::mfint32_id:
-      return new mfint32;
+      return new openvrml::mfint32;
     case field_value::mfnode_id:
-      return new mfnode;
+      return new openvrml::mfnode;
     case field_value::mfrotation_id:
-      return new mfrotation;
+      return new openvrml::mfrotation;
     case field_value::mfstring_id:
-      return new mfstring;
+      return new openvrml::mfstring;
     case field_value::mftime_id:
-      return new mftime;
+      return new openvrml::mftime;
     case field_value::mfvec2f_id:
-      return new mfvec2f;
+      return new openvrml::mfvec2f;
     case field_value::mfvec3f_id:
-      return new mfvec3f;
+      return new openvrml::mfvec3f;
     default:
       return NULL;
   }
@@ -620,7 +620,7 @@
     try {
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
-        std::auto_ptr<sfbool> sfbool(new sfbool(value));
+        std::auto_ptr<openvrml::sfbool> sfbool(new openvrml::sfbool(value));
         env->SetIntField(obj, fid, reinterpret_cast<int>(sfbool.release()));
     } catch (std::bad_alloc & ex) {
         env->ExceptionDescribe();
@@ -644,7 +644,7 @@
 jboolean JNICALL Java_vrml_field_ConstSFBool_getValue(JNIEnv * env,
                                                       jobject obj)
 {
-    sfbool * sfb = static_cast<sfbool *>(getFieldValue(env, obj));
+    openvrml::sfbool * sfb = static_cast<openvrml::sfbool *>(getFieldValue(env, obj));
     if (!sfb) { return false; }
     return sfb->value;
 }
@@ -699,7 +699,7 @@
                                                 jobject obj,
                                                 jboolean value)
 {
-    sfbool * sfb = static_cast<sfbool *>(getFieldValue(env, obj));
+    openvrml::sfbool * sfb = static_cast<openvrml::sfbool *>(getFieldValue(env, obj));
     if (!sfb) { return; }
     sfb->value = value;
 }
@@ -715,8 +715,8 @@
 Java_vrml_field_SFBool_setValue__Lvrml_field_ConstSFBool_2
   (JNIEnv *env, jobject obj, jobject value)
 {
-  sfbool* newsfbool = static_cast<sfbool*>(getFieldValue(env, value));
-  sfbool* sfb = static_cast<sfbool*>(getFieldValue(env, obj));
+  openvrml::sfbool* newsfbool = static_cast<openvrml::sfbool*>(getFieldValue(env, value));
+  openvrml::sfbool* sfb = static_cast<openvrml::sfbool*>(getFieldValue(env, obj));
   if (!newsfbool || !sfb) return;
   sfb->value = newsfbool->value;
 }
@@ -763,7 +763,7 @@
     try {
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
-        std::auto_ptr<sfcolor> sfcolor(new sfcolor(color(r, g, b)));
+        std::auto_ptr<openvrml::sfcolor> sfcolor(new openvrml::sfcolor(color(r, g, b)));
         env->SetIntField(obj, fid, reinterpret_cast<int>(sfcolor.release()));
     } catch (std::bad_alloc & ex) {
         env->ExceptionDescribe();
@@ -788,7 +788,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfcolor * sfc = static_cast<sfcolor*>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, obj));
     if (!sfc) { return; }
     env->SetFloatArrayRegion(jarr, 0, 3,
                              const_cast<float *>(&sfc->value[0]));
@@ -803,7 +803,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFColor_getRed(JNIEnv * env, jobject obj)
 {
-    sfcolor * sfc = static_cast<sfcolor *>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
     if (!sfc) { return 0.0; }
     return sfc->value.r();
 }
@@ -818,7 +818,7 @@
 jfloat JNICALL Java_vrml_field_ConstSFColor_getGreen(JNIEnv * env,
                                                      jobject obj)
 {
-    sfcolor * sfc = static_cast<sfcolor *>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
     if (!sfc) { return 0.0; }
     return sfc->value.g();
 }
@@ -832,7 +832,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFColor_getBlue(JNIEnv * env, jobject obj)
 {
-    sfcolor * sfc = static_cast<sfcolor *>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
     if (!sfc) { return 0.0; }
     return sfc->value.b();
 }
@@ -928,7 +928,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfcolor * sfc = static_cast<sfcolor *>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
     if (!sfc) { return; }
     jfloat * pjf = env->GetFloatArrayElements(jarr, NULL);
     sfc->value = color(pjf[0], pjf[1], pjf[2]);
@@ -947,7 +947,7 @@
 void JNICALL Java_vrml_field_SFColor_setValue__FFF
   (JNIEnv *env, jobject obj, jfloat r, jfloat g, jfloat b)
 {
-    sfcolor* sfc = static_cast<sfcolor*>(getFieldValue(env, obj));
+    openvrml::sfcolor* sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, obj));
     if (!sfc) { return; }
     sfc->value = color(r, g, b);
 }
@@ -963,8 +963,8 @@
 Java_vrml_field_SFColor_setValue__Lvrml_field_ConstSFColor_2
   (JNIEnv *env, jobject obj, jobject value)
 {
-    sfcolor* newSFColor = static_cast<sfcolor*>(getFieldValue(env, value));
-    sfcolor* sfc = static_cast<sfcolor*>(getFieldValue(env, obj));
+    openvrml::sfcolor* newSFColor = static_cast<openvrml::sfcolor*>(getFieldValue(env, value));
+    openvrml::sfcolor* sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, obj));
     if (!newSFColor || !sfc) return;
     sfc->value = newSFColor->value;
 }
@@ -1010,7 +1010,7 @@
     try {
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
-        std::auto_ptr<sffloat> sffloat(new sffloat(value));
+        std::auto_ptr<openvrml::sffloat> sffloat(new openvrml::sffloat(value));
         env->SetIntField(obj, fid, reinterpret_cast<int>(sffloat.release()));
     } catch (std::bad_alloc & ex) {
         env->ExceptionDescribe();
@@ -1034,7 +1034,7 @@
 jfloat JNICALL Java_vrml_field_ConstSFFloat_getValue(JNIEnv * env,
                                                      jobject obj)
 {
-    sffloat * sff = static_cast<sffloat *>(getFieldValue(env, obj));
+    openvrml::sffloat * sff = static_cast<openvrml::sffloat *>(getFieldValue(env, obj));
     if (!sff) { return 0.0; }
     return sff->value;
 }
@@ -1089,7 +1089,7 @@
                                                  jobject obj,
                                                  jfloat f)
 {
-    sffloat * sff = static_cast<sffloat *>(getFieldValue(env, obj));
+    openvrml::sffloat * sff = static_cast<openvrml::sffloat *>(getFieldValue(env, obj));
     if (!sff) { return; }
     sff->value = f;
 }
@@ -1105,8 +1105,8 @@
 Java_vrml_field_SFFloat_setValue__Lvrml_field_ConstSFFloat_2
   (JNIEnv *env, jobject obj, jobject value)
 {
-    sffloat* sff = static_cast<sffloat*>(getFieldValue(env, obj));
-    sffloat* newSFFloat = static_cast<sffloat*>(getFieldValue(env, value));
+    openvrml::sffloat* sff = static_cast<openvrml::sffloat*>(getFieldValue(env, obj));
+    openvrml::sffloat* newSFFloat = static_cast<openvrml::sffloat*>(getFieldValue(env, value));
     if (!sff || !newSFFloat) return;
     sff->value = newSFFloat->value;
 }
@@ -1404,7 +1404,7 @@
     try {
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
-        std::auto_ptr<sfint32> sfint32(new sfint32(value));
+        std::auto_ptr<openvrml::sfint32> sfint32(new openvrml::sfint32(value));
         env->SetIntField(obj, fid, reinterpret_cast<int>(sfint32.release()));
     } catch (std::bad_alloc & ex) {
         env->ExceptionDescribe();
@@ -1427,7 +1427,7 @@
  */
 jint JNICALL Java_vrml_field_ConstSFInt32_getValue(JNIEnv * env, jobject obj)
 {
-    sfint32 * sfi = static_cast<sfint32*>(getFieldValue(env, obj));
+    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, obj));
     if (!sfi) { return 0; }
     return jint(sfi->value);
 }
@@ -1475,7 +1475,7 @@
                                                  jobject obj,
                                                  jint value)
 {
-    sfint32 * sfi = static_cast<sfint32*>(getFieldValue(env, obj));
+    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, obj));
     if (!sfi) { return; }
     sfi->value = value;
 }
@@ -1492,8 +1492,8 @@
                                                              jobject obj,
                                                              jobject value)
 {
-    sfint32* sfi = static_cast<sfint32*>(getFieldValue(env, obj));
-    sfint32* newSFInt32 = static_cast<sfint32*>(getFieldValue(env, value));
+    openvrml::sfint32* sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, obj));
+    openvrml::sfint32* newSFInt32 = static_cast<openvrml::sfint32*>(getFieldValue(env, value));
     if (!sfi || !newSFInt32) return;
     sfi->value = newSFInt32->value;
 }
@@ -1694,7 +1694,7 @@
    jfloat axisZ, jfloat angle)
 {
     try {
-        std::auto_ptr<sfrotation> sfrotation(new sfrotation(rotation(axisX,
+        std::auto_ptr<openvrml::sfrotation> sfrotation(new openvrml::sfrotation(rotation(axisX,
                                                                      axisY,
                                                                      axisZ,
                                                                      angle)));
@@ -1717,7 +1717,7 @@
                                                       jobject obj,
                                                       jfloatArray jarr)
 {
-    sfrotation * sfr = static_cast<sfrotation*>(getFieldValue(env, obj));
+    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
     if (!sfr) { return; }
     env->SetFloatArrayRegion(jarr, 0, 4,
                              const_cast<float *>(&sfr->value[0]));
@@ -1761,7 +1761,7 @@
                                                       jobject obj,
                                                       jfloatArray jarr)
 {
-    sfrotation * sfr = static_cast<sfrotation*>(getFieldValue(env, obj));
+    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
     if (!sfr) { return; }
     jfloat * pjf = env->GetFloatArrayElements(jarr, NULL);
     sfr->value = rotation(pjf[0], pjf[1], pjf[2], pjf[3]);
@@ -1785,7 +1785,7 @@
                                                        jfloat axisZ,
                                                        jfloat angle)
 {
-    sfrotation * sfr = static_cast<sfrotation*>(getFieldValue(env, obj));
+    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
     if (!sfr) { return; }
     sfr->value = rotation(axisX, axisY, axisZ, angle);
 }
@@ -1803,9 +1803,9 @@
     jobject obj,
     jobject value)
 {
-    sfrotation * sfr = static_cast<sfrotation*>(getFieldValue(env, obj));
-    sfrotation * newSFRotation =
-        static_cast<sfrotation*>(getFieldValue(env, value));
+    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
+    openvrml::sfrotation * newSFRotation =
+        static_cast<openvrml::sfrotation*>(getFieldValue(env, value));
     if (!sfr || !newSFRotation) return;
     sfr->value = newSFRotation->value;
 }
@@ -1966,7 +1966,7 @@
   (JNIEnv *env, jobject obj, jdouble time)
 {
     try {
-        std::auto_ptr<sftime> sftime(new sftime(time));
+        std::auto_ptr<openvrml::sftime> sftime(new openvrml::sftime(time));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(sftime.release()));
@@ -1991,7 +1991,7 @@
  */
 jdouble JNICALL Java_vrml_field_ConstSFTime_getValue(JNIEnv * env, jobject obj)
 {
-    sftime * sft = static_cast<sftime*>(getFieldValue(env, obj));
+    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, obj));
     if (!sft) { return 0.0; }
     return jdouble(sft->value);
 }
@@ -2032,7 +2032,7 @@
                                                 jobject obj,
                                                 jdouble time)
 {
-    sftime * sft = static_cast<sftime*>(getFieldValue(env, obj));
+    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, obj));
     if (!sft) { return; }
     sft->value = time;
 }
@@ -2042,8 +2042,8 @@
                                                            jobject obj,
                                                            jobject value)
 {
-    sftime* sft = static_cast<sftime*>(getFieldValue(env, obj));
-    sftime* newsftime = static_cast<sftime*>(getFieldValue(env, value));
+    openvrml::sftime* sft = static_cast<openvrml::sftime*>(getFieldValue(env, obj));
+    openvrml::sftime* newsftime = static_cast<openvrml::sftime*>(getFieldValue(env, value));
     if (!sft || !newsftime) { return; }
     sft->value = newsftime->value;
 }
@@ -2072,7 +2072,7 @@
   (JNIEnv *env, jobject obj, jfloat x, jfloat y)
 {
     try {
-        std::auto_ptr<sfvec2f> sfvec2f(new sfvec2f(vec2f(x, y)));
+        std::auto_ptr<openvrml::sfvec2f> sfvec2f(new openvrml::sfvec2f(vec2f(x, y)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
         env->SetIntField(obj, fid, reinterpret_cast<int>(sfvec2f.release()));
@@ -2099,7 +2099,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfvec2f * sfv = static_cast<sfvec2f *>(getFieldValue(env, obj));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f *>(getFieldValue(env, obj));
     if (!sfv) { return; }
     env->SetFloatArrayRegion(jarr, 0, 2, const_cast<float *>(&sfv->value[0]));
 }
@@ -2113,7 +2113,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFVec2f_getX(JNIEnv * env, jobject obj)
 {
-    sfvec2f * sfv = static_cast<sfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
     if (!sfv) { return 0.0; }
     return sfv->value.x();
 }
@@ -2127,7 +2127,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFVec2f_getY(JNIEnv * env, jobject obj)
 {
-    sfvec2f * sfv = static_cast<sfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
     if (!sfv) { return 0.0; }
     return sfv->value.y();
 }
@@ -2194,7 +2194,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfvec2f * sfv = static_cast<sfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
     if (!sfv) return;
     jfloat * pjf = env->GetFloatArrayElements(jarr, NULL);
     sfv->value = vec2f(pjf[0], pjf[1]);
@@ -2206,7 +2206,7 @@
                                                   jfloat x,
                                                   jfloat y)
 {
-    sfvec2f * sfv = static_cast<sfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
     if (!sfv) return;
     sfv->value = vec2f(x, y);
 }
@@ -2216,8 +2216,8 @@
                                                              jobject obj,
                                                              jobject value)
 {
-    sfvec2f * sfv = static_cast<sfvec2f*>(getFieldValue(env, obj));
-    sfvec2f * newSFVec2f = static_cast<sfvec2f*>(getFieldValue(env, value));
+    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f * newSFVec2f = static_cast<openvrml::sfvec2f*>(getFieldValue(env, value));
     if (!sfv || !newSFVec2f) { return; }
     sfv->value = newSFVec2f->value;
 }
@@ -2250,7 +2250,7 @@
                                                        jfloat z)
 {
     try {
-        std::auto_ptr<sfvec3f> sfvec3f(new sfvec3f(vec3f(x, y, z)));
+        std::auto_ptr<openvrml::sfvec3f> sfvec3f(new openvrml::sfvec3f(vec3f(x, y, z)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
         env->SetIntField(obj, fid, reinterpret_cast<int>(sfvec3f.release()));
@@ -2277,7 +2277,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfvec3f * sfv = static_cast<sfvec3f*>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, obj));
     if (!sfv) { return; }
     env->SetFloatArrayRegion(jarr, 0, 3, const_cast<float *>(&sfv->value[0]));
 }
@@ -2291,7 +2291,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFVec3f_getX(JNIEnv * env, jobject obj)
 {
-    sfvec3f * sfv = static_cast<sfvec3f *>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
     if (!sfv) { return 0.0; }
     return sfv->value.x();
 }
@@ -2305,7 +2305,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFVec3f_getY(JNIEnv * env, jobject obj)
 {
-    sfvec3f * sfv = static_cast<sfvec3f *>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
     if (!sfv) { return 0.0; }
     return sfv->value.y();
 }
@@ -2319,7 +2319,7 @@
  */
 jfloat JNICALL Java_vrml_field_ConstSFVec3f_getZ(JNIEnv * env, jobject obj)
 {
-    sfvec3f * sfv = static_cast<sfvec3f *>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
     if (!sfv) { return 0.0; }
     return sfv->value.z();
 }
@@ -2399,7 +2399,7 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    sfvec3f * sfv = static_cast<sfvec3f *>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
     if (!sfv) { return; }
     jfloat * pjf = env->GetFloatArrayElements(jarr, NULL);
     sfv->value = vec3f(pjf[0], pjf[1], pjf[2]);
@@ -2412,7 +2412,7 @@
                                                    jfloat y,
                                                    jfloat z)
 {
-    sfvec3f * sfv = static_cast<sfvec3f*>(getFieldValue(env, obj));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, obj));
     if (!sfv) { return; }
     sfv->value = vec3f(x, y, z);
 }
@@ -2422,8 +2422,8 @@
                                                              jobject obj,
                                                              jobject value)
 {
-    sfvec3f * sfv = static_cast<sfvec3f*>(getFieldValue(env, obj));
-    sfvec3f * newSFVec3f = static_cast<sfvec3f*>(getFieldValue(env, value));
+    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, obj));
+    openvrml::sfvec3f * newSFVec3f = static_cast<openvrml::sfvec3f*>(getFieldValue(env, value));
     if (!sfv || !newSFVec3f) { return; }
     sfv->value = newSFVec3f->value; // Does not throw.
 }
@@ -2455,7 +2455,7 @@
     jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfcolor> mfcolor(new mfcolor(env->GetArrayLength(jarr)));
+        std::auto_ptr<openvrml::mfcolor> mfcolor(new openvrml::mfcolor(env->GetArrayLength(jarr)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfcolor.release()));
@@ -2478,7 +2478,7 @@
                                                              jfloatArray jarr)
 {
     try {
-        std::auto_ptr<mfcolor> mfcolor(new mfcolor(size));
+        std::auto_ptr<openvrml::mfcolor> mfcolor(new openvrml::mfcolor(size));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfcolor.release()));
@@ -2498,7 +2498,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFColor_getSize(JNIEnv * env, jobject obj)
 {
-    mfcolor * mfc = static_cast<mfcolor *>(getFieldValue(env, obj));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
     if (!mfc) { return 0; }
     return mfc->value.size();
 }
@@ -2507,8 +2507,8 @@
                                                           jobject obj,
                                                           jobjectArray jarr)
 {
-    const mfcolor * const mfc =
-            static_cast<mfcolor *>(getFieldValue(env, obj));
+    const openvrml::mfcolor * const mfc =
+            static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
     if (!mfc) { return; }
     for (size_t i = 0; i < mfc->value.size(); ++i) {
         jfloatArray element =
@@ -2531,8 +2531,8 @@
                                                         jobject obj,
                                                         jfloatArray jarr)
 {
-    const mfcolor * const mfc =
-            static_cast<mfcolor *>(getFieldValue(env, obj));
+    const openvrml::mfcolor * const mfc =
+            static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
     if (!mfc) return;
     for (size_t i = 0; i < mfc->value.size(); ++i) {
         jfloat * const arrayRegion =
@@ -2550,7 +2550,7 @@
                                                           jint element,
                                                           jfloatArray jarr)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
     if (!mfc) { return; }
     try {
         jfloat * const arrayRegion =
@@ -2576,11 +2576,11 @@
         jint element,
         jobject sfcolorObj)
 {
-    const mfcolor * const mfc =
-        static_cast<mfcolor *>(getFieldValue(env, obj));
+    const openvrml::mfcolor * const mfc =
+        static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
     if (!mfc) return;
-    sfcolor * const sfc =
-        static_cast<sfcolor *>(getFieldValue(env, sfcolorObj));
+    openvrml::sfcolor * const sfc =
+        static_cast<openvrml::sfcolor *>(getFieldValue(env, sfcolorObj));
     if (!sfc) { return; }
     try {
         sfc->value = mfc->value.at(element);
@@ -2630,7 +2630,7 @@
 
 void JNICALL Java_vrml_field_MFColor_clear(JNIEnv * env, jobject obj)
 {
-    mfcolor * const mfc = static_cast<mfcolor *>(getFieldValue(env, obj));
+    openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
     if (!mfc) { return; }
     mfc->value.clear();
 }
@@ -2639,7 +2639,7 @@
                                             jobject obj,
                                             jint index)
 {
-    mfcolor * const mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
+    openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
     if (!mfc) { return; }
     if (!(size_t(index) < mfc->value.size())) {
         env->ExceptionDescribe();
@@ -2687,8 +2687,8 @@
                                                      jobjectArray value)
 {
     try {
-        mfcolor * const mfc =
-                static_cast<mfcolor *>(getFieldValue(env, obj));
+        openvrml::mfcolor * const mfc =
+                static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
         if (!mfc) return;
         mfc->value.resize(env->GetArrayLength(value)); // Throws std::bad_alloc.
         for (size_t i = 0; i < mfc->value.size(); ++i) {
@@ -2738,7 +2738,7 @@
                                                     jfloatArray value)
 {
     try {
-        mfcolor * const mfc = static_cast<mfcolor *>(getFieldValue(env, obj));
+        openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
         if (!mfc) { return; }
         mfc->value.resize(size); // Throws std::bad_alloc.
         jfloat * const colors = env->GetFloatArrayElements(value, 0);
@@ -2795,9 +2795,9 @@
                                                         jobject obj,
                                                         jobject value)
 {
-    mfcolor * const mfc = static_cast<mfcolor *>(getFieldValue(env, obj));
-    const mfcolor * const newMFColor =
-        static_cast<mfcolor *>(getFieldValue(env, value));
+    openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
+    const openvrml::mfcolor * const newMFColor =
+        static_cast<openvrml::mfcolor *>(getFieldValue(env, value));
     if (!mfc || !newMFColor) { return; }
     try {
         *mfc = *newMFColor; // Throws bad_alloc.
@@ -2827,9 +2827,9 @@
     jint index,
     jobject sfcolor_object)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
-    sfcolor * sfcolorptr =
-        static_cast<sfcolor*>(getFieldValue(env, sfcolor_object));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfcolorptr =
+        static_cast<openvrml::sfcolor*>(getFieldValue(env, sfcolor_object));
     if (!mfc || !sfcolorptr) { return; }
     try {
         mfc->value.at(index) = sfcolorptr->value;
@@ -2858,7 +2858,7 @@
   (JNIEnv *env, jobject obj, jint index, jfloat red, jfloat green,
    jfloat blue)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
     if (!mfc) { return; }
     try {
         mfc->value.at(index) = color(red, green, blue);
@@ -2888,8 +2888,8 @@
     jobject obj,
     jobject sfcolor_object)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
-    sfcolor * sfc = static_cast<sfcolor*>(getFieldValue(env, sfcolor_object));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
+    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, sfcolor_object));
     if (!mfc || !sfc) { return; }
     try {
         mfc->value.push_back(sfc->value);
@@ -2935,7 +2935,7 @@
                                                    jfloat green,
                                                    jfloat blue)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
     if (!mfc) { return; }
     try {
         mfc->value.push_back(color(red, green, blue));
@@ -2958,8 +2958,8 @@
     jint index,
     jobject sfcolor_object)
 {
-    sfcolor * sfcolorptr =
-        static_cast<sfcolor*>(getFieldValue(env, sfcolor_object));
+    openvrml::sfcolor * sfcolorptr =
+        static_cast<openvrml::sfcolor*>(getFieldValue(env, sfcolor_object));
     if (!sfcolorptr) { return; }
     Java_vrml_field_MFColor_insertValue__IFFF(env, obj, index,
                                               sfcolorptr->value.r(),
@@ -2984,7 +2984,7 @@
                                                        jfloat green,
                                                        jfloat blue)
 {
-    mfcolor * mfc = static_cast<mfcolor*>(getFieldValue(env, obj));
+    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
     if (!mfc) { return; }
     if (!(size_t(index) < mfc->value.size())) {
         env->ExceptionDescribe();
@@ -3029,7 +3029,7 @@
 {
     try {
         jfloat *pjf = env->GetFloatArrayElements(value, NULL);
-        std::auto_ptr<mffloat> mffloat(new mffloat(pjf, pjf + size));
+        std::auto_ptr<openvrml::mffloat> mffloat(new openvrml::mffloat(pjf, pjf + size));
         env->ReleaseFloatArrayElements(value, pjf, JNI_ABORT);
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
@@ -3047,7 +3047,7 @@
 }
 
 jint JNICALL Java_vrml_field_ConstMFFloat_getSize(JNIEnv * env, jobject obj) {
-    mffloat * mff = static_cast<mffloat *>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     if (!mff) return 0;
     return mff->value.size();
 }
@@ -3056,8 +3056,8 @@
                                                    jobject obj,
                                                    jfloatArray jarr)
 {
-    const mffloat * const mff =
-        static_cast<mffloat *>(getFieldValue(env, obj));
+    const openvrml::mffloat * const mff =
+        static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     if (!mff) { return; }
     const size_t size = mff->value.size();
     if (size > 0) {
@@ -3070,7 +3070,7 @@
                                                       jobject obj,
                                                       jint index)
 {
-    mffloat * mff = static_cast<mffloat *>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     if (!mff) { return 0.0; }
     return mff->value[index];
 }
@@ -3102,7 +3102,7 @@
 
 void JNICALL Java_vrml_field_MFFloat_clear(JNIEnv * env, jobject obj)
 {
-    mffloat * const mff = static_cast<mffloat *>(getFieldValue(env, obj));
+    openvrml::mffloat * const mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     if (!mff) { return; }
     mff->value.clear();
 }
@@ -3111,7 +3111,7 @@
                                             jobject obj,
                                             jint index)
 {
-    mffloat * mff = static_cast<mffloat*>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
     if (!mff) { return; }
     if (!(size_t(index) < mff->value.size())) {
         env->ExceptionDescribe();
@@ -3146,7 +3146,7 @@
                                                     jfloatArray value)
 {
     try {
-        mffloat * const mff = static_cast<mffloat *>(getFieldValue(env, obj));
+        openvrml::mffloat * const mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
         if (!mff) { return; }
         mff->value.resize(size); // Throws bad_alloc.
         jfloat * const floats = env->GetFloatArrayElements(value, 0);
@@ -3188,9 +3188,9 @@
                                                         jobject obj,
                                                         jobject value)
 {
-    mffloat * const mff = static_cast<mffloat *>(getFieldValue(env, obj));
-    const mffloat * const newMFFloat =
-        static_cast<mffloat*>(getFieldValue(env, value));
+    openvrml::mffloat * const mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
+    const openvrml::mffloat * const newMFFloat =
+        static_cast<openvrml::mffloat*>(getFieldValue(env, value));
     if (!mff || !newMFFloat) return;
     try {
         *mff = *newMFFloat; // Throws bad_alloc.
@@ -3218,7 +3218,7 @@
                                                    jint index,
                                                    jfloat value)
 {
-    mffloat * mff = static_cast<mffloat *>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     mff->value[index] = value;
 }
 
@@ -3226,8 +3226,8 @@
 Java_vrml_field_MFFloat_set1Value__ILvrml_field_ConstSFFloat_2
   (JNIEnv *env, jobject obj, jint index, jobject sffloatObj)
 {
-    mffloat * mff = static_cast<mffloat*>(getFieldValue(env, obj));
-    sffloat * sff = static_cast<sffloat*>(getFieldValue(env, sffloatObj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
+    openvrml::sffloat * sff = static_cast<openvrml::sffloat*>(getFieldValue(env, sffloatObj));
     if (!mff || !sff) { return; }
     mff->value[index] = sff->value;
 }
@@ -3251,7 +3251,7 @@
                                                  jobject obj,
                                                  jfloat value)
 {
-    mffloat * mff = static_cast<mffloat*>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
     if (!mff) { return; }
     try {
         mff->value.push_back(value);
@@ -3279,8 +3279,8 @@
                                                              jobject obj,
                                                              jobject value)
 {
-    mffloat * mff = static_cast<mffloat*>(getFieldValue(env, obj));
-    sffloat * sff = static_cast<sffloat*>(getFieldValue(env, value));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
+    openvrml::sffloat * sff = static_cast<openvrml::sffloat*>(getFieldValue(env, value));
     if (!mff || !sff) { return; }
     try {
         mff->value.push_back(sff->value);
@@ -3316,7 +3316,7 @@
                                                      jint index,
                                                      jfloat value)
 {
-    mffloat * mff = static_cast<mffloat *>(getFieldValue(env, obj));
+    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
     if (!mff) { return; }
     if (!(size_t(index) < mff->value.size())) {
         env->ExceptionDescribe();
@@ -3349,7 +3349,7 @@
                                                                  jint index,
                                                                  jobject value)
 {
-    sffloat * sff = static_cast<sffloat*>(getFieldValue(env, value));
+    openvrml::sffloat * sff = static_cast<openvrml::sffloat*>(getFieldValue(env, value));
     if (!sff) { return; }
     Java_vrml_field_MFFloat_insertValue__IF(env, obj, index, sff->value);
 }
@@ -3382,7 +3382,7 @@
 {
     try {
         jint * pji = env->GetIntArrayElements(value, NULL);
-        std::auto_ptr<mfint32> pMFInt32(new mfint32(pji, pji + size));
+        std::auto_ptr<openvrml::mfint32> pMFInt32(new openvrml::mfint32(pji, pji + size));
         env->ReleaseIntArrayElements(value, pji, JNI_ABORT);
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
@@ -3401,7 +3401,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFInt32_getSize(JNIEnv * env, jobject obj)
 {
-    mfint32 * mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
     if (!mfi) return 0;
     return mfi->value.size();
 }
@@ -3410,7 +3410,7 @@
                                                    jobject obj,
                                                    jintArray jarr)
 {
-    const mfint32 * const mfi = static_cast<mfint32*>(getFieldValue(env, obj));
+    const openvrml::mfint32 * const mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
     if (!mfi) return;
     const size_t size = mfi->value.size();
     if (size > 0) {
@@ -3437,7 +3437,7 @@
                                                     jobject obj,
                                                     jint index)
 {
-    mfint32 * mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
     if (!mfi) { return 0; }
     return mfi->value[index];
 }
@@ -3469,14 +3469,14 @@
 
 void JNICALL Java_vrml_field_MFInt32_clear(JNIEnv * env, jobject obj)
 {
-    mfint32 * const mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
+    openvrml::mfint32 * const mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
     if (!mfi) { return; }
     mfi->value.clear();
 }
 
 void JNICALL Java_vrml_field_MFInt32_delete(JNIEnv * env, jobject obj, jint n)
 {
-    mfint32 * mfi = static_cast<mfint32*>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
     if (!mfi) { return; }
     if (!(size_t(n) < mfi->value.size())) {
         env->ExceptionDescribe();
@@ -3511,7 +3511,7 @@
                                                     jintArray value)
 {
     try {
-        mfint32 * const mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
+        openvrml::mfint32 * const mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
         if (!mfi) return;
         mfi->value.resize(size); // Throws bad_alloc.
         jint * ints = env->GetIntArrayElements(value, 0);
@@ -3553,9 +3553,9 @@
                                                         jobject obj,
                                                         jobject value)
 {
-    mfint32 * const mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
-    const mfint32 * const newMFInt32 =
-        static_cast<mfint32 *>(getFieldValue(env, value));
+    openvrml::mfint32 * const mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
+    const openvrml::mfint32 * const newMFInt32 =
+        static_cast<openvrml::mfint32 *>(getFieldValue(env, value));
     if (!mfi || !newMFInt32) return;
     try {
         *mfi = *newMFInt32; // Throws bad_alloc.
@@ -3583,7 +3583,7 @@
                                                    jint index,
                                                    jint value)
 {
-    mfint32 * mfi = static_cast<mfint32*>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
     if (!mfi) { return; }
     mfi->value[index] = value;
 }
@@ -3595,8 +3595,8 @@
     jint index,
     jobject sfint32_object)
 {
-    mfint32 * mfi = static_cast<mfint32*>(getFieldValue(env, obj));
-    sfint32 * sfi = static_cast<sfint32*>(getFieldValue(env, sfint32_object));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
+    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, sfint32_object));
     if (!mfi || !sfi) { return; }
     mfi->value[index] = sfi->value;
 }
@@ -3620,7 +3620,7 @@
                                                  jobject obj,
                                                  jint value)
 {
-    mfint32 * mfi = static_cast<mfint32 *>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
     if (!mfi) { return; }
     try {
         mfi->value.push_back(value);
@@ -3648,8 +3648,8 @@
                                                              jobject obj,
                                                              jobject value)
 {
-    mfint32 * mfi = static_cast<mfint32*>(getFieldValue(env, obj));
-    sfint32 * sfi = static_cast<sfint32*>(getFieldValue(env, value));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
+    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, value));
     if (!mfi || !sfi) { return; }
     try {
         mfi->value.push_back(sfi->value);
@@ -3686,7 +3686,7 @@
                                                      jint index,
                                                      jint value)
 {
-    mfint32 * mfi = static_cast<mfint32*>(getFieldValue(env, obj));
+    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
     if (!mfi) { return; }
     if (!(size_t(index) < mfi->value.size())) {
         env->ExceptionDescribe();
@@ -3719,7 +3719,7 @@
                                                                  jint index,
                                                                  jobject value)
 {
-    sfint32 * sfi = static_cast<sfint32*>(getFieldValue(env, value));
+    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, value));
     if (!sfi) { return; }
     Java_vrml_field_MFInt32_insertValue__II(env, obj, index, sfi->value);
 }
@@ -3749,7 +3749,7 @@
   (JNIEnv *env, jobject obj, jint size, jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfnode> mfnode(new mfnode(size));
+        std::auto_ptr<openvrml::mfnode> mfnode(new openvrml::mfnode(size));
         jfieldID fid;
 
         for (jint i = 0; i < size; i++) {
@@ -3779,7 +3779,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFNode_getSize(JNIEnv * env, jobject obj)
 {
-    mfnode * mfn = static_cast<mfnode *>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode *>(getFieldValue(env, obj));
     if (!mfn) { return 0; }
     return mfn->value.size();
 }
@@ -3788,7 +3788,7 @@
                                                   jobject obj,
                                                   jobjectArray basenode)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     std::vector<node_ptr>::size_type arraySize = mfn->value.size();
     jclass clazz = env->FindClass("vrml/node/Node");
@@ -3816,7 +3816,7 @@
                                                       jobject obj,
                                                       jint index)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return 0; }
     jclass clazz = env->FindClass("vrml/node/Node");
     jobject jNode = env->AllocObject(clazz);
@@ -3854,7 +3854,7 @@
 
 void JNICALL Java_vrml_field_MFNode_clear(JNIEnv * env, jobject obj)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     mfn->value.clear();
 }
@@ -3863,7 +3863,7 @@
                                            jobject obj,
                                            jint index)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     if (!(size_t(index) < mfn->value.size())) {
         env->ExceptionDescribe();
@@ -3920,8 +3920,8 @@
                                                       jobject obj,
                                                       jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
-    mfnode* newMFNode = static_cast<mfnode*>(getFieldValue(env, value));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode* newMFNode = static_cast<openvrml::mfnode*>(getFieldValue(env, value));
     if (!mfn || !newMFNode) { return; }
 
     try {
@@ -3950,7 +3950,7 @@
                                                                  jint pos,
                                                                  jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     jfieldID fid = getFid(env, value, "NodePtr", "I");
     if (!fid) { return; }
@@ -3967,7 +3967,7 @@
     jint index,
     jobject sfnode_object)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     sfnode * sfn = static_cast<sfnode*>(getFieldValue(env, sfnode_object));
     if (!mfn || !sfn) { return; }
     mfn->value[index] = sfn->value;
@@ -3992,7 +3992,7 @@
                                                                jobject obj,
                                                                jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     jfieldID fid = getFid(env, value, "NodePtr", "I");
     if (!fid) { return; }
@@ -4025,7 +4025,7 @@
                                                            jobject obj,
                                                            jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     sfnode * sfn = static_cast<sfnode*>(getFieldValue(env, value));
     if (!mfn || !sfn) { return; }
     try {
@@ -4061,7 +4061,7 @@
                                                       jint index,
                                                       jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     if (!mfn) { return; }
     jfieldID fid = getFid(env, value, "NodePtr", "I");
     if (!fid) { return; }
@@ -4099,7 +4099,7 @@
                                                                jint index,
                                                                jobject value)
 {
-    mfnode * mfn = static_cast<mfnode*>(getFieldValue(env, obj));
+    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
     sfnode * sfn = static_cast<sfnode*>(getFieldValue(env, value));
     if (!mfn || !sfn) { return; }
     if (!(size_t(index) < mfn->value.size())) {
@@ -4154,8 +4154,8 @@
                                                     jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfrotation>
-                mfrotation(new mfrotation(env->GetArrayLength(jarr)));
+        std::auto_ptr<openvrml::mfrotation>
+                mfrotation(new openvrml::mfrotation(env->GetArrayLength(jarr)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfrotation.release()));
@@ -4180,7 +4180,7 @@
                                                    jfloatArray jarr)
 {
     try {
-        std::auto_ptr<mfrotation> mfrotation(new mfrotation(size));
+        std::auto_ptr<openvrml::mfrotation> mfrotation(new openvrml::mfrotation(size));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
         env->SetIntField(obj, fid,
@@ -4202,8 +4202,8 @@
 jint JNICALL Java_vrml_field_ConstMFRotation_getSize(JNIEnv * env,
                                                      jobject obj)
 {
-    mfrotation * mfrot =
-        static_cast<mfrotation *>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot =
+        static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
     if (!mfrot) { return 0; }
     return mfrot->value.size();
 }
@@ -4212,8 +4212,8 @@
                                                              jobject obj,
                                                              jobjectArray jarr)
 {
-    const mfrotation * const mfrot =
-            static_cast<mfrotation *>(getFieldValue(env, obj));
+    const openvrml::mfrotation * const mfrot =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
     for (size_t i = 0; i < mfrot->value.size(); ++i) {
         jfloatArray element =
                 static_cast<jfloatArray>(env->GetObjectArrayElement(jarr, i));
@@ -4234,8 +4234,8 @@
                                                            jobject obj,
                                                            jfloatArray jarr)
 {
-    const mfrotation * const mfrot =
-            static_cast<mfrotation *>(getFieldValue(env, obj));
+    const openvrml::mfrotation * const mfrot =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
     for (size_t i = 0; i < mfrot->value.size(); ++i) {
         env->SetFloatArrayRegion(jarr, i * 4, 4,
                                  const_cast<jfloat *>(&mfrot->value[i][0]));
@@ -4251,7 +4251,7 @@
                                                              jint element,
                                                              jfloatArray jarr)
 {
-    mfrotation * mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
     env->SetFloatArrayRegion(jarr, 0, 4,
                              const_cast<jfloat*>(&mfrot->value[element][0]));
 }
@@ -4263,11 +4263,11 @@
         jint element,
         jobject sfrotationObj)
 {
-    const mfrotation * const mfrot =
-            static_cast<mfrotation *>(getFieldValue(env, obj));
+    const openvrml::mfrotation * const mfrot =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
     if (!mfrot) { return; }
-    sfrotation * const sfrot =
-            static_cast<sfrotation *>(getFieldValue(env, sfrotationObj));
+    openvrml::sfrotation * const sfrot =
+            static_cast<openvrml::sfrotation *>(getFieldValue(env, sfrotationObj));
     if (!sfrot) { return; }
     try {
         sfrot->value = mfrot->value[element];
@@ -4317,8 +4317,8 @@
 
 void JNICALL Java_vrml_field_MFRotation_clear(JNIEnv * env, jobject obj)
 {
-    mfrotation * const mfrot =
-        static_cast<mfrotation *>(getFieldValue(env, obj));
+    openvrml::mfrotation * const mfrot =
+        static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
     if (!mfrot) { return; }
     mfrot->value.clear(); // Shouldn't throw bad_alloc.
 }
@@ -4327,7 +4327,7 @@
                                                jobject obj,
                                                jint index)
 {
-    mfrotation * mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
     if (!mfrot) { return; }
     if (!(size_t(index) < mfrot->value.size())) {
         env->ExceptionDescribe();
@@ -4375,8 +4375,8 @@
                                                         jobjectArray value)
 {
     try {
-        mfrotation * const mfrot =
-            static_cast<mfrotation *>(getFieldValue(env, obj));
+        openvrml::mfrotation * const mfrot =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
         if (!mfrot) { return; }
         mfrot->value.resize(env->GetArrayLength(value));
         for (size_t i = 0; i < mfrot->value.size(); ++i) {
@@ -4413,8 +4413,8 @@
                                                        jfloatArray value)
 {
     try {
-        mfrotation * const mfrot =
-                static_cast<mfrotation *>(getFieldValue(env, obj));
+        openvrml::mfrotation * const mfrot =
+                static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
         if (!mfrot) { return; }
         mfrot->value.resize(size);
         jfloat * const r = env->GetFloatArrayElements(value, 0);
@@ -4458,10 +4458,10 @@
                                                               jobject obj,
                                                               jobject value)
 {
-    mfrotation * const mfrot =
-            static_cast<mfrotation *>(getFieldValue(env, obj));
-    const mfrotation * const newMFRotation =
-            static_cast<mfrotation *>(getFieldValue(env, value));
+    openvrml::mfrotation * const mfrot =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
+    const openvrml::mfrotation * const newMFRotation =
+            static_cast<openvrml::mfrotation *>(getFieldValue(env, value));
     if (!mfrot || !newMFRotation) return;
     try {
         *mfrot = *newMFRotation; // Throws bad_alloc.
@@ -4492,9 +4492,9 @@
     jint index,
     jobject sfrotation_object)
 {
-    mfrotation* mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
-    sfrotation* sfrot =
-        static_cast<sfrotation*>(getFieldValue(env, sfrotation_object));
+    openvrml::mfrotation* mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
+    openvrml::sfrotation* sfrot =
+        static_cast<openvrml::sfrotation*>(getFieldValue(env, sfrotation_object));
     if (!mfrot || !sfrot) { return; }
     mfrot->value[index] = sfrot->value;
 }
@@ -4515,7 +4515,7 @@
                                                          jfloat axisZ,
                                                          jfloat angle)
 {
-    mfrotation * mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
     if (!mfrot) { return; }
     mfrot->value[index] = rotation(axisX, axisY, axisZ, angle);
 }
@@ -4533,9 +4533,9 @@
         jobject obj,
         jobject sfrotation_object)
 {
-    mfrotation * mfrot = static_cast<mfrotation *>(getFieldValue(env, obj));
-    sfrotation * sfrot =
-        static_cast<sfrotation *>(getFieldValue(env, sfrotation_object));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
+    openvrml::sfrotation * sfrot =
+        static_cast<openvrml::sfrotation *>(getFieldValue(env, sfrotation_object));
     if (!mfrot || !sfrot) { return; }
     try {
         mfrot->value.push_back(sfrot->value);
@@ -4583,7 +4583,7 @@
                                                        jfloat axisZ,
                                                        jfloat angle)
 {
-    mfrotation * mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
     if (!mfrot) { return; }
     try {
         mfrot->value.push_back(rotation(axisX, axisY, axisZ, angle));
@@ -4606,8 +4606,8 @@
     jint index,
     jobject sfrotation_object)
 {
-    sfrotation * sfrot =
-        static_cast<sfrotation*>(getFieldValue(env, sfrotation_object));
+    openvrml::sfrotation * sfrot =
+        static_cast<openvrml::sfrotation*>(getFieldValue(env, sfrotation_object));
     if (!sfrot) { return; }
     Java_vrml_field_MFRotation_insertValue__IFFFF(env, obj, index,
                                                   sfrot->value.x(),
@@ -4632,7 +4632,7 @@
                                                            jfloat axisZ,
                                                            jfloat angle)
 {
-    mfrotation * mfrot = static_cast<mfrotation*>(getFieldValue(env, obj));
+    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
     if (!mfrot) { return; }
     if (!(size_t(index) < mfrot->value.size())) {
         env->ExceptionDescribe();
@@ -4677,7 +4677,7 @@
   (JNIEnv *env, jobject obj, jint size, jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfstring> mfstring(new mfstring(size));
+        std::auto_ptr<openvrml::mfstring> mfstring(new openvrml::mfstring(size));
 
         for (jint i = 0; i < size; i++) {
             jstring el = (jstring) env->GetObjectArrayElement(jarr, i);
@@ -4704,7 +4704,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFString_getSize(JNIEnv * env, jobject obj)
 {
-    mfstring * mfstr = static_cast<mfstring *>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring *>(getFieldValue(env, obj));
     if (!mfstr) { return 0; }
     return mfstr->value.size();
 }
@@ -4713,7 +4713,7 @@
                                                     jobject obj,
                                                     jobjectArray jarr)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) return;
     for (size_t i = 0; i < mfstr->value.size(); i++) {
         jstring jstr;
@@ -4729,7 +4729,7 @@
                                                         jobject obj,
                                                         jint index)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return 0; }
     jstring jstr = env->NewStringUTF(mfstr->value[index].c_str());
     return jstr;
@@ -4762,7 +4762,7 @@
 
 void JNICALL Java_vrml_field_MFString_clear(JNIEnv * env, jobject obj)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return; }
     mfstr->value.clear();
 }
@@ -4771,7 +4771,7 @@
                                              jobject obj,
                                              jint index)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return; }
     if (!(size_t(index) < mfstr->value.size())) {
         env->ExceptionDescribe();
@@ -4807,7 +4807,7 @@
                                                           jobjectArray jarr)
 {
     try {
-        mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+        openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
         if (!mfstr) { return; }
 
         jsize entries = env->GetArrayLength(jarr);
@@ -4838,8 +4838,8 @@
                                                           jobject obj,
                                                           jobject value)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
-    mfstring * newMFString = static_cast<mfstring*>(getFieldValue(env, value));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * newMFString = static_cast<openvrml::mfstring*>(getFieldValue(env, value));
     if (!mfstr || !newMFString) return;
 
     try {
@@ -4869,7 +4869,7 @@
                                                          jint index,
                                                          jstring value)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return; }
     const char * utf8chars = env->GetStringUTFChars(value, 0);
     if (!utf8chars) { return; } // OutOfMemoryError
@@ -4884,7 +4884,7 @@
     jint index,
     jobject sfstring_object)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     sfstring * sfstr =
         static_cast<sfstring*>(getFieldValue(env, sfstring_object));
     if (!mfstr || !sfstr) { return; }
@@ -4911,7 +4911,7 @@
                                                        jobject obj,
                                                        jstring value)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return; }
     const char * utf8chars = env->GetStringUTFChars(value, 0);
     if (!utf8chars) { return; } // OutOfMemoryError
@@ -4943,7 +4943,7 @@
     jobject obj,
     jobject sfstring_object)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     sfstring * sfstr =
         static_cast<sfstring*>(getFieldValue(env, sfstring_object));
     if (!mfstr || !sfstr) { return; }
@@ -4990,7 +4990,7 @@
                                                            jint index,
                                                            jstring value)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     if (!mfstr) { return; }
     const char * utf8chars = env->GetStringUTFChars(value, 0);
     if (!utf8chars) { return; } // OutOfMemoryError
@@ -5024,7 +5024,7 @@
     jint index,
     jobject sfstring_object)
 {
-    mfstring * mfstr = static_cast<mfstring*>(getFieldValue(env, obj));
+    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
     sfstring * sfstr =
         static_cast<sfstring*>(getFieldValue(env, sfstring_object));
     if (!mfstr || !sfstr) { return; }
@@ -5076,7 +5076,7 @@
 {
     try {
         jdouble *pjd = env->GetDoubleArrayElements(value, 0);
-        std::auto_ptr<mftime> mftime(new mftime(pjd, pjd + size));
+        std::auto_ptr<openvrml::mftime> mftime(new openvrml::mftime(pjd, pjd + size));
         env->ReleaseDoubleArrayElements(value, pjd, JNI_ABORT);
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) { return; }
@@ -5095,7 +5095,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFTime_getSize(JNIEnv * env, jobject obj)
 {
-    mftime * mft = static_cast<mftime *>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
     if (!mft) { return 0; }
     return mft->value.size();
 }
@@ -5104,7 +5104,7 @@
                                                   jobject obj,
                                                   jdoubleArray jarr)
 {
-    mftime * const mft = static_cast<mftime*>(getFieldValue(env, obj));
+    openvrml::mftime * const mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
     if (!mft) { return; }
     const size_t size = mft->value.size();
     if (size > 0) {
@@ -5117,7 +5117,7 @@
                                                       jobject obj,
                                                       jint index)
 {
-    mftime * mft = static_cast<mftime *>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
     if (!mft) { return 0.0; }
     jdouble retval;
     try {
@@ -5163,7 +5163,7 @@
 
 void JNICALL Java_vrml_field_MFTime_clear(JNIEnv * env, jobject obj)
 {
-    mftime * const mft = static_cast<mftime *>(getFieldValue(env, obj));
+    openvrml::mftime * const mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
     if (!mft) { return; }
     mft->value.clear();
 }
@@ -5172,7 +5172,7 @@
                                            jobject obj,
                                            jint index)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
     if (!mft) { return; }
     if (!(size_t(index) < mft->value.size())) {
         env->ExceptionDescribe();
@@ -5207,7 +5207,7 @@
                                                    const jdoubleArray value)
 {
     try {
-        mftime * const mft = static_cast<mftime *>(getFieldValue(env, obj));
+        openvrml::mftime * const mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
         if (!mft) { return; }
         mft->value.resize(size); // Throws std::bad_alloc.
         jdouble * const times = env->GetDoubleArrayElements(value, 0);
@@ -5249,9 +5249,9 @@
                                                       jobject obj,
                                                       jobject value)
 {
-    mftime * const mft = static_cast<mftime *>(getFieldValue(env, obj));
-    const mftime * const newMFTime =
-            static_cast<mftime *>(getFieldValue(env, value));
+    openvrml::mftime * const mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
+    const openvrml::mftime * const newMFTime =
+            static_cast<openvrml::mftime *>(getFieldValue(env, value));
     if (!mft || !newMFTime) return;
     try {
         *mft = *newMFTime; // Throws bad_alloc.
@@ -5279,7 +5279,7 @@
                                                   jint index,
                                                   jdouble value)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
     if (!mft) { return; }
     try {
         mft->value.at(index) = value;
@@ -5303,8 +5303,8 @@
     jint index,
     jobject sftime_object)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
-    sftime * sft = static_cast<sftime*>(getFieldValue(env, sftime_object));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
+    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, sftime_object));
     if (!mft || !sft) { return; }
     try {
         mft->value.at(index) = sft->value;
@@ -5340,7 +5340,7 @@
                                                 jobject obj,
                                                 jdouble value)
 {
-    mftime * mft = static_cast<mftime *>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
     if (!mft) { return; }
     try {
         mft->value.push_back(value);
@@ -5369,8 +5369,8 @@
     jobject obj,
     jobject sftime_object)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
-    sftime * sft = static_cast<sftime*>(getFieldValue(env, sftime_object));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
+    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, sftime_object));
     if (!mft || !sft) { return; }
     try {
         mft->value.push_back(sft->value);
@@ -5406,7 +5406,7 @@
                                                     jint index,
                                                     jdouble value)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
     if (!mft) { return; }
     try {
         mft->value.insert(mft->value.begin() + index, value);
@@ -5429,8 +5429,8 @@
     jint index,
     jobject sftime_object)
 {
-    mftime * mft = static_cast<mftime*>(getFieldValue(env, obj));
-    sftime * sft = static_cast<sftime*>(getFieldValue(env, sftime_object));
+    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
+    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, sftime_object));
     if (!mft || !sft) { return; }
     try {
         mft->value.insert(mft->value.begin() + index, sft->value);
@@ -5472,7 +5472,7 @@
                                                               jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfvec2f> mfvec2f(new mfvec2f(env->GetArrayLength(jarr)));
+        std::auto_ptr<openvrml::mfvec2f> mfvec2f(new openvrml::mfvec2f(env->GetArrayLength(jarr)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfvec2f.release()));
@@ -5495,7 +5495,7 @@
                                                              jfloatArray jarr)
 {
     try {
-        std::auto_ptr<mfvec2f> mfvec2f(new mfvec2f(size));
+        std::auto_ptr<openvrml::mfvec2f> mfvec2f(new openvrml::mfvec2f(size));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfvec2f.release()));
@@ -5514,7 +5514,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFVec2f_getSize(JNIEnv * env, jobject obj)
 {
-    mfvec2f * mfv = static_cast<mfvec2f *>(getFieldValue(env, obj));
+    openvrml::mfvec2f * mfv = static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
     if (!mfv) { return 0; }
     return mfv->value.size();
 }
@@ -5523,8 +5523,8 @@
                                                           jobject obj,
                                                           jobjectArray jarr)
 {
-    const mfvec2f * const mfv =
-            static_cast<mfvec2f *>(getFieldValue(env, obj));
+    const openvrml::mfvec2f * const mfv =
+            static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
     if (!mfv) return;
     for (size_t i = 0; i < mfv->value.size(); ++i) {
         jfloatArray element =
@@ -5546,8 +5546,8 @@
                                                         jobject obj,
                                                         jfloatArray jarr)
 {
-    const mfvec2f * const mfv =
-            static_cast<mfvec2f *>(getFieldValue(env, obj));
+    const openvrml::mfvec2f * const mfv =
+            static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
     if (!mfv) return;
     for (size_t i = 0; i < mfv->value.size(); ++i) {
         env->SetFloatArrayRegion(jarr, i * 2, 2,
@@ -5570,7 +5570,7 @@
 void JNICALL Java_vrml_field_ConstMFVec2f_get1Value__I_3F
   (JNIEnv *env, jobject obj, jint element, jfloatArray jarr)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         jfloat * const arrayRegion =
@@ -5604,11 +5604,11 @@
         jint element,
         jobject sfvec2f_object)
 {
-    const mfvec2f * const mfv =
-            static_cast<mfvec2f *>(getFieldValue(env, obj));
+    const openvrml::mfvec2f * const mfv =
+            static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
     if (!mfv) return;
-    sfvec2f * const sfv =
-        static_cast<sfvec2f *>(getFieldValue(env, sfvec2f_object));
+    openvrml::sfvec2f * const sfv =
+        static_cast<openvrml::sfvec2f *>(getFieldValue(env, sfvec2f_object));
     if (!sfv) { return; }
     try {
         sfv->value = mfv->value.at(element);
@@ -5658,7 +5658,7 @@
 
 void JNICALL Java_vrml_field_MFVec2f_clear(JNIEnv * env, jobject obj)
 {
-    mfvec2f * const mfv = static_cast<mfvec2f *>(getFieldValue(env, obj));
+    openvrml::mfvec2f * const mfv = static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
     if (!mfv) return;
     mfv->value.clear();
 }
@@ -5666,7 +5666,7 @@
 void JNICALL Java_vrml_field_MFVec2f_delete
   (JNIEnv *env, jobject obj, jint n)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
     if (!mfv) return;
     if (!(size_t(n) < mfv->value.size())) {
         env->ExceptionDescribe();
@@ -5730,8 +5730,8 @@
                                                      jobjectArray value)
 {
     try {
-        mfvec2f * const mfv =
-                static_cast<mfvec2f *>(getFieldValue(env, obj));
+        openvrml::mfvec2f * const mfv =
+                static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
         if (!mfv) return;
         mfv->value.resize(env->GetArrayLength(value)); // Throws bad_alloc.
 
@@ -5769,8 +5769,8 @@
                                                     jfloatArray value)
 {
     try {
-        mfvec2f * const mfv =
-                static_cast<mfvec2f *>(getFieldValue(env, obj));
+        openvrml::mfvec2f * const mfv =
+                static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
         if (!mfv) return;
         mfv->value.resize(size); // throws bad_alloc
         jfloat * const vecs = env->GetFloatArrayElements(value, 0);
@@ -5812,9 +5812,9 @@
                                                         jobject obj,
                                                         jobject value)
 {
-    mfvec2f * const mfv = static_cast<mfvec2f *>(getFieldValue(env, obj));
-    const mfvec2f * const newMFVec2f =
-            static_cast<mfvec2f *>(getFieldValue(env, value));
+    openvrml::mfvec2f * const mfv = static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
+    const openvrml::mfvec2f * const newMFVec2f =
+            static_cast<openvrml::mfvec2f *>(getFieldValue(env, value));
     if (!mfv || !newMFVec2f) return;
     try {
         *mfv = *newMFVec2f; // Throws bad_alloc.
@@ -5840,7 +5840,7 @@
 void JNICALL Java_vrml_field_MFVec2f_set1Value__IFF
   (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         mfv->value.at(index) = vec2f(x, y);
@@ -5861,8 +5861,8 @@
 Java_vrml_field_MFVec2f_set1Value__ILvrml_field_ConstSFVec2f_2
   (JNIEnv *env, jobject obj, jint index, jobject sfvec2fObj)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
-    sfvec2f* sfv = static_cast<sfvec2f*>(getFieldValue(env, sfvec2fObj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f* sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, sfvec2fObj));
     if (!mfv || !sfv) return;
     try {
         mfv->value.at(index) = sfv->value;
@@ -5898,7 +5898,7 @@
 void JNICALL Java_vrml_field_MFVec2f_addValue__FF
   (JNIEnv *env, jobject obj, jfloat x, jfloat y)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         mfv->value.push_back(vec2f(x, y));
@@ -5925,8 +5925,8 @@
 Java_vrml_field_MFVec2f_addValue__Lvrml_field_ConstSFVec2f_2
   (JNIEnv *env, jobject obj, jobject sfvec2fObj)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
-    sfvec2f* sfv = static_cast<sfvec2f*>(getFieldValue(env, sfvec2fObj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f* sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, sfvec2fObj));
     if (!mfv || !sfv) return;
     try {
         mfv->value.push_back(sfv->value);
@@ -5960,7 +5960,7 @@
 void JNICALL Java_vrml_field_MFVec2f_insertValue__IFF
   (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         mfv->value.insert(mfv->value.begin() + index, vec2f(x, y));
@@ -5980,8 +5980,8 @@
 Java_vrml_field_MFVec2f_insertValue__ILvrml_field_ConstSFVec2f_2
   (JNIEnv *env, jobject obj, jint index, jobject sfvec2fObj)
 {
-    mfvec2f* mfv = static_cast<mfvec2f*>(getFieldValue(env, obj));
-    sfvec2f* sfv = static_cast<sfvec2f*>(getFieldValue(env, sfvec2fObj));
+    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
+    openvrml::sfvec2f* sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, sfvec2fObj));
     if (!mfv || !sfv) return;
     try {
         mfv->value.insert(mfv->value.begin() + index, sfv->value);
@@ -6023,7 +6023,7 @@
                                                               jobjectArray jarr)
 {
     try {
-        std::auto_ptr<mfvec3f> mfvec3f(new mfvec3f(env->GetArrayLength(jarr)));
+        std::auto_ptr<openvrml::mfvec3f> mfvec3f(new openvrml::mfvec3f(env->GetArrayLength(jarr)));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfvec3f.release()));
@@ -6046,7 +6046,7 @@
                                                              jfloatArray jarr)
 {
     try {
-        std::auto_ptr<mfvec3f> mfvec3f(new mfvec3f(size));
+        std::auto_ptr<openvrml::mfvec3f> mfvec3f(new openvrml::mfvec3f(size));
         jfieldID fid = getFid(env, obj, "FieldPtr", "I");
         if (!fid) return;
         env->SetIntField(obj, fid, reinterpret_cast<int>(mfvec3f.release()));
@@ -6065,7 +6065,7 @@
 
 jint JNICALL Java_vrml_field_ConstMFVec3f_getSize(JNIEnv * env, jobject obj)
 {
-    mfvec3f * mfv = static_cast<mfvec3f *>(getFieldValue(env, obj));
+    openvrml::mfvec3f * mfv = static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
     if (!mfv) return 0;
     return mfv->value.size();
 }
@@ -6074,8 +6074,8 @@
                                                           jobject obj,
                                                           jobjectArray jarr)
 {
-    const mfvec3f * const mfv =
-            static_cast<mfvec3f *>(getFieldValue(env, obj));
+    const openvrml::mfvec3f * const mfv =
+            static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
     if (!mfv) return;
     for (size_t i = 0; i < mfv->value.size(); ++i) {
         jfloatArray element =
@@ -6097,8 +6097,8 @@
                                                         jobject obj,
                                                         jfloatArray jarr)
 {
-    const mfvec3f * const mfv =
-            static_cast<mfvec3f *>(getFieldValue(env, obj));
+    const openvrml::mfvec3f * const mfv =
+            static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
     if (!mfv) return;
     for (size_t i = 0; i < mfv->value.size(); ++i) {
         env->SetFloatArrayRegion(jarr, i * 3, 3,
@@ -6121,7 +6121,7 @@
 void JNICALL Java_vrml_field_ConstMFVec3f_get1Value__I_3F
   (JNIEnv *env, jobject obj, jint element, jfloatArray jarr)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         jfloat * const arrayRegion =
@@ -6155,11 +6155,11 @@
         jint element,
         jobject sfvec3fObj)
 {
-    const mfvec3f * const mfv =
-            static_cast<mfvec3f *>(getFieldValue(env, obj));
+    const openvrml::mfvec3f * const mfv =
+            static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
     if (!mfv) return;
-    sfvec3f * const sfv =
-            static_cast<sfvec3f *>(getFieldValue(env, sfvec3fObj));
+    openvrml::sfvec3f * const sfv =
+            static_cast<openvrml::sfvec3f *>(getFieldValue(env, sfvec3fObj));
     if (!sfv) return;
     try {
         sfv->value = mfv->value.at(element);
@@ -6209,7 +6209,7 @@
 
 void JNICALL Java_vrml_field_MFVec3f_clear(JNIEnv * env, jobject obj)
 {
-    mfvec3f * const mfv = static_cast<mfvec3f *>(getFieldValue(env, obj));
+    openvrml::mfvec3f * const mfv = static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
     if (!mfv) return;
     mfv->value.clear();
 }
@@ -6217,7 +6217,7 @@
 void JNICALL Java_vrml_field_MFVec3f_delete
   (JNIEnv *env, jobject obj, jint n)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
     if (!mfv) return;
     if (!(size_t(n) < mfv->value.size())) {
         env->ExceptionDescribe();
@@ -6281,8 +6281,8 @@
                                                      jobjectArray value)
 {
     try {
-        mfvec3f * const mfv =
-                static_cast<mfvec3f *>(getFieldValue(env, obj));
+        openvrml::mfvec3f * const mfv =
+                static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
         if (!mfv) return;
         mfv->value.resize(env->GetArrayLength(value)); // Throws bad_alloc.
 
@@ -6320,8 +6320,8 @@
                                                     jfloatArray value)
 {
     try {
-        mfvec3f * const mfv =
-                static_cast<mfvec3f *>(getFieldValue(env, obj));
+        openvrml::mfvec3f * const mfv =
+                static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
         if (!mfv) return;
         mfv->value.resize(size); // Throws std::bad_alloc.
         jfloat * const vecs = env->GetFloatArrayElements(value, 0);
@@ -6363,9 +6363,9 @@
                                                         jobject obj,
                                                         jobject value)
 {
-    mfvec3f * const mfv = static_cast<mfvec3f *>(getFieldValue(env, obj));
-    const mfvec3f * const newMFVec3f =
-            static_cast<mfvec3f *>(getFieldValue(env, value));
+    openvrml::mfvec3f * const mfv = static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
+    const openvrml::mfvec3f * const newMFVec3f =
+            static_cast<openvrml::mfvec3f *>(getFieldValue(env, value));
     if (!mfv || !newMFVec3f) return;
     try {
         *mfv = *newMFVec3f; // Throws bad_alloc.
@@ -6391,7 +6391,7 @@
 void JNICALL Java_vrml_field_MFVec3f_set1Value__IFFF
   (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y, jfloat z)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         mfv->value.at(index) = vec3f(x, y, z);
@@ -6412,8 +6412,8 @@
 Java_vrml_field_MFVec3f_set1Value__ILvrml_field_ConstSFVec3f_2
   (JNIEnv *env, jobject obj, jint index, jobject sfvec3fObj)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
-    sfvec3f* sfv = static_cast<sfvec3f*>(getFieldValue(env, sfvec3fObj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
+    openvrml::sfvec3f* sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, sfvec3fObj));
     if (!mfv || !sfv) return;
     try {
         mfv->value.at(index) = sfv->value;
@@ -6450,7 +6450,7 @@
 void JNICALL Java_vrml_field_MFVec3f_addValue__FFF
   (JNIEnv *env, jobject obj, jfloat x, jfloat y, jfloat z)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
     if (!mfv) return;
     try {
         mfv->value.push_back(vec3f(x, y, z));
@@ -6477,8 +6477,8 @@
 Java_vrml_field_MFVec3f_addValue__Lvrml_field_ConstSFVec3f_2
   (JNIEnv *env, jobject obj, jobject sfvec3fObj)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
-    sfvec3f* sfv = static_cast<sfvec3f*>(getFieldValue(env, sfvec3fObj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
+    openvrml::sfvec3f* sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, sfvec3fObj));
     if (!mfv || !sfv) return;
     try {
         mfv->value.push_back(sfv->value);
@@ -6516,7 +6516,7 @@
                                                        jfloat y,
                                                        jfloat z)
 {
-    mfvec3f* mfv = static_cast<mfvec3f*>(getFieldValue(env, obj));
+    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
     if (!mfv) { return; }
     if (!(size_t(index) < mfv->value.size())) {
         env->ExceptionDescribe();
@@ -6547,7 +6547,7 @@
 Java_vrml_field_MFVec3f_insertValue__ILvrml_field_ConstSFVec3f_2
   (JNIEnv *env, jobject obj, jint index, jobject sfvec3fObj)
 {
-    sfvec3f* sfv = static_cast<sfvec3f*>(getFieldValue(env, sfvec3fObj));
+    openvrml::sfvec3f* sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, sfvec3fObj));
     if (!sfv) { return; }
     Java_vrml_field_MFVec3f_insertValue__IFFF(env, obj, index,
                                               sfv->value.x(),
diff -Naur openvrml-0.14.3-a/src/libopenvrml/openvrml/scope.h openvrml-0.14.3-b/src/libopenvrml/openvrml/scope.h
--- src/libopenvrml/openvrml/scope.h	2005-11-16 08:21:43.000000000 +0000
+++ src/libopenvrml/openvrml/scope.h	2005-11-16 08:21:43.000000000 +0000
@@ -28,6 +28,7 @@
 #   include <string>
 #   include <openvrml/node_type_ptr.h>
 #   include <openvrml/scope_ptr.h>
+#   include <openvrml/node.h>
 
 namespace openvrml {
 
diff -Naur openvrml-0.14.3-a/src/libopenvrml/openvrml/script.cpp openvrml-0.14.3-b/src/libopenvrml/openvrml/script.cpp
--- src/libopenvrml/openvrml/script.cpp	2005-11-16 08:21:43.000000000 +0000
+++ src/libopenvrml/openvrml/script.cpp	2005-11-16 08:21:43.000000000 +0000
@@ -1856,7 +1856,7 @@
 
     case field_value::sfcolor_id:
         {
-            using openvrml::sfcolor
+            using openvrml::sfcolor;
             const sfcolor & c = static_cast<const sfcolor &>(fieldValue);
             if (!SFColor::toJsval(c.value, this->cx, globalObj, &rval)) {
                 rval = JSVAL_NULL;
@@ -3056,7 +3056,7 @@
 
         auto_ptr<openvrml::sfcolor>
             sfcolor(new openvrml::sfcolor(color(rgb[0], rgb[1], rgb[2])));
-        auto_ptr<sfdata> sfdata(new sfdata(sfcolor.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfcolor.get()));
         sfcolor.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -3236,7 +3236,7 @@
         std::auto_ptr<openvrml::sfimage>
                 sfimageClone(static_cast<openvrml::sfimage *>
                     (sfimage.clone().release()));
-        std::auto_ptr<sfdata> sfdata(new sfdata(sfimageClone.get()));
+        std::auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfimageClone.get()));
         sfimageClone.release();
         if (!JS_SetPrivate(cx, sfimageObj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -3355,7 +3355,7 @@
 
         auto_ptr<openvrml::sfimage>
             sfimage(new openvrml::sfimage(x, y, comp, &pixels[0]));
-        auto_ptr<sfdata> sfdata(new sfdata(sfimage.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfimage.get()));
         sfimage.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -3483,7 +3483,7 @@
         using std::auto_ptr;
 
         auto_ptr<openvrml::sfnode> sfnodeClone(new openvrml::sfnode(node));
-        auto_ptr<sfdata> sfdata(new sfdata(sfnodeClone.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnodeClone.get()));
         sfnodeClone.release();
         if (!JS_SetPrivate(cx, sfnodeObj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -3573,7 +3573,7 @@
     try {
         using std::auto_ptr;
         auto_ptr<openvrml::sfnode> sfnode(new openvrml::sfnode(nodes[0]));
-        auto_ptr<sfdata> sfdata(new sfdata(sfnode.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnode.get()));
         sfnode.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -3863,7 +3863,7 @@
     try {
         auto_ptr<openvrml::sfrotation>
             sfrotation(new openvrml::sfrotation(rotation(x, y, z, angle)));
-        auto_ptr<sfdata> sfdata(new sfdata(sfrotation.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfrotation.get()));
         sfrotation.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -4325,7 +4325,7 @@
 
         auto_ptr<openvrml::sfvec2f>
             sfvec2f(new openvrml::sfvec2f(vec2f(x, y)));
-        auto_ptr<sfdata> sfdata(new sfdata(sfvec2f.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec2f.get()));
         sfvec2f.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();
@@ -4816,7 +4816,7 @@
 
         auto_ptr<openvrml::sfvec3f>
             sfvec3f(new openvrml::sfvec3f(vec3f(vec[0], vec[1], vec[2])));
-        auto_ptr<sfdata> sfdata(new sfdata(sfvec3f.get()));
+        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec3f.get()));
         sfvec3f.release();
         if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
         sfdata.release();