"""Description:  Provides a simple VTK widget for pyGtk.  This embeds a  vtkRenderWindow inside a GTK widget.  This is based on  vtkTkRenderWidget.py.  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:  Thanks to Dave Reed for testing the code under various platforms and  for his suggestion to use the GtkGLArea widget to avoid flicker  related issues.Created by Prabhu Ramachandran, March 2001.Using GtkGLArea, March, 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 not work under Win32 because it uses the XID of a window in  OnRealize.  Suggestions to fix this will be appreciated."""import gtk, GDK, gtkglimport vtkimport mathclass GtkVTKRenderWindowBase(gtkgl.GtkGLArea):    """ 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. """    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.vtkRenderWindow()        # private attributes        self.__Created = 0        # used by the LOD actors        self._DesiredUpdateRate = 15        self._StillUpdateRate = 0.0001        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)            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)            def GetRenderWindow(self):        return self._RenderWindow    def GetRenderer(self):        self._RenderWindow.GetRenderers().InitTraversal()        return self._RenderWindow.GetRenderers().GetNextItem()    def SetDesiredUpdateRate(self, rate):        """Mirrors the method with the same name in        vtkRenderWindowInteractor."""        self._DesiredUpdateRate = rate    def GetDesiredUpdateRate(self):        """Mirrors the method with the same name in        vtkRenderWindowInteractor."""        return self._DesiredUpdateRate             def SetStillUpdateRate(self, rate):        """Mirrors the method with the same name in        vtkRenderWindowInteractor."""        self._StillUpdateRate = rate    def GetStillUpdateRate(self):        """Mirrors the method with the same name in        vtkRenderWindowInteractor."""        return self._StillUpdateRate    def Render(self):        if self.__Created:            self._RenderWindow.Render()    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)            self.__Created = 1        return gtk.TRUE        def OnConfigure(self, wid, event=None):        sz = self._RenderWindow.GetSize()        if (event.width != sz[0]) or (event.height != sz[1]):            self._RenderWindow.SetSize(event.width, event.height)        return gtk.TRUE    def OnExpose(self, *args):        self.Render()        return gtk.TRUE    def OnDestroy(self, event=None):        self.hide()        del self._RenderWindow        self.destroy()        return gtk.TRUE    def OnButtonDown(self, wid, event):        """Mouse button pressed."""        self._RenderWindow.SetDesiredUpdateRate(self._DesiredUpdateRate)        return gtk.TRUE        def OnButtonUp(self, wid, event):        """Mouse button released."""        self._RenderWindow.SetDesiredUpdateRate(self._StillUpdateRate)        return gtk.TRUE    def OnMouseMove(self, wid, event):        """Mouse has moved."""        return gtk.TRUE    def OnEnter(self, wid, event):        """Entering the vtkRenderWindow."""        return gtk.TRUE    def OnLeave(self, wid, event):        """Leaving the vtkRenderWindow."""        return gtk.TRUE        def OnKeyPress(self, wid, event):        """Key pressed."""        return gtk.TRUE    def OnKeyRelease(self, wid, event):        "Key released."        return gtk.TRUEclass GtkVTKRenderWindow(GtkVTKRenderWindowBase):    """ An example of a fully functional GtkVTKRenderWindow that is    based on the vtkRenderWidget.py provided with the VTK sources."""    def __init__(self, *args):        l = list(args)        l.insert(0, self)        apply(GtkVTKRenderWindowBase.__init__, l)                self._CurrentRenderer = None        self._CurrentCamera = None        self._CurrentZoom = 1.0        self._CurrentLight = None        self._ViewportCenterX = 0        self._ViewportCenterY = 0                self._Picker = vtk.vtkCellPicker()        self._PickedAssembly = None        self._PickedProperty = vtk.vtkProperty()        self._PickedProperty.SetColor(1, 0, 0)        self._PrePickedProperty = None                self._OldFocus = None        # these record the previous mouse position        self._LastX = 0        self._LastY = 0    def OnButtonDown(self, wid, event):        self._RenderWindow.SetDesiredUpdateRate(self._DesiredUpdateRate)        return self.StartMotion(wid, event)        def OnButtonUp(self, wid, event):        self._RenderWindow.SetDesiredUpdateRate(self._StillUpdateRate)        return self.EndMotion(wid, event)    def OnMouseMove(self, wid, event=None):        if ((event.state & GDK.BUTTON1_MASK) == GDK.BUTTON1_MASK):            if ((event.state & GDK.SHIFT_MASK) == GDK.SHIFT_MASK):                m = self.get_pointer()                self.Pan(m[0], m[1])                return gtk.TRUE            else:                m = self.get_pointer()                self.Rotate(m[0], m[1])                return gtk.TRUE        elif ((event.state & GDK.BUTTON2_MASK) == GDK.BUTTON2_MASK):            m = self.get_pointer()            self.Pan(m[0], m[1])            return gtk.TRUE        elif ((event.state & GDK.BUTTON3_MASK) == GDK.BUTTON3_MASK):            m = self.get_pointer()            self.Zoom(m[0], m[1])            return gtk.TRUE        else:            return gtk.FALSE    def OnEnter(self, wid, event=None):        self.grab_focus()        w = self.get_pointer()        self.UpdateRenderer(w[0], w[1])        return gtk.TRUE    def OnLeave(self, wid, event):        return gtk.TRUE    def OnKeyPress(self, wid, event=None):        if (event.keyval == GDK.r) or (event.keyval == GDK.R):            self.Reset()            return gtk.TRUE        elif (event.keyval == GDK.w) or (event.keyval == GDK.W):            self.Wireframe()            return gtk.TRUE        elif (event.keyval == GDK.s) or (event.keyval == GDK.S):            self.Surface()            return gtk.TRUE        elif (event.keyval == GDK.p) or (event.keyval == GDK.P):            m = self.get_pointer()            self.PickActor(m[0], m[1])            return gtk.TRUE        else:            return gtk.FALSE    def GetZoomFactor(self):