class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
for object in screenObjects:
object._draw(g) #Now calls a _draw method on each object, instead of just having a bunch of lambdas in screenObjects.
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped']=string(k)
# print("Key Pressed: " + string(k))
def my_move(self, x, y):
mouse_pos[0]= SP2(x,y)
def initUI(self):
self.addKeyListener(KA(lambda k: self.mykey(k)))
self.xp=0
self.yp=0
self.canvas=Canvas(lambda g:self.mypaint(g), lambda x, y: self.myclick(x, y), lambda x, y: self.my_move(x, y))
self.canvas.setBackground(Color(200, 200, 200))
self.getContentPane().add(self.canvas)
self.setTitle("Test")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setSize(500, 500)
self.setLocationRelativeTo(None)
self.setBackground(Color(255, 255, 255))
self.setVisible(True)
self.timer=Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
currentTime=System.currentTimeMillis()
rSide = random.randrange(0,4)
if ((currentTime-startTime[0]) % 5 == 0):
if (rSide == 0):
(circle(p2(random.randrange(50,450),-30+localTime*100), 10))
elif (rSide == 1):
(circle(p2(500-localTime*100, random.randrange(50,450)), 10))
elif (rSide == 2):
(circle(p2(random.randrange(50,450),500-localTime*100), 10))
else:
(circle(p2(-30+localTime*100,random.randrange(50,450)), 10))
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
class WindowClose(ActionListener):
def __init__(self):
from javax.swing import Timer
self.timer = Timer(5000, self)
self.timer.start()
def actionPerformed(self, e):
self.timer.stop()
mframe.dispose()
class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
for object in screenObjects:
object(g)
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(
x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped'] = string(k)
def initUI(self):
self.addKeyListener(KA(lambda k: k))
self.xp = 0
self.yp = 0
self.canvas = Canvas(lambda g: self.mypaint(g),
lambda x, y: self.myclick(x, y))
self.canvas.setBackground(Color(200, 200, 100))
self.getContentPane().add(self.canvas)
self.setTitle("Ball")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setSize(300, 300)
self.setLocationRelativeTo(None)
self.setBackground(Color(255, 255, 255))
self.setVisible(True)
self.timer = Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
currentTime = System.currentTimeMillis()
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
class LifeGame(object):
def __init__(self, numRows, numCols):
self.numRows = numRows
self.numCols = numCols
self.timer = Timer(250, None, actionPerformed=self._step)
self.gridMutator = GridMutator()
def startGui(self):
frame = JFrame("Life", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
self.gridPanel = JPanel(GridLayout(self.numRows, self.numCols))
self.cellButtons = self._doForAllCells(self._createCellButton)
self.grid = self._doForAllCells(lambda r, c: False)
frame.add(self.gridPanel)
buttonPanel = JPanel(FlowLayout())
stepButton = JButton("Step", actionPerformed=self._step)
runButton = JToggleButton("Run", actionPerformed=self._run)
buttonPanel.add(stepButton)
buttonPanel.add(runButton)
frame.add(buttonPanel, SOUTH)
frame.pack()
frame.locationRelativeTo = None
frame.visible = True
def _step(self, event):
self.grid = self.gridMutator.generateNext(
self._doForAllCells(lambda r, c: self.cellButtons[r][c].selected))
self._doForAllCells(self._selectCellButtonFromGrid)
def _run(self, event):
if self.timer.running:
self.timer.stop()
else:
self.timer.start()
def _createCellButton(self, r, c):
button = JToggleButton()
s = button.preferredSize
button.preferredSize = (s.height, s.height) # Make square
self.gridPanel.add(button)
return button
def _doForAllCells(self, fn):
return [[fn(r, c) for c in range(self.numCols)]
for r in range(self.numRows)]
def _selectCellButtonFromGrid(self, r, c):
self.cellButtons[r][c].selected = self.grid[r][c]
def highlightTab(self):
currentPane = self._splitpane
previousPane = currentPane
while currentPane and not isinstance(currentPane, JTabbedPane):
previousPane = currentPane
currentPane = currentPane.getParent()
if currentPane:
index = currentPane.indexOfComponent(previousPane)
currentPane.setBackgroundAt(index, Color(0xff6633))
class setColorBackActionListener(ActionListener):
def actionPerformed(self, e):
currentPane.setBackgroundAt(index, Color.BLACK)
timer = Timer(5000, setColorBackActionListener())
timer.setRepeats(False)
timer.start()
class _EventTimer(ActionListener):
timers = {}
def __init__(self, eventid):
self.event = pyj2d.event.Event(eventid)
self.timer = Timer(0, self)
def set_timer(self, time):
if self.timer.isRunning():
self.timer.stop()
if time:
self.timer.setInitialDelay(time)
self.timer.setDelay(time)
self.timer.start()
def actionPerformed(self, evt):
pyj2d.event.post(self.event)
class svtMonitor(ActionListener):
def __init__(self, delay):
self.frame = JFrame("SVT Monitor", \
windowClosing = lambda event: sys.exit(0))
self.grid = GridLayout(2, 4)
self.pane = self.frame.contentPane
self.pane.layout = self.grid
self.buttonList = map(lambda x: JButton("b0svt0" + `x`), \
[0,7,6,5,1,2,3,4]) # Left to right,
# top to bottom
for button in self.buttonList:
button.actionCommand = button.text
button.addActionListener(self)
self.pane.add(button)
self.crateMonitorList = []
self.frame.pack()
self.frame.visible = 1
self.timer = Timer(delay, self)
self.timer.start()
def actionPerformed(self, event):
crate = event.getActionCommand()
if crate == None: # it's the timer
self.update()
else: # the user pushed a button
if __debug__:
print "%s pushed" % crate
crateList = map(lambda x, self=self: x.crate,
self.crateMonitorList)
if not crate in crateList: # Do not open the same crate more than once
if __debug__:
print "%s opening" % crate
self.crateMonitorList.append(
crateMonitor(event.getActionCommand(), mainWindow=self))
def delete(self, crate):
crate.close()
self.crateMonitorList.remove(crate)
def update(self):
if __debug__:
print "big update"
for crate in self.crateMonitorList:
crate.update()
class LifeGame(object):
def __init__(self, numRows, numCols):
self.numRows = numRows
self.numCols = numCols
self.timer = Timer(250, None, actionPerformed=self._step)
def startGui(self):
frame = JFrame("Life", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
(R, C) = (self.numRows, self.numCols)
gridPanel = JPanel(GridLayout(R, C))
self.checkBoxes = [[JCheckBox() for c in range(C)] for r in range(R)]
self.grid = [[False for c in range(C)] for r in range(R)]
for r in range(R):
for c in range(C):
gridPanel.add(self.checkBoxes[r][c])
frame.add(gridPanel)
buttonPanel = JPanel(FlowLayout())
stepButton = JButton("Step", actionPerformed=self._step)
runButton = JToggleButton("Run", actionPerformed=self._run)
buttonPanel.add(stepButton)
buttonPanel.add(runButton)
frame.add(buttonPanel, SOUTH)
frame.pack()
frame.locationRelativeTo = None
frame.visible = True
def _getGridFromCheckBoxes(self):
return [[self.checkBoxes[r][c].selected for c in range(self.numCols)]
for r in range(self.numRows)]
def _step(self, event):
self.grid = GridMutator().generateNext(self._getGridFromCheckBoxes())
self._selectCheckBoxesFromGrid()
def _run(self, event):
if self.timer.running:
self.timer.stop()
else:
self.timer.start()
def _selectCheckBoxesFromGrid(self):
for r in range(self.numRows):
for c in range(self.numCols):
self.checkBoxes[r][c].selected = self.grid[r][c]
class CommandClient():
def __init__(self, extender):
self._syncTimer = Timer(1000, None)
self._syncTimer.setRepeats(True)
self._syncTimer.actionPerformed = self._sendCommandSync
self._syncTimer.stop()
self.commandListenPort = 8089;
self._startTimer = Timer(1000, None)
self._startTimer.setInitialDelay(1500)
self._startTimer.setRepeats(False)
self._startTimer.actionPerformed = self._sendCommandStart
self._startTimer.stop()
self._extender = extender
def startCrawling(self):
self._startTimer.start()
def startSync(self):
self._syncTimer.start()
def stopCrawling(self):
self._sendCommandStop(None)
self._syncTimer.stop()
def _sendCommandStart(self, ev):
self._sendCommand("start")
self.startSync()
def _sendCommandStop(self, ev):
self._sendCommand("stop")
def _sendCommandSync(self, ev):
result = self._sendCommand("sync")
self._extender.syncCrawlingState(result)
def _sendCommand(self, command):
url = 'http://127.0.0.1:' + str(self.commandListenPort) + '/?command={0}'.format(command)
# TODO: iterate through parameters
response = urllib2.urlopen(url)
data = json.load(response)
return data
class LifeGame(object):
def __init__(self, numRows, numCols):
self.numRows = numRows
self.numCols = numCols
self.timer = Timer(250, None, actionPerformed=self._step)
def startGui(self):
frame = JFrame("Life", defaultCloseOperation=JFrame.EXIT_ON_CLOSE)
(R, C) = (self.numRows, self.numCols)
gridPanel = JPanel(GridLayout(R, C))
self.checkBoxes = [[JCheckBox() for c in range(C)] for r in range(R)]
self.grid = [[False for c in range(C)] for r in range(R)]
for r in range(R):
for c in range(C):
gridPanel.add(self.checkBoxes[r][c])
frame.add(gridPanel)
buttonPanel = JPanel(FlowLayout())
stepButton = JButton("Step", actionPerformed=self._step)
runButton = JToggleButton("Run", actionPerformed=self._run)
buttonPanel.add(stepButton)
buttonPanel.add(runButton)
frame.add(buttonPanel, SOUTH)
frame.pack()
frame.locationRelativeTo = None
frame.visible = True
def _getGridFromCheckBoxes(self):
return [[self.checkBoxes[r][c].selected for c in range(self.numCols)]
for r in range(self.numRows)]
def _step(self, event):
self.grid = GridMutator().generateNext(self._getGridFromCheckBoxes())
self._selectCheckBoxesFromGrid()
def _run(self, event):
if self.timer.running:
self.timer.stop()
else:
self.timer.start()
def _selectCheckBoxesFromGrid(self):
for r in range(self.numRows):
for c in range(self.numCols):
self.checkBoxes[r][c].selected = self.grid[r][c]
class _EventTimer(ActionListener):
def __init__(self, event):
self.event = event
self.timer = Timer(0, self)
self.repeat = True
def set_timer(self, time, repeat):
if self.timer.isRunning():
self.timer.stop()
if time:
self.repeat = repeat
self.timer.setInitialDelay(time)
self.timer.setDelay(time)
self.timer.start()
def actionPerformed(self, evt):
env.event.post(self.event)
if not self.repeat:
self.timer.stop()
class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
for object in screenObjects:
object(g)
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped'] = string(k)
def initUI(self):
self.addKeyListener(KA(lambda k: k))
self.xp = 0
self.yp = 0
self.canvas = Canvas(lambda g:self.mypaint(g), lambda x, y: self.myclick(x, y))
self.canvas.setBackground(Color(200, 200, 100))
self.getContentPane().add(self.canvas)
self.setTitle("Ball")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setSize(300, 300)
self.setLocationRelativeTo(None)
self.setBackground(Color(255, 255, 255))
self.setVisible(True)
self.timer = Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
currentTime = System.currentTimeMillis()
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
class ProfelisPanel(JPanel):
def __init__(self, frame, name):
self.frame = frame
self.exception = None
self.name = name
self.searchTerm = None
self.searchIndex = -1
self.searchField = JTextField("")
self.searchField.addActionListener(SearchListener(self))
self.newGeneFrom = JTextField("")
self.newGeneTo = JTextField("")
self.newGeneButton = JButton("New Gene")
newGeneActionListener = NewGeneActionListener(self)
self.newGeneFrom.addActionListener(newGeneActionListener)
self.newGeneTo.addActionListener(newGeneActionListener)
self.newGeneButton.addActionListener(newGeneActionListener)
self.markForRemovalButton = JButton("Mark For Removal")
self.markForRemovalButton.addActionListener(MarkForRemovalListener(self))
self.inGenes = JList(DefaultListModel())
self.inGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
self.inGenes.cellRenderer = ProfelisCellRenderer()
self.markButtonLabelerTimer = Timer(100, MarkButtonLabeler(self))
self.markButtonLabelerTimer.start()
self.loadFile()
self.outGenes = JList(DefaultListModel())
self.outGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
self.outGenes.cellRenderer = ProfelisCellRenderer()
constraints = GridBagConstraints()
self.layout = GridBagLayout()
constraints.gridx, constraints.gridy = 0, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.fill = GridBagConstraints.NONE
constraints.weightx, constraints.weighty = 0, 0
self.add(JLabel("Genes In Artemis File"), constraints)
constraints.gridx, constraints.gridy = 0, 1
self.add(JButton(RemoveAction(self)), constraints)
constraints.gridx, constraints.gridy = 1, 1
self.add(self.markForRemovalButton, constraints)
constraints.gridx, constraints.gridy = 2, 1
self.add(JLabel("Search"), constraints)
constraints.gridx, constraints.gridy = 3, 1
constraints.fill = GridBagConstraints.HORIZONTAL
self.add(self.searchField, constraints)
constraints.gridx, constraints.gridy = 0, 2
constraints.gridwidth, constraints.gridheight = 4, 2
constraints.fill = GridBagConstraints.BOTH
constraints.weightx, constraints.weighty = 1, 1
self.add(JScrollPane(self.inGenes), constraints)
constraints.gridx, constraints.gridy = 4, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.fill = GridBagConstraints.NONE
constraints.weightx, constraints.weighty = 0, 0
self.add(JLabel("Genes To Add To Artemis File"), constraints)
constraints.gridx, constraints.gridy = 4, 1
self.add(self.newGeneButton, constraints)
constraints.weightx = 1
constraints.fill = GridBagConstraints.BOTH
constraints.gridx, constraints.gridy = 5, 1
self.add(self.newGeneFrom, constraints)
constraints.weightx = 0
constraints.fill = GridBagConstraints.NONE
constraints.gridx, constraints.gridy = 6, 1
self.add(JLabel("To"), constraints)
constraints.weightx = 1
constraints.fill = GridBagConstraints.BOTH
constraints.gridx, constraints.gridy = 7, 1
self.add(self.newGeneTo, constraints)
constraints.weightx = 0
constraints.fill = GridBagConstraints.NONE
constraints.gridx, constraints.gridy = 4, 2
self.add(JButton(AddGenesAction(self)), constraints)
constraints.gridx, constraints.gridy = 4, 3
constraints.gridwidth, constraints.gridheight = 4, 1
constraints.fill = GridBagConstraints.BOTH
constraints.weightx, constraints.weighty = 1, 1
self.add(JScrollPane(self.outGenes), constraints)
def loadFile(self):
self.inGenes.model.clear()
self.database, self.evalue, genes = utils.parseBlast(self.name + ".blastp.xml")
[self.inGenes.model.addElement(gene) for gene in genes]
artemisInput = open(self.name + ".art", "r")
lines = artemisInput.readlines()
artemisInput.close()
self.restOfFile = self.genome = []
while lines:
if re.match("\s+CDS\s+(complement\()?\d+\.\.\d+\)?\n", lines[0]):
lines = lines[4:]
elif lines[0].find("ORIGIN") == 0:
self.genome = map(lambda x: re.sub("\s+", "", x), lines[1:])
lines = []
else:
if lines[0].strip():
self.restOfFile.append(lines[0])
lines = lines[1:]
self.genome = "".join(self.genome)
self.restOfFile = "".join(self.restOfFile)
def writeArtemisFile(self):
output = open(self.name + ".art", "w")
output.write(self.restOfFile)
for element in self.inGenes.model.elements():
output.write(element.toArtemis())
output.write("\nORIGIN\n\n")
for i in range(0, len(self.genome), 50):
output.write(self.genome[i:min(i+50, len(self.genome))] + "\n")
output.close()
class TrackDevice(java.beans.PropertyChangeListener):
import java
import javax.swing
import javax.swing.Timer
delayTimer = None
relayClicks = None
# TrackDevice.init - Initialize a TrackDevice instance for a particular device
#
# aName : Device name
# aDevice : JMRI device instance
# aAllowedStates : Array of states we want to track, other states are ignored
#
def init(self, aName, aDevice, aAllowedStates, aLogFile, aParent):
from javax.swing import Timer
#print ('TrackDevice.init ' + aName )
self.DeviceName = aName
self.Device = aDevice
self.DeviceValue = self.Device.getValue()
self.AllowedStates = aAllowedStates
self.parent = aParent
self.LogFile = aLogFile
self.timeoutListener = self.TimeoutReceiver()
self.timeoutListener.setCallBack(self.receiveTimeoutHandler)
self.receiveTimer = Timer(1, self.timeoutListener)
self.receiveTimer.stop()
self.receiveTimer.setRepeats(False)
self.sendTimeoutListener = self.TimeoutReceiver()
self.sendTimeoutListener.setCallBack(self.sendTimeoutHandler)
self.sendTimer = Timer(1, self.sendTimeoutListener)
self.sendTimer.stop()
self.sendTimer.setRepeats(False)
self.pauseTimeoutListener = self.TimeoutReceiver()
self.pauseTimeoutListener.setCallBack(self.pauseTimeoutHandler)
self.pauseTimer = Timer(1, self.pauseTimeoutListener)
self.pauseTimer.stop()
self.pauseTimer.setRepeats(False)
self.relayClicks = jmri.jmrit.Sound(
"resources/sounds/Code-receive.wav")
#self.relayClicks = jmri.jmrit.Sound(jmri.util.FileUtil.getExternalFilename("preference:resources/sounds/EnhancedCTCRelay.wav"))
self.relaySend = jmri.jmrit.Sound("resources/sounds/Code-send.wav")
return
# TrackDevice.updateState - Track the device state while reading the old log
# file. Note the state but don't change the device
# itself and don't log the changes to the new log file
# (yet).
#
# aNewState : New device state.
#
def updateState(self, aNewState):
#print 'updateState ' + self.DeviceName
for i in range(len(self.AllowedStates)):
if (aNewState == self.AllowedStates[i]):
self.DeviceValue = aNewState
break
# TrackDevice.propertyChange - Record state changes as a result of activities
# elsewhere in JMRI
#
# aEvent : Event triggering the change (we don't actually look at the event...)
#
def propertyChange(self, aEvent):
#print "Property change " + self.DeviceName
newValue = self.Device.getValue()
codeSendSensor = sensors.getSensor("IS16:CCK")
codeSendSensor.setState(ACTIVE)
self.relaySend.loop()
ccdl = 5 + java.util.Random().nextInt(1) # Code transmission delay
self.sendTimer.setInitialDelay(ccdl * 10)
self.sendTimer.start()
if (newValue == self.DeviceValue):
return
for i in range(len(self.AllowedStates)):
if (newValue == self.AllowedStates[i]):
self.DeviceValue = newValue
#logStateChange2(self.DeviceName, self.DeviceValue, True)
#print "state change " + self.DeviceName + " " + str(self.DeviceValue)
self.LogFile.write(self.DeviceName + " " +
self.DeviceValue + "\n")
self.LogFile.flush()
break
return
# TrackDevice.setInitialDeviceState - After reading all of the old tracking file we
# now initialize the actual devices to their last
# known states and log these states into the new
# log file.
#
def setInitialDeviceState(self, logFile):
# Uncomment the following print statement to display the list of devices being tracked.
#print "In setInitDeviceState, name = " + self.DeviceName + " value = " + self.DeviceValue
self.LogFile = logFile
self.Device.setValue(self.DeviceValue)
self.Device.addPropertyChangeListener(self)
#logStateChange2(self.DeviceName, self.DeviceState, False)
logFile.write(self.DeviceName + " " + self.DeviceValue + "\n")
signalId = "IS" + self.DeviceName[2:3]
ctcId = "CTC:TO" + self.DeviceName[2:3]
# Move the switch lever to the correct position
if (self.DeviceValue == "P"):
#print " ctcId = " + ctcId + " state = green"
turnouts.provideTurnout("NT" +
self.DeviceName[2:3]).setState(CLOSED)
sensors.getSensor(signalId + ":WLL").setState(INACTIVE)
sensors.getSensor(signalId + ":WLR").setState(INACTIVE)
sensors.getSensor(signalId + ":WLC").setState(ACTIVE)
sensors.getSensor(signalId + ":WKR").setState(INACTIVE)
sensors.getSensor(signalId + ":WKL").setState(INACTIVE)
sensors.getSensor(signalId + ":WKC").setState(ACTIVE)
sensors.getSensor(ctcId + "GK").setState(ACTIVE)
sensors.getSensor(ctcId + "YK").setState(INACTIVE)
sensors.getSensor(ctcId + "RK").setState(INACTIVE)
sensors.getSensor(ctcId + "GS").setState(ACTIVE)
sensors.getSensor(ctcId + "YS").setState(INACTIVE)
sensors.getSensor(ctcId + "RS").setState(INACTIVE)
sensors.getSensor(signalId + ":TOC").setState(INACTIVE)
sensors.getSensor(signalId + ":TOS").setState(INACTIVE)
sensors.getSensor(signalId + ":TOP").setState(ACTIVE)
elif (self.DeviceValue == "C"):
#print " ctcId = " + ctcId + " state = yellow"
sensors.getSensor(signalId + ":WLL").setState(ACTIVE)
sensors.getSensor(signalId + ":WLR").setState(INACTIVE)
sensors.getSensor(signalId + ":WLC").setState(INACTIVE)
sensors.getSensor(signalId + ":WKR").setState(INACTIVE)
sensors.getSensor(signalId + ":WKL").setState(ACTIVE)
sensors.getSensor(signalId + ":WKC").setState(INACTIVE)
sensors.getSensor(ctcId + "GK").setState(INACTIVE)
sensors.getSensor(ctcId + "YK").setState(ACTIVE)
sensors.getSensor(ctcId + "RK").setState(INACTIVE)
sensors.getSensor(ctcId + "GS").setState(INACTIVE)
sensors.getSensor(ctcId + "YS").setState(ACTIVE)
sensors.getSensor(ctcId + "RS").setState(INACTIVE)
sensors.getSensor(signalId + ":TOC").setState(ACTIVE)
sensors.getSensor(signalId + ":TOS").setState(INACTIVE)
sensors.getSensor(signalId + ":TOP").setState(INACTIVE)
else:
#print " ctcId = " + ctcId + " state = red"
turnouts.provideTurnout("NT" +
self.DeviceName[2:3]).setState(THROWN)
sensors.getSensor(signalId + ":WLL").setState(INACTIVE)
sensors.getSensor(signalId + ":WLR").setState(ACTIVE)
sensors.getSensor(signalId + ":WLC").setState(INACTIVE)
sensors.getSensor(signalId + ":WKR").setState(ACTIVE)
sensors.getSensor(signalId + ":WKL").setState(INACTIVE)
sensors.getSensor(signalId + ":WKC").setState(INACTIVE)
sensors.getSensor(ctcId + "GK").setState(INACTIVE)
sensors.getSensor(ctcId + "YK").setState(INACTIVE)
sensors.getSensor(ctcId + "RK").setState(ACTIVE)
sensors.getSensor(ctcId + "GS").setState(INACTIVE)
sensors.getSensor(ctcId + "YS").setState(INACTIVE)
sensors.getSensor(ctcId + "RS").setState(ACTIVE)
sensors.getSensor(signalId + ":TOC").setState(INACTIVE)
sensors.getSensor(signalId + ":TOS").setState(ACTIVE)
sensors.getSensor(signalId + ":TOP").setState(INACTIVE)
class TimeoutReceiver(java.awt.event.ActionListener):
cb = None
def actionPerformed(self, event):
if (self.cb != None):
self.cb(event)
return
def setCallBack(self, cbf):
self.cb = cbf
return
class TimeoutReceiver2(java.awt.event.ActionListener):
cb = None
def actionPerformed(self, event):
if (self.cb != None):
self.cb(event)
return
def setCallBack(self, cbf):
self.cb = cbf
return
class TimeoutReceiver3(java.awt.event.ActionListener):
cb = None
def actionPerformed(self, event):
if (self.cb != None):
self.cb(event)
return
def setCallBack(self, cbf):
self.cb = cbf
return
def sendTimeoutHandler(self, event):
#print "In send timeout handler"
self.sendTimer.stop()
self.relaySend.stop()
sensors.getSensor("IS16:CCK").setState(INACTIVE)
#sleep(2)
signalNumber = self.DeviceName[2:3]
if (self.Device.getValue() == "P"):
turnouts.provideTurnout("NT" + signalNumber).setState(CLOSED)
elif (self.Device.getValue() == "S"):
turnouts.provideTurnout("NT" + signalNumber).setState(THROWN)
smdl = 5 + java.util.Random().nextInt(2) # Switch motor delay -
self.pauseTimer.setInitialDelay(smdl * 10)
self.pauseTimer.start()
return
def pauseTimeoutHandler(self, event):
#print "In pause timeout handler"
self.pauseTimer.stop()
sensors.getSensor("IS17:ICK").setState(ACTIVE)
#print "Turning on IC light"
self.relayClicks.loop()
newName = "IS" + self.DeviceName[2:3]
sensors.getSensor(newName + ":WKC").setState(INACTIVE)
sensors.getSensor(newName + ":WKL").setState(INACTIVE)
sensors.getSensor(newName + ":WKR").setState(INACTIVE)
ctcName = "CTC:TO" + self.DeviceName[2:3]
if (sensors.getSensor(ctcName + "YK").getState() == ACTIVE):
sensors.getSensor(ctcName + "YK").setState(INACTIVE)
if (sensors.getSensor(ctcName + "GK").getState() == ACTIVE):
sensors.getSensor(ctcName + "GK").setState(INACTIVE)
if (sensors.getSensor(ctcName + "RK").getState() == ACTIVE):
sensors.getSensor(ctcName + "RK").setState(INACTIVE)
icdl = 5 + java.util.Random().nextInt(3) # Indicator code delay
self.receiveTimer.setInitialDelay(icdl * 10)
self.receiveTimer.start()
return
def receiveTimeoutHandler(self, event):
# see which phase we think we are in
#print "In receive timeout Handler"
self.receiveTimer.stop()
signalNumber = self.DeviceName[2:3]
#print " Signal number = " + str(signalNumber) + " signal state = " + self.Device.getValue()
if (self.Device.getValue() == "P"):
sensors.getSensor("IS" + signalNumber +
":WKC").setState(ACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKR").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKL").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOC").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOS").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOP").setState(ACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "YK").setState(INACTIVE)
sensors.getSensor("CTC:TO" + signalNumber +
"GK").setState(ACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "RK").setState(INACTIVE)
elif (self.Device.getValue() == "C"):
sensors.getSensor("IS" + signalNumber +
":WKC").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKR").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKL").setState(ACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOS").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOP").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOC").setState(ACTIVE)
sensors.getSensor("CTC:TO" + signalNumber +
"YK").setState(ACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "GK").setState(INACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "RK").setState(INACTIVE)
jmri.jmrit.Sound("resources/sounds/Bell.wav").play()
elif (self.Device.getValue() == "S"):
sensors.getSensor("IS" + signalNumber +
":WKC").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKR").setState(ACTIVE)
sensors.getSensor("IS" + signalNumber +
":WKL").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOC").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOP").setState(INACTIVE)
sensors.getSensor("IS" + signalNumber +
":TOS").setState(ACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "YK").setState(INACTIVE)
#sensors.getSensor("CTC:TO" + signalNumber + "GK").setState(INACTIVE)
sensors.getSensor("CTC:TO" + signalNumber +
"RK").setState(ACTIVE)
self.relayClicks.stop()
self.parent.waitMsec(1000)
sensors.getSensor("IS17:ICK").setState(INACTIVE)
return
class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
layerArray = [[] for i in range (100)] #Creating a 100-item array for us to work with.
for object in screenObjects:
layerIndex = int(min(object._zLayer, 99)) #This specifies the layer that the object will be headed for...
layerLoc = 0
myDepth = object._get("zDepth")
for compObject in layerArray[layerIndex]: #but first, we need to find the right place in that layer to put our object.
if (myDepth > compObject._get("zDepth")):
layerLoc = layerLoc + 1
else:
break
layerArray[layerIndex].insert(layerLoc ,object)
newArray = [] #We now want to compress our scattered 2d-array into a 1d-array.
for subArray in layerArray: #It's called Radix sorting.
newArray.extend(subArray)
#screenObjects = newArray #Turns out you can't actually do this, and I have no idea why.
for object in newArray: #Instead of going through screenObjects, we go through newArray, which is sorted by layer.
object._draw(g) #Now calls a _draw method on each object, instead of just having a bunch of lambdas in screenObjects.
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped']=string(k)
# print("Key Pressed: " + string(k))
def my_move(self, x, y):
mouse_pos[0]= SP2(x,y)
def initUI(self):
self.addKeyListener(KA(lambda k: self.mykey(k)))
self.xp=0
self.yp=0
self.canvas=Canvas(lambda g:self.mypaint(g), lambda x, y: self.myclick(x, y), lambda x, y: self.my_move(x, y))
self.canvas.setBackground(JavaColor(200, 200, 100))
self.getContentPane().add(self.canvas)
self.setTitle("Test")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.xSize = 500
self.ySize = 500
self.setSize(self.xSize, self.ySize)
self.setLocationRelativeTo(None)
self.setBackground(JavaColor(255, 255, 255))
self.setVisible(True)
#self.button = JButton("This is a button")
#self.add(self.button, BorderLayout.SOUTH)
#self.button.addActionListener(self)
self.timer=Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
#if(e.getSource() == self.button):
#self.addSlider()
#else:
currentTime=System.currentTimeMillis()
#if ((currentTime-startTime[0]) % 75 == 0):
# balls.append(circle(p2(random.randrange(50,250),270-localTime*100), 10))
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
def addSlider(self): #adds a new slider at the bottom of the window.
slider = JSlider()
self.add(slider, BorderLayout.SOUTH) #this is the best way I could find to make sure the slider appears somewhere consistent.
self.ySize = self.ySize + 20 #the problem, sadly, is that all of the sliders and buttons and stuff appear at the SAME PLACE, overlapping.
self.setSize(self.xSize, self.ySize)
class WiimoteThrottle2(Jynstrument, PropertyChangeListener, AddressListener,
WiiDeviceDiscoveryListener, WiiRemoteListener,
Runnable):
#Jynstrument main and mandatory methods
def getExpectedContextClassName(self):
return "jmri.jmrit.throttle.ThrottleWindow"
def init(self):
self.getContext().addPropertyChangeListener(
self) #ThrottleFrame change
self.addressPanel = self.getContext().getCurrentThrottleFrame(
).getAddressPanel()
self.addressPanel.addAddressListener(
self) # change of throttle in Current frame
self.throttle = self.getContext().getCurrentThrottleFrame(
).getAddressPanel().getThrottle() # the throttle
self.speedAction = SpeedAction() #Speed increase thread
self.speedAction.setThrottle(self.throttle)
self.speedTimer = Timer(
valueSpeedTimerRepeat, self.speedAction
) # Very important to use swing Timer object (see Swing and multithreading doc)
self.speedTimer.setRepeats(True)
self.label = JButton(
ImageIcon(self.getFolder() + "/WiimoteThrottle2.png",
"WiiMote")) #label
self.label.addMouseListener(
self.getMouseListeners()
[0]) # In order to get the popupmenu on the button too
self.add(self.label)
self.lastTimeButton1 = Calendar.getInstance().getTimeInMillis()
self.lastTimeButton2 = Calendar.getInstance().getTimeInMillis()
self.advFunctions = AdvFunctions()
self.lastTimeEStop = Calendar.getInstance().getTimeInMillis()
self.wiiDevice = None
self.sync = thread.allocate_lock() # A lock protecting bellow self.evt
self.evt = None
java.lang.System.setProperty("bluecove.jsr82.psm_minimum_off", "true")
# Required for Bluecove + WiiRemoteJ
WiiRemoteJ.findRemotes(self, 1) # Search for 1 Wiimote, and call back
def quit(self):
self.speedTimer.stop()
WiiRemoteJ.stopFind()
if ((self.wiiDevice != None) and (self.wiiDevice.isConnected())):
self.wiiDevice.removeWiiRemoteListener(self)
self.wiiDevice.disconnect()
self.wiiDevice = None
self.speedAction = None
self.speedTimer = None
self.throttle = None
self.advFunctions = None
self.getContext().removePropertyChangeListener(self)
self.addressPanel.removeAddressListener(self)
self.addressPanel = None
#Wiimote discoverer events
def findFinished(self, nb):
print "Search finished, found ", nb, " wiimotes"
def wiiDeviceDiscovered(self, evt):
print "Found a Wiimote, number: ", evt.getNumber()
self.wiiDevice = evt.getWiiDevice()
ledLights = [False, False, False, False]
ledLights[evt.getNumber() % 4] = True
self.wiiDevice.setLEDLights(ledLights)
self.wiiDevice.addWiiRemoteListener(self)
#Wiimote events
def buttonInputReceived(self, evt):
# print("Wiimote Button event: ", evt)
self.sync.acquire()
self.evt = evt
self.sync.release()
SwingUtilities.invokeLater(
self
) # Delegate processing to Swing thread (when we are here, we're in the WiiRemoteJ driver thread)
def run(self):
self.sync.acquire()
evt = self.evt
self.sync.release()
if (self.speedTimer != None):
self.speedTimer.stop() # In any case
# ThrottleFrames
if (evt.wasReleased(WRButtonEvent.RIGHT)): # NEXT
self.getContext().nextThrottleFrame()
if (evt.wasReleased(WRButtonEvent.LEFT)): # PREVIOUS
self.getContext().previousThrottleFrame()
if (evt.wasReleased(WRButtonEvent.UP)): # NEXT RUNNING
self.getContext().nextRunningThrottleFrame()
if (evt.wasReleased(WRButtonEvent.DOWN)): # PREVIOUS RUNNING
self.getContext().previousRunningThrottleFrame()
# No throttle assigned to current frame, browse through roster
if (self.throttle == None):
if (evt.wasReleased(
WRButtonEvent.HOME)): # Assign selected roster entry
self.addressPanel.selectRosterEntry()
return
if (evt.wasReleased(WRButtonEvent.PLUS)): # Next roster entry
selectedIndex = self.addressPanel.getRosterSelectedIndex()
self.addressPanel.setIcon(False)
self.addressPanel.setVisible(True)
self.addressPanel.setRosterSelectedIndex(selectedIndex + 1)
return
if (evt.wasReleased(WRButtonEvent.MINUS)): # Previous roster entry
selectedIndex = self.addressPanel.getRosterSelectedIndex()
self.addressPanel.setIcon(False)
self.addressPanel.setVisible(True)
self.addressPanel.setRosterSelectedIndex(selectedIndex - 1)
return
# Throttle assigned to current frame, control it
if (self.throttle != None):
# Speed control
if (evt.isPressed(WRButtonEvent.B)): # SPEED - increment
self.speedAction.setSpeedIncrement(valueSpeedIncrement)
self.speedTimer.start()
if (evt.isPressed(WRButtonEvent.A)): # SPEED - decrement
self.speedAction.setSpeedIncrement(-valueSpeedIncrement)
self.speedTimer.start()
# EStop
if (evt.isPressed(WRButtonEvent.PLUS
| WRButtonEvent.MINUS)): # estop = + & -
self.throttle.setSpeedSetting(speedEStopSpeed)
self.lastTimeEStop = Calendar.getInstance().getTimeInMillis(
) # To cancel next inputs
self.wiiDevice.vibrateFor(750)
# Directions
if (evt.wasReleased(WRButtonEvent.PLUS)): # FORWARD
self.throttle.setIsForward(True)
if (evt.wasReleased(WRButtonEvent.MINUS)): # BACKWARD
self.throttle.setIsForward(False)
# Home : F0
if (evt.wasReleased(WRButtonEvent.HOME)): # LIGHTS
if not ((self.addressPanel.getRosterEntry() != None) and
(self.advFunctions.call(
self.addressPanel.getRosterEntry(), "0", False,
self.throttle) != None)):
self.throttle.setF0(not self.throttle.getF0())
# Wiimote 1 & 2 buttons
if (evt.isPressed(WRButtonEvent.ONE)):
if not ((self.addressPanel.getRosterEntry() != None) and
(self.advFunctions.call(
self.addressPanel.getRosterEntry(), "1", True,
self.throttle) != None)):
pass # default F1 not momentary (switch only on Release, do nothing here)
if (evt.wasReleased(WRButtonEvent.ONE)):
if not ((self.addressPanel.getRosterEntry() != None) and
(self.advFunctions.call(
self.addressPanel.getRosterEntry(), "1", False,
self.throttle) != None)):
self.throttle.setF1(
not self.throttle.getF1()) # default F1 not momentary
if (evt.isPressed(WRButtonEvent.TWO)):
if not ((self.addressPanel.getRosterEntry() != None) and
(self.advFunctions.call(
self.addressPanel.getRosterEntry(), "2", True,
self.throttle) != None)):
self.throttle.setF2(True) # default F2 momentary
if (evt.wasReleased(WRButtonEvent.TWO)):
if not ((self.addressPanel.getRosterEntry() != None) and
(self.advFunctions.call(
self.addressPanel.getRosterEntry(), "2", False,
self.throttle) != None)):
self.throttle.setF2(False)
def disconnected(self):
self.wiiDevice = None
print("Lost wiimote")
def accelerationInputReceived(self, evt):
pass
def combinedInputReceived(self, evt):
pass
def extensionConnected(self, extension):
pass
def extensionDisconnected(self, extension):
pass
def extensionInputReceived(self, evt):
pass
def extensionPartiallyInserted(self):
pass
def extensionUnknown(self):
pass
def IRInputReceived(self, evt):
pass
def statusReported(self, evt):
print("Wiimote status reported: ", evt)
#Property listener part
def propertyChange(self, event):
self.speedTimer.stop()
if (event.propertyName == "ThrottleFrame"
): # Current throttle frame changed
event.oldValue.getAddressPanel().removeAddressListener(self)
self.addressPanel = event.newValue.getAddressPanel()
self.throttle = self.addressPanel.getThrottle()
self.speedAction.setThrottle(self.throttle)
self.addressPanel.addAddressListener(self)
#AddressListener part: to listen for address changes in address panel (release, acquired)
def notifyAddressChosen(self, address):
pass
def notifyAddressThrottleFound(self, throttle):
self.speedTimer.stop()
self.throttle = throttle
self.speedAction.setThrottle(self.throttle)
def notifyAddressReleased(self, address):
self.speedTimer.stop()
self.throttle = None
self.speedAction.setThrottle(self.throttle)
def notifyConsistAddressChosen(self, address, isLong):
self.notifyAddressChosen(address)
def notifyConsistAddressThrottleFound(self, throttle):
self.notifyAddressThrottleFound(throttle)
def notifyConsistAddressReleased(self, address, isLong):
self.notifyAddressReleased(address)
class ProfelisPanel(JPanel):
def __init__(self, frame, name):
self.frame = frame
self.exception = None
self.name = name
self.searchTerm = None
self.searchIndex = -1
self.searchField = JTextField("")
self.searchField.addActionListener(SearchListener(self))
self.newGeneFrom = JTextField("")
self.newGeneTo = JTextField("")
self.newGeneButton = JButton("New Gene")
newGeneActionListener = NewGeneActionListener(self)
self.newGeneFrom.addActionListener(newGeneActionListener)
self.newGeneTo.addActionListener(newGeneActionListener)
self.newGeneButton.addActionListener(newGeneActionListener)
self.markForRemovalButton = JButton("Mark For Removal")
self.markForRemovalButton.addActionListener(
MarkForRemovalListener(self))
self.inGenes = JList(DefaultListModel())
self.inGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
self.inGenes.cellRenderer = ProfelisCellRenderer()
self.markButtonLabelerTimer = Timer(100, MarkButtonLabeler(self))
self.markButtonLabelerTimer.start()
self.loadFile()
self.outGenes = JList(DefaultListModel())
self.outGenes.selectionMode = ListSelectionModel.SINGLE_SELECTION
self.outGenes.cellRenderer = ProfelisCellRenderer()
constraints = GridBagConstraints()
self.layout = GridBagLayout()
constraints.gridx, constraints.gridy = 0, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.fill = GridBagConstraints.NONE
constraints.weightx, constraints.weighty = 0, 0
self.add(JLabel("Genes In Artemis File"), constraints)
constraints.gridx, constraints.gridy = 0, 1
self.add(JButton(RemoveAction(self)), constraints)
constraints.gridx, constraints.gridy = 1, 1
self.add(self.markForRemovalButton, constraints)
constraints.gridx, constraints.gridy = 2, 1
self.add(JLabel("Search"), constraints)
constraints.gridx, constraints.gridy = 3, 1
constraints.fill = GridBagConstraints.HORIZONTAL
self.add(self.searchField, constraints)
constraints.gridx, constraints.gridy = 0, 2
constraints.gridwidth, constraints.gridheight = 4, 2
constraints.fill = GridBagConstraints.BOTH
constraints.weightx, constraints.weighty = 1, 1
self.add(JScrollPane(self.inGenes), constraints)
constraints.gridx, constraints.gridy = 4, 0
constraints.gridwidth, constraints.gridheight = 1, 1
constraints.fill = GridBagConstraints.NONE
constraints.weightx, constraints.weighty = 0, 0
self.add(JLabel("Genes To Add To Artemis File"), constraints)
constraints.gridx, constraints.gridy = 4, 1
self.add(self.newGeneButton, constraints)
constraints.weightx = 1
constraints.fill = GridBagConstraints.BOTH
constraints.gridx, constraints.gridy = 5, 1
self.add(self.newGeneFrom, constraints)
constraints.weightx = 0
constraints.fill = GridBagConstraints.NONE
constraints.gridx, constraints.gridy = 6, 1
self.add(JLabel("To"), constraints)
constraints.weightx = 1
constraints.fill = GridBagConstraints.BOTH
constraints.gridx, constraints.gridy = 7, 1
self.add(self.newGeneTo, constraints)
constraints.weightx = 0
constraints.fill = GridBagConstraints.NONE
constraints.gridx, constraints.gridy = 4, 2
self.add(JButton(AddGenesAction(self)), constraints)
constraints.gridx, constraints.gridy = 4, 3
constraints.gridwidth, constraints.gridheight = 4, 1
constraints.fill = GridBagConstraints.BOTH
constraints.weightx, constraints.weighty = 1, 1
self.add(JScrollPane(self.outGenes), constraints)
def loadFile(self):
self.inGenes.model.clear()
self.database, self.evalue, genes = utils.parseBlast(self.name +
".blastp.xml")
[self.inGenes.model.addElement(gene) for gene in genes]
artemisInput = open(self.name + ".art", "r")
lines = artemisInput.readlines()
artemisInput.close()
self.restOfFile = self.genome = []
while lines:
if re.match("\s+CDS\s+(complement\()?\d+\.\.\d+\)?\n", lines[0]):
lines = lines[4:]
elif lines[0].find("ORIGIN") == 0:
self.genome = map(lambda x: re.sub("\s+", "", x), lines[1:])
lines = []
else:
if lines[0].strip():
self.restOfFile.append(lines[0])
lines = lines[1:]
self.genome = "".join(self.genome)
self.restOfFile = "".join(self.restOfFile)
def writeArtemisFile(self):
output = open(self.name + ".art", "w")
output.write(self.restOfFile)
for element in self.inGenes.model.elements():
output.write(element.toArtemis())
output.write("\nORIGIN\n\n")
for i in range(0, len(self.genome), 50):
output.write(self.genome[i:min(i + 50, len(self.genome))] + "\n")
output.close()
class Board(JPanel, KeyListener, ActionListener):
def __init__(self):
super(Board, self).__init__()
self.initUI()
def initUI(self):
self.setBackground(Color.black)
iid = ImageIcon("dot.png")
self.ball = iid.getImage()
iia = ImageIcon("apple.png")
self.apple = iia.getImage()
iih = ImageIcon("head.png")
self.head = iih.getImage()
self.setFocusable(True)
self.addKeyListener(self)
self.initGame()
def initGame(self):
self.left = False
self.right = True
self.up = False
self.down = False
self.inGame = True
self.dots = 3
for i in range(self.dots):
x[i] = 50 - i * 10
y[i] = 50
self.locateApple()
self.timer = Timer(DELAY, self)
self.timer.start()
def paint(self, g):
# due to bug, cannot call super()
JPanel.paint(self, g)
if self.inGame:
self.drawObjects(g)
else:
self.gameOver(g)
def drawObjects(self, g):
g.drawImage(self.apple, self.apple_x, self.apple_y, self)
for z in range(self.dots):
if (z == 0):
g.drawImage(self.head, x[z], y[z], self)
else:
g.drawImage(self.ball, x[z], y[z], self)
Toolkit.getDefaultToolkit().sync()
g.dispose()
def gameOver(self, g):
msg = "Game Over"
small = Font("Helvetica", Font.BOLD, 14)
metr = self.getFontMetrics(small)
g.setColor(Color.white)
g.setFont(small)
g.drawString(msg, (WIDTH - metr.stringWidth(msg)) / 2,
HEIGHT / 2)
def checkApple(self):
if x[0] == self.apple_x and y[0] == self.apple_y:
self.dots = self.dots + 1
self.locateApple()
def move(self):
z = self.dots
while z > 0:
x[z] = x[(z - 1)]
y[z] = y[(z - 1)]
z = z - 1
if self.left:
x[0] -= DOT_SIZE
if self.right:
x[0] += DOT_SIZE
if self.up:
y[0] -= DOT_SIZE
if self.down:
y[0] += DOT_SIZE
def checkCollision(self):
z = self.dots
while z > 0:
if z > 4 and x[0] == x[z] and y[0] == y[z]:
self.inGame = False
z = z - 1
if y[0] > HEIGHT - DOT_SIZE:
self.inGame = False
if y[0] < 0:
self.inGame = False
if x[0] > WIDTH - DOT_SIZE:
self.inGame = False
if x[0] < 0:
self.inGame = False
def locateApple(self):
r = random.randint(0, RAND_POS)
self.apple_x = r * DOT_SIZE
r = random.randint(0, RAND_POS)
self.apple_y = r * DOT_SIZE
# public void actionPerformed(ActionEvent e) {
def actionPerformed(self, e):
if self.inGame:
self.checkApple()
self.checkCollision()
self.move()
else:
self.timer.stop()
self.repaint()
def keyPressed(self, e):
key = e.getKeyCode()
if key == KeyEvent.VK_LEFT and not self.right:
self.left = True
self.up = False
self.down = False
if key == KeyEvent.VK_RIGHT and not self.left:
self.right = True
self.up = False
self.down = False
if key == KeyEvent.VK_UP and not self.down:
self.up = True
self.right = False
self.left = False
if key == KeyEvent.VK_DOWN and not self.up:
self.down = True
self.right = False
self.left = False
class XYPlot(core.DataViewComponent):
def __init__(self, view, name, func, args=(), filter=None, label=None):
core.DataViewComponent.__init__(self, label)
self.view = view
self.name = name
self.func = func
self.indices = None
self.data = self.view.watcher.watch(name, func, args=args)
self.margin = 10
self.autozoom = True
self.last_maxy = None
self.popup_zoom = JCheckBoxMenuItem('auto-zoom', self.autozoom, stateChanged=self.toggle_autozoom)
self.popup.add(self.popup_zoom)
self.autohide = True
self.show_axes_labels = True
self.popup_hide = JCheckBoxMenuItem('auto-hide axis labels', True, actionPerformed=self.toggle_autohide)
self.popup.add(self.popup_hide)
self.axes_label_init_clr = 0.3
self.axes_label_clr_val = self.axes_label_init_clr
self.axes_label_clr_step = (1 - self.axes_label_init_clr) / 10
self.axes_label_hide_dly = 1000
self.axes_label_hide_tmr = Timer(self.axes_label_hide_dly / 10, None, actionPerformed=self.fade_axes_labels)
self.filter = filter
self.setSize(200, 200)
def save(self):
save_info = core.DataViewComponent.save(self)
save_info['sel_dim'] = self.indices
save_info['autozoom'] = self.autozoom
save_info['last_maxy'] = self.last_maxy
save_info['autohide'] = self.autohide
return save_info
def restore(self, d):
core.DataViewComponent.restore(self, d)
self.indices = d.get('sel_dim', [0, 1])
self.autozoom = d.get('autozoom', True)
self.popup_zoom.state = self.autozoom
self.last_maxy = d.get('last_maxy', None)
self.autohide = d.get('autohide', True)
self.popup_hide.state = self.autohide
self.show_axes_labels = not self.autohide
self.fix_popup()
def toggle_autozoom(self, event):
self.autozoom = event.source.state
self.repaint()
def toggle_autohide(self, event):
self.autohide = event.source.state
if(self.autohide):
self.axes_label_hide_tmr.start()
else:
self.disp_axes_labels()
def fix_popup(self):
self.popup.add(JPopupMenu.Separator())
# Add submenus for x and y axes
x_menu = JMenu("X Axis")
y_menu = JMenu("Y Axis")
self.popup.add(x_menu)
self.popup.add(y_menu)
x_btngrp = ButtonGroup()
y_btngrp = ButtonGroup()
# Calculate number of submenu layers needed
max_ind = len(self.data.get_first())
num_sub = max(1, int(ceil(log(max_ind) / log(self.max_show_dim))))
max_sub = [self.max_show_dim ** (num_sub - i) for i in range(num_sub)]
x_subs = [x_menu] * num_sub
y_subs = [y_menu] * num_sub
for i in range(max_ind):
if(i % self.max_show_dim == 0):
for n in range(num_sub - 1):
if(i % max_sub[n + 1] == 0):
new_xmenu = JMenu("%s[%d:%d]" % ('v', i, min(max_ind, i + max_sub[n + 1]) - 1))
new_ymenu = JMenu("%s[%d:%d]" % ('v', i, min(max_ind, i + max_sub[n + 1]) - 1))
x_subs[n].add(new_xmenu)
x_subs[n + 1] = new_xmenu
y_subs[n].add(new_ymenu)
y_subs[n + 1] = new_ymenu
x_radio = JRadioButtonMenuItem('%s[%d]' % ('v', i), i == self.indices[0], actionPerformed=lambda x, index=i, self=self: self.indices.__setitem__(0, index))
y_radio = JRadioButtonMenuItem('%s[%d]' % ('v', i), i == self.indices[1], actionPerformed=lambda x, index=i, self=self: self.indices.__setitem__(1, index))
x_btngrp.add(x_radio)
y_btngrp.add(y_radio)
x_subs[num_sub - 1].add(x_radio)
y_subs[num_sub - 1].add(y_radio)
def mouseEntered(self, event):
if(self.autohide):
self.disp_axes_labels()
core.DataViewComponent.mouseEntered(self, event)
def mouseExited(self, event):
if(self.autohide):
self.axes_label_hide_tmr.start()
core.DataViewComponent.mouseExited(self, event)
def disp_axes_labels(self):
self.axes_label_clr_val = self.axes_label_init_clr
self.show_axes_labels = True
self.axes_label_hide_tmr.stop()
self.repaint()
def fade_axes_labels(self, event):
if(self.show_axes_labels):
if(self.axes_label_clr_val >= 1 - self.axes_label_clr_step):
self.axes_label_hide_tmr.stop()
self.show_axes_labels = False
else:
self.axes_label_clr_val += self.axes_label_clr_step
self.axes_label_clr_val = min(1, self.axes_label_clr_val)
self.axes_label_hide_tmr.start()
self.repaint()
def paintComponent(self, g):
core.DataViewComponent.paintComponent(self, g)
xc = self.width / 2
yc = (self.height - self.label_offset) / 2
x0 = self.margin / 2.0
y0 = self.margin / 2.0
g.color = Color(0.8, 0.8, 0.8)
g.drawRect(int(x0) - 1, int(y0 + self.label_offset) - 1, int(self.size.width - self.margin) + 1, int(self.size.height - self.label_offset - self.margin) + 1)
g.drawLine(xc, self.margin + self.label_offset, xc, self.height - self.margin)
g.drawLine(self.margin, yc + self.label_offset, self.width - self.margin, yc + self.label_offset)
dt_tau = None
if self.filter and self.view.tau_filter > 0:
dt_tau = self.view.dt / self.view.tau_filter
pts = int(self.view.time_shown / self.view.dt)
try:
data = self.data.get(start=self.view.current_tick - pts + 1, count=pts, dt_tau=dt_tau)
except:
return
if data is None:
return
if(self.indices is None):
self.indices = [0, 1]
self.fix_popup()
xs = [d[self.indices[0]] for d in data if d is not None]
ys = [d[self.indices[1]] for d in data if d is not None]
if len(xs) > 0:
mx = max(max(xs), max(ys), -min(xs), -min(ys))
mx = round(mx)[1]
if mx < 1.0:
mx = 1.0
else:
mx = 1.0
if(not self.autozoom and self.last_maxy is not None and mx < self.last_maxy):
mx = self.last_maxy
self.last_maxy = mx
g.color = Color.black
txt = '%g' % mx
bounds = g.font.getStringBounds(txt, g.fontRenderContext)
#g.drawString(txt,xc+self.margin,bounds.height)
g.drawString(txt, xc + x0, bounds.height + self.margin + self.label_offset)
g.drawString(txt, self.width - self.margin - bounds.width, yc + bounds.height + self.label_offset)
txt = '%g' % (-mx)
#g.drawString(txt,xc+self.margin,self.height-self.margin)
g.drawString(txt, xc + x0, self.height - self.margin)
g.drawString(txt, self.margin, yc + bounds.height + self.label_offset)
if(self.show_axes_labels):
g.color = Color(self.axes_label_clr_val, self.axes_label_clr_val, self.axes_label_clr_val)
txt = '%s[%d]' % ('v', self.indices[0])
boundsl = g.font.getStringBounds(txt, g.fontRenderContext)
g.drawString(txt, self.width - self.margin - boundsl.width, yc - y0 + self.label_offset)
txt = '%s[%d]' % ('v', self.indices[1])
boundsl = g.font.getStringBounds(txt, g.fontRenderContext)
g.drawString(txt, xc - x0 - boundsl.width, bounds.height + self.margin + self.label_offset)
g.color = Color.black
pdftemplate = getattr(self.view.area, 'pdftemplate', None)
if pdftemplate is not None:
pdf, scale = pdftemplate
pdf.setLineWidth(0.5)
last_color = None
sx = (self.width / 2 - self.margin) / mx
sy = (yc - self.margin) / mx
for i in range(pts - 1):
if data[i] is not None and data[i + 1] is not None:
x0 = data[i][self.indices[0]]
y0 = data[i][self.indices[1]]
x1 = data[i + 1][self.indices[0]]
y1 = data[i + 1][self.indices[1]]
c = 1.0 - i / float(pts - 1)
g.color = Color(c, c, c)
if pdftemplate is None:
g.drawLine(int(xc + x0 * sx), int(yc - y0 * sy + self.label_offset), int(xc + x1 * sx), int(yc - y1 * sy + self.label_offset))
else:
c = int(c * 32) * 8
if c > 255:
c = 255
if c != last_color:
if last_color is not None:
pdf.setRGBColorStroke(last_color, last_color, last_color)
pdf.stroke()
pdf.moveTo(((xc + x0 * sx) + self.x) * scale, 800 - (self.y + yc - y0 * sy + self.label_offset) * scale)
last_color = c
pdf.lineTo(((xc + x1 * sx) + self.x) * scale, 800 - (self.y + yc - y1 * sy + self.label_offset) * scale)
if pdftemplate is not None:
pdf.setRGBColorStroke(last_color, last_color, last_color)
pdf.stroke()
class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
layerArray = [[] for i in range(100)
] #Creating a 100-item array for us to work with.
for object in screenObjects:
layerIndex = int(
min(object._zLayer, 99)
) #This specifies the layer that the object will be headed for...
layerLoc = 0
myDepth = object._get("zDepth")
for compObject in layerArray[
layerIndex]: #but first, we need to find the right place in that layer to put our object.
if (myDepth > compObject._get("zDepth")):
layerLoc = layerLoc + 1
else:
break
layerArray[layerIndex].insert(layerLoc, object)
newArray = [
] #We now want to compress our scattered 2d-array into a 1d-array.
for subArray in layerArray: #It's called Radix sorting.
newArray.extend(subArray)
#screenObjects = newArray #Turns out you can't actually do this, and I have no idea why.
for object in newArray: #Instead of going through screenObjects, we go through newArray, which is sorted by layer.
object._draw(
g
) #Now calls a _draw method on each object, instead of just having a bunch of lambdas in screenObjects.
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(
x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped'] = string(k)
# print("Key Pressed: " + string(k))
def my_move(self, x, y):
mouse_pos[0] = SP2(x, y)
def initUI(self):
self.addKeyListener(KA(lambda k: self.mykey(k)))
self.xp = 0
self.yp = 0
self.canvas = Canvas(lambda g: self.mypaint(g),
lambda x, y: self.myclick(x, y),
lambda x, y: self.my_move(x, y))
self.canvas.setBackground(JavaColor(200, 200, 100))
self.getContentPane().add(self.canvas)
self.setTitle("Test")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.xSize = 500
self.ySize = 500
self.setSize(self.xSize, self.ySize)
self.setLocationRelativeTo(None)
self.setBackground(JavaColor(255, 255, 255))
self.setVisible(True)
#self.button = JButton("This is a button")
#self.add(self.button, BorderLayout.SOUTH)
#self.button.addActionListener(self)
self.timer = Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
#if(e.getSource() == self.button):
#self.addSlider()
#else:
currentTime = System.currentTimeMillis()
#if ((currentTime-startTime[0]) % 75 == 0):
# balls.append(circle(p2(random.randrange(50,250),270-localTime*100), 10))
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
def addSlider(self): #adds a new slider at the bottom of the window.
slider = JSlider()
self.add(
slider, BorderLayout.SOUTH
) #this is the best way I could find to make sure the slider appears somewhere consistent.
self.ySize = self.ySize + 20 #the problem, sadly, is that all of the sliders and buttons and stuff appear at the SAME PLACE, overlapping.
self.setSize(self.xSize, self.ySize)
class FunctionControl(core.DataViewComponent, ComponentListener):
def __init__(self, view, name, func, label=None):
core.DataViewComponent.__init__(self, label)
self.view = view
self.name = name
self.func = func
self.label_height = 18
self.resize_border = 2
self.popup_hide_limit = JCheckBoxMenuItem('auto-hide limits', True, actionPerformed=self.toggle_autohide)
self.popup.add(self.popup_hide_limit)
self.show_limits = False
self.auto_hide_limits = True
self.limits_font = Font("Dialog", Font.PLAIN, 10)
self.limit_width = 0
self.limit_hide_delay = 1000
self.limit_color_def = 0.3
self.limit_color_val = self.limit_color_def
self.limit_color_step = (1 - self.limit_color_def) / 10
self.limit_hide_timer = Timer(self.limit_hide_delay / 10, None, actionPerformed=self.hide_limits)
self.limit_hide_timer.setRepeats(False)
self.popup.add(JPopupMenu.Separator())
self.popup.add(JMenuItem('zero', actionPerformed=self.zero))
self.popup.add(JMenuItem('set value', actionPerformed=self.set_value))
self.filename = None
self.popup.add(JMenuItem('set from file...', actionPerformed=self.set_from_file))
self.popup.add(JPopupMenu.Separator())
self.popup.add(JMenuItem('increase range', actionPerformed=self.increase_range))
self.popup.add(JMenuItem('decrease range', actionPerformed=self.decrease_range))
self.scale_factor = 0.01
self.range = 1.0
self.data = self.view.watcher.watch(name, func)
values = self.data.get_first()
self.sliders = []
self.labels = []
for i, v in enumerate(values):
vv = int(v * 100 / self.range)
if vv > 100:
vv = 100
if vv < -100:
vv = -100
slider = JSlider(JSlider.VERTICAL, -100, 100, vv, stateChanged=lambda event, index=i: self.slider_moved(index))
slider.background = Color.white
self.add(slider)
self.sliders.append(slider)
label = JLabel('0.00')
self.add(label)
self.labels.append(label)
slider.addMouseListener(self)
self.setSize(len(values) * 40 + 40, 200)
self.addComponentListener(self)
self.componentResized(None)
def increase_range(self, event):
self.range *= 2.0
self.check_label_size()
self.repaint()
def decrease_range(self, event):
self.range *= 0.5
self.check_label_size()
self.repaint()
def check_label_size(self):
if(self.show_limits):
limit_label = JLabel(("-%1.2f" % (self.range)))
limit_width = limit_label.getPreferredSize().width - self.sliders[0].width / 2
if(limit_width != self.limit_width):
self.setSize(self.size.width + limit_width - self.limit_width, self.size.height)
self.setLocation(self.x - limit_width + self.limit_width, self.y)
self.limit_width = limit_width
def zero(self, event):
for i in range(len(self.sliders)):
self.set_slider_value(i, 0)
def set_value(self, event):
try:
example = ','.join(['%1.1f' % random.uniform(-5, 5) for i in range(len(self.sliders))])
text = JOptionPane.showInputDialog(self.view.frame, 'Enter input value. \nExample: %s' % example, "Set value", JOptionPane.PLAIN_MESSAGE, None, None, None)
v = eval(text)
if isinstance(v, (int, float)):
v = [v]
if len(v) > len(self.sliders):
v = v[:len(self.sliders)]
for i, vv in enumerate(v):
self.set_slider_value(i, vv)
except:
self.release_value(event)
def set_from_file(self, event):
fileChooser = JFileChooser()
if self.filename is not None:
fileChooser.setSelectedFile(java.io.File(self.filename))
if fileChooser.showOpenDialog(self) == JFileChooser.APPROVE_OPTION:
self.filename = fileChooser.selectedFile.absolutePath
#TODO: this doesn't for for nested FunctionInputs
input = self.view.network.getNode(self.name)
from nef.functions import Interpolator
interp = Interpolator(self.filename)
interp.load_into_function(input)
def set_slider_value(self, index, value):
sv = value / (self.scale_factor * self.range)
self.sliders[index].value = int(sv)
self.labels[index].text = '%1.2f' % value
self.check_label_size()
self.repaint()
if self.view.paused: # change immediately, bypassing filter
self.data.data[-1][index] = value
self.view.forced_origins_prev[(self.name, 'origin', index)] = value
self.view.forced_origins[(self.name, 'origin', index)] = value
def slider_moved(self, index):
if self.sliders[index].valueIsAdjusting: # if I moved it
v = self.sliders[index].value * self.scale_factor * self.range
self.labels[index].text = '%1.2f' % v
if self.view.paused: # change immediately, bypassing filter
self.data.data[-1][index] = v
self.view.forced_origins_prev[(self.name, 'origin', index)] = v
self.view.forced_origins[(self.name, 'origin', index)] = v
def paintComponent(self, g):
temp = self.show_label
self.show_label = False
core.DataViewComponent.paintComponent(self, g)
self.show_label = temp
if self.show_label:
g.color = Color(0.3, 0.3, 0.3)
bounds = g.font.getStringBounds(self.label, g.fontRenderContext)
g.drawString(self.label, (self.size.width - self.limit_width) / 2 - bounds.width / 2 + self.limit_width, bounds.height)
self.active = self.view.current_tick >= self.view.timelog.tick_count - 1
data = self.data.get(start=self.view.current_tick, count=1)[0]
if data is None:
data = self.data.get_first()
if(self.show_limits):
g.color = Color(self.limit_color_val, self.limit_color_val, self.limit_color_val)
txt_min = "%1.2f" % (-self.range)
txt_max = "%1.2f" % (self.range)
temp_font = g.font
g.font = self.limits_font
bounds_min = g.font.getStringBounds(txt_min, g.fontRenderContext)
bounds_max = g.font.getStringBounds(txt_max, g.fontRenderContext)
g.drawString(txt_max, 10 + bounds_min.width - bounds_max.width, self.resize_border + self.label_offset + bounds_max.height)
g.drawString(txt_min, 10, self.height - self.resize_border - self.labels[0].getPreferredSize().height - bounds_min.height)
g.font = temp_font
for i, v in enumerate(data):
while v > self.range * 1.1:
self.range *= 2
while v < -self.range * 1.1:
self.range *= 2
for i, v in enumerate(data):
sv = int(v * 100.0 / self.range)
if sv > 100:
sv = 100
if sv < -100:
sv = -100
if not self.sliders[i].valueIsAdjusting:
self.sliders[i].value = sv
self.labels[i].text = '%1.2f' % v
self.sliders[i].enabled = self.active
self.componentResized(None)
def componentResized(self, e):
w = self.width - self.resize_border * 2 - self.limit_width
dw = w / len(self.sliders)
x = (dw - self.sliders[0].minimumSize.width) / 2
for i, slider in enumerate(self.sliders):
slider.setLocation(self.limit_width + self.resize_border + x + i * dw, self.resize_border + self.label_offset)
slider.setSize(slider.minimumSize.width, self.height - self.resize_border * 2 - 20 - self.label_offset)
self.labels[i].setLocation(slider.x + slider.width / 2 - self.labels[i].width / 2, slider.y + slider.height)
def componentHidden(self, e):
pass
def componentMoved(self, e):
pass
def componentShown(self, e):
pass
def save(self):
info = core.DataViewComponent.save(self)
if(self.auto_hide_limits):
self.hide_limits(None)
info['x'] = self.x # Overwrite x and width to account for removed limits
info['width'] = self.width
info['range'] = self.range
info['limits'] = self.auto_hide_limits
info['limits_w'] = self.limit_width
return info
def restore(self, d):
core.DataViewComponent.restore(self, d)
self.range = d.get('range', 1.0)
self.auto_hide_limits = d.get('limits', True)
self.limit_width = d.get('limits_w', 0)
self.popup_hide_limit.state = self.auto_hide_limits
self.show_limits = not self.auto_hide_limits
def mouseEntered(self, event):
if(self.auto_hide_limits):
self.disp_limits()
core.DataViewComponent.mouseEntered(self, event)
def mouseExited(self, event):
if(self.auto_hide_limits):
self.limit_hide_timer.start()
core.DataViewComponent.mouseExited(self, event)
def toggle_autohide(self, event):
self.auto_hide_limits = event.source.state
if(self.auto_hide_limits):
self.limit_hide_timer.start()
else:
self.disp_limits()
def disp_limits(self):
if(not self.show_limits):
limit_label = JLabel(("-%1.2f" % (self.range)))
self.limit_width = limit_label.getPreferredSize().width - self.sliders[0].width / 2
self.setSize(self.size.width + self.limit_width, self.size.height)
self.setLocation(self.x - self.limit_width, self.y)
self.limit_hide_timer.stop()
self.limit_color_val = self.limit_color_def
self.show_limits = True
self.repaint()
def hide_limits(self, event):
if(self.show_limits):
if(self.limit_color_val >= 1 - self.limit_color_step):
self.limit_hide_timer.stop()
self.setSize(self.size.width - self.limit_width, self.size.height)
self.setLocation(self.x + self.limit_width, self.y)
self.limit_width = 0
self.show_limits = False
else:
self.limit_color_val += self.limit_color_step
self.limit_color_val = min(self.limit_color_val, 1.0)
self.limit_hide_timer.start()
self.repaint()
class Simbicon(java, applet, Applet, MouseListener, MouseMotionListener,
KeyListener):
""" generated source for class Simbicon """
bip7 = Bip7()
gnd = Ground()
Dt = 0.00005
DtDisp = 0.0054
timeEllapsed = 0
# we'll use this buffered image to reduce flickering
tempBuffer = BufferedImage()
timer = Timer()
# and the controller
con = Controller()
Md = float()
Mdd = float()
DesVel = 0
# if this variable is set to true, the simulation will be running, otherwise it won't
simFlag = False
simButton = javax.swing.JButton()
reset = javax.swing.JButton()
panel = javax.swing.JPanel()
speedSlider = javax.swing.JSlider()
label = javax.swing.JLabel()
shouldPanY = False
def init(self):
""" generated source for method init """
setSize(500, 500)
addMouseListener(self)
addMouseMotionListener(self)
# initialize the biped to a valid state:
state = [
0.463, 0.98, 0.898, -0.229, 0.051, 0.276, -0.221, -1.430, -0.217,
0.086, 0.298, -3.268, -0.601, 3.167, 0.360, 0.697, 0.241, 3.532
]
self.bip7.setState(state)
delay = 1
# milliseconds
taskPerformer = ActionListener()
self.timer = Timer(delay, taskPerformer)
self.timer.start()
self.tempBuffer = BufferedImage(500, 500, BufferedImage.TYPE_INT_RGB)
initComponents()
self.con = Controller()
self.con.addWalkingController()
self.con.addRunningController()
self.con.addCrouchWalkController()
self.addKeyListener(self)
self.requestFocus()
def boundRange(self, value, min, max):
""" generated source for method boundRange """
if value < min:
value = min
if value > max:
value = max
return value
# ////////////////////////////////////////////////////////
# PROC: wPDtorq()
# DOES: computes requires torque to move a joint wrt world frame
# ////////////////////////////////////////////////////////
def wPDtorq(self, torq, joint, dposn, kp, kd, world):
""" generated source for method wPDtorq """
joint_posn = self.bip7.State[4 + joint * 2]
joint_vel = self.bip7.State[4 + joint * 2 + 1]
if world:
# control wrt world frame? (virtual)
joint_posn += self.bip7.State[4]
# add body tilt
joint_vel += self.bip7.State[5]
# add body angular velocity
torq[joint] = kp * (dposn - joint_posn) - kd * joint_vel
# ////////////////////////////////////////////////////////
# PROC: jointLimit()
# DOES: enforces joint limits
# ////////////////////////////////////////////////////////
def jointLimit(self, torq, joint):
""" generated source for method jointLimit """
kpL = 800
kdL = 80
minAngle = self.con.jointLimit[0][joint]
maxAngle = self.con.jointLimit[1][joint]
currAngle = self.bip7.State[4 + joint * 2]
currOmega = self.bip7.State[4 + joint * 2 + 1]
if currAngle < minAngle:
torq = kpL * (minAngle - currAngle) - kdL * currOmega
elif currAngle > maxAngle:
torq = kpL * (maxAngle - currAngle) - kdL * currOmega
return torq
def bip7WalkFsm(self, torq):
""" generated source for method bip7WalkFsm """
torsoIndex = 0
rhipIndex = 1
rkneeIndex = 2
lhipIndex = 3
lkneeIndex = 4
rankleIndex = 5
lankleIndex = 6
worldFrame = [False, True, False, True, False, False, False]
self.con.stateTime += self.Dt
s = self.con.state[self.con.fsmState]
computeMdMdd()
n = 0
while n < 7:
target = self.boundRange(target, self.con.targetLimit[0][n],
self.con.targetLimit[1][n])
self.wPDtorq(torq, n, target, self.con.kp[n], self.con.kd[n],
worldFrame[n])
n += 1
self.con.advance(self.bip7)
def bip7Control(self, torq):
""" generated source for method bip7Control """
body = 0
stanceHip = int()
swingHip = int()
fallAngle = 60
n = 0
while n < 7:
torq[n] = 0
n += 1
if not self.bip7.lostControl:
self.bip7WalkFsm(torq)
if self.con.state[self.con.fsmState].leftStance:
stanceHip = 3
swingHip = 1
else:
stanceHip = 1
swingHip = 3
if not self.con.state[self.con.fsmState].poseStance:
torq[stanceHip] = -torq[body] - torq[swingHip]
torq[0] = 0
n = 1
while n < 7:
torq[n] = self.boundRange(torq[n], self.con.torqLimit[0][n],
self.con.torqLimit[1][n])
self.jointLimit(torq[n], n)
n += 1
def computeMdMdd(self):
""" generated source for method computeMdMdd """
stanceFootX = self.bip7.getStanceFootXPos(self.con)
self.Mdd = self.bip7.State[1] - self.DesVel
self.Md = self.bip7.State[0] - stanceFootX
def initComponents(self):
""" generated source for method initComponents """
self.simButton = javax.swing.JButton()
self.reset = javax.swing.JButton()
self.panel = javax.swing.JPanel()
self.label = javax.swing.JLabel()
self.label.setText("Speed: ")
self.speedSlider = javax.swing.JSlider()
self.speedSlider.setMaximum(100)
self.speedSlider.setMinimum(0)
self.speedSlider.setToolTipText(
"Adjust the speed of the simulation by adjusting this slider.")
setLayout(BorderLayout())
self.panel.setLayout(FlowLayout())
add(self.panel, BorderLayout.NORTH)
self.panel.add(self.label)
self.panel.add(self.speedSlider)
self.panel.add(self.simButton)
self.panel.add(self.reset)
self.speedSlider.addMouseListener(java.awt.event.MouseAdapter())
self.simButton.setText(" Start ")
self.reset.setText("Reset")
self.simButton.addActionListener(java.awt.event.ActionListener())
self.reset.addActionListener(java.awt.event.ActionListener())
def resetSimulation(self):
""" generated source for method resetSimulation """
self.bip7.resetBiped()
self.con.stateTime = 0
self.con.fsmState = 0
self.con.currentGroupNumber = 0
self.con.desiredGroupNumber = 0
repaint()
def runLoop(self):
""" generated source for method runLoop """
if self.simFlag == False:
return
self.timer.stop()
i = 0
while i < 200:
self.bip7.computeGroundForces(self.gnd)
self.bip7Control(self.bip7.t)
self.bip7.runSimulationStep(self.Dt)
self.timeEllapsed += self.Dt
if self.timeEllapsed > self.DtDisp:
self.update(self.getGraphics())
self.timeEllapsed = 0
i += 1
self.timer.start()
def update(self, g):
""" generated source for method update """
if g == None:
return
g2 = self.tempBuffer.getGraphics()
g2.setColor(Color(255, 255, 255))
g2.fillRect(0, 0, getSize().width - 1, getSize().height - 1)
m = Matrix3x3.getTranslationMatrix(0, -300)
m = m.multiplyBy(Matrix3x3.getScalingMatrix(float(100)))
panX = self.bip7.State[0]
panY = self.bip7.State[2]
if self.shouldPanY == False:
panY = 0
m = m.multiplyBy(
Matrix3x3.getTranslationMatrix(-panX + 1.5, -panY + 0.5))
self.bip7.drawBiped(g2, m)
self.gnd.draw(g2, m)
g.drawImage(self.tempBuffer, 0, self.panel.getHeight(), self)
self.panel.repaint()
def paint(self, g):
""" generated source for method paint """
self.update(g)
self.panel.repaint()
def keyReleased(self, e):
""" generated source for method keyReleased """
def keyPressed(self, e):
""" generated source for method keyPressed """
if e.getKeyCode() == e.VK_LEFT:
self.bip7.PushTime = 0.2
self.bip7.PushForce = -60
if e.getKeyCode() == e.VK_RIGHT:
self.bip7.PushTime = 0.2
self.bip7.PushForce = 60
if e.getKeyChar() == 'r' or e.getKeyChar() == 'R':
self.con.desiredGroupNumber = 1
if e.getKeyChar() == 'w' or e.getKeyChar() == 'W':
self.con.desiredGroupNumber = 0
if e.getKeyChar() == 'c' or e.getKeyChar() == 'C':
self.con.desiredGroupNumber = 2
if e.getKeyChar() == '1':
self.gnd.getFlatGround()
self.resetSimulation()
if e.getKeyChar() == '2':
self.gnd.getComplexTerrain()
self.resetSimulation()
def keyTyped(self, e):
""" generated source for method keyTyped """
def mouseDragged(self, e):
""" generated source for method mouseDragged """
def mouseMoved(self, e):
""" generated source for method mouseMoved """
def mousePressed(self, e):
""" generated source for method mousePressed """
self.requestFocus()
def mouseReleased(self, e):
""" generated source for method mouseReleased """
def mouseEntered(self, e):
""" generated source for method mouseEntered """
def mouseExited(self, e):
""" generated source for method mouseExited """
def mouseClicked(self, e):
""" generated source for method mouseClicked """
def destroy(self):
""" generated source for method destroy """
removeMouseListener(self)
removeMouseMotionListener(self)
def getAppletInfo(self):
""" generated source for method getAppletInfo """
return "Title: Simbicon\n" + "Author: Stelian Coros, Michiel van de Panne."
class Browser:
def __init__(self, repository):
self.repository = repository
# want a better solution, with domains, perhaps user specifies
self.currentUserReference = System.getProperty("user.name")
self.currentRecord = None
self.window = JFrame("Pointrel browser", windowClosing=self.exit)
self.window.contentPane.layout = BorderLayout() # redundant as the default
self.window.bounds = (100, 100, 800, 600)
self.menuBar = JMenuBar()
self.window.JMenuBar = self.menuBar
fileMenu = JMenu("File")
fileMenu.add(JMenuItem("Open...", actionPerformed=self.open))
fileMenu.add(JMenuItem("Reload", actionPerformed=self.reloadPressed))
fileMenu.addSeparator()
fileMenu.add(JMenuItem("Import from other repository...", actionPerformed=self.importFromOtherRepository))
fileMenu.addSeparator()
fileMenu.add(JMenuItem("Close", actionPerformed=self.close))
self.menuBar.add(fileMenu)
exportMenu = JMenu("Export")
exportMenu.add(JMenuItem("Choose current export file...", actionPerformed=self.exportChooseCurrentFile))
exportMenu.addSeparator()
exportMenu.add(JMenuItem("Export selected record", actionPerformed=self.exportSelectedRecord))
exportMenu.add(JMenuItem("Export record history for selected attribute", actionPerformed=self.exportAllRecordsForSelectedAttribute))
exportMenu.addSeparator()
exportMenu.add(JMenuItem("Export current records for all attributes of selected entity", actionPerformed=self.exportLatestRecordsForSelectedEntity))
exportMenu.add(JMenuItem("Export entire record history for all attributes of selected entity", actionPerformed=self.exportAllRecordsForSelectedEntity))
self.menuBar.add(exportMenu)
self.exportFileName = "export.pointrel"
#self.reloadButton = JButton("Reload Repository", actionPerformed=self.reloadPressed)
self.entitiesList = JList(DefaultListModel(), mouseClicked=self.entitiesListClicked)
self.entitiesList.model.addElement("root")
self.entitiesList.mousePressed = self.entitiesListMousePressed
self.entitiesList.mouseReleased = self.entitiesListMousePressed
self.attributesList = JList(DefaultListModel(), mouseClicked=self.attributesListClicked)
self.versionsList = JList(DefaultListModel(), mouseClicked=self.versionsListClicked)
self.listPanel = JPanel(layout=GridLayout(1, 2))
self.listPanel.add(JScrollPane(self.entitiesList))
self.listPanel.add(JScrollPane(self.attributesList))
self.listPanel.add(JScrollPane(self.versionsList))
self.navigationPanel = JPanel(layout=BorderLayout())
#self.navigationPanel.add(self.reloadButton, BorderLayout.NORTH)
self.navigationPanel.add(self.listPanel, BorderLayout.CENTER)
self.entityTextField = JTextField(preferredSize=(200,20))
self.attributeTextField = JTextField(preferredSize=(200,20))
self.deletedButton = JCheckBox("Deleted", actionPerformed=self.deletedPressed)
# only one right now -- and no support for switching editor panels yet
examples = ["pointrel:text/utf-8", ]
self.valueTypeComboBox = JComboBox(examples, preferredSize=(200,20), editable=True)
self.attributePanel = Box(BoxLayout.X_AXIS)
self.attributePanel.add(Box.createRigidArea(Dimension(5,0)))
self.attributePanel.add(JLabel("Entity:"))
self.attributePanel.add(Box.createRigidArea(Dimension(2,0)))
self.attributePanel.add(self.entityTextField)
self.attributePanel.add(Box.createRigidArea(Dimension(5,0)))
self.attributePanel.add(JLabel("Attribute:"))
self.attributePanel.add(Box.createRigidArea(Dimension(2,0)))
self.attributePanel.add(self.attributeTextField)
self.attributePanel.add(Box.createRigidArea(Dimension(5,0)))
self.attributePanel.add(JLabel("Value type:"))
self.attributePanel.add(Box.createRigidArea(Dimension(2,0)))
self.attributePanel.add(self.valueTypeComboBox)
self.attributePanel.add(Box.createRigidArea(Dimension(5,0)))
self.attributePanel.add(self.deletedButton)
self.attributePanel.add(Box.createRigidArea(Dimension(5,0)))
self.showAllDeletedButton = JCheckBox("Show all deleted", actionPerformed=self.showAllDeletedPressed)
self.statusText = JTextField(preferredSize=(100,20))
self.saveButton = JButton("Save", actionPerformed=self.savePressed)
self.normalSaveButtonColor = self.saveButton.background
self.changedSaveButtonColor = Color.YELLOW
self.statusPanel = Box(BoxLayout.X_AXIS)
self.statusPanel.add(Box.createRigidArea(Dimension(5,0)))
self.statusPanel.add(self.showAllDeletedButton)
self.statusPanel.add(Box.createRigidArea(Dimension(25,0)))
self.statusPanel.add(JLabel("Message:") )
self.statusPanel.add(Box.createRigidArea(Dimension(2,0)))
self.statusPanel.add(self.statusText)
self.statusPanel.add(Box.createRigidArea(Dimension(5,0)))
self.statusPanel.add(self.saveButton)
self.statusPanel.add(Box.createRigidArea(Dimension(1,0)))
self.currentEditorPanel = EditorPanel_text_utf_8(self, "pointrel:text/utf-8")
self.topPanel = Box(BoxLayout.Y_AXIS)
self.topPanel.add(Box.createRigidArea(Dimension(0,5)))
self.topPanel.add(self.attributePanel)
self.topPanel.add(Box.createRigidArea(Dimension(0,5)))
self.editorPanel = JPanel(layout=BorderLayout())
self.editorPanel.add(self.topPanel, BorderLayout.NORTH)
self.editorPanel.add(self.currentEditorPanel, BorderLayout.CENTER)
self.editorPanel.add(self.statusPanel, BorderLayout.SOUTH)
self.browserPanel = JSplitPane(JSplitPane.VERTICAL_SPLIT)
self.browserPanel.add(self.navigationPanel)
self.browserPanel.add(self.editorPanel)
self.window.contentPane.add(self.browserPanel, BorderLayout.CENTER)
self.setTitleForRepository()
self.window.show()
# background timer for updating save button color
self.timer = Timer(1000, CallbackActionListener(self.timerEvent))
self.timer.initialDelay = 1000
self.timer.start()
def close(self, event):
System.exit(0)
def open(self, event):
dialog = FileDialog(self.window)
fileName = dialog.go(PointrelFileTypes)
if not fileName:
return
repository = Repository(fileName)
self.repository = repository
self.currentRecord = None
self.clearAllEntityNames()
self.refreshBrowser()
self.setTitleForRepository()
def setTitleForRepository(self):
self.window.title = "Pointrel browser on %s" % self.repository.fileName
def setStatus(self, messageText):
self.statusText.text = messageText
def getCurrentEntityName(self):
return self.entityTextField.text
def setCurrentEntityName(self, newAttributeName):
self.entityTextField.text = newAttributeName
def getCurrentAttributeName(self):
return self.attributeTextField.text
def setCurrentAttributeName(self, newAttributeName):
self.attributeTextField.text = newAttributeName
def getCurrentValueType(self):
#return self.valueTypeComboBox.selectedItem
return self.valueTypeComboBox.editor.editorComponent.text
def setCurrentValueType(self, newValueType):
self.valueTypeComboBox.selectedItem = newValueType
# PDF FIX __ NEED TO CHANGE EDITOR TYPE
def reportStatistics(self):
contents = self.currentEditorPanel.getCurrentValueBytes()
words = len(contents.split())
lines = contents.count('\n')
characters = len(contents)
report = "%d lines; %d words; %d characters" % (lines, words, characters)
self.setStatus(report)
def timerEvent(self, event):
self.manageSaveButtonColor()
self.reportStatistics()
def exit(self, event=None):
System.exit(0)
def reloadPressed(self, event):
print "reloading repository; ",
self.repository.reload()
self.refreshBrowser()
print "done"
def importCodeFromRepository(self, name, globals=None, locals=None, fromlist=None):
# seems to fail with stack overflow if print while importing while trying jconsole (it reassigns stdio)
debug = 0
self.importLevel += 1
if debug: print " " * self.importLevel,
if debug: print "importCodeFromRepository", name
try:
if debug: print " " * self.importLevel,
if debug: print " globals: ", globals
if debug: print " " * self.importLevel,
if debug: print " locals", locals
if debug: print " " * self.importLevel,
if debug: print " fromlist", fromlist
except UnboundLocalError:
if debug: print " " * self.importLevel,
if debug: print "unbound error"
# Fast path: see if the module has already been imported.
# though this is wrong -- as need to check repository if code has been changed
# broken as does not consider fromlist
#try:
# return sys.modules[name]
#except KeyError:
# pass
# check if local module
record = self.repository.findLatestRecordForEntityAttribute(self.contextUUID, name + ".py")
if record:
if debug: print " " * self.importLevel,
if debug: print " Loading from repository"
#file = StringIO.StringIO(record.valueBytes)
#try:
#module = imp.load_source(name, name, file)
#print module
modifiedName = self.contextUUID[7:] + "." + name
modifiedName = modifiedName.replace("-", "_")
if debug: print "modifiedName", modifiedName
if debug: print "sys.module.items", sys.modules.items()
try:
module = sys.modules[modifiedName]
except KeyError:
module = None
# use the latest if this one is not
if module:
if module.__pointrelIdentifier__ != record.identifierString:
module = None
if not module:
file = ByteArrayInputStream(record.valueBytes)
module = imp.load_module(modifiedName, file, modifiedName + ".py", (".py", "r", imp.PY_SOURCE))
module.__pointrelIdentifier__ = record.identifierString
if fromlist:
if debug: print " " * self.importLevel,
if debug: print "processing fromlist"
for fromItemName in fromlist:
if debug: print " " * self.importLevel,
if debug: print "fromitemname", fromItemName
if fromItemName == "*":
for moduleItemName in dir(module):
if debug: print " " * self.importLevel,
if debug: print "moduleItemName", moduleItemName
if moduleItemName[1] != '_':
result = getattr(module, moduleItemName)
#print " " * self.importLevel,
#print "result", result
#print " " * self.importLevel,
#print "globals", globals
globals[moduleItemName] = result
else:
result = getattr(module, fromItemName)
globals[fromItemName] = result
if debug: print "finished set", fromItemName
#finally:
# file.close()
if debug: print " " * self.importLevel,
if debug: print " Done loading"
self.importLevel -= 1
result = module
else:
if debug: print " " * self.importLevel,
if debug: print "default loading", name, fromlist
try:
result = self.oldimport(name, globals, locals, fromlist)
except UnboundLocalError:
# deal with strange Jython error
result = self.oldimport(name)
self.importLevel -= 1
return result
def importFromOtherRepository(self, event):
dialog = FileDialog(self.window, loadOrSave="load")
fileName = dialog.go(PointrelFileTypes)
if not fileName:
return
print "Importing from: ", fileName
self.repository.importRecordsFromAnotherRepository(fileName)
print "Done with import"
self.refreshBrowser()
def exportChooseCurrentFile(self, event):
dialog = FileDialog(self.window, loadOrSave="save")
fileName = dialog.go(PointrelFileTypes)
if not fileName:
return
self.exportFileName = fileName
print "File selected for exports:", self.exportFileName
def exportSelectedRecord(self, event):
if not self.currentRecord:
print "No record selected"
return
oldRecords = [self.currentRecord]
print "Exporting current record to repository %s" % self.exportFileName
repository = Repository(self.exportFileName)
repository.addRecordsFromAnotherRepository(oldRecords)
print "Done"
def exportAllRecordsForSelectedAttribute(self, event):
entityName = self.getCurrentEntityName()
if not entityName:
print "No entity selected"
return
attributeName = self.getCurrentAttributeName()
if not attributeName:
print "No attribute selected"
return
print "Exporting all records for entity '%s' attribute '%s' to repository %s" % (entityName, attributeName, self.exportFileName)
oldRecords = self.repository.findAllRecordsForEntityAttribute(entityName, attributeName)
oldRecords.reverse()
repository = Repository(self.exportFileName)
repository.addRecordsFromAnotherRepository(oldRecords)
print "Done"
def exportLatestRecordsForSelectedEntity(self, event):
entityName = self.getCurrentEntityName()
if not entityName:
print "No entity selected"
return
print "Exporting latest records for all entity '%s' attributes to repository %s" % (entityName, self.exportFileName)
oldRecords = self.repository.findLatestRecordsForAllEntityAttributes(entityName)
oldRecords.reverse()
repository = Repository(self.exportFileName)
repository.addRecordsFromAnotherRepository(oldRecords)
print "Done"
def exportAllRecordsForSelectedEntity(self, event):
entityName = self.getCurrentEntityName()
if not entityName:
print "No entity selected"
return
print "Exporting all records for entity '%s' to repository %s" % (entityName, self.exportFileName)
oldRecords = self.repository.findAllRecordsForEntity(entityName)
oldRecords.reverse()
repository = Repository(self.exportFileName)
repository.addRecordsFromAnotherRepository(oldRecords)
print "Done"
def setCurrentRecord(self, aRecord):
self.currentRecord = aRecord
if aRecord:
self.setCurrentEntityName(aRecord.entity)
self.entityTextField.caretPosition = 0
self.setCurrentAttributeName(aRecord.attribute)
self.attributeTextField.caretPosition = 0
self.setCurrentValueType(aRecord.valueType)
self.currentEditorPanel.setCurrentValueBytes(aRecord.valueBytes)
self.deletedButton.model.setSelected(aRecord.deleted)
else:
entityName = self.entitiesList.selectedValue
if entityName == None:
entityName = ""
self.setCurrentEntityName(entityName)
self.entityTextField.caretPosition = 0
self.setCurrentAttributeName("")
self.setCurrentValueType(DefaultValueType)
self.currentEditorPanel.setCurrentValueBytes("")
self.deletedButton.model.selected = False
def manageSaveButtonColor(self):
if self.isCurrentRecordChanged():
self.saveButton.background = self.changedSaveButtonColor
else:
self.saveButton.background = self.normalSaveButtonColor
def isCurrentRecordChanged(self):
if not self.currentRecord:
if self.getCurrentAttributeName() or self.currentEditorPanel.getCurrentValueBytes():
return True
return False
if self.getCurrentEntityName() != self.currentRecord.entity:
return True
if self.getCurrentAttributeName() != self.currentRecord.attribute:
return True
if self.getCurrentValueType() != self.currentRecord.valueType:
return True
if self.currentEditorPanel.isChangedFromOriginal():
return True
# funky comparison because may be booleans and integers?
# decided not to test as not really linked to save button
#if (self.deletedButton.model.selected and not self.currentRecord.deleted) or (not self.deletedButton.model.selected and self.currentRecord.deleted):
# return True
return False
def deletedPressed(self, event):
deleteFlag = self.deletedButton.model.selected
if self.currentRecord == None:
return
self.repository.deleteOrUndelete(self.currentRecord, self.currentUserReference, deleteFlag=deleteFlag)
if not self.isDeletedViewable():
self.refreshBrowser()
def refreshBrowser(self):
entityName = self.entitiesList.selectedValue
attributeName = self.attributesList.selectedValue
versionName = self.versionsList.selectedValue
self.entitiesListClicked(None, entityName, attributeName, versionName)
def showAllDeletedPressed(self, event):
self.refreshBrowser()
def isDeletedViewable(self):
return self.showAllDeletedButton.model.selected
def savePressed(self, event):
#entityName = self.entitiesList.selectedValue
entityName = self.getCurrentEntityName()
if entityName:
attributeName = self.getCurrentAttributeName()
if attributeName:
attributeValue = self.currentEditorPanel.getCurrentValueBytes()
attributeType = self.getCurrentValueType()
newRecord = self.repository.add(entityName, attributeName, attributeValue, attributeType, self.currentUserReference)
self.setCurrentRecord(newRecord)
self.entitiesListClicked(None, self.entitiesList.selectedValue, attributeName)
# refresh list if changed
if attributeName != self.attributesList.selectedValue:
# ? self.attributesList.model.addElement(attributeName)
# need to select new version
self.entitiesListClicked(None)
def test(self):
print "test OK"
def clearAllEntityNames(self):
self.entitiesList.model.clear()
self.addEntityNameToEntitiesList("root")
def deleteEntityNameFromList(self):
entityName = self.entitiesList.selectedValue
if entityName:
self.entitiesList.model.removeElement(entityName)
def addEntitytNameToList(self):
entityName = JOptionPane.showInputDialog("Enter an entity name: ")
if entityName:
self.addEntityNameToEntitiesList(entityName)
def addAllEntityNamesToList(self, addMeta):
entityNames = self.repository.lastUser.keys()
entityNames.sort()
for entityName in entityNames:
if addMeta or entityName.find("pointrel://tripleID/") != 0:
self.addEntityNameToEntitiesList(entityName)
def entitiesListMousePressed(self, event):
if event.isPopupTrigger():
# options should be a list of (name, function, [arg1, [arg2]]) tuples
options = [
("add to list..", self.addEntitytNameToList),
("delete from list", self.deleteEntityNameFromList),
(None),
("clear", self.clearAllEntityNames),
(None),
("add all except meta", self.addAllEntityNamesToList, False),
("add all", self.addAllEntityNamesToList, True),
]
menu = OptionsCallbackPopupMenu(event.component, event.x, event.y, options)
def entitiesListClicked(self, event, entityName=None, attributeName=None, versionName=None):
if event:
self.setCurrentRecord(None)
if entityName:
self.entitiesList.setSelectedValue(entityName, True)
else:
entityName = self.entitiesList.selectedValue
if entityName:
self.versionsList.model.clear()
model = self.attributesList.model
model.clear()
attributes = self.repository.allAttributesForEntity(entityName, self.isDeletedViewable())
attributes.sort()
for attribute in attributes:
model.addElement(attribute)
if attributeName:
self.attributesList.setSelectedValue(attributeName, True)
self.attributesListClicked(None, versionName)
def attributesListClicked(self, event, versionName=None):
if event:
self.setCurrentRecord(None)
entityName = self.entitiesList.selectedValue
if entityName:
attributeName = self.attributesList.selectedValue
if event:
self.setCurrentAttributeName(attributeName)
if attributeName:
model = self.versionsList.model
model.clear()
versions = self.repository.findAllRecordsForEntityAttribute(entityName, attributeName, self.isDeletedViewable())
for version in versions:
versionDescription = "%s %s" % (version.timestamp, version.userReference)
model.addElement(versionDescription)
selectedRecord = None
if versions:
if versionName == None or not model.contains(versionName):
self.versionsList.selectedIndex = 0
selectedRecord = versions[0]
else:
versionIndex = model.indexOf(versionName)
self.versionsList.selectedIndex = versionIndex
selectedRecord = versions[versionIndex]
self.setCurrentRecord(selectedRecord)
if event and event.clickCount == 2:
self.followResource(self.currentRecord)
else:
self.setCurrentRecord(None)
else:
self.setCurrentRecord(None)
def versionsListClicked(self, event):
entityName = self.entitiesList.selectedValue
if entityName:
attributeName = self.attributesList.selectedValue
if event:
self.setCurrentAttributeName(attributeName)
if attributeName:
index = self.versionsList.selectedIndex
versions = self.repository.findAllRecordsForEntityAttribute(entityName, attributeName, self.isDeletedViewable())
if versions:
versionRecord = versions[index]
self.setCurrentRecord(versionRecord)
if event and event.clickCount == 2:
self.followResource(versionRecord)
else:
self.setCurrentRecord(None)
def followResource(self, record):
if not record:
return
if '\n' in record.valueBytes:
print "not following a resource with a newline"
return
self.addEntityNameToEntitiesList(record.valueBytes)
def addEntityNameToEntitiesList(self, entityName):
self.entitiesList.model.addElement(entityName)
self.entitiesList.selectedIndex = self.entitiesList.model.size() - 1
self.entitiesListClicked(None)
self.setCurrentRecord(None)
class TrackDevice(java.beans.PropertyChangeListener):
import java
import javax.swing
from javax.swing import Timer
delayTimer = None
relayClicks = None
# TrackDevice.init - Initialize a TrackDevice instance for a particular device
#
# aName : Device name
# aDevice : JMRI device instance
# aAllowedStates : Array of states we want to track, other states are ignored
#
def init(self, aName, aDevice, aAllowedStates, aLogFile, aParent):
from javax.swing import Timer
self.DeviceName = aName
self.Device = aDevice
self.DeviceNumber = self.DeviceName[2:self.DeviceName.find(":")]
self.AllowedStates = aAllowedStates
self.parent = aParent
self.DeviceValue = self.AllowedStates[0]
self.LogFile = aLogFile
self.timeoutListener = self.TimeoutReceiver()
self.timeoutListener.setCallBack(self.receiveTimeoutHandler)
self.receiveTimer = Timer(100, self.timeoutListener)
self.receiveTimer.setInitialDelay(10)
self.receiveTimer.stop()
self.receiveTimer.setRepeats(False)
self.sendTimeoutListener = self.TimeoutReceiver2()
self.sendTimeoutListener.setCallBack(self.sendTimeoutHandler)
self.sendTimer = Timer(100, self.timeoutListener)
self.sendTimer.setInitialDelay(10)
self.sendTimer.stop()
self.sendTimer.setRepeats(False)
self.pauseTimeoutListener = self.TimeoutReceiver()
self.pauseTimeoutListener.setCallBack(self.pauseTimeoutHandler)
self.pauseTimer = Timer(100, self.pauseTimeoutListener)
self.pauseTimer.setInitialDelay(10)
self.pauseTimer.stop()
self.pauseTimer.setRepeats(False)
self.finalTimeoutListener = self.TimeoutReceiver()
self.finalTimeoutListener.setCallBack(self.finalTimeoutHandler)
self.finalTimer = Timer(100, self.finalTimeoutListener)
self.finalTimer.setInitialDelay(10)
self.finalTimer.stop()
self.finalTimer.setRepeats(False)
# self.relayClicks = jmri.jmrit.Sound(jmri.util.FileUtil.getExternalFilename("preference:resources/sounds/EnhancedCTCRelayTrimmed.wav"))
self.relayClicks = jmri.jmrit.Sound(
"resources/sounds/Code-receive.wav")
self.relaySend = jmri.jmrit.Sound("resources/sounds/Code-send.wav")
return
# TrackDevice.updateState - Track the device state while reading the old log
# file. Note the state but don't change the device
# itself and don't log the changes to the new log file
# (yet).
#
# aNewState : New device state.
#
def updateState(self, aNewState):
print 'updateState ' + self.DeviceName + " to state = " + aNewState
for i in range(len(self.AllowedStates)):
if (aNewState == self.AllowedStates[i]):
self.DeviceValue = aNewState
self.Device.setValue(aNewState)
break
# TrackDevice.propertyChange - Record state changes as a result of activities
# elsewhere in JMRI
#
# aEvent : Event triggering the change (we don't actually look at the event...)
#
def propertyChange(self, aEvent):
newValue = self.Device.getValue()
print("***** In propertyChange")
memories.getMemory("IM5:TVC").setValue("1")
#
# Turn on Control Code indicator light
codeSendSensor = sensors.getSensor("Code Send Indicator")
codeSendSensor.setState(ACTIVE)
#
# Start relay clicking sound
self.relaySend.loop()
#
# Start timer to keep code send light on and relays clicking for a while.
ccdl = 15 #+ java.util.Random().nextInt(1) # Code transmission delay
self.sendTimer.setDelay(ccdl * 1000)
#self.sendTimer.start()
self.parent.waitMsec(ccdl * 1000)
self.relaySend.stop()
codeSendSensor.setState(INACTIVE)
if (newValue == self.DeviceValue):
return
for i in range(len(self.AllowedStates)):
if (newValue == self.AllowedStates[i]):
self.DeviceValue = newValue
self.LogFile.write(self.DeviceName + " " +
self.DeviceValue + "\n")
self.LogFile.flush()
break
return
# TrackDevice.setInitialDeviceState - After reading all of the old tracking file we
# now initialize the actual devices to their last
# known states and log these states into the new
# log file.
#
def setInitialDeviceState(self, logFile, parent):
# Uncomment the following print statement to display the list of devices being tracked.
print "In setInitDeviceState, name = " + self.DeviceName + " value = " + self.DeviceValue
self.LogFile = logFile
### self.Device.setState(self.DeviceValue)
self.Device.addPropertyChangeListener(self)
#logStateChange2(self.DeviceName, self.DeviceState, False)
logFile.write(self.DeviceName + " " + self.DeviceValue + "\n")
signalId = "IS:" + self.DeviceNumber
# Move the switch lever to the correct position
sensors.getSensor(signalId + ":CB").setState(INACTIVE)
if (self.DeviceValue == "N"):
turnouts.provideTurnout("NT" +
self.DeviceNumber).setState(CLOSED)
self.parent.waitMsec(100)
sensors.getSensor(signalId + ":NK").setState(ACTIVE)
sensors.getSensor(signalId + ":L").setState(ACTIVE)
sensors.getSensor(signalId + ":RK").setState(INACTIVE)
else:
turnouts.provideTurnout("NT" +
self.DeviceNumber).setState(THROWN)
self.parent.waitMsec(100)
sensors.getSensor(signalId + ":NK").setState(INACTIVE)
sensors.getSensor(signalId + ":RK").setState(ACTIVE)
sensors.getSensor(signalId + ":L").setState(INACTIVE)
class TimeoutReceiver(java.awt.event.ActionListener):
cb = None
def actionPerformed(self, event):
if (self.cb != None):
self.cb(event)
return
def setCallBack(self, cbf):
self.cb = cbf
return
class TimeoutReceiver2(java.awt.event.ActionListener):
cb = None
def actionPerformed(self, event):
if (self.cb != None):
self.cb(event)
return
def setCallBack(self, cbf):
self.cb = cbf
return
def sendTimeoutHandler(self, event):
print "In send timeout handler"
self.sendTimer.stop()
self.relaySend.stop()
sensors.getSensor("IS16:CCK").setState(INACTIVE)
smdl = 5 #+ java.util.Random().nextInt(2) # Switch motor delay -
self.pauseTimer.setInitialDelay(smdl * 100)
self.pauseTimer.start()
return
#
# Timeout handler between send & receive.
# Turn panel indicators off & start indication code relay clicks.
def pauseTimeoutHandler(self, event):
self.pauseTimer.stop()
sensors.getSensor("Code Receive Indicator").setState(ACTIVE)
self.relayClicks.loop()
newName = "IS:" + self.DeviceNumber
sensors.getSensor(newName + ":NK").setState(INACTIVE)
sensors.getSensor(newName + ":RK").setState(INACTIVE)
signals.getSignalHead("VH:T" + str(self.DeviceNumber) +
"N").setAppearance(DARK)
signals.getSignalHead("VH:T" + str(self.DeviceNumber) +
"R").setAppearance(DARK)
icdl = 5 #+ java.util.Random().nextInt(3) # Indicator code delay
self.receiveTimer.setInitialDelay(icdl * 100)
self.receiveTimer.start()
return
#
# Final timeout handler....turn off Indication Code relay clicks and change indicator lights on panel.
def receiveTimeoutHandler(self, event):
# see which phase we think we are in
self.receiveTimer.stop()
sensors.getSensor("Code Receive Indicator").setState(INACTIVE)
#
# Throw the turnout. We should do this in an earlier timeout handler, but with the CTC panel lights hardwired to the tortoise motor,
# the lights change too soon.
if (memories.getMemory("IM1:FB").getValue() == 0):
if (self.Device.getValue() == "N"):
turnouts.provideTurnout("NT" +
self.DeviceNumber).setState(CLOSED)
else:
turnouts.provideTurnout("NT" +
self.DeviceNumber).setState(THROWN)
self.finalTimer.setInitialDelay(6000)
self.finalTimer.start()
return
#
# Final timeout handler....turn off Indication Code relay clicks and change indicator lights on panel.
def finalTimeoutHandler(self, event):
# see which phase we think we are in
self.finalTimer.stop()
self.relayClicks.stop()
sensors.getSensor("Code Receive Indicator").setState(INACTIVE)
memories.getMemory("IM5:TVC").setValue("0")
memories.getMemory("IM1:FB").setValue(0)
return
class Example(JFrame, ActionListener):
def __init__(self):
super(Example, self).__init__()
self.initUI()
# Paint all of the objects in screenObjects
def mypaint(self, g):
for object in screenObjects:
object._draw(
g
) #Now calls a _draw method on each object, instead of just having a bunch of lambdas in screenObjects.
# Add an external event on a mouse click
def myclick(self, x, y):
externalEvents['LeftMouseButton'] = SP2(
x, y) #SP2 inherited from pythonfrp StaticNumerics.py
def mykey(self, k):
externalEvents['KeyTyped'] = string(k)
# print("Key Pressed: " + string(k))
def my_move(self, x, y):
mouse_pos[0] = SP2(x, y)
def initUI(self):
self.addKeyListener(KA(lambda k: self.mykey(k)))
self.xp = 0
self.yp = 0
self.canvas = Canvas(lambda g: self.mypaint(g),
lambda x, y: self.myclick(x, y),
lambda x, y: self.my_move(x, y))
self.canvas.setBackground(Color(200, 200, 200))
self.getContentPane().add(self.canvas)
self.setTitle("Test")
self.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE)
self.setSize(500, 500)
self.setLocationRelativeTo(None)
self.setBackground(Color(255, 255, 255))
self.setVisible(True)
self.timer = Timer(50, self)
self.timer.start()
# This is the heartbeat handling code - this is attached to a timer in the frame
def actionPerformed(self, e):
currentTime = System.currentTimeMillis()
rSide = random.randrange(0, 4)
if ((currentTime - startTime[0]) % 5 == 0):
if (rSide == 0):
(circle(p2(random.randrange(50, 450), -30 + localTime * 100),
10))
elif (rSide == 1):
(circle(p2(500 - localTime * 100, random.randrange(50, 450)),
10))
elif (rSide == 2):
(circle(p2(random.randrange(50, 450), 500 - localTime * 100),
10))
else:
(circle(p2(-30 + localTime * 100, random.randrange(50, 450)),
10))
del screenObjects[:]
# print(currentTime-startTime[0])
# print('Objects: ' + str(Globals.worldObjects))
heartbeat((currentTime - startTime[0]) / 1000.0, externalEvents)
externalEvents.clear()
self.repaint()
class Board(JPanel, KeyListener, ActionListener):
def __init__(self):
super(Board, self).__init__()
self.initUI()
def initUI(self):
self.setBackground(Color.black)
iid = ImageIcon("dot.png")
self.ball = iid.getImage()
iia = ImageIcon("apple.png")
self.apple = iia.getImage()
iih = ImageIcon("head.png")
self.head = iih.getImage()
self.setFocusable(True)
self.addKeyListener(self)
self.initGame()
def initGame(self):
self.left = False
self.right = True
self.up = False
self.down = False
self.inGame = True
self.dots = 3
for i in range(self.dots):
x[i] = 50 - i * 10
y[i] = 50
self.locateApple()
self.timer = Timer(DELAY, self)
self.timer.start()
def paint(self, g):
# due to bug, cannot call super()
JPanel.paint(self, g)
if self.inGame:
self.drawObjects(g)
else:
self.gameOver(g)
def drawObjects(self, g):
g.drawImage(self.apple, self.apple_x, self.apple_y, self)
for z in range(self.dots):
if (z == 0):
g.drawImage(self.head, x[z], y[z], self)
else:
g.drawImage(self.ball, x[z], y[z], self)
Toolkit.getDefaultToolkit().sync()
g.dispose()
def gameOver(self, g):
msg = "Game Over"
small = Font("Helvetica", Font.BOLD, 14)
metr = self.getFontMetrics(small)
g.setColor(Color.white)
g.setFont(small)
g.drawString(msg, (WIDTH - metr.stringWidth(msg)) / 2, HEIGHT / 2)
def checkApple(self):
if x[0] == self.apple_x and y[0] == self.apple_y:
self.dots = self.dots + 1
self.locateApple()
def move(self):
z = self.dots
while z > 0:
x[z] = x[(z - 1)]
y[z] = y[(z - 1)]
z = z - 1
if self.left:
x[0] -= DOT_SIZE
if self.right:
x[0] += DOT_SIZE
if self.up:
y[0] -= DOT_SIZE
if self.down:
y[0] += DOT_SIZE
def checkCollision(self):
z = self.dots
while z > 0:
if z > 4 and x[0] == x[z] and y[0] == y[z]:
self.inGame = False
z = z - 1
if y[0] > HEIGHT - DOT_SIZE:
self.inGame = False
if y[0] < 0:
self.inGame = False
if x[0] > WIDTH - DOT_SIZE:
self.inGame = False
if x[0] < 0:
self.inGame = False
def locateApple(self):
r = random.randint(0, RAND_POS)
self.apple_x = r * DOT_SIZE
r = random.randint(0, RAND_POS)
self.apple_y = r * DOT_SIZE
# public void actionPerformed(ActionEvent e) {
def actionPerformed(self, e):
if self.inGame:
self.checkApple()
self.checkCollision()
self.move()
else:
self.timer.stop()
self.repaint()
def keyPressed(self, e):
key = e.getKeyCode()
if key == KeyEvent.VK_LEFT and not self.right:
self.left = True
self.up = False
self.down = False
if key == KeyEvent.VK_RIGHT and not self.left:
self.right = True
self.up = False
self.down = False
if key == KeyEvent.VK_UP and not self.down:
self.up = True
self.right = False
self.left = False
if key == KeyEvent.VK_DOWN and not self.up:
self.down = True
self.right = False
self.left = False
class WiimoteThrottle2(Jynstrument, PropertyChangeListener, AddressListener, WiiDeviceDiscoveryListener, WiiRemoteListener, Runnable):
#Jynstrument main and mandatory methods
def getExpectedContextClassName(self):
return "jmri.jmrit.throttle.ThrottleWindow"
def init(self):
self.getContext().addPropertyChangeListener(self) #ThrottleFrame change
self.addressPanel=self.getContext().getCurrentThrottleFrame().getAddressPanel();
self.addressPanel.addAddressListener(self) # change of throttle in Current frame
self.throttle = self.getContext().getCurrentThrottleFrame().getAddressPanel().getThrottle() # the throttle
self.speedAction = SpeedAction() #Speed increase thread
self.speedAction.setThrottle( self.throttle )
self.speedTimer = Timer(valueSpeedTimerRepeat, self.speedAction ) # Very important to use swing Timer object (see Swing and multithreading doc)
self.speedTimer.setRepeats(True)
self.label = JButton(ImageIcon(self.getFolder() + "/WiimoteThrottle2.png","WiiMote")) #label
self.label.addMouseListener(self.getMouseListeners()[0]) # In order to get the popupmenu on the button too
self.add(self.label)
self.lastTimeButton1 = Calendar.getInstance().getTimeInMillis()
self.lastTimeButton2 = Calendar.getInstance().getTimeInMillis()
self.advFunctions = AdvFunctions()
self.lastTimeEStop = Calendar.getInstance().getTimeInMillis()
self.wiiDevice = None
self.sync = thread.allocate_lock() # A lock protecting bellow self.evt
self.evt = None
java.lang.System.setProperty("bluecove.jsr82.psm_minimum_off", "true"); # Required for Bluecove + WiiRemoteJ
WiiRemoteJ.findRemotes(self, 1) # Search for 1 Wiimote, and call back
def quit(self):
self.speedTimer.stop()
WiiRemoteJ.stopFind()
if ((self.wiiDevice != None) and (self.wiiDevice.isConnected())):
self.wiiDevice.removeWiiRemoteListener(self)
self.wiiDevice.disconnect()
self.wiiDevice = None
self.speedAction = None
self.speedTimer = None
self.throttle = None
self.advFunctions = None
self.getContext().removePropertyChangeListener(self)
self.addressPanel.removeAddressListener(self)
self.addressPanel = None
#Wiimote discoverer events
def findFinished(self, nb):
print "Search finished, found ",nb ," wiimotes"
def wiiDeviceDiscovered(self, evt):
print "Found a Wiimote, number: ", evt.getNumber()
self.wiiDevice = evt.getWiiDevice()
ledLights = [False, False, False, False]
ledLights[evt.getNumber()%4] = True
self.wiiDevice.setLEDLights(ledLights)
self.wiiDevice.addWiiRemoteListener(self)
#Wiimote events
def buttonInputReceived(self, evt):
# print("Wiimote Button event: ", evt)
self.sync.acquire()
self.evt = evt
self.sync.release()
SwingUtilities.invokeLater(self) # Delegate processing to Swing thread (when we are here, we're in the WiiRemoteJ driver thread)
def run(self):
self.sync.acquire()
evt = self.evt
self.sync.release()
if (self.speedTimer != None):
self.speedTimer.stop() # In any case
# ThrottleFrames
if ( evt.wasReleased(WRButtonEvent.RIGHT) ): # NEXT
self.getContext().nextThrottleFrame()
if ( evt.wasReleased(WRButtonEvent.LEFT) ): # PREVIOUS
self.getContext().previousThrottleFrame()
if ( evt.wasReleased(WRButtonEvent.UP) ): # NEXT RUNNING
self.getContext().nextRunningThrottleFrame()
if ( evt.wasReleased(WRButtonEvent.DOWN) ): # PREVIOUS RUNNING
self.getContext().previousRunningThrottleFrame()
# No throttle assigned to current frame, browse through roster
if (self.throttle == None):
if (evt.wasReleased(WRButtonEvent.HOME) ): # Assign selected roster entry
self.addressPanel.selectRosterEntry()
return
if ( evt.wasReleased(WRButtonEvent.PLUS) ): # Next roster entry
selectedIndex = self.addressPanel.getRosterSelectedIndex()
self.addressPanel.setIcon(False)
self.addressPanel.setVisible(True)
self.addressPanel.setRosterSelectedIndex(selectedIndex + 1)
return
if ( evt.wasReleased(WRButtonEvent.MINUS) ): # Previous roster entry
selectedIndex = self.addressPanel.getRosterSelectedIndex()
self.addressPanel.setIcon(False)
self.addressPanel.setVisible(True)
self.addressPanel.setRosterSelectedIndex(selectedIndex - 1)
return
# Throttle assigned to current frame, control it
if (self.throttle != None):
# Speed control
if ( evt.isPressed(WRButtonEvent.B) ): # SPEED - increment
self.speedAction.setSpeedIncrement( valueSpeedIncrement )
self.speedTimer.start()
if ( evt.isPressed(WRButtonEvent.A) ): # SPEED - decrement
self.speedAction.setSpeedIncrement( -valueSpeedIncrement )
self.speedTimer.start()
# EStop
if ( evt.isPressed( WRButtonEvent.PLUS | WRButtonEvent.MINUS ) ): # estop = + & -
self.throttle.setSpeedSetting( speedEStopSpeed )
self.lastTimeEStop = Calendar.getInstance().getTimeInMillis() # To cancel next inputs
self.wiiDevice.vibrateFor(750)
# Directions
if ( evt.wasReleased(WRButtonEvent.PLUS) ): # FORWARD
self.throttle.setIsForward(True)
if ( evt.wasReleased(WRButtonEvent.MINUS) ): # BACKWARD
self.throttle.setIsForward(False)
# Home : F0
if ( evt.wasReleased(WRButtonEvent.HOME) ): # LIGHTS
if not ((self.addressPanel.getRosterEntry() != None) and (self.advFunctions.call(self.addressPanel.getRosterEntry(), "0", False, self.throttle) != None)):
self.throttle.setF0( not self.throttle.getF0() )
# Wiimote 1 & 2 buttons
if (evt.isPressed(WRButtonEvent.ONE)):
if not ((self.addressPanel.getRosterEntry() != None) and (self.advFunctions.call(self.addressPanel.getRosterEntry(), "1", True, self.throttle) != None)):
pass # default F1 not momentary (switch only on Release, do nothing here)
if (evt.wasReleased(WRButtonEvent.ONE)):
if not ((self.addressPanel.getRosterEntry() != None) and (self.advFunctions.call(self.addressPanel.getRosterEntry(), "1", False, self.throttle) != None)):
self.throttle.setF1( not self.throttle.getF1() ) # default F1 not momentary
if (evt.isPressed(WRButtonEvent.TWO)):
if not ((self.addressPanel.getRosterEntry() != None) and (self.advFunctions.call(self.addressPanel.getRosterEntry(), "2", True, self.throttle) != None)):
self.throttle.setF2( True ) # default F2 momentary
if (evt.wasReleased(WRButtonEvent.TWO)):
if not ((self.addressPanel.getRosterEntry() != None) and (self.advFunctions.call(self.addressPanel.getRosterEntry(), "2", False, self.throttle) != None)):
self.throttle.setF2( False )
def disconnected(self):
self.wiiDevice = None
print("Lost wiimote")
def accelerationInputReceived(self, evt):
pass
def combinedInputReceived(self, evt):
pass
def extensionConnected(self, extension):
pass
def extensionDisconnected(self, extension):
pass
def extensionInputReceived(self, evt):
pass
def extensionPartiallyInserted(self):
pass
def extensionUnknown(self):
pass
def IRInputReceived(self, evt):
pass
def statusReported(self, evt):
print("Wiimote status reported: ", evt)
#Property listener part
def propertyChange(self, event):
self.speedTimer.stop()
if (event.propertyName == "ThrottleFrame") : # Current throttle frame changed
event.oldValue.getAddressPanel().removeAddressListener(self)
self.addressPanel = event.newValue.getAddressPanel()
self.throttle = self.addressPanel.getThrottle()
self.speedAction.setThrottle( self.throttle )
self.addressPanel.addAddressListener(self)
#AddressListener part: to listen for address changes in address panel (release, acquired)
def notifyAddressChosen(self, address):
pass
def notifyAddressThrottleFound(self, throttle):
self.speedTimer.stop()
self.throttle = throttle
self.speedAction.setThrottle( self.throttle )
def notifyAddressReleased(self, address):
self.speedTimer.stop()
self.throttle = None
self.speedAction.setThrottle( self.throttle )
def notifyConsistAddressChosen(self, address, isLong):
self.notifyAddressChosen(address)
def notifyConsistAddressThrottleFound(self, throttle):
self.notifyAddressThrottleFound(throttle)
def notifyConsistAddressReleased(self, address, isLong):
self.notifyAddressReleased(address)
