diff --git a/direct/src/extensions/CInterval-extensions.py b/direct/src/extensions/CInterval-extensions.py index 4d611de137..94b2607f19 100644 --- a/direct/src/extensions/CInterval-extensions.py +++ b/direct/src/extensions/CInterval-extensions.py @@ -27,12 +27,23 @@ # Kill task taskMgr.remove(self.getName() + '-play') return self.getT() + + def setT(self, t, event = ETStep): + # Overridden from the C++ layer. We rename the C++ function + # in FFIRename to make this possible. + self.__cSetT(t, event) + if hasattr(self, "setTHooks"): + for func in self.setTHooks: + func(t) def setFinalT(self): # We have to define this at the Python level so we can # implicitly call stop(). self.stop() self.finalize() + if hasattr(self, "setTHooks"): + for func in self.setTHooks: + func(self.getT()) def isPlaying(self): return taskMgr.hasTaskNamed(self.getName() + '-play') @@ -40,7 +51,81 @@ def __playTask(self, task): import Task loopCount = self.stepPlay() + if hasattr(self, "setTHooks"): + for func in self.setTHooks: + func(self.getT()) if loopCount == 0 or self.__loop: return Task.cont else: return Task.done + + def popupControls(self, tl = None): + """ popupControls() + Popup control panel for interval. + """ + import TkGlobal + import fpformat + import string + # I moved this here because Toontown does not ship Tk + from Tkinter import Toplevel, Frame, Button, LEFT, X + import Pmw + import EntryScale + if tl == None: + tl = Toplevel() + tl.title('Interval Controls') + outerFrame = Frame(tl) + self.es = es = EntryScale.EntryScale( + outerFrame, text = self.getName(), + min = 0, max = string.atof(fpformat.fix(self.getDuration(), 2)), + command = lambda t, s = self: s.setT(t)) + # So when you drag scale with mouse its like you started a playback + def onPress(s=self,es=es): + # Kill playback task + s.stop() + # INIT interval + s.setT(es.get(), CInterval.ETInitialize) + es.onPress = onPress + # To make sure you stop free running intervals + es.onRelease = lambda s=self: s.stop() + # To update scale and execute intervals with ETInitialize + def onReturn(s = self, es = es): + s.setT(es.get(), CInterval.ETInitialize) + s.stop() + es.onReturnRelease = onReturn + es.pack(expand = 1, fill = X) + bf = Frame(outerFrame) + # Jump to start and end + def toStart(s=self, es=es): + s.setT(0.0, CInterval.ETInitialize) + s.stop() + def toEnd(s=self): + s.setT(s.getDuration(), CInterval.ETInitialize) + s.stop() + jumpToStart = Button(bf, text = '<<', command = toStart) + # Stop/play buttons + stop = Button(bf, text = 'Stop', + command = lambda s=self: s.stop()) + play = Button( + bf, text = 'Play', + command = lambda s=self, es=es: s.play(es.get())) + jumpToEnd = Button(bf, text = '>>', command = toEnd) + jumpToStart.pack(side = LEFT, expand = 1, fill = X) + play.pack(side = LEFT, expand = 1, fill = X) + stop.pack(side = LEFT, expand = 1, fill = X) + jumpToEnd.pack(side = LEFT, expand = 1, fill = X) + bf.pack(expand = 1, fill = X) + outerFrame.pack(expand = 1, fill = X) + # Add function to update slider during setT calls + def update(t,es=es): + es.set(t, fCommand = 0) + if not hasattr(self, "setTHooks"): + self.setTHooks = [] + self.setTHooks.append(update) + # Clear out function on destroy + def onDestroy(e, s=self, u=update): + if u in s.setTHooks: + s.setTHooks.remove(u) + tl.bind('', onDestroy) + + + diff --git a/direct/src/ffi/FFIInterrogateDatabase.py b/direct/src/ffi/FFIInterrogateDatabase.py index b15d39af54..bb6d163645 100644 --- a/direct/src/ffi/FFIInterrogateDatabase.py +++ b/direct/src/ffi/FFIInterrogateDatabase.py @@ -479,7 +479,8 @@ class FFIInterrogateDatabase: for typeDesc in typeDescs: funcSpec = FFISpecs.MethodSpecification() funcSpec.name = FFIRename.methodNameFromCppName( - interrogate_function_name(funcIndex)) + interrogate_function_name(funcIndex), + getTypeName(typeIndex)) funcSpec.typeDescriptor = typeDesc funcSpec.index = funcIndex funcSpecs.append(funcSpec) @@ -528,7 +529,8 @@ class FFIInterrogateDatabase: for typeDesc in typeDescs: funcSpec = FFISpecs.GlobalFunctionSpecification() funcSpec.name = FFIRename.methodNameFromCppName( - interrogate_function_name(funcIndex)) + interrogate_function_name(funcIndex), + getTypeName(typeIndex)) funcSpec.typeDescriptor = typeDesc funcSpec.index = funcIndex # Here we look for the class in the first argument diff --git a/direct/src/ffi/FFIRename.py b/direct/src/ffi/FFIRename.py index 6a11e25950..b058a7344f 100644 --- a/direct/src/ffi/FFIRename.py +++ b/direct/src/ffi/FFIRename.py @@ -43,7 +43,8 @@ methodRenameDictionary = { 'operator->' : 'dereference', 'operator<<=' : '__ilshift__', 'operator>>=' : '__irshift__', - 'print' : 'Cprint' + 'print' : 'Cprint', + 'CInterval.setT' : '__cSetT', } classRenameDictionary = { @@ -124,7 +125,7 @@ def nonClassNameFromCppName(cppName): newName = checkKeyword(newName) return newName -def methodNameFromCppName(cppName): +def methodNameFromCppName(cppName, className = None): methodName = '' badChars = ' ' nextCap = 0 @@ -138,9 +139,12 @@ def methodNameFromCppName(cppName): methodName = methodName + capitalize(char) nextCap = 0 else: - methodName = methodName + char - if methodRenameDictionary.has_key(methodName): - methodName = methodRenameDictionary[methodName] + methodName = methodName + char + + if className != None: + methodName = methodRenameDictionary.get(className + '.' + methodName, methodName) + methodName = methodRenameDictionary.get(methodName, methodName) + # Mangle names that happen to be python keywords so they are not anymore methodName = checkKeyword(methodName) return methodName diff --git a/direct/src/interval/LerpInterval.py b/direct/src/interval/LerpInterval.py index 104616362a..c88dbfa0ad 100644 --- a/direct/src/interval/LerpInterval.py +++ b/direct/src/interval/LerpInterval.py @@ -71,7 +71,8 @@ class LerpPosInterval(LerpNodePathInterval): node, other) # Check for functors in the input parameters. - if self.anyCallable(pos, startPos): + self.paramSetup = self.anyCallable(pos, startPos) + if self.paramSetup: self.endPos = pos self.startPos = startPos self.inPython = 1 @@ -80,10 +81,10 @@ class LerpPosInterval(LerpNodePathInterval): if startPos != None: self.setStartPos(startPos) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndPos, self.endPos) self.setupParam(self.setStartPos, self.startPos) LerpNodePathInterval.setT(self, t, event) @@ -96,7 +97,8 @@ class LerpHprInterval(LerpNodePathInterval): node, other) # Check for functors in the input parameters. - if self.anyCallable(hpr, startHpr): + self.paramSetup = self.anyCallable(hpr, startHpr) + if self.paramSetup: self.endHpr = hpr self.startHpr = startHpr self.inPython = 1 @@ -105,10 +107,10 @@ class LerpHprInterval(LerpNodePathInterval): if startHpr != None: self.setStartHpr(startHpr) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndHpr, self.endHpr) self.setupParam(self.setStartHpr, self.startHpr) LerpNodePathInterval.setT(self, t, event) @@ -119,7 +121,8 @@ class LerpScaleInterval(LerpNodePathInterval): LerpNodePathInterval.__init__(self, name, duration, blendType, node, other) # Check for functors in the input parameters. - if self.anyCallable(scale, startScale): + self.paramSetup = self.anyCallable(scale, startScale) + if self.paramSetup: self.endScale = scale self.startScale = startScale self.inPython = 1 @@ -128,10 +131,10 @@ class LerpScaleInterval(LerpNodePathInterval): if startScale != None: self.setStartScale(startScale) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndScale, self.endScale) self.setupParam(self.setStartScale, self.startScale) LerpNodePathInterval.setT(self, t, event) @@ -143,7 +146,8 @@ class LerpPosHprInterval(LerpNodePathInterval): LerpNodePathInterval.__init__(self, name, duration, blendType, node, other) # Check for functors in the input parameters. - if self.anyCallable(pos, startPos, hpr, startHpr): + self.paramSetup = self.anyCallable(pos, startPos, hpr, startHpr) + if self.paramSetup: self.endPos = pos self.startPos = startPos self.endHpr = hpr @@ -157,10 +161,10 @@ class LerpPosHprInterval(LerpNodePathInterval): if startHpr != None: self.setStartHpr(startHpr) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndPos, self.endPos) self.setupParam(self.setStartPos, self.startPos) self.setupParam(self.setEndHpr, self.endHpr) @@ -175,7 +179,8 @@ class LerpHprScaleInterval(LerpNodePathInterval): node, other) # Check for functors in the input parameters. - if self.anyCallable(hpr, startHpr, scale, startScale): + self.paramSetup = self.anyCallable(hpr, startHpr, scale, startScale) + if self.paramSetup: self.endHpr = hpr self.startHpr = startHpr self.endScale = scale @@ -189,10 +194,10 @@ class LerpHprScaleInterval(LerpNodePathInterval): if startScale != None: self.setStartScale(startScale) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndHpr, self.endHpr) self.setupParam(self.setStartHpr, self.startHpr) self.setupParam(self.setEndScale, self.endScale) @@ -206,7 +211,8 @@ class LerpPosHprScaleInterval(LerpNodePathInterval): LerpNodePathInterval.__init__(self, name, duration, blendType, node, other) # Check for functors in the input parameters. - if self.anyCallable(pos, startPos, hpr, startHpr, scale, startScale): + self.paramSetup = self.anyCallable(pos, startPos, hpr, startHpr, scale, startScale) + if self.paramSetup: self.endPos = pos self.startPos = startPos self.endHpr = hpr @@ -225,10 +231,10 @@ class LerpPosHprScaleInterval(LerpNodePathInterval): if startScale != None: self.setStartScale(startScale) - def setT(self, t, event): + def setT(self, t, event = Interval.IVAL_NONE): # This function is only used if Python functors were passed in # for some of the input parameters. - if event == Interval.IVAL_INIT: + if self.paramSetup and event == Interval.IVAL_INIT: self.setupParam(self.setEndPos, self.endPos) self.setupParam(self.setStartPos, self.startPos) self.setupParam(self.setEndHpr, self.endHpr)