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 _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 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)