"""This python module provides functionality to parse the methods of aVTK object.Created by Prabhu Ramachandran.  Committed in Apr, 2002."""import string, re, sysimport types# set this to 1 if you want to see debugging messages - very useful if# you have problemsDEBUG=0def debug (msg):    if DEBUG:	print msgclass VtkDirMethodParser:    """ Parses the methods from dir(vtk_obj). """    def initialize_methods (self, vtk_obj):        debug ("VtkDirMethodParser:: initialize_methods ()")	self.methods = dir (vtk_obj)[:]	# stores the <blah>On methods	self.toggle_meths = []	# stores the Set<blah>To<blah> methods	self.state_meths = []	# stores the methods that have a Get<blah> and Set<blah>	# only the <blah> is stored	self.get_set_meths = []	# pure get methods	self.get_meths = []	self.state_patn = re.compile ("To[A-Z0-9]")    def parse_methods (self, vtk_obj):	debug ("VtkDirMethodParser:: parse_methods()")        self.initialize_methods (vtk_obj)		debug ("VtkDirMethodParser:: parse_methods() - initialized methods")		for method in self.methods[:]:	    # finding all the methods that set the state.	    if string.find (method[:3], "Set") >= 0 and \		 self.state_patn.search (method) is not None :                try:                    eval ("vtk_obj.Get%s"%method[3:])                except AttributeError:                    self.state_meths.append (method)                    self.methods.remove (method)            # finding all the On/Off toggle methods	    elif string.find (method[-2:], "On") >= 0:                try:                    self.methods.index ("%sOff"%method[:-2])                except ValueError:                    pass                else:                    self.toggle_meths.append (method)                    self.methods.remove (method)                    self.methods.remove ("%sOff"%method[:-2])            	    # finding the Get/Set methods.	    elif string.find (method[:3], "Get") == 0:		set_m = "Set"+method[3:]		try: 		    self.methods.index (set_m) 		except ValueError:		    pass		else:		    self.get_set_meths.append (method[3:])		    self.methods.remove (method)		    self.methods.remove (set_m)	self.clean_up_methods (vtk_obj)    def clean_up_methods (self, vtk_obj):	self.clean_get_set (vtk_obj)	self.clean_state_methods (vtk_obj)	self.clean_get_methods (vtk_obj)    def clean_get_set (self, vtk_obj):	debug ("VtkDirMethodParser:: clean_get_set()")	# cleaning up the Get/Set methods by removing the toggle funcs.	for method in self.toggle_meths:	    try:		self.get_set_meths.remove (method[:-2])	    except ValueError:		pass	# cleaning them up by removing any methods that are responsible for	# other vtkObjects	for method in self.get_set_meths[:]:	    try:		eval ("vtk_obj.Get%s ().GetClassName ()"%method)	    except (TypeError, AttributeError):		pass	    else:		self.get_set_meths.remove (method)                continue	    try:		val = eval ("vtk_obj.Get%s ()"%method)	    except (TypeError, AttributeError):		self.get_set_meths.remove (method)	    else:		if val is None:		    self.get_set_meths.remove (method)	    def clean_state_methods (self, vtk_obj):	debug ("VtkDirMethodParser:: clean_state_methods()")	# Getting the remaining pure GetMethods 	for method in self.methods[:]:	    if string.find (method[:3], "Get") == 0:		self.get_meths.append (method)		self.methods.remove (method)	# Grouping similar state methods	if len (self.state_meths) != 0:	    tmp = self.state_meths[:]	    self.state_meths = []	    state_group = [tmp[0]]	    end = self.state_patn.search (tmp[0]).start ()	    # stores the method type common to all similar methods	    m = tmp[0][3:end] 	    for i in range (1, len (tmp)):		if string.find (tmp[i], m) >= 0:		    state_group.append (tmp[i])		else:		    self.state_meths.append (state_group)		    state_group = [tmp[i]]			    end = self.state_patn.search (tmp[i]).start ()		    m = tmp[i][3:end]		try: # remove the corresponding set method in get_set		    val = self.get_set_meths.index (m)		except ValueError: 		    pass		else:		    del self.get_set_meths[val]		    #self.get_meths.append ("Get"+m)                clamp_m = "Get" + m + "MinValue"                try: # remove the GetNameMax/MinValue in get_meths                    val = self.get_meths.index (clamp_m)                except ValueError:                    pass                else:                    del self.get_meths[val]                    val = self.get_meths.index ("Get" + m + "MaxValue")                    del self.get_meths[val]	    if len (state_group) > 0:		self.state_meths.append (state_group)    def clean_get_methods (self, vtk_obj):	debug ("VtkDirMethodParser:: clean_get_methods()")	for method in self.get_meths[:]:            debug (method)            try:		res = eval ("vtk_obj.%s ()"%method)	    except (TypeError, AttributeError):		self.get_meths.remove (method)                continue	    else:		try:		    eval ("vtk_obj.%s ().GetClassName ()"%method)		except AttributeError:		    pass		else:		    self.get_meths.remove (method)                    continue            if string.find (method[-8:], "MaxValue") > -1:                self.get_meths.remove( method)            elif string.find (method[-8:], "MinValue") > -1:                self.get_meths.remove( method)                	self.get_meths.sort ()    def toggle_methods (self):	return self.toggle_meths    def state_methods (self):	return self.state_meths    def get_set_methods (self):	return self.get_set_meths    def get_methods (self):	return self.get_methsclass VtkPrintMethodParser:    """ This class finds the methods for a given vtkObject.  It uses    the output from vtkObject->Print() (or in Python str(vtkObject))    and output from the VtkDirMethodParser to obtain the methods. """        def parse_methods (self, vtk_obj):	"Parse for the methods."	debug ("VtkPrintMethodParser:: parse_methods()")        if self._initialize_methods (vtk_obj):            # if David Gobbi's improvements are in this version of VTK            # then I need to go no further.            return	for method in self.methods[:]:	    # removing methods that have nothing to the right of the ':'	    if (method[1] == '') or \	       (string.find (method[1], "none") > -1) :		self.methods.remove (method)	for method in self.methods:	    # toggle methods are first identified	    if (method[1] == "On") or (method[1] == "Off"):		try:		    val = eval ("vtk_obj.Get%s ()"%method[0])		    if val == 1:			eval ("vtk_obj.%sOn ()"%method[0])		    elif val == 0:			eval ("vtk_obj.%sOff ()"%method[0])		except AttributeError:		    pass		else:		    self.toggle_meths.append (method[0]+"On")			    else: # see it it is get_set or get or a state method		found = 0		# checking if it is a state func.		# figure out the long names from the dir_state_meths		for sms in self.dir_state_meths[:]:		    if string.find (sms[0], method[0]) >= 0:			self.state_meths.append (sms)			self.dir_state_meths.remove (sms)			found = 1		if found:		    self.get_meths.append ("Get"+method[0])		    try:			t = eval ("vtk_obj.Get%sAsString ()"%method[0])		    except AttributeError:			pass		    else:			self.get_meths.append ("Get"+method[0]+"AsString")		else: 		    # the long name is inherited or it is not a state method		    try:			t = eval ("vtk_obj.Get%s ().GetClassName ()"%				  method[0])		    except AttributeError:			pass		    else:			continue			    val = 0		    try:			val = eval ("vtk_obj.Get%s ()"%method[0])		    except (TypeError, AttributeError):			pass		    else:                        try:                            f = eval ("vtk_obj.Set%s"%method[0])                        except AttributeError:                            self.get_meths.append ("Get"+method[0])                        else:                            try:                                apply (f, val)                            except TypeError:                                try:                                    apply (f, (val, ))                                except TypeError:                                    self.get_meths.append ("Get"+method[0])                                else:                                    self.get_set_meths.append (method[0])                            else:                                self.get_set_meths.append (method[0])                                self._clean_up_methods (vtk_obj)    def _get_str_obj (self, vtk_obj):	debug ("VtkPrintMethodParser:: _get_str_obj()")	self.methods = str (vtk_obj)	self.methods = string.split (self.methods, "\n")	del self.methods[0]    def _initialize_methods (self, vtk_obj):	"Do the basic parsing and setting up"	debug ("VtkPrintMethodParser:: _initialize_methods()")	dir_p = VtkDirMethodParser ()	dir_p.parse_methods (vtk_obj)        # testing if this version of vtk has David Gobbi's cool        # stuff. If it does then no need to do other things.        try:            junk = vtk_obj.__class__        except AttributeError:            pass        else:            self.toggle_meths = dir_p.toggle_methods ()            self.state_meths = dir_p.state_methods ()            self.get_set_meths = dir_p.get_set_methods ()            self.get_meths = dir_p.get_methods ()            return 1	self.dir_toggle_meths = dir_p.toggle_methods ()	self.dir_state_meths = dir_p.state_methods ()	self.dir_get_set_meths = dir_p.get_set_methods ()	self.dir_get_meths = dir_p.get_methods ()	self._get_str_obj (vtk_obj)	patn = re.compile ("  \S")    	for method in self.methods[:]:	    if not patn.match (method):		self.methods.remove (method)    	for method in self.methods[:]:	    if string.find (method, ":") == -1:		self.methods.remove (method)	for i in range (0, len (self.methods)):	    strng = self.methods[i]	    strng = string.replace (strng, " ", "")	    self.methods[i] = string.split (strng, ":")	self.toggle_meths = []	self.state_meths = []	self.get_set_meths = []	self.get_meths = []            return 0    def _clean_up_methods (self, vtk_obj):	"Merge dir and str methods.  Finish up."	debug ("VtkPrintMethodParser:: _clean_up_methods()")	for meth_list in ((self.dir_toggle_meths, self.toggle_meths),\			  (self.dir_get_set_meths, self.get_set_meths),\			  (self.dir_get_meths, self.get_meths)):	    for method in meth_list[0]:		try:		    meth_list[1].index (method)		except ValueError:		    meth_list[1].append (method)	    	# Remove all get_set methods that are already in toggle_meths	# This case can happen if the str produces no "On/Off" but	# dir does and str produces a get_set instead.	for method in self.toggle_meths:	    try:		self.get_set_meths.remove (method[:-2])	    except ValueError:		pass	self.toggle_meths.sort ()	self.state_meths.sort ()	self.get_set_meths.sort ()	self.get_meths.sort ()        def toggle_methods (self):	return self.toggle_meths    def state_methods (self):	return self.state_meths    def get_set_methods (self):	return self.get_set_meths    def get_methods (self):	return self.get_meths