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



#? *** actions

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

#? * soaction
;;.TYPE CLASS
#? (==> <soaction> -destructor)
#? (==> <soaction> isoftype <type>)
#? (==> <soaction> apply-node <node>)
#? (==> <soaction> apply-path <path>)
#? (==> <soaction> apply-list <pathlist> <obeysrules>)
#? (==> <soaction> invalidatestate)

#? * socallbackaction
;;.TYPE CLASS
#? (new socallbackaction <flag>>
#? (==> <socallbackaction> -destructor)
#? (==> <socallbackaction> addprecallback <type> <cb> <data>)
#? (==> <socallbackaction> addpostcallback <type> <cb> <data>)
#? (==> <socallbackaction> addpretailcallback <cb> <data>)
#? (==> <socallbackaction> addposttailcallback <cb> <data>)
#? (==> <socallbackaction> addtrianglecallback <type> <cb> <data>)
#? (==> <socallbackaction> addlinesegmentcallback <type> <cb> <data>)
#? (==> <socallbackaction> addpointcallback <type> <cb> <data>)
#? (==> <socallbackaction> getcomplexity)
#? (==> <socallbackaction> getcomplexitytype)
#? (==> <socallbackaction> getnumcoordinates)
#? (==> <socallbackaction> getcoordinate3 <index>)
#? (==> <socallbackaction> getcoordinate4 <index>)
#? (==> <socallbackaction> getdrawstyle)
#? (==> <socallbackaction> getlinepattern)
#? (==> <socallbackaction> getlinewidth)
#? (==> <socallbackaction> getpointsize)
#? (==> <socallbackaction> getfontname)
#? (==> <socallbackaction> getfontsize)
#? (==> <socallbackaction> getlightmodel)
#? (==> <socallbackaction> getlightattenuation)
#? (==> <socallbackaction> getmaterial <ambient> <diffuse> <specular> <emission> <shininess> <transparency> <mtlindex>)
#? (==> <socallbackaction> getmaterialbinding)
#? (==> <socallbackaction> getnumnormals)
#? (==> <socallbackaction> getnormal <index>)
#? (==> <socallbackaction> getnormalbinding)
#? (==> <socallbackaction> getnumprofilecoordinates)
#? (==> <socallbackaction> getprofilecoordinate2 <index>)
#? (==> <socallbackaction> getprofilecoordinate3 <index>)
#? (==> <socallbackaction> getprofile)
#? (==> <socallbackaction> getvertexordering)
#? (==> <socallbackaction> getshapetype)
#? (==> <socallbackaction> getfacetype)
#? (==> <socallbackaction> getcreaseangle)
#? (==> <socallbackaction> getnumtexturecoordinates)
#? (==> <socallbackaction> gettexturecoordinate2 <index>)
#? (==> <socallbackaction> gettexturecoordinate4 <index>)
#? (==> <socallbackaction> gettexturecoordinatebinding)
#? (==> <socallbackaction> gettextureblendcolor)
#? (==> <socallbackaction> gettextureimage <size> <numcomps>)
#? (==> <socallbackaction> gettexturematrix)
#? (==> <socallbackaction> gettexturemodel)
#? (==> <socallbackaction> gettexturewraps)
#? (==> <socallbackaction> gettexturewrapt)
#? (==> <socallbackaction> getmodelmatrix)
#? (==> <socallbackaction> getunits)
#? (==> <socallbackaction> getfocaldistance)
#? (==> <socallbackaction> getprojectionmatrix)
#? (==> <socallbackaction> getviewingmatrix)
#? (==> <socallbackaction> getviewvolume)
#? (==> <socallbackaction> getpickstyle)
#? (==> <socallbackaction> getswitch)

#? * sogetboundingboxaction
;;.TYPE CLASS
#? (new sogetboundingboxaction <flag> <viewportregion>>
#? (==> <sogetboundingboxaction> -destructor)
#? (==> <sogetboundingboxaction> setviewportregion <newregion>)
#? (==> <sogetboundingboxaction> getviewportregion)
#? (==> <sogetboundingboxaction> getboundingbox)
#? (==> <sogetboundingboxaction> getxfboundingbox)
#? (==> <sogetboundingboxaction> getcenter)
#? (==> <sogetboundingboxaction> setincameraspace <flag>)
#? (==> <sogetboundingboxaction> isincameraspace)
#? (==> <sogetboundingboxaction> setresetpath <path> <resetbefore> <what>)
#? (==> <sogetboundingboxaction> getresetpath)
#? (==> <sogetboundingboxaction> isresetpath)
#? (==> <sogetboundingboxaction> isresetbefore)
#? (==> <sogetboundingboxaction> getwhatreset)

#? * sogetmatrixaction
;;.TYPE CLASS
#? (new sogetmatrixaction <flag> <newregion>>
#? (==> <sogetmatrixaction> -destructor)
#? (==> <sogetmatrixaction> setviewportregion <newregion>)
#? (==> <sogetmatrixaction> getviewportregion)
#? (==> <sogetmatrixaction> getmatrix)
#? (==> <sogetmatrixaction> getinverse)
#? (==> <sogetmatrixaction> gettexturematrix)
#? (==> <sogetmatrixaction> gettextureinverse)

#? * soglrenderaction
;;.TYPE CLASS
#? (new soglrenderaction <flag> <viewportregion>>
#? (==> <soglrenderaction> -destructor)
#? (==> <soglrenderaction> setviewportregion <newregion>)
#? (==> <soglrenderaction> getviewportregion)
#? (==> <soglrenderaction> setupdatearea <origin> <size>)
#? (==> <soglrenderaction> getupdatearea <origin> <size>)
#? (==> <soglrenderaction> setabortcallback <func> <userdata>)
#? (==> <soglrenderaction> settransparencytype <type>)
#? (==> <soglrenderaction> gettransparencytype)
#? (==> <soglrenderaction> setsmoothing <smooth>)
#? (==> <soglrenderaction> issmoothing)
#? (==> <soglrenderaction> setnumpasses <num>)
#? (==> <soglrenderaction> getnumpasses)
#? (==> <soglrenderaction> setpassupdate <flag>)
#? (==> <soglrenderaction> ispassupdate)
#? (==> <soglrenderaction> setpasscallback <func> <userdata>)
#? (==> <soglrenderaction> setcachecontext <context>)
#? (==> <soglrenderaction> getcachecontext)
#? (==> <soglrenderaction> setrenderingisremote <flag>)
#? (==> <soglrenderaction> getrenderingisremote)
#? (==> <soglrenderaction> invalidatestate)

#? * sohandleeventaction
;;.TYPE CLASS
#? (new sohandleeventaction <flag> <viewportregion>>
#? (==> <sohandleeventaction> -destructor)
#? (==> <sohandleeventaction> setviewportregion <newregion>)
#? (==> <sohandleeventaction> getviewportregion)
#? (==> <sohandleeventaction> setevent <ev>)
#? (==> <sohandleeventaction> getevent)
#? (==> <sohandleeventaction> sethandled)
#? (==> <sohandleeventaction> ishandled)
#? (==> <sohandleeventaction> setgrabber <node>)
#? (==> <sohandleeventaction> releasegrabber)
#? (==> <sohandleeventaction> getgrabber)
#? (==> <sohandleeventaction> setpickroot <node>)
#? (==> <sohandleeventaction> getpickroot)
#? (==> <sohandleeventaction> setpickradius <radiusinpixels>)
#? (==> <sohandleeventaction> getpickedpoint)
#? (==> <sohandleeventaction> getpickedpointlist)

#? * sopickaction
;;.TYPE CLASS
#? (==> <sopickaction> setviewportregion <newregion>)
#? (==> <sopickaction> getviewportregion)

#? * soraypickaction
;;.TYPE CLASS
#? (new soraypickaction <flag> <viewportregion>>
#? (==> <soraypickaction> -destructor)
#? (==> <soraypickaction> setpoint <viewportpoint>)
#? (==> <soraypickaction> setnormalizedpoint <normpoint>)
#? (==> <soraypickaction> setradius <radiusinpixels>)
#? (==> <soraypickaction> setray <start> <direction> <neardistance> <fardistance>)
#? (==> <soraypickaction> setpickall <flag>)
#? (==> <soraypickaction> ispickall)
#? (==> <soraypickaction> getpickedpointlist)
#? (==> <soraypickaction> getpickedpoint <index>)

#? * sosearchaction
;;.TYPE CLASS
#? (new sosearchaction <flag>>
#? (==> <sosearchaction> -destructor)
#? (==> <sosearchaction> reset)
#? (==> <sosearchaction> setfind <what>)
#? (==> <sosearchaction> getfind)
#? (==> <sosearchaction> getnode)
#? (==> <sosearchaction> setnode <n>)
#? (==> <sosearchaction> settype <s> <derivedisok>)
#? (==> <sosearchaction> getname)
#? (==> <sosearchaction> setname <n>)
#? (==> <sosearchaction> getinterest)
#? (==> <sosearchaction> setinterest <i>)
#? (==> <sosearchaction> issearchingall)
#? (==> <sosearchaction> setsearchingall <flag>)
#? (==> <sosearchaction> getpath)
#? (==> <sosearchaction> getpaths)

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

#? * soboxhighlightrenderaction
;;.TYPE CLASS
#? (new soboxhighlightrenderaction <flag>>
#? (==> <soboxhighlightrenderaction> -destructor)
#? (==> <soboxhighlightrenderaction> apply-node <node>)
#? (==> <soboxhighlightrenderaction> apply-path <path>)
#? (==> <soboxhighlightrenderaction> apply <pathlist> <obeysrules>)
#? (==> <soboxhighlightrenderaction> setvisible <b>)
#? (==> <soboxhighlightrenderaction> isvisible)
#? (==> <soboxhighlightrenderaction> setcolor <c>)
#? (==> <soboxhighlightrenderaction> getcolor)
#? (==> <soboxhighlightrenderaction> setlinepattern <pattern>)
#? (==> <soboxhighlightrenderaction> getlinepattern)
#? (==> <soboxhighlightrenderaction> setlinewidth <width>)
#? (==> <soboxhighlightrenderaction> getlinewidth)

#? * solinehighlightrenderaction
;;.TYPE CLASS
#? (new solinehighlightrenderaction <flag>>
#? (==> <solinehighlightrenderaction> -destructor)
#? (==> <solinehighlightrenderaction> apply-node <node>)
#? (==> <solinehighlightrenderaction> apply-path <path>)
#? (==> <solinehighlightrenderaction> apply-list <pathlist> <obeysrules>)
#? (==> <solinehighlightrenderaction> setvisible <b>)
#? (==> <solinehighlightrenderaction> isvisible)
#? (==> <solinehighlightrenderaction> setcolor <c>)
#? (==> <solinehighlightrenderaction> getcolor)
#? (==> <solinehighlightrenderaction> setlinepattern <pattern>)
#? (==> <solinehighlightrenderaction> getlinepattern)
#? (==> <solinehighlightrenderaction> setlinewidth <width>)
#? (==> <solinehighlightrenderaction> getlinewidth)

#? * (|dummy_actions|)

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


;;*****************************************************************
;;************   actions   ********************
;;*****************************************************************
(libload "inventor/sotype")

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

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

(defmethod SoAction  isOfType (  type )
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  (int #{ ((SoAction *)$p)->isOfType(*$type)  #} ))

(defmethod SoAction  apply_node (  node )
  
  ((-gptr- "SoNode *") node)
  #{ ((SoAction *)$p)->apply($node);  #} 
  ())

(defmethod SoAction  apply_path (  path )
  
  ((-gptr- "SoPath *") path)
  #{ ((SoAction *)$p)->apply($path);  #} 
  ())

(defmethod SoAction  apply_list (  pathList obeysRules )
  
  ((-gptr- "const SoPathList *") pathList)  ;; reference -> gptr
  ((-int-) obeysRules)                    ;; SbBool -> int
  #{ ((SoAction *)$p)->apply(*$pathList,$obeysRules);  #} 
  ())

(defmethod SoAction  invalidateState (  )
  
  #{ ((SoAction *)$p)->invalidateState();  #} 
  ())


;; class SoCallbackAction : public SoAction
(defclass SoCallbackAction SoAction)


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

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

(defmethod SoCallbackAction  addPreCallback ( type cb data)
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  ((-gptr- "SoCallbackAction::SoCallbackActionCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addPreCallback(*$type,$cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addPostCallback ( type cb data)
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  ((-gptr- "SoCallbackAction::SoCallbackActionCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addPostCallback(*$type,$cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addPreTailCallback ( cb data)
  
  ((-gptr- "SoCallbackAction::SoCallbackActionCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addPreTailCallback($cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addPostTailCallback ( cb data)
  
  ((-gptr- "SoCallbackAction::SoCallbackActionCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addPostTailCallback($cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addTriangleCallback ( type cb data)
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  ((-gptr- "SoTriangleCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addTriangleCallback(*$type,$cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addLineSegmentCallback ( type cb data)
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  ((-gptr- "SoLineSegmentCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addLineSegmentCallback(*$type,$cb,$data);  #} 
  ())

(defmethod SoCallbackAction  addPointCallback ( type cb data)
  
  ((-gptr- "SoType *") type)    ;; object -> gptr
  ((-gptr- "SoPointCB *") cb)
  ((-gptr-) data)
  #{ ((SoCallbackAction *)$p)->addPointCallback(*$type,$cb,$data);  #} 
  ())

(defmethod SoCallbackAction  getComplexity (  )
  
  (float #{ ((SoCallbackAction *)$p)->getComplexity()  #} ))

(defmethod SoCallbackAction  getComplexityType (  )
  
  (int #{ ((SoCallbackAction *)$p)->getComplexityType()  #} ))   ;; SoComplexity::Type

(defmethod SoCallbackAction  getNumCoordinates (  )
  
  (int #{ ((SoCallbackAction *)$p)->getNumCoordinates()  #} ))  ;; int32_t -> int

(defmethod SoCallbackAction  getCoordinate3 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getCoordinate3($index))  #} ))  ;; const SbVec3f & -> gptr

(defmethod SoCallbackAction  getCoordinate4 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getCoordinate4($index))  #} ))  ;; const SbVec4f & -> gptr

(defmethod SoCallbackAction  getDrawStyle (  )
  
  (int #{ ((SoCallbackAction *)$p)->getDrawStyle()  #} ))   ;; SoDrawStyle::Style

(defmethod SoCallbackAction  getLinePattern (  )
  
  (int  #{ ((SoCallbackAction *)$p)->getLinePattern()  #} ))   ;; u_short -> int

(defmethod SoCallbackAction  getLineWidth (  )
  
  (float #{ ((SoCallbackAction *)$p)->getLineWidth()  #} ))

(defmethod SoCallbackAction  getPointSize (  )
  
  (float #{ ((SoCallbackAction *)$p)->getPointSize()  #} ))

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

(defmethod SoCallbackAction  getFontSize (  )
  
  (float #{ ((SoCallbackAction *)$p)->getFontSize()  #} ))

(defmethod SoCallbackAction  getLightModel (  )
  
  (int #{ ((SoCallbackAction *)$p)->getLightModel()  #} ))   ;; SoLightModel::Model

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

(defmethod SoCallbackAction  getMaterial ( ambient diffuse specular emission shininess transparency mtlIndex)
  
  ((-gptr- "SbColor *") ambient)   ;; reference -> gptr
  ((-gptr- "SbColor *") diffuse)   ;; reference -> gptr
  ((-gptr- "SbColor *") specular)   ;; reference -> gptr
  ((-gptr- "SbColor *") emission)   ;; reference -> gptr
  ((-gptr- "float   *") shininess)   ;; reference -> gptr
  ((-gptr- "float   *") transparency)   ;; reference -> gptr
  ((-int-) mtlIndex)
  #{ ((SoCallbackAction *)$p)->getMaterial(*$ambient, *$diffuse, *$specular, *$emission, *$shininess, *$transparency,$mtlIndex);  #} 
  ())

(defmethod SoCallbackAction  getMaterialBinding (  )
  
  (int #{ ((SoCallbackAction *)$p)->getMaterialBinding()  #} ))   ;; SoMaterialBinding::Binding

(defmethod SoCallbackAction  getNumNormals (  )
  
  (int #{ ((SoCallbackAction *)$p)->getNumNormals()  #} ))  ;; int32_t -> int

(defmethod SoCallbackAction  getNormal ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getNormal($index))  #} ))  ;; const SbVec3f & -> gptr

(defmethod SoCallbackAction  getNormalBinding (  )
  
  (int #{ ((SoCallbackAction *)$p)->getNormalBinding()  #} ))   ;; SoNormalBinding::Binding

(defmethod SoCallbackAction  getNumProfileCoordinates (  )
  
  (int #{ ((SoCallbackAction *)$p)->getNumProfileCoordinates()  #} ))  ;; int32_t -> int

(defmethod SoCallbackAction  getProfileCoordinate2 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getProfileCoordinate2($index))  #} ))  ;; const SbVec2f & -> gptr

(defmethod SoCallbackAction  getProfileCoordinate3 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getProfileCoordinate3($index))  #} ))  ;; const SbVec3f & -> gptr

(defmethod SoCallbackAction  getProfile (  )
  
  (gptr #{ &(((SoCallbackAction *)$p)->getProfile())  #} ))  ;; const SoNodeList & -> gptr

(defmethod SoCallbackAction  getVertexOrdering (  )
  
  (int #{ ((SoCallbackAction *)$p)->getVertexOrdering()  #} ))   ;; SoShapeHints::VertexOrdering

(defmethod SoCallbackAction  getShapeType (  )
  
  (int #{ ((SoCallbackAction *)$p)->getShapeType()  #} ))   ;; SoShapeHints::ShapeType

(defmethod SoCallbackAction  getFaceType (  )
  
  (int #{ ((SoCallbackAction *)$p)->getFaceType()  #} ))   ;; SoShapeHints::FaceType

(defmethod SoCallbackAction  getCreaseAngle (  )
  
  (float #{ ((SoCallbackAction *)$p)->getCreaseAngle()  #} ))

(defmethod SoCallbackAction  getNumTextureCoordinates (  )
  
  (int #{ ((SoCallbackAction *)$p)->getNumTextureCoordinates()  #} ))  ;; int32_t -> int

(defmethod SoCallbackAction  getTextureCoordinate2 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getTextureCoordinate2($index))  #} ))  ;; const SbVec2f & -> gptr

(defmethod SoCallbackAction  getTextureCoordinate4 ( index)
  
  ((-int-) index)
  (gptr #{ &(((SoCallbackAction *)$p)->getTextureCoordinate4($index))  #} ))  ;; const SbVec4f & -> gptr

(defmethod SoCallbackAction  getTextureCoordinateBinding (  )
  
  (int #{ ((SoCallbackAction *)$p)->getTextureCoordinateBinding()  #} ))   ;; SoTextureCoordinateBinding::Binding

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

(defmethod SoCallbackAction  getTextureImage ( size numComps)
  
  ((-gptr- "SbVec2s *") size)   ;; reference -> gptr
  ((-gptr- "int *") numComps)   ;; reference -> gptr
  (gptr #{ ((SoCallbackAction *)$p)->getTextureImage(*$size, *$numComps)  #} ))    ;; const unsigned char *  -> gptr

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

(defmethod SoCallbackAction  getTextureModel (  )
  
  (int #{ ((SoCallbackAction *)$p)->getTextureModel()  #} ))   ;; SoTexture2::Model

(defmethod SoCallbackAction  getTextureWrapS (  )
  
  (int #{ ((SoCallbackAction *)$p)->getTextureWrapS()  #} ))   ;; SoTexture2::Wrap

(defmethod SoCallbackAction  getTextureWrapT (  )
  
  (int #{ ((SoCallbackAction *)$p)->getTextureWrapT()  #} ))   ;; SoTexture2::Wrap

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

(defmethod SoCallbackAction  getUnits (  )
  
  (int #{ ((SoCallbackAction *)$p)->getUnits()  #} ))   ;; SoUnits::Units

(defmethod SoCallbackAction  getFocalDistance (  )
  
  (float #{ ((SoCallbackAction *)$p)->getFocalDistance()  #} ))

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

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

(defmethod SoCallbackAction  getViewVolume (  )
  
  (gptr #{ &(((SoCallbackAction *)$p)->getViewVolume())  #} ))  ;; const SbViewVolume & -> gptr

(defmethod SoCallbackAction  getPickStyle (  )
  
  (int #{ ((SoCallbackAction *)$p)->getPickStyle()  #} ))   ;; SoPickStyle::Style

(defmethod SoCallbackAction  getSwitch (  )
  
  (int #{ ((SoCallbackAction *)$p)->getSwitch()  #} ))  ;; int32_t -> int





;; class SoGetBoundingBoxAction : public SoAction
(defclass SoGetBoundingBoxAction SoAction)

(defmethod SoGetBoundingBoxAction  SoGetBoundingBoxAction ( flag viewportRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoGetBoundingBoxAction(*$viewportRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

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

(defmethod SoGetBoundingBoxAction  setViewportRegion ( newRegion)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{ ((SoGetBoundingBoxAction *)$p)->setViewportRegion(*$newRegion);  #} 
  ())

(defmethod SoGetBoundingBoxAction  getViewportRegion (  )
  
  (gptr #{ &(((SoGetBoundingBoxAction *)$p)->getViewportRegion())  #} ))  ;; const SbViewportRegion & -> gptr

(defmethod SoGetBoundingBoxAction  getBoundingBox (  )
  
  (let*  ((retobj (new SbBox3f ()))
	  (retobjp  :retobj:p))
    #{ *((SbBox3f *)$retobjp) = ((SoGetBoundingBoxAction *)$p)->getBoundingBox();  #} 
    (setq :retobj:p retobjp)
    retobj))

(defmethod SoGetBoundingBoxAction  getXfBoundingBox (  )
  
  (gptr #{ &(((SoGetBoundingBoxAction *)$p)->getXfBoundingBox())  #} ))  ;; SbXfBox3f & -> gptr

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

(defmethod SoGetBoundingBoxAction  setInCameraSpace ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoGetBoundingBoxAction *)$p)->setInCameraSpace($flag);  #} 
  ())

(defmethod SoGetBoundingBoxAction  isInCameraSpace (  )
  
  (int #{ ((SoGetBoundingBoxAction *)$p)->isInCameraSpace()  #} ))

(defmethod SoGetBoundingBoxAction  setResetPath ( path resetBefore what)
  
  ((-gptr- "const SoPath *") path)
  ((-int-) resetBefore)                    ;; SbBool -> int
  ((-int-) what)   ;; ResetType(enum) -> int
  #{ ((SoGetBoundingBoxAction *)$p)->setResetPath($path,$resetBefore,(SoGetBoundingBoxAction::ResetType) $what);  #} 
  ())

(defmethod SoGetBoundingBoxAction  getResetPath (  )
  
  (gptr #{ ((SoGetBoundingBoxAction *)$p)->getResetPath()  #} ))    ;; const SoPath *  -> gptr

(defmethod SoGetBoundingBoxAction  isResetPath (  )
  
  (int #{ ((SoGetBoundingBoxAction *)$p)->isResetPath()  #} ))

(defmethod SoGetBoundingBoxAction  isResetBefore (  )
  
  (int #{ ((SoGetBoundingBoxAction *)$p)->isResetBefore()  #} ))

(defmethod SoGetBoundingBoxAction  getWhatReset (  )
  
  (int #{ ((SoGetBoundingBoxAction *)$p)->getWhatReset()  #} ))   ;; SoGetBoundingBoxAction::ResetType




;; class SoGetMatrixAction : public SoAction
(defclass SoGetMatrixAction SoAction)

(defmethod SoGetMatrixAction  SoGetMatrixAction ( flag newRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoGetMatrixAction(*$newRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

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

(defmethod SoGetMatrixAction  setViewportRegion ( newRegion)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{ ((SoGetMatrixAction *)$p)->setViewportRegion(*$newRegion);  #} 
  ())

(defmethod SoGetMatrixAction  getViewportRegion (  )
  
  (gptr #{ &(((SoGetMatrixAction *)$p)->getViewportRegion())  #} ))  ;; const SbViewportRegion & -> gptr

(defmethod SoGetMatrixAction  getMatrix (  )
  
  (gptr #{ &(((SoGetMatrixAction *)$p)->getMatrix())  #} ))  ;; SbMatrix & -> gptr

(defmethod SoGetMatrixAction  getInverse (  )
  
  (gptr #{ &(((SoGetMatrixAction *)$p)->getInverse())  #} ))  ;; SbMatrix & -> gptr

(defmethod SoGetMatrixAction  getTextureMatrix (  )
  
  (gptr #{ &(((SoGetMatrixAction *)$p)->getTextureMatrix())  #} ))  ;; SbMatrix & -> gptr

(defmethod SoGetMatrixAction  getTextureInverse (  )
  
  (gptr #{ &(((SoGetMatrixAction *)$p)->getTextureInverse())  #} ))  ;; SbMatrix & -> gptr






;; class SoGLRenderAction : public SoAction
(defclass SoGLRenderAction SoAction)


(defmethod SoGLRenderAction  SoGLRenderAction ( flag viewportRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoGLRenderAction(*$viewportRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

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

(defmethod SoGLRenderAction  setViewportRegion ( newRegion)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{ ((SoGLRenderAction *)$p)->setViewportRegion(*$newRegion);  #} 
  ())

(defmethod SoGLRenderAction  getViewportRegion (  )
  
  (gptr #{ &(((SoGLRenderAction *)$p)->getViewportRegion())  #} ))  ;; const SbViewportRegion & -> gptr

(defmethod SoGLRenderAction  setUpdateArea ( origin size)
  
  ((-gptr- "const SbVec2f *") origin)   ;; reference -> gptr
  ((-gptr- "const SbVec2f *") size)   ;; reference -> gptr
  #{ ((SoGLRenderAction *)$p)->setUpdateArea(*$origin, *$size);  #} 
  ())

(defmethod SoGLRenderAction  getUpdateArea ( origin size)
  
  ((-gptr- "SbVec2f *") origin)   ;; reference -> gptr
  ((-gptr- "SbVec2f *") size)   ;; reference -> gptr
  #{ ((SoGLRenderAction *)$p)->getUpdateArea(*$origin,*$size);  #} 
  ())

(defmethod SoGLRenderAction  setAbortCallback ( func userData)
  
  ((-gptr- "SoGLRenderAction::SoGLRenderAbortCB *") func)
  ((-gptr-) userData)
  #{ ((SoGLRenderAction *)$p)->setAbortCallback($func,$userData);  #} 
  ())

(defmethod SoGLRenderAction  setTransparencyType ( type)
  
  ((-int-) type)  ;; TransparencyType -> int
  #{ ((SoGLRenderAction *)$p)->setTransparencyType((SoGLRenderAction::TransparencyType)$type);  #} 
  ())

(defmethod SoGLRenderAction  getTransparencyType (  )
  
  (int  #{ ((SoGLRenderAction *)$p)->getTransparencyType()  #} )) ;; TransparencyType -> int

(defmethod SoGLRenderAction  setSmoothing ( smooth)
  
  ((-int-) smooth)                    ;; SbBool -> int
  #{ ((SoGLRenderAction *)$p)->setSmoothing($smooth);  #} 
  ())

(defmethod SoGLRenderAction  isSmoothing (  )
  
  (int #{ ((SoGLRenderAction *)$p)->isSmoothing()  #} ))

(defmethod SoGLRenderAction  setNumPasses ( num)
  
  ((-int-) num)
  #{ ((SoGLRenderAction *)$p)->setNumPasses($num);  #} 
  ())

(defmethod SoGLRenderAction  getNumPasses (  )
  
  (int #{ ((SoGLRenderAction *)$p)->getNumPasses()  #} ))

(defmethod SoGLRenderAction  setPassUpdate ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoGLRenderAction *)$p)->setPassUpdate($flag);  #} 
  ())

(defmethod SoGLRenderAction  isPassUpdate (  )
  
  (int #{ ((SoGLRenderAction *)$p)->isPassUpdate()  #} ))

(defmethod SoGLRenderAction  setPassCallback ( func userData)
  
  ((-gptr- "SoGLRenderPassCB *") func)
  ((-gptr-) userData)
  #{ ((SoGLRenderAction *)$p)->setPassCallback($func,$userData);  #} 
  ())

(defmethod SoGLRenderAction  setCacheContext ( context)
  
  ((-int-) context)    ;; uint32_t -> int
  #{ ((SoGLRenderAction *)$p)->setCacheContext($context);  #} 
  ())

(defmethod SoGLRenderAction  getCacheContext (  )
  
  (int #{ ((SoGLRenderAction *)$p)->getCacheContext()  #} )) ;; uint32_t -> int

(defmethod SoGLRenderAction  setRenderingIsRemote ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoGLRenderAction *)$p)->setRenderingIsRemote($flag);  #} 
  ())

(defmethod SoGLRenderAction  getRenderingIsRemote (  )
  
  (int #{ ((SoGLRenderAction *)$p)->getRenderingIsRemote()  #} ))

(defmethod SoGLRenderAction  invalidateState (  )
  
  #{ ((SoGLRenderAction *)$p)->invalidateState();  #} 
  ())



;; class SoHandleEventAction : public SoAction
(defclass SoHandleEventAction SoAction)

(defmethod SoHandleEventAction  SoHandleEventAction ( flag viewportRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoHandleEventAction(*$viewportRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

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

(defmethod SoHandleEventAction  setViewportRegion ( newRegion)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{ ((SoHandleEventAction *)$p)->setViewportRegion(*$newRegion);  #} 
  ())

(defmethod SoHandleEventAction  getViewportRegion (  )
  
  (gptr #{ &(((SoHandleEventAction *)$p)->getViewportRegion())  #} ))  ;; const SbViewportRegion & -> gptr

(defmethod SoHandleEventAction  setEvent ( ev)
  
  ((-gptr- "const SoEvent *") ev)
  #{ ((SoHandleEventAction *)$p)->setEvent($ev);  #} 
  ())

(defmethod SoHandleEventAction  getEvent (  )
  
  (gptr #{ ((SoHandleEventAction *)$p)->getEvent()  #} ))    ;; const SoEvent *  -> gptr

(defmethod SoHandleEventAction  setHandled (  )
  
  #{ ((SoHandleEventAction *)$p)->setHandled();  #} 
  ())

(defmethod SoHandleEventAction  isHandled (  )
  
  (int #{ ((SoHandleEventAction *)$p)->isHandled()  #} ))

(defmethod SoHandleEventAction  setGrabber ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoHandleEventAction *)$p)->setGrabber($node);  #} 
  ())

(defmethod SoHandleEventAction  releaseGrabber (  )
  
  #{ ((SoHandleEventAction *)$p)->releaseGrabber();  #} 
  ())

(defmethod SoHandleEventAction  getGrabber (  )
  
  (gptr #{ ((SoHandleEventAction *)$p)->getGrabber()  #} ))    ;; SoNode *  -> gptr

(defmethod SoHandleEventAction  setPickRoot ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoHandleEventAction *)$p)->setPickRoot($node);  #} 
  ())

(defmethod SoHandleEventAction  getPickRoot (  )
  
  (gptr #{ ((SoHandleEventAction *)$p)->getPickRoot()  #} ))    ;; SoNode *  -> gptr

(defmethod SoHandleEventAction  setPickRadius ( radiusInPixels)
  
  ((-float-) radiusInPixels)
  #{ ((SoHandleEventAction *)$p)->setPickRadius($radiusInPixels);  #} 
  ())

(defmethod SoHandleEventAction  getPickedPoint (  )
  
  (gptr #{ ((SoHandleEventAction *)$p)->getPickedPoint()  #} ))    ;; const SoPickedPoint *  -> gptr

(defmethod SoHandleEventAction  getPickedPointList (  )
  
  (gptr #{ &(((SoHandleEventAction *)$p)->getPickedPointList())  #} ))  ;; const SoPickedPointList & -> gptr



;; class SoPickAction : public SoAction
(defclass SoPickAction SoAction)

(defmethod SoPickAction  setViewportRegion ( newRegion)
  
  ((-gptr- "const SbViewportRegion *") newRegion)   ;; reference -> gptr
  #{ ((SoPickAction *)$p)->setViewportRegion(*$newRegion);  #} 
  ())

(defmethod SoPickAction  getViewportRegion (  )
  
  (gptr #{ &(((SoPickAction *)$p)->getViewportRegion())  #} ))  ;; const SbViewportRegion & -> gptr



;; class SoRayPickAction : public SoPickAction
(defclass SoRayPickAction SoPickAction)

(defmethod SoRayPickAction  SoRayPickAction ( flag viewportRegion)
  ((-bool-) flag)
  
  ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
  #{  if($flag == false ) {
            $p = new  SoRayPickAction(*$viewportRegion);
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

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

(defmethod SoRayPickAction  setPoint ( viewportPoint)
  
  ((-gptr- "const SbVec2s *") viewportPoint)   ;; reference -> gptr
  #{ ((SoRayPickAction *)$p)->setPoint(*$viewportPoint);  #} 
  ())

(defmethod SoRayPickAction  setNormalizedPoint ( normPoint)
  
  ((-gptr- "const SbVec2f *") normPoint)   ;; reference -> gptr
  #{ ((SoRayPickAction *)$p)->setNormalizedPoint(*$normPoint);  #} 
  ())

(defmethod SoRayPickAction  setRadius ( radiusInPixels)
  
  ((-float-) radiusInPixels)
  #{ ((SoRayPickAction *)$p)->setRadius($radiusInPixels);  #} 
  ())

(defmethod SoRayPickAction  setRay ( start direction nearDistance farDistance)
  
  ((-gptr- "const SbVec3f *") start)   ;; reference -> gptr
  ((-gptr- "const SbVec3f *") direction)   ;; reference -> gptr
  ((-float-) nearDistance)
  ((-float-) farDistance)
  #{ ((SoRayPickAction *)$p)->setRay(*$start, *$direction,$nearDistance,$farDistance);  #} 
  ())

(defmethod SoRayPickAction  setPickAll ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoRayPickAction *)$p)->setPickAll($flag);  #} 
  ())

(defmethod SoRayPickAction  isPickAll (  )
  
  (int #{ ((SoRayPickAction *)$p)->isPickAll()  #} ))

(defmethod SoRayPickAction  getPickedPointList (  )
  
  (gptr #{ &(((SoRayPickAction *)$p)->getPickedPointList())  #} ))  ;; const SoPickedPointList & -> gptr

(defmethod SoRayPickAction  getPickedPoint ( index)
  
  ((-int-) index)
  (gptr #{ ((SoRayPickAction *)$p)->getPickedPoint($index)  #} ))    ;; SoPickedPoint *  -> gptr


;; class SoSearchAction : public SoAction
(defclass SoSearchAction SoAction)

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

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

(defmethod SoSearchAction  reset (  )
  
  #{ ((SoSearchAction *)$p)->reset();  #} 
  ())

(defmethod SoSearchAction  setFind ( what)
  
  ((-int-) what)
  #{ ((SoSearchAction *)$p)->setFind($what);  #} 
  ())

(defmethod SoSearchAction  getFind (  )
  
  (int #{ ((SoSearchAction *)$p)->getFind()  #} ))

(defmethod SoSearchAction  getNode (  )
  
  (gptr #{ ((SoSearchAction *)$p)->getNode()  #} ))    ;; SoNode *  -> gptr

(defmethod SoSearchAction  setNode ( n)
  
  ((-gptr- "SoNode *") n)
  #{ ((SoSearchAction *)$p)->setNode($n);  #} 
  ())

(defmethod SoSearchAction  setType ( s derivedIsOk)
  
  ((-gptr- "SoType *") s)    ;; object -> gptr
  ((-int-) derivedIsOk)                    ;; SbBool -> int
  #{ ((SoSearchAction *)$p)->setType(*$s,$derivedIsOk);  #} 
  ())

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

(defmethod SoSearchAction  setName ( n)
  
  ((-gptr- "const SbName *") n)   ;; reference -> gptr
  #{ ((SoSearchAction *)$p)->setName(*$n);  #} 
  ())

(defmethod SoSearchAction  getInterest (  )
  
  (int #{ ((SoSearchAction *)$p)->getInterest()  #} )) ;; Interest -> int

(defmethod SoSearchAction  setInterest ( i)
  
  ((-int-) i)     ;; Interest -> int
  #{ ((SoSearchAction *)$p)->setInterest((SoSearchAction::Interest)$i);  #} 
  ())

(defmethod SoSearchAction  isSearchingAll (  )
  
  (int #{ ((SoSearchAction *)$p)->isSearchingAll()  #} ))

(defmethod SoSearchAction  setSearchingAll ( flag)
  
  ((-int-) flag)                    ;; SbBool -> int
  #{ ((SoSearchAction *)$p)->setSearchingAll($flag);  #} 
  ())

(defmethod SoSearchAction  getPath (  )
  
  (gptr #{ ((SoSearchAction *)$p)->getPath()  #} ))    ;; SoPath *  -> gptr

(defmethod SoSearchAction  getPaths (  )
  
  (gptr #{ &(((SoSearchAction *)$p)->getPaths())  #} ))  ;; SoPathList & -> gptr



;; class SoWriteAction : public SoAction
(defclass SoWriteAction SoAction)

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

;; (defmethod SoWriteAction  SoWriteAction ( flag out)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "SoOutput *") out)
;;   #{  if($flag == false ) {
;;             $p = new  SoWriteAction;
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

(defmethod SoWriteAction  getOutput (  )
  
  (gptr #{ ((SoWriteAction *)$p)->getOutput()  #} ))    ;; SoOutput *  -> gptr





;; class SoBoxHighlightRenderAction : public SoGLRenderAction
(defclass SoBoxHighlightRenderAction SoGLRenderAction)

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

;; (defmethod SoBoxHighlightRenderAction  SoBoxHighlightRenderAction ( flag viewportRegion)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
;;   #{  if($flag == false ) {
;;             $p = new  SoBoxHighlightRenderAction(*$viewportRegion);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

(defmethod SoBoxHighlightRenderAction  apply_node ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoBoxHighlightRenderAction *)$p)->apply($node);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  apply_path ( path)
  
  ((-gptr- "SoPath *") path)
  #{ ((SoBoxHighlightRenderAction *)$p)->apply($path);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  apply ( pathList obeysRules)
  
  ((-gptr- "const SoPathList *") pathList)   ;; reference -> gptr
  ((-int-) obeysRules)                    ;; SbBool -> int
  #{ ((SoBoxHighlightRenderAction *)$p)->apply(*$pathList,$obeysRules);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  setVisible ( b)
  
  ((-int-) b)                    ;; SbBool -> int
  #{ ((SoBoxHighlightRenderAction *)$p)->setVisible($b);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  isVisible (  )
  
  (int #{ ((SoBoxHighlightRenderAction *)$p)->isVisible()  #} ))

(defmethod SoBoxHighlightRenderAction  setColor ( c)
  
  ((-gptr- "const SbColor *") c)   ;; reference -> gptr
  #{ ((SoBoxHighlightRenderAction *)$p)->setColor(*$c);  #} 
  ())

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

(defmethod SoBoxHighlightRenderAction  setLinePattern ( pattern)
  
  ((-int-) pattern)   ;; unsigned short -> int
  #{ ((SoBoxHighlightRenderAction *)$p)->setLinePattern($pattern);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  getLinePattern (  )
  
  (int #{ ((SoBoxHighlightRenderAction *)$p)->getLinePattern()  #} ))  ;; unsigned short -> int

(defmethod SoBoxHighlightRenderAction  setLineWidth ( width)
  
  ((-float-) width)
  #{ ((SoBoxHighlightRenderAction *)$p)->setLineWidth($width);  #} 
  ())

(defmethod SoBoxHighlightRenderAction  getLineWidth (  )
  
  (float #{ ((SoBoxHighlightRenderAction *)$p)->getLineWidth()  #} ))






;; class SoLineHighlightRenderAction : public SoGLRenderAction
(defclass SoLineHighlightRenderAction SoGLRenderAction)

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


;; (defmethod SoLineHighlightRenderAction  SoLineHighlightRenderAction ( flag viewportRegion)
;;   ((-bool-) flag)
;;   
;;   ((-gptr- "const SbViewportRegion *") viewportRegion)   ;; reference -> gptr
;;   #{  if($flag == false ) {
;;             $p = new  SoLineHighlightRenderAction(*$viewportRegion);
;;             $shell_flag = false;
;;       }
;;       else
;;             $shell_flag = true;
;;   #} 
;;   ())

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

(defmethod SoLineHighlightRenderAction  apply_node ( node)
  
  ((-gptr- "SoNode *") node)
  #{ ((SoLineHighlightRenderAction *)$p)->apply($node);  #} 
  ())

(defmethod SoLineHighlightRenderAction  apply_path ( path)
  
  ((-gptr- "SoPath *") path)
  #{ ((SoLineHighlightRenderAction *)$p)->apply($path);  #} 
  ())

(defmethod SoLineHighlightRenderAction  apply_list ( pathList obeysRules)
  
  ((-gptr- "const SoPathList *") pathList)   ;; reference -> gptr
  ((-int-) obeysRules)                    ;; SbBool -> int
  #{ ((SoLineHighlightRenderAction *)$p)->apply(*$pathList,$obeysRules);  #} 
  ())

(defmethod SoLineHighlightRenderAction  setVisible ( b)
  
  ((-int-) b)                    ;; SbBool -> int
  #{ ((SoLineHighlightRenderAction *)$p)->setVisible($b);  #} 
  ())

(defmethod SoLineHighlightRenderAction  isVisible (  )
  
  (int #{ ((SoLineHighlightRenderAction *)$p)->isVisible()  #} ))

(defmethod SoLineHighlightRenderAction  setColor ( c)
  
  ((-gptr- "const SbColor *") c)   ;; reference -> gptr
  #{ ((SoLineHighlightRenderAction *)$p)->setColor(*$c);  #} 
  ())

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

(defmethod SoLineHighlightRenderAction  setLinePattern ( pattern)
  
  ((-int-) pattern)   ;; unsigned short -> int
  #{ ((SoLineHighlightRenderAction *)$p)->setLinePattern($pattern);  #} 
  ())

(defmethod SoLineHighlightRenderAction  getLinePattern (  )
  
  (int #{ ((SoLineHighlightRenderAction *)$p)->getLinePattern()  #} ))  ;; unsigned short -> int

(defmethod SoLineHighlightRenderAction  setLineWidth ( width)
  
  ((-float-) width)
  #{ ((SoLineHighlightRenderAction *)$p)->setLineWidth($width);  #} 
  ())

(defmethod SoLineHighlightRenderAction  getLineWidth (  )
  
  (float #{ ((SoLineHighlightRenderAction *)$p)->getLineWidth()  #} ))





()

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

(dhc-make-with-c++ () () 
  |dummy_actions|
  (soaction  invalidatestate  apply-list  apply-path  apply-node  isoftype  -destructor)
  (socallbackaction  getswitch  getpickstyle  getviewvolume  getviewingmatrix  getprojectionmatrix  getfocaldistance  getunits  getmodelmatrix  gettexturewrapt  gettexturewraps  gettexturemodel  gettexturematrix  gettextureimage  gettextureblendcolor  gettexturecoordinatebinding  gettexturecoordinate4  gettexturecoordinate2  getnumtexturecoordinates  getcreaseangle  getfacetype  getshapetype  getvertexordering  getprofile  getprofilecoordinate3  getprofilecoordinate2  getnumprofilecoordinates  getnormalbinding  getnormal  getnumnormals  getmaterialbinding  getmaterial  getlightattenuation  getlightmodel  getfontsize  getfontname  getpointsize  getlinewidth  getlinepattern  getdrawstyle  getcoordinate4  getcoordinate3  getnumcoordinates  getcomplexitytype  getcomplexity  addpointcallback  addlinesegmentcallback  addtrianglecallback  addposttailcallback  addpretailcallback  addpostcallback  addprecallback  -destructor  socallbackaction)
  (sogetboundingboxaction  getwhatreset  isresetbefore  isresetpath  getresetpath  setresetpath  isincameraspace  setincameraspace  getcenter  getxfboundingbox  getboundingbox  getviewportregion  setviewportregion  -destructor  sogetboundingboxaction)
  (sogetmatrixaction  gettextureinverse  gettexturematrix  getinverse  getmatrix  getviewportregion  setviewportregion  -destructor  sogetmatrixaction)
  (soglrenderaction  invalidatestate  getrenderingisremote  setrenderingisremote  getcachecontext  setcachecontext  setpasscallback  ispassupdate  setpassupdate  getnumpasses  setnumpasses  issmoothing  setsmoothing  gettransparencytype  settransparencytype  setabortcallback  getupdatearea  setupdatearea  getviewportregion  setviewportregion  -destructor  soglrenderaction)
  (sohandleeventaction  getpickedpointlist  getpickedpoint  setpickradius  getpickroot  setpickroot  getgrabber  releasegrabber  setgrabber  ishandled  sethandled  getevent  setevent  getviewportregion  setviewportregion  -destructor  sohandleeventaction)
  (sopickaction  getviewportregion  setviewportregion)
  (soraypickaction  getpickedpoint  getpickedpointlist  ispickall  setpickall  setray  setradius  setnormalizedpoint  setpoint  -destructor  soraypickaction)
  (sosearchaction  getpaths  getpath  setsearchingall  issearchingall  setinterest  getinterest  setname  getname  settype  setnode  getnode  getfind  setfind  reset  -destructor  sosearchaction)
  (sowriteaction  getoutput  -destructor  sowriteaction)
  (soboxhighlightrenderaction  getlinewidth  setlinewidth  getlinepattern  setlinepattern  getcolor  setcolor  isvisible  setvisible  apply  apply-path  apply-node  -destructor  soboxhighlightrenderaction)
  (solinehighlightrenderaction  getlinewidth  setlinewidth  getlinepattern  setlinepattern  getcolor  setcolor  isvisible  setvisible  apply-list  apply-path  apply-node  -destructor  solinehighlightrenderaction)
)
