001package jmri.jmrit.operations.trains.trainbuilder; 002 003import java.awt.*; 004import java.io.PrintWriter; 005import java.text.MessageFormat; 006import java.text.SimpleDateFormat; 007import java.util.*; 008import java.util.List; 009 010import javax.swing.JLabel; 011 012import org.slf4j.Logger; 013import org.slf4j.LoggerFactory; 014 015import com.fasterxml.jackson.databind.util.StdDateFormat; 016 017import jmri.InstanceManager; 018import jmri.jmrit.operations.locations.*; 019import jmri.jmrit.operations.locations.divisions.DivisionManager; 020import jmri.jmrit.operations.rollingstock.RollingStock; 021import jmri.jmrit.operations.rollingstock.cars.*; 022import jmri.jmrit.operations.rollingstock.engines.*; 023import jmri.jmrit.operations.routes.RouteLocation; 024import jmri.jmrit.operations.setup.Control; 025import jmri.jmrit.operations.setup.Setup; 026import jmri.jmrit.operations.trains.*; 027import jmri.util.ColorUtil; 028 029/** 030 * Common routines for trains 031 * 032 * @author Daniel Boudreau (C) Copyright 2008, 2009, 2010, 2011, 2012, 2013, 033 * 2021, 2025 034 */ 035public class TrainCommon { 036 037 protected static final String TAB = " "; // NOI18N 038 protected static final String NEW_LINE = "\n"; // NOI18N 039 public static final String SPACE = " "; 040 public static final String BLANK_LINE = " "; 041 protected static final char HORIZONTAL_LINE_CHAR = '-'; 042 protected static final String BUILD_REPORT_CHAR = "-"; 043 public static final String HYPHEN = "-"; 044 protected static final char VERTICAL_LINE_CHAR = '|'; 045 protected static final String TEXT_COLOR_START = "<FONT color=\""; 046 protected static final String TEXT_COLOR_DONE = "\">"; 047 protected static final String TEXT_COLOR_END = "</FONT>"; 048 049 // when true a pick up, when false a set out 050 protected static final boolean PICKUP = true; 051 // when true Manifest, when false switch list 052 protected static final boolean IS_MANIFEST = true; 053 // when true local car move 054 public static final boolean LOCAL = true; 055 // when true engine attribute, when false car 056 protected static final boolean ENGINE = true; 057 // when true, two column table is sorted by track names 058 public static final boolean IS_TWO_COLUMN_TRACK = true; 059 060 protected CarManager carManager = InstanceManager.getDefault(CarManager.class); 061 protected EngineManager engineManager = InstanceManager.getDefault(EngineManager.class); 062 protected LocationManager locationManager = InstanceManager.getDefault(LocationManager.class); 063 064 // for switch lists 065 protected boolean _pickupCars; // true when there are pickups 066 protected boolean _dropCars; // true when there are set outs 067 068 /** 069 * Used to generate "Two Column" format for engines. 070 * 071 * @param file Manifest or Switch List File 072 * @param engineList List of engines for this train. 073 * @param rl The RouteLocation being printed. 074 * @param isManifest True if manifest, false if switch list. 075 */ 076 protected void blockLocosTwoColumn(PrintWriter file, List<Engine> engineList, RouteLocation rl, 077 boolean isManifest) { 078 if (isThereWorkAtLocation(null, engineList, rl)) { 079 printEngineHeader(file, isManifest); 080 } 081 int lineLength = getLineLength(isManifest); 082 for (Engine engine : engineList) { 083 if (engine.getRouteLocation() == rl && !engine.getTrackName().equals(Engine.NONE)) { 084 String pullText = padAndTruncate(pickupEngine(engine).trim(), lineLength / 2); 085 pullText = formatColorString(pullText, Setup.getPickupEngineColor()); 086 String s = pullText + VERTICAL_LINE_CHAR + tabString("", lineLength / 2 - 1); 087 addLine(file, s); 088 } 089 if (engine.getRouteDestination() == rl) { 090 String dropText = padAndTruncate(dropEngine(engine).trim(), lineLength / 2 - 1); 091 dropText = formatColorString(dropText, Setup.getDropEngineColor()); 092 String s = tabString("", lineLength / 2) + VERTICAL_LINE_CHAR + dropText; 093 addLine(file, s); 094 } 095 } 096 } 097 098 /** 099 * Adds a list of locomotive pick ups for the route location to the output 100 * file. Used to generate "Standard" format. 101 * 102 * @param file Manifest or Switch List File 103 * @param engineList List of engines for this train. 104 * @param rl The RouteLocation being printed. 105 * @param isManifest True if manifest, false if switch list 106 */ 107 protected void pickupEngines(PrintWriter file, List<Engine> engineList, RouteLocation rl, boolean isManifest) { 108 boolean printHeader = Setup.isPrintHeadersEnabled(); 109 for (Engine engine : engineList) { 110 if (engine.getRouteLocation() == rl && !engine.getTrackName().equals(Engine.NONE)) { 111 if (printHeader) { 112 printPickupEngineHeader(file, isManifest); 113 printHeader = false; 114 } 115 pickupEngine(file, engine, isManifest); 116 } 117 } 118 } 119 120 private void pickupEngine(PrintWriter file, Engine engine, boolean isManifest) { 121 StringBuffer buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupEnginePrefix(), 122 isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength())); 123 String[] format = Setup.getPickupEngineMessageFormat(); 124 for (String attribute : format) { 125 String s = getEngineAttribute(engine, attribute, PICKUP); 126 if (!checkStringLength(buf.toString() + s, isManifest)) { 127 addLine(file, buf, Setup.getPickupEngineColor()); 128 buf = new StringBuffer(TAB); // new line 129 } 130 buf.append(s); 131 } 132 addLine(file, buf, Setup.getPickupEngineColor()); 133 } 134 135 /** 136 * Adds a list of locomotive drops for the route location to the output 137 * file. Used to generate "Standard" format. 138 * 139 * @param file Manifest or Switch List File 140 * @param engineList List of engines for this train. 141 * @param rl The RouteLocation being printed. 142 * @param isManifest True if manifest, false if switch list 143 */ 144 protected void dropEngines(PrintWriter file, List<Engine> engineList, RouteLocation rl, boolean isManifest) { 145 boolean printHeader = Setup.isPrintHeadersEnabled(); 146 for (Engine engine : engineList) { 147 if (engine.getRouteDestination() == rl) { 148 if (printHeader) { 149 printDropEngineHeader(file, isManifest); 150 printHeader = false; 151 } 152 dropEngine(file, engine, isManifest); 153 } 154 } 155 } 156 157 private void dropEngine(PrintWriter file, Engine engine, boolean isManifest) { 158 StringBuffer buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getDropEnginePrefix(), 159 isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength())); 160 String[] format = Setup.getDropEngineMessageFormat(); 161 for (String attribute : format) { 162 String s = getEngineAttribute(engine, attribute, !PICKUP); 163 if (!checkStringLength(buf.toString() + s, isManifest)) { 164 addLine(file, buf, Setup.getDropEngineColor()); 165 buf = new StringBuffer(TAB); // new line 166 } 167 buf.append(s); 168 } 169 addLine(file, buf, Setup.getDropEngineColor()); 170 } 171 172 /** 173 * Returns the pick up string for a loco. Useful for frames like the train 174 * conductor and yardmaster. 175 * 176 * @param engine The Engine. 177 * @return engine pick up string 178 */ 179 public String pickupEngine(Engine engine) { 180 StringBuilder builder = new StringBuilder(); 181 for (String attribute : Setup.getPickupEngineMessageFormat()) { 182 builder.append(getEngineAttribute(engine, attribute, PICKUP)); 183 } 184 return builder.toString(); 185 } 186 187 /** 188 * Returns the drop string for a loco. Useful for frames like the train 189 * conductor and yardmaster. 190 * 191 * @param engine The Engine. 192 * @return engine drop string 193 */ 194 public String dropEngine(Engine engine) { 195 StringBuilder builder = new StringBuilder(); 196 for (String attribute : Setup.getDropEngineMessageFormat()) { 197 builder.append(getEngineAttribute(engine, attribute, !PICKUP)); 198 } 199 return builder.toString(); 200 } 201 202 // the next three booleans are used to limit the header to once per location 203 boolean _printPickupHeader = true; 204 boolean _printSetoutHeader = true; 205 boolean _printLocalMoveHeader = true; 206 207 /** 208 * Block cars by track, then pick up and set out for each location in a 209 * train's route. This routine is used for the "Standard" format. 210 * 211 * @param file Manifest or switch list File 212 * @param train The train being printed. 213 * @param carList List of cars for this train 214 * @param rl The RouteLocation being printed 215 * @param printHeader True if new location. 216 * @param isManifest True if manifest, false if switch list. 217 */ 218 protected void blockCarsByTrack(PrintWriter file, Train train, List<Car> carList, RouteLocation rl, 219 boolean printHeader, boolean isManifest) { 220 if (printHeader) { 221 _printPickupHeader = true; 222 _printSetoutHeader = true; 223 _printLocalMoveHeader = true; 224 } 225 List<Track> tracks = rl.getLocation().getTracksByNameList(null); 226 List<String> trackNames = new ArrayList<>(); 227 clearUtilityCarTypes(); // list utility cars by quantity 228 for (Track track : tracks) { 229 if (trackNames.contains(track.getSplitName())) { 230 continue; 231 } 232 trackNames.add(track.getSplitName()); // use a track name once 233 234 // car pick ups 235 blockCarsPickups(file, train, carList, rl, track, isManifest); 236 237 // now do car set outs and local moves 238 // group local moves first? 239 blockCarsSetoutsAndMoves(file, train, carList, rl, track, isManifest, false, 240 Setup.isGroupCarMovesEnabled()); 241 // set outs or both 242 blockCarsSetoutsAndMoves(file, train, carList, rl, track, isManifest, true, 243 !Setup.isGroupCarMovesEnabled()); 244 245 if (!Setup.isSortByTrackNameEnabled()) { 246 break; // done 247 } 248 } 249 } 250 251 private void blockCarsPickups(PrintWriter file, Train train, List<Car> carList, RouteLocation rl, 252 Track track, boolean isManifest) { 253 // block pick up cars, except for passenger cars 254 for (RouteLocation rld : train.getTrainBlockingOrder()) { 255 for (Car car : carList) { 256 if (Setup.isSortByTrackNameEnabled() && 257 !track.getSplitName().equals(car.getSplitTrackName())) { 258 continue; 259 } 260 // Block cars 261 // caboose or FRED is placed at end of the train 262 // passenger cars are already blocked in the car list 263 // passenger cars with negative block numbers are placed at 264 // the front of the train, positive numbers at the end of 265 // the train. 266 if (isNextCar(car, rl, rld)) { 267 // determine if pick up header is needed 268 printPickupCarHeader(file, car, isManifest, !IS_TWO_COLUMN_TRACK); 269 270 // use truncated format if there's a switch list 271 boolean isTruncate = Setup.isPrintTruncateManifestEnabled() && 272 rl.getLocation().isSwitchListEnabled(); 273 274 if (car.isUtility()) { 275 pickupUtilityCars(file, carList, car, isTruncate, isManifest); 276 } else if (isManifest && isTruncate) { 277 pickUpCarTruncated(file, car, isManifest); 278 } else { 279 pickUpCar(file, car, isManifest); 280 } 281 _pickupCars = true; 282 } 283 } 284 } 285 } 286 287 private void blockCarsSetoutsAndMoves(PrintWriter file, Train train, List<Car> carList, RouteLocation rl, 288 Track track, boolean isManifest, boolean isSetout, boolean isLocalMove) { 289 for (Car car : carList) { 290 if (!car.isLocalMove() && isSetout || car.isLocalMove() && isLocalMove) { 291 if (Setup.isSortByTrackNameEnabled() && 292 car.getRouteLocation() != null && 293 car.getRouteDestination() == rl) { 294 // must sort local moves by car's destination track name and not car's track name 295 // sorting by car's track name fails if there are "similar" location names. 296 if (!track.getSplitName().equals(car.getSplitDestinationTrackName())) { 297 continue; 298 } 299 } 300 if (car.getRouteDestination() == rl && car.getDestinationTrack() != null) { 301 // determine if drop or move header is needed 302 printDropOrMoveCarHeader(file, car, isManifest, !IS_TWO_COLUMN_TRACK); 303 304 // use truncated format if there's a switch list 305 boolean isTruncate = Setup.isPrintTruncateManifestEnabled() && 306 rl.getLocation().isSwitchListEnabled() && 307 !train.isLocalSwitcher(); 308 309 if (car.isUtility()) { 310 setoutUtilityCars(file, carList, car, isTruncate, isManifest); 311 } else if (isManifest && isTruncate) { 312 truncatedDropCar(file, car, isManifest); 313 } else { 314 dropCar(file, car, isManifest); 315 } 316 _dropCars = true; 317 } 318 } 319 } 320 } 321 322 /** 323 * Used to determine if car is the next to be processed when producing 324 * Manifests or Switch Lists. Caboose or FRED is placed at end of the train. 325 * Passenger cars are already blocked in the car list. Passenger cars with 326 * negative block numbers are placed at the front of the train, positive 327 * numbers at the end of the train. Note that a car in train doesn't have a 328 * track assignment. 329 * 330 * @param car the car being tested 331 * @param rl when in train's route the car is being pulled 332 * @param rld the destination being tested 333 * @return true if this car is the next one to be processed 334 */ 335 public static boolean isNextCar(Car car, RouteLocation rl, RouteLocation rld) { 336 return isNextCar(car, rl, rld, false); 337 } 338 339 public static boolean isNextCar(Car car, RouteLocation rl, RouteLocation rld, boolean isIgnoreTrack) { 340 Train train = car.getTrain(); 341 if (train != null && 342 (car.getTrack() != null || isIgnoreTrack) && 343 car.getRouteLocation() == rl && 344 (rld == car.getRouteDestination() && 345 !car.isCaboose() && 346 !car.hasFred() && 347 !car.isPassenger() || 348 rld == train.getTrainDepartsRouteLocation() && 349 car.isPassenger() && 350 car.getBlocking() < 0 || 351 rld == train.getTrainTerminatesRouteLocation() && 352 (car.isCaboose() || 353 car.hasFred() || 354 car.isPassenger() && car.getBlocking() >= 0))) { 355 return true; 356 } 357 return false; 358 } 359 360 private void printPickupCarHeader(PrintWriter file, Car car, boolean isManifest, boolean isTwoColumnTrack) { 361 if (_printPickupHeader && !car.isLocalMove()) { 362 printPickupCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK); 363 _printPickupHeader = false; 364 // check to see if the other headers are needed. If 365 // they are identical, not needed 366 if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK) 367 .equals(getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK))) { 368 _printSetoutHeader = false; 369 } 370 if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK) 371 .equals(getLocalMoveHeader(isManifest))) { 372 _printLocalMoveHeader = false; 373 } 374 } 375 } 376 377 private void printDropOrMoveCarHeader(PrintWriter file, Car car, boolean isManifest, boolean isTwoColumnTrack) { 378 if (_printSetoutHeader && !car.isLocalMove()) { 379 printDropCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK); 380 _printSetoutHeader = false; 381 // check to see if the other headers are needed. If they 382 // are identical, not needed 383 if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK) 384 .equals(getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK))) { 385 _printPickupHeader = false; 386 } 387 if (getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK).equals(getLocalMoveHeader(isManifest))) { 388 _printLocalMoveHeader = false; 389 } 390 } 391 if (_printLocalMoveHeader && car.isLocalMove()) { 392 printLocalCarMoveHeader(file, isManifest); 393 _printLocalMoveHeader = false; 394 // check to see if the other headers are needed. If they 395 // are identical, not needed 396 if (getPickupCarHeader(isManifest, !IS_TWO_COLUMN_TRACK) 397 .equals(getLocalMoveHeader(isManifest))) { 398 _printPickupHeader = false; 399 } 400 if (getDropCarHeader(isManifest, !IS_TWO_COLUMN_TRACK).equals(getLocalMoveHeader(isManifest))) { 401 _printSetoutHeader = false; 402 } 403 } 404 } 405 406 /** 407 * Produces a two column format for car pick ups and set outs. Sorted by 408 * track and then by blocking order. This routine is used for the "Two 409 * Column" format. 410 * 411 * @param file Manifest or switch list File 412 * @param train The train 413 * @param carList List of cars for this train 414 * @param rl The RouteLocation being printed 415 * @param printHeader True if new location. 416 * @param isManifest True if manifest, false if switch list. 417 */ 418 protected void blockCarsTwoColumn(PrintWriter file, Train train, List<Car> carList, RouteLocation rl, 419 boolean printHeader, boolean isManifest) { 420 index = 0; 421 int lineLength = getLineLength(isManifest); 422 List<Track> tracks = rl.getLocation().getTracksByNameList(null); 423 List<String> trackNames = new ArrayList<>(); 424 clearUtilityCarTypes(); // list utility cars by quantity 425 if (printHeader) { 426 printCarHeader(file, isManifest, !IS_TWO_COLUMN_TRACK); 427 } 428 for (Track track : tracks) { 429 if (trackNames.contains(track.getSplitName())) { 430 continue; 431 } 432 trackNames.add(track.getSplitName()); // use a track name once 433 // block car pick ups 434 for (RouteLocation rld : train.getTrainBlockingOrder()) { 435 for (int k = 0; k < carList.size(); k++) { 436 Car car = carList.get(k); 437 // block cars 438 // caboose or FRED is placed at end of the train 439 // passenger cars are already blocked in the car list 440 // passenger cars with negative block numbers are placed at 441 // the front of the train, positive numbers at the end of 442 // the train. 443 if (isNextCar(car, rl, rld)) { 444 if (Setup.isSortByTrackNameEnabled() && 445 !track.getSplitName().equals(car.getSplitTrackName())) { 446 continue; 447 } 448 _pickupCars = true; 449 String s; 450 if (car.isUtility()) { 451 s = pickupUtilityCars(carList, car, isManifest, !IS_TWO_COLUMN_TRACK); 452 if (s == null) { 453 continue; 454 } 455 s = s.trim(); 456 } else { 457 s = pickupCar(car, isManifest, !IS_TWO_COLUMN_TRACK).trim(); 458 } 459 s = padAndTruncate(s, lineLength / 2); 460 if (car.isLocalMove()) { 461 s = formatColorString(s, Setup.getLocalColor()); 462 String sl = appendSetoutString(s, carList, car.getRouteDestination(), car, isManifest, 463 !IS_TWO_COLUMN_TRACK); 464 // check for utility car, and local route with two 465 // or more locations 466 if (!sl.equals(s)) { 467 s = sl; 468 carList.remove(car); // done with this car, remove from list 469 k--; 470 } else { 471 s = padAndTruncate(s + VERTICAL_LINE_CHAR, getLineLength(isManifest)); 472 } 473 } else { 474 s = formatColorString(s, Setup.getPickupColor()); 475 s = appendSetoutString(s, carList, rl, true, isManifest, !IS_TWO_COLUMN_TRACK); 476 } 477 addLine(file, s); 478 } 479 } 480 } 481 if (!Setup.isSortByTrackNameEnabled()) { 482 break; // done 483 } 484 } 485 while (index < carList.size()) { 486 String s = padString("", lineLength / 2); 487 s = appendSetoutString(s, carList, rl, false, isManifest, !IS_TWO_COLUMN_TRACK); 488 String test = s.trim(); 489 // null line contains | 490 if (test.length() > 1) { 491 addLine(file, s); 492 } 493 } 494 } 495 496 List<Car> doneCars = new ArrayList<>(); 497 498 /** 499 * Produces a two column format for car pick ups and set outs. Sorted by 500 * track and then by destination. Track name in header format, track name 501 * removed from format. This routine is used to generate the "Two Column by 502 * Track" format. 503 * 504 * @param file Manifest or switch list File 505 * @param train The train 506 * @param carList List of cars for this train 507 * @param rl The RouteLocation being printed 508 * @param printHeader True if new location. 509 * @param isManifest True if manifest, false if switch list. 510 */ 511 protected void blockCarsByTrackNameTwoColumn(PrintWriter file, Train train, List<Car> carList, RouteLocation rl, 512 boolean printHeader, boolean isManifest) { 513 index = 0; 514 List<Track> tracks = rl.getLocation().getTracksByNameList(null); 515 List<String> trackNames = new ArrayList<>(); 516 doneCars.clear(); 517 clearUtilityCarTypes(); // list utility cars by quantity 518 if (printHeader) { 519 printCarHeader(file, isManifest, IS_TWO_COLUMN_TRACK); 520 } 521 for (Track track : tracks) { 522 String trackName = track.getSplitName(); 523 if (trackNames.contains(trackName)) { 524 continue; 525 } 526 // block car pick ups 527 for (RouteLocation rld : train.getTrainBlockingOrder()) { 528 for (Car car : carList) { 529 if (car.getTrack() != null && 530 car.getRouteLocation() == rl && 531 trackName.equals(car.getSplitTrackName()) && 532 ((car.getRouteDestination() == rld && !car.isCaboose() && !car.hasFred()) || 533 (rld == train.getTrainTerminatesRouteLocation() && 534 (car.isCaboose() || car.hasFred())))) { 535 if (!trackNames.contains(trackName)) { 536 printTrackNameHeader(file, trackName, isManifest); 537 } 538 trackNames.add(trackName); // use a track name once 539 _pickupCars = true; 540 String s; 541 if (car.isUtility()) { 542 s = pickupUtilityCars(carList, car, isManifest, IS_TWO_COLUMN_TRACK); 543 if (s == null) { 544 continue; 545 } 546 s = s.trim(); 547 } else { 548 s = pickupCar(car, isManifest, IS_TWO_COLUMN_TRACK).trim(); 549 } 550 s = padAndTruncate(s, getLineLength(isManifest) / 2); 551 s = formatColorString(s, car.isLocalMove() ? Setup.getLocalColor() : Setup.getPickupColor()); 552 s = appendSetoutString(s, trackName, carList, rl, isManifest, IS_TWO_COLUMN_TRACK); 553 addLine(file, s); 554 } 555 } 556 } 557 for (Car car : carList) { 558 if (!doneCars.contains(car) && 559 car.getRouteDestination() == rl && 560 trackName.equals(car.getSplitDestinationTrackName())) { 561 if (!trackNames.contains(trackName)) { 562 printTrackNameHeader(file, trackName, isManifest); 563 } 564 trackNames.add(trackName); // use a track name once 565 String s = padString("", getLineLength(isManifest) / 2); 566 String so = appendSetoutString(s, carList, rl, car, isManifest, IS_TWO_COLUMN_TRACK); 567 // check for utility car 568 if (so.equals(s)) { 569 continue; 570 } 571 String test = so.trim(); 572 if (test.length() > 1) // null line contains | 573 { 574 addLine(file, so); 575 } 576 } 577 } 578 } 579 } 580 581 protected void printTrackComments(PrintWriter file, RouteLocation rl, List<Car> carList, boolean isManifest) { 582 Location location = rl.getLocation(); 583 if (location != null) { 584 List<Track> tracks = location.getTracksByNameList(null); 585 for (Track track : tracks) { 586 if (isManifest && !track.isPrintManifestCommentEnabled() || 587 !isManifest && !track.isPrintSwitchListCommentEnabled()) { 588 continue; 589 } 590 // any pick ups or set outs to this track? 591 boolean pickup = false; 592 boolean setout = false; 593 for (Car car : carList) { 594 if (car.getRouteLocation() == rl && car.getTrack() != null && car.getTrack() == track) { 595 pickup = true; 596 } 597 if (car.getRouteDestination() == rl && 598 car.getDestinationTrack() != null && 599 car.getDestinationTrack() == track) { 600 setout = true; 601 } 602 } 603 // print the appropriate comment if there's one 604 if (pickup && setout && !track.getCommentBothWithColor().equals(Track.NONE)) { 605 newLine(file, track.getCommentBothWithColor(), isManifest); 606 } else if (pickup && !setout && !track.getCommentPickupWithColor().equals(Track.NONE)) { 607 newLine(file, track.getCommentPickupWithColor(), isManifest); 608 } else if (!pickup && setout && !track.getCommentSetoutWithColor().equals(Track.NONE)) { 609 newLine(file, track.getCommentSetoutWithColor(), isManifest); 610 } 611 } 612 } 613 } 614 615 protected void setCarPickupAndSetoutTimes(Train train, RouteLocation rl, List<Car> carList) { 616 String expectedDepartureTime = train.getExpectedDepartureTime(rl, true); 617 for (Car car : carList) { 618 if (car.getRouteLocation() == rl) { 619 car.setPickupTime(expectedDepartureTime); 620 } 621 if (car.getRouteDestination() == rl) { 622 car.setSetoutTime(expectedDepartureTime); 623 } 624 } 625 626 } 627 628 @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SLF4J_FORMAT_SHOULD_BE_CONST", 629 justification = "Only when exception") 630 public static String getTrainMessage(Train train, RouteLocation rl) { 631 String expectedArrivalTime = train.getExpectedArrivalTime(rl); 632 String routeLocationName = rl.getSplitName(); 633 String msg = ""; 634 String messageFormatText = ""; // the text being formated in case there's an exception 635 try { 636 // Scheduled work at {0} 637 msg = MessageFormat.format(messageFormatText = TrainManifestText 638 .getStringScheduledWork(), 639 new Object[]{routeLocationName, train.getSplitName(), 640 train.getDescription(), rl.getLocation().getDivisionName()}); 641 if (train.isShowArrivalAndDepartureTimesEnabled()) { 642 if (rl == train.getTrainDepartsRouteLocation()) { 643 // Scheduled work at {0}, departure time {1} 644 msg = MessageFormat.format(messageFormatText = TrainManifestText 645 .getStringWorkDepartureTime(), 646 new Object[]{routeLocationName, 647 train.getFormatedDepartureTime(), train.getSplitName(), 648 train.getDescription(), rl.getLocation().getDivisionName()}); 649 } else if (!rl.getDepartureTime().equals(RouteLocation.NONE) && 650 rl != train.getTrainTerminatesRouteLocation()) { 651 // Scheduled work at {0}, departure time {1} 652 msg = MessageFormat.format(messageFormatText = TrainManifestText 653 .getStringWorkDepartureTime(), 654 new Object[]{routeLocationName, 655 expectedArrivalTime.equals(Train.ALREADY_SERVICED) 656 ? rl.getFormatedDepartureTime() : train.getExpectedDepartureTime(rl), 657 train.getSplitName(), train.getDescription(), 658 rl.getLocation().getDivisionName()}); 659 } else if (Setup.isUseDepartureTimeEnabled() && 660 rl != train.getTrainTerminatesRouteLocation() && 661 !train.getExpectedDepartureTime(rl).equals(Train.ALREADY_SERVICED)) { 662 // Scheduled work at {0}, departure time {1} 663 msg = MessageFormat.format(messageFormatText = TrainManifestText 664 .getStringWorkDepartureTime(), 665 new Object[]{routeLocationName, 666 train.getExpectedDepartureTime(rl), train.getSplitName(), 667 train.getDescription(), rl.getLocation().getDivisionName()}); 668 } else if (!expectedArrivalTime.equals(Train.ALREADY_SERVICED)) { 669 // Scheduled work at {0}, arrival time {1} 670 msg = MessageFormat.format(messageFormatText = TrainManifestText 671 .getStringWorkArrivalTime(), 672 new Object[]{routeLocationName, expectedArrivalTime, 673 train.getSplitName(), train.getDescription(), 674 rl.getLocation().getDivisionName()}); 675 } 676 } 677 return msg; 678 } catch (IllegalArgumentException e) { 679 msg = Bundle.getMessage("ErrorIllegalArgument", 680 Bundle.getMessage("TitleManifestText"), e.getLocalizedMessage()) + NEW_LINE + messageFormatText; 681 log.error(msg); 682 log.error("Illegal argument", e); 683 return msg; 684 } 685 } 686 687 @edu.umd.cs.findbugs.annotations.SuppressFBWarnings(value = "SLF4J_FORMAT_SHOULD_BE_CONST", 688 justification = "Only when exception") 689 public static String getSwitchListTrainStatus(Train train, RouteLocation rl) { 690 String expectedArrivalTime = train.getExpectedArrivalTime(rl); 691 String msg = ""; 692 String messageFormatText = ""; // the text being formated in case there's an exception 693 try { 694 if (train.isLocalSwitcher()) { 695 // Use Manifest text for local departure 696 // Scheduled work at {0}, departure time {1} 697 msg = MessageFormat.format(messageFormatText = TrainManifestText.getStringWorkDepartureTime(), 698 new Object[]{splitString(train.getTrainDepartsName()), train.getFormatedDepartureTime(), 699 train.getSplitName(), train.getDescription(), 700 rl.getLocation().getDivisionName()}); 701 } else if (rl == train.getTrainDepartsRouteLocation()) { 702 // Departs {0} {1}bound at {2} 703 msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartsAt(), 704 new Object[]{splitString(train.getTrainDepartsName()), rl.getTrainDirectionString(), 705 train.getFormatedDepartureTime()}); 706 } else if (Setup.isUseSwitchListDepartureTimeEnabled() && 707 rl != train.getTrainTerminatesRouteLocation() && 708 !train.isTrainEnRoute()) { 709 // Departs {0} at {1} expected arrival {2}, arrives {3}bound 710 msg = MessageFormat.format( 711 messageFormatText = TrainSwitchListText.getStringDepartsAtExpectedArrival(), 712 new Object[]{splitString(rl.getName()), 713 train.getExpectedDepartureTime(rl), expectedArrivalTime, 714 rl.getTrainDirectionString()}); 715 } else if (Setup.isUseSwitchListDepartureTimeEnabled() && 716 rl == train.getCurrentRouteLocation() && 717 rl != train.getTrainTerminatesRouteLocation() && 718 !rl.getDepartureTime().equals(RouteLocation.NONE)) { 719 // Departs {0} {1}bound at {2} 720 msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartsAt(), 721 new Object[]{splitString(rl.getName()), rl.getTrainDirectionString(), 722 rl.getFormatedDepartureTime()}); 723 } else if (train.isTrainEnRoute()) { 724 if (!expectedArrivalTime.equals(Train.ALREADY_SERVICED)) { 725 // Departed {0}, expect to arrive in {1}, arrives {2}bound 726 msg = MessageFormat.format(messageFormatText = TrainSwitchListText.getStringDepartedExpected(), 727 new Object[]{splitString(train.getTrainDepartsName()), expectedArrivalTime, 728 rl.getTrainDirectionString(), train.getCurrentLocationName()}); 729 } 730 } else { 731 // Departs {0} at {1} expected arrival {2}, arrives {3}bound 732 msg = MessageFormat.format( 733 messageFormatText = TrainSwitchListText.getStringDepartsAtExpectedArrival(), 734 new Object[]{splitString(train.getTrainDepartsName()), 735 train.getFormatedDepartureTime(), expectedArrivalTime, 736 rl.getTrainDirectionString()}); 737 } 738 return msg; 739 } catch (IllegalArgumentException e) { 740 msg = Bundle.getMessage("ErrorIllegalArgument", 741 Bundle.getMessage("TitleSwitchListText"), e.getLocalizedMessage()) + NEW_LINE + messageFormatText; 742 log.error(msg); 743 log.error("Illegal argument", e); 744 return msg; 745 } 746 } 747 748 int index = 0; 749 750 /* 751 * Used by two column format. Local moves (pulls and spots) are lined up 752 * when using this format, 753 */ 754 private String appendSetoutString(String s, List<Car> carList, RouteLocation rl, boolean local, boolean isManifest, 755 boolean isTwoColumnTrack) { 756 while (index < carList.size()) { 757 Car car = carList.get(index++); 758 if (local && car.isLocalMove()) { 759 continue; // skip local moves 760 } 761 // car list is already sorted by destination track 762 if (car.getRouteDestination() == rl) { 763 String so = appendSetoutString(s, carList, rl, car, isManifest, isTwoColumnTrack); 764 // check for utility car 765 if (!so.equals(s)) { 766 return so; 767 } 768 } 769 } 770 // no set out for this line 771 return s + VERTICAL_LINE_CHAR + padAndTruncate("", getLineLength(isManifest) / 2 - 1); 772 } 773 774 /* 775 * Used by two column, track names shown in the columns. 776 */ 777 private String appendSetoutString(String s, String trackName, List<Car> carList, RouteLocation rl, 778 boolean isManifest, boolean isTwoColumnTrack) { 779 for (Car car : carList) { 780 if (!doneCars.contains(car) && 781 car.getRouteDestination() == rl && 782 trackName.equals(car.getSplitDestinationTrackName())) { 783 doneCars.add(car); 784 String so = appendSetoutString(s, carList, rl, car, isManifest, isTwoColumnTrack); 785 // check for utility car 786 if (!so.equals(s)) { 787 return so; 788 } 789 } 790 } 791 // no set out for this track 792 return s + VERTICAL_LINE_CHAR + padAndTruncate("", getLineLength(isManifest) / 2 - 1); 793 } 794 795 /* 796 * Appends to string the vertical line character, and the car set out 797 * string. Used in two column format. 798 */ 799 private String appendSetoutString(String s, List<Car> carList, RouteLocation rl, Car car, boolean isManifest, 800 boolean isTwoColumnTrack) { 801 _dropCars = true; 802 String dropText; 803 804 if (car.isUtility()) { 805 dropText = setoutUtilityCars(carList, car, !LOCAL, isManifest, isTwoColumnTrack); 806 if (dropText == null) { 807 return s; // no changes to the input string 808 } 809 } else { 810 dropText = dropCar(car, isManifest, isTwoColumnTrack).trim(); 811 } 812 813 dropText = padAndTruncate(dropText.trim(), getLineLength(isManifest) / 2 - 1); 814 dropText = formatColorString(dropText, car.isLocalMove() ? Setup.getLocalColor() : Setup.getDropColor()); 815 return s + VERTICAL_LINE_CHAR + dropText; 816 } 817 818 /** 819 * Adds the car's pick up string to the output file using the truncated 820 * manifest format 821 * 822 * @param file Manifest or switch list File 823 * @param car The car being printed. 824 * @param isManifest True if manifest, false if switch list. 825 */ 826 protected void pickUpCarTruncated(PrintWriter file, Car car, boolean isManifest) { 827 pickUpCar(file, car, 828 new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupCarPrefix(), Setup.getManifestPrefixLength())), 829 Setup.getPickupTruncatedManifestMessageFormat(), isManifest); 830 } 831 832 /** 833 * Adds the car's pick up string to the output file using the manifest or 834 * switch list format 835 * 836 * @param file Manifest or switch list File 837 * @param car The car being printed. 838 * @param isManifest True if manifest, false if switch list. 839 */ 840 protected void pickUpCar(PrintWriter file, Car car, boolean isManifest) { 841 if (isManifest) { 842 pickUpCar(file, car, 843 new StringBuffer( 844 padAndTruncateIfNeeded(Setup.getPickupCarPrefix(), Setup.getManifestPrefixLength())), 845 Setup.getPickupManifestMessageFormat(), isManifest); 846 } else { 847 pickUpCar(file, car, new StringBuffer( 848 padAndTruncateIfNeeded(Setup.getSwitchListPickupCarPrefix(), Setup.getSwitchListPrefixLength())), 849 Setup.getPickupSwitchListMessageFormat(), isManifest); 850 } 851 } 852 853 private void pickUpCar(PrintWriter file, Car car, StringBuffer buf, String[] format, boolean isManifest) { 854 if (car.isLocalMove()) { 855 return; // print nothing local move, see dropCar 856 } 857 for (String attribute : format) { 858 String s = getCarAttribute(car, attribute, PICKUP, !LOCAL); 859 if (!checkStringLength(buf.toString() + s, isManifest)) { 860 addLine(file, buf, Setup.getPickupColor()); 861 buf = new StringBuffer(TAB); // new line 862 } 863 buf.append(s); 864 } 865 addLine(file, buf, Setup.getPickupColor()); 866 } 867 868 /** 869 * Returns the pick up car string. Useful for frames like train conductor 870 * and yardmaster. 871 * 872 * @param car The car being printed. 873 * @param isManifest when true use manifest format, when false use 874 * switch list format 875 * @param isTwoColumnTrack True if printing using two column format sorted 876 * by track name. 877 * @return pick up car string 878 */ 879 public String pickupCar(Car car, boolean isManifest, boolean isTwoColumnTrack) { 880 StringBuffer buf = new StringBuffer(); 881 String[] format; 882 if (isManifest && !isTwoColumnTrack) { 883 format = Setup.getPickupManifestMessageFormat(); 884 } else if (!isManifest && !isTwoColumnTrack) { 885 format = Setup.getPickupSwitchListMessageFormat(); 886 } else if (isManifest && isTwoColumnTrack) { 887 format = Setup.getPickupTwoColumnByTrackManifestMessageFormat(); 888 } else { 889 format = Setup.getPickupTwoColumnByTrackSwitchListMessageFormat(); 890 } 891 for (String attribute : format) { 892 buf.append(getCarAttribute(car, attribute, PICKUP, !LOCAL)); 893 } 894 return buf.toString(); 895 } 896 897 /** 898 * Adds the car's set out string to the output file using the truncated 899 * manifest format. Does not print out local moves. Local moves are only 900 * shown on the switch list for that location. 901 * 902 * @param file Manifest or switch list File 903 * @param car The car being printed. 904 * @param isManifest True if manifest, false if switch list. 905 */ 906 protected void truncatedDropCar(PrintWriter file, Car car, boolean isManifest) { 907 // local move? 908 if (car.isLocalMove()) { 909 return; // yes, don't print local moves on train manifest 910 } 911 dropCar(file, car, new StringBuffer(Setup.getDropCarPrefix()), Setup.getDropTruncatedManifestMessageFormat(), 912 false, isManifest); 913 } 914 915 /** 916 * Adds the car's set out string to the output file using the manifest or 917 * switch list format 918 * 919 * @param file Manifest or switch list File 920 * @param car The car being printed. 921 * @param isManifest True if manifest, false if switch list. 922 */ 923 protected void dropCar(PrintWriter file, Car car, boolean isManifest) { 924 boolean isLocal = car.isLocalMove(); 925 if (isManifest) { 926 StringBuffer buf = new StringBuffer( 927 padAndTruncateIfNeeded(Setup.getDropCarPrefix(), Setup.getManifestPrefixLength())); 928 String[] format = Setup.getDropManifestMessageFormat(); 929 if (isLocal) { 930 buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getLocalPrefix(), Setup.getManifestPrefixLength())); 931 format = Setup.getLocalManifestMessageFormat(); 932 } 933 dropCar(file, car, buf, format, isLocal, isManifest); 934 } else { 935 StringBuffer buf = new StringBuffer( 936 padAndTruncateIfNeeded(Setup.getSwitchListDropCarPrefix(), Setup.getSwitchListPrefixLength())); 937 String[] format = Setup.getDropSwitchListMessageFormat(); 938 if (isLocal) { 939 buf = new StringBuffer( 940 padAndTruncateIfNeeded(Setup.getSwitchListLocalPrefix(), Setup.getSwitchListPrefixLength())); 941 format = Setup.getLocalSwitchListMessageFormat(); 942 } 943 dropCar(file, car, buf, format, isLocal, isManifest); 944 } 945 } 946 947 private void dropCar(PrintWriter file, Car car, StringBuffer buf, String[] format, boolean isLocal, 948 boolean isManifest) { 949 for (String attribute : format) { 950 String s = getCarAttribute(car, attribute, !PICKUP, isLocal); 951 if (!checkStringLength(buf.toString() + s, isManifest)) { 952 addLine(file, buf, isLocal ? Setup.getLocalColor() : Setup.getDropColor()); 953 buf = new StringBuffer(TAB); // new line 954 } 955 buf.append(s); 956 } 957 addLine(file, buf, isLocal ? Setup.getLocalColor() : Setup.getDropColor()); 958 } 959 960 /** 961 * Returns the drop car string. Useful for frames like train conductor and 962 * yardmaster. 963 * 964 * @param car The car being printed. 965 * @param isManifest when true use manifest format, when false use 966 * switch list format 967 * @param isTwoColumnTrack True if printing using two column format. 968 * @return drop car string 969 */ 970 public String dropCar(Car car, boolean isManifest, boolean isTwoColumnTrack) { 971 StringBuffer buf = new StringBuffer(); 972 String[] format; 973 if (isManifest && !isTwoColumnTrack) { 974 format = Setup.getDropManifestMessageFormat(); 975 } else if (!isManifest && !isTwoColumnTrack) { 976 format = Setup.getDropSwitchListMessageFormat(); 977 } else if (isManifest && isTwoColumnTrack) { 978 format = Setup.getDropTwoColumnByTrackManifestMessageFormat(); 979 } else { 980 format = Setup.getDropTwoColumnByTrackSwitchListMessageFormat(); 981 } 982 // TODO the Setup.Location doesn't work correctly for the conductor 983 // window due to the fact that the car can be in the train and not 984 // at its starting location. 985 // Therefore we use the local true to disable it. 986 boolean local = false; 987 if (car.getTrack() == null) { 988 local = true; 989 } 990 for (String attribute : format) { 991 buf.append(getCarAttribute(car, attribute, !PICKUP, local)); 992 } 993 return buf.toString(); 994 } 995 996 /** 997 * Returns the move car string. Useful for frames like train conductor and 998 * yardmaster. 999 * 1000 * @param car The car being printed. 1001 * @param isManifest when true use manifest format, when false use switch 1002 * list format 1003 * @return move car string 1004 */ 1005 public String localMoveCar(Car car, boolean isManifest) { 1006 StringBuffer buf = new StringBuffer(); 1007 String[] format; 1008 if (isManifest) { 1009 format = Setup.getLocalManifestMessageFormat(); 1010 } else { 1011 format = Setup.getLocalSwitchListMessageFormat(); 1012 } 1013 for (String attribute : format) { 1014 buf.append(getCarAttribute(car, attribute, !PICKUP, LOCAL)); 1015 } 1016 return buf.toString(); 1017 } 1018 1019 List<String> utilityCarTypes = new ArrayList<>(); 1020 private static final int UTILITY_CAR_COUNT_FIELD_SIZE = 3; 1021 1022 /** 1023 * Add a list of utility cars scheduled for pick up from the route location 1024 * to the output file. The cars are blocked by destination. 1025 * 1026 * @param file Manifest or Switch List File. 1027 * @param carList List of cars for this train. 1028 * @param car The utility car. 1029 * @param isTruncate True if manifest is to be truncated 1030 * @param isManifest True if manifest, false if switch list. 1031 */ 1032 protected void pickupUtilityCars(PrintWriter file, List<Car> carList, Car car, boolean isTruncate, 1033 boolean isManifest) { 1034 // list utility cars by type, track, length, and load 1035 String[] format; 1036 if (isManifest) { 1037 format = Setup.getPickupUtilityManifestMessageFormat(); 1038 } else { 1039 format = Setup.getPickupUtilitySwitchListMessageFormat(); 1040 } 1041 if (isTruncate && isManifest) { 1042 format = Setup.createTruncatedManifestMessageFormat(format); 1043 } 1044 int count = countUtilityCars(format, carList, car, PICKUP); 1045 if (count == 0) { 1046 return; // already printed out this car type 1047 } 1048 pickUpCar(file, car, 1049 new StringBuffer(padAndTruncateIfNeeded(Setup.getPickupCarPrefix(), 1050 isManifest ? Setup.getManifestPrefixLength() : Setup.getSwitchListPrefixLength()) + 1051 SPACE + 1052 padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE)), 1053 format, isManifest); 1054 } 1055 1056 /** 1057 * Add a list of utility cars scheduled for drop at the route location to 1058 * the output file. 1059 * 1060 * @param file Manifest or Switch List File. 1061 * @param carList List of cars for this train. 1062 * @param car The utility car. 1063 * @param isTruncate True if manifest is to be truncated 1064 * @param isManifest True if manifest, false if switch list. 1065 */ 1066 protected void setoutUtilityCars(PrintWriter file, List<Car> carList, Car car, boolean isTruncate, 1067 boolean isManifest) { 1068 boolean isLocal = car.isLocalMove(); 1069 StringBuffer buf; 1070 String[] format; 1071 if (isLocal && isManifest) { 1072 buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getLocalPrefix(), Setup.getManifestPrefixLength())); 1073 format = Setup.getLocalUtilityManifestMessageFormat(); 1074 } else if (!isLocal && isManifest) { 1075 buf = new StringBuffer(padAndTruncateIfNeeded(Setup.getDropCarPrefix(), Setup.getManifestPrefixLength())); 1076 format = Setup.getDropUtilityManifestMessageFormat(); 1077 } else if (isLocal && !isManifest) { 1078 buf = new StringBuffer( 1079 padAndTruncateIfNeeded(Setup.getSwitchListLocalPrefix(), Setup.getSwitchListPrefixLength())); 1080 format = Setup.getLocalUtilitySwitchListMessageFormat(); 1081 } else { 1082 buf = new StringBuffer( 1083 padAndTruncateIfNeeded(Setup.getSwitchListDropCarPrefix(), Setup.getSwitchListPrefixLength())); 1084 format = Setup.getDropUtilitySwitchListMessageFormat(); 1085 } 1086 if (isTruncate && isManifest) { 1087 format = Setup.createTruncatedManifestMessageFormat(format); 1088 } 1089 1090 int count = countUtilityCars(format, carList, car, !PICKUP); 1091 if (count == 0) { 1092 return; // already printed out this car type 1093 } 1094 buf.append(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE)); 1095 dropCar(file, car, buf, format, isLocal, isManifest); 1096 } 1097 1098 public String pickupUtilityCars(List<Car> carList, Car car, boolean isManifest, boolean isTwoColumnTrack) { 1099 int count = countPickupUtilityCars(carList, car, isManifest); 1100 if (count == 0) { 1101 return null; 1102 } 1103 String[] format; 1104 if (isManifest && !isTwoColumnTrack) { 1105 format = Setup.getPickupUtilityManifestMessageFormat(); 1106 } else if (!isManifest && !isTwoColumnTrack) { 1107 format = Setup.getPickupUtilitySwitchListMessageFormat(); 1108 } else if (isManifest && isTwoColumnTrack) { 1109 format = Setup.getPickupTwoColumnByTrackUtilityManifestMessageFormat(); 1110 } else { 1111 format = Setup.getPickupTwoColumnByTrackUtilitySwitchListMessageFormat(); 1112 } 1113 StringBuffer buf = new StringBuffer(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE)); 1114 for (String attribute : format) { 1115 buf.append(getCarAttribute(car, attribute, PICKUP, !LOCAL)); 1116 } 1117 return buf.toString(); 1118 } 1119 1120 public int countPickupUtilityCars(List<Car> carList, Car car, boolean isManifest) { 1121 // list utility cars by type, track, length, and load 1122 String[] format; 1123 if (isManifest) { 1124 format = Setup.getPickupUtilityManifestMessageFormat(); 1125 } else { 1126 format = Setup.getPickupUtilitySwitchListMessageFormat(); 1127 } 1128 return countUtilityCars(format, carList, car, PICKUP); 1129 } 1130 1131 /** 1132 * For the Conductor and Yardmaster windows. 1133 * 1134 * @param carList List of cars for this train. 1135 * @param car The utility car. 1136 * @param isLocal True if local move. 1137 * @param isManifest True if manifest, false if switch list. 1138 * @return A string representing the work of identical utility cars. 1139 */ 1140 public String setoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest) { 1141 return setoutUtilityCars(carList, car, isLocal, isManifest, !IS_TWO_COLUMN_TRACK); 1142 } 1143 1144 protected String setoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest, 1145 boolean isTwoColumnTrack) { 1146 int count = countSetoutUtilityCars(carList, car, isLocal, isManifest); 1147 if (count == 0) { 1148 return null; 1149 } 1150 // list utility cars by type, track, length, and load 1151 String[] format; 1152 if (isLocal && isManifest && !isTwoColumnTrack) { 1153 format = Setup.getLocalUtilityManifestMessageFormat(); 1154 } else if (isLocal && !isManifest && !isTwoColumnTrack) { 1155 format = Setup.getLocalUtilitySwitchListMessageFormat(); 1156 } else if (!isLocal && !isManifest && !isTwoColumnTrack) { 1157 format = Setup.getDropUtilitySwitchListMessageFormat(); 1158 } else if (!isLocal && isManifest && !isTwoColumnTrack) { 1159 format = Setup.getDropUtilityManifestMessageFormat(); 1160 } else if (isManifest && isTwoColumnTrack) { 1161 format = Setup.getDropTwoColumnByTrackUtilityManifestMessageFormat(); 1162 } else { 1163 format = Setup.getDropTwoColumnByTrackUtilitySwitchListMessageFormat(); 1164 } 1165 StringBuffer buf = new StringBuffer(SPACE + padString(Integer.toString(count), UTILITY_CAR_COUNT_FIELD_SIZE)); 1166 // TODO the Setup.Location doesn't work correctly for the conductor 1167 // window due to the fact that the car can be in the train and not 1168 // at its starting location. 1169 // Therefore we use the local true to disable it. 1170 if (car.getTrack() == null) { 1171 isLocal = true; 1172 } 1173 for (String attribute : format) { 1174 buf.append(getCarAttribute(car, attribute, !PICKUP, isLocal)); 1175 } 1176 return buf.toString(); 1177 } 1178 1179 public int countSetoutUtilityCars(List<Car> carList, Car car, boolean isLocal, boolean isManifest) { 1180 // list utility cars by type, track, length, and load 1181 String[] format; 1182 if (isLocal && isManifest) { 1183 format = Setup.getLocalUtilityManifestMessageFormat(); 1184 } else if (isLocal && !isManifest) { 1185 format = Setup.getLocalUtilitySwitchListMessageFormat(); 1186 } else if (!isLocal && !isManifest) { 1187 format = Setup.getDropUtilitySwitchListMessageFormat(); 1188 } else { 1189 format = Setup.getDropUtilityManifestMessageFormat(); 1190 } 1191 return countUtilityCars(format, carList, car, !PICKUP); 1192 } 1193 1194 /** 1195 * Scans the car list for utility cars that have the same attributes as the 1196 * car provided. Returns 0 if this car type has already been processed, 1197 * otherwise the number of cars with the same attribute. 1198 * 1199 * @param format Message format. 1200 * @param carList List of cars for this train 1201 * @param car The utility car. 1202 * @param isPickup True if pick up, false if set out. 1203 * @return 0 if the car type has already been processed 1204 */ 1205 protected int countUtilityCars(String[] format, List<Car> carList, Car car, boolean isPickup) { 1206 int count = 0; 1207 // figure out if the user wants to show the car's length 1208 boolean showLength = showUtilityCarLength(format); 1209 // figure out if the user want to show the car's loads 1210 boolean showLoad = showUtilityCarLoad(format); 1211 boolean showLocation = false; 1212 boolean showDestination = false; 1213 String carType = car.getTypeName().split(HYPHEN)[0]; 1214 String carAttributes; 1215 // Note for car pick up: type, id, track name. For set out type, track 1216 // name, id (reversed). 1217 if (isPickup) { 1218 carAttributes = carType + car.getRouteLocationId() + car.getSplitTrackName(); 1219 showDestination = showUtilityCarDestination(format); 1220 if (showDestination) { 1221 carAttributes = carAttributes + car.getRouteDestinationId(); 1222 } 1223 } else { 1224 // set outs and local moves 1225 carAttributes = carType + car.getSplitDestinationTrackName() + car.getRouteDestinationId(); 1226 showLocation = showUtilityCarLocation(format); 1227 if (showLocation && car.getTrack() != null) { 1228 carAttributes = carAttributes + car.getRouteLocationId(); 1229 } 1230 } 1231 if (car.isLocalMove()) { 1232 carAttributes = carAttributes + car.getSplitTrackName(); 1233 } 1234 if (showLength) { 1235 carAttributes = carAttributes + car.getLength(); 1236 } 1237 if (showLoad) { 1238 carAttributes = carAttributes + car.getLoadName(); 1239 } 1240 // have we already done this car type? 1241 if (!utilityCarTypes.contains(carAttributes)) { 1242 utilityCarTypes.add(carAttributes); // don't do this type again 1243 // determine how many cars of this type 1244 for (Car c : carList) { 1245 if (!c.isUtility()) { 1246 continue; 1247 } 1248 String cType = c.getTypeName().split(HYPHEN)[0]; 1249 if (!cType.equals(carType)) { 1250 continue; 1251 } 1252 if (showLength && !c.getLength().equals(car.getLength())) { 1253 continue; 1254 } 1255 if (showLoad && !c.getLoadName().equals(car.getLoadName())) { 1256 continue; 1257 } 1258 if (showLocation && !c.getRouteLocationId().equals(car.getRouteLocationId())) { 1259 continue; 1260 } 1261 if (showDestination && !c.getRouteDestinationId().equals(car.getRouteDestinationId())) { 1262 continue; 1263 } 1264 if (car.isLocalMove() ^ c.isLocalMove()) { 1265 continue; 1266 } 1267 if (isPickup && 1268 c.getRouteLocation() == car.getRouteLocation() && 1269 c.getSplitTrackName().equals(car.getSplitTrackName())) { 1270 count++; 1271 } 1272 if (!isPickup && 1273 c.getRouteDestination() == car.getRouteDestination() && 1274 c.getSplitDestinationTrackName().equals(car.getSplitDestinationTrackName()) && 1275 (c.getSplitTrackName().equals(car.getSplitTrackName()) || !c.isLocalMove())) { 1276 count++; 1277 } 1278 } 1279 } 1280 return count; 1281 } 1282 1283 public void clearUtilityCarTypes() { 1284 utilityCarTypes.clear(); 1285 } 1286 1287 private boolean showUtilityCarLength(String[] mFormat) { 1288 return showUtilityCarAttribute(Setup.LENGTH, mFormat); 1289 } 1290 1291 private boolean showUtilityCarLoad(String[] mFormat) { 1292 return showUtilityCarAttribute(Setup.LOAD, mFormat); 1293 } 1294 1295 private boolean showUtilityCarLocation(String[] mFormat) { 1296 return showUtilityCarAttribute(Setup.LOCATION, mFormat); 1297 } 1298 1299 private boolean showUtilityCarDestination(String[] mFormat) { 1300 return showUtilityCarAttribute(Setup.DESTINATION, mFormat) || 1301 showUtilityCarAttribute(Setup.DEST_TRACK, mFormat); 1302 } 1303 1304 private boolean showUtilityCarAttribute(String string, String[] mFormat) { 1305 for (String s : mFormat) { 1306 if (s.equals(string)) { 1307 return true; 1308 } 1309 } 1310 return false; 1311 } 1312 1313 /** 1314 * Writes a line to the build report file 1315 * 1316 * @param file build report file 1317 * @param level print level 1318 * @param string string to write 1319 */ 1320 public static void addLine(PrintWriter file, String level, String string) { 1321 log.debug("addLine: {}", string); 1322 if (file != null) { 1323 String[] lines = string.split(NEW_LINE); 1324 for (String line : lines) { 1325 printLine(file, level, line); 1326 } 1327 } 1328 } 1329 1330 // only used by build report 1331 private static void printLine(PrintWriter file, String level, String string) { 1332 int lineLengthMax = getLineLength(Setup.PORTRAIT, Setup.MONOSPACED, Font.PLAIN, Setup.getBuildReportFontSize()); 1333 if (string.length() > lineLengthMax) { 1334 String[] words = string.split(SPACE); 1335 StringBuffer sb = new StringBuffer(); 1336 for (String word : words) { 1337 if (sb.length() + word.length() < lineLengthMax) { 1338 sb.append(word + SPACE); 1339 } else { 1340 file.println(level + BUILD_REPORT_CHAR + SPACE + sb.toString()); 1341 sb = new StringBuffer(word + SPACE); 1342 } 1343 } 1344 string = sb.toString(); 1345 } 1346 file.println(level + BUILD_REPORT_CHAR + SPACE + string); 1347 } 1348 1349 /** 1350 * Writes string to file. No line length wrap or protection. 1351 * 1352 * @param file The File to write to. 1353 * @param string The string to write. 1354 */ 1355 protected void addLine(PrintWriter file, String string) { 1356 log.debug("addLine: {}", string); 1357 if (file != null) { 1358 file.println(string); 1359 } 1360 } 1361 1362 /** 1363 * Writes a string to a file. Checks for string length, and will 1364 * automatically wrap lines. 1365 * 1366 * @param file The File to write to. 1367 * @param string The string to write. 1368 * @param isManifest set true for manifest page orientation, false for 1369 * switch list orientation 1370 */ 1371 protected void newLine(PrintWriter file, String string, boolean isManifest) { 1372 String[] lines = string.split(NEW_LINE); 1373 for (String line : lines) { 1374 String[] words = line.split(SPACE); 1375 StringBuffer sb = new StringBuffer(); 1376 for (String word : words) { 1377 if (checkStringLength(sb.toString() + word, isManifest)) { 1378 sb.append(word + SPACE); 1379 } else { 1380 sb.setLength(sb.length() - 1); // remove last space added to string 1381 addLine(file, sb.toString()); 1382 sb = new StringBuffer(word + SPACE); 1383 } 1384 } 1385 if (sb.length() > 0) { 1386 sb.setLength(sb.length() - 1); // remove last space added to string 1387 } 1388 addLine(file, sb.toString()); 1389 } 1390 } 1391 1392 /** 1393 * Adds a blank line to the file. 1394 * 1395 * @param file The File to write to. 1396 */ 1397 protected void newLine(PrintWriter file) { 1398 file.println(BLANK_LINE); 1399 } 1400 1401 /** 1402 * Splits a string (example-number) as long as the second part of the string 1403 * is an integer or if the first character after the hyphen is a left 1404 * parenthesis "(". 1405 * 1406 * @param name The string to split if necessary. 1407 * @return First half of the string. 1408 */ 1409 public static String splitString(String name) { 1410 String[] splitname = name.split(HYPHEN); 1411 // is the hyphen followed by a number or left parenthesis? 1412 if (splitname.length > 1 && !splitname[1].startsWith("(")) { 1413 try { 1414 Integer.parseInt(splitname[1]); 1415 } catch (NumberFormatException e) { 1416 // no return full name 1417 return name.trim(); 1418 } 1419 } 1420 return splitname[0].trim(); 1421 } 1422 1423 /** 1424 * Splits a string if there's a hyphen followed by a left parenthesis "-(". 1425 * 1426 * @param name the string to split 1427 * @return First half of the string. 1428 */ 1429 public static String splitStringLeftParenthesis(String name) { 1430 String[] splitname = name.split(HYPHEN); 1431 if (splitname.length > 1 && splitname[1].startsWith("(")) { 1432 return splitname[0].trim(); 1433 } 1434 return name.trim(); 1435 } 1436 1437 // returns true if there's work at location 1438 protected boolean isThereWorkAtLocation(List<Car> carList, List<Engine> engList, RouteLocation rl) { 1439 if (carList != null) { 1440 for (Car car : carList) { 1441 if (car.getRouteLocation() == rl || car.getRouteDestination() == rl) { 1442 return true; 1443 } 1444 } 1445 } 1446 if (engList != null) { 1447 for (Engine eng : engList) { 1448 if (eng.getRouteLocation() == rl || eng.getRouteDestination() == rl) { 1449 return true; 1450 } 1451 } 1452 } 1453 return false; 1454 } 1455 1456 /** 1457 * returns true if the train has work at the location 1458 * 1459 * @param train The Train. 1460 * @param location The Location. 1461 * @return true if the train has work at the location 1462 */ 1463 public static boolean isThereWorkAtLocation(Train train, Location location) { 1464 if (isThereWorkAtLocation(train, location, InstanceManager.getDefault(CarManager.class).getList(train))) { 1465 return true; 1466 } 1467 if (isThereWorkAtLocation(train, location, InstanceManager.getDefault(EngineManager.class).getList(train))) { 1468 return true; 1469 } 1470 return false; 1471 } 1472 1473 private static boolean isThereWorkAtLocation(Train train, Location location, List<? extends RollingStock> list) { 1474 for (RollingStock rs : list) { 1475 if ((rs.getRouteLocation() != null && 1476 rs.getTrack() != null && 1477 rs.getRouteLocation().getSplitName() 1478 .equals(location.getSplitName())) || 1479 (rs.getRouteDestination() != null && 1480 rs.getRouteDestination().getSplitName().equals(location.getSplitName()))) { 1481 return true; 1482 } 1483 } 1484 return false; 1485 } 1486 1487 protected void addCarsLocationUnknown(PrintWriter file, boolean isManifest) { 1488 List<Car> cars = carManager.getCarsLocationUnknown(); 1489 if (cars.size() == 0) { 1490 return; // no cars to search for! 1491 } 1492 newLine(file); 1493 newLine(file, Setup.getMiaComment(), isManifest); 1494 if (Setup.isPrintHeadersEnabled()) { 1495 printHorizontalLine1(file, isManifest); 1496 newLine(file, SPACE + getHeader(Setup.getMissingCarMessageFormat(), false, false, false), isManifest); 1497 printHorizontalLine2(file, isManifest); 1498 } 1499 for (Car car : cars) { 1500 addSearchForCar(file, car, isManifest); 1501 } 1502 } 1503 1504 private void addSearchForCar(PrintWriter file, Car car, boolean isManifest) { 1505 StringBuffer buf = new StringBuffer(); 1506 String[] format = Setup.getMissingCarMessageFormat(); 1507 for (String attribute : format) { 1508 buf.append(getCarAttribute(car, attribute, false, false)); 1509 } 1510 newLine(file, buf.toString(), isManifest); 1511 } 1512 1513 /* 1514 * Gets an engine's attribute String. Returns empty if there isn't an 1515 * attribute and not using the tabular feature. isPickup true when engine is 1516 * being picked up. 1517 */ 1518 private String getEngineAttribute(Engine engine, String attribute, boolean isPickup) { 1519 if (!attribute.equals(Setup.BLANK)) { 1520 String s = SPACE + getEngineAttrib(engine, attribute, isPickup); 1521 if (Setup.isTabEnabled() || !s.isBlank()) { 1522 return s; 1523 } 1524 } 1525 return ""; 1526 } 1527 1528 /* 1529 * Can not use String case statement since Setup.MODEL, etc, are not fixed 1530 * strings. 1531 */ 1532 private String getEngineAttrib(Engine engine, String attribute, boolean isPickup) { 1533 if (attribute.equals(Setup.MODEL)) { 1534 return padAndTruncateIfNeeded(splitStringLeftParenthesis(engine.getModel()), 1535 InstanceManager.getDefault(EngineModels.class).getMaxNameLength()); 1536 } else if (attribute.equals(Setup.HP)) { 1537 return padAndTruncateIfNeeded(engine.getHp(), 5) + 1538 (Setup.isPrintHeadersEnabled() ? "" : TrainManifestHeaderText.getStringHeader_Hp()); 1539 } else if (attribute.equals(Setup.CONSIST)) { 1540 return padAndTruncateIfNeeded(engine.getConsistName(), 1541 InstanceManager.getDefault(ConsistManager.class).getMaxNameLength()); 1542 } else if (attribute.equals(Setup.DCC_ADDRESS)) { 1543 return padAndTruncateIfNeeded(engine.getDccAddress(), 1544 TrainManifestHeaderText.getStringHeader_DCC_Address().length()); 1545 } else if (attribute.equals(Setup.COMMENT)) { 1546 return padAndTruncateIfNeeded(engine.getComment(), engineManager.getMaxCommentLength()); 1547 } 1548 return getRollingStockAttribute(engine, attribute, isPickup, false); 1549 } 1550 1551 /* 1552 * Gets a car's attribute String. Returns empty if there isn't an attribute 1553 * and not using the tabular feature. isPickup true when car is being picked 1554 * up. isLocal true when car is performing a local move. 1555 */ 1556 private String getCarAttribute(Car car, String attribute, boolean isPickup, boolean isLocal) { 1557 if (!attribute.equals(Setup.BLANK)) { 1558 String s = SPACE + getCarAttrib(car, attribute, isPickup, isLocal); 1559 if (Setup.isTabEnabled() || !s.isBlank()) { 1560 return s; 1561 } 1562 } 1563 return ""; 1564 } 1565 1566 private String getCarAttrib(Car car, String attribute, boolean isPickup, boolean isLocal) { 1567 if (attribute.equals(Setup.LOAD)) { 1568 return ((car.isCaboose() && !Setup.isPrintCabooseLoadEnabled()) || 1569 (car.isPassenger() && !Setup.isPrintPassengerLoadEnabled())) 1570 ? padAndTruncateIfNeeded("", 1571 InstanceManager.getDefault(CarLoads.class).getMaxNameLength()) 1572 : padAndTruncateIfNeeded(car.getLoadName().split(HYPHEN)[0], 1573 InstanceManager.getDefault(CarLoads.class).getMaxNameLength()); 1574 } else if (attribute.equals(Setup.LOAD_TYPE)) { 1575 return padAndTruncateIfNeeded(car.getLoadType(), 1576 TrainManifestHeaderText.getStringHeader_Load_Type().length()); 1577 } else if (attribute.equals(Setup.HAZARDOUS)) { 1578 return (car.isHazardous() ? Setup.getHazardousMsg() 1579 : padAndTruncateIfNeeded("", Setup.getHazardousMsg().length())); 1580 } else if (attribute.equals(Setup.DROP_COMMENT)) { 1581 return padAndTruncateIfNeeded(car.getDropComment(), 1582 InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()); 1583 } else if (attribute.equals(Setup.PICKUP_COMMENT)) { 1584 return padAndTruncateIfNeeded(car.getPickupComment(), 1585 InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()); 1586 } else if (attribute.equals(Setup.KERNEL)) { 1587 return padAndTruncateIfNeeded(car.getKernelName(), 1588 InstanceManager.getDefault(KernelManager.class).getMaxNameLength()); 1589 } else if (attribute.equals(Setup.KERNEL_SIZE)) { 1590 if (car.isLead()) { 1591 return padAndTruncateIfNeeded(Integer.toString(car.getKernel().getSize()), 2); 1592 } 1593 return SPACE + SPACE; // assumes that kernel size is 99 or less 1594 } else if (attribute.equals(Setup.RWE)) { 1595 if (!car.getReturnWhenEmptyDestinationName().equals(Car.NONE)) { 1596 // format RWE destination and track name 1597 String rweAndTrackName = car.getSplitReturnWhenEmptyDestinationName(); 1598 if (!car.getReturnWhenEmptyDestTrackName().equals(Car.NONE)) { 1599 rweAndTrackName = rweAndTrackName + "," + SPACE + car.getSplitReturnWhenEmptyDestinationTrackName(); 1600 } 1601 return Setup.isPrintHeadersEnabled() 1602 ? padAndTruncateIfNeeded(rweAndTrackName, locationManager.getMaxLocationAndTrackNameLength()) 1603 : padAndTruncateIfNeeded( 1604 TrainManifestHeaderText.getStringHeader_RWE() + SPACE + rweAndTrackName, 1605 locationManager.getMaxLocationAndTrackNameLength() + 1606 TrainManifestHeaderText.getStringHeader_RWE().length() + 1607 3); 1608 } 1609 return padAndTruncateIfNeeded("", locationManager.getMaxLocationAndTrackNameLength()); 1610 } else if (attribute.equals(Setup.FINAL_DEST)) { 1611 return Setup.isPrintHeadersEnabled() 1612 ? padAndTruncateIfNeeded(car.getSplitFinalDestinationName(), 1613 locationManager.getMaxLocationNameLength()) 1614 : padAndTruncateIfNeeded( 1615 TrainManifestText.getStringFinalDestination() + 1616 SPACE + 1617 car.getSplitFinalDestinationName(), 1618 locationManager.getMaxLocationNameLength() + 1619 TrainManifestText.getStringFinalDestination().length() + 1620 1); 1621 } else if (attribute.equals(Setup.FINAL_DEST_TRACK)) { 1622 // format final destination and track name 1623 String FDAndTrackName = car.getSplitFinalDestinationName(); 1624 if (!car.getFinalDestinationTrackName().equals(Car.NONE)) { 1625 FDAndTrackName = FDAndTrackName + "," + SPACE + car.getSplitFinalDestinationTrackName(); 1626 } 1627 return Setup.isPrintHeadersEnabled() 1628 ? padAndTruncateIfNeeded(FDAndTrackName, locationManager.getMaxLocationAndTrackNameLength() + 2) 1629 : padAndTruncateIfNeeded(TrainManifestText.getStringFinalDestination() + SPACE + FDAndTrackName, 1630 locationManager.getMaxLocationAndTrackNameLength() + 1631 TrainManifestText.getStringFinalDestination().length() + 1632 3); 1633 } else if (attribute.equals(Setup.DIVISION)) { 1634 return padAndTruncateIfNeeded(car.getDivisionName(), 1635 InstanceManager.getDefault(DivisionManager.class).getMaxDivisionNameLength()); 1636 } else if (attribute.equals(Setup.BLOCKING_ORDER)) { 1637 if (car.isPassenger()) { 1638 return padAndTruncateIfNeeded(Integer.toString(car.getBlocking()), 3); 1639 } 1640 return SPACE + SPACE + SPACE; // assumes that blocking order is +/- 99 1641 } else if (attribute.equals(Setup.COMMENT)) { 1642 return padAndTruncateIfNeeded(car.getComment(), carManager.getMaxCommentLength()); 1643 } 1644 return getRollingStockAttribute(car, attribute, isPickup, isLocal); 1645 } 1646 1647 private String getRollingStockAttribute(RollingStock rs, String attribute, boolean isPickup, boolean isLocal) { 1648 try { 1649 if (attribute.equals(Setup.NUMBER)) { 1650 return padAndTruncateIfNeeded(splitString(rs.getNumber()), Control.max_len_string_print_road_number); 1651 } else if (attribute.equals(Setup.ROAD)) { 1652 String road = rs.getRoadName().split(HYPHEN)[0]; 1653 return padAndTruncateIfNeeded(road, InstanceManager.getDefault(CarRoads.class).getMaxNameLength()); 1654 } else if (attribute.equals(Setup.TYPE)) { 1655 String type = rs.getTypeName().split(HYPHEN)[0]; 1656 return padAndTruncateIfNeeded(type, InstanceManager.getDefault(CarTypes.class).getMaxNameLength()); 1657 } else if (attribute.equals(Setup.LENGTH)) { 1658 return padAndTruncateIfNeeded(rs.getLength() + Setup.getLengthUnitAbv(), 1659 InstanceManager.getDefault(CarLengths.class).getMaxNameLength()); 1660 } else if (attribute.equals(Setup.WEIGHT)) { 1661 return padAndTruncateIfNeeded(Integer.toString(rs.getAdjustedWeightTons()), 1662 Control.max_len_string_weight_name) + 1663 (Setup.isPrintHeadersEnabled() ? "" : TrainManifestHeaderText.getStringHeader_Weight()); 1664 } else if (attribute.equals(Setup.COLOR)) { 1665 return padAndTruncateIfNeeded(rs.getColor(), 1666 InstanceManager.getDefault(CarColors.class).getMaxNameLength()); 1667 } else if (((attribute.equals(Setup.LOCATION)) && (isPickup || isLocal)) || 1668 (attribute.equals(Setup.TRACK) && isPickup)) { 1669 return Setup.isPrintHeadersEnabled() 1670 ? padAndTruncateIfNeeded(rs.getSplitTrackName(), 1671 locationManager.getMaxTrackNameLength()) 1672 : padAndTruncateIfNeeded( 1673 TrainManifestText.getStringFrom() + SPACE + rs.getSplitTrackName(), 1674 TrainManifestText.getStringFrom().length() + 1675 locationManager.getMaxTrackNameLength() + 1676 1); 1677 } else if (attribute.equals(Setup.LOCATION) && !isPickup && !isLocal) { 1678 return Setup.isPrintHeadersEnabled() 1679 ? padAndTruncateIfNeeded(rs.getSplitLocationName(), 1680 locationManager.getMaxLocationNameLength()) 1681 : padAndTruncateIfNeeded( 1682 TrainManifestText.getStringFrom() + SPACE + rs.getSplitLocationName(), 1683 locationManager.getMaxLocationNameLength() + 1684 TrainManifestText.getStringFrom().length() + 1685 1); 1686 } else if (attribute.equals(Setup.DESTINATION) && isPickup) { 1687 if (Setup.isPrintHeadersEnabled()) { 1688 return padAndTruncateIfNeeded(rs.getSplitDestinationName(), 1689 locationManager.getMaxLocationNameLength()); 1690 } 1691 if (Setup.isTabEnabled()) { 1692 return padAndTruncateIfNeeded( 1693 TrainManifestText.getStringDest() + SPACE + rs.getSplitDestinationName(), 1694 TrainManifestText.getStringDest().length() + 1695 locationManager.getMaxLocationNameLength() + 1696 1); 1697 } else { 1698 return TrainManifestText.getStringDestination() + 1699 SPACE + 1700 rs.getSplitDestinationName(); 1701 } 1702 } else if ((attribute.equals(Setup.DESTINATION) || attribute.equals(Setup.TRACK)) && !isPickup) { 1703 return Setup.isPrintHeadersEnabled() 1704 ? padAndTruncateIfNeeded(rs.getSplitDestinationTrackName(), 1705 locationManager.getMaxTrackNameLength()) 1706 : padAndTruncateIfNeeded( 1707 TrainManifestText.getStringTo() + 1708 SPACE + 1709 rs.getSplitDestinationTrackName(), 1710 locationManager.getMaxTrackNameLength() + 1711 TrainManifestText.getStringTo().length() + 1712 1); 1713 } else if (attribute.equals(Setup.DEST_TRACK)) { 1714 // format destination name and destination track name 1715 String destAndTrackName = 1716 rs.getSplitDestinationName() + "," + SPACE + rs.getSplitDestinationTrackName(); 1717 return Setup.isPrintHeadersEnabled() 1718 ? padAndTruncateIfNeeded(destAndTrackName, 1719 locationManager.getMaxLocationAndTrackNameLength() + 2) 1720 : padAndTruncateIfNeeded(TrainManifestText.getStringDest() + SPACE + destAndTrackName, 1721 locationManager.getMaxLocationAndTrackNameLength() + 1722 TrainManifestText.getStringDest().length() + 1723 3); 1724 } else if (attribute.equals(Setup.OWNER)) { 1725 return padAndTruncateIfNeeded(rs.getOwnerName(), 1726 InstanceManager.getDefault(CarOwners.class).getMaxNameLength()); 1727 } else if (attribute.equals(Setup.LAST_TRAIN)) { 1728 String lastTrainName = padAndTruncateIfNeeded(rs.getLastTrainName(), 1729 InstanceManager.getDefault(TrainManager.class).getMaxTrainNameLength()); 1730 return Setup.isPrintHeadersEnabled() ? lastTrainName 1731 : TrainManifestHeaderText.getStringHeader_Last_Train() + SPACE + lastTrainName; 1732 } 1733 // the three utility attributes that don't get printed but need to 1734 // be tabbed out 1735 else if (attribute.equals(Setup.NO_NUMBER)) { 1736 return padAndTruncateIfNeeded("", 1737 Control.max_len_string_print_road_number - (UTILITY_CAR_COUNT_FIELD_SIZE + 1)); 1738 } else if (attribute.equals(Setup.NO_ROAD)) { 1739 return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarRoads.class).getMaxNameLength()); 1740 } else if (attribute.equals(Setup.NO_COLOR)) { 1741 return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarColors.class).getMaxNameLength()); 1742 } // there are four truncated manifest attributes 1743 else if (attribute.equals(Setup.NO_DEST_TRACK)) { 1744 return Setup.isPrintHeadersEnabled() 1745 ? padAndTruncateIfNeeded("", locationManager.getMaxLocationAndTrackNameLength() + 1) 1746 : ""; 1747 } else if ((attribute.equals(Setup.NO_LOCATION) && !isPickup) || 1748 (attribute.equals(Setup.NO_DESTINATION) && isPickup)) { 1749 return Setup.isPrintHeadersEnabled() 1750 ? padAndTruncateIfNeeded("", locationManager.getMaxLocationNameLength()) 1751 : ""; 1752 } else if (attribute.equals(Setup.NO_TRACK) || 1753 attribute.equals(Setup.NO_LOCATION) || 1754 attribute.equals(Setup.NO_DESTINATION)) { 1755 return Setup.isPrintHeadersEnabled() 1756 ? padAndTruncateIfNeeded("", locationManager.getMaxTrackNameLength()) 1757 : ""; 1758 } else if (attribute.equals(Setup.TAB)) { 1759 return createTabIfNeeded(Setup.getTab1Length() - 1); 1760 } else if (attribute.equals(Setup.TAB2)) { 1761 return createTabIfNeeded(Setup.getTab2Length() - 1); 1762 } else if (attribute.equals(Setup.TAB3)) { 1763 return createTabIfNeeded(Setup.getTab3Length() - 1); 1764 } 1765 // something isn't right! 1766 return Bundle.getMessage("ErrorPrintOptions", attribute); 1767 1768 } catch (ArrayIndexOutOfBoundsException e) { 1769 if (attribute.equals(Setup.ROAD)) { 1770 return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarRoads.class).getMaxNameLength()); 1771 } else if (attribute.equals(Setup.TYPE)) { 1772 return padAndTruncateIfNeeded("", InstanceManager.getDefault(CarTypes.class).getMaxNameLength()); 1773 } 1774 // something isn't right! 1775 return Bundle.getMessage("ErrorPrintOptions", attribute); 1776 } 1777 } 1778 1779 /** 1780 * Two column header format. Left side pick ups, right side set outs 1781 * 1782 * @param file Manifest or switch list File. 1783 * @param isManifest True if manifest, false if switch list. 1784 */ 1785 public void printEngineHeader(PrintWriter file, boolean isManifest) { 1786 int lineLength = getLineLength(isManifest); 1787 printHorizontalLine(file, isManifest); 1788 if (Setup.isPrintHeadersEnabled()) { 1789 if (!Setup.getPickupEnginePrefix().isBlank() || !Setup.getDropEnginePrefix().isBlank()) { 1790 // center engine pick up and set out text 1791 String s = padAndTruncate(tabString(Setup.getPickupEnginePrefix().trim(), 1792 lineLength / 4 - Setup.getPickupEnginePrefix().length() / 2), lineLength / 2) + 1793 VERTICAL_LINE_CHAR + 1794 tabString(Setup.getDropEnginePrefix(), 1795 lineLength / 4 - Setup.getDropEnginePrefix().length() / 2); 1796 s = padAndTruncate(s, lineLength); 1797 addLine(file, s); 1798 printHorizontalLine1(file, isManifest); 1799 } 1800 1801 String s = padAndTruncate(getPickupEngineHeader(), lineLength / 2); 1802 s = padAndTruncate(s + VERTICAL_LINE_CHAR + getDropEngineHeader(), lineLength); 1803 addLine(file, s); 1804 printHorizontalLine2(file, isManifest); 1805 } 1806 } 1807 1808 public void printPickupEngineHeader(PrintWriter file, boolean isManifest) { 1809 int lineLength = getLineLength(isManifest); 1810 printHorizontalLine1(file, isManifest); 1811 String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getPickupEngineHeader(), 1812 lineLength); 1813 addLine(file, s); 1814 printHorizontalLine2(file, isManifest); 1815 } 1816 1817 public void printDropEngineHeader(PrintWriter file, boolean isManifest) { 1818 int lineLength = getLineLength(isManifest); 1819 printHorizontalLine1(file, isManifest); 1820 String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getDropEngineHeader(), 1821 lineLength); 1822 addLine(file, s); 1823 printHorizontalLine2(file, isManifest); 1824 } 1825 1826 /** 1827 * Prints the two column header for cars. Left side pick ups, right side set 1828 * outs. 1829 * 1830 * @param file Manifest or Switch List File 1831 * @param isManifest True if manifest, false if switch list. 1832 * @param isTwoColumnTrack True if two column format using track names. 1833 */ 1834 public void printCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) { 1835 int lineLength = getLineLength(isManifest); 1836 printHorizontalLine(file, isManifest); 1837 if (Setup.isPrintHeadersEnabled()) { 1838 // center pick up and set out text 1839 String s = padAndTruncate( 1840 tabString(Setup.getPickupCarPrefix(), lineLength / 4 - Setup.getPickupCarPrefix().length() / 2), 1841 lineLength / 2) + 1842 VERTICAL_LINE_CHAR + 1843 tabString(Setup.getDropCarPrefix(), lineLength / 4 - Setup.getDropCarPrefix().length() / 2); 1844 s = padAndTruncate(s, lineLength); 1845 addLine(file, s); 1846 printHorizontalLine1(file, isManifest); 1847 1848 s = padAndTruncate(getPickupCarHeader(isManifest, isTwoColumnTrack), lineLength / 2); 1849 s = padAndTruncate(s + VERTICAL_LINE_CHAR + getDropCarHeader(isManifest, isTwoColumnTrack), lineLength); 1850 addLine(file, s); 1851 printHorizontalLine2(file, isManifest); 1852 } 1853 } 1854 1855 public void printPickupCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) { 1856 if (Setup.isPrintHeadersEnabled()) { 1857 printHorizontalLine1(file, isManifest); 1858 String s = padAndTruncate(createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + 1859 getPickupCarHeader(isManifest, isTwoColumnTrack), getLineLength(isManifest)); 1860 addLine(file, s); 1861 printHorizontalLine2(file, isManifest); 1862 } 1863 } 1864 1865 public void printDropCarHeader(PrintWriter file, boolean isManifest, boolean isTwoColumnTrack) { 1866 if (!Setup.isPrintHeadersEnabled() || getDropCarHeader(isManifest, isTwoColumnTrack).isBlank()) { 1867 return; 1868 } 1869 printHorizontalLine1(file, isManifest); 1870 String s = padAndTruncate( 1871 createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getDropCarHeader(isManifest, isTwoColumnTrack), 1872 getLineLength(isManifest)); 1873 addLine(file, s); 1874 printHorizontalLine2(file, isManifest); 1875 } 1876 1877 public void printLocalCarMoveHeader(PrintWriter file, boolean isManifest) { 1878 if (!Setup.isPrintHeadersEnabled()) { 1879 return; 1880 } 1881 printHorizontalLine1(file, isManifest); 1882 String s = padAndTruncate( 1883 createTabIfNeeded(Setup.getManifestPrefixLength() + 1) + getLocalMoveHeader(isManifest), 1884 getLineLength(isManifest)); 1885 addLine(file, s); 1886 printHorizontalLine2(file, isManifest); 1887 } 1888 1889 public String getPickupEngineHeader() { 1890 return getHeader(Setup.getPickupEngineMessageFormat(), PICKUP, !LOCAL, ENGINE); 1891 } 1892 1893 public String getDropEngineHeader() { 1894 return getHeader(Setup.getDropEngineMessageFormat(), !PICKUP, !LOCAL, ENGINE); 1895 } 1896 1897 public String getPickupCarHeader(boolean isManifest, boolean isTwoColumnTrack) { 1898 if (isManifest && !isTwoColumnTrack) { 1899 return getHeader(Setup.getPickupManifestMessageFormat(), PICKUP, !LOCAL, !ENGINE); 1900 } else if (!isManifest && !isTwoColumnTrack) { 1901 return getHeader(Setup.getPickupSwitchListMessageFormat(), PICKUP, !LOCAL, !ENGINE); 1902 } else if (isManifest && isTwoColumnTrack) { 1903 return getHeader(Setup.getPickupTwoColumnByTrackManifestMessageFormat(), PICKUP, !LOCAL, !ENGINE); 1904 } else { 1905 return getHeader(Setup.getPickupTwoColumnByTrackSwitchListMessageFormat(), PICKUP, !LOCAL, !ENGINE); 1906 } 1907 } 1908 1909 public String getDropCarHeader(boolean isManifest, boolean isTwoColumnTrack) { 1910 if (isManifest && !isTwoColumnTrack) { 1911 return getHeader(Setup.getDropManifestMessageFormat(), !PICKUP, !LOCAL, !ENGINE); 1912 } else if (!isManifest && !isTwoColumnTrack) { 1913 return getHeader(Setup.getDropSwitchListMessageFormat(), !PICKUP, !LOCAL, !ENGINE); 1914 } else if (isManifest && isTwoColumnTrack) { 1915 return getHeader(Setup.getDropTwoColumnByTrackManifestMessageFormat(), !PICKUP, !LOCAL, !ENGINE); 1916 } else { 1917 return getHeader(Setup.getDropTwoColumnByTrackSwitchListMessageFormat(), !PICKUP, !LOCAL, !ENGINE); 1918 } 1919 } 1920 1921 public String getLocalMoveHeader(boolean isManifest) { 1922 if (isManifest) { 1923 return getHeader(Setup.getLocalManifestMessageFormat(), !PICKUP, LOCAL, !ENGINE); 1924 } else { 1925 return getHeader(Setup.getLocalSwitchListMessageFormat(), !PICKUP, LOCAL, !ENGINE); 1926 } 1927 } 1928 1929 private String getHeader(String[] format, boolean isPickup, boolean isLocal, boolean isEngine) { 1930 StringBuffer buf = new StringBuffer(); 1931 for (String attribute : format) { 1932 if (attribute.equals(Setup.BLANK)) { 1933 continue; 1934 } 1935 if (attribute.equals(Setup.ROAD)) { 1936 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Road(), 1937 InstanceManager.getDefault(CarRoads.class).getMaxNameLength()) + SPACE); 1938 } else if (attribute.equals(Setup.NUMBER) && !isEngine) { 1939 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Number(), 1940 Control.max_len_string_print_road_number) + SPACE); 1941 } else if (attribute.equals(Setup.NUMBER) && isEngine) { 1942 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_EngineNumber(), 1943 Control.max_len_string_print_road_number) + SPACE); 1944 } else if (attribute.equals(Setup.TYPE)) { 1945 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Type(), 1946 InstanceManager.getDefault(CarTypes.class).getMaxNameLength()) + SPACE); 1947 } else if (attribute.equals(Setup.MODEL)) { 1948 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Model(), 1949 InstanceManager.getDefault(EngineModels.class).getMaxNameLength()) + SPACE); 1950 } else if (attribute.equals(Setup.HP)) { 1951 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Hp(), 1952 5) + SPACE); 1953 } else if (attribute.equals(Setup.CONSIST)) { 1954 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Consist(), 1955 InstanceManager.getDefault(ConsistManager.class).getMaxNameLength()) + SPACE); 1956 } else if (attribute.equals(Setup.DCC_ADDRESS)) { 1957 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_DCC_Address(), 1958 TrainManifestHeaderText.getStringHeader_DCC_Address().length()) + SPACE); 1959 } else if (attribute.equals(Setup.KERNEL)) { 1960 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Kernel(), 1961 InstanceManager.getDefault(KernelManager.class).getMaxNameLength()) + SPACE); 1962 } else if (attribute.equals(Setup.KERNEL_SIZE)) { 1963 buf.append(" "); // assume kernel size is 99 or less 1964 } else if (attribute.equals(Setup.LOAD)) { 1965 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Load(), 1966 InstanceManager.getDefault(CarLoads.class).getMaxNameLength()) + SPACE); 1967 } else if (attribute.equals(Setup.LOAD_TYPE)) { 1968 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Load_Type(), 1969 TrainManifestHeaderText.getStringHeader_Load_Type().length()) + SPACE); 1970 } else if (attribute.equals(Setup.COLOR)) { 1971 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Color(), 1972 InstanceManager.getDefault(CarColors.class).getMaxNameLength()) + SPACE); 1973 } else if (attribute.equals(Setup.OWNER)) { 1974 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Owner(), 1975 InstanceManager.getDefault(CarOwners.class).getMaxNameLength()) + SPACE); 1976 } else if (attribute.equals(Setup.LENGTH)) { 1977 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Length(), 1978 InstanceManager.getDefault(CarLengths.class).getMaxNameLength()) + SPACE); 1979 } else if (attribute.equals(Setup.WEIGHT)) { 1980 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Weight(), 1981 Control.max_len_string_weight_name) + SPACE); 1982 } else if (attribute.equals(Setup.TRACK)) { 1983 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Track(), 1984 locationManager.getMaxTrackNameLength()) + SPACE); 1985 } else if (attribute.equals(Setup.LOCATION) && (isPickup || isLocal)) { 1986 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Location(), 1987 locationManager.getMaxTrackNameLength()) + SPACE); 1988 } else if (attribute.equals(Setup.LOCATION) && !isPickup) { 1989 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Location(), 1990 locationManager.getMaxLocationNameLength()) + SPACE); 1991 } else if (attribute.equals(Setup.DESTINATION) && !isPickup) { 1992 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Destination(), 1993 locationManager.getMaxTrackNameLength()) + SPACE); 1994 } else if (attribute.equals(Setup.DESTINATION) && isPickup) { 1995 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Destination(), 1996 locationManager.getMaxLocationNameLength()) + SPACE); 1997 } else if (attribute.equals(Setup.DEST_TRACK)) { 1998 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Dest_Track(), 1999 locationManager.getMaxLocationAndTrackNameLength() + 2) + SPACE); 2000 } else if (attribute.equals(Setup.FINAL_DEST)) { 2001 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Final_Dest(), 2002 locationManager.getMaxLocationNameLength()) + SPACE); 2003 } else if (attribute.equals(Setup.FINAL_DEST_TRACK)) { 2004 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Final_Dest_Track(), 2005 locationManager.getMaxLocationAndTrackNameLength() + 2) + SPACE); 2006 } else if (attribute.equals(Setup.HAZARDOUS)) { 2007 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Hazardous(), 2008 Setup.getHazardousMsg().length()) + SPACE); 2009 } else if (attribute.equals(Setup.RWE)) { 2010 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_RWE(), 2011 locationManager.getMaxLocationAndTrackNameLength()) + SPACE); 2012 } else if (attribute.equals(Setup.COMMENT)) { 2013 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Comment(), 2014 isEngine ? engineManager.getMaxCommentLength() : carManager.getMaxCommentLength()) + SPACE); 2015 } else if (attribute.equals(Setup.DROP_COMMENT)) { 2016 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Drop_Comment(), 2017 InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()) + SPACE); 2018 } else if (attribute.equals(Setup.PICKUP_COMMENT)) { 2019 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Pickup_Comment(), 2020 InstanceManager.getDefault(CarLoads.class).getMaxLoadCommentLength()) + SPACE); 2021 } else if (attribute.equals(Setup.DIVISION)) { 2022 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Division(), 2023 InstanceManager.getDefault(DivisionManager.class).getMaxDivisionNameLength()) + SPACE); 2024 } else if (attribute.equals(Setup.BLOCKING_ORDER)) { 2025 buf.append(" "); // assume blocking order +/- 99 2026 } else if (attribute.equals(Setup.LAST_TRAIN)) { 2027 buf.append(padAndTruncateIfNeeded(TrainManifestHeaderText.getStringHeader_Last_Train(), 2028 InstanceManager.getDefault(TrainManager.class).getMaxTrainNameLength()) + SPACE); 2029 } else if (attribute.equals(Setup.TAB)) { 2030 buf.append(createTabIfNeeded(Setup.getTab1Length())); 2031 } else if (attribute.equals(Setup.TAB2)) { 2032 buf.append(createTabIfNeeded(Setup.getTab2Length())); 2033 } else if (attribute.equals(Setup.TAB3)) { 2034 buf.append(createTabIfNeeded(Setup.getTab3Length())); 2035 } else { 2036 buf.append(attribute + SPACE); 2037 } 2038 } 2039 return buf.toString().stripTrailing(); 2040 } 2041 2042 protected void printTrackNameHeader(PrintWriter file, String trackName, boolean isManifest) { 2043 printHorizontalLine(file, isManifest); 2044 int lineLength = getLineLength(isManifest); 2045 String s = padAndTruncate(tabString(trackName.trim(), lineLength / 4 - trackName.trim().length() / 2), 2046 lineLength / 2) + 2047 VERTICAL_LINE_CHAR + 2048 tabString(trackName.trim(), lineLength / 4 - trackName.trim().length() / 2); 2049 s = padAndTruncate(s, lineLength); 2050 addLine(file, s); 2051 if (Setup.isPrintHeaderLine3Enabled()) { 2052 printHorizontalLine(file, isManifest); 2053 } 2054 } 2055 2056 public void printHorizontalLine1(PrintWriter file, boolean isManifest) { 2057 if (Setup.isPrintHeaderLine1Enabled()) { 2058 printHorizontalLine(file, isManifest); 2059 } 2060 } 2061 2062 public void printHorizontalLine2(PrintWriter file, boolean isManifest) { 2063 if (Setup.isPrintHeaderLine2Enabled()) { 2064 printHorizontalLine(file, isManifest); 2065 } 2066 } 2067 2068 public void printHorizontalLine3(PrintWriter file, boolean isManifest) { 2069 if (Setup.isPrintHeadersEnabled() && Setup.isPrintHeaderLine3Enabled() || 2070 !Setup.getManifestFormat().equals(Setup.STANDARD_FORMAT)) { 2071 printHorizontalLine(file, isManifest); 2072 } 2073 } 2074 2075 /** 2076 * Prints a line across the entire page. 2077 * 2078 * @param file The File to print to. 2079 * @param isManifest True if manifest, false if switch list. 2080 */ 2081 public void printHorizontalLine(PrintWriter file, boolean isManifest) { 2082 printHorizontalLine(file, 0, getLineLength(isManifest)); 2083 } 2084 2085 public void printHorizontalLine(PrintWriter file, int start, int end) { 2086 StringBuffer sb = new StringBuffer(); 2087 while (start-- > 0) { 2088 sb.append(SPACE); 2089 } 2090 while (end-- > 0) { 2091 sb.append(HORIZONTAL_LINE_CHAR); 2092 } 2093 addLine(file, sb.toString()); 2094 } 2095 2096 public static String getISO8601Date(boolean isModelYear) { 2097 Calendar calendar = Calendar.getInstance(); 2098 // use the JMRI Timebase (which may be a fast clock). 2099 calendar.setTime(jmri.InstanceManager.getDefault(jmri.Timebase.class).getTime()); 2100 if (isModelYear && !Setup.getYearModeled().isEmpty()) { 2101 try { 2102 calendar.set(Calendar.YEAR, Integer.parseInt(Setup.getYearModeled().trim())); 2103 } catch (NumberFormatException e) { 2104 return Setup.getYearModeled(); 2105 } 2106 } 2107 return (new StdDateFormat()).format(calendar.getTime()); 2108 } 2109 2110 public static String getDate(Date date) { 2111 SimpleDateFormat format = new SimpleDateFormat("M/dd/yyyy HH:mm"); // NOI18N 2112 if (Setup.is12hrFormatEnabled()) { 2113 format = new SimpleDateFormat("M/dd/yyyy hh:mm a"); // NOI18N 2114 } 2115 return format.format(date); 2116 } 2117 2118 public static String getDate(boolean isModelYear) { 2119 Calendar calendar = Calendar.getInstance(); 2120 // use the JMRI Timebase (which may be a fast clock). 2121 calendar.setTime(jmri.InstanceManager.getDefault(jmri.Timebase.class).getTime()); 2122 if (isModelYear && !Setup.getYearModeled().equals(Setup.NONE)) { 2123 try { 2124 calendar.set(Calendar.YEAR, Integer.parseInt(Setup.getYearModeled().trim())); 2125 } catch (NumberFormatException e) { 2126 return Setup.getYearModeled(); 2127 } 2128 } 2129 return TrainCommon.getDate(calendar.getTime()); 2130 } 2131 2132 public static Date convertStringToDate(String date) { 2133 if (!date.isBlank()) { 2134 // create a date object from the string. 2135 try { 2136 // try MM/dd/yyyy HH:mm:ss. 2137 SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy HH:mm:ss"); // NOI18N 2138 return formatter.parse(date); 2139 } catch (java.text.ParseException pe1) { 2140 // try the old 12 hour format (no seconds). 2141 try { 2142 SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy hh:mmaa"); // NOI18N 2143 return formatter.parse(date); 2144 } catch (java.text.ParseException pe2) { 2145 try { 2146 // try 24hour clock. 2147 SimpleDateFormat formatter = new SimpleDateFormat("MM/dd/yyyy HH:mm"); // NOI18N 2148 return formatter.parse(date); 2149 } catch (java.text.ParseException pe3) { 2150 log.debug("Not able to parse date: {}", date); 2151 } 2152 } 2153 } 2154 } 2155 return null; // there was no date specified. 2156 } 2157 2158 /* 2159 * Converts String time DAYS:HH:MM and DAYS:HH:MM AM/PM to minutes from 2160 * midnight. Note that the string time could be blank, and in that case 2161 * returns 0 minutes. 2162 */ 2163 protected int convertStringTime(String time) { 2164 int minutes = 0; 2165 boolean hrFormat = false; 2166 String[] splitTimePM = time.split(SPACE); 2167 if (splitTimePM.length > 1) { 2168 hrFormat = true; 2169 if (splitTimePM[1].equals(Bundle.getMessage("PM"))) { 2170 minutes = 12 * 60; 2171 } 2172 } 2173 String[] splitTime = splitTimePM[0].split(":"); 2174 2175 if (splitTime.length > 2) { 2176 // days:hrs:minutes 2177 if (hrFormat && splitTime[1].equals("12")) { 2178 splitTime[1] = "00"; 2179 } 2180 minutes += 24 * 60 * Integer.parseInt(splitTime[0]); 2181 minutes += 60 * Integer.parseInt(splitTime[1]); 2182 minutes += Integer.parseInt(splitTime[2]); 2183 } else if (splitTime.length == 2){ 2184 // hrs:minutes 2185 if (hrFormat && splitTime[0].equals("12")) { 2186 splitTime[0] = "00"; 2187 } 2188 minutes += 60 * Integer.parseInt(splitTime[0]); 2189 minutes += Integer.parseInt(splitTime[1]); 2190 } 2191 log.debug("convert time {} to minutes {}", time, minutes); 2192 return minutes; 2193 } 2194 2195 /** 2196 * Pads out a string by adding spaces to the end of the string, and will 2197 * remove characters from the end of the string if the string exceeds the 2198 * field size. 2199 * 2200 * @param s The string to pad. 2201 * @param fieldSize The maximum length of the string. 2202 * @return A String the specified length 2203 */ 2204 public static String padAndTruncateIfNeeded(String s, int fieldSize) { 2205 if (Setup.isTabEnabled()) { 2206 return padAndTruncate(s, fieldSize); 2207 } 2208 return s; 2209 } 2210 2211 public static String padAndTruncate(String s, int fieldSize) { 2212 s = padString(s, fieldSize); 2213 if (s.length() > fieldSize) { 2214 s = s.substring(0, fieldSize); 2215 } 2216 return s; 2217 } 2218 2219 /** 2220 * Adjusts string to be a certain number of characters by adding spaces to 2221 * the end of the string. 2222 * 2223 * @param s The string to pad 2224 * @param fieldSize The fixed length of the string. 2225 * @return A String the specified length 2226 */ 2227 public static String padString(String s, int fieldSize) { 2228 StringBuffer buf = new StringBuffer(s); 2229 while (buf.length() < fieldSize) { 2230 buf.append(SPACE); 2231 } 2232 return buf.toString(); 2233 } 2234 2235 /** 2236 * Creates a String of spaces to create a tab for text. Tabs must be 2237 * enabled. Setup.isTabEnabled() 2238 * 2239 * @param tabSize the length of tab 2240 * @return tab 2241 */ 2242 public static String createTabIfNeeded(int tabSize) { 2243 if (Setup.isTabEnabled()) { 2244 return tabString("", tabSize); 2245 } 2246 return ""; 2247 } 2248 2249 protected static String tabString(String s, int tabSize) { 2250 StringBuffer buf = new StringBuffer(); 2251 // TODO this doesn't consider the length of s string. 2252 while (buf.length() < tabSize) { 2253 buf.append(SPACE); 2254 } 2255 buf.append(s); 2256 return buf.toString(); 2257 } 2258 2259 /** 2260 * Returns the line length for manifest or switch list printout. Always an 2261 * even number. 2262 * 2263 * @param isManifest True if manifest. 2264 * @return line length for manifest or switch list. 2265 */ 2266 public static int getLineLength(boolean isManifest) { 2267 return getLineLength(isManifest ? Setup.getManifestOrientation() : Setup.getSwitchListOrientation(), 2268 Setup.getFontName(), Font.PLAIN, Setup.getManifestFontSize()); 2269 } 2270 2271 public static int getManifestHeaderLineLength() { 2272 return getLineLength(Setup.getManifestOrientation(), "SansSerif", Font.ITALIC, Setup.getManifestFontSize()); 2273 } 2274 2275 private static int getLineLength(String orientation, String fontName, int fontStyle, int fontSize) { 2276 Font font = new Font(fontName, fontStyle, fontSize); // NOI18N 2277 JLabel label = new JLabel(); 2278 FontMetrics metrics = label.getFontMetrics(font); 2279 int charwidth = metrics.charWidth('m'); 2280 if (charwidth == 0) { 2281 log.error("Line length charater width equal to zero. font size: {}, fontName: {}", fontSize, fontName); 2282 charwidth = fontSize / 2; // create a reasonable character width 2283 } 2284 // compute lines and columns within margins 2285 int charLength = getPageSize(orientation).width / charwidth; 2286 if (charLength % 2 != 0) { 2287 charLength--; // make it even 2288 } 2289 return charLength; 2290 } 2291 2292 private boolean checkStringLength(String string, boolean isManifest) { 2293 return checkStringLength(string, isManifest ? Setup.getManifestOrientation() : Setup.getSwitchListOrientation(), 2294 Setup.getFontName(), Setup.getManifestFontSize()); 2295 } 2296 2297 /** 2298 * Checks to see if the string fits on the page. 2299 * 2300 * @return false if string length is longer than page width. 2301 */ 2302 private boolean checkStringLength(String string, String orientation, String fontName, int fontSize) { 2303 // ignore text color controls when determining line length 2304 if (string.startsWith(TEXT_COLOR_START) && string.contains(TEXT_COLOR_DONE)) { 2305 string = string.substring(string.indexOf(TEXT_COLOR_DONE) + 2); 2306 } 2307 if (string.contains(TEXT_COLOR_END)) { 2308 string = string.substring(0, string.indexOf(TEXT_COLOR_END)); 2309 } 2310 Font font = new Font(fontName, Font.PLAIN, fontSize); // NOI18N 2311 JLabel label = new JLabel(); 2312 FontMetrics metrics = label.getFontMetrics(font); 2313 int stringWidth = metrics.stringWidth(string); 2314 return stringWidth <= getPageSize(orientation).width; 2315 } 2316 2317 protected static final Dimension PAPER_MARGINS = new Dimension(84, 72); 2318 2319 protected static Dimension getPageSize(String orientation) { 2320 // page size has been adjusted to account for margins of .5 2321 // Dimension(84, 72) 2322 Dimension pagesize = new Dimension(523, 720); // Portrait 8.5 x 11 2323 // landscape has .65 margins 2324 if (orientation.equals(Setup.LANDSCAPE)) { 2325 pagesize = new Dimension(702, 523); // 11 x 8.5 2326 } 2327 if (orientation.equals(Setup.HALFPAGE)) { 2328 pagesize = new Dimension(261, 720); // 4.25 x 11 2329 } 2330 if (orientation.equals(Setup.HANDHELD)) { 2331 pagesize = new Dimension(206, 720); // 3.25 x 11 2332 } 2333 return pagesize; 2334 } 2335 2336 /** 2337 * Produces a string using commas and spaces between the strings provided in 2338 * the array. Does not check for embedded commas in the string array. 2339 * 2340 * @param array The string array to be formated. 2341 * @return formated string using commas and spaces 2342 */ 2343 public static String formatStringToCommaSeparated(String[] array) { 2344 StringBuffer sbuf = new StringBuffer(""); 2345 for (String s : array) { 2346 if (s != null) { 2347 sbuf = sbuf.append(s + "," + SPACE); 2348 } 2349 } 2350 if (sbuf.length() > 2) { 2351 sbuf.setLength(sbuf.length() - 2); // remove trailing separators 2352 } 2353 return sbuf.toString(); 2354 } 2355 2356 private void addLine(PrintWriter file, StringBuffer buf, Color color) { 2357 String s = buf.toString(); 2358 if (!s.isBlank()) { 2359 addLine(file, formatColorString(s, color)); 2360 } 2361 } 2362 2363 /** 2364 * Adds HTML like color text control characters around a string. Note that 2365 * black is the standard text color, and if black is requested no control 2366 * characters are added. 2367 * 2368 * @param text the text to be modified 2369 * @param color the color the text is to be printed 2370 * @return formated text with color modifiers 2371 */ 2372 public static String formatColorString(String text, Color color) { 2373 String s = text; 2374 if (!color.equals(Color.black)) { 2375 s = TEXT_COLOR_START + ColorUtil.colorToColorName(color) + TEXT_COLOR_DONE + text + TEXT_COLOR_END; 2376 } 2377 return s; 2378 } 2379 2380 /** 2381 * Removes the color text control characters around the desired string 2382 * 2383 * @param string the string with control characters 2384 * @return pure text 2385 */ 2386 public static String getTextColorString(String string) { 2387 String text = string; 2388 if (string.contains(TEXT_COLOR_START)) { 2389 text = string.substring(0, string.indexOf(TEXT_COLOR_START)) + 2390 string.substring(string.indexOf(TEXT_COLOR_DONE) + 2); 2391 } 2392 if (text.contains(TEXT_COLOR_END)) { 2393 text = text.substring(0, text.indexOf(TEXT_COLOR_END)) + 2394 string.substring(string.indexOf(TEXT_COLOR_END) + TEXT_COLOR_END.length()); 2395 } 2396 return text; 2397 } 2398 2399 public static Color getTextColor(String string) { 2400 Color color = Color.black; 2401 if (string.contains(TEXT_COLOR_START)) { 2402 String c = string.substring(string.indexOf(TEXT_COLOR_START) + TEXT_COLOR_START.length()); 2403 c = c.substring(0, c.indexOf("\"")); 2404 color = ColorUtil.stringToColor(c); 2405 } 2406 return color; 2407 } 2408 2409 public static String getTextColorName(String string) { 2410 return ColorUtil.colorToColorName(getTextColor(string)); 2411 } 2412 2413 private static final Logger log = LoggerFactory.getLogger(TrainCommon.class); 2414}