jython/RobotThrottle3.py
# This script runs a loco around the track, controlling the speed
# according to signals and following the blocks.
#
# Author: Ken Cameron, copyright 2009,2010
# Part of the JMRI distribution
#
# The start button is inactive until data has been entered.
#
# The test button is to force re-evaluation of all block and signal values.
#
# If the loco id isn't showing in the block table, do a 'stop'/'start the
# run' to reestablish the loco position.
#
# Notes:
# 1. This script expects a fully developed set of blocks and signals
# to exist.
# 2. Best way for that is using the 'Layout Editor' to develop the
# configuration.
# 3. However, on turnouts, the non-throat (frog) ends of the turnout should
# not have a track segment attached, the block boundary must be the
# turnout anchor point. The throat end (points) may have additional
# track segments in the same block as the turnout.
# 4. The layout must be laid out like a CTC type panel, meaning string line
# left to right across the panel. If you need to have multiple lines
# to build the whole layout place a track segment of the same block
# at the end of the first line and the start of the next line and
# use a 'hidden' track segment (same block) to connect
# those track segments.
# 5. The script keys off the loco id being passed from block to block
# by the block manager. If you have detector issues and the blocks
# falsely cycle, this may not work. You may have to add internal
# sensors to 'buffer' these false cycles using Logix to clean
# things up.
# 6. FIXED: You no longer need usernames for everything. It will use
# system or user names depending on what you have in your panel.
# 7. If you create memory values and memory labels on your panel and
# tie them to the blocks, you will always see the loco id displayed.
# That is the block value that the script is looking for when
# tracking the loco.
# NEW FOR Version 2
# 8. It now has options for a rate of speed (still needs the matching
# throttle setting) for speeds to compute stopping. But it only uses
# this for stopping on approach to a red signal. When this is added as
# an 'autopilot' to the throttle interface, it will consider more of
# these inputs. A zero in the rate will cause it to ignore it.
# 9. If the blocks have the length set (and the rate above) it will try
# to delay stopping in a red block until 80% into the block.
# NEW FOR Version 3
# 10. Requires the length of blocks be known. In turn it computes the
# fastest speed that will stop within the next two blocks based
# on the most restrictive speeds that may be in the next blocks.
#
# Still needing work:
# 1. Improve the method for 'findNextBlock' as it currently uses the
# direction from the current block. To work for 'physically designed'
# panels, it would need to focus on the connectivity of the blocks
# more and less on the direction attributes. It currently fails
# if a block transitioned more than 90 degrees within a single
# block.
# 2. Add option to delay halting if it looses sight of the loco.
# This may help some layouts where the detection 'blinks' out
# for a few seconds due to dirt etc...
# Currently you must use something like 'DebounceSensor.py' if you
# have sensors that don't hold due to the above.
# 3. Learn about the neat features the 'operations' data is adding.
# This would help with knowing lengths of trains, grades of track,
# etc to aid in controlling how to stop within a block.
#
# Changes:
# 07/23/2009 - Added a Halt button that tries to -1 the throttle to
# stop now and not be smooth. Plus a few other fixes
# like the system vs user name thing.
#
# 08/30/2009 - Added methods so this can be run from a master script
# for running mulitple throttles. Also improved many
# reliblity issues in the code.
#
# Much thanks go to the Medina Railroad Museum who was asked for
# something to help out when they have larger number of visitors
# and few staff but want the trains to run around without taking
# staff to keep them from running into each other. What started
# as a simple request grew into this script. I am planning on
# turning it into real code as a next step.
# http://railroadmuseum.net/
#
# Portions of this script are taken from a number of scripts
# by Bob Jacobsen
#
# A AbstractAutomaton is used to get a throttle and run the loco.
#
# A PropertyChangeListener is used to report block information.
# It could have been with AbstractAutomaton but this allows for
# independent action with a block change.
#
# Same thing for also watching signals.
#
# A WindowListener is used to report when the window is closing and
# allow for the removal of the PropertyChangeListener.
#
import jmri
import java
import java.awt
import java.awt.event
import java.beans
import java.util
import javax.swing
import java.util.Calendar
HighDebug = 3
MediumDebug = 2
LowDebug = 1
NoneDebug = 0
# set up a throttle with the loco address
class LocoThrot(jmri.jmrit.automat.AbstractAutomaton) :
# initialize variables
locoAddress = None
currentBlock = None
currentDirection = jmri.Path.NONE
currentBlocks = []
currentNextBlocks = []
next1Block = None
next2Block = None
next3Block = None
priorBlocks = []
priornext1Blocks = []
priorSignal = None
priorSignalAspect = None
currentSignal = None
currentSignalAspect = None
nearSignal = None
nearSignalAspect = None
next1Signal = None
next1SignalAspect = None
next2Signal = None
next2SignalAspect = None
isRunning = False
isStarting = False
isAborting = True
currentThrottle = None
scriptFrame = None
scriptFrameOldX = None
scriptFarmeOldY = None
listenerBlocks = []
listenerBlockListeners = []
listenerSignals = []
listenerSignalListeners = []
greenSignalIcon = None
greenFlashSignalIcon = None
yellowSignalIcon = None
yellowFlashSignalIcon = None
redSignalIcon = None
redFlashSignalIcon = None
darkSignalIcon = None
unknownSignalIcon = None
speedChangeTimer = None
speedChangeListener = None
shrinkGrow = True
fullScrollRows = 15
speedPane = None
rosterInstance = None
oldLocoAddress = None
didWeMoveCounter = 0
holdMoving = False
stopBlock = None
hornDelayTimer = None
hornDelayListener = None
throttleManager = None
askChangeThrottle = False
askFinishStartButton = False
methodLocoAddress = None
methodBlockDirection = None
methodLocoDirection = None
methodLocoHeadlight = None
methodShortHorn = None
methodLongHorn = None
methodBlockStart = None
methodPushShrink = None
methodPushStart = None
methodPushStop = None
methodPushTest = None
methodBlockStop = None
methodlocoDistRed = None
haltOnSignalHeadAppearance = YELLOW
debugLevel = LowDebug
movementDetected = False
def init(self):
#print("start begin:.\n")
self.setName("RT3: no loco")
self.setup()
#print("start end:.\n")
return
def handle(self):
if (self.isAborting == True) :
return 0
#self.msgText("handle begin:.")
self.waitMsec(100)
if (self.askChangeThrottle) :
self.getNewThrottle()
self.askChangeThrottle = False
if (self.askFinishStartButton) :
self.doFinishStartButton()
self.askFinishStartButton = False
if (self.methodLocoAddress != None) :
self.locoAddress.text = self.methodLocoAddress
self.methodLocoAddress = None
self.whenLocoChanged(self)
if (self.methodBlockDirection != None) :
if (self.methodBlockDirection == True) :
self.blockDirection.setSelected(True)
else :
self.blockDirection.setSelected(False)
self.methodBlockDirection = None
self.whenLocoChanged(self)
if (self.methodLocoDirection != None) :
if (self.methodLocoDirection == True) :
self.locoForward.setSelected(True)
else :
self.locoForward.setSelected(False)
self.methodLocoDirection = None
self.whenLocoChanged(self)
if (self.methodLocoHeadlight != None) :
if (self.methodLocoHeadlight == True) :
self.locoHeadlight.setSelected(True)
else :
self.locoHeadlight.setSelected(False)
self.methodLocoHeadlight = None
self.whenLocoHeadlight(self)
if (self.methodShortHorn != None) :
self.methodShortHorn = None
self.doShortHorn()
if (self.methodLongHorn != None) :
self.methodLongHorn = None
self.doLongHorn()
if (self.methodBlockStart != None) :
self.blockStart.text = self.methodBlockStart
self.methodBlockStart = None
self.whenLocoChanged(self)
if (self.methodPushShrink != None) :
self.methodPushShrink = None
self.whenShrinkButtonClicked(self)
if (self.stopButton.isEnabled() == True and self.methodPushStop != None) :
self.methodPushStop = None
self.whenStopButtonClicked(self)
if (self.testButton.isEnabled() == True and self.methodPushTest != None) :
self.methodPushTest = None
self.callBackForDidWeMove(self)
if (self.startButton.isEnabled() == True and self.methodPushStart != None) :
self.methodPushStart = None
self.whenStartButtonClicked(self)
if (self.methodBlockStop != None) :
self.blockStop.text = self.methodBlockStop
self.methodBlockStop = None
self.whenStopBlockChanged(self)
if (self.methodlocoDistRed != None) :
self.locoDistRed.text = self.methodlocoDistRed
self.methodlocoDistRed = None
self.whenLocoChanged(self)
# This handles tracking how many overlapping events happened
# and insures we run the didWeMove the right number of times
if ((self.didWeMoveCounter > 0 and self.holdMoving == False) or self.isStarting == True) :
#self.msgText("didWeMoveCounterCheck: " + str(self.didWeMoveCounter) + " - calling didWeMove")
self.didWeMove()
self.didWeMoveCounter = 0
#self.msgText("didWeMoveCounterCheck: decremented counter down to " + str(self.didWeMoveCounter))
#self.msgText("handle done")
return 1 #continue if 1, run once if 0
# allow changes of a signal dropping on the appearance to trigger halting
def setSignalAppearanceHalt(self, signalIndication) :
self.haltOnSignalHeadAppearance = signalIndication
return
# show what level of signal appearance causes a halt on dropping signal
def returnSignalAppearanceHalt(self) :
return(str(self.haltOnSignalHeadAppearance))
def getNewThrottle(self) :
self.holdMoving = True
if (self.currentThrottle != None) :
oldId = self.currentThrottle.getLocoAddress()
if (self.debugLevel >= LowDebug) :
self.msgText("stop and release the current loco: " + str(oldId))
self.doStop();
self.currentThrottle.release(None)
self.currentThrottle = None
if (self.debugLevel >= LowDebug) :
self.msgText("Throttle " + str(oldId) + " released")
if (self.debugLevel >= LowDebug) :
self.msgText("Getting throttle") #add text to scroll field
id = int(self.locoAddress.text)
if (self.throttleManager.addressTypeUnique() == True) :
if (self.debugLevel >= HighDebug) :
self.msgText("id values are not ambiguous")
isLong = self.throttleManager.canBeLongAddress(id)
else :
if (self.debugLevel >= LowDebug) :
self.msgText("id values are ambiguous")
isLong = True
if (self.throttleManager.canBeShortAddress(id)) :
if (self.debugLevel >= LowDebug) :
self.msgText("id could be a short.")
if (self.locoLong.isSelected() == False) :
isLong = False
if (self.debugLevel >= LowDebug) :
self.msgText("Getting throttle " + str(id) + " " + str(isLong))
throttle = self.getThrottle(id, isLong)
self.currentThrottle = throttle
if (self.currentThrottle == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("Couldn't assign throttle! - Run stopped")
self.doHalt()
else :
if (self.debugLevel >= LowDebug) :
self.msgText("got throttle: " + str(self.currentThrottle.getLocoAddress()))
self.currentThrottle.setIsForward(self.locoForward.isSelected())
self.currentThrottle.setF0(self.locoHeadlight.isSelected())
self.currentThrottle.setF1(self.locoBell.isSelected())
self.holdMoving = False
return
# return userName if available, else systemName
def giveBlockName(self, block) :
if (block == None) :
return 'None'
else :
if ((block.getUserName() == None) or (block.getUserName() == '')) :
return block.getSystemName()
else :
return block.getUserName()
# return userName if available, else systemName
def giveSignalName(self, sig) :
if (sig == None) :
return 'None'
else :
if ((sig.getUserName() == None) or (sig.getUserName() == '')) :
return sig.getSystemName()
else :
return sig.getUserName()
# return userName if available, else systemName
def giveTurnoutName(self, to) :
if (to == None) :
return 'None'
else :
if ((to.getUserName() == None) or (to.getUserName() == '')) :
return to.getSystemName()
else :
return to.getUserName()
# return userName if available, else systemName
def giveSensorName(self, sen) :
if (sen == None) :
return 'None'
else :
if ((sen.getUserName() == None) or (sen.getUserName() == '')) :
return sen.getSystemName()
else :
return sen.getUserName()
# Isolate the callback handling from the didWeMove processing
# this makes dealing with multiple events simpler
def callBackForDidWeMove(self, event) :
self.didWeMoveCounter = self.didWeMoveCounter + 1
if (self.debugLevel >= HighDebug) :
self.msgText("callBackForDidWeMove(" + str(event) + ")")
self.msgText("counter = " + str(self.didWeMoveCounter))
# the handle() will invoke the didWeMove() as needed
return
# figure out if we moved and where
def didWeMove(self) :
self.movementDetected = False
if (self.debugLevel >= HighDebug) :
self.msgText("didWeMove start: " + self.giveBlockName(self.currentBlock) + ":" + self.giveBlockName(self.next1Block))
if (self.currentThrottle == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("didWeMove called while currentThrottle was None")
return
# allow for a 2nd try. In case the id in block didn't move, but we hit the next signal
# try reading the blocks one more time in case we now see that we did move.
tryCount = 0
tryCountLimit = 2
while (tryCount < tryCountLimit) :
tryCount = tryCount + 1
if (self.debugLevel >= HighDebug) :
if (self.currentBlock != None) :
self.msgText("Current block: " + self.giveBlockName(self.currentBlock))
newCurrentBlocks = self.findCurrentBlocks()
if (len(newCurrentBlocks) == 0) :
self.msgText("Can't find loco!! Doing halt!!")
self.doHalt()
# new current block must be farthest connected to current block in current direction chain
oldCurrent = self.currentBlock
oldSignal = self.currentSignal
oldnext1Signal = self.next1Signal
oldnext2Signal = self.next2Signal
oldAspect = self.currentSignalAspect
oldFarAspect = self.next1SignalAspect
oldnext2Block = self.next1Block
tryBlock = self.currentBlock
nearSignal = None
next1Signal = None
next2Signal = None
newCurrent = None
watchSignal = None
giveUpTimer = 0
while (giveUpTimer < 10) :
giveUpTimer = giveUpTimer + 1
newCurrent = self.findNewCurrentBlock(tryBlock, newCurrentBlocks, self.currentDirection)
if (newCurrent == None) :
newBlockText = "None"
else :
newBlockText = self.giveBlockName(newCurrent)
#self.msgText("try " + str(giveUpTimer) + " " + self.giveBlockName(tryBlock) + " " + newBlockText)
if ((newCurrent == tryBlock) or (newCurrent == None)) :
break
else :
tryBlock = newCurrent
if (self.debugLevel >= MediumDebug) :
self.msgText("tryBlock: " + self.giveBlockName(tryBlock) + " oldCurrent: " + self.giveBlockName(oldCurrent) + " isStarting: " + str(self.isStarting))
if (tryBlock != oldCurrent or self.isStarting == True) :
# we did move somewhere
self.blockNow.text = " "
self.blockNowLength.text = " "
self.blockNext.text = " "
self.blockNextLength.text = " "
self.blockBeyond.text = " "
self.blockBeyondLength.text = " "
self.stopDistance.text = "0"
self.stopDistanceForSpeed.text = "0"
self.currentBlock = tryBlock
self.blockStart.text = self.giveBlockName(self.currentBlock)
self.blockNow.text = self.giveBlockName(self.currentBlock)
self.blockNowLength.text = str(self.currentBlock.getLengthIn())
self.next1Block = self.findNextBlock(self.currentBlock)
self.next2Block = None
self.next3Block = None
self.testAddBlockListener(self.currentBlock)
if (self.next1Block != None) :
self.blockNext.text = self.giveBlockName(self.next1Block)
self.blockNextLength.text = str(self.next1Block.getLengthIn())
self.stopDistance.text = str(float(self.stopDistance.text) + self.next1Block.getLengthIn())
self.testAddBlockListener(self.next1Block)
self.next2Block = self.findNextBlock(self.next1Block)
if (self.next2Block != None) :
self.blockBeyond.text = self.giveBlockName(self.next2Block)
self.blockBeyondLength.text = str(self.next2Block.getLengthIn())
self.stopDistance.text = str(float(self.stopDistance.text) + self.next2Block.getLengthIn())
self.testAddBlockListener(self.next2Block)
self.next3Block = self.findNextBlock(self.next2Block)
self.priorBlock = oldCurrent
self.priorBlocks = self.currentBlocks
# find signals from currentBlock
if (self.currentBlock != None and self.next1Block != None) :
nearSignal = jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager).getFacingSignalHead(self.currentBlock, self.next1Block)
if (nearSignal != None) :
self.testAddSignalListener(nearSignal)
if (self.debugLevel >= MediumDebug) :
self.msgText("finding nearSignal between " + self.giveBlockName(self.currentBlock) + " and " + self.giveBlockName(self.next1Block) + " found " + self.giveSignalName(nearSignal))
if (self.next1Block != None and self.next2Block != None) :
next1Signal = jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager).getFacingSignalHead(self.next1Block, self.next2Block)
if (next1Signal != None) :
self.testAddSignalListener(next1Signal)
if (self.debugLevel >= MediumDebug) :
self.msgText("finding next1Signal between " + self.giveBlockName(self.next1Block) + " and " + self.giveBlockName(self.next2Block) + " found " + self.giveSignalName(next1Signal))
if (self.next2Block != None and self.next3Block != None) :
next2Signal = jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager).getFacingSignalHead(self.next2Block, self.next3Block)
if (next2Signal != None) :
self.testAddSignalListener(next2Signal)
if (self.debugLevel >= MediumDebug) :
self.msgText("finding next2Signal between " + self.giveBlockName(self.next2Block) + " and " + self.giveBlockName(self.next3Block) + " found " + self.giveSignalName(next2Signal))
if (self.blockAhead2.isSelected() == False) :
if (self.debugLevel >= HighDebug) :
self.msgText("3 block test: " + self.giveBlockName(self.currentBlock))
if (nearSignal != None) :
watchSignal = nearSignal
else :
if (next1Signal != None) :
watchSignal = next1Signal
else :
if (next2Signal != None) :
watchSignal = next2Signal
else :
if (self.debugLevel >= MediumDebug) :
self.msgText("4 block test: " + self.giveBlockName(self.next1Block))
if (next1Signal != None) :
watchSignal = next1Signal
else :
if (next2Signal != None) :
watchSignal = next2Signal
# if we didn't find a signal, treat as RED
if (watchSignal == None) :
watchAspect = RED
else :
watchAspect = watchSignal.getAppearance()
# if we moved or the signal head changed or the aspect changed
if (self.debugLevel >= MediumDebug) :
self.msgText("test blocks: " + self.giveBlockName(oldCurrent) + ":" + self.giveBlockName(self.currentBlock) + ":" + self.giveBlockName(self.next1Block))
self.msgText("test signals: " + self.giveSignalName(oldSignal) + ":" + self.giveSignalName(watchSignal))
self.msgText("test aspects: " + self.textSignalAspect(oldAspect) + ":" + self.textSignalAspect(watchAspect))
# set flag is we just moved, needed for some timer controls
if oldCurrent != self.currentBlock :
self.movementDetected = True
if (self.movementDetected or oldSignal != watchSignal or oldAspect != watchAspect or self.isStarting == True) :
# something changed, we calc the new speed
if (oldCurrent == self.currentBlock and oldSignal == watchSignal and self.compareSignalAspects(oldAspect, watchAspect) < 0 and self.isStarting == False) :
# signal dropped, that's bad
if (self.debugLevel >= LowDebug) :
self.msgText("signal dropped, same signal being watched.")
if (self.compareSignalAspects(self.haltOnSignalHeadAppearance, watchAspect) >= 0) : # Only stop on dropping below this
self.findNewSpeed(self.currentBlock, self.next1Block, watchSignal)
else :
self.msgText("Signal dropped in front of train. Halting!!")
if (tryCount < tryCountLimit) :
if (self.debugLevel >= LowDebug) :
self.msgText("Doing change retry: " + str(tryCount))
continue
else :
self.doHalt()
else :
if (self.debugLevel >= LowDebug) :
self.msgText("We moved, signal or aspect changed.")
self.findNewSpeed(self.currentBlock, self.next1Block, watchSignal)
else :
if (self.debugLevel >= MediumDebug) :
self.msgText("nothing changed to effect speed")
# this is for display updates
if (nearSignal != None) :
self.signalNext.setIcon(self.cvtAppearanceIcon(nearSignal))
self.signalNextText.text = self.giveSignalName(nearSignal)
else :
self.signalNext.setIcon(None)
self.signalNextText.text = ""
if (next1Signal != None) :
self.signalBeyond.setIcon(self.cvtAppearanceIcon(next1Signal))
self.signalBeyondText.text = self.giveSignalName(next1Signal)
self.next1SignalAspect = next1Signal.getAppearance()
else :
self.signalBeyond.setIcon(None)
self.signalBeyondText.text = ""
if (next2Signal != None) :
self.next2SignalAspect = next2Signal.getAppearance()
self.nearSignal = nearSignal
self.next1Signal = next1Signal
self.next2Signal = next2Signal
# we passed normal, so don't repeat
tryCount = tryCountLimit
# if we have a stop block
if (self.stopBlock != None and self.currentBlock == self.stopBlock) :
if (self.currentThrottle.getSpeedSetting() == 0) :
if (self.debugLevel >= LowDebug) :
self.msgText("Found stop block, doing stop.")
self.doStop()
self.isStarting = False
self.releaseExtraListeners()
#self.msgText("didMove: done")
return
# check lists of block and signal listeners and release ones not needed
def releaseExtraListeners(self) :
numBlocksL = len(self.listenerBlockListeners)
numBlocks = len(self.listenerBlocks)
#self.msgText("start with Blocks: " + str(numBlocks) + " Listeners: " + str(numBlocksL))
if (numBlocksL != numBlocks or numBlocksL <= 0 or numBlocks <= 0) :
# blocks out of sync, stop and take it from the top
if (self.debugLevel >= LowDebug) :
self.msgText("Block lists out of sync! Blocks: " + str(numBlocks) + " Listeners: " + str(numBlocksL))
self.doHalt()
self.releaseBlockListParts()
else :
while (numBlocks > 0) :
numBlocks = numBlocks - 1
testBlock = self.listenerBlocks[numBlocks]
#self.msgText("testing block: " + self.giveBlockName(testBlock))
if (testBlock != None) :
if (testBlock != self.currentBlock) :
if (testBlock != self.next1Block) :
if (testBlock != self.next2Block) :
#self.msgText("we don't need block: " + self.giveBlockName(testBlock))
l = self.listenerBlockListeners[numBlocks]
testBlock.removePropertyChangeListener(l)
self.listenerBlockListeners.pop(numBlocks)
self.listenerBlocks.pop(numBlocks)
numSignals = len(self.listenerSignals)
numSignalsL = len(self.listenerSignalListeners)
#self.msgText("starting Signals: " + str(numSignals) + " Listeners:" + str(numSignalsL))
if (numSignals != numSignalsL or numSignalsL <= 0 or numSignals <= 0) :
if (self.debugLevel >= LowDebug) :
self.msgText("Signal lists out of sync! Signals: " + str(numSignals) + " Listeners:" + str(numSignalsL))
self.doHalt()
self.releaseSignalListParts()
else :
while (numSignals > 0) :
numSignals = numSignals - 1
testSignal = self.listenerSignals[numSignals]
#self.msgText("releaseExtraListeners() testing signal: " + self.giveSignalName(testSignal))
if (testSignal != self.currentSignal and testSignal != self.nearSignal and testSignal != self.next1Signal and testSignal != self.next2Signal) :
if (self.debugLevel >= MediumDebug) :
self.msgText("releaseExtraListeners() releasing: " + self.giveSignalName(testSignal))
l = self.listenerSignalListeners[numSignals]
testSignal.removePropertyChangeListener(l)
self.listenerSignalListeners.pop(numSignals)
self.listenerSignals.pop(numSignals)
#self.msgText("num signalListeners: " + str(len(self.listenerSignalListeners)) + " " + str(len(self.listenerSignals)))
return
# return true if thing is in thingList
def isInList(self, thing, thingList) :
found = False
for b in thingList :
if (b == thing) :
found = True
return found
# see if block is in the listenerBlocks, add listener if not
def testAddBlockListener(self, bk) :
if (self.isInList(bk, self.listenerBlocks) == False) :
# isn't in list, setup listener and add to list
bl = self.BlockListener()
bl.setCallBack(self.callBackForDidWeMove)
bk.addPropertyChangeListener(bl)
self.listenerBlocks.append(bk)
self.listenerBlockListeners.append(bl)
return
# see if signal is in the listenerSignals, add listener if not
def testAddSignalListener(self, sig) :
if (self.isInList(sig, self.listenerSignals) == False) :
# isn't in list, setup listener and add to list
sl = self.SignalListener()
sl.setCallBack(self.callBackForDidWeMove)
sig.addPropertyChangeListener(sl)
self.listenerSignals.append(sig)
self.listenerSignalListeners.append(sl)
if (self.debugLevel >= MediumDebug) :
self.msgText("testAddSignalListener(" + self.giveSignalName(sig) + ")")
return
# release signal listeners and clean lists
def releaseSignalListParts(self) :
while(len(self.listenerSignals) > 0) :
s = self.listenerSignals.pop(0)
l = self.listenerSignalListeners.pop(0)
if (self.debugLevel >= MediumDebug) :
self.msgText("releasing listener for signal " + self.giveSignalName(s))
s.removePropertyChangeListener(l)
return
# release block listeners and clean lists
def releaseBlockListParts(self) :
while(len(self.listenerBlocks) > 0) :
b = self.listenerBlocks.pop(0)
l = self.listenerBlockListeners.pop(0)
#self.msgText("releasing listener for block " + self.giveBlockName(b))
b.removePropertyChangeListener(l)
return
# release all listeners, part of the exit cleanup
def releaseAllListeners(self, event) :
self.releaseSignalListParts()
self.releaseBlockListParts()
if (self.speedChangeTimer != None) :
for i in self.speedChangeTimer.getActionListeners() :
self.speedChangeTimer.removeActionListener(i)
if (self.hornDelayTimer != None) :
for i in self.hornDelayTimer.getActionListeners() :
self.hornDelayTimer.removeActionListener(i)
if (self.currentThrottle != None) :
#self.msgText("releasing throttle")
self.currentThrottle.setSpeedSetting(0)
self.currentThrottle.release(None)
self.isAborting = True
return
# take list of new current blocks, a current block, and a current direction
# return new current block at edge of current blocks
def findNewCurrentBlock(self, cBlock, cList, cDir) :
nBlock = None
dMask = jmri.Path.EAST | jmri.Path.WEST
if (self.debugLevel >= HighDebug) :
self.msgText("dmask: " + str(dMask) + " orig cDir: " + str(cDir))
cDir = cDir & dMask # only looking for east/west
if (self.debugLevel >= HighDebug) :
self.msgText(" filtered cDir: " + str(cDir) + " currentDirection: " + str(self.currentDirection))
if (cDir == jmri.Path.NONE) :
if (self.blockDirection.isSelected() == True) :
cDir = jmri.Path.EAST
else :
cDir = jmri.Path.WEST
if (cBlock == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("findNewCurrentBlock: bad current block passed!")
return None
if (len(cList) <= 0) :
if (self.debugLevel >= LowDebug) :
self.msgText("findNewCurrentBlock: empty cList")
else :
pList = cBlock.getPaths()
for p in pList :
pB = p.getBlock()
if (p.checkPathSet()) :
dirTest = p.getToBlockDirection() & dMask
if (self.debugLevel >= MediumDebug) :
self.msgText("findNewCurrentBlock: testing for " + jmri.Path.decodeDirection(cDir) + " from " + self.giveBlockName(cBlock) + " to " + self.giveBlockName(pB) + " pointing " + jmri.Path.decodeDirection(dirTest))
if ((cDir & dirTest) == cDir) :
for c in cList :
if (c == pB) :
nBlock = pB
if (self.debugLevel >= MediumDebug) :
self.msgText("findNewCurrentBlock found " + self.giveBlockName(pB))
break
else :
if (self.debugLevel >= MediumDebug) :
self.msgText("findNewCurrentBlock not in cList: " + self.giveBlockName(c))
if (nBlock != None) :
break
else :
if (self.debugLevel >= MediumDebug) :
self.msgText("findNewCurrentBlock path not traversable: " + self.giveBlockName(cBlock) + " to " + self.giveBlockName(pB))
return nBlock
# figure out signal names and decide speeds
def findNewSpeed(self, cBlock, nBlock, wSig) :
if (self.isRunning) :
if (cBlock == None) :
if (nBlock == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("Failed to find either blocks")
self.doHalt()
else :
if (self.debugLevel >= LowDebug) :
self.msgText("Failed to find current block")
self.doHalt()
else :
if (nBlock == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("next block doesn't exist, treating as red.")
self.speedFromAppearance(RED)
self.priorSignal = self.currentSignal
self.priorSignalAspect = self.currentSignalAspect
self.currentSignal = None
self.currentSignalAspect = RED
self.next1Signal = None
self.next1SignalAspect = RED
else :
useAspect = RED
if (wSig != None) :
if (self.debugLevel >= LowDebug) :
self.msgText("Found currentSignal: " + self.giveSignalName(wSig) + " displaying: " + self.cvtAppearanceText(wSig))
useAspect = wSig.getAppearance()
if (self.useStopFromDistance.isSelected() == True) :
stopDistAspect = self.speedFromStopDistance()
signalRank = self.rankSignalAspect(signalAspect)
stopDistRank = self.rankSignalAspect(stopDistAspect)
if (stopDistRank >= signalRank) :
useAspect = signalAspect
else :
useAspect = stopDistAspect
self.speedFromAppearance(useAspect)
self.priorSignal = self.currentSignal
self.priorSignalAspect = self.currentSignalAspect
self.currentSignal = wSig
self.currentSignalAspect = wSig.getAppearance()
else :
self.msgText("Failed finding signal!")
self.doHalt()
return
# return rate from signal aspect
def rateFromSignalAspect(self, sigAspect) :
ret = 0
txt = "UNKNOWN"
try :
if (sigAspect & RED != 0) :
txt = "RED"
ret = float(self.locoRateRed.text)
elif (sigAspect & FLASHRED != 0) :
txt = "FLASHRED"
ret = float(self.locoRateRedFlash.text)
elif (sigAspect & YELLOW != 0) :
txt = "YELLOW"
ret = float(self.locoRateYellow.text)
elif (sigAspect & FLASHYELLOW != 0) :
txt = "FLASHYELLOW"
ret = float(self.locoRateYellowFlash.text)
elif (sigAspect & GREEN != 0) :
txt = "GREEN"
ret = float(self.locoRateGreen.text)
elif (sigAspect & FLASHGREEN != 0) :
txt = "FLASHGREEN"
ret = float(self.locoRateGreenFlash.text)
except ValueError :
if (self.debugLevel >= LowDebug) :
self.msgText("rateFromSignalAspect: no value for aspect " + txt)
if (self.debugLevel >= MediumDebug) :
self.msgText("rateFromSignalAspect(" + self.textSignalAspect(sigAspect) + "): " + str(ret))
return ret
# convert signal appearance to a ranked value
def rankSignalAspect(self, sigAspect) :
ret = 0
if (sigAspect & RED != 0) :
ret = 1
elif (sigAspect & FLASHRED != 0) :
ret = 2
elif (sigAspect & YELLOW != 0) :
ret = 3
elif (sigAspect & FLASHYELLOW != 0) :
ret = 4
elif (sigAspect & GREEN != 0) :
ret = 5
elif (sigAspect & FLASHGREEN != 0) :
ret = 6
return ret
# return speed change distance sum for rank change
def rankSpeedChangeDistance(self, rankOld, rankNew) :
ret = 0
if (rankOld >= 1 and rankNew <= 1) :
ret = ret + float(self.locoDistRed.text)
if (rankOld >= 2 and rankNew <= 2) :
ret = ret + float(self.locoDistRedFlash.text)
if (rankOld >= 3 and rankNew <= 3) :
ret = ret + float(self.locoDistYellow.text)
if (rankOld >= 4 and rankNew <= 4) :
ret = ret + float(self.locoDistYellowFlash.text)
if (rankOld >= 5 and rankNew <= 5) :
ret = ret + float(self.locoDistGreen.text)
if (rankOld >= 6 and rankNew <= 6) :
ret = ret + float(self.locoDistGreenFlash.text)
if (self.debugLevel >= MediumDebug) :
self.msgText("rankSpeedChangeDistance(" + str(rankOld) + ", " + str(rankNew) + "): " + str(ret))
return ret
# convert signal appearance to text
def textSignalAspect(self, sigAspect) :
ret = "???"
if (sigAspect == None) :
ret = "None"
elif (sigAspect & RED != 0) :
ret = "RED"
elif (sigAspect & FLASHRED != 0) :
ret = "FLASHRED"
elif (sigAspect & YELLOW != 0) :
ret = "YELLOW"
elif (sigAspect & FLASHYELLOW != 0) :
ret = "FLASHYELLOW"
elif (sigAspect & GREEN != 0) :
ret = "GREEN"
elif (sigAspect & FLASHGREEN != 0) :
ret = "FLASHGREEN"
return ret
# compare two signal appearances
def compareSignalAspects(self, oldSigState, newSigState) :
ret = "0"
if (newSigState == None) :
# this is wrong
if (self.debugLevel >= LowDebug) :
self.msgText("compare signals got a None for new signal state")
self.doHalt()
return
if (oldSigState == None) :
# startup case
ret = 1
else :
newSigValue = self.rankSignalAspect(newSigState)
oldSigValue = self.rankSignalAspect(oldSigState)
#self.msgText("compareSignalAspects: " + self.textSignalAspect(oldSigState) + " went " + self.textSignalAspect(newSigState))
if (newSigValue < oldSigValue) :
ret = -1
elif (newSigValue > oldSigValue) :
ret = 1
return ret
# set speed from signal appearance. update stopDistanceForSpeed with distance and return aspect to match.
def speedFromStopDistance(self) :
distLimit = float(self.stopDistance.text)
speedAspect = RED
stopDistance = 0
next = float(self.locoDistRed.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = RED
next = float(self.locoDistRedFlash.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = FLASHRED
next = float(self.locoDistYellow.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = YELLOW
next = float(self.locoDistYellowFlash.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = FLASHYELLOW
next = float(self.locoDistGreen.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = GREEN
next = float(self.locoDistGreenFlash.text)
distLimit = distLimit - next
if (distLimit >= 0) :
stopDistance = stopDistance + next
speedAspect = FLASHGREEN
if (self.debugLevel >= MediumDebug) :
self.msgText("speedFromStopDistance() " + str(stopDistance) + " " + self.cvtAspectToText(speedAspect))
self.stopDistanceForSpeed.text = str(stopDistance)
return speedAspect
# set speed from signal appearance
def speedFromAppearance(self, sigState) :
rep = ""
if (sigState == RED or self.currentBlock == self.stopBlock) :
rep = rep + "doRed "
self.doSpeedRed()
elif (sigState == FLASHRED) :
rep = rep + "doRedFlash "
self.doSpeedRedFlash()
elif (sigState == YELLOW or self.next1Block == self.stopBlock) :
rep = rep + "doYellow "
self.doSpeedYellow()
elif (sigState == FLASHYELLOW) :
rep = rep + "doYellowFlash "
self.doSpeedYellowFlash()
elif (sigState == GREEN) :
rep = rep + "doGreen "
self.doSpeedGreen()
elif (sigState == FLASHGREEN) :
rep = rep + "doGreenFlash "
self.doSpeedGreenFlash()
else :
rep = rep + "unknown "
self.msgText("speedFromAppearance, unknown value! " + str(sigState))
self.doHalt()
#self.msgText("speedFromAppearance: " + self.giveSignalName(sig) + " displaying: " + self.cvtAppearanceText(sig) + " so we did: " + rep)
return
# convert signal appearance to english
def cvtAppearanceText(self, sig) :
rep = ""
if (sig.getHeld()) :
rep = rep + "Held "
if (sig.getLit()) :
rep = rep + "Lit "
rep = rep + self.cvtAspectToText(sig.getAppearance())
#self.msgText("cvtAppearanceText: " + self.giveSignalName(sig) + " displaying: " + rep)
return rep
# convert signal appearance to english
def cvtAspectToText(self, sigState) :
rep = ""
if (sigState == RED) :
rep = rep + "Red "
elif (sigState == FLASHRED) :
rep = rep + "Flashing Red "
elif (sigState == YELLOW) :
rep = rep + "Yellow "
elif (sigState == FLASHYELLOW) :
rep = rep + "Flashing Yellow "
elif (sigState == GREEN) :
rep = rep + "Green "
elif (sigState == FLASHGREEN) :
rep = rep + "Flashing Green "
elif (sigState == DARK) :
rep = rep + "Dark "
else :
rep = rep + "Unknown "
#self.msgText("cvtAppearanceText: " + self.giveSignalName(sig) + " displaying: " + rep)
return rep
# convert signal appearance to icon
def cvtAppearanceIcon(self, sig) :
rep = self.darkSignalIcon
if (sig.getLit()) :
sigState = sig.getAppearance()
if (sigState == RED) :
rep = self.redSignalIcon
elif (sigState == FLASHRED) :
rep = self.redFlashSignalIcon
elif (sigState == YELLOW) :
rep = self.yellowSignalIcon
elif (sigState == FLASHYELLOW) :
rep = self.yellowFlashSignalIcon
elif (sigState == GREEN) :
rep = self.greenSignalIcon
elif (sigState == FLASHGREEN) :
rep = self.greenFlashSignalIcon
else :
rep = self.unknownSignalIcon
#self.msgText("cvtAppearanceIcon: " + self.giveSignalName(sig) + " displaying: " + rep)
return rep
# compare two lists, reply true or false
def compareLists(self, aList, bList) :
if (self.debugLevel >= HighDebug) :
self.msgText("comparing lists")
doesMatchA = True
doesMatchB = True
for a in aList :
try :
i = bList.index(a)
except :
doesMatchA = False
if (doesMatchA) :
if (self.debugLevel >= HighDebug) :
self.msgText("comparing lists: all of a in b")
for b in bList :
try :
i = aList.index(b)
except :
doesMatchB = False
if (doesMatchB) :
if (self.debugLevel >= HighDebug) :
self.msgText("comparing lists: all of b in a")
return doesMatchA and doesMatchB
def doSpeedGreenFlash(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
i = 0
try :
i = int(self.locoSpeedGreenFlash.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedGreenFlash: Invalid value! " + self.locoSpeedGreenFlash.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedGreenFlash: " + str(i))
self.locoSpeed.text = str(100 * i)
return
def doSpeedGreen(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
i = 0
try :
i = int(self.locoSpeedGreen.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedGreen: Invalid value! " + self.locoSpeedGreen.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedGreen: " + str(i))
self.locoSpeed.text = str(100 * i)
return
def doSpeedYellowFlash(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
i = 0
try :
i = int(self.locoSpeedYellowFlash.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedYellowFlash: Invalid value! " + self.locoSpeedYellowFlash.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedYellowFlash: " + str(i))
self.locoSpeed.text = str(100 * i)
return
def doSpeedYellow(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
doYellowNow = True
if (self.movementDetected) :
# compute how long to delay speed change
dist = self.currentBlock.getLengthIn()
rate = self.rateFromSignalAspect(FLASHGREEN)
speedChgDist = self.rankSpeedChangeDistance(self.rankSignalAspect(FLASHGREEN), self.rankSignalAspect(FLASHYELLOW))
if (self.priorSignalAspect != None) :
rate = self.rateFromSignalAspect(self.priorSignalAspect)
speedChgDist = self.rankSpeedChangeDistance(self.rankSignalAspect(self.priorSignalAspect), self.rankSignalAspect(FLASHYELLOW))
if (dist > 0 and rate > 0) :
# the delay distance is the reserved space plus 10% from far end of block
# the less one covers the delay of the handle() routine
delay = (((dist* 0.90) - speedChgDist) / rate ) - 1
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedYellow: dist: " + str(dist) + " rate: " + str(rate) + " speedChgDist: " + str(speedChgDist) + " delay: " + str(delay))
if (delay > 1) :
currentDelay = 0
if (self.speedChangeTimer == None) :
if (self.speedChangeListener == None) :
self.speedChangeListener = self.SpeedChangeTimeoutReceiver()
self.speedChangeTimer = javax.swing.Timer(int(delay * 0), self.speedChangeListener)
self.speedChangeTimer.setInitialDelay(int(delay * 1000))
self.speedChangeTimer.setRepeats(False);
self.speedChangeListener.setCallBack(self.yellowDelayHandler)
self.speedChangeTimer.setInitialDelay(int(delay * 1000))
self.speedChangeTimer.start()
doYellowNow = False
else :
if (self.debugLevel >= LowDebug) :
self.msgText("yellow delay less that 1 second")
if (doYellowNow) :
i = 0
try :
i = int(self.locoSpeedYellow.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedYellow: Invalid value! " + self.locoSpeedYellow.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedYellow: " + str(i))
self.locoSpeed.text = str(100 * i)
return
def doSpeedRedFlash(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
i = 0
try :
i = int(self.locoSpeedRedFlash.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedRedFlash: Invalid value! " + self.locoSpeedRedFlash.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedRedFlash: " + str(i))
self.locoSpeed.text = str(100 * i)
return
def doSpeedRed(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None and self.currentThrottle.getSpeedSetting() != 0) :
i = 0
try :
i = int(self.locoSpeedRed.text) * 0.01
except :
if (self.debugLevel >= NoneDebug) :
self.msgText("doSpeedRed: Invalid value! " + self.locoSpeedRed.text)
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedRed: " + str(i))
self.locoSpeed.text = str(100 * i)
# compute how long to delay stopping
dist = self.currentBlock.getLengthIn()
rate = float(self.locoRateRed.text)
stopDist = float(self.locoDistRed.text)
if (self.priorSignalAspect != None) :
stopDist = self.rankSpeedChangeDistance(self.rankSignalAspect(self.priorSignalAspect), self.rankSignalAspect(RED))
if (self.movementDetected == True and dist != 0 and rate != 0) :
# the stop distance is the reserved space plus 10% from far end of block
# the less one covers the delay of the handle() routine
delay = ((dist - stopDist) / rate * 0.90) - 1
if (self.debugLevel >= LowDebug) :
self.msgText("doSpeedRed: dist: " + str(dist) + " rate: " + str(rate) + " stopDist: " + str(stopDist) + " delay: " + str(delay))
if (delay > 1) :
currentDelay = 0
if (self.speedChangeTimer == None) :
if (self.speedChangeListener == None) :
self.speedChangeListener = self.SpeedChangeTimeoutReceiver()
self.speedChangeTimer = javax.swing.Timer(int(delay * 0), self.speedChangeListener)
self.speedChangeTimer.setInitialDelay(int(delay * 1000))
self.speedChangeTimer.setRepeats(False);
self.speedChangeListener.setCallBack(self.redDelayHandler)
self.speedChangeTimer.setInitialDelay(int(delay * 1000))
self.speedChangeTimer.start()
else :
if (self.debugLevel >= LowDebug) :
self.msgText("stop delay less that 1 second")
self.doStop()
else :
self.doStop()
return
# handle the timeout for slowing to yellow
def yellowDelayHandler(self, event) :
if (self.debugLevel >= MediumDebug) :
self.msgText("yellowDelayHandler: slow to yellow now!")
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
i = int(self.locoSpeedYellow.text) * 0.01
self.currentThrottle.setSpeedSetting(i)
if (self.debugLevel >= MediumDebug) :
self.msgText("yellowDelayHandler: " + str(i))
self.locoSpeed.text = self.locoSpeedYellow.text
return
# handle the timeout for stopping on red
def redDelayHandler(self, event) :
if (self.debugLevel >= MediumDebug) :
self.msgText("redDelayHandler, stopping now!")
self.speedChangeTimer.stop()
self.doStop()
return
# stopping for normal issues, allows for restarting automaticly
def doStop(self):
if (self.speedChangeTimer != None) :
self.speedChangeTimer.stop()
if (self.currentThrottle != None) :
self.currentThrottle.setSpeedSetting(0)
if (self.debugLevel >= LowDebug) :
self.msgText("doStop")
self.locoSpeed.text = "0"
if (self.currentBlock != None) :
self.blockStart.text = self.giveBlockName(self.currentBlock)
if (self.stopBlock != None and self.currentBlock == self.stopBlock) :
self.handleHalting()
return
# doHalt is for stopping due to error conditions, won't restart
def doHalt(self) :
if (self.currentThrottle != None) :
self.currentThrottle.setSpeedSetting(-1)
self.msgText("doHalt, something was in error!!")
self.locoSpeed.text = "0"
if (self.currentBlock != None) :
self.blockStart.text = self.giveBlockName(self.currentBlock)
self.handleHalting()
self.msgText("*** Run halted ***")
return
# deal with the buttons and stuff when we wait for humans
def handleHalting(self) :
self.stopButton.setEnabled(False)
self.haltButton.setEnabled(False)
self.startButton.setEnabled(True)
self.isRunning = False
return
# process the stop block
def whenStopBlockChanged(self, event) :
self.blockStop.text = self.blockStop.text.strip()
if (self.blockStop.text == "") :
self.stopBlock = None
else :
self.stopBlock = blocks.getBlock(self.blockStop.text)
return
# validate loco values
def whenLocoFieldChanged(self, event) :
isBad = False
ptr = event.getSource()
msg = "whenLocoFieldChanged: " + ptr.getName() + " - "
try :
i = int(ptr.text)
if (i < 0 or i > 9999) :
msg = msg + "Loco id out of range: " + ptr.text
ptr.text = str(i)
msg = msg + ptr.text
except :
isBad = True
msg = msg + "Invalid loco value: " + ptr.text
ptr.text = ""
if (isBad) or (self.debugLevel >= MediumDebug) :
self.msgText(msg)
return
# validate speed values
def whenSpeedFieldChanged(self, event) :
isBad = False
ptr = event.getSource()
msg = "whenSpeedFieldChanged: " + ptr.getName() + " - "
i = 0
try :
i = int(ptr.text)
ptr.text = str(i)
msg = msg + ptr.text
except ValueError :
isBad = True
msg = msg + "Invalid speed value: " + ptr.text
ptr.text = ""
if (i < 0) :
isBad = True
msg = msg + "Negitive value for speed: " + ptr.text
ptr.text = ""
if (i > 100) :
isBad = True
msg = msg + "Too large value for speed: " + ptr.text
ptr.text = ""
if (isBad) or (self.debugLevel >= MediumDebug) :
self.msgText(msg)
return
# validate distance values
def whenDistanceFieldChanged(self, event) :
isBad = False
ptr = event.getSource()
msg = "whenDistanceFieldChanged: " + ptr.getName() + " - "
f = 0
try :
f = float(round(float(ptr.text) * 100) / 100.00)
ptr.text = str(f)
msg = msg + ptr.text
except ValueError :
isBad = True
msg = msg + "Invalid distance value: " + ptr.text
ptr.text = ""
if (f < 0) :
isBad = True
msg = msg + "Negitive value for distance: " + ptr.text
ptr.text = ""
if (isBad) or (self.debugLevel >= MediumDebug) :
self.msgText(msg)
return
# enable the button when OK
def whenLocoChanged(self, event) :
# keep track of whether both fields have been changed
if (self.isRunning) :
self.doStop()
if (self.debugLevel >= LowDebug) :
self.msgText("whenLocoChanged: was running, now stopped")
isOk = True
startBlock = None
self.locoAddress.text = self.locoAddress.text.strip()
if (self.locoAddress.text == "") :
isOk = False
else :
self.scriptFrame.setTitle("Run Loco " + self.locoAddress.text)
self.setName("RT3: " + self.locoAddress.text)
if (self.locoAddress.text != self.oldLocoAddress) :
# clear old block assignments
self.clearLocoFromBlocks(self.oldLocoAddress)
self.oldLocoAddress = self.locoAddress.text
if (self.loadFromRoster.isSelected() == True) :
# take the loco id and try looking up values in roster
if (self.rosterInstance == None) :
self.rosterInstance = jmri.jmrit.roster.Roster.getDefault()
if (self.debugLevel >= MediumDebug) :
self.msgText("got roster instance")
rosterEntries = self.rosterInstance.matchingList(None, None, self.locoAddress.text, None, None, None, None)
if (self.debugLevel >= MediumDebug) :
self.msgText("found " + str(rosterEntries.size()) + " entries matching |" + str(id) + "|")
for ent in rosterEntries :
if (self.debugLevel >= LowDebug) :
self.msgText("posible entries: " + ent.fileName)
if (rosterEntries.size() == 1) :
ent = rosterEntries.get(0)
if (self.debugLevel >= LowDebug) :
self.msgText("Reading roster: " + ent.fileName)
v = ent.getAttribute('RT_locoSpeedGreenFlash')
if (v != None and v.strip() != "") :
self.locoSpeedGreenFlash.text = v.strip()
v = ent.getAttribute('RT_locoRateGreenFlash')
if (v != None and v.strip() != "") :
self.locoRateGreenFlash.text = v.strip()
v = ent.getAttribute('RT_locoDistGreenFlash')
if (v != None and v.strip() != "") :
self.locoDistGreenFlash.text = v.strip()
v = ent.getAttribute('RT_locoSpeedGreen')
if (v != None and v.strip() != "") :
self.locoSpeedGreen.text = v.strip()
v = ent.getAttribute('RT_locoRateGreen')
if (v != None and v.strip() != "") :
self.locoRateGreen.text = v.strip()
v = ent.getAttribute('RT_locoDistGreen')
if (v != None and v.strip() != "") :
self.locoDistGreen.text = v.strip()
v = ent.getAttribute('RT_locoSpeedYellowFlash')
if (v != None and v.strip() != "") :
self.locoSpeedYellowFlash.text = v.strip()
v = ent.getAttribute('RT_locoRateYellowFlash')
if (v != None and v.strip() != "") :
self.locoRateYellowFlash.text = v.strip()
v = ent.getAttribute('RT_locoDistYellowFlash')
if (v != None and v.strip() != "") :
self.locoDistYellowFlash.text = v.strip()
v = ent.getAttribute('RT_locoSpeedYellow')
if (v != None and v.strip() != "") :
self.locoSpeedYellow.text = v.strip()
v = ent.getAttribute('RT_locoRateYellow')
if (v != None and v.strip() != "") :
self.locoRateYellow.text = v.strip()
v = ent.getAttribute('RT_locoDistYellow')
if (v != None and v.strip() != "") :
self.locoDistYellow.text = v.strip()
v = ent.getAttribute('RT_locoSpeedRedFlash')
if (v != None and v.strip() != "") :
self.locoSpeedRedFlash.text = v.strip()
v = ent.getAttribute('RT_locoRateRedFlash')
if (v != None and v.strip() != "") :
self.locoRateRedFlash.text = v.strip()
v = ent.getAttribute('RT_locoDistRedFlash')
if (v != None and v.strip() != "") :
self.locoDistRedFlash.text = v.strip()
v = ent.getAttribute('RT_locoSpeedRed')
if (v != None and v.strip() != "") :
self.locoSpeedRed.text = v.strip()
v = ent.getAttribute('RT_locoRateRed')
if (v != None and v.strip() != "") :
self.locoRateRed.text = v.strip()
v = ent.getAttribute('RT_locoDistRed')
if (v != None and v.strip() != "") :
self.locoDistRed.text = v.strip()
self.locoLong.setSelected(ent.isLongAddress())
if (self.debugLevel >= LowDebug) :
self.msgText("Read completed: " + ent.fileName)
self.oldLocoAddress = self.locoAddress.text
if (self.locoSpeedRed.text == "") :
isOk = False
if (self.locoSpeedRedFlash.text == "") :
isOk = False
if (self.locoSpeedYellow.text == "") :
isOk = False
if (self.locoSpeedYellowFlash.text == "") :
isOk = False
if (self.locoSpeedGreen.text == "") :
isOk = False
if (self.locoSpeedGreenFlash.text == "") :
isOk = False
self.blockStart.text = self.blockStart.text.strip()
if (self.blockStart.text == "") :
isOk = False
else :
startBlock = blocks.getBlock(self.blockStart.text)
if (self.testIfBlockNameValid(self.blockStart.text) == False) :
if (self.debugLevel >= LowDebug) :
self.msgText("Invalid block name: " + self.blockStart.text + " please try again")
isOk = False
else:
if (startBlock.getState() != ACTIVE) :
if (self.debugLevel >= LowDebug) :
self.msgText("Block: " + self.blockStart.text + " is not occupied!")
isOk = False
if (isOk) :
# clear id from any existing blocks
for b in blocks.getNamedBeanSet() :
if (b != blocks.getBlock(self.blockStart.text) and b.getValue() == self.locoAddress.text) :
b.setValue("")
if (self.blockDirection.isSelected()) :
self.currentDirection = jmri.Path.EAST
else :
self.currentDirecion = jmri.Path.WEST
self.startButton.setEnabled(True)
self.haltButton.setEnabled(True)
self.testAddBlockListener(blocks.getBlock(self.blockStart.text))
if (self.debugLevel >= LowDebug) :
self.msgText("Enabled Start")
return
# handle the Move Green button on
def whenLocoMoveOnGreen(self, event) :
self.doLocoMove(event, int(self.locoSpeedGreen.text) * 0.01)
return
# handle the Move Yellow button on
def whenLocoMoveOnYellow(self, event) :
self.doLocoMove(event, int(self.locoSpeedYellow.text) * 0.01)
return
# handle the Move Red button on
def whenLocoMoveOnRed(self, event) :
self.doLocoMove(event, int(self.locoSpeedRed.text) * 0.01)
return
# handle the Move button off
def whenLocoMoveOff(self, event) :
self.doLocoMove(event, 0)
return
def doLocoMove(self, event, state) :
if (self.currentThrottle != None) :
wasState = self.currentThrottle.getSpeedSetting()
self.currentThrottle.setSpeedSetting(state)
if (self.debugLevel >= LowDebug) and (state != wasState) :
self.msgText("changed speed to: " + str(state) + " was " + str(wasState))
return
# handle the horn button on
def whenLocoHornOn(self, event) :
self.doLocoHorn(event, True)
return
# handle the horn button off
def whenLocoHornOff(self, event) :
self.doLocoHorn(event, False)
return
def doLocoHorn(self, event, state) :
if (self.currentThrottle != None) :
wasState = self.currentThrottle.getF2()
self.currentThrottle.setF2(state)
if (self.debugLevel >= HighDebug) :
self.msgText("changed horn to: " + str(state) + " was " + str(wasState))
return
def doShortHorn(self) :
self.doTimedHorn(1*1000)
return
def doLongHorn(self) :
self.doTimedHorn(2*1000)
return
def doTimedHorn(self, delay) :
if (self.currentThrottle != None) :
self.currentThrottle.setF2(True)
if (self.hornDelayTimer == None) :
self.hornDelayListener = self.HornTimeoutReceiver()
self.hornDelayListener.setCallBack(self.hornDelayHandler)
self.hornDelayTimer = javax.swing.Timer(int(delay), self.hornDelayListener)
self.hornDelayTimer.setInitialDelay(int(delay))
self.hornDelayTimer.setRepeats(False);
self.hornDelayTimer.setInitialDelay(int(delay))
self.hornDelayTimer.start()
if (self.debugLevel >= HighDebug) :
self.msgText("Started Timed Horn")
return
def hornDelayHandler(self, event) :
if (self.hornDelayTimer != None) :
self.hornDelayTimer.stop()
if (self.currentThrottle != None) :
self.currentThrottle.setF2(False)
if (self.debugLevel >= HighDebug) :
self.msgText("Stopped Timed Horn")
return
# handle the Headlight button
def whenLocoHeadlight(self, event) :
if (self.currentThrottle != None) :
wasState = self.currentThrottle.getF0()
state = self.locoHeadlight.isSelected()
self.currentThrottle.setF0(state)
if (self.debugLevel >= HighDebug) :
self.msgText("changed light to: " + str(state) + " was " +str( wasState))
return
# handle the Bell button
def whenLocoBell(self, event) :
if (self.currentThrottle != None) :
wasState = self.currentThrottle.getF1()
state = self.locoBell.isSelected()
self.currentThrottle.setF1(state)
if (self.debugLevel >= HighDebug) :
self.msgText("changed bell to: " + str(state) + " was " + str(wasState))
return
# test for block name
def testIfBlockNameValid(self, userName) :
foundStart = False
b = blocks.getByUserName(userName)
if (b != None and self.giveBlockName(b) == userName) :
foundStart = True
return foundStart
# define what button does when clicked and attach that routine to the button
def whenStartButtonClicked(self, event) :
self.msgText("Run started") # add text
if (self.testIfBlockNameValid(self.blockStart.text) == False) :
if (self.debugLevel >= LowDebug) :
self.msgText("Invalid block name: " + self.blockStart.text + " please try again")
else :
c = blocks.getBlock(self.blockStart.text)
if (c == None) :
if (self.debugLevel >= LowDebug) :
self.msgText("Invalid block name: " + self.blockStart.text + " please try again")
else :
# clear any prior block entries
self.clearLocoFromBlocks(self.locoAddress.text)
c.setValue(self.locoAddress.text)
self.currentBlock = c
self.priorSignal = None
self.priorSignalAspect = None
self.currentSignal = None
self.currentSignalAspect = None
self.next1Block = None
self.next1Signal = None
self.next1SignalAspect = None
# set flags so things get done from handle() routine
self.askChangeThrottle = True
self.askFinishStartButton = True
if (self.debugLevel >= MediumDebug) :
self.msgText("whenStartButtonClicked, done") # add text
return
# split out so it can happen from the handle() routine
def doFinishStartButton(self) :
if (self.debugLevel >= MediumDebug) :
self.msgText("Change button states") # add text
self.stopButton.setEnabled(True)
self.haltButton.setEnabled(True)
self.startButton.setEnabled(False)
self.isRunning = True
self.isStarting = True
self.currentBlocks = None
self.priorBlocks = None
if (self.blockDirection.isSelected() == True) :
self.currentDirection = jmri.Path.EAST
self.currentBlock.setDirection(jmri.Path.EAST)
else :
self.currentDirection = jmri.Path.WEST
self.currentBlock.setDirection(jmri.Path.WEST)
self.didWeMoveCounter = self.didWeMoveCounter + 1
if (self.isRunning) :
if (self.debugLevel >= LowDebug) :
self.msgText("Starting current:" + self.giveBlockName(self.currentBlock))
return
def whenStopButtonClicked(self, event):
if (self.debugLevel >= MediumDebug) :
self.msgText("Slow loco to stop") # add text
self.doStop()
if (self.debugLevel >= LowDebug) :
self.msgText("*** Run stopped ***")
self.stopButton.setEnabled(False)
self.handleHalting()
self.whenLocoChanged(event)
return
def whenHaltButtonClicked(self, event):
if (self.debugLevel >= LowDebug) :
self.msgText("Button Halt loco NOW!") # add text
self.doHalt()
if (self.debugLevel >= LowDebug) :
self.msgText("*** Run halted ***")
self.handleHalting()
self.whenLocoChanged(event)
return
def whenLocoDirectionButtonClicked(self, event) :
if (self.debugLevel >= MediumDebug) :
self.msgText("Button Loco Direction clicked")
if (self.currentThrottle != None) :
self.currentThrottle.setIsForward(self.locoForward.isSelected())
return
def whenBlockDirectionButtonClicked(self, event) :
if (self.debugLevel >= MediumDebug) :
self.msgText("Button Block Direction clicked")
self.methodBlockDirection = self.blockDirection.isSelected()
return
def whenShrinkButtonClicked(self, event):
if (self.shrinkGrow == True) :
if (self.debugLevel >= HighDebug) :
self.msgText("Shrink Display!") # add text
self.speedPane.setVisible(False)
self.shrinkGrow = False
self.fullScrollRows = self.scrollArea.getRows()
self.scrollArea.setRows(self.fullScrollRows / 2)
self.scriptFrame.pack()
else :
if (self.debugLevel >= HighDebug) :
self.msgText("Grow Display!")
self.speedPane.setVisible(True)
self.shrinkGrow = True
self.scrollArea.setRows(self.fullScrollRows)
self.scriptFrame.pack()
return
def whenSaveToRosterButtonClicked(self, event):
if (self.locoAddress.text != "") :
if (self.rosterInstance == None) :
self.rosterInstance = jmri.jmrit.roster.Roster.getDefault()
if (self.debugLevel >= MediumDebug) :
self.msgText("got roster instance")
id = int(self.locoAddress.text)
rosterEntries = self.rosterInstance.matchingList(None, None, str(id), None, None, None, None)
if (self.debugLevel >= HighDebug) :
self.msgText("found " + str(rosterEntries.size()) + " entries matching |" + str(id) + "|")
for ent in rosterEntries :
if (self.debugLevel >= LowDebug) :
self.msgText("posible entries: " + ent.fileName)
if (rosterEntries.size() == 1) :
ent = rosterEntries.get(0)
if (self.debugLevel >= LowDebug) :
self.msgText("Saving to roster: " + ent.fileName)
ent.putAttribute('RT_locoSpeedGreenFlash', self.locoSpeedGreenFlash.text)
ent.putAttribute('RT_locoRateGreenFlash', self.locoRateGreenFlash.text)
ent.putAttribute('RT_locoDistGreenFlash', self.locoDistGreenFlash.text)
ent.putAttribute('RT_locoSpeedGreen', self.locoSpeedGreen.text)
ent.putAttribute('RT_locoRateGreen', self.locoRateGreen.text)
ent.putAttribute('RT_locoDistGreen', self.locoDistGreen.text)
ent.putAttribute('RT_locoSpeedYellowFlash', self.locoSpeedYellowFlash.text)
ent.putAttribute('RT_locoRateYellowFlash', self.locoRateYellowFlash.text)
ent.putAttribute('RT_locoDistYellowFlash', self.locoDistYellowFlash.text)
ent.putAttribute('RT_locoSpeedYellow', self.locoSpeedYellow.text)
ent.putAttribute('RT_locoRateYellow', self.locoRateYellow.text)
ent.putAttribute('RT_locoDistYellow', self.locoDistYellow.text)
ent.putAttribute('RT_locoSpeedRedFlash', self.locoSpeedRedFlash.text)
ent.putAttribute('RT_locoRateRedFlash', self.locoRateRedFlash.text)
ent.putAttribute('RT_locoDistRedFlash', self.locoDistRedFlash.text)
ent.putAttribute('RT_locoSpeedRed', self.locoSpeedRed.text)
ent.putAttribute('RT_locoRateRed', self.locoRateRed.text)
ent.putAttribute('RT_locoDistRed', self.locoDistRed.text)
ent.updateFile()
self.rosterInstance.writeRosterFile()
if (self.debugLevel >= LowDebug) :
self.msgText("Save completed: " + ent.fileName)
return
def findCurrentBlocks(self) :
# search the block list for the matching loco
blockList = []
for b in blocks.getNamedBeanSet() :
if (b.getValue() == self.locoAddress.text and b.getState() == ACTIVE) :
blockList.append(b)
return blockList
def clearLocoFromBlocks(self, oldId) :
# search the block list for the matching loco
blockList = []
for b in blocks.getNamedBeanSet() :
if (b.getValue() == oldId) :
b.setValue(None)
return
def findNextBlock(self, cB) :
# look down list of getToBlockDirection for match
# use 'suggestion' flag if current block doesn't have direction
bTrav = None
bNoTrav = None
dirFlag = cB.getDirection()
if (dirFlag == jmri.Path.NONE) :
if (self.currentDirection == None) :
if (self.blockDirection.isSelected() == True) :
dirFlag = jmri.Path.EAST
self.currentDirection = jmri.Path.EAST
else :
dirFlag = jmri.Path.WEST
self.currentDirection = jmri.Path.WEST
else :
dirFlag = self.currentDirection
pathList = cB.getPaths()
if (self.debugLevel >= HighDebug) :
self.msgText("searching " + str(len(pathList)) + " paths from " + self.giveBlockName(cB))
for p in pathList :
blockTest = p.getBlock()
dirTest = p.getToBlockDirection()
if (dirTest & dirFlag != 0) :
if (p.checkPathSet()) :
if (self.debugLevel >= MediumDebug) :
self.msgText("findNextBlock path traversable: " + self.giveBlockName(cB) + " to " + self.giveBlockName(blockTest) + " dirTest: " + jmri.Path.decodeDirection(dirTest) + ":" + str(dirTest) + " dirFlag: " + jmri.Path.decodeDirection(dirFlag) + ":" + str(dirFlag) + " result: " + str(dirTest & dirFlag))
bTrav = blockTest
else :
if (self.debugLevel >= MediumDebug) :
self.msgText("findNextBlock path not traversable: " + self.giveBlockName(cB) + " to " + self.giveBlockName(blockTest))
bNoTrav = blockTest
if (self.debugLevel >= LowDebug) :
self.msgText("findNextBlock Found " + self.giveBlockName(blockTest))
if (bTrav == None) :
return bNoTrav
return bTrav
# ActionListener - used for the stop timeout
class SpeedChangeTimeoutReceiver(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
# ActionListener - used for the horn timeout
class HornTimeoutReceiver(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
# WindowListener is a interface class and therefore all of it's
# methods should be implemented even if not used to avoid AttributeErrors
class WinListener(java.awt.event.WindowListener):
f = None
cleanUp = None
def setCallBack(self, fr, c):
self.f = fr
self.cleanUp = c
return
def windowClosing(self, event):
if (self.cleanUp != None) :
self.cleanUp(event)
self.f.dispose() # close the pane (window)
return
def windowActivated(self,event):
return
def windowDeactivated(self,event):
return
def windowOpened(self,event):
return
def windowClosed(self,event):
return
def windowIconified(self, event):
return
def windowDeiconified(self, event):
return
#To detect block status, first define the listener.
class BlockListener(java.beans.PropertyChangeListener):
cb = None
def setCallBack(self, ptr) :
self.cb = ptr
return
def propertyChange(self, event):
if (self.cb != None) :
self.cb(event)
return
#To detect block status, first define the listener.
class SignalListener(java.beans.PropertyChangeListener):
cb = None
def setCallBack(self, ptr) :
self.cb = ptr
return
def propertyChange(self, event):
if (self.cb != None) :
self.cb(event)
return
# method for creating a TimeStamp.
def formatTime(self, ts):
ptHrs = str(ts.get(java.util.Calendar.HOUR_OF_DAY))
if len(ptHrs) == 1 :
ptHrs = "0" + ptHrs
ptMins = str(ts.get(java.util.Calendar.MINUTE))
if len(ptMins) == 1 :
ptMins = "0" + ptMins
ptSecs = str(ts.get(java.util.Calendar.SECOND))
if len(ptSecs) == 1 :
ptSecs = "0" + ptSecs
ptMs = str(ts.get(java.util.Calendar.MILLISECOND))
pTime = ptHrs + ":" + ptMins + ":" + ptSecs + "." + ptMs
return pTime
# method for creating a DateStamp.
def formatDate(self, ts):
ptDays = str(ts.get(java.util.Calendar.DATE))
if len(ptDays) == 1 :
ptDays = "0" + ptDays
ptMonths = str(ts.get(java.util.Calendar.MONTH) + 1)
if len(ptMonths) == 1 :
ptMonths = "0" + ptMonths
ptYears = str(ts.get(java.util.Calendar.YEAR))
pDate = ptMonths + "/" + ptDays + "/" + ptYears
return pDate
# handle adding to message window
def msgText(self, txt) :
if (self.scrollTimeStamp.isSelected() == True) :
ts = java.util.Calendar.getInstance()
self.scrollArea.append(self.formatTime(ts) + ": " + txt + "\n")
else :
self.scrollArea.append(txt + "\n")
if (self.autoScroll.isSelected() == True) :
self.scrollArea.setCaretPosition(self.scrollArea.getDocument().getLength())
return
# setup the user interface
def setup(self) :
# get other setup things
self.greenSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-green-short.gif", "GreenCabSignal")
self.greenFlashSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-flashgreen-short.gif", "GreenFlashCabSignal")
self.yellowSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-yellow-short.gif", "YellowCabSignal")
self.yellowFlashSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-flashyellow-short.gif", "YellowFlashCabSignal")
self.redSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-red-short.gif", "RedCabSignal")
self.redFlashSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-flashred-short.gif", "RedFlashCabSignal")
self.darkSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/smallschematics/searchlights/right-dark-short.gif", "DarkCabSignal")
self.unknownSignalIcon = jmri.jmrit.catalog.NamedIcon("resources/icons/misc/Question-black.gif", "UnknownCabSignal")
self.throttleManager = jmri.InstanceManager.getDefault(jmri.ThrottleManager)
if (self.throttleManager == None) :
print("No command station found!!\nRT has no way to control the trains.\n")
return
# start to initialise the GUI
sizeRateField = 4
sizeSpeedField = 3
# create buttons and define action
self.startButton = javax.swing.JButton("Start")
self.startButton.setEnabled(False) # button starts as grayed out (disabled)
self.startButton.actionPerformed = self.whenStartButtonClicked
self.stopButton = javax.swing.JButton("Stop")
self.stopButton.setEnabled(False) # button starts as grayed out (disabled)
self.stopButton.setToolTipText("Stops the run - there is a delay as the loco slows")
self.stopButton.actionPerformed = self.whenStopButtonClicked
self.haltButton = javax.swing.JButton("Halt")
self.haltButton.setEnabled(False) # button starts as grayed out (disabled)
self.haltButton.setToolTipText("Emergency halt the run - should be an abrupt stop")
self.haltButton.actionPerformed = self.whenHaltButtonClicked
self.shrinkButton = javax.swing.JButton("Shrink")
self.shrinkButton.setEnabled(True)
self.shrinkButton.setToolTipText("Shrink/Grow the window")
self.shrinkButton.actionPerformed = self.whenShrinkButtonClicked
self.testButton = javax.swing.JButton("Test")
self.testButton.setEnabled(True) # button starts as grayed out (disabled)
self.testButton.setToolTipText("run the didWeMove test")
self.testButton.actionPerformed = self.callBackForDidWeMove
self.saveToRosterButton = javax.swing.JButton("Save Settings")
self.saveToRosterButton.setEnabled(True)
self.saveToRosterButton.setToolTipText("Saves setting in roster, if found.")
self.saveToRosterButton.actionPerformed = self.whenSaveToRosterButtonClicked
# address of the loco
self.locoAddress = javax.swing.JTextField(5) # sized to hold 5 characters, initially empty
self.locoAddress.actionPerformed = self.whenLocoChanged # if user hit return or enter
self.locoAddress.focusLost = self.whenLocoChanged # if user tabs away
self.locoAddress.requestFocusInWindow()
# long/short address flag
self.locoLong = javax.swing.JCheckBox()
self.locoLong.setToolTipText("Check to use long address")
self.locoLong.setSelected(True)
if (self.throttleManager.addressTypeUnique() == True) :
self.locoLong.setEnabled(False)
self.locoLong.actionPerformed = self.whenLocoChanged
self.locoLong.focusLost = self.whenLocoChanged
# loco direction flag
self.locoForward = javax.swing.JCheckBox()
self.locoForward.setToolTipText("Sets forward loco direction")
self.locoForward.setSelected(True)
self.locoForward.actionPerformed = self.whenLocoDirectionButtonClicked
self.locoForward.focusLost = self.whenLocoDirectionButtonClicked
# loco headlight flag
self.locoHeadlight = javax.swing.JCheckBox()
self.locoHeadlight.setToolTipText("Controls loco hightlight")
self.locoHeadlight.actionPerformed = self.whenLocoHeadlight
self.locoHeadlight.focusLost = self.whenLocoHeadlight
# loco bell flag
self.locoBell = javax.swing.JCheckBox()
self.locoBell.setToolTipText("Controls loco bell")
self.locoBell.actionPerformed = self.whenLocoBell
self.locoBell.focusLost = self.whenLocoBell
# loco horn/whistle flag
self.locoHorn = javax.swing.JButton("Horn")
self.locoHorn.setToolTipText("Controls loco horn")
self.locoHorn.mousePressed = self.whenLocoHornOn
self.locoHorn.mouseReleased = self.whenLocoHornOff
# loco move buttons
self.locoMoveGreen = javax.swing.JButton("Move @ Clear")
self.locoMoveGreen.setToolTipText("Moves loco at Clear speed")
self.locoMoveGreen.mousePressed = self.whenLocoMoveOnGreen
self.locoMoveGreen.mouseReleased = self.whenLocoMoveOff
self.locoMoveYellow = javax.swing.JButton("Move @ Limited")
self.locoMoveYellow.setToolTipText("Moves loco at Limited speed")
self.locoMoveYellow.mousePressed = self.whenLocoMoveOnYellow
self.locoMoveYellow.mouseReleased = self.whenLocoMoveOff
self.locoMoveRed = javax.swing.JButton("Move @ Restricted")
self.locoMoveRed.setToolTipText("Moves loco at Restricted speed")
self.locoMoveRed.mousePressed = self.whenLocoMoveOnRed
self.locoMoveRed.mouseReleased = self.whenLocoMoveOff
# create the speed fields for a Green Flash Signal
self.locoSpeedGreenFlash = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedGreenFlash.setToolTipText("Green Flash Speed is a number from 1 to 100%")
self.locoSpeedGreenFlash.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedGreenFlash.focusLost = self.whenSpeedFieldChanged
self.locoSpeedGreenFlash.text = "70"
self.locoSpeedGreenFlash.setName("locoSpeedGreenFlash")
# create the physical speed field for a Green Flash Signal
self.locoRateGreenFlash = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateGreenFlash.setToolTipText("Throttle as Distance/Second, approaching green flash signal")
self.locoRateGreenFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoRateGreenFlash.focusLost = self.whenDistanceFieldChanged
self.locoRateGreenFlash.text = "0"
self.locoRateGreenFlash.setName("locoRateGreenFlash")
# create the distance field for a Green Flash Signal
self.locoDistGreenFlash = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistGreenFlash.setToolTipText("Distance to Green Speed from Green Flash signal speed, inches")
self.locoDistGreenFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoDistGreenFlash.focusLost = self.whenDistanceFieldChanged
self.locoDistGreenFlash.text = "6"
self.locoDistGreenFlash.setName("locoDistGreenFlash")
# create the speed fields for a Green Signal
self.locoSpeedGreen = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedGreen.setToolTipText("Green Speed is a number from 1 to 100%")
self.locoSpeedGreen.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedGreen.focusLost = self.whenSpeedFieldChanged
self.locoSpeedGreen.text = "45"
self.locoSpeedGreen.setName("locoSpeedGreen")
# create the physical speed field for a Green Signal
self.locoRateGreen = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateGreen.setToolTipText("Throttle as Distance/Second, approaching Green signal")
self.locoRateGreen.actionPerformed = self.whenDistanceFieldChanged
self.locoRateGreen.focusLost = self.whenDistanceFieldChanged
self.locoRateGreen.text = "9"
self.locoRateGreen.setName("locoRateGreen")
# create the distance field for a Green Signal
self.locoDistGreen = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistGreen.setToolTipText("Distance to Yellow Flash Speed from Green signal speed, inches")
self.locoDistGreen.actionPerformed = self.whenDistanceFieldChanged
self.locoDistGreen.focusLost = self.whenDistanceFieldChanged
self.locoDistGreen.text = "6"
self.locoDistGreen.setName("locoDistGreen")
# create the speed fields for a Yellow Flash Signal
self.locoSpeedYellowFlash = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedYellowFlash.setToolTipText("Yellow Flash Speed is a number from 1 to 100%")
self.locoSpeedYellowFlash.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedYellowFlash.focusLost = self.whenSpeedFieldChanged
self.locoSpeedYellowFlash.text = "45"
self.locoSpeedYellowFlash.setName("locoSpeedYellowFlash")
# create the physical speed field for a Yellow Flash Signal
self.locoRateYellowFlash = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateYellowFlash.setToolTipText("Throttle as Distance/Second, approaching yello flash signal")
self.locoRateYellowFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoRateYellowFlash.focusLost = self.whenDistanceFieldChanged
self.locoRateYellowFlash.text = "0"
self.locoRateYellowFlash.setName("locoRateYellowFlash")
# create the distance field for a Yellow Flash Signal
self.locoDistYellowFlash = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistYellowFlash.setToolTipText("Distance to Yellow Speed from Yellow Flash signal speed, inches")
self.locoDistYellowFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoDistYellowFlash.focusLost = self.whenDistanceFieldChanged
self.locoDistYellowFlash.text = "6"
self.locoDistYellowFlash.setName("locoDistYellowFlash")
# create the speed fields for a Yellow Signal
self.locoSpeedYellow = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedYellow.setToolTipText("Yellow Speed is a number from 1 to 100%")
self.locoSpeedYellow.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedYellow.focusLost = self.whenSpeedFieldChanged
self.locoSpeedYellow.text = "30"
self.locoSpeedYellow.setName("locoSpeedYellow")
# create the physical speed field for a Yellow Signal
self.locoRateYellow = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateYellow.setToolTipText("Throttle as Distance/Second, approaching yellow signal")
self.locoRateYellow.actionPerformed = self.whenDistanceFieldChanged
self.locoRateYellow.focusLost = self.whenDistanceFieldChanged
self.locoRateYellow.text = "6"
self.locoRateYellow.setName("locoRateYellow")
# create the distance field for a Yellow Signal
self.locoDistYellow = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistYellow.setToolTipText("Distance to Red Flash Speed from Yellow signal speed, inches")
self.locoDistYellow.actionPerformed = self.whenDistanceFieldChanged
self.locoDistYellow.focusLost = self.whenDistanceFieldChanged
self.locoDistYellow.text = "6"
self.locoDistYellow.setName("locoDistYellow")
# create the speed fields for a Red Flash Signal
self.locoSpeedRedFlash = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedRedFlash.setToolTipText("Red Flash Speed is a number from 1 to 100%")
self.locoSpeedRedFlash.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedRedFlash.focusLost = self.whenSpeedFieldChanged
self.locoSpeedRedFlash.text = "20"
self.locoSpeedRedFlash.setName("locoSpeedRedFlash")
# create the physical speed field for a Red Flash Signal
self.locoRateRedFlash = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateRedFlash.setToolTipText("Throttle as Distance/Second, approaching red flash signal")
self.locoRateRedFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoRateRedFlash.focusLost = self.whenDistanceFieldChanged
self.locoRateRedFlash.text = "0"
self.locoRateRedFlash.setName("locoRateRedFlash")
# create the distance field for a Red Flash Signal
self.locoDistRedFlash = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistRedFlash.setToolTipText("Distance to Red Speed from Red Flash signal speed, inches")
self.locoDistRedFlash.actionPerformed = self.whenDistanceFieldChanged
self.locoDistRedFlash.focusLost = self.whenDistanceFieldChanged
self.locoDistRedFlash.text = "0"
self.locoDistRedFlash.setName("locoDistRedFlash")
# create the speed fields for a Red Signal
self.locoSpeedRed = javax.swing.JTextField(sizeSpeedField) # sized to hold 5 characters
self.locoSpeedRed.setToolTipText("Red Speed is a number from 1 to 100%, creep to Red Signal")
self.locoSpeedRed.actionPerformed = self.whenSpeedFieldChanged
self.locoSpeedRed.focusLost = self.whenSpeedFieldChanged
self.locoSpeedRed.text = "15"
self.locoSpeedRed.setName("locoSpeedRed")
# create the physical speed field for a Red Signal
self.locoRateRed = javax.swing.JTextField(sizeRateField) # sized to hold 5 characters
self.locoRateRed.setToolTipText("Throttle as Distance/Second, approaching red signal")
self.locoRateRed.actionPerformed = self.whenDistanceFieldChanged
self.locoRateRed.focusLost = self.whenDistanceFieldChanged
self.locoRateRed.text = "3"
self.locoRateRed.setName("locoRateRed")
# create the distance field for a Red Signal
self.locoDistRed = javax.swing.JTextField(5) # sized to hold 5 characters
self.locoDistRed.setToolTipText("Distance to stop from Red signal speed, inches")
self.locoDistRed.actionPerformed = self.whenDistanceFieldChanged
self.locoDistRed.focusLost = self.whenDistanceFieldChanged
self.locoDistRed.text = "10"
self.locoDistRed.setName("locoDistRed")
# create current speed display
self.locoSpeed = javax.swing.JLabel()
self.locoSpeed.text = "0"
# create the starting block field
self.blockStart = javax.swing.JTextField(10)
self.blockStart.setToolTipText("Starting Block Name")
self.blockStart.actionPerformed = self.whenLocoChanged
self.blockStart.focusLost = self.whenLocoChanged
self.blockStart.setName("blockStart")
# create the starting block direction
self.blockDirection = javax.swing.JCheckBox()
self.blockDirection.setToolTipText("Starting Block Direction")
self.blockDirection.actionPerformed = self.whenBlockDirectionButtonClicked
self.blockDirection.focusLost = self.whenBlockDirectionButtonClicked
self.blockDirection.setSelected(True)
# create flag for looking any extra block ahead
self.blockAhead2 = javax.swing.JCheckBox()
self.blockAhead2.setSelected(False)
self.blockAhead2.setToolTipText("for 4 block mode")
# create flag for enable lookahead stopping
self.useStopFromDistance = javax.swing.JCheckBox()
self.useStopFromDistance.setSelected(False)
self.useStopFromDistance.setToolTipText("reduce current signal viewed due to distant stop")
# create the stopping block field
self.blockStop = javax.swing.JTextField(10)
self.blockStop.setToolTipText("Stopping Block Name")
self.blockStop.actionPerformed = self.whenStopBlockChanged
self.blockStop.focusLost = self.whenStopBlockChanged
# create the current block field
self.blockNow = javax.swing.JLabel()
self.blockNowLength = javax.swing.JLabel()
# create the current/next signal field
self.signalNext = javax.swing.JLabel()
self.signalNextText = javax.swing.JLabel()
# create the next block field
self.blockNext = javax.swing.JLabel()
self.blockNextLength = javax.swing.JLabel()
# create the next/beyond signal field
self.signalBeyond = javax.swing.JLabel()
self.signalBeyondText = javax.swing.JLabel()
# create the beyond block field
self.blockBeyond = javax.swing.JLabel()
self.blockBeyondLength = javax.swing.JLabel()
# create the stop distance field
self.stopDistance = javax.swing.JLabel()
self.stopDistanceForSpeed = javax.swing.JLabel()
# load from roster flag
self.loadFromRoster = javax.swing.JCheckBox()
self.loadFromRoster.setToolTipText("Load settings from roster entry if found.")
self.loadFromRoster.setSelected(True)
# auto-scroll message window flag
self.autoScroll = javax.swing.JCheckBox()
self.autoScroll.setToolTipText("Sets message window to auto-scroll")
self.autoScroll.setSelected(True)
# time stamp message window flag
self.scrollTimeStamp = javax.swing.JCheckBox()
self.scrollTimeStamp.setToolTipText("Insert time stamp on message window")
self.scrollTimeStamp.setSelected(True)
# create a text area
self.scrollArea = javax.swing.JTextArea(15, 70) # define a text area with it's size
if (self.debugLevel >= LowDebug) :
self.msgText("Enter the loco number, direction and addr mode")
self.msgText("Set min and max speed")
self.msgText("Enter block name loco is in")
srcollField = javax.swing.JScrollPane(self.scrollArea) # put text area in scroll field
# create a frame to hold the buttons and fields
# also create a window listener. This is used mainly to remove the property change listener
# when the window is closed by clicking on the window close button
w = self.WinListener()
self.scriptFrame = javax.swing.JFrame("Run Loco") # argument is the frames title
self.scriptFrame.contentPane.setLayout(javax.swing.BoxLayout(self.scriptFrame.contentPane, javax.swing.BoxLayout.Y_AXIS))
self.scriptFrame.addWindowListener(w)
w.setCallBack(self.scriptFrame, self.releaseAllListeners)
# put the text field on a line preceded by a label
temppanel1 = javax.swing.JPanel()
temppanel1.add(javax.swing.JLabel("Loco Address:"))
temppanel1.add(self.locoAddress)
temppanel1.add(javax.swing.JLabel(" LongAddr?"))
temppanel1.add(self.locoLong)
temppanel1.add(javax.swing.JLabel(" Forward?"))
temppanel1.add(self.locoForward)
temppanel1a = javax.swing.JPanel()
temppanel1a.add(javax.swing.JLabel("Headlight:"))
temppanel1a.add(self.locoHeadlight)
temppanel1a.add(javax.swing.JLabel("Bell:"))
temppanel1a.add(self.locoBell)
temppanel1a.add(self.locoHorn)
temppanel1a.add(self.locoMoveGreen)
temppanel1a.add(self.locoMoveYellow)
temppanel1a.add(self.locoMoveRed)
# build speed table
gLayout = java.awt.GridBagLayout()
gConstraints = java.awt.GridBagConstraints()
self.speedPane = javax.swing.JPanel()
pane2Border = javax.swing.BorderFactory.createEtchedBorder()
pane2Titled = javax.swing.BorderFactory.createTitledBorder(pane2Border, "Speed Settings")
self.speedPane.setBorder(pane2Titled)
self.speedPane.setLayout(gLayout)
gConstraints.gridx = 0
gConstraints.gridy = 0
gConstraints.gridwidth = 1
gConstraints.gridheight = 1
gConstraints.ipadx = 12
gConstraints.ipady = 3
gConstraints.insets = java.awt.Insets(3, 3, 3, 3)
self.speedPane.add(javax.swing.JLabel("locoDistRed"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Throttle"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Inch/Sec"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Speed Chg Distance"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Indication"), gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(javax.swing.JLabel("Throttle"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Inch/Sec"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("Speed Chg Distance"), gConstraints)
gConstraints.gridx = 0
gConstraints.gridy = gConstraints.gridy + 1
self.speedPane.add(javax.swing.JLabel(self.greenFlashSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedGreenFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoRateGreenFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoDistGreenFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(self.greenSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedGreen, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoRateGreen, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoDistGreen, gConstraints)
gConstraints.gridx = 0
gConstraints.gridy = gConstraints.gridy + 1
self.speedPane.add(javax.swing.JLabel(self.yellowFlashSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedYellowFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoRateYellowFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoDistYellowFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(self.yellowSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedYellow, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoRateYellow, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoDistYellow, gConstraints)
gConstraints.gridx = 0
gConstraints.gridy = gConstraints.gridy + 1
self.speedPane.add(javax.swing.JLabel(self.redFlashSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedRedFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoRateRedFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoDistRedFlash, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(javax.swing.JLabel(" "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel(self.redSignalIcon), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoSpeedRed, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(javax.swing.JLabel("%"), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.locoRateRed, gConstraints)
gConstraints.gridx = gConstraints.gridx+ 1
self.speedPane.add(self.locoDistRed, gConstraints)
gConstraints.gridx = 0
gConstraints.gridy = gConstraints.gridy + 1
self.speedPane.add(javax.swing.JLabel("Load From Roster: "), gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.loadFromRoster, gConstraints)
gConstraints.gridx = gConstraints.gridx + 1
self.speedPane.add(self.saveToRosterButton, gConstraints)
# build block info
temppanel3 = javax.swing.JPanel()
temppanel3.add(javax.swing.JLabel("Block Starting: "))
temppanel3.add(self.blockStart)
temppanel3.add(javax.swing.JLabel(" Eastbound: "))
temppanel3.add(self.blockDirection)
temppanel3.add(javax.swing.JLabel(" Check block ahead: "))
temppanel3.add(self.blockAhead2)
temppanel3.add(javax.swing.JLabel(" Lookahead for Stop: "))
temppanel3.add(self.useStopFromDistance)
temppanel3.add(javax.swing.JLabel(" Stopping Block: "))
temppanel3.add(self.blockStop)
temppanel3.add(javax.swing.JLabel(" AutoScroll Messages: "))
temppanel3.add(self.autoScroll)
temppanel3.add(javax.swing.JLabel(" Time Stamp Messages: "))
temppanel3.add(self.scrollTimeStamp)
temppanel4 = javax.swing.JPanel()
temppanel4.add(javax.swing.JLabel("Speed: "), gConstraints)
temppanel4.add(self.locoSpeed, gConstraints)
temppanel4.add(javax.swing.JLabel("% "), gConstraints)
temppanel4.add(javax.swing.JLabel(" Now:"))
temppanel4.add(self.blockNow)
temppanel4.add(javax.swing.JLabel(" "))
temppanel4.add(self.signalNext)
temppanel4.add(self.signalNextText)
temppanel4.add(javax.swing.JLabel(" "))
temppanel4.add(self.blockNowLength)
temppanel4.add(javax.swing.JLabel("in Next:"))
temppanel4.add(self.blockNext)
temppanel4.add(javax.swing.JLabel(" "))
temppanel4.add(self.signalBeyond)
temppanel4.add(self.signalBeyondText)
temppanel4.add(javax.swing.JLabel(" "))
temppanel4.add(self.blockNextLength)
temppanel4.add(javax.swing.JLabel("in Beyond:"))
temppanel4.add(self.blockBeyond)
temppanel4.add(javax.swing.JLabel(" "))
temppanel4.add(self.blockBeyondLength)
temppanel4.add(javax.swing.JLabel(" in "))
temppanel4.add(javax.swing.JLabel("Min Stop Dist: "))
temppanel4.add(self.stopDistance)
temppanel4.add(javax.swing.JLabel(" : "))
temppanel4.add(self.stopDistanceForSpeed)
self.greenFlashSignalIcon.setRotation(1, temppanel4)
self.greenSignalIcon.setRotation(1, temppanel4)
self.yellowFlashSignalIcon.setRotation(1, temppanel4)
self.yellowSignalIcon.setRotation(1, temppanel4)
self.redFlashSignalIcon.setRotation(1, temppanel4)
self.redSignalIcon.setRotation(1, temppanel4)
self.darkSignalIcon.setRotation(1, temppanel4)
butPanel = javax.swing.JPanel()
butPanel.add(self.startButton)
butPanel.add(self.stopButton)
butPanel.add(self.testButton)
butPanel.add(self.haltButton)
butPanel.add(self.shrinkButton)
# Put contents in frame and display
self.scriptFrame.contentPane.add(temppanel1)
self.scriptFrame.contentPane.add(temppanel1a)
self.scriptFrame.contentPane.add(self.speedPane)
self.scriptFrame.contentPane.add(temppanel3)
self.scriptFrame.contentPane.add(temppanel4)
self.scriptFrame.contentPane.add(srcollField)
self.scriptFrame.contentPane.add(butPanel)
self.scriptFrame.pack()
self.scriptFrame.show()
self.isAborting = False
return
def setLoco(self, locoId) :
self.methodLocoAddress = locoId
return
def setLocoEast(self) :
self.methodBlockDirection = True
return
def setLocoWest(self) :
self.methodBlockDirection = False
return
def setLocoForward(self) :
self.methodLocoForward = True
return
def setLocoReverse(self) :
self.methodLocoForward = False
return
def locoHeadlightOn(self) :
self.methodLocoHeadlight = True
return
def locoHeadlightOff(self) :
self.methodLocoHeadlight = False
return
def soundShortHorn(self) :
self.methodShortHorn = True
return
def soundLongHorn(self) :
self.methodLongHorn = True
return
def pushShrink(self) :
self.methodPushShrink = True
return
def setStartBlock(self, blockId) :
self.methodBlockStart = blockId
return
def pushStart(self) :
self.methodPushStart = True
return
def pushStop(self) :
self.methodPushStop = True
return
def pushTest(self) :
self.methodPushTest = True
return
def setStopBlock(self, blockId) :
self.methodBlockStop = blockId
return
def setStopDistance(self, dist) :
self.methodlocoDistRed = dist
return
def updateMemoryWithCurrentSpeed(self, memoryId) :
mem = jmri.InstanceManager.memoryManagerInstance().provideMemory(memoryId)
if (mem != None) :
if (self.currentThrottle != None) :
mem.setValue(str((int)(round(self.currentThrottle.getSpeedSetting() * 100, 0))))
else :
mem.setValue("0")
return
def returnCurrentSpeed(self) :
if (self.currentThrottle != None) :
v = str((int)(round(self.currentThrottle.getSpeedSetting() * 100, 0)))
else :
v = "0"
return(v)
def updateMemoryWithCurrentBlock(self, memoryId) :
mem = jmri.InstanceManager.memoryManagerInstance().provideMemory(memoryId)
if (mem != None) :
if (self.currentBlock != None) :
mem.setValue(self.giveBlockName(self.currentBlock))
else :
mem.setValue("")
return
def returnCurrentBlock(self) :
if (self.currentBlock != None) :
v = self.giveBlockName(self.currentBlock)
else :
v = ""
return(v)
def setDebugNone(self) :
self.debugLevel = NoneDebug
return()
def setDebugLow(self) :
self.debugLevel = LowDebug
return()
def setDebugMedium(self) :
self.debugLevel = MediumDebug
return()
def setDebugHigh(self) :
self.debugLevel = HighDebug
return()
# if you are running the RobotThrottle completely interactive,
# the following two lines are all you need
rb1 = LocoThrot()
rb1.start()
#rb1.setSignalAppearanceHalt(GREEN)
# However, if you are automating the automation, then
## Options for doing more via scripts or Logix Jython command line option
## this will set the loco number, if a matching roster entry is found, it will load the values
## rb1.setLoco("111")
## rb1.setLocoEast()
## rb1.setLocoWest()
## rb1.locoHeadlightOn()
## rb1.locoHeadlightOff()
## rb1.soundShortHorn()
## rb1.soundLongHorn()
## this will set the starting block
## rb1.setStartBlock("LB25")
## this will enable the loco to move according to the signals
## rb1.pushStart()
## rb1.pushStop()
## this sets a block to stop at
## rb1.setStopBlock("LB27")
## shrink the display size
## rb1.pushShrink()
## turn off all debug messages
## rb1.setDebugNone()
## turn on all debug messages
## rb1.setDebugHigh()