def __init__(self, eventNode, coordSysNode=None, eventSource=avg.TOUCH | avg.MOUSE,
initialEvent=None,
direction=ANY_DIRECTION, directionTolerance=DIRECTION_TOLERANCE,
friction=-1,
possibleHandler=None, failHandler=None, detectedHandler=None,
moveHandler=None, upHandler=None, endHandler=None):
if coordSysNode != None:
self.__coordSysNode = weakref.ref(coordSysNode)
else:
self.__coordSysNode = weakref.ref(eventNode)
self.__moveHandler = utils.methodref(moveHandler)
self.__upHandler = utils.methodref(upHandler)
self.__direction = direction
if self.__direction == DragRecognizer.ANY_DIRECTION:
self.__minDist = 0
else:
self.__minDist = MIN_DRAG_DIST*g_Player.getPixelsPerMM()
self.__directionTolerance = directionTolerance
self.__friction = friction
self.__isSliding = False
self.__inertiaHandler = None
super(DragRecognizer, self).__init__(eventNode, True, eventSource, 1,
initialEvent, possibleHandler=possibleHandler, failHandler=failHandler,
detectedHandler=detectedHandler, endHandler=endHandler)
def __init__(self, node, isContinuous, eventSource, maxContacts, initialEvent,
possibleHandler=None, failHandler=None, detectedHandler=None,
endHandler=None):
if node:
self.__node = weakref.ref(node)
else:
self.__node = None
self.__isContinuous = isContinuous
self.__eventSource = eventSource
self.__maxContacts = maxContacts
self.__possibleHandler = utils.methodref(possibleHandler)
self.__failHandler = utils.methodref(failHandler)
self.__detectedHandler = utils.methodref(detectedHandler)
self.__endHandler = utils.methodref(endHandler)
self.__setEventHandler()
self.__isEnabled = True
self._contacts = {}
self.__dirty = False
self.__stateMachine = statemachine.StateMachine(str(type(self)), "IDLE")
if self.__isContinuous:
self.__stateMachine.addState("IDLE", ("POSSIBLE", "RUNNING"))
self.__stateMachine.addState("POSSIBLE", ("IDLE", "RUNNING"))
self.__stateMachine.addState("RUNNING", ("IDLE",))
else:
self.__stateMachine.addState("IDLE", ("POSSIBLE",))
self.__stateMachine.addState("POSSIBLE", ("IDLE",))
#self.__stateMachine.traceChanges(True)
if initialEvent:
self.__onDown(initialEvent)
def __init__(self, upNode=None, downNode=None, disabledNode=None,
activeAreaNode=None, pressHandler=None, clickHandler=None,
stateChangeHandler=None, parent=None, **kwargs):
super(Button, self).__init__(**kwargs)
if parent:
parent.appendChild(self)
self.__upNode = upNode
self.__downNode = downNode
self.__disabledNode = disabledNode
self.__activeAreaNode = activeAreaNode
self.__pressCallback = utils.methodref(pressHandler)
self.__clickCallback = utils.methodref(clickHandler)
self.__stateChangeCallback = utils.methodref(stateChangeHandler)
self.__capturedCursorIds = set()
self.__overCursorIds = set()
self.__isCheckable = False
self.__isToggled = False
self.__isOver = False
self.__state = Button.STATE_UP
if self.__upNode and self.__downNode:
self.__setupNodes()
def __init__(self, eventNode, coordSysNode=None, eventSource=avg.TOUCH,
initialEvent=None, friction=-1,
detectedHandler=None, moveHandler=None, upHandler=None, endHandler=None):
if coordSysNode != None:
self.__coordSysNode = weakref.ref(coordSysNode)
else:
self.__coordSysNode = weakref.ref(eventNode)
self.__moveHandler = utils.methodref(moveHandler)
self.__upHandler = utils.methodref(upHandler)
self.__friction = friction
self.__baseTransform = Mat3x3()
self.__lastPosns = []
self.__posns = []
self.__inertiaHandler = None
super(TransformRecognizer, self).__init__(eventNode, True, eventSource, None,
initialEvent, detectedHandler=detectedHandler, endHandler=endHandler)
def __init__(self, upNode, downNode, disabledNode=None, activeAreaNode=None,
fatFingerEnlarge=False, clickHandler=None, parent=None, **kwargs):
super(TouchButton, self).__init__(**kwargs)
if parent:
parent.appendChild(self)
self.__upNode = upNode
self.__downNode = downNode
self.__disabledNode = disabledNode
self.__activeAreaNode = activeAreaNode
self.__clickHandler = utils.methodref(clickHandler)
self.__stateMachine = statemachine.StateMachine("TouchButton", "UP")
self.__stateMachine.addState("UP", ("DOWN", "DISABLED"),
enterFunc=self.__enterUp, leaveFunc=self.__leaveUp)
self.__stateMachine.addState("DOWN", ("UP", "DISABLED"),
enterFunc=self.__enterDown, leaveFunc=self.__leaveDown)
self.__stateMachine.addState("DISABLED", ("UP", "DOWN"),
enterFunc=self.__enterDisabled, leaveFunc=self.__leaveDisabled)
self.appendChild(self.__upNode)
self.__upNode.active = True
self.appendChild(self.__downNode)
self.__downNode.active = False
if self.__disabledNode:
self.appendChild(self.__disabledNode)
self.__disabledNode.active = False
if fatFingerEnlarge:
if self.__activeAreaNode != None:
raise(RuntimeError(
"TouchButton: Can't specify both fatFingerEnlarge and activeAreaNode"))
size = upNode.size
minSize = 20*g_Player.getPixelsPerMM()
size = avg.Point2D(max(minSize, size.x), max(minSize, size.y))
self.__activeAreaNode = avg.RectNode(size=size, opacity=0, parent=self)
else:
if self.__activeAreaNode == None:
self.__activeAreaNode = self.__upNode
else:
self.appendChild(self.__activeAreaNode)
self.__tapRecognizer = gesture.TapRecognizer(self.__activeAreaNode,
possibleHandler=self.__onDown,
detectedHandler=self.__onTap,
failHandler=self.__onTapFail)
def setClickHandler(self, handler):
self.__clickCallback = utils.methodref(handler)
def setPressHandler(self, handler):
self.__pressCallback = utils.methodref(handler)
def __init__(self, uncheckedUpNode, uncheckedDownNode, checkedUpNode, checkedDownNode,
uncheckedDisabledNode=None, checkedDisabledNode=None, activeAreaNode=None,
enabled=True, fatFingerEnlarge=False, checkHandler=None, uncheckHandler=None,
checked=False, parent=None, **kwargs):
super(ToggleButton, self).__init__(**kwargs)
if parent:
parent.appendChild(self)
self.__uncheckedUpNode = uncheckedUpNode
self.__uncheckedDownNode = uncheckedDownNode
self.__checkedUpNode = checkedUpNode
self.__checkedDownNode = checkedDownNode
self.__uncheckedDisabledNode = uncheckedDisabledNode
self.__checkedDisabledNode = checkedDisabledNode
self.__activeAreaNode = activeAreaNode
self.__checkHandler = utils.methodref(checkHandler)
self.__uncheckHandler = utils.methodref(uncheckHandler)
self.__stateMachine = statemachine.StateMachine("ToggleButton", "UNCHECKED_UP")
self.__stateMachine.addState("UNCHECKED_UP", ("UNCHECKED_DOWN",
"UNCHECKED_DISABLED"), enterFunc=self.__enterUncheckedUp,
leaveFunc=self.__leaveUncheckedUp)
self.__stateMachine.addState("UNCHECKED_DOWN", ("UNCHECKED_UP",
"UNCHECKED_DISABLED", "CHECKED_UP"), enterFunc=self.__enterUncheckedDown,
leaveFunc=self.__leaveUncheckedDown)
self.__stateMachine.addState("CHECKED_UP", ("CHECKED_DOWN", "CHECKED_DISABLED"),
enterFunc=self.__enterCheckedUp, leaveFunc=self.__leaveCheckedUp)
self.__stateMachine.addState("CHECKED_DOWN", ("CHECKED_UP", "UNCHECKED_UP",
"CHECKED_DISABLED"), enterFunc=self.__enterCheckedDown,
leaveFunc=self.__leaveCheckedDown)
self.__stateMachine.addState("UNCHECKED_DISABLED", ("UNCHECKED_UP",),
enterFunc=self.__enterUncheckedDisabled,
leaveFunc=self.__leaveUncheckedDisabled)
self.__stateMachine.addState("CHECKED_DISABLED", ("CHECKED_UP", ),
enterFunc=self.__enterCheckedDisabled,
leaveFunc=self.__leaveCheckedDisabled)
if(checkedDisabledNode == None):
self.__checkedDisabledNode = avg.ImageNode()
if(uncheckedDisabledNode == None):
self.__uncheckedDisabledNode = avg.ImageNode()
self.appendChild(self.__uncheckedUpNode)
self.appendChild(self.__checkedUpNode)
self.appendChild(self.__uncheckedDownNode)
self.appendChild(self.__checkedDownNode)
self.appendChild(self.__uncheckedDisabledNode)
self.appendChild(self.__checkedDisabledNode)
self.__uncheckedUpNode.active = True
self.__checkedUpNode.active = False
self.__uncheckedDownNode.active = False
self.__checkedDownNode.active = False
self.__checkedDisabledNode.active = False
self.__uncheckedDisabledNode.active = False
if fatFingerEnlarge:
if self.__activeAreaNode != None:
raise(RuntimeError(
"ToggleButton: Can't specify both fatFingerEnlarge and activeAreaNode"))
size = upNode.size
minSize = 20*g_Player.getPixelsPerMM()
size = avg.Point2D(max(minSize, size.x), max(minSize, size.y))
self.__activeAreaNode = avg.RectNode(size=size, opacity=0, parent=self)
else:
if self.__activeAreaNode == None:
self.__activeAreaNode = self
else:
self.appendChild(self.__activeAreaNode)
self.__tapRecognizer = gesture.TapRecognizer(self.__activeAreaNode,
possibleHandler=self.__onDown,
detectedHandler=self.__onTap,
failHandler=self.__onTapFail)
if not enabled:
self.__stateMachine.changeState("UNCHECKED_DISABLED")
if checked:
self.setChecked(True)
