easylinux/JIMRI
1
0
Fork 0
Code Issues Pull Requests Actions 1 Packages Projects Releases Wiki Activity
Files
main
JIMRI/jython/DispatcherSystem/MoveTrain.py
T
Serge NOEL efdf1683af Initialisation depot
2026-06-17 14:00:51 +02:00

2595 lines
124 KiB
Python
Raw Permalink Blame History

###############################################################################
#
# class MoveTrain
# Calls dispatcher to e train from one station to another
# given engine and start and end positions
#
###############################################################################
import os
import java
import jmri
import math
import time
from javax.swing import JTable, JScrollPane, JFrame, JPanel, JComboBox, BorderFactory, DefaultCellEditor, JLabel, UIManager, SwingConstants, JFileChooser
from javax.swing.table import TableCellRenderer, DefaultTableCellRenderer
from java.awt.event import MouseAdapter,MouseEvent, WindowListener, WindowEvent
from java.awt import GridLayout, Dimension, BorderLayout, Color
from javax.swing.table import AbstractTableModel, DefaultTableModel
from java.lang.Object import getClass
from jmri.jmrit.logix import WarrantPreferences
import jarray
from javax.swing.event import TableModelListener, TableModelEvent
from javax.swing.filechooser import FileNameExtensionFilter
from org.apache.commons.io import FilenameUtils
from java.io import File
#, defaultTableModel
global MoveTrain_index
MoveTrain_index = 0
class MoveTrain(jmri.jmrit.automat.AbstractAutomaton):
global trains_dispatched
global trains
global time_last_train
def __init__(self, station_from_name, station_to_name, train_name, graph, stop_mode = None, mode = "not_scheduling", route = None):
self.logLevel = 0
if self.logLevel > 0: print "station_from_name", station_from_name, "station_to_name",station_to_name, "train_name", train_name, "stop_mode", stop_mode
self.station_from_name = station_from_name
self.station_to_name = station_to_name
self.train_name = train_name
self.graph = graph
self.route = route
# if there is a stop sensor at the last station, get the stop mode at the last station if it has been set up
if self.route != None:
self.stop_mode = self.get_route_location_stop_mode(station_to_name)
else:
self.stop_mode = ""
self.mode = mode
def setup(self):
return True
def handle(self):
# move between stations in the thread
if self.logLevel > 1: print"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
if self.logLevel > 1: print "move between stations in the thread"
if self.logLevel > 1: print"!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!"
result = self.move_between_stations(self.station_from_name, self.station_to_name, self.train_name, self.graph, self.mode)
return False
def get_route_location_stop_mode(self, station_to_name):
route_location = self.route.getLastLocationByName(station_to_name)
if self.logLevel > 0: print "get_stop_mode" , "route location", route_location
comment = route_location.getComment()
stop_mode = self.find_between(comment, "[stopMode-", "-stopMode]")
if self.logLevel > 0: print "routeLocation stop_mode", stop_mode
return stop_mode
def find_between(self, s, first, last):
try:
start = s.index(first) + len(first)
end = s.index(last, start)
return s[start:end]
except ValueError:
return ""
def move_between_stations(self, station_from_name, station_to_name, train_name, graph, mode = "not_scheduling"):
global trains
global scheduling_margin_gbl
global fast_clock_rate
global MoveTrain_index
global trains_dispatched
MoveTrain_index += 1
self.index = MoveTrain_index
strindex = str(self.index) + " " * 5 #make debugging easier to understand by indenting and prefixing by the train index
if self.logLevel > 0: print ""
if self.logLevel > 0: print ""
if self.logLevel > 0: print strindex + "&&&&&&&&&&&&&&&&& start move_between_stations &&&&&&&&&&&&&&&&&" , strindex
if self.logLevel > 0: print strindex + "*********************************************"
if self.logLevel > 0: print strindex + "move_between_stations"
if self.logLevel > 0: print strindex + "Moving from " + station_from_name + " to " + station_to_name
if self.logLevel > 0: print strindex + "*********************************************"
i = 0
if self.logLevel > 0: print strindex + "checking train in start block"
# print strindex + "move_between_stations a"
if self.logLevel > 0: print strindex + "train is in start block"
#need to look up the required transit in the graph
StateVertex_start = station_from_name
StateVertex_end = station_to_name
for e in graph.edgeSet():
if self.logLevel > 1: print (graph.getEdgeSource(e) + " --> " + graph.getEdgeTarget(e))
if self.logLevel > 0: print strindex + "calling shortest path", StateVertex_start, StateVertex_end
# List all vertices
if self.logLevel > 0:
for vertex in graph.vertexSet():
print("Vertex:", vertex)
paths = DijkstraShortestPath.findPathBetween(graph, StateVertex_start, StateVertex_end)
# print strindex + "move_between_stations b"
if paths == None:
if self.logLevel > 0: print strindex + "cannot find shortest path, paths found is empty"
# print strindex + "end of move between ", station_from_name, station_to_name
return
if self.logLevel > 1: print strindex + "graph", graph
if self.logLevel > 1: print strindex + "paths", paths
if self.logLevel > 1: print strindex + "returned from shortest path"
if self.logLevel > 0: print strindex + "in move_between_stations trains = ", trains, "train_name = ", train_name
if train_name in trains:
train = trains[train_name]
else:
if self.logLevel > 0: print strindex + "in case of key error: trains", trains
if self.logLevel > 0: print strindex + "******"
if self.logLevel > 0: print strindex + "train_name", train_name, "trains", trains
if self.logLevel > 0: print strindex + "************Not Moving Train************"
return
if self.logLevel > 1: print strindex + "train" , train, "train_name", train_name
penultimate_block_name = train["penultimate_block_name"]
if self.logLevel > 1: print strindex + "penultimate_block_name" , penultimate_block_name
previous_edge = train["edge"]
if self.logLevel > 2: print 'move_between_stations train["direction"]' , train["direction"]
previous_direction_from = train["direction"]
count_path = 0
# print strindex + "move_between_stations c"
if paths == None or paths == []:
if self.logLevel > 0: print strindex + "1Error cannot find shortest path. restart the system. " + \
"The stop dispatcher system routine does not work properly with multiple layout panels. Sorry"
return
# if we have a problem in one of the paths we set the following to False, and jump out of for statement
call_next_edge_in_paths = True
for e in paths:
if call_next_edge_in_paths == False:
break
# print strindex + "move_between_stations d"
# need to check whether:
# last block of previous edge and current first block
# are the same
# if the same the train must change direction. as we are going in and out the same path
#
if self.logLevel > 0: print strindex + "********************************"
previous_edge = train["edge"]
penultimate_block_name = train["penultimate_block_name"]
current_edge = e
neighbor_name = e.getItem("neighbor_name")
if self.logLevel > 0: print train
if self.logLevel > 0: print strindex + "neighbor_name = ", neighbor_name
if self.logLevel > 0: print strindex + "train penultimate_block_name" , penultimate_block_name
BlockManager = jmri.InstanceManager.getDefault(jmri.BlockManager)
previous_direction_from = train["direction"]
# print strindex + "previous direction from", previous_direction_from
# wait for the allocated time
speech_reqd = self.speech_required_flag()
# print strindex + "move_between_stations e"
# wait in station and announce the wait time (announcement only for debugging)
transit_direction = previous_direction_from
time_to_stop_in_station = self.get_time_to_stop_in_station(e, transit_direction)
t = time_to_stop_in_station / 1000
msg = "started waiting for " + str(int(t)) + " seconds"
if self.logLevel > 0: self.speak(msg)
self.waitMsec(int(time_to_stop_in_station))
msg = "finished waiting for " + str(int(t)) + " seconds"
if self.logLevel > 0: self.speak(msg)
iter = 0
result = False
# try to call dispatch until success (result of calling dispatch is True (success) or False (failure))
while result == False:
# in case the train moves since the last try of calling for the dispatch (and we have a failure)
# get the current location of the train at the beginning of the while loop
# if str(train_name) in trains_dispatched:
# print strindex + "train is dispatching trying again" + "trains_dispatched", trains_dispatched:
# self.waitMsec(500)
# continue
# else:
# print strindex + "train is not dispatching continuing"
train = trains[train_name]
previous_edge = train["edge"]
if self.logLevel > 0: print strindex + "previous_edge " + str(previous_edge)
penultimate_block_name = train["penultimate_block_name"]
previous_block = BlockManager.getBlock(previous_edge.getItem("penultimate_block_name"))
# print strindex + "previous_block", previous_block.getUserName()
current_block = BlockManager.getBlock(previous_edge.getItem("last_block_name"))
# print strindex + "current_block", current_block.getUserName()
next_block = BlockManager.getBlock(current_edge.getItem("second_block_name"))
# print strindex + "next_block", next_block.getUserName()
previous_direction_from = train["direction"]
transit_direction = previous_direction_from
# move_between_stations
if self.logLevel > 0: print strindex + "previous transit_direction ", transit_direction
if self.logLevel > 0: print strindex + "setting direction iterno", iter
[train["direction"], transit_instruction] = self.set_direction(train, previous_block, current_block, next_block, transit_direction, self.index) # get the new train_direction_from
transit_direction = train["direction"]
# need to store if we change direction in case we have to redo the command
if transit_direction != previous_direction_from:
stored_transit_instruction = "change"
else:
stored_transit_instruction = "no_change"
if self.logLevel > 0: print strindex + "new transit_direction " + transit_direction
if self.logLevel > 0: print strindex + "+++++++++++++++++++++++++++"
if self.logLevel > 0: print strindex + "calling self.move iterno", iter
result = self.move(e, transit_direction, transit_instruction, train_name, mode, self.index)
if self.logLevel > 0: print strindex + "called self.move iterno", iter, "result", result
# result is True (success) or False (failure)
# if result is false we will try again as we are in a loop
# if we are not scheduling, we will try once before allowing the operator to specify whether we are giving up
# if we are scheduling we try until the scheduling margin is reached
if self.logLevel > 0: print strindex + "returned from self.move, result = ", result
if result == False:
# we will repeat, sot put everything back to original state
if stored_transit_instruction == "change":
if self.logLevel > 0: print strindex + "reverting changed direction iterno", iter
if train["direction"] == "forward":
train["direction"] = "reverse"
else:
train["direction"] = "forward"
if self.logLevel > 0: print strindex + "mode", mode
if mode == "not_scheduling":
if iter >= 1: #allow one retry without prompting
msg = "Failure1 to dispatch train " + train_name + " retrying moving from " + station_from_name + " to " + station_to_name
title = ""
opt1 = "try again"
opt2 = "cancel"
reply = OptionDialog().customQuestionMessage2str(msg, title, opt1, opt2)
if opt1:
iter = 0
else:
result = True # break from while loop
else:
# print strindex + "--" + self.train_name + " calling doDispatch"
self.waitMsec(1000) # wait 1 sec
# wait for the scheduling margin (specified in fast minutes)
# convert scheduling margin to seconds
scheduling_margin_sec = int((float(scheduling_margin_gbl) / float(str(fast_clock_rate))) * 60.0) # fast minutes
# print strindex + "scheduling_margin_sec", scheduling_margin_sec
if iter > scheduling_margin_sec:
if self.logLevel > 0: print strindex + "waited", iter+1, "secs, could not schedule train and gave up"
result = True # break from while loop
# we do not want to call the next edge in the paths
call_next_edge_in_paths = False
else:
if self.logLevel > 0: print strindex + "waited", iter+1, "secs but could not schedule train", train
# end of while. repeat again if result is false and call dispatch again
if self.logLevel > 0: print strindex + "called self.move iterno", iter
if self.logLevel > 0: print strindex + "++++++++++++++++++++++++++++++++++"
# store the current edge for next move
#store current edge information in train
train["edge"] = e
train["penultimate_block_name"] = e.getItem("penultimate_block_name")
# count the paths in
count_path +=1
if self.logLevel > 0: print strindex + "transit finished, removing train from dispatch list" + str(trains_dispatched)
if str(train_name) in trains_dispatched:
# print "str(train_name) in trains_dispatched"
trains_dispatched.remove(str(train_name))
if self.logLevel > 0: print strindex + "removed from trains_dispatched", str(trains_dispatched)
if self.logLevel > 0: print strindex + "&&&&&&&&&&&&&&&&& end move_between_stations &&&&&&&&&&&&&&&&&", self.index
def set_direction(self, train, previous_block, current_block, next_block, previous_direction_from, index = 0):
# global train
strindex = str(index) + " " * 10 #make debugging easier to understand by indenting
if self.logLevel > 2: print "set_direction1: previous_direction_from", previous_direction_from
# We have two cases for the direction to be changed:
# 1) we have a back and forth situation where we can check that the previous_block == next_block
# 2) we reverse and go through a point. there will be no through path from the previous_block to the next next_block
#
# these two cases are not exclusive.
# print "set_direction"
transit_instruction = "same"
if self.logLevel > 0: print strindex + "previous_block", previous_block.getUserName(), "current", current_block.getUserName(), "next", next_block.getUserName()
if previous_block == next_block:
if self.logLevel > 0: print strindex + "previous_block == next_block", previous_block == next_block, "so changing direction"
transit_instruction = "change"
# check if current block is a turntable
for panel in jmri.util.JmriJFrame.getFrameList():
if isinstance(panel, jmri.jmrit.display.layoutEditor.LayoutEditor):
for turntable in panel.getLayoutTurntables():
if turntable.getLayoutBlock() is not None:
if (turntable.getLayoutBlock().getBlock() == current_block) and (current_block != next_block):
if self.logLevel > 0: print strindex + "current_block is a turntable, so changing direction"
transit_instruction = "change"
break
# check if current block is a traverser
for panel in jmri.util.JmriJFrame.getFrameList():
if isinstance(panel, jmri.jmrit.display.layoutEditor.LayoutEditor):
for traverser in panel.getLayoutTraversers():
if traverser.getLayoutBlock() is not None:
if (traverser.getLayoutBlock().getBlock() == current_block) and (current_block != next_block):
# Found the traverser object
entry_slot_index = -1
exit_slot_index = -1
slot_list = traverser.getSlotList()
for i in range(len(slot_list)):
slot = slot_list[i]
ts = slot.getConnect()
if ts is not None and ts.getLayoutBlock() is not None:
connected_block = ts.getLayoutBlock().getBlock()
if connected_block == previous_block: entry_slot_index = i
if connected_block == next_block: exit_slot_index = i
if entry_slot_index != -1 and exit_slot_index != -1 and ((entry_slot_index % 2) == (exit_slot_index % 2)):
if self.logLevel > 0: print strindex + "current_block is a traverser and slots are on the same side, so changing direction"
transit_instruction = "change"
break # Found the traverser, no need to check others
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
current_layout_block = LayoutBlockManager.getLayoutBlock(current_block)
# don't need this as previous block == next block is sufficient
# if not current_layout_block.validThroughPath(previous_block, next_block):
# print ("current_layout_block.validThroughPath",
# current_layout_block.validThroughPath(previous_block, next_block), "so changing direction")
# transit_instruction = "change"
if transit_instruction == "change":
if previous_direction_from == "forward":
transit_direction = "reverse"
else:
transit_direction = "forward"
if self.logLevel > 2: print strindex + "set_direction1: transit_direction", transit_direction
else:
transit_direction = previous_direction_from
if self.logLevel > 2: print strindex + "set_direction1: transit_direction2", transit_direction
train["direction"] = transit_direction
# print "transit_direction", transit_direction
previous_direction_from = transit_direction
return [transit_direction, transit_instruction]
def check_train_in_start_block(self, train_to_move, blockName):
# print "check_train_in_start_block"
# print "checking " , train_to_move, " in " , blockName
block = blocks.getBlock(blockName)
if self.blockOccupied(block):
# print " block Occupied ", self.blockOccupied(block), " value ", block.getValue()
if block.getValue() == train_to_move:
return True
else:
startBlock = block.getUserName()
# print "trying to move from blockName" , blockName, "but not occupied by", "train_to_move", train_to_move
blockName = [block.getUserName() for block in blocks.getNamedBeanSet() if block.getValue() == train_to_move]
if blockName != []:
blockName = blockName[0]
# print "train", train_to_move, "actually in" , blockName
return False
else:
blockName = "train not in any block"
#as the block
block.setValue(train_to_move)
# print "train", train_to_move, "reset in" , blockName
return True
else:
# print "train_to_move", train_to_move, "not in" , blockName
blockName = [block for block in blocks.getNamedBeanSet() if block.getValue() == train_to_move]
if blockName != []:
blockName = blockName[0]
else:
blockName = "train not in any block"
# print "train_to_move", train_to_move, "in" , blockName
return False
def blockOccupied(self, block):
# print "blockOccupied"
if block.getState() == ACTIVE:
state = True
else:
state = False
return state
def get_time_to_stop_in_station(self, edge, direction):
if direction == "forward":
filename_fwd = self.get_filename(edge, "fwd")
trainInfo_fwd = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(filename_fwd)
if trainInfo_fwd is None:
OptionDialog().displayMessage("Route graph out of date. Regenerate Dispatcher System")
return 0
# print "type trainInfo_fwd", type (trainInfo_fwd)
station_wait_time = trainInfo_fwd.getWaitTime()
else:
filename_rvs = self.get_filename(edge, "rvs")
# print "filename_rvs", filename_rvs, "edge", edge
trainInfo_rvs = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(filename_rvs)
if trainInfo_rvs is None:
OptionDialog().displayMessage("Route graph out of date. Regenerate Dispatcher System")
return 0
# print "type trainInfo_rvs", type (trainInfo_rvs)
station_wait_time = trainInfo_rvs.getWaitTime()
if station_wait_time != None:
return math.floor(float(station_wait_time+0)) * 1000 # set in milli secs
else:
return 0
def is_integer(self, n):
try:
if n == None: return False
float(n)
except ValueError:
return False
else:
return float(n).is_integer()
def announce1(self, e, direction, instruction, train):
# print "announce1"
to_name = e.getTarget()
from_name = e.getSource()
speech_reqd = self.speech_required_flag()
self.announce( from_name, to_name, speech_reqd, direction, instruction)
def move(self, e, direction, instruction, train_name, mode="not_scheduling" , index = 0):
strindex = str(index) + " " * 10 # make debugging easier to understand by indenting
# print strindex +"move"
if self.logLevel > 0: print strindex +"++++++++++++++++++++++++"
if self.logLevel > 0: print strindex +"path" , e
if self.logLevel > 0: print strindex +"calling move: Target", e.getTarget(), "Source", e.getSource(),"Train", train_name
if self.logLevel > 0: print strindex +"++++++++++++++++++++++++"
to_name = e.getTarget()
from_name = e.getSource()
sensor_move_name = "MoveInProgress"+to_name.replace(" ","_")
self.set_sensor(sensor_move_name, "active")
speech_reqd = self.speech_required_flag()
#self.announce( from_name, to_name, speech_reqd, direction, instruction) # now done when train arrives in platfor instead of when leaving
if self.logLevel > 0: print strindex +"calling move", train, from_name, to_name
if mode == "not_scheduling":
self.waitMsec(1000) # wait for train to stop dispatching we don't want to start another train before it has stopped properly
if self.train_is_dispatching(train_name, index):
self.wait_till_train_stops_dispatching(train_name, index)
if self.logLevel > 0: print strindex + "waited till train stops dispatching, trying again with new position"
# print strindex + "train is dispatching, trying again with new position"
# self.waitMsec(500)
return False
else:
if self.logLevel > 0: print strindex + "train is not dispatching"
else:
if self.logLevel > 0: print "train is scheduling"
# if mode == "scheduling":
# waited_till_train_stops_dispatching = self.wait_till_train_stops_dispatching(train_name, index) #it might be already doing a dispatch
# if waited_till_train_stops_dispatching:
# # need to try again with new train position
# print strindex +"waited_till_train_stops_dispatching not calling dispatch"
# return False
if self.logLevel > 0: print strindex +"calling dispatch"
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
result = self.call_dispatch(e, direction, train_name, mode, index)
if self.logLevel > 0: print strindex +"exit call_dispatch" , result
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
self.set_sensor(sensor_move_name, "inactive")
if result == True:
# print strindex +"result from calling move is True!!", train, from_name, to_name
# Wait for the Active Trains List to not have the train we wish to start in it
self.wait_till_train_stops_dispatching(train_name, index)
self.set_sensor(sensor_move_name, "inactive")
self.report_train_state(train_name) # just for debugging
if self.logLevel > 0: print strindex +("+++++ sensor " + sensor_move_name + " inactive")
else:
# print strindex +"result from calling move is False!!", train, from_name, to_name
self.set_sensor(sensor_move_name, "inactive")
if self.logLevel > 0: print strindex +"****** finished moving train: called move *******"
return result
def report_train_state(self, train_name):
train = trains[train_name]
direction = train["direction"]
if self.logLevel > 1: print "train direction" , direction
def train_is_dispatching(self, train_name, index):
strindex = str(index) + " " * 10 #make debugging easier to understand by indenting
if self.logLevel > 0: print strindex + "checking if train is dispatching", train_name
DF = jmri.InstanceManager.getDefault(jmri.jmrit.dispatcher.DispatcherFrame)
java_active_trains_list = DF.getActiveTrainsList()
java_active_trains_Arraylist= java.util.ArrayList(java_active_trains_list)
active_train_names_list = [str(t.getTrainName()) for t in java_active_trains_Arraylist]
if train_name in active_train_names_list:
return True
else:
return False
def wait_till_train_stops_dispatching(self, train_name, index = 0):
strindex = str(index) + " " * 10 #make debugging easier to understand by indenting
# print strindex + "wait_till_train_stops_dispatching", train_name
DF = jmri.InstanceManager.getDefault(jmri.jmrit.dispatcher.DispatcherFrame)
java_active_trains_list = DF.getActiveTrainsList()
java_active_trains_Arraylist= java.util.ArrayList(java_active_trains_list)
active_train_names_list = [str(t.getTrainName()) for t in java_active_trains_Arraylist]
while train_name in active_train_names_list:
self.waitMsec(500)
# print strindex + train_name + "in active train list"
java_active_trains_list = DF.getActiveTrainsList()
java_active_trains_Arraylist= java.util.ArrayList(java_active_trains_list)
active_train_names_list = [str(t.getTrainName()) for t in java_active_trains_Arraylist]
if self.logLevel > 0: print (strindex + "+++++ train " + train_name + " stopped dispatching" )
return
def speech_required_flag(self):
# print "speech_required_flag"
self.sound_sensor = sensors.getSensor("soundSensor")
if self.sound_sensor is None:
OptionDialog().displayMessage("No sound Sensor set up")
return None
sound_state = self.sound_sensor.getKnownState()
if self.logLevel > 1: print sound_state,ACTIVE
if sound_state == ACTIVE:
sound_flag = True
else:
sound_flag = False
return sound_flag
def call_dispatch(self, e, direction, train, mode="not_scheduling", index = 0):
global scheduling_margin_gbl, fast_clock_rate
global check_action_route_flag
global check_route_flag
global trains_dispatched
strindex = str(index) + " " * 15 #make debugging easier to understand by indenting
if self.logLevel > 0: print strindex + "+++++++++++++++call_dispatch++++++++++++++++ mode:", train, mode
# for information only
if self.logLevel > 1: print strindex + " in dispatch"
to_name = e.getTarget()
from_name = e.getSource()
if self.logLevel > 1: print ("in call_dispatch: move from " + from_name + " to " + to_name)
# set traininfo filename
if direction == "forward":
filename = self.get_filename(e, "fwd")
else:
filename = self.get_filename(e, "rvs")
if self.logLevel > 1: print strindex + "filename = ", filename, "direction = " , direction
# print strindex + "call_dispatch a"
check_route_active_flag = sensors.getSensor("checkRouteSensor").getKnownState()
if check_route_active_flag == ACTIVE:
check_route_flag = True
else:
check_route_flag = False
if self.logLevel > 0: print strindex + "check_route_flag", check_route_flag
# initialise globals to False if not set
if 'check_action_route_flag' not in globals():
check_action_route_flag = False
# wait for blocks to be clear before allocating (if required)
if check_route_flag == True or check_action_route_flag == True: # can ask for route to be checked globally or in action
# print strindex + "call_dispatch b1"
# print strindex + "checking route is clear", from_name
self.wait_route_is_clear(filename, from_name, train)
t = trains[train] #train is train_name
t["allocating"] = True
if self.logLevel > 0: print self.train_name, "route", filename, "is clear"
if self.logLevel > 0: print strindex + "appending trains_dispatched", trains_dispatched
if str(train) not in trains_dispatched: #have to checl because added each transit of route
trains_dispatched.append(str(train))
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
# run dispatch
if self.logLevel > 0: print strindex + "%%%%%%%%%calling doDispatch"
result = self.doDispatch(filename, "ROSTER", train, mode, index)
if self.logLevel > 0: print strindex + "%%%%%%%%%exiting doDispatch A"
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
# # when scheduling the dispatch is normally not called until the previous dispatch is complete
# # we will keep this in for now even though better in calling routine
# # definitely cannot recall doDispatch from here in non-scheduling mode
#
# if mode != "not_scheduling and result == False": # i.e. if scheduling
# print strindex + "scheduling mode code"
# print strindex + "mode" , mode
# # keep repeating until the scheduling margin is reached
# iter = 0
# while result == False:
# # print strindex + "--" + self.train_name + " calling doDispatch"
# self.waitMsec(1000) # wait 1 sec
# # wait for the scheduling margin (specified in fast minutes)
# # convert scheduling margin to seconds
# scheduling_margin_sec = int((float(scheduling_margin_gbl) / float(str(fast_clock_rate))) * 60.0) # fast minutes
# # print strindex + "scheduling_margin_sec", scheduling_margin_sec
# if iter > scheduling_margin_sec:
# if self.logLevel > 0: print strindex + "waited", iter+1, "secs, could not schedule train and gave up"
# return result
# else:
# if self.logLevel > 0: print strindex + "waited", iter+1, "secs but could not schedule train", train
#
# result = self.doDispatch(filename, "ROSTER", train, mode, index)
# if self.logLevel > 0: print strindex + "exiting doDispatch B"
# iter += 1
#return result
if self.logLevel > 0: print strindex + "+++++++++++++exit call_dispatch+++++++++++++++++ result", result
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
return result
def initialise_if_not_set(self, global_name, state):
if 'global_name' not in globals():
global_name = state
def get_filename(self, e, suffix):
# print "get_filename"
# suffix is "fwd" or "rvs"
# e is edge
from_station_name = g.g_express.getEdgeSource(e)
to_station_name = g.g_express.getEdgeTarget(e)
neighbor_name = e.getItem("neighbor_name")
index = e.getItem("index")
filename = "From " + str(from_station_name) + " To " + str(to_station_name) + " Via " + str(neighbor_name) + " " + str(index)
filename = filename.replace(" ", "_")
filename = filename + "_" + suffix + ".xml"
return filename
# Dispatch (<filename.xml>, [USER | ROSTER | OPERATIONS >,<dccAddress, RosterEntryName or Operations>
def doDispatch(self, traininfoFileName, type, train_name, mode = "not_scheduling", index = 0):
global trains_dispatched
strindex = str(index) + " " * 20 #make debugging easier to understand by indenting
if self.logLevel > 0: print strindex + "doDispatch"
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
DF = jmri.InstanceManager.getDefault(jmri.jmrit.dispatcher.DispatcherFrame)
if self.logLevel > 1: print strindex + "traininfoFileName",traininfoFileName
if train_name in trains:
train = trains[train_name]
else:
if self.logLevel > 0: print strindex + "train", train_name , "cannot be dispatched", "trains", trains
return False
self.trainInfo = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(traininfoFileName)
self.modify_trainInfo(train_name) # sets the speed factor and other train dependent factors
transit_name = self.trainInfo.getTransitName()
self.transit_name = transit_name # allow calling routine to use transit_name
#print strindex + "traininfoFileName", traininfoFileName
jmri.jmrit.dispatcher.TrainInfoFile().writeTrainInfo(self.trainInfo, traininfoFileName)
# print strindex + "__" + train_name + " calling loadTrainFromTrainInfo"
# print strindex + "DF.dispatcherSystemSchedulingInOperation before", DF.dispatcherSystemSchedulingInOperation
DF.dispatcherSystemSchedulingInOperation = True # to inhibit error message when train started but not in station
# print strindex + "DF.dispatcherSystemSchedulingInOperation", DF.dispatcherSystemSchedulingInOperation
if mode != "not_scheduling": # == scheduling
# if self.logLevel > 0: print strindex + "__________________________Start__" + self.train_name + "__transit: " + transit_name
if self.logLevel > 0: print "__________________________Start__" + self.train_name + "__transit: " + transit_name
else:
if self.logLevel > 0: print strindex + "_Start__" + self.train_name + "__transit: " + transit_name
# run the train, setting the flag that the train is doing a dispatch
result = DF.loadTrainFromTrainInfo(self.trainInfo, type, train_name)
if self.logLevel > 0: print strindex + "loaded returning with code ", result
if self.logLevel > 0: print strindex + "trains_dispatched", trains_dispatched
if result == 0:
# print strindex + "--" + self.train_name + " called doDispatch; transit name: " + transit_name
self.set_whether_to_stop_at_sensor(DF)
train["allocating"] = False # this flag is used when checking to see whether path for dispatch is clear
if result == -1:
if self.logLevel > 0: print strindex + "did not run train ", train_name , "aborting: result from loading train:" , result
# did not work properly
# # delete the transit so can try loading the transit again
# self.trainInfo = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(traininfoFileName)
# transit_name = self.trainInfo.getTransitName()
# active_train_list = [active_train for active_train in DF.getActiveTrainsList() \
# if active_train.getTransitName() == transit_name]
# if active_train_list == []:
# active_train = None
# else:
# active_train = active_train_list[0]
# print strindex + "terminating active_train", active_train, "train", train_name, "active_train_list", active_train_list
# DF.terminateActiveTrain(active_train, True, False)
# if train_name in trains:
# trains.pop(train_name)
return False #No train allocated
else:
DF = None
if mode != "not_scheduling": # == scheduling
if self.logLevel > 0: print strindex + "__________________________End____" + self.train_name + "__transit: " + transit_name
else:
if self.logLevel > 0: print strindex + "_End____" + self.train_name + "__transit: " + transit_name
return True
def get_train_length(self, new_train_name):
# print "get_train_length"
EngineManager=jmri.InstanceManager.getDefault(jmri.jmrit.operations.rollingstock.engines.EngineManager)
engineRoad = "Set by Dispatcher System"
engineNumber = new_train_name
engine = EngineManager.newRS(engineRoad, engineNumber)
# get the current length of the engine
default = "10"
current_length = engine.getLength()
if current_length == "0":
current_length = default
return [engine, current_length]
def get_train_speed_factor(self, new_train_name):
# print "get_train_speed_factor"
EngineManager=jmri.InstanceManager.getDefault(jmri.jmrit.operations.rollingstock.engines.EngineManager)
engineRoad = "Set by Dispatcher System"
engineNumber = new_train_name
engine = EngineManager.newRS(engineRoad, engineNumber)
# get the current speed factor of the engine
default = "100" # percentage
comment = engine.getComment()
split_comment = []
if "speed factor" in comment:
split_comment = comment.split(" ")
index = split_comment.index("speed")
# print "len(split_comment)", len(split_comment), "index + 2", index + 2
if len(split_comment) > index + 2:
speed_factor = split_comment[index+2]
else:
speed_factor = default
else:
speed_factor = default
return [engine, speed_factor]
def get_stopping_length_fraction(self):
transit_name = self.trainInfo.getTransitName()
# this has _fwd or _rvs at end. Remove these to get edge
edge = transit_name.replace("_fwd","").replace("rvs", "")
# trainInfo_fwd = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(filename_fwd)
# filename_fwd = self.get_filename(edge, "fwd")
dm = DispatchMaster()
last_section = dm.last_section_of_transit(self.trainInfo)
length_of_last_section = float(dm.length_of_last_section(last_section))/10.0 # length in cm
overall_stopping_position = ResetButtonMaster().get_overall_stopping_distance()
[_, individual_stopping_position] = dm.get_stopping_position(edge)
# the stopping position is made up of one for a particular transit
# plus an overall one affecting all transits
total_stopping_position = individual_stopping_position + overall_stopping_position
stopping_length_fraction = 1.0-(float(total_stopping_position)/float(length_of_last_section))
return stopping_length_fraction
def modify_trainInfo(self, train_name):
# print "modify_trainInfo"
# setTrainLengthUnits to scalemetres
tlu = jmri.jmrit.dispatcher.ActiveTrain(None,None,0).TrainLengthUnits
# x = tlu.TRAINLENGTH_SCALEMETERS
# print "TRAINLENGTH_SCALEMETERS= ", x
self.trainInfo.setTrainLengthUnits(tlu.TRAINLENGTH_SCALEMETERS) #scale metres
# setMaxTrainLength (in scale metres)
[engine,current_length] = self.get_train_length(train_name) #get the engine name
self.trainInfo.setMaxTrainLengthScaleMeters(float(current_length))
# setSpeedFactor
# print "in modify_trainInfo1 "
[engine,current_speed_factor] = self.get_train_speed_factor(train_name)
# print "in modify_trainInfo2 ", current_speed_factor
speedFactor = float(current_speed_factor)/100.0
# print "in modify_trainInfo2 speedFactor", speedFactor
# print "in modify_trainInfo2 a"
if speedFactor >= 2 or speedFactor <=0:
speedFactor = 1
msg = "speedFactor set is out of range " + str(current_speed_factor) + "\nSpeed Factor set to 100% " + "for train " + train_name
OptionDialog().displayMessage(msg)
self.trainInfo.setSpeedFactor(float(speedFactor))
# set the stopbyspeedprofileadjust (stopping length)
stopbyspeedprofileadjust = self.get_stopping_length_fraction()
self.trainInfo.setStopBySpeedProfileAdjust(stopbyspeedprofileadjust)
# setMinReliableOperatingSpeed
percentage = 10.0
self.trainInfo.setMinReliableOperatingSpeed(percentage/100)
# set wait for block to be clear before running transit
transit_name = self.trainInfo.getTransitName()
folder = "restrictTransits"
filename = "restrictTransits.txt"
restricted_transits = DispatchMaster().read_list(folder,filename)
if restricted_transits[0] != "":
filtered_restricted_transits = [ t for t in restricted_transits if t[0] == transit_name]
if filtered_restricted_transits != []:
[transit_name1, transit_block_name] = filtered_restricted_transits
trainInfo_fwd.setBlockName(new_transit_block_name)
if self.logLevel > 0: print "self.forward_stopping_sensor_exists(self.trainInfo)",self.forward_stopping_sensor_exists(self.trainInfo)
# print "sensors.getSensor('stopAtStopSensor').getKnownState()", sensors.getSensor("stopAtStopSensor").getKnownState(), ACTIVE
def set_whether_to_stop_at_sensor(self, DF):
# print "set_whether_to_stop_at_sensor"
transit_name = self.trainInfo.getTransitName()
if self.logLevel > 0: print "transit_name", transit_name
active_train_list = [active_train for active_train in DF.getActiveTrainsList() \
if active_train.getTransitName() == transit_name]
if self.logLevel > 0: print "active_train_list", active_train_list
active_train = active_train_list[0]
if self.logLevel > 0: print "active_train", active_train
autoActiveTrain = active_train.getAutoActiveTrain()
if self.forward_stopping_sensor_exists(self.trainInfo):
if self.logLevel > 0: print "forward_stopping_sensor_exists"
# set default
if sensors.getSensor("stopAtStopSensor").getKnownState() == ACTIVE:
if self.logLevel > 0: print "stop at stop sensor active", sensors.getSensor("stopAtStopSensor").getKnownState(), ACTIVE
autoActiveTrain.set_useStopSensor(True)
else:
if self.logLevel > 0: print "stop at stop sensor inactive", sensors.getSensor("stopAtStopSensor").getKnownState(), INACTIVE
if self.logLevel > 0: print "before", self.trainInfo.getStopBySpeedProfile(), self.trainInfo.getUseSpeedProfile()
autoActiveTrain.set_useStopSensor(False)
# overwrite with set values
if self.stop_mode is None or self.stop_mode == "" or self.stop_mode == "Use Default":
if self.logLevel > 0: print "Use Defailt"
pass
elif self.stop_mode == "Use Stop Sensor":
autoActiveTrain.set_useStopSensor(True)
if self.logLevel > 0: print "set stop sensor True"
elif self.stop_mode == "Use Speed Profile":
autoActiveTrain.set_useStopSensor(False)
if self.logLevel > 0: print "set_useStopSensor False"
else:
print "ERROR incorrect value for stop mode"
else:
if self.logLevel > 0: print "forward_stopping_sensor does not exist"
def forward_stopping_sensor_exists(self, traininfo):
# print "forward_stopping_sensor_exists"
transit_name = traininfo.getTransitId()
transit = transits.getTransit(transit_name)
transit_section_list = transit.getTransitSectionList()
section_list = transit.getSectionListBySeq(transit.getMaxSequence())
section = section_list[0]
forward_stopping_sensor = section.getForwardStoppingSensor()
if forward_stopping_sensor != None:
return True
else:
return False
def set_sensor(self, sensorName, sensorState):
sensor = sensors.getSensor(sensorName)
if sensor is None:
self.displayMessage('{} - Sensor {} not found'.format(self.threadName, sensorName))
return
if sensorState == 'active':
newState = ACTIVE
elif sensorState == 'inactive':
if self.logLevel > 1: print "set_sensor ", sensorName, 'inactive'
newState = INACTIVE
else:
self.displayMessage('{} - Sensor state, {}, is not valid'.format(self.threadName, sensorState))
sensor.setKnownState(newState)
return
def wait_sensor(self, sensorName, sensorState):
# print "wait_sensor"
sensor = sensors.getSensor(sensorName)
if sensor is None:
self.displayMessage('{} - Sensor {} not found'.format(self.threadName, sensorName))
return
if sensorState == 'active':
self.waitSensorActive(sensor)
elif sensorState == 'inactive':
self.waitSensorInactive(sensor)
else:
self.displayMessage('{} - Sensor state, {}, is not valid'.format(self.threadName, sensorState))
## ***********************************************************************************
## sound routines
## ***********************************************************************************
def getOperatingSystem(self):
#detecting the operating system using `os.name` System property
os = java.lang.System.getProperty("os.name")
os = os.lower()
if "win" in os:
return "WINDOWS"
elif "nix" in os or "nux" in os or "aix" in os:
return "LINUX"
elif "mac" in os:
return "MAC"
return None
def speak(self, msg):
os = self.getOperatingSystem()
if os == "WINDOWS":
self.speak_windows(msg)
elif os == "LINUX":
self.speak_linux(msg)
elif os == "MAC":
self.speak_mac(msg)
def speak_windows(self,msg) :
try:
cmd1 = "Add-Type -AssemblyName System.Speech"
cmd2 = '$SpeechSynthesizer = New-Object -TypeName System.Speech.Synthesis.SpeechSynthesizer'
cmd3 = "$SpeechSynthesizer.Speak('" + msg + "')"
cmd = cmd1 + ";" + cmd2 + ";" + cmd3
os.system("powershell " + cmd )
except:
msg = "Announcements not working \n Only supported on windows versions with powershell and SpeechSynthesizer"
JOptionPane.showMessageDialog(None, msg, "Warning", JOptionPane.WARNING_MESSAGE)
def speak_mac(self, msg):
try:
java.lang.Runtime.getRuntime().exec("say {}".format(msg))
except:
msg = "Announcements not working \n say not working on your Mac"
JOptionPane.showMessageDialog(None, msg, "Warning", JOptionPane.WARNING_MESSAGE)
def speak_linux(self, msg):
try:
#os.system("""echo %s | spd-say -e -w -t male1""" % (msg,))
#os.system("""echo %s | spd-say -e -w -t female3""" % (msg,))
#os.system("""echo %s | spd-say -e -w -t child_male""" % (msg,))
os.system("""echo %s | spd-say -e -w -t child_female""" % (msg,)) #slightly slower
except:
msg = "Announcements not working \n spd-say not set up on your linux system"
JOptionPane.showMessageDialog(None, msg, "Warning", JOptionPane.WARNING_MESSAGE)
def announce(self, fromblockname, toblockname, speak_on, direction, instruction):
# print "announce"
from_station = self.get_station_name(fromblockname)
to_station = self.get_station_name(toblockname)
if speak_on == True:
if direction == "forward":
platform = " platform 1 "
else:
platform = " platform 2 "
self.speak("The train in" + platform + " is due to depart to " + to_station)
#self.speak("The train in "+ from_station + " is due to depart to " + to_station )
def get_station_name(self, block_name):
# print "get_station_name"
BlockManager = jmri.InstanceManager.getDefault(jmri.BlockManager)
block = BlockManager.getBlock(block_name)
comment = block.getComment()
# % is the delimeter for block name
delimeter = '"'
if delimeter in comment:
station_name = self.get_substring_between_delimeters(comment, delimeter)
else:
station_name = block_name
return station_name
def get_substring_between_delimeters(self, comment, delimeter):
start = delimeter
end = delimeter
s = comment
substring = s[s.find(start)+len(start):s.rfind(end)]
return substring
def bell(self, bell_on = "True"):
# print "bell"
if bell_on == "True":
snd = jmri.jmrit.Sound("resources/sounds/Bell.wav")
snd.play()
def do_not_start_trains_simultaneously(self):
# print "do_not_start_trains_simultaneously"
global time_last_train
time_now = int(round(time.time() * 1000))
time_train = math.max(time_now,time_last_train)
time_to_wait = time_train - time_now
time_last_train = time_train + 1000 #store the time this train will start
self.waitMsec(time_to_wait) #make this train wait for 1 sec after previous train
def wait_route_is_clear(self, traininfoFileName, startBlockName, train):
route_is_occupied = True # occupied
i = 0
while route_is_occupied : #require 1 occurrences of route not occupied
i = i+1
route_is_occupied = \
self.check_route_is_allocated_or_occupied(traininfoFileName, startBlockName)
if route_is_occupied:
if i == 1: print train, "waiting for route", traininfoFileName, "to be clear"
self.waitMsec(1000)
def check_route_is_allocated_or_occupied(self, traininfoFileName, startBlockName):
# print "check_route_is_allocated_or_occupied"
[transit_name, transit_id] = self.get_transit(traininfoFileName)
TransitManager = jmri.InstanceManager.getDefault(jmri.TransitManager)
transit = TransitManager.getTransit(transit_name)
if self.logLevel > 0: print "transit_name", transit_name, "transit_id", transit_id
block_list = [block for block in transit.getInternalBlocksList() if block.getUserName() != startBlockName]
if self.logLevel > 0: print "block_list", [block.getUserName() for block in block_list]
route_is_occupied = False
#add the block that must be clear for the transit to run
trainInfo = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(traininfoFileName)
transit_block_name = trainInfo.getBlockName()
if transit_block_name != "":
transit_block = blocks.getBlock(transit_block_name)
# print "appending", transit_block_name, transit_block
block_list.append(transit_block)
index = 0
for block in block_list:
index += 1
#getValue is set if the track is occupied
if block.getSensor().getKnownState() == ACTIVE: # check if block is occupied
route_is_occupied = True
if self.logLevel > 0: print block.getUserName() , "is not clear value =", block.getSensor().getKnownState(), index
break
else:
if self.logLevel > 0: print block.getUserName() , "is clear value =", block.getSensor().getKnownState(), index
# getExtraColor is set if the block is allocated
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
layoutBlock = LayoutBlockManager.getLayoutBlock(block)
if layoutBlock.getUseExtraColor():
route_is_occupied = True
if self.logLevel > 0: print block.getUserName() , "is not clear (extracolor) value =", block.getSensor().getKnownState(), index
break
if self.logLevel > 0: print "route_is_occupied", route_is_occupied; print
# DF = jmri.InstanceManager.getDefault(jmri.jmrit.dispatcher.DispatcherFrame)
# java_active_trains_list = DF.getActiveTrainsList()
# java_active_trains_Arraylist= java.util.ArrayList(java_active_trains_list)
# active_train_names_list = [str(t.getTrainName()) for t in java_active_trains_Arraylist]
# if self.logLevel > 0: print "active_train_names_list", active_train_names_list
# for train_name in active_train_names_list:
# # print "trains", trains
# # print "train_name", train_name
# train = trains[train_name]
# if train["allocating"] == True:
# route_is_occupied = True # only allow one dispatch to be set up at a time else this routine does not work
# # we don't want to check that the route is clear, and then have an allocation take place immediately after
# print "route_is_occupied state is:", route_is_occupied
return route_is_occupied
def set_route_allocated(self, traininfoFileName, startBlockName):
# print "set_route_allocated"
[transit_name, transit_id] = self.get_transit(traininfoFileName)
TransitManager = jmri.InstanceManager.getDefault(jmri.TransitManager)
transit = TransitManager.getTransit(transit_name)
if self.logLevel > 0: print "transit_name", transit_name, "transit_id", transit_id
block_list = [block for block in transit.getInternalBlocksList() if block.getUserName() != startBlockName]
for block in block_list:
# getExtraColor is set if the block is allocated
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
layoutBlock = LayoutBlockManager.getLayoutBlock(block)
layoutBlock.setUseExtraColor(True)
if self.train_name == "shunter": print " ",
if self.logLevel > 0: print "allocated route", traininfoFileName
def get_transit(self, filename):
# print "get_transit"
trainInfo = jmri.jmrit.dispatcher.TrainInfoFile().readTrainInfo(filename)
transit_name = trainInfo.getTransitName()
transit_id = trainInfo.getTransitId()
return [transit_name, transit_id]
class NewTrainMaster(jmri.jmrit.automat.AbstractAutomaton):
# responds to the newTrainSensor, and allocates trains available for dispatching
# we make the allocated flag global as we will use it in DispatchMaster when we dispatch a train
global trains_allocated
def init(self):
self.logLevel = 0
if self.logLevel > 0: print 'Create Stop Thread'
self.od = OptionDialog()
def setup(self):
global trains_allocated
#self.initialise_train()
newTrainSensor = "newTrainSensor"
self.new_train_sensor = sensors.getSensor(newTrainSensor)
if self.new_train_sensor is None:
return False
self.new_train_sensor.setKnownState(INACTIVE)
if 'trains_allocated' not in globals():
trains_allocated = []
self.od = OptionDialog()
return True
def handle(self):
global trains_allocated
#this repeats
# wait for a sensor requesting to check for new train
if self.logLevel > 0: print ("wait for a sensor requesting to check for new train")
self.waitSensorActive(self.new_train_sensor)
self.new_train_sensor.setKnownState(INACTIVE)
#display the allocated trains
title = "Setup trains"
msg = "setup one or more trains"
opt1 = "1 train"
opt2 = "several trains"
opt3 = "check/swap train direction"
opt4 = "modify existing trains"
#opt4 = "reset trains"
action = self.od.customQuestionMessage4str(msg, title, opt1, opt2, opt3, opt4)
if self.od.CLOSED_OPTION == True: #check of optionbox was closed prematurely
pass
elif action == "1 train":
# print "trains_allocated", trains_allocated
# msg = "choose"
# actions = ["setup 1 train","setup 2+ trains"]
# action = self.od.List(msg, actions)
# if action == "setup 1 train":
station_block_name, new_train_name = self.check_new_train_in_siding()
if self.logLevel > 0: print "station_block_name",station_block_name, "existing train name", new_train_name
if station_block_name != None:
# take actions for new train
# if new_train_name == None:
if True:
all_trains = self.get_all_roster_entries_with_speed_profile()
sections_to_choose = self.get_non_allocated_trains_sections()
if all_trains == []:
msg = "There are no engines with speed profiles, cannot operate without any"
JOptionPane.showMessageDialog(None,msg)
elif len(sections_to_choose)>1:
# msg = self.get_all_trains_msg()
# title = None
# opt1 = "Select section"
# s = self.od.customMessage(msg, title, opt1)
# if self.logLevel > 0: print "station_block_name",station_block_name, "s", s
# if self.od.CLOSED_OPTION == False:
msg = "Select section"
sections_to_choose = self.get_non_allocated_trains_sections()
new_section_name = self.od.List(msg, sections_to_choose)
if self.od.CLOSED_OPTION == False:
msg = "Select the train in " + new_section_name
trains_to_choose = self.get_non_allocated_trains()
if trains_to_choose == []:
s = OptionDialog().displayMessage("no more trains with speed profiles \nto select")
else:
new_train_name = self.od.List(msg, trains_to_choose)
if self.od.CLOSED_OPTION == False:
if new_train_name not in trains_allocated:
trains_allocated.append(new_train_name)
# print "trains allocated", trains_allocated
#print "*****", "new_train_name", new_train_name, "new_section_name", new_section_name
self.add_to_train_list_and_set_new_train_location(new_train_name, new_section_name)
if self.od.CLOSED_OPTION == False: #only do this if have not closed a frame in add_to_train_list_and_set_new_train_location
self.set_blockcontents(new_section_name, new_train_name)
self.set_length(new_train_name)
self.set_speed_factor(new_train_name)
else:
if self.logLevel > 0 : print "!!!!5"
trains_to_choose = self.get_non_allocated_trains()
title = "In " + station_block_name + " Select train roster"
list_items = trains_to_choose
new_train_name = self.od.List(title, list_items, preferred_size = "default")
if new_train_name not in trains_allocated:
trains_allocated.append(new_train_name)
self.add_to_train_list_and_set_new_train_location(new_train_name, station_block_name)
self.set_blockcontents(station_block_name, new_train_name)
self.set_length(new_train_name)
self.set_speed_factor(new_train_name)
else:
if self.logLevel > 0: print "about to show message no new train in siding"
msg = self.get_all_trains_msg()
msg += "\nPut a train in a section so it can be allocated!\n"
title = "All trains allocated"
opt1 = "Continue"
opt2 = "Delete the trains already set up and start again"
ans = self.od.customQuestionMessage2str(msg, title, opt1, opt2)
if self.od.CLOSED_OPTION == True:
pass
elif ans == opt2:
self.reset_allocation1()
elif action == "several trains":
self.hideGui()
createandshowGUI(self, action)
elif action == "modify existing trains":
self.hideGui()
createandshowGUI(self, action)
elif action == "check/swap train direction":
self.check_swap_train_direction()
return True
def check_swap_train_direction(self):
trains_to_choose = self.get_allocated_trains()
# print "trains_to_choose", trains_to_choose
if trains_to_choose == []:
s = OptionDialog().displayMessage("no allocated trains to select")
else:
msg = "Select the required train"
new_train_name = self.od.List(msg, trains_to_choose)
self.swap_train_direction1(new_train_name)
def swap_train_direction1(self, train_name):
train_block_array = \
[block.getUserName() for block in blocks.getNamedBeanSet() if block.getValue() == train_name]
if train_block_array == []:
OptionDialog().displayMessage(train_name + " is not allocated")
return
train_block = \
[block.getUserName() for block in blocks.getNamedBeanSet() if block.getValue() == train_name][0]
if train_block is not None:
self.check_train_direction(train_name, train_block)
def hideGui(self):
global CreateAndShowGUI_frame
if "CreateAndShowGUI_frame" in globals():
CreateAndShowGUI_frame.setVisible(False)
def check_train_direction(self, train_name, station_block_name):
global train
if train_name in trains:
train = trains[train_name]
direction = train["direction"]
penultimate_layout_block = self.get_penultimate_layout_block(station_block_name)
saved_state = penultimate_layout_block.getUseExtraColor()
in_siding = self.in_siding(station_block_name)
closed = False
while closed == False:
penultimate_layout_block.setUseExtraColor(True)
direction = train["direction"]
msg = "train travelling " + self.swap_direction(direction) + " towards highlighted block"
title = "swap directions of " + train_name
opt1 = "swap direction"
opt2 = "Close"
s = OptionDialog().customQuestionMessage2str(msg, title, opt1, opt2)
if s == JOptionPane.CLOSED_OPTION:
closed = True
if s == opt1:
self.swap_train_direction(train_name)
closed = False
if s == opt2:
closed = True
penultimate_layout_block.setUseExtraColor(saved_state)
def swap_train_direction(self, train_name):
global train
if train_name in trains:
train = trains[train_name]
direction = train["direction"]
train["direction"] = self.swap_direction(direction)
def swap_direction(self, direction):
if direction == "reverse":
direction = "forward"
else:
direction = "reverse"
return direction
def get_train_length(self, new_train_name):
EngineManager=jmri.InstanceManager.getDefault(jmri.jmrit.operations.rollingstock.engines.EngineManager)
engineRoad = "Set by Dispatcher System"
engineNumber = new_train_name
engine = EngineManager.newRS(engineRoad, engineNumber)
#get the current length of the engine
default = "10"
current_length = engine.getLength()
# print "current_length", current_length
# print "type", type(current_length) , "test", str(current_length) == "0"
if str(current_length) == "0" or current_length is None:
current_length = default # current length is in unicode
engine.setLength(current_length)
# print "current_length2", current_length
return [engine, current_length]
def set_length(self, new_train_name):
if new_train_name is None: return
title = "Set the length of the engine/train"
# msg = str(fred)
request = "Change"
while request == "Change":
[engine,current_length] = self.get_train_length(new_train_name)
if current_length == None: return
# print "current_length3", current_length
# current_length is an integer, and is set to a default of 10 scale metres
gauge = WarrantPreferences.getDefault().getLayoutScale()
length_in_cm_float = (float(current_length) / gauge) * 100.0
length_in_cm_str = str("{:.2f}".format(length_in_cm_float))
length_in_inches_float = (float(current_length) / gauge / 2.54) * 100.0
length_in_inches_str = str("{:.2f}".format(length_in_inches_float))
msg = "<html>length of " + new_train_name + " = " + str(current_length) + " scale metres" + \
"<br> gauge : " + "1:" + str(int(gauge)) + \
"<br> length in cm : " + length_in_cm_str + \
"<br> length in inches: " + length_in_inches_str
opt1 = "OK"
opt2 = "Change"
request = self.od.customQuestionMessage2str(msg,title,opt1, opt2)
if request == "Change":
#set the new length
msg = "input length of " + new_train_name + " in scale metres"
title = "length of " + new_train_name
default_value = current_length
new_length = self.od.input(msg, title, default_value)
engine.setLength(new_length)
def set_length0(self, new_train_name):
[engine,current_length] = self.get_train_length(new_train_name)
engine.setLength(current_length)
def get_train_speed_factor(self, new_train_name):
EngineManager=jmri.InstanceManager.getDefault(jmri.jmrit.operations.rollingstock.engines.EngineManager)
engineRoad = "Set by Dispatcher System"
engineNumber = new_train_name
engine = EngineManager.newRS(engineRoad, engineNumber)
# get the current speed factor of the engine
default = "100" # percentage
comment = engine.getComment()
split_comment = []
if "speed factor" in comment:
split_comment = comment.split(" ")
index = split_comment.index("speed")
# print "len(split_comment)", len(split_comment), "index + 2", index + 2
if len(split_comment) > index + 2:
speed_factor = split_comment[index+2]
else:
speed_factor = default
else:
speed_factor = default
return [engine, speed_factor]
def set_speed_factor(self, new_train_name):
[engine, current_speed_factor] = self.get_train_speed_factor(new_train_name)
# if current_length == "0":
# default = "10"
# current_speed_factor = default
# engine.setSpeedFactor(default)
#ask if want to change length
title = "Scale the speed of the engine/train"
msg = "speed factor of " + new_train_name + " = " + str(current_speed_factor) + "%"
opt1 = "OK"
opt2 = "Change"
request = self.od.customQuestionMessage2str(msg,title,opt1, opt2)
if request == "Change":
#set the new speed factor
msg = "input speed factor % of " + new_train_name
title = "speed factor of " + new_train_name
default_value = current_speed_factor
new_speed_factor= self.od.input(msg, title, default_value)
new_speed_factor = "speed factor " + new_speed_factor
engine.setComment(new_speed_factor)
def set_speed_factor0(self, new_train_name): # used in set several trains
[engine, current_speed_factor] = self.get_train_speed_factor(new_train_name)
new_speed_factor = "speed factor " + current_speed_factor
engine.setComment(new_speed_factor)
def get_allocated_trains_msg(self):
allocated_trains =[ str(train) + " in block " + str(trains[train]["edge"].getTarget()) for train in trains_allocated]
if allocated_trains ==[]:
msg = "There are no trains in blocks that are not allocated. \n"
else:
msg = "The allocated trains are: \n" +'\n'.join(allocated_trains)
return msg
def get_allocated_trains(self):
return trains_allocated
def get_non_allocated_trains(self):
all_trains = self.get_all_roster_entries_with_speed_profile()
non_allocated_trains = copy.copy(all_trains)
for train in trains_allocated:
if train in non_allocated_trains:
non_allocated_trains.remove(train)
return non_allocated_trains
def get_non_allocated_trains_msg(self):
trains_in_sections_allocated1 = self.trains_in_sections_allocated()
msg = "the non-allocated trains are in sections: \n\n" + "\n".join([" " + str(train[0]) for train in trains_in_sections_allocated1 if train[2] == "non-allocated"])
return msg
def get_all_sections(self):
return [section for section in sections.getNamedBeanSet()]
def get_all_blocks(self):
return [block for block in blocks.getNamedBeanSet()]
def get_sections_for_trains_in_table(self, trains_in_table):
return [str(train) for train in trains_in_table]
def get_non_allocated_trains_sections(self):
trains_in_sections_allocated1 = self.trains_in_sections_allocated()
# print "trains_in_sections_allocated1", trains_in_sections_allocated1
return [str(train[0]) for train in trains_in_sections_allocated1 if train[2] == "non-allocated"]
def get_allocated_trains_sections(self):
trains_in_sections_allocated1 = self.trains_in_sections_allocated()
return [str(train[0]) for train in trains_in_sections_allocated1 if train[2] == "allocated"]
def get_all_trains_msg(self):
return self.get_allocated_trains_msg() + "\n" + self.get_non_allocated_trains_msg()
def reset_allocation(self):
global trains_allocated
if trains_allocated == []:
if self.logLevel > 0: print ("a")
msg = "Nothing to reset"
OptionDialog().displayMessage(msg)
else:
if self.logLevel > 0: print ("b")
msg = "Select train to modify"
train_name_to_remove = modifiableJComboBox(trains_allocated,msg).return_val()
trains_allocated.remove(train_name_to_remove)
self.new_train_sensor.setKnownState(ACTIVE)
def reset_allocation1(self):
global trains_allocated
if trains_allocated == []:
if self.logLevel > 0: print ("a")
msg = "Nothing to reset"
OptionDialog().displayMessage(msg)
else:
if self.logLevel > 0: print ("b")
#set trains_allocated to []
for train_name_to_remove in trains_allocated:
msg = "Select train to modify"
#train_name_to_remove = modifiableJComboBox(trains_allocated,msg).return_val()
trains_allocated.remove(train_name_to_remove) #remove the train from trains_allocated
self.reset_train_in_blocks(train_name_to_remove) #remove the blockcontents text
if self.logLevel > 0: print "trains_allocated",trains_allocated
#self.new_train_sensor.setKnownState(ACTIVE)
def get_all_roster_entries_with_speed_profile(self):
roster_entries_with_speed_profile = []
r = jmri.jmrit.roster.Roster.getDefault()
for roster_entry in jmri.jmrit.roster.Roster.getAllEntries(r):
if self.logLevel > 0: print "roster_entry.getSpeedProfile()",roster_entry,roster_entry.getSpeedProfile()
if roster_entry.getSpeedProfile() != None:
roster_entries_with_speed_profile.append(roster_entry.getId())
if self.logLevel > 0: print "roster_entry.getId()",roster_entry.getId()
return roster_entries_with_speed_profile
def add_to_train_list_and_set_new_train_location(self, train_name, station_block_name):
# called by setup 1 train
# trains is a dictionary, with keys of the train_name
# each value is itself a dictionary with 3 items
# edge
# penultimate_block_name
# direction
global train
global trains_allocated
if train_name not in trains:
trains[train_name] = {}
train = trains[train_name]
train["train_name"] = train_name
else:
#train_name = self.get_train_name()
self.set_train_in_block(station_block_name, train_name)
# 2) set the last traversed edge to the edge going into the siding
edge = None
j = 0
#print "edge_before" , edge
#print "g.g_stopping.edgesOf(station_block_name)",g.g_stopping.edgesOf(station_block_name)
break1 = False
for e in g.g_stopping.edgeSet():
j+=1
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
station_block = LayoutBlockManager.getLayoutBlock(station_block_name)
number_neighbors = station_block.getNumberOfNeighbours()
#print "station block number neighbors", number_neighbors
in_siding = (number_neighbors == 1)
#print "in_siding", in_siding
for i in range(station_block.getNumberOfNeighbours()):
neighbor_name = station_block.getNeighbourAtIndex(i).getDisplayName()
if e.getItem("penultimate_block_name") == neighbor_name and e.getItem("last_block_name") == station_block_name:
edge = e
break1 = True
if break1 == True:
break
#print "******************************++"
if edge == None:
print "Error the required block has not been found1. restart and try again. Sorry!"
return
train["edge"] = edge
train["penultimate_block_name"] = edge.getItem("penultimate_block_name")
# 3) set direction so can check direction of transit
penultimate_block_name = edge.getItem("penultimate_block_name")
penultimate_layout_block = LayoutBlockManager.getLayoutBlock(penultimate_block_name)
saved_state = penultimate_layout_block.getUseExtraColor()
if not in_siding:
# highlight the penultimate block
penultimate_layout_block.setUseExtraColor(True)
penultimate_layout_block.setUseExtraColor(True)
# print "set train direction"
[train_direction,result] = self.set_train_direction(station_block_name, in_siding)
# print "finished set train direction"
#check the condition set in set_train_direction
train["direction"] = train_direction
# print "train['direction']", train["direction"]
penultimate_layout_block.setUseExtraColor(saved_state)
# print "edge" , edge
if self.logLevel > 3: print "penultimate_block_name", penultimate_block_name
if self.logLevel > 4: print "train_direction", train_direction
# print
# 4) add to allocated train list
if str(train_name) not in trains_allocated:
trains_allocated.append(str(train_name))
if "allocating" not in train:
train["allocating"] = False
# print "done"
def add_to_train_list_and_set_new_train_location0(self, train_name, station_block_name,
train_direction, train_length, train_speed_factor):
# called by setup several trains
# trains is a dictionary, with keys of the train_name
# each value is itself a dictionary with 3 items
# edge
# penultimate_block_name
# direction
global train
global trains_allocated
if train_name not in trains:
trains[train_name] = {}
train = trains[train_name]
train["train_name"] = train_name
else:
#train_name = self.get_train_name()
train = trains[train_name]
train["train_name"] = train_name
self.set_train_in_block(station_block_name, train_name)
# 2) set the last traversed edge to the edge going into the siding
edge = None
j = 0
#print "edge_before" , edge
#print "g.g_stopping.edgesOf(station_block_name)",g.g_stopping.edgesOf(station_block_name)
break1 = False
#print "no edges", g.g_stopping.edgeSet()
for e in g.g_stopping.edgeSet():
j+=1
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
station_block = LayoutBlockManager.getLayoutBlock(station_block_name)
number_neighbors = station_block.getNumberOfNeighbours()
#print "station block number neighbors", number_neighbors
in_siding = (number_neighbors == 1)
#print "in_siding", in_siding
for i in range(station_block.getNumberOfNeighbours()):
neighbor_name = station_block.getNeighbourAtIndex(i).getDisplayName()
# print "penultimate_block_name", e.getItem("penultimate_block_name")
# print "last_block_name", e.getItem("last_block_name")
print "***************"
if e.getItem("penultimate_block_name") == neighbor_name and e.getItem("last_block_name") == station_block_name:
edge = e
break1 = True
if break1 == True:
break
#print "******************************++"
if edge == None:
print "Error the required block has not been found2. restart and try again. Sorry!"
return
train["edge"] = edge
train["penultimate_block_name"] = edge.getItem("penultimate_block_name")
# 3) set direction so can check direction of transit
train["direction"] = train_direction
# print train_name, 'train["direction"]',train["direction"]
# 4) add to allocated train list
# if str(train_name) not in trains_allocated:
# trains_allocated.append(str(train_name))
[engine,current_length] = self.get_train_length(train_name) #get the engine name
engine.setLength(str(train_length)) # save the length provided in the parameter
#[engine,current_speed_factor] = self.get_train_speed_factor(train_name)
speed_factor_str = "speed factor " + train_speed_factor
engine.setComment(speed_factor_str)
train["allocating"] = False
def highlight_penultimate_block(self, station_block_name):
# print("highlight_penultimate_block")
# 2) set the last traversed edge to the edge going into the siding
edge = None
j = 0
#print "edge_before" , edge
#print "g.g_stopping.edgesOf(station_block_name)",g.g_stopping.edgesOf(station_block_name)
break1 = False
#print "no edges", g.g_stopping.edgeSet()
# for e in g.g_express.edgeSet():
# print "e" , e
for e in g.g_express.edgeSet():
j+=1
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
station_block = LayoutBlockManager.getLayoutBlock(station_block_name)
number_neighbors = station_block.getNumberOfNeighbours()
#print "station block number neighbors", number_neighbors
in_siding = (number_neighbors == 1)
# print "in_siding", in_siding
for i in range(station_block.getNumberOfNeighbours()):
neighbor_name = station_block.getNeighbourAtIndex(i).getDisplayName()
print "neighbor_name", neighbor_name
print "station_block_name", station_block_name
# print "penultimate_block_name", e.getItem("penultimate_block_name")
# print "last_block_name", e.getItem("last_block_name")
print "***************"
if e.getItem("penultimate_block_name") == neighbor_name and e.getItem("last_block_name") == station_block_name:
edge = e
break1 = True
if break1 == True:
break
#print "******************************++"
if edge == None:
print "Error the required block has not been found3. restart and try again. Sorry!"
return ["Error", "Error", "Error"]
# 3) set direction so can check direction of transit
penultimate_block_name = edge.getItem("penultimate_block_name")
penultimate_layout_block = LayoutBlockManager.getLayoutBlock(penultimate_block_name)
saved_state = penultimate_layout_block.getUseExtraColor()
if not in_siding:
# highlight the penultimate block
penultimate_layout_block.setUseExtraColor(True)
penultimate_layout_block.setUseExtraColor(True)
[train_direction, result] = self.set_train_direction(station_block_name, in_siding)
penultimate_layout_block.setUseExtraColor(saved_state)
return [edge, train_direction, result]
def get_penultimate_layout_block(self, station_block_name):
# get the last traversed edge to the edge of the station_block
edge = None
j = 0
#print "edge_before" , edge
#print "g.g_stopping.edgesOf(station_block_name)",g.g_stopping.edgesOf(station_block_name)
break1 = False
#print "no edges", g.g_stopping.edgeSet()
for e in g.g_stopping.edgeSet():
j+=1
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
station_block = LayoutBlockManager.getLayoutBlock(station_block_name)
number_neighbors = station_block.getNumberOfNeighbours()
#print "station block number neighbors", number_neighbors
in_siding = (number_neighbors == 1)
for i in range(station_block.getNumberOfNeighbours()):
neighbor_name = station_block.getNeighbourAtIndex(i).getDisplayName()
print "neighbor_name", neighbor_name
print "station_block_name", station_block_name
# print "penultimate_block_name", e.getItem("penultimate_block_name")
# print "last_block_name", e.getItem("last_block_name")
print "***************"
if e.getItem("penultimate_block_name") == neighbor_name and e.getItem("last_block_name") == station_block_name:
edge = e
break1 = True
if break1 == True:
break
if edge == None:
# print "Error the required block has not been found4. restart and try again. Sorry!"
return None
penultimate_block_name = edge.getItem("penultimate_block_name")
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
penultimate_layout_block = LayoutBlockManager.getLayoutBlock(penultimate_block_name)
return penultimate_layout_block
def in_siding(self, station_block_name):
LayoutBlockManager=jmri.InstanceManager.getDefault(jmri.jmrit.display.layoutEditor.LayoutBlockManager)
station_block = LayoutBlockManager.getLayoutBlock(station_block_name)
number_neighbors = station_block.getNumberOfNeighbours()
#print "station block number neighbors", number_neighbors
in_siding = (number_neighbors == 1)
return in_siding
def set_train_direction(self, block_name, in_siding):
# in_siding = self.in_siding(block_name)
options = ["forward", "reverse"]
default = "forward"
self.od.CLOSED_OPTION = True
while self.od.CLOSED_OPTION == True:
msg = "In block: " + block_name + "\n" +'What way is train facing\ntowards highlighted block?'
title = "Set Train Facing Direction"
type = JOptionPane.QUESTION_MESSAGE
result = self.od.customQuestionMessage2str(msg, title, "forward", "reverse")
if self.od.CLOSED_OPTION == True:
OptionDialog().displayMessage("Sorry Can't Cancel at this point")
if result == "reverse":
train_direction = "forward"
else:
train_direction = "reverse"
# if in_siding:
# if result == "reverse":
# train_direction = "forward"
# else:
# train_direction = "reverse"
# else:
# if result == "forward":
# train_direction = "forward"
# else:
# train_direction = "reverse"
return [train_direction, result]
def set_train_in_block(self, block_name, train_name):
mem_val = train_name
self.set_blockcontents(block_name, mem_val)
def reset_train_in_blocks(self, train_name):
for block in blocks.getNamedBeanSet():
#print "block name", block.getUserName(), "block.getValue()" , block.getValue()
if block.getValue() == train_name:
#print "yes"
block.setValue("")
#print "block name yes", block.getUserName(), "block.getValue()" , block.getValue()
def trains_in_sections_allocated(self):
trains_in_sections_allocated = []
#trains_in_sections_nonallocated = []
for station_block_name in g.station_block_list:
block_value = self.get_blockcontents(station_block_name)
block_occupied_state = self.check_sensor_state_given_block_name(station_block_name)
# print "trains_allocated", trains_allocated
# print "block_value", block_value
if block_occupied_state == True:
if block_value not in trains_allocated:
# print "appending non_allocated as block_value not in trains allocated"
trains_in_sections_allocated.append([station_block_name, block_value, "non-allocated"])
elif (block_value != None and block_value != "" and block_value != "none"):
trains_in_sections_allocated.append([station_block_name, block_value, "allocated"])
else:
trains_in_sections_allocated.append([station_block_name, block_value, "other"])
# print "trains_in_sections_allocated", trains_in_sections_allocated
if self.logLevel > 0: print str(trains_in_sections_allocated)
return trains_in_sections_allocated
def occupied_blocks_allocated(self):
occupied_blocks = [block for [block, train, state] in self.trains_in_sections_allocated() if state == "allocated"]
return occupied_blocks
def occupied_blocks_not_allocated(self):
occupied_blocks = [block for [block, train, state] in self.trains_in_sections_allocated() if state == "non-allocated"]
return occupied_blocks
def blocks_allocated(self):
occupied_blocks = [block for [block, train, state] in self.trains_in_sections_allocated()]
return occupied_blocks
def train_blocks(self, train_list, in_list):
occupied_blocks = \
[station_block_name for station_block_name in g.station_block_list \
if self.check_sensor_state_given_block_name(station_block_name) == True]
# print "occupied_blocks", occupied_blocks
# print "train_list", train_list
self.get_blockcontents(station_block_name),
if in_list:
items_in_list = \
[[self.get_blockcontents(block_name), block_name, self.check_sensor_state_given_block_name(block_name)] \
for block_name in occupied_blocks if self.get_blockcontents(block_name) in train_list]
# [train_name , block_name, block_state] = items_in_list # for clarity
return items_in_list
else:
items_not_in_list = \
[[self.get_blockcontents(block_name), block_name, self.check_sensor_state_given_block_name(block_name)] \
for block_name in occupied_blocks if self.get_blockcontents(block_name) not in train_list]
# [train_name , block_name, block_state] = items_in_list # for clarity
return items_not_in_list
def train_blocks_in_list(self,train_list):
return self.train_blocks(train_list, True)
def train_blocks_not_in_list(self,train_list):
return self.train_blocks(train_list, False)
def check_new_train_in_siding(self):
# go through all station
global trains_allocated
for station_block_name in g.station_block_list:
#get a True if the block block_value has the train name in it
block_value = self.get_blockcontents(station_block_name)
if self.logLevel > 0: print " a trains_allocated:", trains_allocated, ": block_value", block_value
#get a True if the block is occupied
block_occupied_state = self.check_sensor_state_given_block_name(station_block_name)
if self.logLevel > 0: print ("station block name {} : block_value {}". format(station_block_name, str(block_value)))
#check if the block is occupied and has the required train in it
if (block_value == None or block_value == "" or block_value == "none") and block_occupied_state == True:
return [station_block_name, None]
elif block_occupied_state == True and (block_value != None and block_value != "" and block_value != "none"):
#check if there is already a thread for the train
#check if the train has already been allocated
#if self.new_train_thread_required(block_value):
if block_value not in trains_allocated:
return [station_block_name, block_value]
else:
if self.logLevel > 0: print "block_value in trains_allocated"
if self.logLevel > 0: print "b trains_allocated:", trains_allocated, ": block_value", block_value
pass
else:
pass
return [None, None]
def is_roster_entry(self, v):
return type(v) is jmri.jmrit.roster.RosterEntry
def train_thread_exists(self, train_name):
for thread in instanceList:
if thread is not None:
if thread.isRunning():
existing_train_name = thread.getName()
if existing_train_name == train_name:
return True
return False
def create_new_train_thread(self, train_name):
idx = len(instanceList)
instanceList.append(RunDispatch()) # Add a new instance
instanceList[idx].setName(train_name) # Set the instance name
#if instanceList[idx].setup(): # Compile the train actions
instanceList[idx].start() # Compile was successful
def get_blockcontents(self, block_name):
block = blocks.getBlock(block_name)
value = block.getValue()
return value
def set_blockcontents(self, block_name, value):
block = blocks.getBlock(block_name)
value = block.setValue(value)
def check_sensor_state_given_block_name(self, station_block_name):
#if self.logLevel > 0: print("station block name {}".format(station_block_name))
layoutBlock = layoutblocks.getLayoutBlock(station_block_name)
station_sensor = layoutBlock.getOccupancySensor()
if station_sensor is None:
OptionDialog().displayMessage(' Sensor in block {} not found'.format(station_block_name))
return
currentState = True if station_sensor.getKnownState() == ACTIVE else False
return currentState
class createandshowGUI(TableModelListener):
def __init__(self, super1, mode1):
global CreateAndShowGUI_frame
self.logLevel = 0
self.super = super1
#Create and set up the window.
self.mode = mode1 # "several trains" or "modify existing trains"
self.initialise_model(super1)
if self.mode == "modify existing trains":
CreateAndShowGUI_frame = JFrame("occupied blocks, allocated or not")
else:
CreateAndShowGUI_frame = JFrame("Set up trains. Any trains shown in blocks are showing on the track but not allocated. Save to allocate")
self.frame = CreateAndShowGUI_frame
self.frame.setPreferredSize(Dimension(800, 600));
self.frame.setVisible(True)
self.completeTablePanel1()
self.populate_action(None)
self.completeTablePanel()
self.cancel = False
def completeTablePanel(self):
self.tidy()
self.frame.pack()
self.frame.setVisible(True)
return
def completeTablePanel1(self):
self.topPanel = JPanel();
self.topPanel.setLayout(BoxLayout(self.topPanel, BoxLayout.X_AXIS))
self.self_table()
scrollPane = JScrollPane(self.table);
scrollPane.setPreferredSize(Dimension(800, 600));
self.topPanel.add(scrollPane);
self.buttonPane = JPanel();
self.buttonPane.setLayout(BoxLayout(self.buttonPane, BoxLayout.LINE_AXIS))
self.buttonPane.setBorder(BorderFactory.createEmptyBorder(0, 10, 10, 10))
# button_add = JButton("Add Row", actionPerformed = self.add_row_action)
# self.buttonPane.add(button_add);
# self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
button_apply = JButton("Save", actionPerformed=self.save_action)
self.buttonPane.add(button_apply)
# self.buttonPane.add(Box.createHorizontalGlue())
self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
button_cancel = JButton("Close", actionPerformed=self.cancel_action)
self.buttonPane.add(button_cancel)
self.buttonPane.add(Box.createHorizontalGlue())
button_populate = JButton("Populate", actionPerformed=self.populate_action)
self.buttonPane.add(button_populate)
# self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
# button_tidy = JButton("Tidy", actionPerformed=self.tidy_action)
# self.buttonPane.add(button_tidy)
self.buttonPane.add(Box.createHorizontalGlue())
self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
button_savetofile = JButton("Save To File", actionPerformed=self.savetofile_action)
self.buttonPane.add(button_savetofile)
# self.buttonPane.add(Box.createHorizontalGlue())
self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
button_loadfromfile = JButton("Load From File", actionPerformed=self.loadfromfile_action)
self.buttonPane.add(button_loadfromfile)
# self.buttonPane.add(Box.createHorizontalGlue())
self.buttonPane.add(Box.createRigidArea(Dimension(10, 0)))
button_deletefromfile = JButton("Delete Saved Files", actionPerformed=self.deletesavedfile_action)
self.buttonPane.add(button_deletefromfile)
self.buttonPane.add(Box.createHorizontalGlue())
contentPane = self.frame.getContentPane()
contentPane.removeAll()
contentPane.add(self.topPanel, BorderLayout.CENTER)
contentPane.add(self.buttonPane, BorderLayout.PAGE_END)
def buttonPanel(self):
row1_1_button = JButton("Add Row", actionPerformed = self.add_row_action)
row1_2_button = JButton("Save", actionPerformed = self.save_action)
row1 = JPanel()
row1.setLayout(BoxLayout(row1, BoxLayout.X_AXIS))
row1.add(Box.createVerticalGlue())
row1.add(Box.createRigidArea(Dimension(20, 0)))
row1.add(row1_1_button)
row1.add(Box.createRigidArea(Dimension(10, 0)))
row1.add(row1_2_button)
layout = BorderLayout()
jPanel = JPanel()
jPanel.setLayout(layout);
jPanel.add(self.table,BorderLayout.NORTH)
jPanel.add(row1,BorderLayout.SOUTH)
#return jPanel
return topPanel
def initialise_model(self, super):
self.model = None
self.model = MyTableModel()
self.table = JTable(self.model)
self.model.addTableModelListener(MyModelListener(self, super))
def self_table(self):
self.table.setPreferredScrollableViewportSize(Dimension(800, 600));
#table.setFillsViewportHeight(True)
#self.table.getModel().addtableModelListener(self)
self.table.setFillsViewportHeight(True);
self.table.setRowHeight(30);
#table.setAutoResizeMode( JTable.AUTO_RESIZE_OFF );
# self.resizeColumnWidth(table)
#renderer = DefaultTableCellRenderer()
#renderer.setToolTipText("Click for combo box");
# set first 3 cols to combobox
# comboBox = [1,2,3]
# column = [1,2,3]
self.trainColumn = self.table.getColumnModel().getColumn(0)
self.trainColumn.setPreferredWidth(100)
self.combobox0 = JComboBox()
self.all_trains = self.super.get_all_roster_entries_with_speed_profile()
self.non_allocated_trains = self.super.get_non_allocated_trains()
self.allocated_trains = self.super.get_allocated_trains()
if self.mode == "several trains":
self.required_trains = self.non_allocated_trains
elif self.mode == "modify existing trains":
self.required_trains = self.allocated_trains
# print "self.non_allocated_trains", self.non_allocated_trains
# print "self.allocated_trains", self.allocated_trains
for train in self.required_trains:
self.combobox0.addItem(train)
# print "adding train", train
self.trainColumn.setCellEditor(DefaultCellEditor(self.combobox0));
renderer0 = ComboBoxCellRenderer()
self.trainColumn.setCellRenderer(renderer0)
self.all_sections = self.super.get_all_sections()
self.all_blocks = self.super.get_all_blocks()
self.sectionColumn = self.table.getColumnModel().getColumn(1);
self.sectionColumn.setPreferredWidth(100)
self.combobox1 = JComboBox()
if self.mode == "several trains":
self.sections_to_choose = self.super.get_non_allocated_trains_sections()
else:
self.sections_to_choose = self.super.get_allocated_trains_sections()
for section in self.sections_to_choose:
self.combobox1.addItem(section)
#self.set_train_selections(combobox0)
self.sectionColumn.setCellEditor(DefaultCellEditor(self.combobox1));
renderer1 = ComboBoxCellRenderer()
self.sectionColumn.setCellRenderer(renderer1);
jpane = JScrollPane(self.table)
panel = JPanel()
panel.add(jpane)
return self.table
def add_row_action(self, e):
model = e.getSource()
data = self.model.getValueAt(0, 0)
count = self.model.getRowCount()
colcount = self.model.getColumnCount()
self.model.add_row()
self.completeTablePanel()
def populate_action(self, event):
# print "populate_action"
column = 1 #block
all_blocks = [block.getUserName() for block in self.all_blocks]
blocks_in_table = [block for block in (self.model.getValueAt(r, column) for r in range(self.table.getRowCount())) if block in all_blocks]
if self.mode == "several trains":
not_allocated_blocks = self.super.occupied_blocks_not_allocated()
blocks_to_put_in_dropdown = [s for s in not_allocated_blocks]
self.populate(blocks_to_put_in_dropdown)
self.tidy()
else:
allocated_blocks = self.super.blocks_allocated()
# print "allocated_blocks", allocated_blocks
blocks_to_put_in_dropdown = [s for s in allocated_blocks]
# print "blocks to put in dropdown", blocks_to_put_in_dropdown
self.model.populate_existing(blocks_to_put_in_dropdown)
self.tidy()
# print "COMPLETING TABLE PANEL"
self.completeTablePanel()
def populate(self, blocks_to_put_in_dropdown):
for row in reversed(range(len(self.model.data))):
self.model.data.pop(row)
# append all blocks to put in dropdown
for block in blocks_to_put_in_dropdown:
# print "block", block
self.model.data.append(["", block, "click ->", False, 10, 100])
# delete rows with no blocks
for row in reversed(range(len(self.model.data))):
if self.model.data[row][1] == None or self.model.data[row][1] == "":
if len(self.model.data)>1:
self.model.data.pop(row)
self.completeTablePanel()
def remove_not_set_row(self):
# print "data", self.model.data
for row in reversed(range(len(self.model.data))):
# print "self.model.data[row][1]", self.model.data[row][1]
if self.model.data[row][1] == "":
self.model.data.pop(row)
def tidy_action(self,e):
self.tidy()
self.completeTablePanel()
def tidy(self):
self.remove_not_set_row()
size_of_one_row = 30
height = 130
for row in reversed(range(len(self.model.data))):
height += size_of_one_row
self.frame.setPreferredSize(Dimension(800, height));
def savetofile_action(self, event):
#Tidy
self.remove_not_set_row()
self.completeTablePanel()
if self.model.getRowCount() == 0:
return
dir = self.directory()
j = JFileChooser(dir);
j.setAcceptAllFileFilterUsed(False)
filter = FileNameExtensionFilter("text files txt", ["txt"])
j.addChoosableFileFilter(filter);
j.setDialogTitle("Select a .txt file");
ret = j.showSaveDialog(None);
if (ret == JFileChooser.APPROVE_OPTION) :
file = j.getSelectedFile()
if file == "" or file == None:
return
if FilenameUtils.getExtension(file.getName()).lower() == "txt" :
#filename is OK as-is
pass
else:
file = File(file.getParentFile(), FilenameUtils.getBaseName(file.getName())+".txt") # ALTERNATIVELY: remove the extension (if any) and replace it with ".xml"
else:
return
if self.logLevel > 0: print "savetofile action", file
my_list = []
[train, block, direction, length, speed_factor] = [0, 1, 2, 4, 5]
for row in range(len(self.model.data)):
train_name = str(self.model.data[row][train])
block_name = str(self.model.data[row][block])
train_direction = str(self.model.data[row][direction])
train_length = str(self.model.data[row][length])
train_speed_factor = str(self.model.data[row][speed_factor])
row_list = [train_name, block_name, train_direction,train_length,train_speed_factor]
if self.logLevel > 0: print "x", row
my_list.append(row_list)
if self.logLevel > 0: print "y", row
if self.logLevel > 0: print "A"
self.write_list(my_list,file)
def loadfromfile_action(self, event):
# load the file
dir = self.directory()
j = JFileChooser(dir)
j.setAcceptAllFileFilterUsed(False)
filter = FileNameExtensionFilter("text files txt", ["txt"])
j.setDialogTitle("Select a .txt file")
j.addChoosableFileFilter(filter)
# Automatically select the first file in the directory
files = j.getCurrentDirectory().listFiles()
j.setSelectedFile(files[0])
ret = j.showOpenDialog(None)
if (ret == JFileChooser.APPROVE_OPTION):
file = j.getSelectedFile()
if self.logLevel > 0: print "about to read list", file
my_list = self.read_list(file)
if self.logLevel > 0: print "my_list", my_list
for row in reversed(range(len(self.model.data))):
self.model.data.pop(row)
i = 0
[train, block, direction, length, speed_factor] = [0, 1, 2, 4, 5]
for row in my_list:
[train_val, block_val, direction_val, length_val, speed_factor_val] = row
self.model.add_row()
self.model.data[i][train] = train_val.replace('"','')
self.model.data[i][block] = block_val.replace('"','')
self.model.data[i][direction] = direction_val.replace('"','')
self.model.data[i][length] = length_val.replace('"','')
self.model.data[i][speed_factor] = speed_factor_val.replace('"','')
i += 1
self.completeTablePanel1()
self.completeTablePanel()
msg = "Deleting invalid rows"
result = OptionDialog().displayMessage(msg)
if result == JOptionPane.NO_OPTION:
return
# check the loaded contents
# 1) check that the trains are valid
# 2) check that the blocks are occupied by valid trains
# if either of the above are not valic we blank the entries
# 3) Tidy
# check the trains are valid
b = False
trains_to_put_in_dropdown = [t for t in self.non_allocated_trains]
for row in reversed(range(len(self.model.data))):
#if len(self.model.data) >1:
# print "row", row
if self.model.data[row][train] not in trains_to_put_in_dropdown:
self.model.data.pop(row)
not_allocated_blocks = self.super.occupied_blocks_not_allocated()
for row in reversed(range(len(self.model.data))):
if self.model.data[row][block] not in not_allocated_blocks:
self.model.data.pop(row)
self.completeTablePanel1()
self.completeTablePanel()
def deletesavedfile_action(self, event):
while True:
#Tidy
self.remove_not_set_row()
self.completeTablePanel()
if self.model.getRowCount() == 0:
return
dir = self.directory()
j = JFileChooser(dir);
j.setAcceptAllFileFilterUsed(False)
filter = FileNameExtensionFilter("text files txt", ["txt"])
j.addChoosableFileFilter(filter);
j.setDialogTitle("Delete not wanted files");
ret = j.showDialog(None, "Delete");
if ret == JFileChooser.APPROVE_OPTION:
file = j.getSelectedFile()
if file == "" or file == None:
return
if file.exists():
os.remove(file.getAbsolutePath())
# print("File " + file.getName() + " has been deleted successfully.")
else:
print("The selected file does not exist.")
else:
print("File selection cancelled.")
return
def cancel_action(self, event):
title = ""
msg = "Do you wish to exit without saving?"
opt1 = "Exit, don't save"
opt2 = "Exit and Save Results"
reply = OptionDialog().customQuestionMessage2str(msg, title, opt1, opt2)
if reply == opt1:
self.frame.dispatchEvent(WindowEvent(self.frame, WindowEvent.WINDOW_CLOSING))
else: #opt2
self.save_action(None)
def save_action(self, event):
[train, block, direction, length, speed_factor] = [0, 1, 2, 4, 5]
# print "save action"
for row in reversed(range(len(self.model.data))):
train_name = self.model.data[row][train]
block_name = self.model.data[row][block]
train_direction = self.model.data[row][direction]
train_length = self.model.data[row][length]
train_speed_factor = self.model.data[row][speed_factor]
result = train_direction
if result == "forward":
train_direction = "reverse"
else:
train_direction = "forward"
if self.logLevel > 3: print "train_name", train_name,"train_direction", train_direction
if train_name != "" and train_name != None and block_name != "" and block_name != None:
if train_name not in trains_allocated:
trains_allocated.append(train_name)
self.super.add_to_train_list_and_set_new_train_location0(train_name, block_name,
train_direction, train_length, train_speed_factor)
self.super.set_blockcontents(block_name, train_name)
self.super.set_length0(train_name)
self.super.set_speed_factor0(train_name)
self.model.data.pop(row)
# print "end save action"
self.completeTablePanel()
if self.model.getRowCount() == 0:
self.frame.dispatchEvent(WindowEvent(self.frame, WindowEvent.WINDOW_CLOSING))
def set_train_selections(self, combobox):
pass
def directory(self):
path = jmri.util.FileUtil.getUserFilesPath() + "dispatcher" + java.io.File.separator + "setup_trains"
if not os.path.exists(path):
os.makedirs(path)
return path + java.io.File.separator
def write_list(self, a_list, file):
# store list in binary file so 'wb' mode
#file = self.directory() + "blockDirections.txt"
if self.logLevel > 0: print "block_info" , a_list
if self.logLevel > 0: print "file" , file
file = str(file)
with open(file, 'wb') as fp:
pass
if self.logLevel > 0: print "V"
with open(file, 'wb') as fp:
if self.logLevel > 0: print "B"
for items in a_list:
if self.logLevel > 0: print "C", items
i = 0
for item in items:
if self.logLevel > 0: print "item", item
fp.write('"%s"' %item)
if i != 4: fp.write(",")
i+=1
fp.write('\n')
# Read list to memory
def read_list(self, file):
file = str(file)
if self.logLevel > 0: print "read list", file
# for reading also binary mode is important
#file = self.directory() + "blockDirections.txt"
n_list = []
# try:
with open(file, 'rb') as fp:
for line in fp:
if self.logLevel > 0: print "line" , line
x = line[:-1]
if self.logLevel > 0: print x
y = x.split(",")
#y = [item.replace('"','') for item in y]
if self.logLevel > 0: print "y" , y
n_list.append(y)
return n_list
class MyModelListener(TableModelListener):
def __init__(self, class_createandshowGUI, class_NewTrainMaster):
self.class_createandshowGUI = class_createandshowGUI
self.class_NewTrainMaster = class_NewTrainMaster
self.super = super
self.cancel = False
self.mode = class_createandshowGUI.mode
def tableChanged(self, e) :
global train_direction_gbl
global trains_allocated
row = e.getFirstRow()
column = e.getColumn()
model = e.getSource()
columnName = model.getColumnName(column)
data = model.getValueAt(row, column)
class_createandshowGUI = self.class_createandshowGUI
class_NewTrainMaster = self.class_NewTrainMaster
tablemodel = class_createandshowGUI.model
if column == 0: #trains
class_createandshowGUI.combobox0.removeAllItems()
#the non_allocated trains are stored in self.non_allocated_trains
# each time a cell is edited we regenerate the list if trains in the drop down
# we set to the non_allocated_trains less the ones marked ro be allocated in the table
trains_in_table = [train for train in (model.getValueAt(r, column) for r in range(class_createandshowGUI.table.getRowCount())) if train in class_createandshowGUI.all_trains]
# print "trains in table", trains_in_table
# starting with non_allocated_trains remove the ones in my_train_list
#trains_to_put_in_dropdown = [t for t in class_createandshowGUI.non_allocated_trains if t not in trains_in_table]
if self.mode == "several trains":
trains_to_put_in_dropdown = [t for t in class_createandshowGUI.non_allocated_trains]
else:
trains_to_put_in_dropdown = [t for t in class_createandshowGUI.allocated_trains]
# print "trains_to_put_in_dropdown", trains_to_put_in_dropdown
class_createandshowGUI.combobox0.removeAllItems()
#put the remaining trains in the combo dropdown
class_createandshowGUI.combobox0.addItem("")
[class_createandshowGUI.combobox0.addItem(train) for train in trains_to_put_in_dropdown]
class_createandshowGUI.trainColumn.setCellEditor(DefaultCellEditor(class_createandshowGUI.combobox0));
# populate the length of the engine
train_name = model.getValueAt(row, 0)
if train_name != "":
[engine, train_length] = class_NewTrainMaster.get_train_length(train_name)
model.setValueAt(train_length, row,4)
#populate the speed factor of the engine
train_name = model.getValueAt(row, 0)
if train_name != "":
[engine, train_speed_factor] = class_NewTrainMaster.get_train_speed_factor(train_name)
model.setValueAt(train_speed_factor, row,5)
# print "%%%%%%%%%%%%%%%%end col1 %%%%%%%%%%%%%%%%%%%%%%%%"
elif column == 1: # sections
class_createandshowGUI.combobox1.removeAllItems()
# print "%%%%%%%%%%%%%%%%start col2 %%%%%%%%%%%%%%%%%%%%%%%%"
# print "class_createandshowGUI.all_sections", class_createandshowGUI.all_sections
# print "range class_createandshowGUI.table.getRowCount()", range(class_createandshowGUI.table.getRowCount())
for r in range(class_createandshowGUI.table.getRowCount()):
# print "r",r,"column",column
# print "r", r, "(model.getValueAt(r, column)", (model.getValueAt(r, column))
pass
all_sections = [str(block.getUserName()) for block in class_createandshowGUI.all_sections]
all_blocks = [str(block.getUserName()) for block in class_createandshowGUI.all_blocks]
# print "all_sections", all_sections
trains_in_table = \
[train for train in (model.getValueAt(r, column) for r in range(class_createandshowGUI.table.getRowCount()))
if train in class_createandshowGUI.all_trains]
X = [str(model.getValueAt(r, column)) for r in range(class_createandshowGUI.table.getRowCount())]
# print "X", X
blocks_in_table = [block for block in X if block in all_blocks]
# print "sections in table", blocks_in_table
# starting with non_allocated_trains remove the ones in my_train_list
# print "sections to choose", class_createandshowGUI.sections_to_choose
# print "trains_in_table",trains_in_table
# print "sections True", class_createandshowGUI.train_blocks(trains_in_table, True)
# print "sections False", class_createandshowGUI.train_blocks(trains_in_table, False)
allocated_blocks = class_createandshowGUI.super.occupied_blocks_allocated()
not_allocated_blocks = class_createandshowGUI.super.occupied_blocks_not_allocated()
#blocks_to_put_in_dropdown = [s for s in not_allocated_blocks if s not in blocks_in_table]
blocks_to_put_in_dropdown = [s for s in not_allocated_blocks]
# print("blocks_to_put_in_dropdown", blocks_to_put_in_dropdown)
#put the remaining trains in the combo dropdown
class_createandshowGUI.combobox1.removeAllItems()
class_createandshowGUI.combobox1.addItem("")
[class_createandshowGUI.combobox1.addItem(section) for section in blocks_to_put_in_dropdown]
# [class_createandshowGUI.combobox1.addItem(section) for section in blocks_to_put_in_dropdown]
class_createandshowGUI.sectionColumn.setCellEditor(DefaultCellEditor(class_createandshowGUI.combobox1));
# print "%%%%%%%%%%%%%%%%end col2 %%%%%%%%%%%%%%%%%%%%%%%%"
elif column == 3: # show the direction on the layout to enable the facing direction to be chosen
# print "cancel on entry", self.cancel
if self.cancel == True:
self.cancel = False
# print "set cancel", self.cancel
return
station_block_name = model.getValueAt(row, 1)
# print "station_block_name", station_block_name
if station_block_name != None and station_block_name != "" and station_block_name != "None Available":
# print "here"
[edge, train_direction_gbl, result] = class_createandshowGUI.super.highlight_penultimate_block(station_block_name)
# print [edge, train_direction_gbl, result]
self.cancel = True
model.setValueAt(result, row, 2) #set the direction box to the result (forwards or reverse)
model.setValueAt(False, row, 3) #reset the check box (need the self.cancel code to stop retriggering of the event code)
else:
OptionDialog().displayMessage("must set Block first")
class ComboBoxCellRenderer (TableCellRenderer):
def getTableCellRendererComponent(self, jtable, value, isSelected, hasFocus, row, column):
combo = JComboBox()
combo.setSelectedItem(value)
return combo
def getTableCellRendererComponent(self, jtable, value, isSelected, hasFocus, row, column) :
panel = self.createPanel(value)
return panel
def createPanel(self, s) :
p = JPanel(BorderLayout())
p.add(JLabel(s, JLabel.LEFT), BorderLayout.WEST)
icon = UIManager.getIcon("Table.descendingSortIcon");
p.add(JLabel(icon, JLabel.RIGHT), BorderLayout.EAST);
p.setBorder(BorderFactory.createLineBorder(Color.blue));
return p;
class MyTableModel (DefaultTableModel):
columnNames = ["Train",
"Block",
"Set Direction",
"Direction Facing",
"Length (scale metres)",
"Speed Factor"]
def __init__(self):
self.data = []
self.add_row()
def add_row(self):
self.data.append(["", "", "click ->", False, 10, 100])
def populate_existing(self, blocks_to_put_in_dropdown):
# print "populate existing"
for row in reversed(range(len(self.data))):
self.data.pop(row)
items_to_put_in_dropdown = []
for block_name in blocks_to_put_in_dropdown:
train_name = NewTrainMaster().get_blockcontents(block_name)
# if train_name == "" or train_name is None:
# continue
if train_name == "" or train_name is None:
train_direction = "unassigned"
train_length = -1
current_speed_factor = -1
else:
# print "block_name", block_name, "train_name", train_name
[engine,current_length] = NewTrainMaster().get_train_length(train_name)
train_length = engine.getLength()
[engine, current_speed_factor] = NewTrainMaster().get_train_speed_factor(train_name)
# current_speed_factor_str = "speed factor " + current_speed_factor
current_speed_factor_str = engine.getComment()
train = trains[train_name]
result = train["direction"]
# print "train[direction] loading to put in dropdown", result
if result == "forward":
train_direction = "reverse"
else:
train_direction = "forward"
# print "train", train, train_direction
items_to_put_in_dropdown.append([train_name,block_name,train_direction, False, train_length, current_speed_factor ])
# print "items_to_put_in_dropdown", items_to_put_in_dropdown
for item in items_to_put_in_dropdown:
self.data.append(item)
# self.completeTablePanel()
pass
def getColumnCount(self) :
return len(self.columnNames)
def getRowCount(self) :
return len(self.data)
def getColumnName(self, col) :
return self.columnNames[col]
def getValueAt(self, row, col) :
return self.data[row][col]
def getColumnClass(self, c) :
if c <= 1:
return java.lang.Boolean.getClass(JComboBox)
return java.lang.Boolean.getClass(self.getValueAt(0,c))
#only include if table editable
def isCellEditable(self, row, col) :
# Note that the data/cell address is constant,
# no matter where the cell appears onscreen.
if col != 2:
return True
else:
return False
# only include if data can change.
def setValueAt(self, value, row, col) :
self.data[row][col] = value
self.fireTableCellUpdated(row, col)
Reference in New Issue View Git Blame Copy Permalink