;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2 of the License, or
;;; (at your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program; if not, write to the Free Software
;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "inventor/inventor-config")



#? *** fields

;; dummy function that adds inventor header files in C file
(eval `(de |dummy_fields| () ,inventor-cpheader-cmd ()))

#? * sofield
;;.TYPE CLASS
#? (==> <sofield> setignored <ig>)
#? (==> <sofield> isignored)
#? (==> <sofield> isdefault)
#? (==> <sofield> isoftype <type>)
#? (==> <sofield> enableconnection <flag>)
#? (==> <sofield> isconnectionenabled)
#? (==> <sofield> connectfrom-engine <engineoutput>)
#? (==> <sofield> connectfrom-field <field>)
#? (==> <sofield> disconnect)
#? (==> <sofield> isconnected)
#? (==> <sofield> isconnectedfromengine)
#? (==> <sofield> isconnectedfromfield)
#? (==> <sofield> getconnectedengine <engineoutput>)
#? (==> <sofield> getconnectedfield <field>)
#? (==> <sofield> getforwardconnections <list>)
#? (==> <sofield> getcontainer)
#? (==> <sofield> set <valuestring>)
#? (==> <sofield> get <valuestring>)
#? (==> <sofield> touch)

#? * sofieldcontainer
;;.TYPE CLASS
#? (==> <sofieldcontainer> settodefaults)
#? (==> <sofieldcontainer> hasdefaultvalues)
#? (==> <sofieldcontainer> fieldsareequal <fc>)
#? (==> <sofieldcontainer> copyfieldvalues <fc> <copyconnections>)
#? (==> <sofieldcontainer> set <fielddatastring>)
#? (==> <sofieldcontainer> get <fielddatastring>)
#? (==> <sofieldcontainer> getfields <list>)
#? (==> <sofieldcontainer> getfield <fieldname>)
#? (==> <sofieldcontainer> getfieldname <field> <fieldname>)
#? (==> <sofieldcontainer> enablenotify <flag>)
#? (==> <sofieldcontainer> isnotifyenabled)

#? * sofieldlist
;;.TYPE CLASS
#? (new sofieldlist <flag>>
#? (==> <sofieldlist> -destructor)
#? (==> <sofieldlist> append <field>)
#? (==> <sofieldlist> insert <field> <addbefore>)
#? (==> <sofieldlist> set <i> <field>)

#? * somfield
;;.TYPE CLASS
#? (==> <somfield> -destructor)
#? (==> <somfield> getnum)
#? (==> <somfield> setnum <num>)
#? (==> <somfield> deletevalues <start> <num>)
#? (==> <somfield> insertspace <start> <num>)
#? (==> <somfield> set1 <index> <valuestring>)
#? (==> <somfield> get1 <index> <valuestring>)

#? * sosfield
;;.TYPE CLASS
#? (==> <sosfield> -destructor)

#? * somfbool
;;.TYPE CLASS
#? (==> <somfbool> gettypeid)
#? (new somfbool <flag>>
#? (==> <somfbool> -destructor)
#? (==> <somfbool> getvalues <start>)
#? (==> <somfbool> find <targetvalue> <addifnotfound>)
#? (==> <somfbool> setvalues <start> <num> <newvalues>)
#? (==> <somfbool> set1value <index> <newvalue>)
#? (==> <somfbool> setvalue <newvalue>)
#? (==> <somfbool> startediting)
#? (==> <somfbool> finishediting)

#? * somfcolor
;;.TYPE CLASS
#? (==> <somfcolor> gettypeid)
#? (new somfcolor <flag>>
#? (==> <somfcolor> -destructor)
#? (==> <somfcolor> getvalues <start>)
#? (==> <somfcolor> find <targetvalue> <addifnotfound>)
#? (==> <somfcolor> setvalues <start> <num> <newvalues>)
#? (==> <somfcolor> startediting)
#? (==> <somfcolor> finishediting)
#? (==> <somfcolor> setvalue <r> <g> <b>)
#? (==> <somfcolor> sethsvvalue <h> <s> <v>)
#? (==> <somfcolor> set1value <index> <r> <g> <b>)
#? (==> <somfcolor> set1hsvvalue <index> <h> <s> <v>)

#? * somfengine
;;.TYPE CLASS
#? (==> <somfengine> gettypeid)
#? (new somfengine <flag>>
#? (==> <somfengine> -destructor)
#? (==> <somfengine> getvalues <start>)
#? (==> <somfengine> find <targetvalue> <addifnotfound>)
#? (==> <somfengine> setvalues <start> <num> <newvalues>)
#? (==> <somfengine> set1value <index> <newvalue>)
#? (==> <somfengine> setvalue <newvalue>)
#? (==> <somfengine> startediting)
#? (==> <somfengine> finishediting)

#? * somfenum
;;.TYPE CLASS
#? (==> <somfenum> gettypeid)
#? (new somfenum <flag>>
#? (==> <somfenum> -destructor)
#? (==> <somfenum> getvalues <start>)
#? (==> <somfenum> find <targetvalue> <addifnotfound>)
#? (==> <somfenum> setvalues <start> <num> <newvalues>)
#? (==> <somfenum> set1value <index> <newvalue>)
#? (==> <somfenum> setvalue <newvalue>)
#? (==> <somfenum> startediting)
#? (==> <somfenum> finishediting)

#? * somffloat
;;.TYPE CLASS
#? (==> <somffloat> gettypeid)
#? (new somffloat <flag>>
#? (==> <somffloat> -destructor)
#? (==> <somffloat> getvalues <start>)
#? (==> <somffloat> find <targetvalue> <addifnotfound>)
#? (==> <somffloat> setvalues <start> <num> <newvalues>)
#? (==> <somffloat> set1value <index> <newvalue>)
#? (==> <somffloat> setvalue <newvalue>)
#? (==> <somffloat> startediting)
#? (==> <somffloat> finishediting)

#? * somfint32
;;.TYPE CLASS
#? (==> <somfint32> gettypeid)
#? (new somfint32 <flag>>
#? (==> <somfint32> -destructor)
#? (==> <somfint32> getvalues <start>)
#? (==> <somfint32> find <targetvalue> <addifnotfound>)
#? (==> <somfint32> setvalues <start> <num> <newvalues>)
#? (==> <somfint32> set1value <index> <newvalue>)
#? (==> <somfint32> setvalue <newvalue>)
#? (==> <somfint32> startediting)
#? (==> <somfint32> finishediting)

#? * somfmatrix
;;.TYPE CLASS
#? (==> <somfmatrix> gettypeid)
#? (new somfmatrix <flag>>
#? (==> <somfmatrix> -destructor)
#? (==> <somfmatrix> getvalues <start>)
#? (==> <somfmatrix> find <targetvalue> <addifnotfound>)
#? (==> <somfmatrix> setvalues <start> <num> <newvalues>)
#? (==> <somfmatrix> set1value <index> <newvalue>)
#? (==> <somfmatrix> startediting)
#? (==> <somfmatrix> finishediting)
#? (==> <somfmatrix> setvalue <a11> <a12> <a13> <a14> <a21> <a22> <a23> <a24> <a31> <a32> <a33> <a34> <a41> <a42> <a43> <a44>)

#? * somfname
;;.TYPE CLASS
#? (==> <somfname> gettypeid)
#? (new somfname <flag>>
#? (==> <somfname> -destructor)
#? (==> <somfname> getvalues <start>)
#? (==> <somfname> find <targetvalue> <addifnotfound>)
#? (==> <somfname> setvalues <start> <num> <newvalues>)
#? (==> <somfname> set1value <index> <newvalue>)
#? (==> <somfname> startediting)
#? (==> <somfname> finishediting)
#? (==> <somfname> setvalue <string>)

#? * somfnode
;;.TYPE CLASS
#? (==> <somfnode> gettypeid)
#? (new somfnode <flag>>
#? (==> <somfnode> -destructor)
#? (==> <somfnode> getvalues <start>)
#? (==> <somfnode> find <targetvalue> <addifnotfound>)
#? (==> <somfnode> setvalues <start> <num> <newvalues>)
#? (==> <somfnode> set1value <index> <newvalue>)
#? (==> <somfnode> setvalue <newvalue>)
#? (==> <somfnode> startediting)
#? (==> <somfnode> finishediting)

#? * somfpath
;;.TYPE CLASS
#? (==> <somfpath> gettypeid)
#? (new somfpath <flag>>
#? (==> <somfpath> -destructor)
#? (==> <somfpath> getvalues <start>)
#? (==> <somfpath> find <targetvalue> <addifnotfound>)
#? (==> <somfpath> setvalues <start> <num> <newvalues>)
#? (==> <somfpath> set1value <index> <newvalue>)
#? (==> <somfpath> setvalue <newvalue>)
#? (==> <somfpath> startediting)
#? (==> <somfpath> finishediting)

#? * somfplane
;;.TYPE CLASS
#? (==> <somfplane> gettypeid)
#? (new somfplane <flag>>
#? (==> <somfplane> -destructor)
#? (==> <somfplane> getvalues <start>)
#? (==> <somfplane> find <targetvalue> <addifnotfound>)
#? (==> <somfplane> setvalues <start> <num> <newvalues>)
#? (==> <somfplane> set1value <index> <newvalue>)
#? (==> <somfplane> setvalue <newvalue>)
#? (==> <somfplane> startediting)
#? (==> <somfplane> finishediting)

#? * somfrotation
;;.TYPE CLASS
#? (==> <somfrotation> gettypeid)
#? (new somfrotation <flag>>
#? (==> <somfrotation> -destructor)
#? (==> <somfrotation> getvalues <start>)
#? (==> <somfrotation> find <targetvalue> <addifnotfound>)
#? (==> <somfrotation> setvalues <start> <num> <newvalues>)
#? (==> <somfrotation> startediting)
#? (==> <somfrotation> finishediting)
#? (==> <somfrotation> set1value <index> <q0> <q1> <q2> <q3>)
#? (==> <somfrotation> setvalue <q0> <q1> <q2> <q3>)

#? * somfshort
;;.TYPE CLASS
#? (==> <somfshort> gettypeid)
#? (new somfshort <flag>>
#? (==> <somfshort> -destructor)
#? (==> <somfshort> getvalues <start>)
#? (==> <somfshort> find <targetvalue> <addifnotfound>)
#? (==> <somfshort> setvalues <start> <num> <newvalues>)
#? (==> <somfshort> set1value <index> <newvalue>)
#? (==> <somfshort> setvalue <newvalue>)
#? (==> <somfshort> startediting)
#? (==> <somfshort> finishediting)

#? * somfstring
;;.TYPE CLASS
#? (==> <somfstring> gettypeid)
#? (new somfstring <flag>>
#? (==> <somfstring> -destructor)
#? (==> <somfstring> getvalues <start>)
#? (==> <somfstring> find <targetvalue> <addifnotfound>)
#? (==> <somfstring> set1value <index> <newvalue>)
#? (==> <somfstring> startediting)
#? (==> <somfstring> finishediting)
#? (==> <somfstring> setvalues <start> <num> <strings>)
#? (==> <somfstring> setvalue <string>)
#? (==> <somfstring> deletetext <fromline> <fromchar> <toline> <tochar>)

#? * somftime
;;.TYPE CLASS
#? (==> <somftime> gettypeid)
#? (new somftime <flag>>
#? (==> <somftime> -destructor)
#? (==> <somftime> getvalues <start>)
#? (==> <somftime> find <targetvalue> <addifnotfound>)
#? (==> <somftime> setvalues <start> <num> <newvalues>)
#? (==> <somftime> set1value <index> <newvalue>)
#? (==> <somftime> setvalue <newvalue>)
#? (==> <somftime> startediting)
#? (==> <somftime> finishediting)

#? * somfuint32
;;.TYPE CLASS
#? (==> <somfuint32> gettypeid)
#? (new somfuint32 <flag>>
#? (==> <somfuint32> -destructor)
#? (==> <somfuint32> getvalues <start>)
#? (==> <somfuint32> find <targetvalue> <addifnotfound>)
#? (==> <somfuint32> setvalues <start> <num> <newvalues>)
#? (==> <somfuint32> set1value <index> <newvalue>)
#? (==> <somfuint32> setvalue <newvalue>)
#? (==> <somfuint32> startediting)
#? (==> <somfuint32> finishediting)

#? * somfushort
;;.TYPE CLASS
#? (==> <somfushort> gettypeid)
#? (new somfushort <flag>>
#? (==> <somfushort> -destructor)
#? (==> <somfushort> getvalues <start>)
#? (==> <somfushort> find <targetvalue> <addifnotfound>)
#? (==> <somfushort> setvalues <start> <num> <newvalues>)
#? (==> <somfushort> set1value <index> <newvalue>)
#? (==> <somfushort> setvalue <newvalue>)
#? (==> <somfushort> startediting)
#? (==> <somfushort> finishediting)

#? * somfvec2f
;;.TYPE CLASS
#? (==> <somfvec2f> gettypeid)
#? (new somfvec2f <flag>>
#? (==> <somfvec2f> -destructor)
#? (==> <somfvec2f> getvalues <start>)
#? (==> <somfvec2f> find <targetvalue> <addifnotfound>)
#? (==> <somfvec2f> startediting)
#? (==> <somfvec2f> finishediting)
#? (==> <somfvec2f> set1value <index> <x> <y>)
#? (==> <somfvec2f> setvalue <x> <y>)

#? * somfvec3f
;;.TYPE CLASS
#? (==> <somfvec3f> gettypeid)
#? (new somfvec3f <flag>>
#? (==> <somfvec3f> -destructor)
#? (==> <somfvec3f> getvalues <start>)
#? (==> <somfvec3f> find <targetvalue> <addifnotfound>)
#? (==> <somfvec3f> startediting)
#? (==> <somfvec3f> finishediting)
#? (==> <somfvec3f> set1value <index> <x> <y> <z>)
#? (==> <somfvec3f> setvalue <x> <y> <z>)

#? * somfvec4f
;;.TYPE CLASS
#? (==> <somfvec4f> gettypeid)
#? (new somfvec4f <flag>>
#? (==> <somfvec4f> -destructor)
#? (==> <somfvec4f> getvalues <start>)
#? (==> <somfvec4f> find <targetvalue> <addifnotfound>)
#? (==> <somfvec4f> startediting)
#? (==> <somfvec4f> finishediting)
#? (==> <somfvec4f> set1value <index> <x> <y> <z> <w>)
#? (==> <somfvec4f> setvalue <x> <y> <z> <w>)

#? * sosfbool
;;.TYPE CLASS
#? (==> <sosfbool> gettypeid)
#? (new sosfbool <flag>>
#? (==> <sosfbool> -destructor)
#? (==> <sosfbool> getvalue)
#? (==> <sosfbool> setvalue <newvalue>)

#? * sosfcolor
;;.TYPE CLASS
#? (==> <sosfcolor> gettypeid)
#? (new sosfcolor <flag>>
#? (==> <sosfcolor> -destructor)
#? (==> <sosfcolor> getvalue)
#? (==> <sosfcolor> setvalue <r> <g> <b>)
#? (==> <sosfcolor> sethsvvalue <h> <s> <v>)

#? * sosfengine
;;.TYPE CLASS
#? (==> <sosfengine> gettypeid)
#? (new sosfengine <flag>>
#? (==> <sosfengine> -destructor)
#? (==> <sosfengine> getvalue)
#? (==> <sosfengine> setvalue <newvalue>)

#? * sosfenum
;;.TYPE CLASS
#? (==> <sosfenum> gettypeid)
#? (new sosfenum <flag>>
#? (==> <sosfenum> -destructor)
#? (==> <sosfenum> getvalue)
#? (==> <sosfenum> setvalue <newvalue>)

#? * sosffloat
;;.TYPE CLASS
#? (==> <sosffloat> gettypeid)
#? (new sosffloat <flag>>
#? (==> <sosffloat> -destructor)
#? (==> <sosffloat> getvalue)
#? (==> <sosffloat> setvalue <newvalue>)

#? * sosfimage
;;.TYPE CLASS
#? (==> <sosfimage> gettypeid)
#? (new sosfimage <flag>>
#? (==> <sosfimage> -destructor)
#? (==> <sosfimage> getvalue <size> <nc>)
#? (==> <sosfimage> setvalue <size> <nc> <bytes>)
#? (==> <sosfimage> startediting <size> <nc>)
#? (==> <sosfimage> finishediting)

#? * sosfint32
;;.TYPE CLASS
#? (==> <sosfint32> gettypeid)
#? (new sosfint32 <flag>>
#? (==> <sosfint32> -destructor)
#? (==> <sosfint32> getvalue)
#? (==> <sosfint32> setvalue <newvalue>)

#? * sosfmatrix
;;.TYPE CLASS
#? (==> <sosfmatrix> gettypeid)
#? (new sosfmatrix <flag>>
#? (==> <sosfmatrix> -destructor)
#? (==> <sosfmatrix> getvalue)
#? (==> <sosfmatrix> setvalue <a11> <a12> <a13> <a14> <a21> <a22> <a23> <a24> <a31> <a32> <a33> <a34> <a41> <a42> <a43> <a44>)

#? * sosfname
;;.TYPE CLASS
#? (==> <sosfname> gettypeid)
#? (new sosfname <flag>>
#? (==> <sosfname> -destructor)
#? (==> <sosfname> getvalue)
#? (==> <sosfname> setvalue <string>)

#? * sosfnode
;;.TYPE CLASS
#? (==> <sosfnode> gettypeid)
#? (new sosfnode <flag>>
#? (==> <sosfnode> -destructor)
#? (==> <sosfnode> getvalue)
#? (==> <sosfnode> setvalue <newvalue>)

#? * sosfpath
;;.TYPE CLASS
#? (==> <sosfpath> gettypeid)
#? (new sosfpath <flag>>
#? (==> <sosfpath> -destructor)
#? (==> <sosfpath> getvalue)
#? (==> <sosfpath> setvalue <newvalue>)

#? * sosfplane
;;.TYPE CLASS
#? (==> <sosfplane> gettypeid)
#? (new sosfplane <flag>>
#? (==> <sosfplane> -destructor)
#? (==> <sosfplane> getvalue)
#? (==> <sosfplane> setvalue <newvalue>)

#? * sosfrotation
;;.TYPE CLASS
#? (==> <sosfrotation> gettypeid)
#? (new sosfrotation <flag>>
#? (==> <sosfrotation> -destructor)
#? (==> <sosfrotation> getvalue <axis> <angle>)
#? (==> <sosfrotation> setvalue <q0> <q1> <q2> <q3>)

#? * sosfshort
;;.TYPE CLASS
#? (==> <sosfshort> gettypeid)
#? (new sosfshort <flag>>
#? (==> <sosfshort> -destructor)
#? (==> <sosfshort> getvalue)
#? (==> <sosfshort> setvalue <newvalue>)

#? * sosfstring
;;.TYPE CLASS
#? (==> <sosfstring> gettypeid)
#? (new sosfstring <flag>>
#? (==> <sosfstring> -destructor)
#? (==> <sosfstring> getvalue)
#? (==> <sosfstring> setvalue <string>)

#? * sosftime
;;.TYPE CLASS
#? (==> <sosftime> gettypeid)
#? (new sosftime <flag>>
#? (==> <sosftime> -destructor)
#? (==> <sosftime> getvalue)
#? (==> <sosftime> setvalue <newvalue>)

#? * sosftrigger
;;.TYPE CLASS
#? (==> <sosftrigger> gettypeid)
#? (new sosftrigger <flag>>
#? (==> <sosftrigger> -destructor)
#? (==> <sosftrigger> setvalue)
#? (==> <sosftrigger> getvalue)
#? (==> <sosftrigger> touch)

#? * sosfuint32
;;.TYPE CLASS
#? (==> <sosfuint32> gettypeid)
#? (new sosfuint32 <flag>>
#? (==> <sosfuint32> -destructor)
#? (==> <sosfuint32> getvalue)
#? (==> <sosfuint32> setvalue <newvalue>)

#? * sosfushort
;;.TYPE CLASS
#? (==> <sosfushort> gettypeid)
#? (new sosfushort <flag>>
#? (==> <sosfushort> -destructor)
#? (==> <sosfushort> getvalue)
#? (==> <sosfushort> setvalue <newvalue>)

#? * sosfvec2f
;;.TYPE CLASS
#? (==> <sosfvec2f> gettypeid)
#? (new sosfvec2f <flag>>
#? (==> <sosfvec2f> -destructor)
#? (==> <sosfvec2f> getvalue)
#? (==> <sosfvec2f> setvalue <x> <y>)

#? * sosfvec3f
;;.TYPE CLASS
#? (==> <sosfvec3f> gettypeid)
#? (new sosfvec3f <flag>>
#? (==> <sosfvec3f> -destructor)
#? (==> <sosfvec3f> getvalue)
#? (==> <sosfvec3f> setvalue <x> <y> <z>)

#? * sosfvec4f
;;.TYPE CLASS
#? (==> <sosfvec4f> gettypeid)
#? (new sosfvec4f <flag>>
#? (==> <sosfvec4f> -destructor)
#? (==> <sosfvec4f> getvalue)
#? (==> <sosfvec4f> setvalue <x> <y> <z> <w>)

#? * somfbitmask
;;.TYPE CLASS
#? (==> <somfbitmask> gettypeid)
#? (new somfbitmask <flag>>
#? (==> <somfbitmask> -destructor)

#? * sosfbitmask
;;.TYPE CLASS
#? (==> <sosfbitmask> gettypeid)
#? (new sosfbitmask <flag>>
#? (==> <sosfbitmask> -destructor)

#? * (|dummy_fields|)

;; ********************************************************


(libload "inventor/misc")

;;class SoField : public InventorObject   ***abstract***
(defclass  SoField  InventorObject)


(defmethod SoField  setIgnored (  ig)

  ((-int-) ig)  ;; SbBool -> int
  #{ ((SoField *)$p)->setIgnored($ig);  #} 
  ())

(defmethod SoField  isIgnored (   )
  
  (int #{ ((SoField *)$p)->isIgnored( )  #} ))  ;; SbBool -> int

(defmethod SoField  isDefault (   )
  
  (int #{ ((SoField *)$p)->isDefault( )  #} ))  ;; SbBool -> int

(defmethod SoField  isOfType (  type)

  ((-gptr- "SoType *") type)
  (int #{ ((SoField *)$p)->isOfType(*$type)  #} ))  ;; SbBool -> int

(defmethod SoField  enableConnection (  flag)

  ((-int-) flag)  ;; SbBool -> int
  #{ ((SoField *)$p)->enableConnection($flag);  #} 
  ())

(defmethod SoField  isConnectionEnabled (   )
  
  (int #{ ((SoField *)$p)->isConnectionEnabled( )  #} ))  ;; SbBool -> int

(defmethod SoField  connectFrom_engine (  engineOutput)

  ((-gptr- "SoEngineOutput *") engineOutput)
  (int #{ ((SoField *)$p)->connectFrom($engineOutput)  #} ))  ;; SbBool -> int

(defmethod SoField  connectFrom_field (  field)

  ((-gptr- "SoField *") field)
  (int #{ ((SoField *)$p)->connectFrom($field)  #} ))  ;; SbBool -> int

(defmethod SoField  disconnect (   )
  
  #{ ((SoField *)$p)->disconnect( );  #} 
  ())

(defmethod SoField  isConnected (   )
  
  (int #{ ((SoField *)$p)->isConnected( )  #} ))  ;; SbBool -> int

(defmethod SoField  isConnectedFromEngine (   )
  
  (int #{ ((SoField *)$p)->isConnectedFromEngine( )  #} ))  ;; SbBool -> int

(defmethod SoField  isConnectedFromField (   )
  
  (int #{ ((SoField *)$p)->isConnectedFromField( )  #} ))  ;; SbBool -> int

(defmethod SoField  getConnectedEngine (  engineOutput)

  ((-gptr- "SoEngineOutput **") engineOutput)     ;; reference -> gptr 
  (int #{ ((SoField *)$p)->getConnectedEngine(*$engineOutput)  #} ))  ;; SbBool -> int

(defmethod SoField  getConnectedField (  field)

  ((-gptr- "SoField **") field)     ;; reference -> gptr 
  (int #{ ((SoField *)$p)->getConnectedField(*$field)  #} ))  ;; SbBool -> int

(defmethod SoField  getForwardConnections (  list)

  ((-gptr- "SoFieldList *") list)     ;; reference -> gptr 
  (int #{ ((SoField *)$p)->getForwardConnections(*$list)  #} ))

(defmethod SoField  getContainer (   )
  
  (gptr #{ ((SoField *)$p)->getContainer( )  #} ))   ;; SoFieldContainer * -> gptr

(defmethod SoField  set (  valueString)

  ((-gptr- "const char *") valueString)
  (int #{ ((SoField *)$p)->set($valueString)  #} ))  ;; SbBool -> int

(defmethod SoField  get (  valueString)

  ((-gptr- "SbString *") valueString)     ;; reference -> gptr 
  #{ ((SoField *)$p)->get(*$valueString);  #} 
  ())

(defmethod SoField  touch (   )
  
  #{ ((SoField *)$p)->touch( );  #} 
  ())





;;class SoFieldContainer : public SoBase
(defclass  SoFieldContainer  SoBase)

(defmethod SoFieldContainer  setToDefaults (   )
  
  #{ ((SoFieldContainer *)$p)->setToDefaults( );  #} 
  ())

(defmethod SoFieldContainer  hasDefaultValues (   )
  
  (int #{ ((SoFieldContainer *)$p)->hasDefaultValues( )  #} ))  ;; SbBool -> int

(defmethod SoFieldContainer  fieldsAreEqual (  fc)

  ((-gptr- "const SoFieldContainer *") fc)
  (int #{ ((SoFieldContainer *)$p)->fieldsAreEqual($fc)  #} ))  ;; SbBool -> int

(defmethod SoFieldContainer  copyFieldValues (  fc  copyConnections)

  ((-gptr- "const SoFieldContainer *") fc)
  ((-int-) copyConnections)  ;; SbBool -> int
  #{ ((SoFieldContainer *)$p)->copyFieldValues($fc,$copyConnections);  #} 
  ())

(defmethod SoFieldContainer  set (  fieldDataString)

  ((-gptr- "const char *") fieldDataString)
  (int #{ ((SoFieldContainer *)$p)->set($fieldDataString)  #} ))  ;; SbBool -> int

(defmethod SoFieldContainer  get (  fieldDataString)

  ((-gptr- "SbString *") fieldDataString)     ;; reference -> gptr 
  #{ ((SoFieldContainer *)$p)->get(*$fieldDataString);  #} 
  ())

(defmethod SoFieldContainer  getFields (  list)

  ((-gptr- "SoFieldList *") list)     ;; reference -> gptr 
  (int #{ ((SoFieldContainer *)$p)->getFields(*$list)  #} ))

(defmethod SoFieldContainer  getField (  fieldName)

  ((-gptr- "const SbName *") fieldName)     ;; reference -> gptr 
  (gptr #{ ((SoFieldContainer *)$p)->getField(*$fieldName)  #} ))   ;; SoField * -> gptr

(defmethod SoFieldContainer  getFieldName (  field  fieldName)

  ((-gptr- "const SoField *") field)
  ((-gptr- "SbName *") fieldName)     ;; reference -> gptr 
  (int #{ ((SoFieldContainer *)$p)->getFieldName($field,*$fieldName)  #} ))  ;; SbBool -> int

(defmethod SoFieldContainer  enableNotify (  flag)

  ((-int-) flag)  ;; SbBool -> int
  (int #{ ((SoFieldContainer *)$p)->enableNotify($flag)       #} ))  ;; SbBool -> int

(defmethod SoFieldContainer  isNotifyEnabled (   )
  
  (int #{ ((SoFieldContainer *)$p)->isNotifyEnabled( )  #} ))  ;; SbBool -> int







;;class SoFieldList : public SbPList
(defclass  SoFieldList  SbPList)

(defmethod SoFieldList  SoFieldList ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoFieldList;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

;; (defmethod SoFieldList  SoFieldList ( flag  size)
;;   ((-bool-) flag)
;; 
;;   ((-int-) size)
;;   #{ if($flag == false ) {
;;            $p = new  SoFieldList;
;;            $shell_flag = false;
;;      }
;;      else
;;            $shell_flag = true;
;;   #} 
;;   ())
;; 
;; (defmethod SoFieldList  SoFieldList ( flag  l)
;;   ((-bool-) flag)
;; 
;;   ((-gptr- "const SoFieldList *") l)     ;; reference -> gptr 
;;   #{ if($flag == false ) {
;;            $p = new  SoFieldList;
;;            $shell_flag = false;
;;      }
;;      else
;;            $shell_flag = true;
;;   #} 
;;   ())

(defmethod SoFieldList  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoFieldList *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoFieldList  append (  field)

  ((-gptr- "SoField *") field)
  #{ ((SoFieldList *)$p)->append($field);  #} 
  ())

(defmethod SoFieldList  insert (  field  addBefore)

  ((-gptr- "SoField *") field)
  ((-int-) addBefore)
  #{ ((SoFieldList *)$p)->insert($field,$addBefore);  #} 
  ())

(defmethod SoFieldList  set (  i  Field)

  ((-int-) i)
  ((-gptr- "SoField *") Field)
  #{ ((SoFieldList *)$p)->set($i,$Field);  #} 
  ())




;;class SoMField : public SoField
(defclass  SoMField  SoField)

(defmethod SoMField  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMField *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMField  getNum (   )
  
  (int #{ ((SoMField *)$p)->getNum( )  #} ))

(defmethod SoMField  setNum (  num)

  ((-int-) num)
  #{ ((SoMField *)$p)->setNum($num);  #} 
  ())

(defmethod SoMField  deleteValues (  start  num)

  ((-int-) start)
  ((-int-) num)
  #{ ((SoMField *)$p)->deleteValues($start,$num);  #} 
  ())

(defmethod SoMField  insertSpace (  start  num)

  ((-int-) start)
  ((-int-) num)
  #{ ((SoMField *)$p)->insertSpace($start,$num);  #} 
  ())

(defmethod SoMField  set1 (  index  valueString)

  ((-int-) index)
  ((-gptr- "const char *") valueString)
  (int #{ ((SoMField *)$p)->set1($index,$valueString)  #} ))  ;; SbBool -> int

(defmethod SoMField  get1 (  index  valueString)

  ((-int-) index)
  ((-gptr- "SbString *") valueString)     ;; reference -> gptr 
  #{ ((SoMField *)$p)->get1($index,*$valueString);  #} 
  ())





;;class SoSField : public SoField
(defclass  SoSField  SoField)

(defmethod SoSField  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSField *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())








;;class SoMFBool : public SoMField
(defclass  SoMFBool  SoMField)

(defmethod SoMFBool  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFBool *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFBool  SoMFBool ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFBool;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFBool  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFBool *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFBool  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFBool *)$p)->getValues($start)  #} ))   ;; const SbBool * -> gptr

(defmethod SoMFBool  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)  ;; SbBool -> int
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFBool *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFBool  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbBool *") newValues)
  #{ ((SoMFBool *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFBool  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)  ;; SbBool -> int
  #{ ((SoMFBool *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFBool  setValue (  newValue)

  ((-int-) newValue)  ;; SbBool -> int
  #{ ((SoMFBool *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFBool  startEditing (   )
  
  (gptr #{ ((SoMFBool *)$p)->startEditing( )  #} ))   ;; SbBool * -> gptr

(defmethod SoMFBool  finishEditing (   )
  
  #{ ((SoMFBool *)$p)->finishEditing( );  #} 
  ())



;;class SoMFColor : public SoMField
(defclass  SoMFColor  SoMField)

(defmethod SoMFColor  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFColor *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFColor  SoMFColor ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFColor;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFColor  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFColor *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFColor  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFColor *)$p)->getValues($start)  #} ))   ;; const SbColor * -> gptr

(defmethod SoMFColor  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbColor *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFColor *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFColor  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbColor *") newValues)
  #{ ((SoMFColor *)$p)->setValues($start,$num,$newValues);  #} 
  ())

;; (defmethod SoMFColor  set1Value (  index  newValue)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbColor *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFColor *)$p)->set1Value($index,*$newValue);  #} 
;;   ())

;; (defmethod SoMFColor  setValue (  newValue)
;; 
;;   ((-gptr- "const SbColor *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFColor *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFColor  startEditing (   )
  
  (gptr #{ ((SoMFColor *)$p)->startEditing( )  #} ))   ;; SbColor * -> gptr

(defmethod SoMFColor  finishEditing (   )
  
  #{ ((SoMFColor *)$p)->finishEditing( );  #} 
  ())

;; (defmethod SoMFColor  setValues (  start  num  rgb)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const float*") rgb)
;;   #{ ((SoMFColor *)$p)->setValues($start,$num,$rgb);  #} 
;;   ())


;; (defmethod SoMFColor  setValue (  vec)
;; 
;;   ((-gptr- "const SbVec3f *") vec)     ;; reference -> gptr 
;;   #{ ((SoMFColor *)$p)->setValue(*$vec);  #} 
;;   ())

(defmethod SoMFColor  setValue (  r  g  b)

  ((-float-) r)
  ((-float-) g)
  ((-float-) b)
  #{ ((SoMFColor *)$p)->setValue($r,$g,$b);  #} 
  ())

;; (defmethod SoMFColor  setValue (  rgb)
;; 
;;   ((-gptr- "const float*") rgb)
;;   #{ ((SoMFColor *)$p)->setValue($rgb);  #} 
;;   ())

(defmethod SoMFColor  setHSVValue (  h  s  v)

  ((-float-) h)
  ((-float-) s)
  ((-float-) v)
  #{ ((SoMFColor *)$p)->setHSVValue($h,$s,$v);  #} 
  ())

;; (defmethod SoMFColor  setHSVValue (  hsv)
;; 
;;   ((-gptr- "const float*") hsv)
;;   #{ ((SoMFColor *)$p)->setHSVValue($hsv);  #} 
;;   ())

;; (defmethod SoMFColor  set1Value (  index  vec)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbVec3f *") vec)     ;; reference -> gptr 
;;   #{ ((SoMFColor *)$p)->set1Value($index,*$vec);  #} 
;;   ())

(defmethod SoMFColor  set1Value (  index  r  g  b)

  ((-int-) index)
  ((-float-) r)
  ((-float-) g)
  ((-float-) b)
  #{ ((SoMFColor *)$p)->set1Value($index,$r,$g,$b);  #} 
  ())

;; (defmethod SoMFColor  set1Value (  index  rgb)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float*") rgb)
;;   #{ ((SoMFColor *)$p)->set1Value($index,$rgb);  #} 
;;   ())

(defmethod SoMFColor  set1HSVValue (  index  h  s  v)

  ((-int-) index)
  ((-float-) h)
  ((-float-) s)
  ((-float-) v)
  #{ ((SoMFColor *)$p)->set1HSVValue($index,$h,$s,$v);  #} 
  ())

;; (defmethod SoMFColor  set1HSVValue (  index  hsv)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float*") hsv)
;;   #{ ((SoMFColor *)$p)->set1HSVValue($index,$hsv);  #} 
;;   ())




;;class SoMFEngine : public SoMField
(defclass  SoMFEngine  SoMField)

(defmethod SoMFEngine  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFEngine *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFEngine  SoMFEngine ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFEngine;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFEngine  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFEngine *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFEngine  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFEngine *)$p)->getValues($start)  #} ))   ;; const SoEngine ** -> gptr

(defmethod SoMFEngine  find (  targetValue  addIfNotFound)

  ((-gptr- "SoEngine *") targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFEngine *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFEngine  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SoEngine **") newValues)
  #{ ((SoMFEngine *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFEngine  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "SoEngine *") newValue)
  #{ ((SoMFEngine *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFEngine  setValue (  newValue)

  ((-gptr- "SoEngine *") newValue)
  #{ ((SoMFEngine *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFEngine  startEditing (   )
  
  (gptr #{ ((SoMFEngine *)$p)->startEditing( )  #} ))   ;; SoEngine ** -> gptr

(defmethod SoMFEngine  finishEditing (   )
  
  #{ ((SoMFEngine *)$p)->finishEditing( );  #} 
  ())




;;class SoMFEnum : public SoMField
(defclass  SoMFEnum  SoMField)

(defmethod SoMFEnum  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFEnum *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFEnum  SoMFEnum ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFEnum;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFEnum  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFEnum *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFEnum  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFEnum *)$p)->getValues($start)  #} ))   ;; const int * -> gptr

(defmethod SoMFEnum  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFEnum *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFEnum  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const int *") newValues)
  #{ ((SoMFEnum *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFEnum  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)
  #{ ((SoMFEnum *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFEnum  setValue (  newValue)

  ((-int-) newValue)
  #{ ((SoMFEnum *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFEnum  startEditing (   )
  
  (gptr #{ ((SoMFEnum *)$p)->startEditing( )  #} ))   ;; int * -> gptr

(defmethod SoMFEnum  finishEditing (   )
  
  #{ ((SoMFEnum *)$p)->finishEditing( );  #} 
  ())

;; (defmethod SoMFEnum  setValue (  name)
;; 
;;   ((-gptr- "const SbName *") name)     ;; reference -> gptr 
;;   #{ ((SoMFEnum *)$p)->setValue(*$name);  #} 
;;   ())
;; 
;; (defmethod SoMFEnum  set1Value (  index  name)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbName *") name)     ;; reference -> gptr 
;;   #{ ((SoMFEnum *)$p)->set1Value($index,*$name);  #} 
;;   ())




;;class SoMFFloat : public SoMField
(defclass  SoMFFloat  SoMField)

(defmethod SoMFFloat  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFFloat *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFFloat  SoMFFloat ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFFloat;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFFloat  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFFloat *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFFloat  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFFloat *)$p)->getValues($start)  #} ))   ;; const float * -> gptr

(defmethod SoMFFloat  find (  targetValue  addIfNotFound)

  ((-float-) targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFFloat *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFFloat  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const float *") newValues)
  #{ ((SoMFFloat *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFFloat  set1Value (  index  newValue)

  ((-int-) index)
  ((-float-) newValue)
  #{ ((SoMFFloat *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFFloat  setValue (  newValue)

  ((-float-) newValue)
  #{ ((SoMFFloat *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFFloat  startEditing (   )
  
  (gptr #{ ((SoMFFloat *)$p)->startEditing( )  #} ))   ;; float * -> gptr

(defmethod SoMFFloat  finishEditing (   )
  
  #{ ((SoMFFloat *)$p)->finishEditing( );  #} 
  ())




;;class SoMFInt32 : public SoMField
(defclass  SoMFInt32  SoMField)

(defmethod SoMFInt32  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFInt32 *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFInt32  SoMFInt32 ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFInt32;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFInt32  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFInt32 *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFInt32  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFInt32 *)$p)->getValues($start)  #} ))   ;; const int32_t * -> gptr

(defmethod SoMFInt32  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)  ;; int32_t -> int
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFInt32 *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFInt32  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const int32_t *") newValues)
  #{ ((SoMFInt32 *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFInt32  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)   ;; int32_t -> int
  #{ ((SoMFInt32 *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFInt32  setValue (  newValue)

  ((-int-) newValue)   ;; int32_t -> int
  #{ ((SoMFInt32 *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFInt32  startEditing (   )
  
  (gptr #{ ((SoMFInt32 *)$p)->startEditing( )  #} ))   ;; int32_t * -> gptr

(defmethod SoMFInt32  finishEditing (   )
  
  #{ ((SoMFInt32 *)$p)->finishEditing( );  #} 
  ())







;;class SoMFMatrix : public SoMField
(defclass  SoMFMatrix  SoMField)

(defmethod SoMFMatrix  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFMatrix *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFMatrix  SoMFMatrix ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFMatrix;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFMatrix  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFMatrix *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFMatrix  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFMatrix *)$p)->getValues($start)  #} ))   ;; const SbMatrix * -> gptr

(defmethod SoMFMatrix  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbMatrix *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFMatrix *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFMatrix  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbMatrix *") newValues)
  #{ ((SoMFMatrix *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFMatrix  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "const SbMatrix *") newValue)     ;; reference -> gptr 
  #{ ((SoMFMatrix *)$p)->set1Value($index,*$newValue);  #} 
  ())

;; (defmethod SoMFMatrix  setValue (  newValue)
;; 
;;   ((-gptr- "const SbMatrix *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFMatrix *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFMatrix  startEditing (   )
  
  (gptr #{ ((SoMFMatrix *)$p)->startEditing( )  #} ))   ;; SbMatrix * -> gptr

(defmethod SoMFMatrix  finishEditing (   )
  
  #{ ((SoMFMatrix *)$p)->finishEditing( );  #} 
  ())

(defmethod SoMFMatrix  setValue (  a11  a12  a13  a14  a21  a22  a23  a24  a31  a32  a33  a34  a41  a42  a43  a44)

  ((-float-) a11)
  ((-float-) a12)
  ((-float-) a13)
  ((-float-) a14)
  ((-float-) a21)
  ((-float-) a22)
  ((-float-) a23)
  ((-float-) a24)
  ((-float-) a31)
  ((-float-) a32)
  ((-float-) a33)
  ((-float-) a34)
  ((-float-) a41)
  ((-float-) a42)
  ((-float-) a43)
  ((-float-) a44)
  #{ ((SoMFMatrix *)$p)->setValue($a11,$a12,$a13,$a14,$a21,$a22,$a23,$a24,$a31,$a32,$a33,$a34,$a41,$a42,$a43,$a44);  #} 
  ())





;;class SoMFName : public SoMField
(defclass  SoMFName  SoMField)

(defmethod SoMFName  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFName *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFName  SoMFName ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFName;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFName  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFName *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFName  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFName *)$p)->getValues($start)  #} ))   ;; const SbName * -> gptr

(defmethod SoMFName  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbName *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFName *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFName  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbName *") newValues)
  #{ ((SoMFName *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFName  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "const SbName *") newValue)     ;; reference -> gptr 
  #{ ((SoMFName *)$p)->set1Value($index,*$newValue);  #} 
  ())

;; (defmethod SoMFName  setValue (  newValue)
;; 
;;   ((-gptr- "const SbName *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFName *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFName  startEditing (   )
  
  (gptr #{ ((SoMFName *)$p)->startEditing( )  #} ))   ;; SbName * -> gptr

(defmethod SoMFName  finishEditing (   )
  
  #{ ((SoMFName *)$p)->finishEditing( );  #} 
  ())

;; (defmethod SoMFName  setValues (  start  num  strings)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const char **") strings)
;;   #{ ((SoMFName *)$p)->setValues($start,$num,$strings);  #} 
;;   ())

(defmethod SoMFName  setValue (  string)

  ((-gptr- "const char *") string)
  #{ ((SoMFName *)$p)->setValue($string);  #} 
  ())




;;class SoMFNode : public SoMField
(defclass  SoMFNode  SoMField)

(defmethod SoMFNode  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFNode *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFNode  SoMFNode ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFNode;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFNode  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFNode *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFNode  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFNode *)$p)->getValues($start)  #} ))   ;; const SoNode ** -> gptr

(defmethod SoMFNode  find (  targetValue  addIfNotFound)

  ((-gptr- "SoNode *") targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFNode *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFNode  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SoNode **") newValues)
  #{ ((SoMFNode *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFNode  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "SoNode *") newValue)
  #{ ((SoMFNode *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFNode  setValue (  newValue)

  ((-gptr- "SoNode *") newValue)
  #{ ((SoMFNode *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFNode  startEditing (   )
  
  (gptr #{ ((SoMFNode *)$p)->startEditing( )  #} ))   ;; SoNode ** -> gptr

(defmethod SoMFNode  finishEditing (   )
  
  #{ ((SoMFNode *)$p)->finishEditing( );  #} 
  ())





;;class SoMFPath : public SoMField
(defclass  SoMFPath  SoMField)

(defmethod SoMFPath  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFPath *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFPath  SoMFPath ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFPath;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFPath  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFPath *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFPath  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFPath *)$p)->getValues($start)  #} ))   ;; const SoPath ** -> gptr

(defmethod SoMFPath  find (  targetValue  addIfNotFound)

  ((-gptr- "SoPath *") targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFPath *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFPath  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SoPath **") newValues)
  #{ ((SoMFPath *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFPath  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "SoPath *") newValue)
  #{ ((SoMFPath *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFPath  setValue (  newValue)

  ((-gptr- "SoPath *") newValue)
  #{ ((SoMFPath *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFPath  startEditing (   )
  
  (gptr #{ ((SoMFPath *)$p)->startEditing( )  #} ))   ;; SoPath ** -> gptr

(defmethod SoMFPath  finishEditing (   )
  
  #{ ((SoMFPath *)$p)->finishEditing( );  #} 
  ())

 


;;class SoMFPlane : public SoMField
(defclass  SoMFPlane  SoMField)

(defmethod SoMFPlane  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFPlane *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFPlane  SoMFPlane ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFPlane;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFPlane  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFPlane *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFPlane  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFPlane *)$p)->getValues($start)  #} ))   ;; const SbPlane * -> gptr

(defmethod SoMFPlane  find (  targetValue  addIfNotFound)

  ((-gptr- "SbPlane *") targetValue)    ;; SbPlane -> gptr
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFPlane *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFPlane  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbPlane *") newValues)
  #{ ((SoMFPlane *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFPlane  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "SbPlane *") newValue)
  #{ ((SoMFPlane *)$p)->set1Value($index,*$newValue);  #} 
  ())

(defmethod SoMFPlane  setValue (  newValue)

  ((-gptr- "SbPlane *") newValue)
  #{ ((SoMFPlane *)$p)->setValue(*$newValue);  #} 
  ())

(defmethod SoMFPlane  startEditing (   )
  
  (gptr #{ ((SoMFPlane *)$p)->startEditing( )  #} ))   ;; SbPlane * -> gptr

(defmethod SoMFPlane  finishEditing (   )
  
  #{ ((SoMFPlane *)$p)->finishEditing( );  #} 
  ())



;;class SoMFRotation : public SoMField
(defclass  SoMFRotation  SoMField)

(defmethod SoMFRotation  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFRotation *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFRotation  SoMFRotation ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFRotation;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFRotation  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFRotation *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFRotation  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFRotation *)$p)->getValues($start)  #} ))   ;; const SbRotation * -> gptr

(defmethod SoMFRotation  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbRotation *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFRotation *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFRotation  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbRotation *") newValues)
  #{ ((SoMFRotation *)$p)->setValues($start,$num,$newValues);  #} 
  ())

;; (defmethod SoMFRotation  set1Value (  index  newValue)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbRotation *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFRotation *)$p)->set1Value($index,*$newValue);  #} 
;;   ())

;; (defmethod SoMFRotation  setValue (  newValue)
;; 
;;   ((-gptr- "const SbRotation *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFRotation *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFRotation  startEditing (   )
  
  (gptr #{ ((SoMFRotation *)$p)->startEditing( )  #} ))   ;; SbRotation * -> gptr

(defmethod SoMFRotation  finishEditing (   )
  
  #{ ((SoMFRotation *)$p)->finishEditing( );  #} 
  ())

;; (defmethod SoMFRotation  setValues (  start  num  q)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const float**") q)
;;   #{ ((SoMFRotation *)$p)->setValues($start,$num,$q);  #} 
;;   ())

(defmethod SoMFRotation  set1Value (  index  q0  q1  q2  q3)

  ((-int-) index)
  ((-float-) q0)
  ((-float-) q1)
  ((-float-) q2)
  ((-float-) q3)
  #{ ((SoMFRotation *)$p)->set1Value($index,$q0,$q1,$q2,$q3);  #} 
  ())

;; (defmethod SoMFRotation  set1Value (  index  q)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float*") q)
;;   #{ ((SoMFRotation *)$p)->set1Value($index,$q);  #} 
;;   ())
;; 
;; (defmethod SoMFRotation  set1Value (  index  axis  angle)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbVec3f *") axis)     ;; reference -> gptr 
;;   ((-float-) angle)
;;   #{ ((SoMFRotation *)$p)->set1Value($index,*$axis,$angle);  #} 
;;   ())

(defmethod SoMFRotation  setValue (  q0  q1  q2  q3)

  ((-float-) q0)
  ((-float-) q1)
  ((-float-) q2)
  ((-float-) q3)
  #{ ((SoMFRotation *)$p)->setValue($q0,$q1,$q2,$q3);  #} 
  ())

;; (defmethod SoMFRotation  setValue (  q)
;; 
;;   ((-gptr- "const float*") q)
;;   #{ ((SoMFRotation *)$p)->setValue($q);  #} 
;;   ())
;; 
;; (defmethod SoMFRotation  setValue (  axis  angle)
;; 
;;   ((-gptr- "const SbVec3f *") axis)     ;; reference -> gptr 
;;   ((-float-) angle)
;;   #{ ((SoMFRotation *)$p)->setValue(*$axis,$angle);  #} 
;;   ())




;;class SoMFShort : public SoMField
(defclass  SoMFShort  SoMField)

(defmethod SoMFShort  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFShort *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFShort  SoMFShort ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFShort;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFShort  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFShort *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFShort  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFShort *)$p)->getValues($start)  #} ))   ;; const short * -> gptr

(defmethod SoMFShort  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFShort *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFShort  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const short *") newValues)
  #{ ((SoMFShort *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFShort  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)
  #{ ((SoMFShort *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFShort  setValue (  newValue)

  ((-int-) newValue)
  #{ ((SoMFShort *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFShort  startEditing (   )
  
  (gptr #{ ((SoMFShort *)$p)->startEditing( )  #} ))   ;; short * -> gptr

(defmethod SoMFShort  finishEditing (   )
  
  #{ ((SoMFShort *)$p)->finishEditing( );  #} 
  ())




;;class SoMFString : public SoMField
(defclass  SoMFString  SoMField)

(defmethod SoMFString  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFString *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFString  SoMFString ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFString;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFString  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFString *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFString  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFString *)$p)->getValues($start)  #} ))   ;; const SbString * -> gptr

(defmethod SoMFString  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbString *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFString *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

;; (defmethod SoMFString  setValues (  start  num  newValues)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const SbString *") newValues)
;;   #{ ((SoMFString *)$p)->setValues($start,$num,$newValues);  #} 
;;   ())

(defmethod SoMFString  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "const SbString *") newValue)     ;; reference -> gptr 
  #{ ((SoMFString *)$p)->set1Value($index,*$newValue);  #} 
  ())

;; (defmethod SoMFString  setValue (  newValue)
;; 
;;   ((-gptr- "const SbString *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFString *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFString  startEditing (   )
  
  (gptr #{ ((SoMFString *)$p)->startEditing( )  #} ))   ;; SbString * -> gptr

(defmethod SoMFString  finishEditing (   )
  
  #{ ((SoMFString *)$p)->finishEditing( );  #} 
  ())

 (defmethod SoMFString  setValues (  start  num  strings)
 
   ((-int-) start)
   ((-int-) num)
   ((-gptr- "const char **") strings)
   #{ ((SoMFString *)$p)->setValues($start,$num,$strings);  #} 
   ())
 
 (defmethod SoMFString  setValue (  string)
 
   ((-gptr- "const char *") string)
   #{ ((SoMFString *)$p)->setValue($string);  #} 
   ())

(defmethod SoMFString  deleteText (  fromLine  fromChar  toLine  toChar)

  ((-int-) fromLine)
  ((-int-) fromChar)
  ((-int-) toLine)
  ((-int-) toChar)
  #{ ((SoMFString *)$p)->deleteText($fromLine,$fromChar,$toLine,$toChar);  #} 
  ())





;;class SoMFTime : public SoMField
(defclass  SoMFTime  SoMField)

(defmethod SoMFTime  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFTime *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFTime  SoMFTime ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFTime;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFTime  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFTime *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFTime  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFTime *)$p)->getValues($start)  #} ))   ;; const SbTime * -> gptr

(defmethod SoMFTime  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbTime *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFTime *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

(defmethod SoMFTime  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const SbTime *") newValues)
  #{ ((SoMFTime *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFTime  set1Value (  index  newValue)

  ((-int-) index)
  ((-gptr- "const SbTime *") newValue)     ;; reference -> gptr 
  #{ ((SoMFTime *)$p)->set1Value($index,*$newValue);  #} 
  ())

(defmethod SoMFTime  setValue (  newValue)

  ((-gptr- "const SbTime *") newValue)     ;; reference -> gptr 
  #{ ((SoMFTime *)$p)->setValue(*$newValue);  #} 
  ())

(defmethod SoMFTime  startEditing (   )
  
  (gptr #{ ((SoMFTime *)$p)->startEditing( )  #} ))   ;; SbTime * -> gptr

(defmethod SoMFTime  finishEditing (   )
  
  #{ ((SoMFTime *)$p)->finishEditing( );  #} 
  ())




;;class SoMFUInt32 : public SoMField
(defclass  SoMFUInt32  SoMField)

(defmethod SoMFUInt32  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFUInt32 *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFUInt32  SoMFUInt32 ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFUInt32;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFUInt32  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFUInt32 *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFUInt32  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFUInt32 *)$p)->getValues($start)  #} ))   ;; const uint32_t * -> gptr

(defmethod SoMFUInt32  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)        ;; uint32_t -> int
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFUInt32 *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFUInt32  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const uint32_t *") newValues)
  #{ ((SoMFUInt32 *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFUInt32  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)   ;; uint32_t -> int
  #{ ((SoMFUInt32 *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFUInt32  setValue (  newValue)

  ((-int-) newValue)   ;; uint32_t -> int
  #{ ((SoMFUInt32 *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFUInt32  startEditing (   )
  
  (gptr #{ ((SoMFUInt32 *)$p)->startEditing( )  #} ))   ;; uint32_t * -> gptr

(defmethod SoMFUInt32  finishEditing (   )
  
  #{ ((SoMFUInt32 *)$p)->finishEditing( );  #} 
  ())




;;class SoMFUShort : public SoMField
(defclass  SoMFUShort  SoMField)

(defmethod SoMFUShort  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFUShort *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFUShort  SoMFUShort ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFUShort;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFUShort  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFUShort *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFUShort  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFUShort *)$p)->getValues($start)  #} ))   ;; const unsigned short * -> gptr

(defmethod SoMFUShort  find (  targetValue  addIfNotFound)

  ((-int-) targetValue)   ;; unsigned short -> int
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFUShort *)$p)->find($targetValue,$addIfNotFound)  #} ))

(defmethod SoMFUShort  setValues (  start  num  newValues)

  ((-int-) start)
  ((-int-) num)
  ((-gptr- "const unsigned short *") newValues)
  #{ ((SoMFUShort *)$p)->setValues($start,$num,$newValues);  #} 
  ())

(defmethod SoMFUShort  set1Value (  index  newValue)

  ((-int-) index)
  ((-int-) newValue)   ;; unsigned short -> int
  #{ ((SoMFUShort *)$p)->set1Value($index,$newValue);  #} 
  ())

(defmethod SoMFUShort  setValue (  newValue)

  ((-int-) newValue)         ;; unsigned short -> int
  #{ ((SoMFUShort *)$p)->setValue($newValue);  #} 
  ())

(defmethod SoMFUShort  startEditing (   )
  
  (gptr #{ ((SoMFUShort *)$p)->startEditing( )  #} ))   ;; unsigned short * -> gptr

(defmethod SoMFUShort  finishEditing (   )
  
  #{ ((SoMFUShort *)$p)->finishEditing( );  #} 
  ())




;;class SoMFVec2f : public SoMField
(defclass  SoMFVec2f  SoMField)

(defmethod SoMFVec2f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFVec2f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFVec2f  SoMFVec2f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFVec2f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFVec2f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFVec2f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFVec2f  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFVec2f *)$p)->getValues($start)  #} ))   ;; const SbVec2f * -> gptr

(defmethod SoMFVec2f  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbVec2f *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFVec2f *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

;; (defmethod SoMFVec2f  setValues (  start  num  newValues)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const SbVec2f *") newValues)
;;   #{ ((SoMFVec2f *)$p)->setValues($start,$num,$newValues);  #} 
;;   ())

;; (defmethod SoMFVec2f  set1Value (  index  newValue)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbVec2f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec2f *)$p)->set1Value($index,*$newValue);  #} 
;;   ())
;; 
;; (defmethod SoMFVec2f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec2f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec2f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFVec2f  startEditing (   )
  
  (gptr #{ ((SoMFVec2f *)$p)->startEditing( )  #} ))   ;; SbVec2f * -> gptr

(defmethod SoMFVec2f  finishEditing (   )
  
  #{ ((SoMFVec2f *)$p)->finishEditing( );  #} 
  ())


(defmethod SoMFVec2f  set1Value (  index  x  y)

  ((-int-) index)
  ((-float-) x)
  ((-float-) y)
  #{ ((SoMFVec2f *)$p)->set1Value($index,$x,$y);  #} 
  ())

;; (defmethod SoMFVec2f  set1Value (  index  xy)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float*") xy)
;;   #{ ((SoMFVec2f *)$p)->set1Value($index,$xy);  #} 
  ())

(defmethod SoMFVec2f  setValue (  x  y)

  ((-float-) x)
  ((-float-) y)
  #{ ((SoMFVec2f *)$p)->setValue($x,$y);  #} 
  ())

;; (defmethod SoMFVec2f  setValue (  xy)
;; 
;;   ((-gptr- "const float*") xy)
;;   #{ ((SoMFVec2f *)$p)->setValue($xy);  #} 
;;   ())





;;class SoMFVec3f : public SoMField
(defclass  SoMFVec3f  SoMField)

(defmethod SoMFVec3f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFVec3f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFVec3f  SoMFVec3f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFVec3f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFVec3f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFVec3f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFVec3f  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFVec3f *)$p)->getValues($start)  #} ))   ;; const SbVec3f * -> gptr

(defmethod SoMFVec3f  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbVec3f *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFVec3f *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

;; (defmethod SoMFVec3f  setValues (  start  num  newValues)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const SbVec3f *") newValues)
;;   #{ ((SoMFVec3f *)$p)->setValues($start,$num,$newValues);  #} 
;;   ())

;; (defmethod SoMFVec3f  set1Value (  index  newValue)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbVec3f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec3f *)$p)->set1Value($index,*$newValue);  #} 
;;   ())
;; 
;; (defmethod SoMFVec3f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec3f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec3f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFVec3f  startEditing (   )
  
  (gptr #{ ((SoMFVec3f *)$p)->startEditing( )  #} ))   ;; SbVec3f * -> gptr

(defmethod SoMFVec3f  finishEditing (   )
  
  #{ ((SoMFVec3f *)$p)->finishEditing( );  #} 
  ())



(defmethod SoMFVec3f  set1Value (  index  x  y  z)

  ((-int-) index)
  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  #{ ((SoMFVec3f *)$p)->set1Value($index,$x,$y,$z);  #} 
  ())

;; (defmethod SoMFVec3f  set1Value (  index  xyz)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float*") xyz)
;;   #{ ((SoMFVec3f *)$p)->set1Value($index,$xyz);  #} 
;;   ())

(defmethod SoMFVec3f  setValue (  x  y  z)

  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  #{ ((SoMFVec3f *)$p)->setValue($x,$y,$z);  #} 
  ())

;; (defmethod SoMFVec3f  setValue (  xyz)
;; 
;;   ((-gptr- "const float*") xyz)
;;   #{ ((SoMFVec3f *)$p)->setValue($xyz);  #} 
;;   ())




;;class SoMFVec4f : public SoMField
(defclass  SoMFVec4f  SoMField)

(defmethod SoMFVec4f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFVec4f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFVec4f  SoMFVec4f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFVec4f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFVec4f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFVec4f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoMFVec4f  getValues (  start)

  ((-int-) start)
  (gptr #{ ((SoMFVec4f *)$p)->getValues($start)  #} ))   ;; const  SbVec4f * -> gptr

(defmethod SoMFVec4f  find (  targetValue  addIfNotFound)

  ((-gptr- "const SbVec4f *") targetValue)     ;; reference -> gptr 
  ((-int-) addIfNotFound)  ;; SbBool -> int
  (int #{ ((SoMFVec4f *)$p)->find(*$targetValue,$addIfNotFound)  #} ))

;; (defmethod SoMFVec4f  setValues (  start  num  newValues)
;; 
;;   ((-int-) start)
;;   ((-int-) num)
;;   ((-gptr- "const SbVec4f *") newValues)
;;   #{ ((SoMFVec4f *)$p)->setValues($start,$num,$newValues);  #} 
;;   ())
;; 
;; (defmethod SoMFVec4f  set1Value (  index  newValue)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const SbVec4f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec4f *)$p)->set1Value($index,*$newValue);  #} 
;;   ())
;; 
;; (defmethod SoMFVec4f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec4f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoMFVec4f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoMFVec4f  startEditing (   )
  
  (gptr #{ ((SoMFVec4f *)$p)->startEditing( )  #} ))   ;; SbVec4f * -> gptr

(defmethod SoMFVec4f  finishEditing (   )
  
  #{ ((SoMFVec4f *)$p)->finishEditing( );  #} 
  ())



(defmethod SoMFVec4f  set1Value (  index  x  y  z  w)

  ((-int-) index)
  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  ((-float-) w)
  #{ ((SoMFVec4f *)$p)->set1Value($index,$x,$y,$z,$w);  #} 
  ())

;; (defmethod SoMFVec4f  set1Value (  index  xyzw)
;; 
;;   ((-int-) index)
;;   ((-gptr- "const float *") xyzw)
;;   #{ ((SoMFVec4f *)$p)->set1Value($index,$xyzw);  #} 
;;   ())

(defmethod SoMFVec4f  setValue (  x  y  z  w)

  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  ((-float-) w)
  #{ ((SoMFVec4f *)$p)->setValue($x,$y,$z,$w);  #} 
  ())

;; (defmethod SoMFVec4f  setValue (  xyzw)
;; 
;;   ((-gptr- "const float*") xyzw)
;;   #{ ((SoMFVec4f *)$p)->setValue($xyzw);  #} 
;;   ())









;;class SoSFBool : public SoSField
(defclass  SoSFBool  SoSField)

(defmethod SoSFBool  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFBool *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFBool  SoSFBool ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFBool;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFBool  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFBool *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFBool  getValue (   )
  
  (int #{ ((SoSFBool *)$p)->getValue( )  #} ))  ;; SbBool -> int

(defmethod SoSFBool  setValue (  newValue)

  ((-int-) newValue)  ;; SbBool -> int
  #{ ((SoSFBool *)$p)->setValue($newValue);  #} 
  ())





;;class SoSFColor : public SoSField
(defclass  SoSFColor  SoSField)

(defmethod SoSFColor  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFColor *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFColor  SoSFColor ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFColor;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFColor  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFColor *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFColor  getValue (   )
  
  (gptr #{ &(((SoSFColor *)$p)->getValue( ))  #} ))  ;; const SbColor &  -> gptr

;; (defmethod SoSFColor  setValue (  newValue)
;; 
;;   ((-gptr- "const SbColor *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFColor *)$p)->setValue(*$newValue);  #} 
;;   ())
;; 
;; (defmethod SoSFColor  setValue (  vec)
;; 
;;   ((-gptr- "const SbVec3f *") vec)     ;; reference -> gptr 
;;   #{ ((SoSFColor *)$p)->setValue(*$vec);  #} 
;;   ())

(defmethod SoSFColor  setValue (  r  g  b)

  ((-float-) r)
  ((-float-) g)
  ((-float-) b)
  #{ ((SoSFColor *)$p)->setValue($r,$g,$b);  #} 
  ())

(defmethod SoSFColor  setHSVValue (  h  s  v)

  ((-float-) h)
  ((-float-) s)
  ((-float-) v)
  #{ ((SoSFColor *)$p)->setHSVValue($h,$s,$v);  #} 
  ())

;; (defmethod SoSFColor  setValue (  rgb)
;; 
;;   ((-gptr- "const float*") rgb)
;;   #{ ((SoSFColor *)$p)->setValue($rgb);  #} 
;;   ())
;; 
;; (defmethod SoSFColor  setHSVValue (  hsv)
;; 
;;   ((-gptr- "const float*") hsv)
;;   #{ ((SoSFColor *)$p)->setHSVValue($hsv);  #} 
;;   ())




;;class SoSFEngine : public SoSField
(defclass  SoSFEngine  SoSField)

(defmethod SoSFEngine  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFEngine *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFEngine  SoSFEngine ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFEngine;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFEngine  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFEngine *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFEngine  getValue (   )
  
  (gptr #{ ((SoSFEngine *)$p)->getValue( )  #} ))   ;; SoEngine * -> gptr

(defmethod SoSFEngine  setValue (  newValue)

  ((-gptr- "SoEngine *") newValue)
  #{ ((SoSFEngine *)$p)->setValue($newValue);  #} 
  ())






;;class SoSFEnum : public SoSField
(defclass  SoSFEnum  SoSField)

(defmethod SoSFEnum  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFEnum *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFEnum  SoSFEnum ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFEnum;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFEnum  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFEnum *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFEnum  getValue (   )
  
  (int #{ ((SoSFEnum *)$p)->getValue( )  #} ))

(defmethod SoSFEnum  setValue (  newValue)

  ((-int-) newValue)
  #{ ((SoSFEnum *)$p)->setValue($newValue);  #} 
  ())

;; (defmethod SoSFEnum  setValue (  name)
;; 
;;   ((-gptr- "const SbName *") name)     ;; reference -> gptr 
;;   #{ ((SoSFEnum *)$p)->setValue(*$name);  #} 
;;   ())




;;class SoSFFloat : public SoSField
(defclass  SoSFFloat  SoSField)

(defmethod SoSFFloat  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFFloat *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFFloat  SoSFFloat ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFFloat;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFFloat  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFFloat *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFFloat  getValue (   )
  
  (float #{ ((SoSFFloat *)$p)->getValue( )  #} ))

(defmethod SoSFFloat  setValue (  newValue)

  ((-float-) newValue)
  #{ ((SoSFFloat *)$p)->setValue($newValue);  #} 
  ())





;;class SoSFImage : public SoSField
(defclass  SoSFImage  SoSField)

(defmethod SoSFImage  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFImage *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFImage  SoSFImage ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFImage;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFImage  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFImage *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFImage  getValue (  size  nc)

  ((-gptr- "SbVec2s *") size)     ;; reference -> gptr 
  ((-gptr- "int *") nc)           ;; reference -> gptr
  (gptr #{ ((SoSFImage *)$p)->getValue(*$size,*$nc)  #} ))   ;; const unsigned char * -> gptr

(defmethod SoSFImage  setValue (  size  nc  bytes)

  ((-gptr- "const SbVec2s *") size)     ;; reference -> gptr 
  ((-int-) nc)
  ((-gptr- "const unsigned char *") bytes)
  #{ ((SoSFImage *)$p)->setValue(*$size,$nc,$bytes);  #} 
  ())

(defmethod SoSFImage  startEditing (  size  nc)

  ((-gptr- "SbVec2s *") size)     ;; reference -> gptr 
  ((-gptr- "int *") nc)     ;; reference -> gptr 
  (gptr #{ ((SoSFImage *)$p)->startEditing(*$size,*$nc)  #} ))   ;; unsigned char * -> gptr

(defmethod SoSFImage  finishEditing (   )
  
  #{ ((SoSFImage *)$p)->finishEditing( );  #} 
  ())





;;class SoSFInt32 : public SoSField
(defclass  SoSFInt32  SoSField)

(defmethod SoSFInt32  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFInt32 *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFInt32  SoSFInt32 ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFInt32;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFInt32  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFInt32 *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFInt32  getValue (   )
  
  (int #{ ((SoSFInt32 *)$p)->getValue( )  #} ))  ;; int32_t -> int

(defmethod SoSFInt32  setValue (  newValue)

  ((-int-) newValue)   ;; int32_t -> int
  #{ ((SoSFInt32 *)$p)->setValue($newValue);  #} 
  ())




;;class SoSFMatrix : public SoSField
(defclass  SoSFMatrix  SoSField)

(defmethod SoSFMatrix  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFMatrix *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFMatrix  SoSFMatrix ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFMatrix;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFMatrix  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFMatrix *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFMatrix  getValue (   )
  
  (gptr #{ &(((SoSFMatrix *)$p)->getValue( ))  #} ))  ;; const SbMatrix &  -> gptr

;; (defmethod SoSFMatrix  setValue (  newValue)
;; 
;;   ((-gptr- "const SbMatrix *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFMatrix *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFMatrix  setValue (  a11  a12  a13  a14  a21  a22  a23  a24  a31  a32  a33  a34  a41  a42  a43  a44)

  ((-float-) a11)
  ((-float-) a12)
  ((-float-) a13)
  ((-float-) a14)
  ((-float-) a21)
  ((-float-) a22)
  ((-float-) a23)
  ((-float-) a24)
  ((-float-) a31)
  ((-float-) a32)
  ((-float-) a33)
  ((-float-) a34)
  ((-float-) a41)
  ((-float-) a42)
  ((-float-) a43)
  ((-float-) a44)
  #{ ((SoSFMatrix *)$p)->setValue($a11,$a12,$a13,$a14,$a21,$a22,$a23,$a24,$a31,$a32,$a33,$a34,$a41,$a42,$a43,$a44);  #} 
  ())





;;class SoSFName : public SoSField
(defclass  SoSFName  SoSField)

(defmethod SoSFName  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFName *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFName  SoSFName ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFName;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFName  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFName *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFName  getValue (   )
  
  (gptr #{ &(((SoSFName *)$p)->getValue( ))  #} ))  ;; const SbName &  -> gptr

;; (defmethod SoSFName  setValue (  newValue)
;; 
;;   ((-gptr- "const SbName *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFName *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFName  setValue (  string)

  ((-gptr- "const char *") string)
  #{ ((SoSFName *)$p)->setValue($string);  #} 
  ())




;;class SoSFNode : public SoSField
(defclass  SoSFNode  SoSField)

(defmethod SoSFNode  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFNode *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFNode  SoSFNode ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFNode;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFNode  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFNode *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFNode  getValue (   )
  
  (gptr #{ ((SoSFNode *)$p)->getValue( )  #} ))   ;; SoNode * -> gptr

(defmethod SoSFNode  setValue (  newValue)

  ((-gptr- "SoNode *") newValue)
  #{ ((SoSFNode *)$p)->setValue($newValue);  #} 
  ())




;;class SoSFPath : public SoSField
(defclass  SoSFPath  SoSField)

(defmethod SoSFPath  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFPath *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFPath  SoSFPath ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFPath;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFPath  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFPath *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFPath  getValue (   )
  
  (gptr #{ ((SoSFPath *)$p)->getValue( )  #} ))   ;; SoPath * -> gptr

(defmethod SoSFPath  setValue (  newValue)

  ((-gptr- "SoPath *") newValue)
  #{ ((SoSFPath *)$p)->setValue($newValue);  #} 
  ())




;;class SoSFPlane : public SoSField
(defclass  SoSFPlane  SoSField)

(defmethod SoSFPlane  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFPlane *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFPlane  SoSFPlane ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFPlane;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFPlane  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFPlane *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFPlane  getValue (   )
  
  (gptr #{ &(((SoSFPlane *)$p)->getValue( ))  #} ))  ;; const SbPlane &  -> gptr

(defmethod SoSFPlane  setValue (  newValue)

  ((-gptr- "const SbPlane *") newValue)     ;; reference -> gptr 
  #{ ((SoSFPlane *)$p)->setValue(*$newValue);  #} 
  ())




;;class SoSFRotation : public SoSField
(defclass  SoSFRotation  SoSField)

(defmethod SoSFRotation  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFRotation *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFRotation  SoSFRotation ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFRotation;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFRotation  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFRotation *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

;; (defmethod SoSFRotation  getValue (   )
;;   
;;   (gptr #{ &(((SoSFRotation *)$p)->getValue( ))  #} ))  ;; const SbRotation &  -> gptr
 
;; (defmethod SoSFRotation  setValue (  newValue)
;; 
;;   ((-gptr- "const SbRotation *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFRotation *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFRotation  getValue (  axis  angle)

  ((-gptr- "SbVec3f *") axis)     ;; reference -> gptr 
  ((-gptr- "float *") angle)     ;; reference -> gptr 
  #{ ((SoSFRotation *)$p)->getValue(*$axis,*$angle);  #} 
  ())

(defmethod SoSFRotation  setValue (  q0  q1  q2  q3)

  ((-float-) q0)
  ((-float-) q1)
  ((-float-) q2)
  ((-float-) q3)
  #{ ((SoSFRotation *)$p)->setValue($q0,$q1,$q2,$q3);  #} 
  ())

;; (defmethod SoSFRotation  setValue (  q)
;; 
;;   ((-gptr- "const float*") q)
;;   #{ ((SoSFRotation *)$p)->setValue($q);  #} 
;;   ())
;; 
;; (defmethod SoSFRotation  setValue (  axis  angle)
;; 
;;   ((-gptr- "const SbVec3f *") axis)     ;; reference -> gptr 
;;   ((-float-) angle)
;;   #{ ((SoSFRotation *)$p)->setValue(*$axis,$angle);  #} 
;;   ())




;;class SoSFShort : public SoSField
(defclass  SoSFShort  SoSField)

(defmethod SoSFShort  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFShort *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFShort  SoSFShort ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFShort;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFShort  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFShort *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFShort  getValue (   )
  
  (int #{ ((SoSFShort *)$p)->getValue( )  #} ))

(defmethod SoSFShort  setValue (  newValue)

  ((-int-) newValue)
  #{ ((SoSFShort *)$p)->setValue($newValue);  #} 
  ())





;;class SoSFString : public SoSField
(defclass  SoSFString  SoSField)

(defmethod SoSFString  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFString *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFString  SoSFString ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFString;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFString  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFString *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFString  getValue (   )
  
  (gptr #{ &(((SoSFString *)$p)->getValue( ))  #} ))  ;; const SbString &  -> gptr

;; (defmethod SoSFString  setValue (  newValue)
;; 
;;   ((-gptr- "const SbString *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFString *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFString  setValue (  string)

  ((-gptr- "const char *") string)
  #{ ((SoSFString *)$p)->setValue($string);  #} 
  ())




;;class SoSFTime : public SoSField
(defclass  SoSFTime  SoSField)

(defmethod SoSFTime  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFTime *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFTime  SoSFTime ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFTime;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFTime  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFTime *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFTime  getValue (   )
  
  (gptr #{ &(((SoSFTime *)$p)->getValue( ))  #} ))  ;; const SbTime &  -> gptr

(defmethod SoSFTime  setValue (  newValue)

  ((-gptr- "const SbTime *") newValue)     ;; reference -> gptr 
  #{ ((SoSFTime *)$p)->setValue(*$newValue);  #} 
  ())




;;class SoSFTrigger : public SoSField
(defclass  SoSFTrigger  SoSField)

(defmethod SoSFTrigger  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFTrigger *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFTrigger  SoSFTrigger ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFTrigger;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFTrigger  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFTrigger *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFTrigger  setValue (   )
  
  #{ ((SoSFTrigger *)$p)->setValue( );  #} 
  ())

(defmethod SoSFTrigger  getValue (   )
  
  #{ ((SoSFTrigger *)$p)->getValue( );  #} 
  ())

(defmethod SoSFTrigger  touch (   )
  
  #{ ((SoSFTrigger *)$p)->touch( );  #} 
  ())





;;class SoSFUInt32 : public SoSField
(defclass  SoSFUInt32  SoSField)

(defmethod SoSFUInt32  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFUInt32 *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFUInt32  SoSFUInt32 ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFUInt32;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFUInt32  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFUInt32 *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFUInt32  getValue (   )
  
  (int #{ ((SoSFUInt32 *)$p)->getValue( )  #} ))  ;; uint32_t -> int

(defmethod SoSFUInt32  setValue (  newValue)

  ((-int-) newValue)      ;; uint32_t -> int
  #{ ((SoSFUInt32 *)$p)->setValue($newValue);  #} 
  ())




;;class SoSFUShort : public SoSField
(defclass  SoSFUShort  SoSField)

(defmethod SoSFUShort  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFUShort *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFUShort  SoSFUShort ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFUShort;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFUShort  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFUShort *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFUShort  getValue (   )
  
  (int #{ ((SoSFUShort *)$p)->getValue( )  #} ))  ;; unsigned short -> int

(defmethod SoSFUShort  setValue (  newValue)

  ((-int-) newValue)    ;; unsigned short -> int
  #{ ((SoSFUShort *)$p)->setValue($newValue);  #} 
  ())






;;class SoSFVec2f : public SoSField
(defclass  SoSFVec2f  SoSField)

(defmethod SoSFVec2f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFVec2f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFVec2f  SoSFVec2f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFVec2f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFVec2f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFVec2f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFVec2f  getValue (   )
  
  (gptr #{ &(((SoSFVec2f *)$p)->getValue( ))  #} ))  ;; const SbVec2f &  -> gptr

;; (defmethod SoSFVec2f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec2f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFVec2f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFVec2f  setValue (  x  y)

  ((-float-) x)
  ((-float-) y)
  #{ ((SoSFVec2f *)$p)->setValue($x,$y);  #} 
  ())

;; (defmethod SoSFVec2f  setValue (  xy)
;; 
;;   ((-gptr- "const float*") xy)
;;   #{ ((SoSFVec2f *)$p)->setValue($xy);  #} 
;;   ())




;;class SoSFVec3f : public SoSField
(defclass  SoSFVec3f  SoSField)

(defmethod SoSFVec3f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFVec3f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFVec3f  SoSFVec3f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFVec3f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFVec3f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFVec3f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFVec3f  getValue (   )
  
  (gptr #{ &(((SoSFVec3f *)$p)->getValue( ))  #} ))  ;; const SbVec3f &  -> gptr

;; (defmethod SoSFVec3f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec3f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFVec3f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFVec3f  setValue (  x  y  z)

  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  #{ ((SoSFVec3f *)$p)->setValue($x,$y,$z);  #} 
  ())

;; (defmethod SoSFVec3f  setValue (  xyz)
;; 
;;   ((-gptr- "const float*") xyz)
;;   #{ ((SoSFVec3f *)$p)->setValue($xyz);  #} 
;;   ())




;;class SoSFVec4f : public SoSField
(defclass  SoSFVec4f  SoSField)

(defmethod SoSFVec4f  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFVec4f *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFVec4f  SoSFVec4f ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFVec4f;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFVec4f  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFVec4f *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

(defmethod SoSFVec4f  getValue (   )
  
  (gptr #{ &(((SoSFVec4f *)$p)->getValue( ))  #} ))  ;; const SbVec4f &  -> gptr

;; (defmethod SoSFVec4f  setValue (  newValue)
;; 
;;   ((-gptr- "const SbVec4f *") newValue)     ;; reference -> gptr 
;;   #{ ((SoSFVec4f *)$p)->setValue(*$newValue);  #} 
;;   ())

(defmethod SoSFVec4f  setValue (  x  y  z  w)

  ((-float-) x)
  ((-float-) y)
  ((-float-) z)
  ((-float-) w)
  #{ ((SoSFVec4f *)$p)->setValue($x,$y,$z,$w);  #} 
  ())

;; (defmethod SoSFVec4f  setValue (  xyzw)
;; 
;;   ((-gptr- "const float*") xyzw)
;;   #{ ((SoSFVec4f *)$p)->setValue($xyzw);  #} 
;;   ())





;;class SoMFBitMask : public SoMFEnum
(defclass  SoMFBitMask  SoMFEnum)

(defmethod SoMFBitMask  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoMFBitMask *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoMFBitMask  SoMFBitMask ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoMFBitMask;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoMFBitMask  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoMFBitMask *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())




;;class SoSFBitMask : public SoSFEnum
(defclass  SoSFBitMask  SoSFEnum)

(defmethod SoSFBitMask  getTypeId (   )
  
  (let*  ((retobj (new SoType ()))
	  (retobjp :retobj:p))
    #{ *((SoType *)$retobjp) = ((SoSFBitMask *)$p)->getTypeId( );  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSFBitMask  SoSFBitMask ( flag   )
  ((-bool-) flag)
  
  #{ if($flag == false ) {
           $p = new  SoSFBitMask;
           $shell_flag = false;
     }
     else
           $shell_flag = true;
  #} 
  ())

(defmethod SoSFBitMask  -destructor (   )
  
  #{  if($shell_flag == false ) {
           delete ((SoSFBitMask *)$p);
           $p = NULL;
           $shell_flag = true;
      }
  #} 
  ())

;; ********************************************************

(dhc-make-with-c++ () () 
  |dummy_fields|
  (sofield  touch  get  set  getcontainer  getforwardconnections  getconnectedfield  getconnectedengine  isconnectedfromfield  isconnectedfromengine  isconnected  disconnect  connectfrom-field  connectfrom-engine  isconnectionenabled  enableconnection  isoftype  isdefault  isignored  setignored)
  (sofieldcontainer  isnotifyenabled  enablenotify  getfieldname  getfield  getfields  get  set  copyfieldvalues  fieldsareequal  hasdefaultvalues  settodefaults)
  (sofieldlist  set  insert  append  -destructor  sofieldlist)
  (somfield  get1  set1  insertspace  deletevalues  setnum  getnum  -destructor)
  (sosfield  -destructor)
  (somfbool  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfbool  gettypeid)
  (somfcolor  set1hsvvalue  set1value  sethsvvalue  setvalue  finishediting  startediting  setvalues  find  getvalues  -destructor  somfcolor  gettypeid)
  (somfengine  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfengine  gettypeid)
  (somfenum  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfenum  gettypeid)
  (somffloat  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somffloat  gettypeid)
  (somfint32  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfint32  gettypeid)
  (somfmatrix  setvalue  finishediting  startediting  set1value  setvalues  find  getvalues  -destructor  somfmatrix  gettypeid)
  (somfname  setvalue  finishediting  startediting  set1value  setvalues  find  getvalues  -destructor  somfname  gettypeid)
  (somfnode  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfnode  gettypeid)
  (somfpath  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfpath  gettypeid)
  (somfplane  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfplane  gettypeid)
  (somfrotation  setvalue  set1value  finishediting  startediting  setvalues  find  getvalues  -destructor  somfrotation  gettypeid)
  (somfshort  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfshort  gettypeid)
  (somfstring  deletetext  setvalue  setvalues  finishediting  startediting  set1value  find  getvalues  -destructor  somfstring  gettypeid)
  (somftime  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somftime  gettypeid)
  (somfuint32  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfuint32  gettypeid)
  (somfushort  finishediting  startediting  setvalue  set1value  setvalues  find  getvalues  -destructor  somfushort  gettypeid)
  (somfvec2f  setvalue  set1value  finishediting  startediting  find  getvalues  -destructor  somfvec2f  gettypeid)
  (somfvec3f  setvalue  set1value  finishediting  startediting  find  getvalues  -destructor  somfvec3f  gettypeid)
  (somfvec4f  setvalue  set1value  finishediting  startediting  find  getvalues  -destructor  somfvec4f  gettypeid)
  (sosfbool  setvalue  getvalue  -destructor  sosfbool  gettypeid)
  (sosfcolor  sethsvvalue  setvalue  getvalue  -destructor  sosfcolor  gettypeid)
  (sosfengine  setvalue  getvalue  -destructor  sosfengine  gettypeid)
  (sosfenum  setvalue  getvalue  -destructor  sosfenum  gettypeid)
  (sosffloat  setvalue  getvalue  -destructor  sosffloat  gettypeid)
  (sosfimage  finishediting  startediting  setvalue  getvalue  -destructor  sosfimage  gettypeid)
  (sosfint32  setvalue  getvalue  -destructor  sosfint32  gettypeid)
  (sosfmatrix  setvalue  getvalue  -destructor  sosfmatrix  gettypeid)
  (sosfname  setvalue  getvalue  -destructor  sosfname  gettypeid)
  (sosfnode  setvalue  getvalue  -destructor  sosfnode  gettypeid)
  (sosfpath  setvalue  getvalue  -destructor  sosfpath  gettypeid)
  (sosfplane  setvalue  getvalue  -destructor  sosfplane  gettypeid)
  (sosfrotation  setvalue  getvalue  -destructor  sosfrotation  gettypeid)
  (sosfshort  setvalue  getvalue  -destructor  sosfshort  gettypeid)
  (sosfstring  setvalue  getvalue  -destructor  sosfstring  gettypeid)
  (sosftime  setvalue  getvalue  -destructor  sosftime  gettypeid)
  (sosftrigger  touch  getvalue  setvalue  -destructor  sosftrigger  gettypeid)
  (sosfuint32  setvalue  getvalue  -destructor  sosfuint32  gettypeid)
  (sosfushort  setvalue  getvalue  -destructor  sosfushort  gettypeid)
  (sosfvec2f  setvalue  getvalue  -destructor  sosfvec2f  gettypeid)
  (sosfvec3f  setvalue  getvalue  -destructor  sosfvec3f  gettypeid)
  (sosfvec4f  setvalue  getvalue  -destructor  sosfvec4f  gettypeid)
  (somfbitmask  -destructor  somfbitmask  gettypeid)
  (sosfbitmask  -destructor  sosfbitmask  gettypeid)
)
