vtk-ruby 5.0.4.0-x86-mswin32-60

data/lib/VTK/gtk/GtkGLExtVTKRenderWindow.rb.rule

@@ -0,0 +1 @@
+# generated from CMake

data/lib/VTK/gtk/GtkGLExtVTKRenderWindowInteractor.rb

@@ -0,0 +1,355 @@
+=begin
+Description:
+
+  Provides a Gtk vtkRenderWindowInteractor widget.  This embeds a
+  vtkRenderWindow inside a GTK widget && uses the
+  vtkGenericRenderWindowInteractor for the event handling.  This is
+  vtkGenericRenderWindowInteractor end
+  similar to GtkVTKRenderWindowInteractor.rb.
+
+  The extensions here allow the use of gtkglext rather than gtkgl &&
+  ruby-gtk2 rather than ruby-gtk.  It requires ruby-gtk2.0.0 || later.
+
+  There is a working example at the bottom.
+
+Credits:
+
+License:
+
+  VTK license.
+
+=end
+
+require 'rbconfig'
+require 'gtk2'
+require 'gtkglext'
+require 'vtk'
+
+class GtkGLExtVTKRenderWindowInteractor < Gtk::DrawingArea
+=begin
+  Embeds a vtkRenderWindow into a pyGTK widget && uses
+  vtkGenericRenderWindowInteractor for the event handling.  This
+  class embeds the RenderWindow correctly.  A __getattr__ hook is
+  provided that makes the class behave like a
+  vtkGenericRenderWindowInteractor.
+=end
+  def initialize
+    super
+
+    glconfig = Gdk::GLConfig.new(Gdk::GLConfig::MODE_RGB|
+                                 Gdk::GLConfig::MODE_DEPTH)
+
+    set_gl_capability(glconfig)
+
+    @RenderWindow = Vtk::RenderWindow.new
+
+    # private attributes
+    @Created = false
+    @ActiveButton = nil
+
+    @Iren = Vtk::GenericRenderWindowInteractor.new
+    @Iren.SetRenderWindow(@RenderWindow)
+    @Iren.GetInteractorStyle.SetCurrentStyleToTrackballCamera
+
+    createTimer = Proc.new{|obj, event|
+      gtk.timeout_add(10, Proc.new{ @Iren.TimerEvent })
+    }
+
+    destroyTimer = Proc.new{|obj, event|
+=begin
+      The timer is a one shot timer so will expire automatically.
+=end
+      return 1
+    }
+
+    @Iren.AddObserver('CreateTimerEvent', createTimer)
+    @Iren.AddObserver('DestroyTimerEvent', destroyTimer)
+    self.ConnectSignals
+
+    # need this to be able to handle key_press events.
+    self.set_flags(Gtk::Window::CAN_FOCUS)
+  end
+
+  def set_size_request(w, h)
+    super(w,h)
+    @RenderWindow.SetSize(w, h)
+    @Iren.SetSize(w, h)
+    @Iren.ConfigureEvent
+  end
+
+  def ConnectSignals
+    self.signal_connect("realize"){|wid,event| OnRealize(wid,event) }
+    self.signal_connect("expose_event"){|wid,event| OnExpose(wid,event) }
+    self.signal_connect("configure_event"){|wid,event| OnConfigure(wid,event) }
+    self.signal_connect("button_press_event"){|wid,event| OnButtonDown(wid,event) }
+    self.signal_connect("button_release_event"){|wid,event| OnButtonUp(wid,event) }
+    self.signal_connect("motion_notify_event"){|wid,event| OnMouseMove(wid,event) }
+    self.signal_connect("enter_notify_event"){|wid,event| OnEnter(wid,event) }
+    self.signal_connect("leave_notify_event"){|wid,event| OnLeave(wid,event) }
+    self.signal_connect("key_press_event"){|wid,event| OnKeyPress(wid,event) }
+    self.signal_connect("delete_event"){|wid,event| OnDestroy(wid,event) }
+    self.add_events(Gdk::Event::EXPOSURE_MASK |
+                    Gdk::Event::BUTTON_PRESS_MASK |
+                    Gdk::Event::BUTTON_RELEASE_MASK |
+                    Gdk::Event::KEY_PRESS_MASK |
+                    Gdk::Event::POINTER_MOTION_MASK |
+                    Gdk::Event::POINTER_MOTION_HINT_MASK |
+                    Gdk::Event::ENTER_NOTIFY_MASK |
+                    Gdk::Event::LEAVE_NOTIFY_MASK)
+  end
+
+  def GetRenderWindow
+    return @RenderWindow
+  end
+
+  def Render
+    if @Created
+      @RenderWindow.Render
+    end
+  end
+
+  def OnRealize(wid, event)
+    unless @Created
+      # you can't get the xid without the window being realized.
+      self.realize
+      if Config::CONFIG["host_os"] =~ /win32/
+        win_id = self.window.handle.to_s
+      else
+        win_id =self.window.xid.to_s
+      end
+
+      @RenderWindow.SetWindowInfo(win_id)
+#      @Iren.Initialize
+      @Created = true
+    end
+    return true
+  end
+
+  def OnConfigure(widget, event)
+#    self.widget=widget
+    @Iren.SetSize(event.width, event.height)
+    @Iren.ConfigureEvent
+    self.Render
+    return true
+  end
+
+  def OnExpose(wid, event)
+    self.Render
+    return true
+  end
+
+  def OnDestroy(wid, event=nil)
+    self.hide
+    @RenderWindow = nil
+    self.destroy
+    return true
+  end
+
+  private
+  def _GetCtrlShift(event)
+    ctrl, shift = 0, 0        
+    if ((event.state & Gdk::Window::ModifierType::CONTROL_MASK) == Gdk::Window::ModifierType::CONTROL_MASK)
+      ctrl = 1
+    end
+    if ((event.state & Gdk::Window::ModifierType::SHIFT_MASK) == Gdk::Window::ModifierType::SHIFT_MASK)
+      shift = 1
+    end
+    return ctrl, shift
+  end
+
+
+  public
+  def OnButtonDown(wid, event)
+=begin
+    Mouse button pressed.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, 0.chr, 0, nil)
+    button = event.button
+    if button == 3
+      @Iren.RightButtonPressEvent
+      return true
+    elsif button == 1
+      @Iren.LeftButtonPressEvent
+      return true
+    elsif button == 2
+      @Iren.MiddleButtonPressEvent
+      return true
+    else
+      return ralse
+    end
+  end
+
+  def OnButtonUp(wid, event)
+=begin
+    Mouse button released.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, 0.chr, 0, nil)
+    button = event.button
+    if button == 3
+      @Iren.RightButtonReleaseEvent
+      return true
+    elsif button == 1
+      @Iren.LeftButtonReleaseEvent
+      return true
+    elsif button == 2
+      @Iren.MiddleButtonReleaseEvent
+      return true
+    end
+
+    return false
+  end
+
+  def OnMouseMove(wid, event)
+=begin
+    Mouse has moved.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, 0.chr, 0, nil)
+    @Iren.MouseMoveEvent
+    return true
+  end
+
+  def OnEnter(wid, event)
+=begin
+    Entering the vtkRenderWindow.
+=end
+    self.grab_focus
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, 0.chr, 0, nil)
+    @Iren.EnterEvent
+    return true
+  end
+
+  def OnLeave(wid, event)
+=begin
+    Leaving the vtkRenderWindow.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, 0.chr, 0, nil)
+    @Iren.LeaveEvent
+    return true
+  end
+
+  def OnKeyPress(wid, event)
+=begin
+    Key pressed.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+#    keycode, keysym = event.keyval, event.string
+    keycode, keysym = event.keyval, nil
+    key = 0.chr
+    if keycode < 256
+      key = keycode.chr
+    end
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, key, 0, keysym)
+    @Iren.KeyPressEvent
+    @Iren.CharEvent
+    return true
+  end
+
+  def OnKeyRelease(wid, event)
+=begin
+    Key released.
+=end
+    m = self.pointer
+    ctrl, shift = _GetCtrlShift(event)
+#    keycode, keysym = event.keyval, event.string
+    keycode, keysym = event.keyval, nil
+    key = 0.chr
+    if keycode < 256
+      key = keycode.chr
+    end
+    @Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift, key, 0, keysym)
+    @Iren.KeyReleaseEvent
+    return true
+  end
+
+  def Initialize
+    if @Created
+      @Iren.Initialize
+    end
+  end
+
+  def Start
+    if @Created
+      @Iren.Start
+    end
+  end
+
+  def SetPicker(picker)
+    @Iren.SetPicker(picker)
+  end
+
+  def GetPicker(picker)
+    return @Iren.GetPicker
+  end
+
+end
+
+def main
+
+  Gtk.init
+  Gtk::GL.init
+
+  # The main window
+  window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+  window.set_title("A GtkVTKRenderWindow Demo!")
+  window.signal_connect("destroy"){ gtk.main_quit }
+  window.signal_connect("delete_event"){ gtk.main_quit }
+  window.set_border_width(10)
+
+  # A VBox into which widgets are packed.
+  vbox = Gtk::VBox.new(false, 3)
+  window.add(vbox)
+  vbox.show
+
+  # The GtkVTKRenderWindow
+  gvtk = GtkGLExtVTKRenderWindowInteractor.new
+  #gvtk.SetDesiredUpdateRate(1000)
+  gvtk.set_size_request(400, 400)
+  vbox.pack_start(gvtk)
+  gvtk.show
+  gvtk.Initialize
+  gvtk.Start
+  # prevents 'q' from exiting the app.
+  exit = Proc.new{|obj, event, x|
+    x
+  }
+#  gvtk.AddObserver("ExitEvent", exit)
+
+  # The VTK stuff.
+  cone = Vtk::ConeSource.new
+  cone.SetResolution(80)
+  coneMapper = Vtk::PolyDataMapper.new
+  coneMapper.SetInput(cone.GetOutput)
+  #coneActor = Vtk::LODActor.new
+  coneActor = Vtk::Actor.new
+  coneActor.SetMapper(coneMapper)    
+  coneActor.GetProperty.SetColor(0.5, 0.5, 1.0)
+  ren = Vtk::Renderer.new
+  gvtk.GetRenderWindow.AddRenderer(ren)
+  ren.AddActor(coneActor)
+
+  # A simple quit button
+  quit = Gtk::Button.new("Quit!")
+  quit.signal_connect("clicked"){ Gtk.main_quit }
+  vbox.pack_start(quit)
+  quit.show
+
+    # show the main window && start event processing.
+  window.show
+  Gtk.main
+end
+
+
+if $0 == __FILE__
+  main
+end

data/lib/VTK/gtk/GtkGLExtVTKRenderWindowInteractor.rb.rule

@@ -0,0 +1 @@
+# generated from CMake

data/lib/VTK/gtk/GtkVTKRenderWindow.rb

@@ -0,0 +1,615 @@
+=begin
+Description:
+
+  Provides a simple VTK widget for Gtk.  This embeds a
+  vtkRenderWindow inside a GTK widget.  This is based on
+  vtkTkRenderWidget.rb.  The GtkVTKRenderWindowBase class provides the
+  abstraction necessary for someone to use their own interaction
+  behaviour.  The method names are similar to those in
+  vtkInteractorStyle.h.
+
+  The class uses the gtkgl.GtkGLArea widget (gtkglarea).  This avoids
+  a lot of problems with flicker.
+
+  There is a working example at the bottom.
+
+Credits:
+
+
+Bugs:
+
+  (*) There is a focus related problem.  Tkinter has a focus object
+  that handles focus events.  I dont know of an equivalent object
+  under GTK.  So, when an 'enter_notify_event' is received on the
+  GtkVTKRenderWindow I grab the focus but I dont know what to do when
+  I get a 'leave_notify_event'.
+
+  (*) Will  !work under Win32 because it uses the XID of a window in
+  OnRealize.  Suggestions to fix this will be appreciated.
+
+=end
+
+require 'gtk2'
+require 'gtkglext'
+require 'vtk'
+
+
+class GtkVTKRenderWindowBase < Gtk::GL::Area
+
+=begin
+   A base class that enables one to embed a vtkRenderWindow into
+    a pyGTK widget.  This class embeds the RenderWindow correctly.
+    Provided are some empty methods that can be overloaded to provide
+    a user defined interaction behaviour.  The event handling
+    functions have names that are somewhat similar to the ones in the
+    vtkInteractorStyle class included with VTK.
+=end
+
+  def initialize
+    super
+
+    glconfig = Gdk::GLConfig.new(Gdk::GLConfig::MODE_RGB|
+                                 Gdk::GLConfig::MODE_DOUBLE)
+
+    set_gl_capability(glconfig)
+
+
+    @RenderWindow = Vtk::RenderWindow.new
+
+    # private attributes
+    @Created = false
+
+    # used by the LOD actors
+    @DesiredUpdateRate = 15
+    @StillUpdateRate = 0.0001
+
+    self.ConnectSignals
+
+    # need this to be able to handle key_press events.
+    self.set_flags(Gtk::Window::CAN_FOCUS)
+    # default size
+    self.set_usize(300, 300)
+  end
+
+  def ConnectSignals
+    self.signal_connect("realize"){|wid, event| OnRealize(wid,event) }
+    self.signal_connect("expose_event"){|wid, event| OnExpose(wid,event) }
+    self.signal_connect("configure_event"){|wid, event| OnConfigure(wid,event) }
+    self.signal_connect("button_press_event"){|wid, event| OnButtonDown(wid,event) }
+    self.signal_connect("button_release_event"){|wid, event| OnButtonUp(wid,event) }
+    self.signal_connect("motion_notify_event"){|wid, event| OnMouseMove(wid,event) }
+    self.signal_connect("enter_notify_event"){|wid, event| OnEnter(wid,event) }
+    self.signal_connect("leave_notify_event"){|wid, event| OnLeave(wid,event) }
+    self.signal_connect("key_press_event"){|wid, event| OnKeyPress(wid,event) }
+    self.signal_connect("delete_event"){|wid, event| OnDestroy(wid,event) }
+    self.add_events(Gdk::Event::EXPOSURE_MASK|
+                    Gdk::Event::BUTTON_PRESS_MASK |
+                    Gdk::Event::BUTTON_RELEASE_MASK |
+                    Gdk::Event::KEY_PRESS_MASK |
+                    Gdk::Event::POINTER_MOTION_MASK |
+                    Gdk::Event::POINTER_MOTION_HINT_MASK |
+                    Gdk::Event::ENTER_NOTIFY_MASK |
+                    Gdk::Event::LEAVE_NOTIFY_MASK)
+  end
+
+  def GetRenderWindow
+    return @RenderWindow
+  end
+
+  def GetRenderer
+    @RenderWindow.GetRenderers.InitTraversal
+    return @RenderWindow.GetRenderers.GetNextItem
+  end
+
+  def SetDesiredUpdateRate(rate)
+=begin
+    Mirrors the method with the same name in vtkRenderWindowInteractor.
+=end
+    @DesiredUpdateRate = rate
+  end
+
+  def GetDesiredUpdateRate
+=begin
+    Mirrors the method with the same name in vtkRenderWindowInteractor.
+=end
+    return @DesiredUpdateRate 
+  end
+
+  def SetStillUpdateRate(rate)
+=begin
+    Mirrors the method with the same name in vtkRenderWindowInteractor.
+=end
+    @StillUpdateRate = rate
+  end
+
+  def GetStillUpdateRate
+=begin
+    Mirrors the method with the same name in vtkRenderWindowInteractor.
+=end
+    return @StillUpdateRate
+  end
+
+  def Render
+    if @Created
+      @RenderWindow.Render
+    end
+  end
+
+  def OnRealize(wid, event)
+    if @Created == 0
+      # you can't get the xid without the window being realized.
+      self.realize
+      win_id = self.get_window.xid.to_s
+      @RenderWindow.SetWindowInfo(win_id)
+      @Created = true
+    end
+    return true
+  end
+
+  def OnConfigure(wid, event=nil)
+    sz = @RenderWindow.GetSize
+    if (event.width != sz[0]) || (event.height != sz[1])
+      @RenderWindow.SetSize(event.width, event.height)
+    end
+    return true
+  end
+
+  def OnExpose(wid, event)
+    self.Render
+    return true
+  end
+
+  def OnDestroy(wid, event=nil)
+    self.hide
+    @RenderWindow = nil
+    self.destroy
+    return true
+  end
+
+  def OnButtonDown(wid, event)
+=begin
+    Mouse button pressed.
+=end
+    @RenderWindow.SetDesiredUpdateRate(@DesiredUpdateRate)
+    return true
+  end
+
+  def OnButtonUp(wid, event)
+=begin
+    Mouse button released.
+=end
+    @RenderWindow.SetDesiredUpdateRate(@StillUpdateRate)
+    return true
+  end
+
+  def OnMouseMove(wid, event)
+=begin
+    Mouse has moved.
+=end
+    return true
+  end
+
+  def OnEnter(wid, event)
+=begin
+    Entering the vtkRenderWindow.
+=end
+    return true
+  end
+
+  def OnLeave(wid, event)
+=begin
+    Leaving the vtkRenderWindow.
+=end
+    return true
+  end
+
+  def OnKeyPress(wid, event)
+=begin
+    Key pressed.
+=end
+    return true
+  end
+
+  def OnKeyRelease(wid, event)
+=begin
+    Key released.
+=end
+    return true
+  end
+end
+
+
+class GtkVTKRenderWindow < GtkVTKRenderWindowBase
+=begin
+    An example of a fully functional GtkVTKRenderWindow that is
+    based on the vtkRenderWidget.py provided with the VTK sources.
+=end
+
+  def initialize
+    super
+
+    @CurrentRenderer = nil
+    @CurrentCamera = nil
+    @CurrentZoom = 1.0
+    @CurrentLight = nil
+
+    @ViewportCenterX = 0
+    @ViewportCenterY = 0
+
+    @Picker = Vtk::CellPicker.new
+    @PickedAssembly = nil
+    @PickedProperty = Vtk::Property.new
+    @PickedProperty.SetColor(1, 0, 0)
+    @PrePickedProperty = nil
+
+    @OldFocus = nil
+
+    # these record the previous mouse position
+    @LastX = 0
+    @LastY = 0
+  end
+
+  def OnButtonDown(wid, event)
+    @RenderWindow.SetDesiredUpdateRate(@DesiredUpdateRate)
+    return self.StartMotion(wid, event)
+  end
+
+  def OnButtonUp(wid, event)
+    @RenderWindow.SetDesiredUpdateRate(@StillUpdateRate)
+    return self.EndMotion(wid, event)
+  end
+
+  def OnMouseMove(wid, event=nil)
+    if ((event.state & Gdk::Window::ModifierType::BUTTON1_MASK) == Gdk::Window::ModifierType::BUTTON1_MASK)
+      if ((event.state & Gdk::Window::ModifierType::SHIFT_MASK) == Gdk::Window::ModifierType::SHIFT_MASK)
+        m = self.pointer
+        self.Pan(m[0], m[1])
+        return true
+      else
+        m = self.pointer
+        self.Rotate(m[0], m[1])
+        return true
+      end
+    elsif ((event.state & Gdk::Window::ModifierType::BUTTON2_MASK) == Gdk::Window::ModifierType::BUTTON2_MASK)
+      m = self.pointer
+      self.Pan(m[0], m[1])
+      return true
+    elsif ((event.state & Gdk::Window::ModifierType::BUTTON3_MASK) == Gdk::Window::ModifierType::BUTTON3_MASK)
+      m = self.pointer
+      self.Zoom(m[0], m[1])
+      return true
+    else
+      return false
+    end
+  end
+
+  def OnEnter(wid, event=nil)
+    self.grab_focus
+    w = self.pointer
+    self.UpdateRenderer(w[0], w[1])
+    return true
+  end
+
+  def OnLeave(wid, event)
+    return true
+  end
+
+  def OnKeyPress(wid, event=nil)
+    if (event.keyval == "r") || (event.keyval == "R")
+      self.Reset
+      return true
+    elsif (event.keyval == "w") || (event.keyval == "W")
+      self.Wireframe
+      return true
+    elsif (event.keyval == "s") || (event.keyval == "S")
+      self.Surface
+      return true
+    elsif (event.keyval == "p") || (event.keyval == "P")
+      m = self.pointer
+      self.PickActor(m[0], m[1])
+      return true
+    else
+      return false
+    end
+  end
+
+  def GetZoomFactor
+    return @CurrentZoom
+  end
+
+  def SetZoomFactor(zf)
+    @CurrentZoom = zf
+  end
+
+  def GetPicker
+    return @Picker
+  end
+
+  def Render
+    if (@CurrentLight)
+      light = @CurrentLight
+      light.SetPosition(@CurrentCamera.GetPosition)
+      light.SetFocalPoint(@CurrentCamera.GetFocalPoint)
+    end
+
+    GtkVTKRenderWindowBase.Render
+  end
+
+  def UpdateRenderer(x,y)
+=begin
+        UpdateRenderer will identify the renderer under the mouse && set
+        up _CurrentRenderer, _CurrentCamera, && _CurrentLight.
+=end
+    windowX = self.get_window.width
+    windowY = self.get_window.height
+
+    renderers = @RenderWindow.GetRenderers
+    numRenderers = renderers.GetNumberOfItems
+
+    @CurrentRenderer = nil
+    renderers.InitTraversal
+    for i in 0...numRenderers
+      renderer = renderers.GetNextItem
+      vx,vy = [0,0]
+      if (windowX > 1)
+        vx = x.to_f/(windowX-1)
+      end
+      if (windowY > 1)
+        vy = (windowY-y.to_f-1)/(windowY-1)
+      end
+      (vpxmin,vpymin,vpxmax,vpymax) = renderer.GetViewport
+
+      if (vx >= vpxmin && vx <= vpxmax && vy >= vpymin && vy <= vpymax)
+        @CurrentRenderer = renderer
+        @ViewportCenterX = windowX.to_f*(vpxmax-vpxmin)/2.0 +vpxmin
+        @ViewportCenterY = windowY.to_f*(vpymax-vpymin)/2.0 +vpymin
+        @CurrentCamera = @CurrentRenderer.GetActiveCamera
+        lights = @CurrentRenderer.GetLights
+        lights.InitTraversal
+        break if @CurrentLight = lights.GetNextItem
+      end
+    end
+
+    @LastX = x
+    @LastY = y
+  end
+
+  def GetCurrentRenderer
+    return @CurrentRenderer
+  end
+
+  def StartMotion(wid, event=nil)
+    x = event.x
+    y = event.y
+    self.UpdateRenderer(x,y)
+    return true
+  end
+
+  def EndMotion(wid, event=nil)
+    if @CurrentRenderer
+      self.Render
+    end
+    return true
+  end
+
+  def Rotate(x,y)
+    if @CurrentRenderer
+
+      @CurrentCamera.Azimuth(@LastX - x)
+      @CurrentCamera.Elevation(y - @LastY)
+      @CurrentCamera.OrthogonalizeViewUp
+
+      @LastX = x
+      @LastY = y
+
+      @CurrentRenderer.ResetCameraClippingRange
+      self.Render
+    end
+  end
+
+  def Pan(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      camera = @CurrentCamera
+      (pPoint0,pPoint1,pPoint2) = camera.GetPosition
+      (fPoint0,fPoint1,fPoint2) = camera.GetFocalPoint
+
+      if (camera.GetParallelProjection)
+        renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
+        renderer.WorldToDisplay
+        fx,fy,fz = renderer.GetDisplayPoint
+        renderer.SetDisplayPoint(fx-x+@LastX,
+                                 fy+y-@LastY,
+                                 fz)
+        renderer.DisplayToWorld
+        fx,fy,fz,fw = renderer.GetWorldPoint
+        camera.SetFocalPoint(fx,fy,fz)
+
+        renderer.SetWorldPoint(pPoint0,pPoint1,pPoint2,1.0)
+        renderer.WorldToDisplay
+        fx,fy,fz = renderer.GetDisplayPoint
+        renderer.SetDisplayPoint(fx-x+@LastX,
+                                 fy+y-@LastY,
+                                 fz)
+        renderer.DisplayToWorld
+        fx,fy,fz,fw = renderer.GetWorldPoint
+        camera.SetPosition(fx,fy,fz)
+
+      else
+        (fPoint0,fPoint1,fPoint2) = camera.GetFocalPoint
+        # Specify a point location in world coordinates
+        renderer.SetWorldPoint(fPoint0,fPoint1,fPoint2,1.0)
+        renderer.WorldToDisplay
+        # Convert world point coordinates to display coordinates
+        dPoint = renderer.GetDisplayPoint
+        focalDepth = dPoint[2]
+
+        aPoint0 = @ViewportCenterX + (x - @LastX)
+        aPoint1 = @ViewportCenterY - (y - @LastY)
+
+        renderer.SetDisplayPoint(aPoint0,aPoint1,focalDepth)
+        renderer.DisplayToWorld
+
+        (rPoint0,rPoint1,rPoint2,rPoint3) = renderer.GetWorldPoint
+        if (rPoint3 != 0.0)
+          rPoint0 = rPoint0/rPoint3
+          rPoint1 = rPoint1/rPoint3
+          rPoint2 = rPoint2/rPoint3
+        end
+
+        camera.SetFocalPoint((fPoint0 - rPoint0) + fPoint0, 
+                             (fPoint1 - rPoint1) + fPoint1,
+                             (fPoint2 - rPoint2) + fPoint2) 
+
+        camera.SetPosition((fPoint0 - rPoint0) + pPoint0, 
+                           (fPoint1 - rPoint1) + pPoint1,
+                           (fPoint2 - rPoint2) + pPoint2)
+      end
+
+      @LastX = x
+      @LastY = y
+
+      self.Render
+    end
+  end
+
+  def Zoom(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      camera = @CurrentCamera
+
+      zoomFactor = 1.02**(0.5*(@LastY - y))
+      @CurrentZoom = @CurrentZoom * zoomFactor
+
+      if camera.GetParallelProjection
+        parallelScale = camera.GetParallelScale/zoomFactor
+        camera.SetParallelScale(parallelScale)
+      else
+        camera.Dolly(zoomFactor)
+        renderer.ResetCameraClippingRange
+      end
+
+      @LastX = x
+      @LastY = y
+
+      self.Render
+    end
+  end
+
+  def Reset
+    if @CurrentRenderer
+      @CurrentRenderer.ResetCamera
+    end
+
+    self.Render
+  end
+
+  def Wireframe
+    actors = @CurrentRenderer.GetActors
+    numActors = actors.GetNumberOfItems
+    actors.InitTraversal
+    for i in 0...numActors
+      actor = actors.GetNextItem
+      actor.GetProperty.SetRepresentationToWireframe
+    end
+
+    self.Render
+  end
+
+  def Surface
+    actors = @CurrentRenderer.GetActors
+    numActors = actors.GetNumberOfItems
+    actors.InitTraversal
+    for i in 0...numActors
+      actor = actors.GetNextItem
+      actor.GetProperty.SetRepresentationToSurface
+    end
+
+    self.Render
+  end
+
+  def PickActor(x,y)
+    if @CurrentRenderer
+
+      renderer = @CurrentRenderer
+      picker = @Picker
+
+      windowY = self.get_window.height
+      picker.Pick(x,(windowY - y - 1),0.0,renderer)
+      assembly = picker.GetAssembly
+
+      if (@PickedAssembly != nil && @PrePickedProperty != nil)
+        @PickedAssembly.SetProperty(@PrePickedProperty)
+        # release hold of the property
+        @PrePickedProperty.UnRegister(@PrePickedProperty)
+        @PrePickedProperty = nil
+      end
+
+      if (assembly != nil)
+        @PickedAssembly = assembly
+        @PrePickedProperty = @PickedAssembly.GetProperty
+        # hold onto the property
+        @PrePickedProperty.Register(@PrePickedProperty)
+        @PickedAssembly.SetProperty(@PickedProperty)
+      end
+
+      self.Render
+    end
+  end
+end
+
+
+def main
+
+  Gtk.init
+  Gtk::GL.init
+
+  # The main window
+  window = Gtk::Window.new(Gtk::Window::TOPLEVEL)
+  window.set_title("A GtkVTKRenderWindow Demo!")
+  window.signal_connect("destroy"){ Gtk.main_quit }
+  window.signal_connect("delete_event"){ Gtk.main_quit }
+  window.set_border_width(10)
+
+  # A VBox into which widgets are packed.
+  vbox = Gtk::VBox.new(false, 3)
+  window.add(vbox)
+  vbox.show
+
+  # The GtkVTKRenderWindow
+  gvtk = GtkVTKRenderWindow.new
+  #gvtk.SetDesiredUpdateRate(1000)
+  gvtk.set_usize(400, 400)
+  vbox.pack_start(gvtk)
+  gvtk.show
+
+  # The VTK stuff.
+  cone = Vtk::ConeSource.new
+  cone.SetResolution(80)
+  coneMapper = Vtk::PolyDataMapper.new
+  coneMapper.SetInput(cone.GetOutput)
+  #coneActor = Vtk::LODActor.new
+  coneActor = Vtk::Actor.new
+  coneActor.SetMapper(coneMapper)    
+  coneActor.GetProperty.SetColor(0.5, 0.5, 1.0)
+  ren = Vtk::Renderer.new
+  gvtk.GetRenderWindow.AddRenderer(ren)
+  ren.AddActor(coneActor)
+
+  # A simple quit button
+  quit = Gtk::Button.new("Quit!")
+  quit.signal_connect("clicked"){ Gtk.main_quit }
+  vbox.pack_start(quit)
+  quit.show
+
+  # show the main window && start event processing.
+  window.show
+  Gtk.main
+end
+
+
+if $0 == __FILE__
+  main
+end