--- /dev/null
+package tim.prune.function.autoplay;
+
+import java.awt.Component;
+import java.awt.FlowLayout;
+import java.awt.event.ActionEvent;
+import java.awt.event.ActionListener;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
+import java.util.Iterator;
+import java.util.TreeSet;
+
+import javax.swing.BoxLayout;
+import javax.swing.JButton;
+import javax.swing.JCheckBox;
+import javax.swing.JDialog;
+import javax.swing.JLabel;
+import javax.swing.JPanel;
+
+import tim.prune.App;
+import tim.prune.GenericFunction;
+import tim.prune.I18nManager;
+import tim.prune.data.Field;
+import tim.prune.data.Timestamp;
+import tim.prune.data.Track;
+import tim.prune.gui.GuiGridLayout;
+import tim.prune.gui.IconManager;
+import tim.prune.gui.WholeNumberField;
+
+/**
+ * Function to handle the autoplay of a track
+ */
+public class AutoplayFunction extends GenericFunction implements Runnable
+{
+ /** Dialog */
+ private JDialog _dialog = null;
+ /** Entry field for number of seconds to autoplay for */
+ private WholeNumberField _durationField = null;
+ /** Checkbox for using point timestamps */
+ private JCheckBox _useTimestampsCheckbox = null;
+ /** Buttons for controlling autoplay */
+ private JButton _rewindButton = null, _pauseButton = null, _playButton = null;
+ /** Flag for recalculating all the times */
+ private boolean _needToRecalculate = true;
+ /** Point list */
+ private PointList _pointList = null;
+ /** Flag to see if we're still running or not */
+ private boolean _running = false;
+ /** Remember the time we started playing */
+ private long _startTime = 0L;
+
+
+ /**
+ * Constructor
+ * @param inApp App object
+ */
+ public AutoplayFunction(App inApp) {
+ super(inApp);
+ }
+
+ @Override
+ public String getNameKey() {
+ return "function.autoplay";
+ }
+
+ /**
+ * Begin the function
+ */
+ public void begin()
+ {
+ if (_dialog == null)
+ {
+ _dialog = new JDialog(_parentFrame, I18nManager.getText(getNameKey()), true);
+ _dialog.setLocationRelativeTo(_parentFrame);
+ _dialog.setDefaultCloseOperation(JDialog.DISPOSE_ON_CLOSE);
+ _dialog.getContentPane().add(makeDialogComponents());
+ _dialog.pack();
+ _dialog.setResizable(false);
+ _dialog.addWindowListener(new WindowAdapter() {
+ public void windowClosing(WindowEvent e) {
+ _running = false;
+ super.windowClosing(e);
+ }
+ });
+ }
+ // Don't select any point
+ _app.getTrackInfo().selectPoint(-1);
+ // enable buttons
+ enableButtons(false, true); // can't pause, can play
+ // MAYBE: reset duration if it's too long
+ // Disable point checkbox if there aren't any times
+ final boolean hasTimes = _app.getTrackInfo().getTrack().hasData(Field.TIMESTAMP);
+ _useTimestampsCheckbox.setEnabled(hasTimes);
+ if (!hasTimes)
+ {
+ _useTimestampsCheckbox.setSelected(false);
+ }
+
+ _needToRecalculate = true;
+ _dialog.setVisible(true);
+ }
+
+
+ /**
+ * Create dialog components
+ * @return Panel containing all gui elements in dialog
+ */
+ private Component makeDialogComponents()
+ {
+ JPanel dialogPanel = new JPanel();
+ dialogPanel.setLayout(new BoxLayout(dialogPanel, BoxLayout.Y_AXIS));
+ // Duration panel
+ JPanel durationPanel = new JPanel();
+ GuiGridLayout grid = new GuiGridLayout(durationPanel);
+ grid.add(new JLabel(I18nManager.getText("dialog.autoplay.duration") + " :"));
+ _durationField = new WholeNumberField(3);
+ _durationField.setValue(60); // default is one minute
+ _durationField.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ onParamsChanged();
+ }
+ });
+ grid.add(_durationField);
+ durationPanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+ dialogPanel.add(durationPanel);
+ // Checkbox
+ _useTimestampsCheckbox = new JCheckBox(I18nManager.getText("dialog.autoplay.usetimestamps"));
+ _useTimestampsCheckbox.setAlignmentX(Component.CENTER_ALIGNMENT);
+ dialogPanel.add(_useTimestampsCheckbox);
+ _useTimestampsCheckbox.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e) {
+ onParamsChanged();
+ }
+ });
+ // Button panel
+ JPanel buttonPanel = new JPanel();
+ buttonPanel.setLayout(new FlowLayout(FlowLayout.CENTER));
+ buttonPanel.add(_rewindButton = new JButton(IconManager.getImageIcon(IconManager.AUTOPLAY_REWIND)));
+ _rewindButton.setToolTipText(I18nManager.getText("dialog.autoplay.rewind"));
+ _rewindButton.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ onRewindPressed();
+ }
+ });
+ buttonPanel.add(_pauseButton = new JButton(IconManager.getImageIcon(IconManager.AUTOPLAY_PAUSE)));
+ _pauseButton.setToolTipText(I18nManager.getText("dialog.autoplay.pause"));
+ _pauseButton.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ onPausePressed();
+ }
+ });
+ buttonPanel.add(_playButton = new JButton(IconManager.getImageIcon(IconManager.AUTOPLAY_PLAY)));
+ _playButton.setToolTipText(I18nManager.getText("dialog.autoplay.play"));
+ _playButton.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent arg0) {
+ onPlayPressed();
+ }
+ });
+ buttonPanel.setAlignmentX(Component.CENTER_ALIGNMENT);
+ dialogPanel.add(buttonPanel);
+ return dialogPanel;
+ }
+
+ /**
+ * React to a change to either the duration or the checkbox
+ */
+ private void onParamsChanged()
+ {
+ onRewindPressed();
+ enableButtons(false, _durationField.getValue() > 0);
+ _needToRecalculate = true;
+ }
+
+ /**
+ * React to rewind button pressed - stop and go back to the first point
+ */
+ private void onRewindPressed()
+ {
+ //System.out.println("Rewind! Stop thread if playing");
+ _running = false;
+ if (_pointList != null)
+ {
+ _pointList.set(0);
+ _app.getTrackInfo().selectPoint(_pointList.getCurrentPointIndex());
+ }
+ }
+
+ /**
+ * React to pause button pressed - stop scrolling but maintain position
+ */
+ private void onPausePressed()
+ {
+ //System.out.println("Pause! Stop thread if playing");
+ _running = false;
+ enableButtons(false, true);
+ }
+
+ /**
+ * React to play button being pressed - either start or resume
+ */
+ private void onPlayPressed()
+ {
+ //System.out.println("Play!");
+ if (_needToRecalculate) {
+ recalculateTimes();
+ }
+ enableButtons(true, false);
+ if (_pointList.isAtStart() || _pointList.isFinished())
+ {
+ _pointList.set(0);
+ _startTime = System.currentTimeMillis();
+ }
+ else
+ {
+ // Get current millis from pointList, reset _startTime
+ _startTime = System.currentTimeMillis() - _pointList.getCurrentMilliseconds();
+ }
+ new Thread(this).start();
+ }
+
+ /**
+ * Recalculate the times using the dialog settings
+ */
+ private void recalculateTimes()
+ {
+ //System.out.println("Recalculate using params " + _durationField.getValue()
+ // + " and " + (_useTimestampsCheckbox.isSelected() ? "times" : "indexes"));
+ if (_useTimestampsCheckbox.isSelected()) {
+ _pointList = generatePointListUsingTimes(_app.getTrackInfo().getTrack(), _durationField.getValue());
+ }
+ else {
+ _pointList = generatePointListUsingIndexes(_app.getTrackInfo().getTrack().getNumPoints(), _durationField.getValue());
+ }
+ _needToRecalculate = false;
+ }
+
+ /**
+ * Enable and disable the pause and play buttons
+ * @param inCanPause true to enable pause button
+ * @param inCanPlay true to enable play button
+ */
+ private void enableButtons(boolean inCanPause, boolean inCanPlay)
+ {
+ _pauseButton.setEnabled(inCanPause);
+ _playButton.setEnabled(inCanPlay);
+ }
+
+ /**
+ * Generate a points list based just on the point timestamps
+ * (points without timestamps will be ignored)
+ * @param inTrack track object
+ * @param inDuration number of seconds to play
+ * @return PointList object
+ */
+ private static PointList generatePointListUsingTimes(Track inTrack, int inDuration)
+ {
+ // Make a Set of all the points with timestamps and sort them
+ TreeSet<PointInfo> set = new TreeSet<PointInfo>();
+ int numPoints = inTrack.getNumPoints();
+ for (int i=0; i<numPoints; i++)
+ {
+ PointInfo info = new PointInfo(inTrack.getPoint(i), i);
+ if (info.getTimestamp() != null) {
+ set.add(info);
+ }
+ }
+ // For each point, keep track of the time since the previous time
+ Timestamp previousTime = null;
+ long trackMillis = 0L;
+ // Copy info to point list
+ numPoints = set.size();
+ PointList list = new PointList(numPoints);
+ Iterator<PointInfo> it = set.iterator();
+ while (it.hasNext())
+ {
+ PointInfo info = it.next();
+ if (previousTime != null)
+ {
+ if (info.getSegmentFlag()) {
+ trackMillis += 1000; // just add a second if it's a new segment
+ }
+ else {
+ trackMillis += (info.getTimestamp().getMillisecondsSince(previousTime));
+ }
+ }
+ previousTime = info.getTimestamp();
+ list.setPoint(trackMillis, info.getIndex());
+ }
+ // Now normalize the list to the requested length
+ list.normalize(inDuration);
+ return list;
+ }
+
+
+ /**
+ * Generate a points list based just on indexes, ignoring timestamps
+ * @param inNumPoints number of points in track
+ * @param inDuration number of seconds to play
+ * @return PointList object
+ */
+ private static PointList generatePointListUsingIndexes(int inNumPoints, int inDuration)
+ {
+ // simple case, just take all the points in the track
+ PointList list = new PointList(inNumPoints);
+ // Add each of the points in turn
+ for (int i=0; i<inNumPoints; i++)
+ {
+ list.setPoint(i, i);
+ }
+ list.normalize(inDuration);
+ return list;
+ }
+
+ /**
+ * Run method, for scrolling in separate thread
+ */
+ public void run()
+ {
+ _running = true;
+ _app.getTrackInfo().selectPoint(_pointList.getCurrentPointIndex());
+ while (_running && !_pointList.isFinished())
+ {
+ _pointList.set(System.currentTimeMillis() - _startTime);
+ final int pointIndex = _pointList.getCurrentPointIndex();
+ //System.out.println("Set point index to " + pointIndex);
+ _app.getTrackInfo().selectPoint(pointIndex);
+ long waitInterval = _pointList.getMillisUntilNextPoint(System.currentTimeMillis() - _startTime);
+ if (waitInterval < 20) {waitInterval = 20;}
+ try {Thread.sleep(waitInterval);}
+ catch (InterruptedException ie) {}
+ }
+ _running = false;
+ enableButtons(false, true);
+ }
+}
projects / GpsPrune.git / blobdiff