Attachment #86599 for bug #88970

View | Details | Raw Unified | Return to bug 88970
Collapse All | Expand All




 */
void ScriptJDK::initialize(const double timestamp)
{
  const openvrml::sftime arg(timestamp);
  const field_value * argv[] = { &arg };
  this->activate(timestamp, "initialize", 1, argv);
}

                              const field_value & value,
                              const double timestamp)
{
  const openvrml::sftime timestampArg(timestamp);
  const field_value * argv[] = { &value, &timestampArg };
  this->activate(timestamp, id, 2, argv);
}

 */
void ScriptJDK::events_processed(const double timestamp)
{
  const openvrml::sftime arg(timestamp);
  const field_value * argv[] = { &arg };
  this->activate(timestamp, "eventsProcessed", 1, argv);
}

 */
void ScriptJDK::shutdown(const double timestamp)
{
  const openvrml::sftime arg(timestamp);
  const field_value * argv[] = { &arg };
  this->activate(timestamp, "shutdown", 1, argv);
}

    case field_value::invalid_type_id:
      return NULL;
    case field_value::sfbool_id:
      return new openvrml::sfbool;
    case field_value::sfcolor_id:
      return new openvrml::sfcolor;
    case field_value::sffloat_id:
      return new openvrml::sffloat;
    case field_value::sfimage_id:
      return new sfimage;
    case field_value::sfint32_id:
      return new openvrml::sfint32;
    case field_value::sfnode_id:
      return new sfnode;
    case field_value::sfrotation_id:
      return new openvrml::sfrotation;
    case field_value::sfstring_id:
      return new sfstring;
    case field_value::sftime_id:
      return new openvrml::sftime;
    case field_value::sfvec2f_id:
      return new openvrml::sfvec2f;
    case field_value::sfvec3f_id:
      return new openvrml::sfvec3f;
    case field_value::mfcolor_id:
      return new openvrml::mfcolor;
    case field_value::mffloat_id:
      return new openvrml::mffloat;
    case field_value::mfint32_id:
      return new openvrml::mfint32;
    case field_value::mfnode_id:
      return new openvrml::mfnode;
    case field_value::mfrotation_id:
      return new openvrml::mfrotation;
    case field_value::mfstring_id:
      return new openvrml::mfstring;
    case field_value::mftime_id:
      return new openvrml::mftime;
    case field_value::mfvec2f_id:
      return new openvrml::mfvec2f;
    case field_value::mfvec3f_id:
      return new openvrml::mfvec3f;
    default:
      return NULL;
  }

    try {
        jfieldID fid = getFid(env, obj, "FieldPtr", "I");
        if (!fid) { return; }
        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();

jboolean JNICALL Java_vrml_field_ConstSFBool_getValue(JNIEnv * env,
                                                      jobject obj)
{
    openvrml::sfbool * sfb = static_cast<openvrml::sfbool *>(getFieldValue(env, obj));
    if (!sfb) { return false; }
    return sfb->value;
}

                                                jobject obj,
                                                jboolean value)
{
    openvrml::sfbool * sfb = static_cast<openvrml::sfbool *>(getFieldValue(env, obj));
    if (!sfb) { return; }
    sfb->value = value;
}

Java_vrml_field_SFBool_setValue__Lvrml_field_ConstSFBool_2
  (JNIEnv *env, jobject obj, jobject value)
{
  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;
}

    try {
        jfieldID fid = getFid(env, obj, "FieldPtr", "I");
        if (!fid) { return; }
        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();

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, obj));
    if (!sfc) { return; }
    env->SetFloatArrayRegion(jarr, 0, 3,
                             const_cast<float *>(&sfc->value[0]));

 */
jfloat JNICALL Java_vrml_field_ConstSFColor_getRed(JNIEnv * env, jobject obj)
{
    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
    if (!sfc) { return 0.0; }
    return sfc->value.r();
}

jfloat JNICALL Java_vrml_field_ConstSFColor_getGreen(JNIEnv * env,
                                                     jobject obj)
{
    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
    if (!sfc) { return 0.0; }
    return sfc->value.g();
}

 */
jfloat JNICALL Java_vrml_field_ConstSFColor_getBlue(JNIEnv * env, jobject obj)
{
    openvrml::sfcolor * sfc = static_cast<openvrml::sfcolor *>(getFieldValue(env, obj));
    if (!sfc) { return 0.0; }
    return sfc->value.b();
}

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    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]);

void JNICALL Java_vrml_field_SFColor_setValue__FFF
  (JNIEnv *env, jobject obj, jfloat r, jfloat g, jfloat b)
{
    openvrml::sfcolor* sfc = static_cast<openvrml::sfcolor*>(getFieldValue(env, obj));
    if (!sfc) { return; }
    sfc->value = color(r, g, b);
}

Java_vrml_field_SFColor_setValue__Lvrml_field_ConstSFColor_2
  (JNIEnv *env, jobject obj, jobject value)
{
    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;
}

    try {
        jfieldID fid = getFid(env, obj, "FieldPtr", "I");
        if (!fid) { return; }
        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();

jfloat JNICALL Java_vrml_field_ConstSFFloat_getValue(JNIEnv * env,
                                                     jobject obj)
{
    openvrml::sffloat * sff = static_cast<openvrml::sffloat *>(getFieldValue(env, obj));
    if (!sff) { return 0.0; }
    return sff->value;
}

                                                 jobject obj,
                                                 jfloat f)
{
    openvrml::sffloat * sff = static_cast<openvrml::sffloat *>(getFieldValue(env, obj));
    if (!sff) { return; }
    sff->value = f;
}

Java_vrml_field_SFFloat_setValue__Lvrml_field_ConstSFFloat_2
  (JNIEnv *env, jobject obj, jobject 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;
}

    try {
        jfieldID fid = getFid(env, obj, "FieldPtr", "I");
        if (!fid) { return; }
        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();

 */
jint JNICALL Java_vrml_field_ConstSFInt32_getValue(JNIEnv * env, jobject obj)
{
    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, obj));
    if (!sfi) { return 0; }
    return jint(sfi->value);
}

                                                 jobject obj,
                                                 jint value)
{
    openvrml::sfint32 * sfi = static_cast<openvrml::sfint32*>(getFieldValue(env, obj));
    if (!sfi) { return; }
    sfi->value = value;
}

                                                             jobject obj,
                                                             jobject 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;
}

   jfloat axisZ, jfloat angle)
{
    try {
        std::auto_ptr<openvrml::sfrotation> sfrotation(new openvrml::sfrotation(rotation(axisX,
                                                                     axisY,
                                                                     axisZ,
                                                                     angle)));

                                                      jobject obj,
                                                      jfloatArray jarr)
{
    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
    if (!sfr) { return; }
    env->SetFloatArrayRegion(jarr, 0, 4,
                             const_cast<float *>(&sfr->value[0]));

                                                      jobject obj,
                                                      jfloatArray jarr)
{
    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]);

                                                       jfloat axisZ,
                                                       jfloat angle)
{
    openvrml::sfrotation * sfr = static_cast<openvrml::sfrotation*>(getFieldValue(env, obj));
    if (!sfr) { return; }
    sfr->value = rotation(axisX, axisY, axisZ, angle);
}

    jobject obj,
    jobject 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;
}

  (JNIEnv *env, jobject obj, jdouble time)
{
    try {
        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()));

 */
jdouble JNICALL Java_vrml_field_ConstSFTime_getValue(JNIEnv * env, jobject obj)
{
    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, obj));
    if (!sft) { return 0.0; }
    return jdouble(sft->value);
}

                                                jobject obj,
                                                jdouble time)
{
    openvrml::sftime * sft = static_cast<openvrml::sftime*>(getFieldValue(env, obj));
    if (!sft) { return; }
    sft->value = time;
}

                                                           jobject obj,
                                                           jobject 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;
}

  (JNIEnv *env, jobject obj, jfloat x, jfloat y)
{
    try {
        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()));

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f *>(getFieldValue(env, obj));
    if (!sfv) { return; }
    env->SetFloatArrayRegion(jarr, 0, 2, const_cast<float *>(&sfv->value[0]));
}

 */
jfloat JNICALL Java_vrml_field_ConstSFVec2f_getX(JNIEnv * env, jobject obj)
{
    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
    if (!sfv) { return 0.0; }
    return sfv->value.x();
}

 */
jfloat JNICALL Java_vrml_field_ConstSFVec2f_getY(JNIEnv * env, jobject obj)
{
    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
    if (!sfv) { return 0.0; }
    return sfv->value.y();
}

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    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]);

                                                  jfloat x,
                                                  jfloat y)
{
    openvrml::sfvec2f * sfv = static_cast<openvrml::sfvec2f*>(getFieldValue(env, obj));
    if (!sfv) return;
    sfv->value = vec2f(x, y);
}

                                                             jobject obj,
                                                             jobject 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;
}

                                                       jfloat z)
{
    try {
        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()));

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, obj));
    if (!sfv) { return; }
    env->SetFloatArrayRegion(jarr, 0, 3, const_cast<float *>(&sfv->value[0]));
}

 */
jfloat JNICALL Java_vrml_field_ConstSFVec3f_getX(JNIEnv * env, jobject obj)
{
    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
    if (!sfv) { return 0.0; }
    return sfv->value.x();
}

 */
jfloat JNICALL Java_vrml_field_ConstSFVec3f_getY(JNIEnv * env, jobject obj)
{
    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
    if (!sfv) { return 0.0; }
    return sfv->value.y();
}

 */
jfloat JNICALL Java_vrml_field_ConstSFVec3f_getZ(JNIEnv * env, jobject obj)
{
    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f *>(getFieldValue(env, obj));
    if (!sfv) { return 0.0; }
    return sfv->value.z();
}

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    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]);

                                                   jfloat y,
                                                   jfloat z)
{
    openvrml::sfvec3f * sfv = static_cast<openvrml::sfvec3f*>(getFieldValue(env, obj));
    if (!sfv) { return; }
    sfv->value = vec3f(x, y, z);
}

                                                             jobject obj,
                                                             jobject 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.
}

    jobjectArray jarr)
{
    try {
        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()));

                                                             jfloatArray jarr)
{
    try {
        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()));


jint JNICALL Java_vrml_field_ConstMFColor_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
    if (!mfc) { return 0; }
    return mfc->value.size();
}

                                                          jobject obj,
                                                          jobjectArray jarr)
{
    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 =

                                                        jobject obj,
                                                        jfloatArray jarr)
{
    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 =

                                                          jint element,
                                                          jfloatArray jarr)
{
    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
    if (!mfc) { return; }
    try {
        jfloat * const arrayRegion =

        jint element,
        jobject sfcolorObj)
{
    const openvrml::mfcolor * const mfc =
        static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
    if (!mfc) return;
    openvrml::sfcolor * const sfc =
        static_cast<openvrml::sfcolor *>(getFieldValue(env, sfcolorObj));
    if (!sfc) { return; }
    try {
        sfc->value = mfc->value.at(element);


void JNICALL Java_vrml_field_MFColor_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor *>(getFieldValue(env, obj));
    if (!mfc) { return; }
    mfc->value.clear();
}

                                            jobject obj,
                                            jint index)
{
    openvrml::mfcolor * const mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
    if (!mfc) { return; }
    if (!(size_t(index) < mfc->value.size())) {
        env->ExceptionDescribe();

                                                     jobjectArray value)
{
    try {
        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) {

                                                    jfloatArray value)
{
    try {
        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);

                                                        jobject obj,
                                                        jobject 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.

    jint index,
    jobject 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;

  (JNIEnv *env, jobject obj, jint index, jfloat red, jfloat green,
   jfloat blue)
{
    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
    if (!mfc) { return; }
    try {
        mfc->value.at(index) = color(red, green, blue);

    jobject obj,
    jobject 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);

                                                   jfloat green,
                                                   jfloat blue)
{
    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
    if (!mfc) { return; }
    try {
        mfc->value.push_back(color(red, green, blue));

    jint index,
    jobject 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(),

                                                       jfloat green,
                                                       jfloat blue)
{
    openvrml::mfcolor * mfc = static_cast<openvrml::mfcolor*>(getFieldValue(env, obj));
    if (!mfc) { return; }
    if (!(size_t(index) < mfc->value.size())) {
        env->ExceptionDescribe();

{
    try {
        jfloat *pjf = env->GetFloatArrayElements(value, NULL);
        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; }

}

jint JNICALL Java_vrml_field_ConstMFFloat_getSize(JNIEnv * env, jobject obj) {
    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
    if (!mff) return 0;
    return mff->value.size();
}

                                                   jobject obj,
                                                   jfloatArray jarr)
{
    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) {

                                                      jobject obj,
                                                      jint index)
{
    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
    if (!mff) { return 0.0; }
    return mff->value[index];
}


void JNICALL Java_vrml_field_MFFloat_clear(JNIEnv * env, jobject obj)
{
    openvrml::mffloat * const mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
    if (!mff) { return; }
    mff->value.clear();
}

                                            jobject obj,
                                            jint index)
{
    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
    if (!mff) { return; }
    if (!(size_t(index) < mff->value.size())) {
        env->ExceptionDescribe();

                                                    jfloatArray value)
{
    try {
        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);

                                                        jobject obj,
                                                        jobject 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.

                                                   jint index,
                                                   jfloat value)
{
    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
    mff->value[index] = value;
}


Java_vrml_field_MFFloat_set1Value__ILvrml_field_ConstSFFloat_2
  (JNIEnv *env, jobject obj, jint index, jobject 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;
}

                                                 jobject obj,
                                                 jfloat value)
{
    openvrml::mffloat * mff = static_cast<openvrml::mffloat*>(getFieldValue(env, obj));
    if (!mff) { return; }
    try {
        mff->value.push_back(value);

                                                             jobject obj,
                                                             jobject 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);

                                                     jint index,
                                                     jfloat value)
{
    openvrml::mffloat * mff = static_cast<openvrml::mffloat *>(getFieldValue(env, obj));
    if (!mff) { return; }
    if (!(size_t(index) < mff->value.size())) {
        env->ExceptionDescribe();

                                                                 jint index,
                                                                 jobject 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);
}

{
    try {
        jint * pji = env->GetIntArrayElements(value, NULL);
        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; }


jint JNICALL Java_vrml_field_ConstMFInt32_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
    if (!mfi) return 0;
    return mfi->value.size();
}

                                                   jobject obj,
                                                   jintArray jarr)
{
    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) {

                                                    jobject obj,
                                                    jint index)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
    if (!mfi) { return 0; }
    return mfi->value[index];
}


void JNICALL Java_vrml_field_MFInt32_clear(JNIEnv * env, jobject 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)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
    if (!mfi) { return; }
    if (!(size_t(n) < mfi->value.size())) {
        env->ExceptionDescribe();

                                                    jintArray value)
{
    try {
        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);

                                                        jobject obj,
                                                        jobject 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.

                                                   jint index,
                                                   jint value)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
    if (!mfi) { return; }
    mfi->value[index] = value;
}

    jint index,
    jobject 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;
}

                                                 jobject obj,
                                                 jint value)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32 *>(getFieldValue(env, obj));
    if (!mfi) { return; }
    try {
        mfi->value.push_back(value);

                                                             jobject obj,
                                                             jobject 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);

                                                     jint index,
                                                     jint value)
{
    openvrml::mfint32 * mfi = static_cast<openvrml::mfint32*>(getFieldValue(env, obj));
    if (!mfi) { return; }
    if (!(size_t(index) < mfi->value.size())) {
        env->ExceptionDescribe();

                                                                 jint index,
                                                                 jobject 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);
}

  (JNIEnv *env, jobject obj, jint size, jobjectArray jarr)
{
    try {
        std::auto_ptr<openvrml::mfnode> mfnode(new openvrml::mfnode(size));
        jfieldID fid;

        for (jint i = 0; i < size; i++) {


jint JNICALL Java_vrml_field_ConstMFNode_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode *>(getFieldValue(env, obj));
    if (!mfn) { return 0; }
    return mfn->value.size();
}

                                                  jobject obj,
                                                  jobjectArray basenode)
{
    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");

                                                      jobject obj,
                                                      jint index)
{
    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);


void JNICALL Java_vrml_field_MFNode_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    if (!mfn) { return; }
    mfn->value.clear();
}

                                           jobject obj,
                                           jint index)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    if (!mfn) { return; }
    if (!(size_t(index) < mfn->value.size())) {
        env->ExceptionDescribe();

                                                      jobject obj,
                                                      jobject 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 {

                                                                 jint pos,
                                                                 jobject value)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    if (!mfn) { return; }
    jfieldID fid = getFid(env, value, "NodePtr", "I");
    if (!fid) { return; }

    jint index,
    jobject sfnode_object)
{
    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;

                                                               jobject obj,
                                                               jobject value)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    if (!mfn) { return; }
    jfieldID fid = getFid(env, value, "NodePtr", "I");
    if (!fid) { return; }

                                                           jobject obj,
                                                           jobject value)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    sfnode * sfn = static_cast<sfnode*>(getFieldValue(env, value));
    if (!mfn || !sfn) { return; }
    try {

                                                      jint index,
                                                      jobject value)
{
    openvrml::mfnode * mfn = static_cast<openvrml::mfnode*>(getFieldValue(env, obj));
    if (!mfn) { return; }
    jfieldID fid = getFid(env, value, "NodePtr", "I");
    if (!fid) { return; }

                                                               jint index,
                                                               jobject value)
{
    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())) {

                                                    jobjectArray jarr)
{
    try {
        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()));

                                                   jfloatArray jarr)
{
    try {
        std::auto_ptr<openvrml::mfrotation> mfrotation(new openvrml::mfrotation(size));
        jfieldID fid = getFid(env, obj, "FieldPtr", "I");
        if (!fid) { return; }
        env->SetIntField(obj, fid,

jint JNICALL Java_vrml_field_ConstMFRotation_getSize(JNIEnv * env,
                                                     jobject obj)
{
    openvrml::mfrotation * mfrot =
        static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
    if (!mfrot) { return 0; }
    return mfrot->value.size();
}

                                                             jobject obj,
                                                             jobjectArray jarr)
{
    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));

                                                           jobject obj,
                                                           jfloatArray jarr)
{
    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]));

                                                             jint element,
                                                             jfloatArray jarr)
{
    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
    env->SetFloatArrayRegion(jarr, 0, 4,
                             const_cast<jfloat*>(&mfrot->value[element][0]));
}

        jint element,
        jobject sfrotationObj)
{
    const openvrml::mfrotation * const mfrot =
            static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    openvrml::sfrotation * const sfrot =
            static_cast<openvrml::sfrotation *>(getFieldValue(env, sfrotationObj));
    if (!sfrot) { return; }
    try {
        sfrot->value = mfrot->value[element];


void JNICALL Java_vrml_field_MFRotation_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfrotation * const mfrot =
        static_cast<openvrml::mfrotation *>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    mfrot->value.clear(); // Shouldn't throw bad_alloc.
}

                                               jobject obj,
                                               jint index)
{
    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    if (!(size_t(index) < mfrot->value.size())) {
        env->ExceptionDescribe();

                                                        jobjectArray value)
{
    try {
        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) {

                                                       jfloatArray value)
{
    try {
        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);

                                                              jobject obj,
                                                              jobject 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.

    jint index,
    jobject 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;
}

                                                         jfloat axisZ,
                                                         jfloat angle)
{
    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    mfrot->value[index] = rotation(axisX, axisY, axisZ, angle);
}

        jobject obj,
        jobject 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);

                                                       jfloat axisZ,
                                                       jfloat angle)
{
    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    try {
        mfrot->value.push_back(rotation(axisX, axisY, axisZ, angle));

    jint index,
    jobject 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(),

                                                           jfloat axisZ,
                                                           jfloat angle)
{
    openvrml::mfrotation * mfrot = static_cast<openvrml::mfrotation*>(getFieldValue(env, obj));
    if (!mfrot) { return; }
    if (!(size_t(index) < mfrot->value.size())) {
        env->ExceptionDescribe();

  (JNIEnv *env, jobject obj, jint size, jobjectArray jarr)
{
    try {
        std::auto_ptr<openvrml::mfstring> mfstring(new openvrml::mfstring(size));

        for (jint i = 0; i < size; i++) {
            jstring el = (jstring) env->GetObjectArrayElement(jarr, i);


jint JNICALL Java_vrml_field_ConstMFString_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring *>(getFieldValue(env, obj));
    if (!mfstr) { return 0; }
    return mfstr->value.size();
}

                                                    jobject obj,
                                                    jobjectArray jarr)
{
    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;

                                                        jobject obj,
                                                        jint index)
{
    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;


void JNICALL Java_vrml_field_MFString_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    if (!mfstr) { return; }
    mfstr->value.clear();
}

                                             jobject obj,
                                             jint index)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    if (!mfstr) { return; }
    if (!(size_t(index) < mfstr->value.size())) {
        env->ExceptionDescribe();

                                                          jobjectArray jarr)
{
    try {
        openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
        if (!mfstr) { return; }

        jsize entries = env->GetArrayLength(jarr);

                                                          jobject obj,
                                                          jobject 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 {

                                                         jint index,
                                                         jstring value)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    if (!mfstr) { return; }
    const char * utf8chars = env->GetStringUTFChars(value, 0);
    if (!utf8chars) { return; } // OutOfMemoryError

    jint index,
    jobject sfstring_object)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    sfstring * sfstr =
        static_cast<sfstring*>(getFieldValue(env, sfstring_object));
    if (!mfstr || !sfstr) { return; }

                                                       jobject obj,
                                                       jstring value)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    if (!mfstr) { return; }
    const char * utf8chars = env->GetStringUTFChars(value, 0);
    if (!utf8chars) { return; } // OutOfMemoryError

    jobject obj,
    jobject sfstring_object)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    sfstring * sfstr =
        static_cast<sfstring*>(getFieldValue(env, sfstring_object));
    if (!mfstr || !sfstr) { return; }

                                                           jint index,
                                                           jstring value)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    if (!mfstr) { return; }
    const char * utf8chars = env->GetStringUTFChars(value, 0);
    if (!utf8chars) { return; } // OutOfMemoryError

    jint index,
    jobject sfstring_object)
{
    openvrml::mfstring * mfstr = static_cast<openvrml::mfstring*>(getFieldValue(env, obj));
    sfstring * sfstr =
        static_cast<sfstring*>(getFieldValue(env, sfstring_object));
    if (!mfstr || !sfstr) { return; }

{
    try {
        jdouble *pjd = env->GetDoubleArrayElements(value, 0);
        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; }


jint JNICALL Java_vrml_field_ConstMFTime_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
    if (!mft) { return 0; }
    return mft->value.size();
}

                                                  jobject obj,
                                                  jdoubleArray jarr)
{
    openvrml::mftime * const mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
    if (!mft) { return; }
    const size_t size = mft->value.size();
    if (size > 0) {

                                                      jobject obj,
                                                      jint index)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
    if (!mft) { return 0.0; }
    jdouble retval;
    try {


void JNICALL Java_vrml_field_MFTime_clear(JNIEnv * env, jobject obj)
{
    openvrml::mftime * const mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
    if (!mft) { return; }
    mft->value.clear();
}

                                           jobject obj,
                                           jint index)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
    if (!mft) { return; }
    if (!(size_t(index) < mft->value.size())) {
        env->ExceptionDescribe();

                                                   const jdoubleArray value)
{
    try {
        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);

                                                      jobject obj,
                                                      jobject 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.

                                                  jint index,
                                                  jdouble value)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
    if (!mft) { return; }
    try {
        mft->value.at(index) = value;

    jint index,
    jobject 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;

                                                jobject obj,
                                                jdouble value)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime *>(getFieldValue(env, obj));
    if (!mft) { return; }
    try {
        mft->value.push_back(value);

    jobject obj,
    jobject 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);

                                                    jint index,
                                                    jdouble value)
{
    openvrml::mftime * mft = static_cast<openvrml::mftime*>(getFieldValue(env, obj));
    if (!mft) { return; }
    try {
        mft->value.insert(mft->value.begin() + index, value);

    jint index,
    jobject 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);

                                                              jobjectArray jarr)
{
    try {
        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()));

                                                             jfloatArray jarr)
{
    try {
        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()));


jint JNICALL Java_vrml_field_ConstMFVec2f_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfvec2f * mfv = static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
    if (!mfv) { return 0; }
    return mfv->value.size();
}

                                                          jobject obj,
                                                          jobjectArray jarr)
{
    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 =

                                                        jobject obj,
                                                        jfloatArray jarr)
{
    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,

void JNICALL Java_vrml_field_ConstMFVec2f_get1Value__I_3F
  (JNIEnv *env, jobject obj, jint element, jfloatArray jarr)
{
    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        jfloat * const arrayRegion =

        jint element,
        jobject sfvec2f_object)
{
    const openvrml::mfvec2f * const mfv =
            static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
    if (!mfv) return;
    openvrml::sfvec2f * const sfv =
        static_cast<openvrml::sfvec2f *>(getFieldValue(env, sfvec2f_object));
    if (!sfv) { return; }
    try {
        sfv->value = mfv->value.at(element);


void JNICALL Java_vrml_field_MFVec2f_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfvec2f * const mfv = static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
    if (!mfv) return;
    mfv->value.clear();
}

void JNICALL Java_vrml_field_MFVec2f_delete
  (JNIEnv *env, jobject obj, jint n)
{
    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
    if (!mfv) return;
    if (!(size_t(n) < mfv->value.size())) {
        env->ExceptionDescribe();

                                                     jobjectArray value)
{
    try {
        openvrml::mfvec2f * const mfv =
                static_cast<openvrml::mfvec2f *>(getFieldValue(env, obj));
        if (!mfv) return;
        mfv->value.resize(env->GetArrayLength(value)); // Throws bad_alloc.


                                                    jfloatArray value)
{
    try {
        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);

                                                        jobject obj,
                                                        jobject 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.

void JNICALL Java_vrml_field_MFVec2f_set1Value__IFF
  (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y)
{
    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        mfv->value.at(index) = vec2f(x, y);

Java_vrml_field_MFVec2f_set1Value__ILvrml_field_ConstSFVec2f_2
  (JNIEnv *env, jobject obj, jint index, jobject 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;

void JNICALL Java_vrml_field_MFVec2f_addValue__FF
  (JNIEnv *env, jobject obj, jfloat x, jfloat y)
{
    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        mfv->value.push_back(vec2f(x, y));

Java_vrml_field_MFVec2f_addValue__Lvrml_field_ConstSFVec2f_2
  (JNIEnv *env, jobject obj, jobject 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);

void JNICALL Java_vrml_field_MFVec2f_insertValue__IFF
  (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y)
{
    openvrml::mfvec2f* mfv = static_cast<openvrml::mfvec2f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        mfv->value.insert(mfv->value.begin() + index, vec2f(x, y));

Java_vrml_field_MFVec2f_insertValue__ILvrml_field_ConstSFVec2f_2
  (JNIEnv *env, jobject obj, jint index, jobject 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);

                                                              jobjectArray jarr)
{
    try {
        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()));

                                                             jfloatArray jarr)
{
    try {
        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()));


jint JNICALL Java_vrml_field_ConstMFVec3f_getSize(JNIEnv * env, jobject obj)
{
    openvrml::mfvec3f * mfv = static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
    if (!mfv) return 0;
    return mfv->value.size();
}

                                                          jobject obj,
                                                          jobjectArray jarr)
{
    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 =

                                                        jobject obj,
                                                        jfloatArray jarr)
{
    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,

void JNICALL Java_vrml_field_ConstMFVec3f_get1Value__I_3F
  (JNIEnv *env, jobject obj, jint element, jfloatArray jarr)
{
    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        jfloat * const arrayRegion =

        jint element,
        jobject sfvec3fObj)
{
    const openvrml::mfvec3f * const mfv =
            static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
    if (!mfv) return;
    openvrml::sfvec3f * const sfv =
            static_cast<openvrml::sfvec3f *>(getFieldValue(env, sfvec3fObj));
    if (!sfv) return;
    try {
        sfv->value = mfv->value.at(element);


void JNICALL Java_vrml_field_MFVec3f_clear(JNIEnv * env, jobject obj)
{
    openvrml::mfvec3f * const mfv = static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
    if (!mfv) return;
    mfv->value.clear();
}

void JNICALL Java_vrml_field_MFVec3f_delete
  (JNIEnv *env, jobject obj, jint n)
{
    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
    if (!mfv) return;
    if (!(size_t(n) < mfv->value.size())) {
        env->ExceptionDescribe();

                                                     jobjectArray value)
{
    try {
        openvrml::mfvec3f * const mfv =
                static_cast<openvrml::mfvec3f *>(getFieldValue(env, obj));
        if (!mfv) return;
        mfv->value.resize(env->GetArrayLength(value)); // Throws bad_alloc.


                                                    jfloatArray value)
{
    try {
        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);

                                                        jobject obj,
                                                        jobject 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.

void JNICALL Java_vrml_field_MFVec3f_set1Value__IFFF
  (JNIEnv *env, jobject obj, jint index, jfloat x, jfloat y, jfloat z)
{
    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        mfv->value.at(index) = vec3f(x, y, z);

Java_vrml_field_MFVec3f_set1Value__ILvrml_field_ConstSFVec3f_2
  (JNIEnv *env, jobject obj, jint index, jobject 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;

void JNICALL Java_vrml_field_MFVec3f_addValue__FFF
  (JNIEnv *env, jobject obj, jfloat x, jfloat y, jfloat z)
{
    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
    if (!mfv) return;
    try {
        mfv->value.push_back(vec3f(x, y, z));

Java_vrml_field_MFVec3f_addValue__Lvrml_field_ConstSFVec3f_2
  (JNIEnv *env, jobject obj, jobject 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);

                                                       jfloat y,
                                                       jfloat z)
{
    openvrml::mfvec3f* mfv = static_cast<openvrml::mfvec3f*>(getFieldValue(env, obj));
    if (!mfv) { return; }
    if (!(size_t(index) < mfv->value.size())) {
        env->ExceptionDescribe();

Java_vrml_field_MFVec3f_insertValue__ILvrml_field_ConstSFVec3f_2
  (JNIEnv *env, jobject obj, jint index, jobject 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(),

Lines 28-33 Link Here

(-)src/libopenvrml/openvrml/scope.h (+1 lines)
28	# include <string>	28	# include <string>
29	# include <openvrml/node_type_ptr.h>	29	# include <openvrml/node_type_ptr.h>
30	# include <openvrml/scope_ptr.h>	30	# include <openvrml/scope_ptr.h>
		31	# include <openvrml/node.h>
31		32
32	namespace openvrml {	33	namespace openvrml {
33		34





    case field_value::sfcolor_id:
        {
            using openvrml::sfcolor;
            const sfcolor & c = static_cast<const sfcolor &>(fieldValue);
            if (!SFColor::toJsval(c.value, this->cx, globalObj, &rval)) {
                rval = JSVAL_NULL;


        auto_ptr<openvrml::sfcolor>
            sfcolor(new openvrml::sfcolor(color(rgb[0], rgb[1], rgb[2])));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfcolor.get()));
        sfcolor.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();

        std::auto_ptr<openvrml::sfimage>
                sfimageClone(static_cast<openvrml::sfimage *>
                    (sfimage.clone().release()));
        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();


        auto_ptr<openvrml::sfimage>
            sfimage(new openvrml::sfimage(x, y, comp, &pixels[0]));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfimage.get()));
        sfimage.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();

        using std::auto_ptr;

        auto_ptr<openvrml::sfnode> sfnodeClone(new openvrml::sfnode(node));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnodeClone.get()));
        sfnodeClone.release();
        if (!JS_SetPrivate(cx, sfnodeObj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();

    try {
        using std::auto_ptr;
        auto_ptr<openvrml::sfnode> sfnode(new openvrml::sfnode(nodes[0]));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnode.get()));
        sfnode.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();

    try {
        auto_ptr<openvrml::sfrotation>
            sfrotation(new openvrml::sfrotation(rotation(x, y, z, angle)));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfrotation.get()));
        sfrotation.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();


        auto_ptr<openvrml::sfvec2f>
            sfvec2f(new openvrml::sfvec2f(vec2f(x, y)));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec2f.get()));
        sfvec2f.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();


        auto_ptr<openvrml::sfvec3f>
            sfvec3f(new openvrml::sfvec3f(vec3f(vec[0], vec[1], vec[2])));
        auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec3f.get()));
        sfvec3f.release();
        if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
        sfdata.release();

Return to bug 88970

Lines 1856-1862 Link Here

(-)src/libopenvrml/openvrml/script.cpp (-9 / +9 lines)
1856		1856
1857	case field_value::sfcolor_id:	1857	case field_value::sfcolor_id:
1858	{	1858	{
1859	using openvrml::sfcolor	1859	using openvrml::sfcolor;
1860	const sfcolor & c = static_cast<const sfcolor &>(fieldValue);	1860	const sfcolor & c = static_cast<const sfcolor &>(fieldValue);
1861	if (!SFColor::toJsval(c.value, this->cx, globalObj, &rval)) {	1861	if (!SFColor::toJsval(c.value, this->cx, globalObj, &rval)) {
1862	rval = JSVAL_NULL;	1862	rval = JSVAL_NULL;
Lines 3056-3062 Link Here
3056		3056
3057	auto_ptr<openvrml::sfcolor>	3057	auto_ptr<openvrml::sfcolor>
3058	sfcolor(new openvrml::sfcolor(color(rgb[0], rgb[1], rgb[2])));	3058	sfcolor(new openvrml::sfcolor(color(rgb[0], rgb[1], rgb[2])));
3059	auto_ptr<sfdata> sfdata(new sfdata(sfcolor.get()));	3059	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfcolor.get()));
3060	sfcolor.release();	3060	sfcolor.release();
3061	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	3061	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
3062	sfdata.release();	3062	sfdata.release();
Lines 3236-3242 Link Here
3236	std::auto_ptr<openvrml::sfimage>	3236	std::auto_ptr<openvrml::sfimage>
3237	sfimageClone(static_cast<openvrml::sfimage *>	3237	sfimageClone(static_cast<openvrml::sfimage *>
3238	(sfimage.clone().release()));	3238	(sfimage.clone().release()));
3239	std::auto_ptr<sfdata> sfdata(new sfdata(sfimageClone.get()));	3239	std::auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfimageClone.get()));
3240	sfimageClone.release();	3240	sfimageClone.release();
3241	if (!JS_SetPrivate(cx, sfimageObj, sfdata.get())) { return JS_FALSE; }	3241	if (!JS_SetPrivate(cx, sfimageObj, sfdata.get())) { return JS_FALSE; }
3242	sfdata.release();	3242	sfdata.release();
Lines 3355-3361 Link Here
3355		3355
3356	auto_ptr<openvrml::sfimage>	3356	auto_ptr<openvrml::sfimage>
3357	sfimage(new openvrml::sfimage(x, y, comp, &pixels[0]));	3357	sfimage(new openvrml::sfimage(x, y, comp, &pixels[0]));
3358	auto_ptr<sfdata> sfdata(new sfdata(sfimage.get()));	3358	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfimage.get()));
3359	sfimage.release();	3359	sfimage.release();
3360	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	3360	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
3361	sfdata.release();	3361	sfdata.release();
Lines 3483-3489 Link Here
3483	using std::auto_ptr;	3483	using std::auto_ptr;
3484		3484
3485	auto_ptr<openvrml::sfnode> sfnodeClone(new openvrml::sfnode(node));	3485	auto_ptr<openvrml::sfnode> sfnodeClone(new openvrml::sfnode(node));
3486	auto_ptr<sfdata> sfdata(new sfdata(sfnodeClone.get()));	3486	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnodeClone.get()));
3487	sfnodeClone.release();	3487	sfnodeClone.release();
3488	if (!JS_SetPrivate(cx, sfnodeObj, sfdata.get())) { return JS_FALSE; }	3488	if (!JS_SetPrivate(cx, sfnodeObj, sfdata.get())) { return JS_FALSE; }
3489	sfdata.release();	3489	sfdata.release();
Lines 3573-3579 Link Here
3573	try {	3573	try {
3574	using std::auto_ptr;	3574	using std::auto_ptr;
3575	auto_ptr<openvrml::sfnode> sfnode(new openvrml::sfnode(nodes[0]));	3575	auto_ptr<openvrml::sfnode> sfnode(new openvrml::sfnode(nodes[0]));
3576	auto_ptr<sfdata> sfdata(new sfdata(sfnode.get()));	3576	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfnode.get()));
3577	sfnode.release();	3577	sfnode.release();
3578	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	3578	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
3579	sfdata.release();	3579	sfdata.release();
Lines 3863-3869 Link Here
3863	try {	3863	try {
3864	auto_ptr<openvrml::sfrotation>	3864	auto_ptr<openvrml::sfrotation>
3865	sfrotation(new openvrml::sfrotation(rotation(x, y, z, angle)));	3865	sfrotation(new openvrml::sfrotation(rotation(x, y, z, angle)));
3866	auto_ptr<sfdata> sfdata(new sfdata(sfrotation.get()));	3866	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfrotation.get()));
3867	sfrotation.release();	3867	sfrotation.release();
3868	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	3868	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
3869	sfdata.release();	3869	sfdata.release();
Lines 4325-4331 Link Here
4325		4325
4326	auto_ptr<openvrml::sfvec2f>	4326	auto_ptr<openvrml::sfvec2f>
4327	sfvec2f(new openvrml::sfvec2f(vec2f(x, y)));	4327	sfvec2f(new openvrml::sfvec2f(vec2f(x, y)));
4328	auto_ptr<sfdata> sfdata(new sfdata(sfvec2f.get()));	4328	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec2f.get()));
4329	sfvec2f.release();	4329	sfvec2f.release();
4330	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	4330	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
4331	sfdata.release();	4331	sfdata.release();
Lines 4816-4822 Link Here
4816		4816
4817	auto_ptr<openvrml::sfvec3f>	4817	auto_ptr<openvrml::sfvec3f>
4818	sfvec3f(new openvrml::sfvec3f(vec3f(vec[0], vec[1], vec[2])));	4818	sfvec3f(new openvrml::sfvec3f(vec3f(vec[0], vec[1], vec[2])));
4819	auto_ptr<sfdata> sfdata(new sfdata(sfvec3f.get()));	4819	auto_ptr<sfield::sfdata> sfdata(new sfield::sfdata(sfvec3f.get()));
4820	sfvec3f.release();	4820	sfvec3f.release();
4821	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }	4821	if (!JS_SetPrivate(cx, obj, sfdata.get())) { return JS_FALSE; }
4822	sfdata.release();	4822	sfdata.release();