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



#? *** nodes_group

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

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

#? * soswitch
;;.TYPE CLASS
#? (==> <soswitch> getsf-whichchild)
#? (new soswitch <flag>>
#? (==> <soswitch> affectsstate)

#? * sopathswitch
;;.TYPE CLASS
#? (==> <sopathswitch> getsf-path)
#? (new sopathswitch <flag>>

#? * somultiplecopy
;;.TYPE CLASS
#? (==> <somultiplecopy> getmf-matrix)
#? (new somultiplecopy <flag>>
#? (==> <somultiplecopy> affectsstate)

#? * solod
;;.TYPE CLASS
#? (==> <solod> getmf-range)
#? (==> <solod> getsf-center)
#? (new solod <flag>>

#? * solevelofdetail
;;.TYPE CLASS
#? (==> <solevelofdetail> getmf-screenarea)
#? (new solevelofdetail <flag>>

#? * soarray
;;.TYPE CLASS
#? (==> <soarray> getsf-numelements1)
#? (==> <soarray> getsf-numelements2)
#? (==> <soarray> getsf-numelements3)
#? (==> <soarray> getsf-separation1)
#? (==> <soarray> getsf-separation2)
#? (==> <soarray> getsf-separation3)
#? (==> <soarray> getsf-origin)
#? (new soarray <flag>>
#? (==> <soarray> affectsstate)

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

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

#? * solocatehighlight
;;.TYPE CLASS
#? (==> <solocatehighlight> getsf-color)
#? (==> <solocatehighlight> getsf-style)
#? (==> <solocatehighlight> getsf-mode)
#? (new solocatehighlight <flag>>

#? * soselection
;;.TYPE CLASS
#? (new soselection <flag>>
#? (==> <soselection> getsf-policy)
#? (==> <soselection> select-path <path>)
#? (==> <soselection> select-node <node>)
#? (==> <soselection> deselect-path <path>)
#? (==> <soselection> deselect <which>)
#? (==> <soselection> deselect-node <node>)
#? (==> <soselection> toggle-path <path>)
#? (==> <soselection> toggle-node <node>)
#? (==> <soselection> isselected-path <path>)
#? (==> <soselection> isselected-node <node>)
#? (==> <soselection> deselectall)
#? (==> <soselection> getnumselected)
#? (==> <soselection> getlist)
#? (==> <soselection> getpath <index>)
#? (==> <soselection> addselectioncallback <f> <userdata>)
#? (==> <soselection> removeselectioncallback <f> <userdata>)
#? (==> <soselection> adddeselectioncallback <f> <userdata>)
#? (==> <soselection> removedeselectioncallback <f> <userdata>)
#? (==> <soselection> addstartcallback <f> <userdata>)
#? (==> <soselection> removestartcallback <f> <userdata>)
#? (==> <soselection> addfinishcallback <f> <userdata>)
#? (==> <soselection> removefinishcallback <f> <userdata>)
#? (==> <soselection> setpickfiltercallback <f> <userdata> <callonlyifselectable>)
#? (==> <soselection> setpickmatching <picktwice>)
#? (==> <soselection> ispickmatching)
#? (==> <soselection> getpickmatching)

#? * sowwwanchor
;;.TYPE CLASS
#? (new sowwwanchor <flag>>
#? (==> <sowwwanchor> getsf-name)
#? (==> <sowwwanchor> getsf-description)
#? (==> <sowwwanchor> getsf-map)
#? (==> <sowwwanchor> setfullurlname <url>)
#? (==> <sowwwanchor> getfullurlname)

#? * (|dummy_nodes_group|)

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

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


;; class SoTransformSeparator : public SoGroup
(defclass SoTransformSeparator SoGroup)

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

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








;; class SoSwitch : public SoGroup
(defclass SoSwitch SoGroup)

(defmethod SoSwitch  getsf_whichChild (  )
  
  (let* ((retobj (new SoSFInt32 t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSwitch *)$p)->whichChild);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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

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






;; class SoPathSwitch : public SoGroup
(defclass SoPathSwitch SoGroup)

(defmethod SoPathSwitch  getsf_path (  )
  
  (let* ((retobj (new SoSFPath t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoPathSwitch *)$p)->path);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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






;; class SoMultipleCopy : public SoGroup
(defclass SoMultipleCopy SoGroup)

(defmethod SoMultipleCopy  getmf_matrix (  )
  
  (let* ((retobj (new SoMFMatrix t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoMultipleCopy *)$p)->matrix);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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









;; class SoLOD : public SoGroup
(defclass SoLOD SoGroup)

(defmethod SoLOD  getmf_range (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLOD *)$p)->range);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoLOD  getsf_center (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLOD *)$p)->center);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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




;; class SoLevelOfDetail : public SoGroup
(defclass SoLevelOfDetail SoGroup)

(defmethod SoLevelOfDetail  getmf_screenArea (  )
  
  (let* ((retobj (new SoMFFloat t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLevelOfDetail *)$p)->screenArea);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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











;; class SoArray : public SoGroup    
(defclass SoArray SoGroup)

(defmethod SoArray  getsf_numElements1 (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->numElements1);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_numElements2 (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->numElements2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_numElements3 (  )
  
  (let* ((retobj (new SoSFShort t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->numElements3);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_separation1 (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->separation1);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_separation2 (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->separation2);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_separation3 (  )
  
  (let* ((retobj (new SoSFVec3f t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->separation3);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoArray  getsf_origin (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoArray *)$p)->origin);  #} 
    (setq :retobj:p retobjp)
    retobj))

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

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






;; class SoSeparator : public SoGroup
(defclass SoSeparator SoGroup)

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

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

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

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

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

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

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




;;************* separator *********************************

;; class SoAnnotation : public SoSeparator    
(defclass SoAnnotation SoSeparator)

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



;; class SoLocateHighlight : public SoSeparator
(defclass SoLocateHighlight SoSeparator)

(defmethod SoLocateHighlight  getsf_color (  )
  
  (let* ((retobj (new SoSFColor t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLocateHighlight *)$p)->color);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoLocateHighlight  getsf_style (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLocateHighlight *)$p)->style);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoLocateHighlight  getsf_mode (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoLocateHighlight *)$p)->mode);  #} 
    (setq :retobj:p retobjp)
    retobj))

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




;; class SoSelection : public SoSeparator
(defclass SoSelection SoSeparator)

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

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

(defmethod SoSelection  getsf_policy (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoSelection *)$p)->policy);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoSelection  select_path ( path)
  
  ((-gptr- "const SoPath *") path)
  #{ ((SoSelection *)$p)->select($path);  #} 
  ())

(defmethod SoSelection  select_node ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoSelection *)$p)->select($node);  #} 
  ())

(defmethod SoSelection  deselect_path ( path)
  
  ((-gptr- "const SoPath *") path)
  #{ ((SoSelection *)$p)->deselect($path);  #} 
  ())

(defmethod SoSelection  deselect ( which)
  
  ((-int-) which)
  #{ ((SoSelection *)$p)->deselect($which);  #} 
  ())

(defmethod SoSelection  deselect_node ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoSelection *)$p)->deselect($node);  #} 
  ())

(defmethod SoSelection  toggle_path ( path)
  
  ((-gptr- "const SoPath *") path)
  #{ ((SoSelection *)$p)->toggle($path);  #} 
  ())

(defmethod SoSelection  toggle_node ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoSelection *)$p)->toggle($node);  #} 
  ())

(defmethod SoSelection  isSelected_path ( path)
  
  ((-gptr- "const SoPath *") path)
  (int #{ ((SoSelection *)$p)->isSelected($path)  #} ))

(defmethod SoSelection  isSelected_node ( node)
  
  ((-gptr- "SoNode *") node)
  (int #{ ((SoSelection *)$p)->isSelected($node)  #} ))

(defmethod SoSelection  deselectAll (  )
  
  #{ ((SoSelection *)$p)->deselectAll();  #} 
  ())

(defmethod SoSelection  getNumSelected (  )
  
  (int #{ ((SoSelection *)$p)->getNumSelected()  #} ))

(defmethod SoSelection  getList (  )
  
  (gptr #{ ((SoSelection *)$p)->getList()  #} ))    ;; const SoPathList *  -> gptr

(defmethod SoSelection  getPath ( index)
  
  ((-int-) index)
  (gptr #{ ((SoSelection *)$p)->getPath($index)  #} ))    ;; SoPath  *  -> gptr

(defmethod SoSelection  addSelectionCallback ( f userData)
  
  ((-gptr- "SoSelectionPathCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->addSelectionCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  removeSelectionCallback ( f userData)
  
  ((-gptr- "SoSelectionPathCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->removeSelectionCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  addDeselectionCallback ( f userData)
  
  ((-gptr- "SoSelectionPathCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->addDeselectionCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  removeDeselectionCallback ( f userData)
  
  ((-gptr- "SoSelectionPathCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->removeDeselectionCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  addStartCallback ( f userData)
  
  ((-gptr- "SoSelectionClassCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->addStartCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  removeStartCallback ( f userData)
  
  ((-gptr- "SoSelectionClassCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->removeStartCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  addFinishCallback ( f userData)
  
  ((-gptr- "SoSelectionClassCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->addFinishCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  removeFinishCallback ( f userData)
  
  ((-gptr- "SoSelectionClassCB *") f)
  ((-gptr-) userData)
  #{ ((SoSelection *)$p)->removeFinishCallback($f,$userData);  #} 
  ())

(defmethod SoSelection  setPickFilterCallback ( f userData callOnlyIfSelectable)
  
  ((-gptr- "SoSelectionPickCB *") f)
  ((-gptr-) userData)
  ((-int-) callOnlyIfSelectable)                    ;; SbBool -> int
  #{ ((SoSelection *)$p)->setPickFilterCallback($f,$userData,$callOnlyIfSelectable);  #} 
  ())

(defmethod SoSelection  setPickMatching ( pickTwice)
  
  ((-int-) pickTwice)                    ;; SbBool -> int
  #{ ((SoSelection *)$p)->setPickMatching($pickTwice);  #} 
  ())

(defmethod SoSelection  isPickMatching (  )
  
  (int #{ ((SoSelection *)$p)->isPickMatching()  #} ))

(defmethod SoSelection  getPickMatching (  )
  
  (int #{ ((SoSelection *)$p)->getPickMatching()  #} ))







;; class SoWWWAnchor : public SoLocateHighlight
(defclass SoWWWAnchor SoLocateHighlight)

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

(defmethod SoWWWAnchor  getsf_name (  )
  
  (let* ((retobj (new SoSFString t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoWWWAnchor *)$p)->name);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoWWWAnchor  getsf_description (  )
  
  (let* ((retobj (new SoSFString t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoWWWAnchor *)$p)->description);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoWWWAnchor  getsf_map (  )
  
  (let* ((retobj (new SoSFEnum t))
	 (retobjp :retobj:p))
    #{ $retobjp = &(((SoWWWAnchor *)$p)->map);  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoWWWAnchor  setFullURLName ( url)
  
  ((-gptr- "const SbString *") url)   ;; reference -> gptr
  #{ ((SoWWWAnchor *)$p)->setFullURLName(*$url);  #} 
  ())

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


()


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

(dhc-make-with-c++ () () 
  |dummy_nodes_group|
  (sotransformseparator  sotransformseparator)
  (soswitch  affectsstate  soswitch  getsf-whichchild)
  (sopathswitch  sopathswitch  getsf-path)
  (somultiplecopy  affectsstate  somultiplecopy  getmf-matrix)
  (solod  solod  getsf-center  getmf-range)
  (solevelofdetail  solevelofdetail  getmf-screenarea)
  (soarray  affectsstate  soarray  getsf-origin  getsf-separation3  getsf-separation2  getsf-separation1  getsf-numelements3  getsf-numelements2  getsf-numelements1)
  (soseparator  affectsstate  soseparator  getsf-pickculling  getsf-renderculling  getsf-boundingboxcaching  getsf-rendercaching)
  (soannotation  soannotation)
  (solocatehighlight  solocatehighlight  getsf-mode  getsf-style  getsf-color)
  (soselection  getpickmatching  ispickmatching  setpickmatching  setpickfiltercallback  removefinishcallback  addfinishcallback  removestartcallback  addstartcallback  removedeselectioncallback  adddeselectioncallback  removeselectioncallback  addselectioncallback  getpath  getlist  getnumselected  deselectall  isselected-node  isselected-path  toggle-node  toggle-path  deselect-node  deselect  deselect-path  select-node  select-path  getsf-policy  soselection)
  (sowwwanchor  getfullurlname  setfullurlname  getsf-map  getsf-description  getsf-name  sowwwanchor)
)
