;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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")



#? *** nodekits

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

#? * sobasekit
;;.TYPE CLASS
#? (new sobasekit <flag>>
#? (==> <sobasekit> getnodekitcatalog)
#? (==> <sobasekit> getpart <partname> <makeifneeded>)
#? (==> <sobasekit> getpartstring <part>)
#? (==> <sobasekit> createpathtopart <partname> <makeifneeded> <pathtoextend>)
#? (==> <sobasekit> setpart <partname> <from>)

#? * soappearancekit
;;.TYPE CLASS
#? (new soappearancekit <flag>>

#? * sointeractionkit
;;.TYPE CLASS
#? (==> <sointeractionkit> setpartaspath <partname> <surrogatepath>)
#? (==> <sointeractionkit> affectsstate)
#? (==> <sointeractionkit> getsf-rendercaching)
#? (==> <sointeractionkit> getsf-boundingboxcaching)
#? (==> <sointeractionkit> getsf-renderculling)
#? (==> <sointeractionkit> getsf-pickculling)

#? * socamerakit
;;.TYPE CLASS
#? (new socamerakit <flag>>

#? * solightkit
;;.TYPE CLASS
#? (new solightkit <flag>>

#? * sonodekitcatalog
;;.TYPE CLASS
#? (==> <sonodekitcatalog> getnumentries)
#? (==> <sonodekitcatalog> getpartnumber <thename>)
#? (==> <sonodekitcatalog> getname <thepartnumber>)
#? (==> <sonodekitcatalog> isnullbydefault <thepartnumber>)
#? (==> <sonodekitcatalog> isnullbydefault-name <thename>)
#? (==> <sonodekitcatalog> isleaf <thepartnumber>)
#? (==> <sonodekitcatalog> isleaf-name <thename>)
#? (==> <sonodekitcatalog> getparentname <thepartnumber>)
#? (==> <sonodekitcatalog> getparentname-name <thename>)
#? (==> <sonodekitcatalog> getparentpartnumber <thepartnumber>)
#? (==> <sonodekitcatalog> getparentpartnumber-name <thename>)
#? (==> <sonodekitcatalog> getrightsiblingname <thepartnumber>)
#? (==> <sonodekitcatalog> getrightsiblingname-name <thename>)
#? (==> <sonodekitcatalog> getrightsiblingpartnumber <thepartnumber>)
#? (==> <sonodekitcatalog> getrightsiblingpartnumber-name <thename>)
#? (==> <sonodekitcatalog> islist <thepartnumber>)
#? (==> <sonodekitcatalog> islist-name <thename>)
#? (==> <sonodekitcatalog> getlistitemtypes <thepartnumber>)
#? (==> <sonodekitcatalog> getlistitemtypes-name <thename>)
#? (==> <sonodekitcatalog> ispublic <thepartnumber>)
#? (==> <sonodekitcatalog> ispublic-name <thename>)

#? * sonodekitlistpart
;;.TYPE CLASS
#? (new sonodekitlistpart <flag>>
#? (==> <sonodekitlistpart> setcontainertype <newcontainertype>)
#? (==> <sonodekitlistpart> getchildtypes)
#? (==> <sonodekitlistpart> addchildtype <typetoadd>)
#? (==> <sonodekitlistpart> istypepermitted <typetocheck>)
#? (==> <sonodekitlistpart> ischildpermitted <child>)
#? (==> <sonodekitlistpart> containerset <fielddatastring>)
#? (==> <sonodekitlistpart> locktypes)
#? (==> <sonodekitlistpart> istypelocked)
#? (==> <sonodekitlistpart> addchild <child>)
#? (==> <sonodekitlistpart> insertchild <child> <childindex>)
#? (==> <sonodekitlistpart> getchild <index>)
#? (==> <sonodekitlistpart> findchild <child>)
#? (==> <sonodekitlistpart> getnumchildren)
#? (==> <sonodekitlistpart> removechild <index>)
#? (==> <sonodekitlistpart> removechild-node <child>)
#? (==> <sonodekitlistpart> replacechild <index> <newchild>)
#? (==> <sonodekitlistpart> replacechild-node <oldchild> <newchild>)
#? (==> <sonodekitlistpart> affectsstate)

#? * soscenekit
;;.TYPE CLASS
#? (new soscenekit <flag>>
#? (==> <soscenekit> getcameranumber)
#? (==> <soscenekit> setcameranumber <camnum>)
#? (==> <soscenekit> affectsstate)

#? * soseparatorkit
;;.TYPE CLASS
#? (==> <soseparatorkit> getsf-rendercaching)
#? (==> <soseparatorkit> getsf-boundingboxcaching)
#? (==> <soseparatorkit> getsf-renderculling)
#? (==> <soseparatorkit> getsf-pickculling)
#? (new soseparatorkit <flag>>
#? (==> <soseparatorkit> affectsstate)

#? * soshapekit
;;.TYPE CLASS
#? (new soshapekit <flag>>

#? * sowrapperkit
;;.TYPE CLASS
#? (new sowrapperkit <flag>>

#? * (|dummy_nodekits|)

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





;;************************************************************
;;**********  nodekits
;;************************************************************
(libload "inventor/nodes_1")



;; class SoBaseKit : public SoNode
(defclass SoBaseKit SoNode)

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


(defmethod SoBaseKit  getNodekitCatalog (  )
  
  (gptr #{ ((SoBaseKit *)$p)->getNodekitCatalog()  #} ))    ;; const SoNodekitCatalog *  -> gptr



(defmethod SoBaseKit  getPart (  partName  makeIfNeeded )
  
  ((-gptr- "const SbName *") partName)    ;; reference -> gptr
  ((-int-) makeIfNeeded)                    ;; SbBool -> int
  (gptr #{ ((SoBaseKit *)$p)->getPart(*$partName,$makeIfNeeded)  #} ))    ;; SoNode*  -> gptr

(defmethod SoBaseKit  getPartString ( part)
  
  ((-gptr- "const SoBase *") part)
  (let*  ((retobj (new SbString ()))
	  (retobjp  :retobj:p))
    #{ *((SbString *)$retobjp) = ((SoBaseKit *)$p)->getPartString($part);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoBaseKit  createPathToPart ( partName makeIfNeeded pathToExtend)
  
  ((-gptr- "const SbName *") partName)   ;; reference -> gptr
  ((-int-) makeIfNeeded)                    ;; SbBool -> int
  ((-gptr- "const SoPath *") pathToExtend)
  (gptr #{ ((SoBaseKit *)$p)->createPathToPart(*$partName,$makeIfNeeded,$pathToExtend)  #} ))    ;; SoNodeKitPath*  -> gptr

(defmethod SoBaseKit  setPart ( partName from)
  
  ((-gptr- "const SbName *") partName)   ;; reference -> gptr
  ((-gptr- "SoNode *") from)
  (int #{ ((SoBaseKit *)$p)->setPart(*$partName,$from)  #} ))

;; (defmethod SoBaseKit  set ( s )
;;   
;;   ((-gptr- "char *") s)
;;   (int #{ ((SoBaseKit *)$p)->set($s)  #} ))

;;(defmethod SoBaseKit  set ( p s)
;;  
;;  ((-gptr- "char *") p)
;;  ((-gptr- "char *") s)
;;  (int #{ ((SoBaseKit *)$p)->set($p,$s)  #} ))




;; class SoAppearanceKit : public SoBaseKit
(defclass SoAppearanceKit SoBaseKit)

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





;; class SoInteractionKit : public SoBaseKit
(defclass SoInteractionKit SoBaseKit)

(defmethod SoInteractionKit  setPartAsPath ( partName surrogatePath)
  
  ((-gptr- "const SbName *") partName)   ;; reference -> gptr
  ((-gptr- "SoPath *") surrogatePath)
  (int #{ ((SoInteractionKit *)$p)->setPartAsPath(*$partName,$surrogatePath)  #} ))

(defmethod SoInteractionKit  affectsState (  )
  
  (int #{ ((SoInteractionKit *)$p)->affectsState()  #} ))

(defmethod SoInteractionKit  getsf_renderCaching (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInteractionKit *)$p)->renderCaching);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInteractionKit  getsf_boundingBoxCaching (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInteractionKit *)$p)->boundingBoxCaching);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInteractionKit  getsf_renderCulling (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInteractionKit *)$p)->renderCulling);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoInteractionKit  getsf_pickCulling (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoInteractionKit *)$p)->pickCulling);  #} 
    (setq :retobj:p retobjp)
    retobj))



;; class SoCameraKit : public SoBaseKit
(defclass SoCameraKit SoBaseKit)

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



;; class SoLightKit : public SoBaseKit
(defclass SoLightKit SoBaseKit)

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



;; class SoNodekitCatalog : public InventorObject
(defclass SoNodekitCatalog InventorObject)

(defmethod SoNodekitCatalog  getNumEntries (  )
  
  (int #{ ((SoNodekitCatalog *)$p)->getNumEntries()  #} ))

(defmethod SoNodekitCatalog  getPartNumber ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->getPartNumber(*$theName)  #} ))

(defmethod SoNodekitCatalog  getName ( thePartNumber)
  
  ((-int-) thePartNumber)
  (gptr #{ &(((SoNodekitCatalog *)$p)->getName($thePartNumber))  #} ))  ;; const SbName     & -> gptr

(defmethod SoNodekitCatalog  isNullByDefault ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->isNullByDefault($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  isNullByDefault_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->isNullByDefault(*$theName)  #} ))

(defmethod SoNodekitCatalog  isLeaf ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->isLeaf($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  isLeaf_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->isLeaf(*$theName)  #} ))

(defmethod SoNodekitCatalog  getParentName ( thePartNumber)
  
  ((-int-) thePartNumber)
  (gptr #{ &(((SoNodekitCatalog *)$p)->getParentName($thePartNumber))  #} ))  ;; const SbName     & -> gptr

(defmethod SoNodekitCatalog  getParentName_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (gptr #{ &(((SoNodekitCatalog *)$p)->getParentName(*$theName))  #} ))  ;; const SbName     & -> gptr

(defmethod SoNodekitCatalog  getParentPartNumber ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->getParentPartNumber($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  getParentPartNumber_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->getParentPartNumber(*$theName)  #} ))

(defmethod SoNodekitCatalog  getRightSiblingName ( thePartNumber)
  
  ((-int-) thePartNumber)
  (gptr #{ &(((SoNodekitCatalog *)$p)->getRightSiblingName($thePartNumber))  #} ))  ;; const SbName     & -> gptr

(defmethod SoNodekitCatalog  getRightSiblingName_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (gptr #{ &(((SoNodekitCatalog *)$p)->getRightSiblingName(*$theName))  #} ))  ;; const SbName     & -> gptr

(defmethod SoNodekitCatalog  getRightSiblingPartNumber ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->getRightSiblingPartNumber($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  getRightSiblingPartNumber_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->getRightSiblingPartNumber(*$theName)  #} ))

(defmethod SoNodekitCatalog  isList ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->isList($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  isList_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->isList(*$theName)  #} ))

(defmethod SoNodekitCatalog  getListItemTypes ( thePartNumber)
  
  ((-int-) thePartNumber)
  (gptr #{ &(((SoNodekitCatalog *)$p)->getListItemTypes($thePartNumber))  #} ))  ;; const SoTypeList    & -> gptr

(defmethod SoNodekitCatalog  getListItemTypes_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (gptr #{ &(((SoNodekitCatalog *)$p)->getListItemTypes(*$theName))  #} ))  ;; const SoTypeList    & -> gptr

(defmethod SoNodekitCatalog  isPublic ( thePartNumber)
  
  ((-int-) thePartNumber)
  (int #{ ((SoNodekitCatalog *)$p)->isPublic($thePartNumber)  #} ))

(defmethod SoNodekitCatalog  isPublic_name ( theName)
  
  ((-gptr- "const SbName *") theName)   ;; reference -> gptr
  (int #{ ((SoNodekitCatalog *)$p)->isPublic(*$theName)  #} ))




;; class SoNodeKitListPart : public SoNode
(defclass SoNodeKitListPart SoNode)

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

(defmethod SoNodeKitListPart  setContainerType ( newContainerType)
  
  ((-gptr- "SoType *") newContainerType)    ;; object -> gptr
  #{ ((SoNodeKitListPart *)$p)->setContainerType(*$newContainerType);  #} 
  ())

(defmethod SoNodeKitListPart  getChildTypes (  )
  
  (gptr #{ &(((SoNodeKitListPart *)$p)->getChildTypes())  #} ))  ;; const SoTypeList & -> gptr

(defmethod SoNodeKitListPart  addChildType ( typeToAdd)
  
  ((-gptr- "SoType *") typeToAdd)    ;; object -> gptr
  #{ ((SoNodeKitListPart *)$p)->addChildType(*$typeToAdd);  #} 
  ())

(defmethod SoNodeKitListPart  isTypePermitted ( typeToCheck)
  
  ((-gptr- "SoType *") typeToCheck)    ;; object -> gptr
  (int #{ ((SoNodeKitListPart *)$p)->isTypePermitted(*$typeToCheck)  #} ))

(defmethod SoNodeKitListPart  isChildPermitted ( child)
  
  ((-gptr- "const SoNode *") child)
  (int #{ ((SoNodeKitListPart *)$p)->isChildPermitted($child)  #} ))

(defmethod SoNodeKitListPart  containerSet ( fieldDataString)
  
  ((-gptr- "const char *") fieldDataString)
  #{ ((SoNodeKitListPart *)$p)->containerSet($fieldDataString);  #} 
  ())

(defmethod SoNodeKitListPart  lockTypes (  )
  
  #{ ((SoNodeKitListPart *)$p)->lockTypes();  #} 
  ())

(defmethod SoNodeKitListPart  isTypeLocked (  )
  
  (int #{ ((SoNodeKitListPart *)$p)->isTypeLocked()  #} ))

(defmethod SoNodeKitListPart  addChild ( child)
  
  ((-gptr- "SoNode *") child)
  #{ ((SoNodeKitListPart *)$p)->addChild($child);  #} 
  ())

(defmethod SoNodeKitListPart  insertChild ( child childIndex)
  
  ((-gptr- "SoNode *") child)
  ((-int-) childIndex)
  #{ ((SoNodeKitListPart *)$p)->insertChild($child,$childIndex);  #} 
  ())

(defmethod SoNodeKitListPart  getChild ( index)
  
  ((-int-) index)
  (gptr #{ ((SoNodeKitListPart *)$p)->getChild($index)  #} ))    ;; SoNode  *  -> gptr

(defmethod SoNodeKitListPart  findChild ( child)
  
  ((-gptr- "SoNode *") child)
  (int #{ ((SoNodeKitListPart *)$p)->findChild($child)  #} ))

(defmethod SoNodeKitListPart  getNumChildren (  )
  
  (int #{ ((SoNodeKitListPart *)$p)->getNumChildren()  #} ))

(defmethod SoNodeKitListPart  removeChild ( index)
  
  ((-int-) index)
  #{ ((SoNodeKitListPart *)$p)->removeChild($index);  #} 
  ())

(defmethod SoNodeKitListPart  removeChild_node ( child)
  
  ((-gptr- "SoNode *") child)
  #{ ((SoNodeKitListPart *)$p)->removeChild($child);  #} 
  ())

(defmethod SoNodeKitListPart  replaceChild ( index newChild)
  
  ((-int-) index)
  ((-gptr- "SoNode *") newChild)
  #{ ((SoNodeKitListPart *)$p)->replaceChild($index,$newChild);  #} 
  ())

(defmethod SoNodeKitListPart  replaceChild_node ( oldChild newChild)
  
  ((-gptr- "SoNode *") oldChild)
  ((-gptr- "SoNode *") newChild)
  #{ ((SoNodeKitListPart *)$p)->replaceChild($oldChild,$newChild);  #} 
  ())

(defmethod SoNodeKitListPart  affectsState (  )
  
  (int #{ ((SoNodeKitListPart *)$p)->affectsState()  #} ))





;; class SoSceneKit : public SoBaseKit
(defclass SoSceneKit SoBaseKit)

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

(defmethod SoSceneKit  getCameraNumber (  )
  
  (int #{ ((SoSceneKit *)$p)->getCameraNumber()  #} ))

(defmethod SoSceneKit  setCameraNumber ( camNum)
  
  ((-int-) camNum)
  #{ ((SoSceneKit *)$p)->setCameraNumber($camNum);  #} 
  ())

(defmethod SoSceneKit  affectsState (  )
  
  (int #{ ((SoSceneKit *)$p)->affectsState()  #} ))




;; class SoSeparatorKit : public SoBaseKit
(defclass SoSeparatorKit SoBaseKit)

(defmethod SoSeparatorKit  getsf_renderCaching (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSeparatorKit *)$p)->renderCaching);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSeparatorKit  getsf_boundingBoxCaching (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSeparatorKit *)$p)->boundingBoxCaching);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSeparatorKit  getsf_renderCulling (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSeparatorKit *)$p)->renderCulling);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSeparatorKit  getsf_pickCulling (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSeparatorKit *)$p)->pickCulling);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

(defmethod SoSeparatorKit  affectsState (  )
  
  (int #{ ((SoSeparatorKit *)$p)->affectsState()  #} ))





;; class SoShapeKit : public SoSeparatorKit
(defclass SoShapeKit SoSeparatorKit)

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




;; class SoWrapperKit : public SoSeparatorKit
(defclass SoWrapperKit SoSeparatorKit)

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


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

(dhc-make-with-c++ () () 
  |dummy_nodekits|
  (sobasekit  setpart  createpathtopart  getpartstring  getpart  getnodekitcatalog  sobasekit)
  (soappearancekit  soappearancekit)
  (sointeractionkit  getsf-pickculling  getsf-renderculling  getsf-boundingboxcaching  getsf-rendercaching  affectsstate  setpartaspath)
  (socamerakit  socamerakit)
  (solightkit  solightkit)
  (sonodekitcatalog  ispublic-name  ispublic  getlistitemtypes-name  getlistitemtypes  islist-name  islist  getrightsiblingpartnumber-name  getrightsiblingpartnumber  getrightsiblingname-name  getrightsiblingname  getparentpartnumber-name  getparentpartnumber  getparentname-name  getparentname  isleaf-name  isleaf  isnullbydefault-name  isnullbydefault  getname  getpartnumber  getnumentries)
  (sonodekitlistpart  affectsstate  replacechild-node  replacechild  removechild-node  removechild  getnumchildren  findchild  getchild  insertchild  addchild  istypelocked  locktypes  containerset  ischildpermitted  istypepermitted  addchildtype  getchildtypes  setcontainertype  sonodekitlistpart)
  (soscenekit  affectsstate  setcameranumber  getcameranumber  soscenekit)
  (soseparatorkit  affectsstate  soseparatorkit  getsf-pickculling  getsf-renderculling  getsf-boundingboxcaching  getsf-rendercaching)
  (soshapekit  soshapekit)
  (sowrapperkit  sowrapperkit)
)
