vtk-ruby 5.0.4.0-x86-mswin32-60

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

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

data/lib/VTK/gtk/GtkVTKRenderWindowInteractor.rb

@@ -0,0 +1,336 @@
+"""
+Description:
+
+  Provides a pyGtk vtkRenderWindowInteractor widget.  This embeds a
+  vtkRenderWindow inside a GTK widget && uses the
+  vtkGenericRenderWindowInteractor for the event handling.  This is
+  vtkGenericRenderWindowInteractor end
+  based on vtkTkRenderWindow.py.
+
+  The class uses the gtkgl.GtkGLArea widget (gtkglarea).  This avoids
+  The end
+  a lot of problems with flicker.
+
+  There is a working example at the bottom.
+
+Created by Prabhu Ramachandran, April 2002.
+
+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.
+
+"""
+
+require 'vtk'
+
+
+class GtkVTKRenderWindowInteractor(gtkgl.GtkGLArea)
+
+    """ Embeds a vtkRenderWindow into a pyGTK widget && uses
+    vtkGenericRenderWindowInteractor for the event handling.  This
+    vtkGenericRenderWindowInteractor end
+    class embeds the RenderWindow correctly.  A __getattr__ hook is
+    end
+    provided that makes the class behave like a
+    provided that makes the end
+    vtkGenericRenderWindowInteractor."""
+
+    def __init__(self, *args)
+        l = list(args)
+        attr = (gtkgl.RGBA, gtkgl.DOUBLEBUFFER)
+        l.insert(0, self)
+        l.insert(1, attr)
+        apply(gtkgl.GtkGLArea.__init__, l)
+        self._RenderWindow = Vtk::RenderWindow.new
+
+        # private attributes
+        self.__Created = 0
+        self._ActiveButton = 0
+
+        self._Iren = Vtk::GenericRenderWindowInteractor.new
+        self._Iren.SetRenderWindow(self._RenderWindow)
+
+        self._Iren.AddObserver('CreateTimerEvent', self.CreateTimer)
+        self._Iren.AddObserver('DestroyTimerEvent', self.DestroyTimer)
+        self.ConnectSignals
+
+        # need this to be able to handle key_press events.
+        self.set_flags(gtk.CAN_FOCUS)
+        # default size
+        self.set_usize(300, 300)
+    end
+
+    def set_usize(self, w, h)
+    end
+end
+	gtkgl.GtkGLArea.set_usize(self, w, h)
+	self._RenderWindow.SetSize(w, h)
+	self._Iren.SetSize(w, h)
+	self._Iren.ConfigureEvent
+
+    def ConnectSignals(self)
+        self.connect("realize", self.OnRealize)
+        self.connect("expose_event", self.OnExpose)
+        self.connect("configure_event", self.OnConfigure)
+        self.connect("button_press_event", self.OnButtonDown)
+        self.connect("button_release_event", self.OnButtonUp)
+        self.connect("motion_notify_event", self.OnMouseMove)
+        self.connect("enter_notify_event", self.OnEnter)
+        self.connect("leave_notify_event", self.OnLeave)
+        self.connect("key_press_event", self.OnKeyPress)
+        self.connect("delete_event", self.OnDestroy)
+        self.add_events(GDK.EXPOSURE_MASK| GDK.BUTTON_PRESS_MASK |
+                        GDK.BUTTON_RELEASE_MASK |
+                        GDK.KEY_PRESS_MASK |
+                        GDK.POINTER_MOTION_MASK |
+                        GDK.POINTER_MOTION_HINT_MASK |
+                        GDK.ENTER_NOTIFY_MASK | GDK.LEAVE_NOTIFY_MASK)
+    end
+
+    def __getattr__(self, attr)
+        """Makes the object behave like a
+        vtkGenericRenderWindowInteractor"""
+        if attr == '__vtk__'
+            return lambda t=self._Iren: t
+        elsif hasattr(self._Iren, attr)            return getattr(self._Iren, attr)
+        else            raise AttributeError, self.__class__.__name__ + \
+                  " has no attribute named " + attr
+        end
+    end
+
+    def CreateTimer(self, obj, event)
+        gtk.timeout_add(10, self._Iren.TimerEvent)
+    end
+
+    def DestroyTimer(self, obj, event)
+        """The timer is a one shot timer so will expire automatically."""
+        return 1
+    end
+
+    def GetRenderWindow(self)
+        return self._RenderWindow
+    end
+
+    def Render(self)
+        if self.__Created
+            self._RenderWindow.Render
+        end
+    end
+
+    def OnRealize(self, *args)
+        if self.__Created == 0
+            # you can't get the xid without the window being realized.
+            self.realize
+            win_id = str(self.get_window.xid)
+            self._RenderWindow.SetWindowInfo(win_id)
+        end
+    end
+	    self._Iren.Initialize
+	    self.__Created = 1
+        return gtk.TRUE    
+
+    def OnConfigure(self, wid, event=nil)
+        sz = self._RenderWindow.GetSize
+        if (event.width != sz[0]) || (event.height != sz[1])
+            self._Iren.SetSize(event.width, event.height)
+            self._Iren.ConfigureEvent
+        end
+        return gtk.TRUE
+    end
+
+    def OnExpose(self, *args)
+        self.Render
+        return gtk.TRUE
+    end
+
+    def OnDestroy(self, event=nil)
+        self.hide
+        del self._RenderWindow
+        self.destroy
+        return gtk.TRUE
+    end
+
+    def _GetCtrlShift(self, event)
+        ctrl, shift = 0, 0        
+        if ((event.state & GDK.CONTROL_MASK) == GDK.CONTROL_MASK)
+            ctrl = 1
+        end
+        if ((event.state & GDK.SHIFT_MASK) == GDK.SHIFT_MASK)
+            shift = 1
+        end
+        return ctrl, shift
+    end
+
+    def OnButtonDown(self, wid, event)
+        """Mouse button pressed."""
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            chr(0), 0, nil)
+        button = event.button
+        if button == 3
+            self._Iren.RightButtonPressEvent
+            return gtk.TRUE
+        end
+    end
+	elif button == 1
+            self._Iren.LeftButtonPressEvent
+            return gtk.TRUE
+	elend
+	elif button == 2
+            self._Iren.MiddleButtonPressEvent
+            return gtk.TRUE
+        else:
+            return gtk.FALSE
+
+    def OnButtonUp(self, wid, event)
+        """Mouse button released."""
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            chr(0), 0, nil)
+        button = event.button
+        if button == 3
+            self._Iren.RightButtonReleaseEvent
+            return gtk.TRUE
+        end
+    end
+	elend
+	elif button == 1
+            self._Iren.LeftButtonReleaseEvent
+            return gtk.TRUE
+	elend
+	elif button == 2
+            self._Iren.MiddleButtonReleaseEvent
+            return gtk.TRUE
+
+        return gtk.FALSE
+
+    def OnMouseMove(self, wid, event)
+        """Mouse has moved."""
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            chr(0), 0, nil)
+        self._Iren.MouseMoveEvent
+        return gtk.TRUE
+    end
+
+    def OnEnter(self, wid, event)
+        """Entering the vtkRenderWindow."""
+        self.grab_focus
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            chr(0), 0, nil)
+        self._Iren.EnterEvent
+        return gtk.TRUE
+    end
+
+    def OnLeave(self, wid, event)
+        """Leaving the vtkRenderWindow."""
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            chr(0), 0, nil)
+        self._Iren.LeaveEvent
+        return gtk.TRUE
+    end
+
+    def OnKeyPress(self, wid, event)
+        """Key pressed."""
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+    end
+	elend
+	keycode, keysym = event.keyval, event.string
+        key = chr(0)
+        if keycode < 256
+            key = chr(keycode)
+        end
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            key, 0, keysym)
+        self._Iren.KeyPressEvent
+        self._Iren.CharEvent
+        return gtk.TRUE
+
+    def OnKeyRelease(self, wid, event)
+        "Key released."
+        m = self.get_pointer
+        ctrl, shift = self._GetCtrlShift(event)
+    end
+	keycode, keysym = event.keyval, event.string
+        key = chr(0)
+        if keycode < 256
+            key = chr(keycode)
+        end
+        self._Iren.SetEventInformationFlipY(m[0], m[1], ctrl, shift,
+                                            key, 0, keysym)
+        self._Iren.KeyReleaseEvent
+        return gtk.TRUE
+
+    def Initialize(self)
+    end
+	if self.__Created
+	end
+	    self._Iren.Initialize
+
+
+def main
+    # The main window
+    window = gtk.GtkWindow(gtk.WINDOW_TOPLEVEL)
+    window.set_title("A GtkVTKRenderWindow Demo!")
+    window.connect("destroy", gtk.mainquit)
+    window.connect("delete_event", gtk.mainquit)
+    window.set_border_width(10)
+
+    # A VBox into which widgets are packed.
+    vbox = gtk.GtkVBox(spacing=3)
+    window.add(vbox)
+    vbox.show
+
+    # The GtkVTKRenderWindow
+    gvtk = GtkVTKRenderWindowInteractor
+    #gvtk.SetDesiredUpdateRate(1000)
+    gvtk.set_usize(400, 400)
+    vbox.pack_start(gvtk)
+    gvtk.show
+    gvtk.Initialize
+    gvtk.Start
+    # prevents 'q' from exiting the app.
+    gvtk.AddObserver("ExitEvent", lambda o,e,x=nil: x)
+
+    # 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.GtkButton("Quit!")
+    quit.connect("clicked", gtk.mainquit)
+    vbox.pack_start(quit)
+    quit.show
+
+    # show the main window && start event processing.
+    window.show
+    gtk.mainloop
+end
+
+
+if __name__ == "__main__"
+    main

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

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

data/lib/VTK/hybrid.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /win32/
+  require 'vtk/vtkHybridRuby'
+else
+  require 'vtk/libvtkHybridRuby'
+end

data/lib/VTK/hybrid.rb.rule

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

data/lib/VTK/imaging.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /win32/
+  require 'vtk/vtkImagingRuby'
+else
+  require 'vtk/libvtkImagingRuby'
+end

data/lib/VTK/imaging.rb.rule

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

data/lib/VTK/io.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /win32/
+  require 'vtk/vtkIORuby'
+else
+  require 'vtk/libvtkIORuby'
+end

data/lib/VTK/io.rb.rule

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

data/lib/VTK/parallel.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /win32/
+  require 'vtk/vtkParallelRuby'
+else
+  require 'vtk/libvtkParallelRuby'
+end

data/lib/VTK/parallel.rb.rule

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

data/lib/VTK/rendering.rb

@@ -0,0 +1,7 @@
+require 'rbconfig'
+
+if Config::CONFIG['host_os'] =~ /win32/
+  require 'vtk/vtkRenderingRuby'
+else
+  require 'vtk/libvtkRenderingRuby'
+end

data/lib/VTK/rendering.rb.rule

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

data/lib/VTK/tk.rb

@@ -0,0 +1,4 @@
+require 'vtk/tk/vtkTkRenderWidget'
+require 'vtk/tk/vtkTkImageViewerWidget'
+require 'vtk/tk/vtkTkRenderWindowInteractor'
+require 'vtk/tk/vtkTkPhotoImage'

data/lib/VTK/tk.rb.rule

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

data/lib/VTK/tk/vtkLoadRubyTkWidgets.rb

@@ -0,0 +1,54 @@
+require 'rbconfig'
+require 'tk'
+
+def Vtk.LoadRubyTkWidgets
+=begin
+    vtkLoadRubyTkWidgets(interp) -- load vtk-tk widget extensions
+
+    This is a mess of mixed python and tcl code that searches for the
+    shared object file that contains the python-vtk-tk widgets.  Both
+    the ruby path and the tcl path are searched.
+=end
+  name = 'vtkRenderingRubyTkWidgets'
+  pkgname = name.downcase.capitalize
+
+  # find out if the file is already loaded
+  loaded = Tk.tk_call('info', 'loaded')
+  if loaded.include?(pkgname)
+    return false
+  end
+
+  # create the platform-dependent file name
+  prefix = ''
+  if Config::CONFIG['arch']=~/linux/
+    prefix = 'lib'
+  end
+  extension = Tk.tk_call('info', 'sharedlibextension')
+  filename = prefix+name+extension
+
+  # create an extensive list of paths to search
+  pathlist = $LOAD_PATH
+  # add tcl paths, ensure that {} is handled properly
+  auto_paths = Tk::AUTO_PATH.to_a
+  pathlist += auto_paths
+
+  # a common place for these sorts of things  
+  if Config::CONFIG['arch']=~/linux/
+    pathlist += ['/usr/local/lib']
+  end
+
+  # attempt to load
+  for path in pathlist
+    fullpath = File.join(path, filename)
+    begin
+      Tk.load_tcllibrary(fullpath, pkgname)
+      return true
+    rescue
+      next
+    end
+  end
+
+  # re-generate the error
+  Tk.tk_call('load', filename)
+  return nil
+end