;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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.
;;;
;;;
;;; 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/xt-config")



#? *** xt_components

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

#? * soxtcomponent
;;.TYPE CLASS
#? (==> <soxtcomponent> show)
#? (==> <soxtcomponent> hide)
#? (==> <soxtcomponent> isvisible)
#? (==> <soxtcomponent> getwidget)
#? (==> <soxtcomponent> basewidget)
#? (==> <soxtcomponent> istoplevelshell)
#? (==> <soxtcomponent> getshellwidget)
#? (==> <soxtcomponent> getparentwidget)
#? (==> <soxtcomponent> setsize <size>)
#? (==> <soxtcomponent> getdisplay)
#? (==> <soxtcomponent> settitle <newtitle>)
#? (==> <soxtcomponent> gettitle)
#? (==> <soxtcomponent> seticontitle <newicontitle>)
#? (==> <soxtcomponent> geticontitle)
#? (==> <soxtcomponent> setwindowclosecallback <func> <data>)
#? (==> <soxtcomponent> getwidgetname)
#? (==> <soxtcomponent> getclassname)

#? * soxtdirectionallighteditor
;;.TYPE CLASS
#? (new soxtdirectionallighteditor <parent> <name> <buildinsideparent> <shellflag>>
#? (==> <soxtdirectionallighteditor> attach <pathtolight>)
#? (==> <soxtdirectionallighteditor> detach)
#? (==> <soxtdirectionallighteditor> isattached)
#? (==> <soxtdirectionallighteditor> setlight <newlight>)
#? (==> <soxtdirectionallighteditor> getlight)
#? (==> <soxtdirectionallighteditor> addlightchangedcallback <f> <userdata>)
#? (==> <soxtdirectionallighteditor> removelightchangedcallback <f> <userdata>)
#? (==> <soxtdirectionallighteditor> show)
#? (==> <soxtdirectionallighteditor> hide)

#? * soxtglwidget
;;.TYPE CLASS
#? (==> <soxtglwidget> getnormalwindow)
#? (==> <soxtglwidget> getoverlaywindow)
#? (==> <soxtglwidget> getnormalcontext)
#? (==> <soxtglwidget> getoverlaycontext)
#? (==> <soxtglwidget> getnormalwidget)
#? (==> <soxtglwidget> getoverlaywidget)
#? (==> <soxtglwidget> setnormalvisual <vis>)
#? (==> <soxtglwidget> getnormalvisual)
#? (==> <soxtglwidget> setoverlayvisual <vis>)
#? (==> <soxtglwidget> getoverlayvisual)
#? (==> <soxtglwidget> setdoublebuffer <onoroff>)
#? (==> <soxtglwidget> isdoublebuffer)
#? (==> <soxtglwidget> setborder <onoroff>)
#? (==> <soxtglwidget> isborder)
#? (==> <soxtglwidget> setdrawtofrontbufferenable <enableflag>)
#? (==> <soxtglwidget> isdrawtofrontbufferenable)

#? * soxtmaterialeditor
;;.TYPE CLASS
#? (new soxtmaterialeditor <parent> <name> <buildinsideparent> <shellflag>>
#? (==> <soxtmaterialeditor> attach <material> <index>)
#? (==> <soxtmaterialeditor> detach)
#? (==> <soxtmaterialeditor> isattached)
#? (==> <soxtmaterialeditor> addmaterialchangedcallback <f> <userdata>)
#? (==> <soxtmaterialeditor> removematerialchangedcallback <f> <userdata>)
#? (==> <soxtmaterialeditor> setupdatefrequency <freq>)
#? (==> <soxtmaterialeditor> getupdatefrequency)
#? (==> <soxtmaterialeditor> show)
#? (==> <soxtmaterialeditor> hide)
#? (==> <soxtmaterialeditor> setmaterial <mtl>)
#? (==> <soxtmaterialeditor> getmaterial)

#? * soxtmateriallist
;;.TYPE CLASS
#? (new soxtmateriallist <parent> <name> <buildinsideparent> <dir> <shellflag>>
#? (==> <soxtmateriallist> addcallback <f> <userdata>)
#? (==> <soxtmateriallist> removecallback <f> <userdata>)

#? * soxtprintdialog
;;.TYPE CLASS
#? (new soxtprintdialog <parent> <name> <buildinsideparent> <shellflag>>
#? (==> <soxtprintdialog> setscenegraph-path <path>)
#? (==> <soxtprintdialog> setscenegraph-node <root>)
#? (==> <soxtprintdialog> getscenegraph)
#? (==> <soxtprintdialog> getscenegraphpath)
#? (==> <soxtprintdialog> setglrenderaction <act>)
#? (==> <soxtprintdialog> getglrenderaction)
#? (==> <soxtprintdialog> setprintsize <s>)
#? (==> <soxtprintdialog> setbeforeprintcallback <f> <userdata>)
#? (==> <soxtprintdialog> setafterprintcallback <f> <userdata>)

#? * soxtrenderarea
;;.TYPE CLASS
#? (new soxtrenderarea <parent> <name> <buildinsideparent> <getmouseinput> <getkeyboardinput> <shellflag>>
#? (==> <soxtrenderarea> setscenegraph <newscene>)
#? (==> <soxtrenderarea> getscenegraph)
#? (==> <soxtrenderarea> setoverlayscenegraph <newscene>)
#? (==> <soxtrenderarea> getoverlayscenegraph)
#? (==> <soxtrenderarea> registerdevice <d>)
#? (==> <soxtrenderarea> unregisterdevice <d>)
#? (==> <soxtrenderarea> setbackgroundcolor <c>)
#? (==> <soxtrenderarea> getbackgroundcolor)
#? (==> <soxtrenderarea> setbackgroundindex <index>)
#? (==> <soxtrenderarea> getbackgroundindex)
#? (==> <soxtrenderarea> setoverlaybackgroundindex <index>)
#? (==> <soxtrenderarea> getoverlaybackgroundindex)
#? (==> <soxtrenderarea> setcolormap <startindex> <num> <colors>)
#? (==> <soxtrenderarea> setoverlaycolormap <startindex> <num> <colors>)
#? (==> <soxtrenderarea> setviewportregion <newregion>)
#? (==> <soxtrenderarea> getviewportregion)
#? (==> <soxtrenderarea> settransparencytype <type>)
#? (==> <soxtrenderarea> gettransparencytype)
#? (==> <soxtrenderarea> setantialiasing <smoothing> <numpasses>)
#? (==> <soxtrenderarea> getantialiasing <smoothing> <numpasses>)
#? (==> <soxtrenderarea> setclearbeforerender <trueorfalse>)
#? (==> <soxtrenderarea> isclearbeforerender)
#? (==> <soxtrenderarea> setclearbeforeoverlayrender <trueorfalse>)
#? (==> <soxtrenderarea> isclearbeforeoverlayrender)
#? (==> <soxtrenderarea> setautoredraw <trueorfalse>)
#? (==> <soxtrenderarea> isautoredraw)
#? (==> <soxtrenderarea> setredrawpriority <priority>)
#? (==> <soxtrenderarea> getredrawpriority)
#? (==> <soxtrenderarea> render)
#? (==> <soxtrenderarea> renderoverlay)
#? (==> <soxtrenderarea> scheduleredraw)
#? (==> <soxtrenderarea> scheduleoverlayredraw)
#? (==> <soxtrenderarea> redrawonselectionchange <s>)
#? (==> <soxtrenderarea> redrawoverlayonselectionchange <s>)
#? (==> <soxtrenderarea> seteventcallback <fcn> <userdata>)
#? (==> <soxtrenderarea> setscenemanager <sm>)
#? (==> <soxtrenderarea> getscenemanager)
#? (==> <soxtrenderarea> setoverlayscenemanager <sm>)
#? (==> <soxtrenderarea> getoverlayscenemanager)
#? (==> <soxtrenderarea> setglrenderaction <ra>)
#? (==> <soxtrenderarea> getglrenderaction)
#? (==> <soxtrenderarea> setoverlayglrenderaction <ra>)
#? (==> <soxtrenderarea> getoverlayglrenderaction)

#? * (|dummy_xt_components|)

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



(libload "inventor/inventorobject")

;;*********************** type alias and conversion  ******************************
;;  Atom <X11/Xdefs.h> (unsigned long ) -> int 
;;  Time <X11/X.h>     (unsigned long ) -> int
;;  Window <X11/X.h>   (unsigned long ) -> int
;;  XtPointer <X11/Intrinsic.h>  -> gptr
;;  XtEventHandler <X11/Intrinsic.h> -> gptr
;;  Widget <X11/Intrinsic.h>  -> gptr
;;  EventMask <X11/Intrinsic.h> (unsigned long) -> int
;;  GLXContext <GL/glx.h>  -> gptr
;;  SbBool  -> int
;;  enum  -> int
;;  SoType -> SoType *
;;  uint32_t -> int
;;*********************************************************************************


;;*********************************************************************************
;;class SoXtComponent 
(defclass SoXtComponent InventorObject)

(defmethod  SoXtComponent  show (  )
  
  #{  ((SoXtComponent *)$p)->show();  #} 
  ())

(defmethod  SoXtComponent  hide (  )
  
  #{  ((SoXtComponent *)$p)->hide();  #} 
  ())

(defmethod  SoXtComponent  isVisible (  )
  
  (int #{  ((SoXtComponent *)$p)->isVisible()  #} ))    ;; SbBool -> int

(defmethod  SoXtComponent  getWidget (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtComponent  baseWidget (  )
  
  (gptr #{  ((SoXtComponent *)$p)->baseWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtComponent  isTopLevelShell (  )
  
  (int #{  ((SoXtComponent *)$p)->isTopLevelShell()  #} ))    ;; SbBool -> int

(defmethod  SoXtComponent  getShellWidget (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getShellWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtComponent  getParentWidget (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getParentWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtComponent  setSize (  size )
  
  ((-gptr- "const SbVec2s *") size)        ;; reference -> gptr
  #{  ((SoXtComponent *)$p)->setSize( *$size );  #} 
  ())

;;(defmethod  SoXtComponent  getSize (  )
  
;;  (SbVec2s  #{  ((SoXtComponent *)$p)->getSize()  #} ))

(defmethod  SoXtComponent  getDisplay (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getDisplay()  #} ))  ;; Display   *  -> gptr

(defmethod  SoXtComponent  setTitle (  newTitle )
  
  ((-gptr- "const char *") newTitle) 
  #{  ((SoXtComponent *)$p)->setTitle( $newTitle );  #} 
  ())

(defmethod  SoXtComponent  getTitle (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getTitle()  #} ))  ;; const char *  -> gptr

(defmethod  SoXtComponent  setIconTitle (  newIconTitle )
  
  ((-gptr- "const char *") newIconTitle) 
  #{  ((SoXtComponent *)$p)->setIconTitle( $newIconTitle );  #} 
  ())

(defmethod  SoXtComponent  getIconTitle (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getIconTitle()  #} ))  ;; const char *  -> gptr

(defmethod  SoXtComponent  setWindowCloseCallback (  func data )
  
  ((-gptr- "SoXtComponentCB *") func) 
  ((-gptr-) data) 
  #{  ((SoXtComponent *)$p)->setWindowCloseCallback( $func  ,$data );  #} 
  ())

(defmethod  SoXtComponent  getWidgetName (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getWidgetName()  #} ))  ;; const char *  -> gptr

(defmethod  SoXtComponent  getClassName (  )
  
  (gptr #{  ((SoXtComponent *)$p)->getClassName()  #} ))  ;; const char *  -> gptr





;;*********************************************************************************
;;class SoXtDirectionalLightEditor : public SoXtComponent 
(defclass SoXtDirectionalLightEditor  SoXtComponent)
 
(defmethod  SoXtDirectionalLightEditor  SoXtDirectionalLightEditor ( parent name buildInsideParent  shellflag)
  
  ((-bool-) shellflag)
  ((-gptr- "Widget") parent) 
  ((-gptr- "const char *") name) 
  ((-int-) buildInsideParent)          ;; SbBool -> int
  #{  if($shellflag == false ) {
            $p = new SoXtDirectionalLightEditor( $parent  ,$name  ,$buildInsideParent );
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())



(defmethod  SoXtDirectionalLightEditor  attach ( pathToLight )
  
  ((-gptr- "SoPath *") pathToLight) 
  #{  ((SoXtDirectionalLightEditor *)$p)->attach( $pathToLight );  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  detach (  )
  
  #{  ((SoXtDirectionalLightEditor *)$p)->detach();  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  isAttached (  )
  
  (int #{  ((SoXtDirectionalLightEditor *)$p)->isAttached()  #} ))    ;; SbBool -> int

(defmethod  SoXtDirectionalLightEditor  setLight ( newLight )
  
  ((-gptr- "const SoDirectionalLight *") newLight)        ;; reference -> gptr
  #{  ((SoXtDirectionalLightEditor *)$p)->setLight( *$newLight );  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  getLight (  )
  
  (gptr #{  &(((SoXtDirectionalLightEditor *)$p)->getLight())  #} ))   ;; reference -> gptr

(defmethod  SoXtDirectionalLightEditor  addLightChangedCallback ( f userData )
  
  ((-gptr- "SoXtDirectionalLightEditorCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtDirectionalLightEditor *)$p)->addLightChangedCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  removeLightChangedCallback ( f userData )
  
  ((-gptr- "SoXtDirectionalLightEditorCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtDirectionalLightEditor *)$p)->removeLightChangedCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  show (  )
  
  #{  ((SoXtDirectionalLightEditor *)$p)->show();  #} 
  ())

(defmethod  SoXtDirectionalLightEditor  hide (  )
  
  #{  ((SoXtDirectionalLightEditor *)$p)->hide();  #} 
  ())




;;*********************************************************************************
;;class SoXtGLWidget : public SoXtComponent 
(defclass SoXtGLWidget  SoXtComponent)
 
(defmethod  SoXtGLWidget  getNormalWindow (  )
  
  (int #{  ((SoXtGLWidget *)$p)->getNormalWindow()  #} ))   ;; Window  -> int

(defmethod  SoXtGLWidget  getOverlayWindow (  )
  
  (int #{  ((SoXtGLWidget *)$p)->getOverlayWindow()  #} ))   ;; Window -> int

(defmethod  SoXtGLWidget  getNormalContext (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getNormalContext()  #} ))   ;; GLXContext -> gptr

(defmethod  SoXtGLWidget  getOverlayContext (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getOverlayContext()  #} ))  ;; GLXContext -> gptr

(defmethod  SoXtGLWidget  getNormalWidget (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getNormalWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtGLWidget  getOverlayWidget (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getOverlayWidget()  #} ))   ;; Widget -> gptr

(defmethod  SoXtGLWidget  setNormalVisual ( vis )
  
  ((-gptr- "XVisualInfo *") vis) 
  #{  ((SoXtGLWidget *)$p)->setNormalVisual( $vis );  #} 
  ())

(defmethod  SoXtGLWidget  getNormalVisual (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getNormalVisual()  #} ))  ;; XVisualInfo *  -> gptr

(defmethod  SoXtGLWidget  setOverlayVisual ( vis )
  
  ((-gptr- "XVisualInfo *") vis) 
  #{  ((SoXtGLWidget *)$p)->setOverlayVisual( $vis );  #} 
  ())

(defmethod  SoXtGLWidget  getOverlayVisual (  )
  
  (gptr #{  ((SoXtGLWidget *)$p)->getOverlayVisual()  #} ))  ;; XVisualInfo *  -> gptr

(defmethod  SoXtGLWidget  setDoubleBuffer ( onOrOff )
  
  ((-int-) onOrOff)          ;; SbBool -> int
  #{  ((SoXtGLWidget *)$p)->setDoubleBuffer( $onOrOff );  #} 
  ())

(defmethod  SoXtGLWidget  isDoubleBuffer (  )
  
  (int #{  ((SoXtGLWidget *)$p)->isDoubleBuffer()  #} ))    ;; SbBool -> int

(defmethod  SoXtGLWidget  setBorder ( onOrOff )
  
  ((-int-) onOrOff)          ;; SbBool -> int
  #{  ((SoXtGLWidget *)$p)->setBorder( $onOrOff );  #} 
  ())

(defmethod  SoXtGLWidget  isBorder (  )
  
  (int #{  ((SoXtGLWidget *)$p)->isBorder()  #} ))    ;; SbBool -> int

(defmethod  SoXtGLWidget  setDrawToFrontBufferEnable ( enableFlag )
  
  ((-int-) enableFlag)          ;; SbBool -> int
  #{  ((SoXtGLWidget *)$p)->setDrawToFrontBufferEnable( $enableFlag );  #} 
  ())

(defmethod  SoXtGLWidget  isDrawToFrontBufferEnable (  )
  
  (int #{  ((SoXtGLWidget *)$p)->isDrawToFrontBufferEnable()  #} ))    ;; SbBool -> int





;;*********************************************************************************
;;class SoXtMaterialEditor : public SoXtComponent 
(defclass SoXtMaterialEditor  SoXtComponent)
 
(defmethod  SoXtMaterialEditor  SoXtMaterialEditor ( parent name buildInsideParent  shellflag)
  
  ((-bool-) shellflag)
  ((-gptr- "Widget") parent) 
  ((-gptr- "const char *") name) 
  ((-int-) buildInsideParent)          ;; SbBool -> int
  #{  if($shellflag == false ) {
            $p = new SoXtMaterialEditor( $parent  ,$name  ,$buildInsideParent );
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())



(defmethod  SoXtMaterialEditor  attach ( material index )
  
  ((-gptr- "SoMaterial *") material) 
  ((-int-) index) 
  #{  ((SoXtMaterialEditor *)$p)->attach( $material  ,$index );  #} 
  ())

(defmethod  SoXtMaterialEditor  detach (  )
  
  #{  ((SoXtMaterialEditor *)$p)->detach();  #} 
  ())

(defmethod  SoXtMaterialEditor  isAttached (  )
  
  (int #{  ((SoXtMaterialEditor *)$p)->isAttached()  #} ))    ;; SbBool -> int

(defmethod  SoXtMaterialEditor  addMaterialChangedCallback ( f userData )
  
  ((-gptr- "SoXtMaterialEditorCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtMaterialEditor *)$p)->addMaterialChangedCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtMaterialEditor  removeMaterialChangedCallback ( f userData )
  
  ((-gptr- "SoXtMaterialEditorCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtMaterialEditor *)$p)->removeMaterialChangedCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtMaterialEditor  setUpdateFrequency ( freq )
  
  ((-int-) freq)          ;; SoXtMaterialEditor::UpdateFrequency -> int
  #{  ((SoXtMaterialEditor *)$p)->setUpdateFrequency( (SoXtMaterialEditor::UpdateFrequency)$freq );  #} 
  ())

(defmethod  SoXtMaterialEditor  getUpdateFrequency (  )
  
  (int #{  ((SoXtMaterialEditor *)$p)->getUpdateFrequency()  #} ))     ;; SoXtMaterialEditor::UpdateFrequency  -> int

(defmethod  SoXtMaterialEditor  show (  )
  
  #{  ((SoXtMaterialEditor *)$p)->show();  #} 
  ())

(defmethod  SoXtMaterialEditor  hide (  )
  
  #{  ((SoXtMaterialEditor *)$p)->hide();  #} 
  ())

(defmethod  SoXtMaterialEditor  setMaterial ( mtl )
  
  ((-gptr- "const SoMaterial *") mtl)        ;; reference -> gptr
  #{  ((SoXtMaterialEditor *)$p)->setMaterial( *$mtl );  #} 
  ())

(defmethod  SoXtMaterialEditor  getMaterial (  )
  
  (gptr #{  &(((SoXtMaterialEditor *)$p)->getMaterial())  #} ))    ;; reference -> gptr







;;*********************************************************************************
;;class SoXtMaterialList : public SoXtComponent 
(defclass SoXtMaterialList  SoXtComponent)
 
(defmethod  SoXtMaterialList  SoXtMaterialList ( parent name buildInsideParent dir  shellflag)
  
  ((-bool-) shellflag)
  ((-gptr- "Widget") parent) 
  ((-gptr- "const char *") name) 
  ((-int-) buildInsideParent)          ;; SbBool -> int
  ((-gptr- "const char *") dir) 
  #{  if($shellflag == false ) {
            $p = new SoXtMaterialList( $parent  ,$name  ,$buildInsideParent  ,$dir );
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())



(defmethod  SoXtMaterialList  addCallback ( f userData )
  
  ((-gptr- "SoXtMaterialListCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtMaterialList *)$p)->addCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtMaterialList  removeCallback ( f userData )
  
  ((-gptr- "SoXtMaterialListCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtMaterialList *)$p)->removeCallback( $f  ,$userData );  #} 
  ())




;;*********************************************************************************
;;class SoXtPrintDialog : public SoXtComponent 
(defclass SoXtPrintDialog  SoXtComponent)
 
(defmethod  SoXtPrintDialog  SoXtPrintDialog ( parent name buildInsideParent  shellflag)
  
  ((-bool-) shellflag)
  ((-gptr- "Widget") parent) 
  ((-gptr- "const char *") name) 
  ((-int-) buildInsideParent)          ;; SbBool -> int
  #{  if($shellflag == false ) {
            $p = new SoXtPrintDialog( $parent  ,$name  ,$buildInsideParent );
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())


(defmethod  SoXtPrintDialog  setSceneGraph_Path ( path )
  
  ((-gptr- "SoPath *") path) 
  #{  ((SoXtPrintDialog *)$p)->setSceneGraph( $path );  #} 
  ())

(defmethod  SoXtPrintDialog  setSceneGraph_Node ( root )
  
  ((-gptr- "SoNode *") root) 
  #{  ((SoXtPrintDialog *)$p)->setSceneGraph( $root );  #} 
  ())

(defmethod  SoXtPrintDialog  getSceneGraph (  )
  
  (gptr #{  ((SoXtPrintDialog *)$p)->getSceneGraph()  #} ))  ;; SoNode  *  -> gptr

(defmethod  SoXtPrintDialog  getSceneGraphPath (  )
  
  (gptr #{  ((SoXtPrintDialog *)$p)->getSceneGraphPath()  #} ))  ;; SoPath  *  -> gptr

(defmethod  SoXtPrintDialog  setGLRenderAction ( act )
  
  ((-gptr- "const SoGLRenderAction *") act) 
  #{  ((SoXtPrintDialog *)$p)->setGLRenderAction( $act );  #} 
  ())

(defmethod  SoXtPrintDialog  getGLRenderAction (  )
  
  (gptr #{  ((SoXtPrintDialog *)$p)->getGLRenderAction()  #} ))  ;; SoGLRenderAction *  -> gptr

(defmethod  SoXtPrintDialog  setPrintSize ( s )
  
  ((-gptr- "const SbVec2f *") s)        ;; reference -> gptr
  #{  ((SoXtPrintDialog *)$p)->setPrintSize( *$s );  #} 
  ())

;;(defmethod  SoXtPrintDialog  setPrintSize ( s )
  
;;  ((-gptr- "const SbVec2s *") s)        ;; reference -> gptr
;;  #{  ((SoXtPrintDialog *)$p)->setPrintSize( *$s );  #} 
;;  ())

(defmethod  SoXtPrintDialog  setBeforePrintCallback ( f userData )
  
  ((-gptr- "SoXtPrintDialogCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtPrintDialog *)$p)->setBeforePrintCallback( $f  ,$userData );  #} 
  ())

(defmethod  SoXtPrintDialog  setAfterPrintCallback ( f userData )
  
  ((-gptr- "SoXtPrintDialogCB *") f) 
  ((-gptr-) userData) 
  #{  ((SoXtPrintDialog *)$p)->setAfterPrintCallback( $f  ,$userData );  #} 
  ())






;;*********************************************************************************
;;class SoXtRenderArea : public SoXtGLWidget 
(defclass SoXtRenderArea  SoXtGLWidget)
 
(defmethod  SoXtRenderArea  SoXtRenderArea ( parent name buildInsideParent getMouseInput getKeyboardInput  shellflag)
  
  ((-bool-) shellflag)
  ((-gptr- "Widget") parent) 
  ((-str-) name) 
  ((-int-) buildInsideParent)          ;; SbBool -> int
  ((-int-) getMouseInput)          ;; SbBool -> int
  ((-int-) getKeyboardInput)          ;; SbBool -> int
  #{  if($shellflag == false ) {
            $p = new SoXtRenderArea( $parent  ,(const char *)$name->data  ,$buildInsideParent  ,$getMouseInput  ,$getKeyboardInput );
            $shell_flag = false;
      }
      else
            $shell_flag = true;
  #} 
  ())

(defmethod  SoXtRenderArea  setSceneGraph ( newScene )
  
  ((-gptr- "SoNode *") newScene) 
  #{  ((SoXtRenderArea *)$p)->setSceneGraph( $newScene );  #} 
  ())

(defmethod  SoXtRenderArea  getSceneGraph (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getSceneGraph()  #} ))  ;; SoNode *  -> gptr

(defmethod  SoXtRenderArea  setOverlaySceneGraph ( newScene )
  
  ((-gptr- "SoNode *") newScene) 
  #{  ((SoXtRenderArea *)$p)->setOverlaySceneGraph( $newScene );  #} 
  ())

(defmethod  SoXtRenderArea  getOverlaySceneGraph (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getOverlaySceneGraph()  #} ))  ;; SoNode *  -> gptr

(defmethod  SoXtRenderArea  registerDevice ( d )
  
  ((-gptr- "SoXtDevice *") d) 
  #{  ((SoXtRenderArea *)$p)->registerDevice( $d );  #} 
  ())

(defmethod  SoXtRenderArea  unregisterDevice ( d )
  
  ((-gptr- "SoXtDevice *") d) 
  #{  ((SoXtRenderArea *)$p)->unregisterDevice( $d );  #} 
  ())

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

(defmethod  SoXtRenderArea  getBackgroundColor (  )
  
  (gptr #{  &(((SoXtRenderArea *)$p)->getBackgroundColor())  #} ))     ;; reference -> gptr

(defmethod  SoXtRenderArea  setBackgroundIndex ( index )
  
  ((-int-) index) 
  #{  ((SoXtRenderArea *)$p)->setBackgroundIndex( $index );  #} 
  ())

(defmethod  SoXtRenderArea  getBackgroundIndex (  )
  
  (int #{  ((SoXtRenderArea *)$p)->getBackgroundIndex()  #} ))

(defmethod  SoXtRenderArea  setOverlayBackgroundIndex ( index )
  
  ((-int-) index) 
  #{  ((SoXtRenderArea *)$p)->setOverlayBackgroundIndex( $index );  #} 
  ())

(defmethod  SoXtRenderArea  getOverlayBackgroundIndex (  )
  
  (int #{  ((SoXtRenderArea *)$p)->getOverlayBackgroundIndex()  #} ))

(defmethod  SoXtRenderArea  setColorMap ( startIndex num colors )
  
  ((-int-) startIndex) 
  ((-int-) num) 
  ((-gptr- "const SbColor *") colors) 
  #{  ((SoXtRenderArea *)$p)->setColorMap( $startIndex  ,$num  ,$colors );  #} 
  ())

(defmethod  SoXtRenderArea  setOverlayColorMap ( startIndex num colors )
  
  ((-int-) startIndex) 
  ((-int-) num) 
  ((-gptr- "const SbColor *") colors) 
  #{  ((SoXtRenderArea *)$p)->setOverlayColorMap( $startIndex  ,$num  ,$colors );  #} 
  ())

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

(defmethod  SoXtRenderArea  getViewportRegion (  )
  
  (gptr #{  &(((SoXtRenderArea *)$p)->getViewportRegion())  #} ))     ;; reference -> gptr

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

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

(defmethod  SoXtRenderArea  setAntialiasing ( smoothing numPasses )
  
  ((-int-) smoothing)          ;; SbBool -> int
  ((-int-) numPasses) 
  #{  ((SoXtRenderArea *)$p)->setAntialiasing( $smoothing  ,$numPasses );  #} 
  ())

(defmethod  SoXtRenderArea  getAntialiasing ( smoothing numPasses )
  
  ((-gptr- "SbBool *") smoothing)     ;; reference -> gptr
  ((-gptr- "int *") numPasses)        ;; reference -> gptr
  #{  ((SoXtRenderArea *)$p)->getAntialiasing( *$smoothing  ,*$numPasses );  #} 
  ())

(defmethod  SoXtRenderArea  setClearBeforeRender ( trueOrFalse )
  
  ((-int-) trueOrFalse)          ;; SbBool -> int
  #{  ((SoXtRenderArea *)$p)->setClearBeforeRender( $trueOrFalse );  #} 
  ())

(defmethod  SoXtRenderArea  isClearBeforeRender (  )
  
  (int #{  ((SoXtRenderArea *)$p)->isClearBeforeRender()  #} ))    ;; SbBool -> int

(defmethod  SoXtRenderArea  setClearBeforeOverlayRender ( trueOrFalse )
  
  ((-int-) trueOrFalse)          ;; SbBool -> int
  #{  ((SoXtRenderArea *)$p)->setClearBeforeOverlayRender( $trueOrFalse );  #} 
  ())

(defmethod  SoXtRenderArea  isClearBeforeOverlayRender (  )
  
  (int #{  ((SoXtRenderArea *)$p)->isClearBeforeOverlayRender()  #} ))    ;; SbBool -> int

(defmethod  SoXtRenderArea  setAutoRedraw ( trueOrFalse )
  
  ((-int-) trueOrFalse)          ;; SbBool -> int
  #{  ((SoXtRenderArea *)$p)->setAutoRedraw( $trueOrFalse );  #} 
  ())

(defmethod  SoXtRenderArea  isAutoRedraw (  )
  
  (int #{  ((SoXtRenderArea *)$p)->isAutoRedraw()  #} ))    ;; SbBool -> int

(defmethod  SoXtRenderArea  setRedrawPriority ( priority )
  
  ((-int-) priority)           ;; uint32_t -> int
  #{  ((SoXtRenderArea *)$p)->setRedrawPriority( $priority );  #} 
  ())

(defmethod  SoXtRenderArea  getRedrawPriority (  )
  
  (int #{  ((SoXtRenderArea *)$p)->getRedrawPriority()  #} ))  ;; uint32_t -> int

(defmethod  SoXtRenderArea  render (  )
  
  #{  ((SoXtRenderArea *)$p)->render();  #} 
  ())

(defmethod  SoXtRenderArea  renderOverlay (  )
  
  #{  ((SoXtRenderArea *)$p)->renderOverlay();  #} 
  ())

(defmethod  SoXtRenderArea  scheduleRedraw (  )
  
  #{  ((SoXtRenderArea *)$p)->scheduleRedraw();  #} 
  ())

(defmethod  SoXtRenderArea  scheduleOverlayRedraw (  )
  
  #{  ((SoXtRenderArea *)$p)->scheduleOverlayRedraw();  #} 
  ())

(defmethod  SoXtRenderArea  redrawOnSelectionChange ( s )
  
  ((-gptr- "SoSelection *") s) 
  #{  ((SoXtRenderArea *)$p)->redrawOnSelectionChange( $s );  #} 
  ())

(defmethod  SoXtRenderArea  redrawOverlayOnSelectionChange ( s )
  
  ((-gptr- "SoSelection *") s) 
  #{  ((SoXtRenderArea *)$p)->redrawOverlayOnSelectionChange( $s );  #} 
  ())

(defmethod  SoXtRenderArea  setEventCallback ( fcn userData )
  
  ((-gptr- "SoXtRenderAreaEventCB *") fcn) 
  ((-gptr-) userData) 
  #{  ((SoXtRenderArea *)$p)->setEventCallback( $fcn  ,$userData );  #} 
  ())

(defmethod  SoXtRenderArea  setSceneManager ( sm )
  
  ((-gptr- "SoSceneManager *") sm) 
  #{  ((SoXtRenderArea *)$p)->setSceneManager( $sm );  #} 
  ())

(defmethod  SoXtRenderArea  getSceneManager (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getSceneManager()  #} ))  ;; SoSceneManager *  -> gptr

(defmethod  SoXtRenderArea  setOverlaySceneManager ( sm )
  
  ((-gptr- "SoSceneManager *") sm) 
  #{  ((SoXtRenderArea *)$p)->setOverlaySceneManager( $sm );  #} 
  ())

(defmethod  SoXtRenderArea  getOverlaySceneManager (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getOverlaySceneManager()  #} ))  ;; SoSceneManager *  -> gptr

(defmethod  SoXtRenderArea  setGLRenderAction ( ra )
  
  ((-gptr- "SoGLRenderAction *") ra) 
  #{  ((SoXtRenderArea *)$p)->setGLRenderAction( $ra );  #} 
  ())

(defmethod  SoXtRenderArea  getGLRenderAction (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getGLRenderAction()  #} ))  ;; SoGLRenderAction *  -> gptr

(defmethod  SoXtRenderArea  setOverlayGLRenderAction ( ra )
  
  ((-gptr- "SoGLRenderAction *") ra) 
  #{  ((SoXtRenderArea *)$p)->setOverlayGLRenderAction( $ra );  #} 
  ())

(defmethod  SoXtRenderArea  getOverlayGLRenderAction (  )
  
  (gptr #{  ((SoXtRenderArea *)$p)->getOverlayGLRenderAction()  #} ))  ;; SoGLRenderAction *  -> gptr


()

;; ********************************************************
(let ((dhc-make-lushflags inventorxt-lushflags))
  (dhc-make-with-c++ 
   () ()
   |dummy_xt_components|
   (soxtcomponent getclassname getwidgetname setwindowclosecallback
		  geticontitle seticontitle gettitle settitle getdisplay setsize
		  getparentwidget getshellwidget istoplevelshell basewidget getwidget
		  isvisible hide show)
   (soxtdirectionallighteditor hide show removelightchangedcallback
			       addlightchangedcallback getlight setlight isattached detach attach
			       soxtdirectionallighteditor)
   (soxtglwidget isdrawtofrontbufferenable setdrawtofrontbufferenable
		 isborder setborder isdoublebuffer setdoublebuffer getoverlayvisual
		 setoverlayvisual getnormalvisual setnormalvisual getoverlaywidget
		 getnormalwidget getoverlaycontext getnormalcontext getoverlaywindow
		 getnormalwindow)
   (soxtmaterialeditor getmaterial setmaterial hide show
		       getupdatefrequency setupdatefrequency removematerialchangedcallback
		       addmaterialchangedcallback isattached detach attach
		       soxtmaterialeditor)
   (soxtmateriallist removecallback addcallback soxtmateriallist)
   (soxtprintdialog setafterprintcallback setbeforeprintcallback
		    setprintsize getglrenderaction setglrenderaction getscenegraphpath
		    getscenegraph setscenegraph-node setscenegraph-path soxtprintdialog)
   (soxtrenderarea getoverlayglrenderaction setoverlayglrenderaction
		   getglrenderaction setglrenderaction getoverlayscenemanager
		   setoverlayscenemanager getscenemanager setscenemanager
		   seteventcallback redrawoverlayonselectionchange
		   redrawonselectionchange scheduleoverlayredraw scheduleredraw
		   renderoverlay render getredrawpriority setredrawpriority isautoredraw
		   setautoredraw isclearbeforeoverlayrender setclearbeforeoverlayrender
		   isclearbeforerender setclearbeforerender getantialiasing
		   setantialiasing gettransparencytype settransparencytype
		   getviewportregion setviewportregion setoverlaycolormap setcolormap
		   getoverlaybackgroundindex setoverlaybackgroundindex getbackgroundindex
		   setbackgroundindex getbackgroundcolor setbackgroundcolor
		   unregisterdevice registerdevice getoverlayscenegraph
		   setoverlayscenegraph getscenegraph setscenegraph soxtrenderarea) ))
