1 package tim.prune.gui.map;
3 import java.awt.AlphaComposite;
4 import java.awt.BasicStroke;
5 import java.awt.BorderLayout;
7 import java.awt.Cursor;
8 import java.awt.Dimension;
9 import java.awt.FlowLayout;
10 import java.awt.FontMetrics;
11 import java.awt.Graphics;
12 import java.awt.Graphics2D;
13 import java.awt.Image;
14 import java.awt.RenderingHints;
15 import java.awt.event.ActionEvent;
16 import java.awt.event.ActionListener;
17 import java.awt.event.ItemEvent;
18 import java.awt.event.ItemListener;
19 import java.awt.event.KeyEvent;
20 import java.awt.event.KeyListener;
21 import java.awt.event.MouseEvent;
22 import java.awt.event.MouseListener;
23 import java.awt.event.MouseMotionListener;
24 import java.awt.event.MouseWheelEvent;
25 import java.awt.event.MouseWheelListener;
26 import java.awt.image.BufferedImage;
28 import javax.swing.BorderFactory;
29 import javax.swing.BoxLayout;
30 import javax.swing.JButton;
31 import javax.swing.JCheckBox;
32 import javax.swing.JMenuItem;
33 import javax.swing.JPanel;
34 import javax.swing.JPopupMenu;
35 import javax.swing.JSlider;
36 import javax.swing.SwingUtilities;
37 import javax.swing.event.ChangeEvent;
38 import javax.swing.event.ChangeListener;
41 import tim.prune.DataSubscriber;
42 import tim.prune.FunctionLibrary;
43 import tim.prune.I18nManager;
44 import tim.prune.UpdateMessageBroker;
45 import tim.prune.config.ColourScheme;
46 import tim.prune.config.Config;
47 import tim.prune.data.Checker;
48 import tim.prune.data.Coordinate;
49 import tim.prune.data.DataPoint;
50 import tim.prune.data.DoubleRange;
51 import tim.prune.data.Field;
52 import tim.prune.data.FieldList;
53 import tim.prune.data.Latitude;
54 import tim.prune.data.Longitude;
55 import tim.prune.data.MidpointData;
56 import tim.prune.data.Selection;
57 import tim.prune.data.Track;
58 import tim.prune.data.TrackInfo;
59 import tim.prune.function.compress.MarkPointsInRectangleFunction;
60 import tim.prune.function.edit.FieldEdit;
61 import tim.prune.function.edit.FieldEditList;
62 import tim.prune.gui.IconManager;
63 import tim.prune.gui.TripleStateCheckBox;
64 import tim.prune.gui.colour.PointColourer;
65 import tim.prune.tips.TipManager;
68 * Class for the map canvas, to display a background map and draw on it
70 public class MapCanvas extends JPanel implements MouseListener, MouseMotionListener, DataSubscriber,
71 KeyListener, MouseWheelListener, TileConsumer
73 /** App object for callbacks */
74 private App _app = null;
76 private Track _track = null;
77 /** TrackInfo object */
78 private TrackInfo _trackInfo = null;
79 /** Selection object */
80 private Selection _selection = null;
81 /** Object to keep track of midpoints */
82 private MidpointData _midpoints = null;
83 /** Index of point clicked at mouseDown */
84 private int _clickedPoint = -1;
85 /** Previously selected point */
86 private int _prevSelectedPoint = -1;
88 private MapTileManager _tileManager = new MapTileManager(this);
89 /** Image to display */
90 private BufferedImage _mapImage = null;
91 /** Second image for drawing track (only needed for alpha blending) */
92 private BufferedImage _trackImage = null;
93 /** Slider for transparency */
94 private JSlider _transparencySlider = null;
95 /** Checkbox for scale bar */
96 private JCheckBox _scaleCheckBox = null;
97 /** Checkbox for maps */
98 private JCheckBox _mapCheckBox = null;
99 /** Checkbox for autopan */
100 private JCheckBox _autopanCheckBox = null;
101 /** Checkbox for connecting track points */
102 private TripleStateCheckBox _connectCheckBox = null;
103 /** Checkbox for enable edit mode */
104 private JCheckBox _editmodeCheckBox = null;
105 /** Right-click popup menu */
106 private JPopupMenu _popup = null;
107 /** Top component panel */
108 private JPanel _topPanel = null;
109 /** Side component panel */
110 private JPanel _sidePanel = null;
112 private ScaleBar _scaleBar = null;
114 private DoubleRange _latRange = null, _lonRange = null;
115 private DoubleRange _xRange = null, _yRange = null;
116 private boolean _recalculate = false;
117 /** Flag to check bounds on next paint */
118 private boolean _checkBounds = false;
120 private MapPosition _mapPosition = null;
121 /** coordinates of drag from point */
122 private int _dragFromX = -1, _dragFromY = -1;
123 /** coordinates of drag to point */
124 private int _dragToX = -1, _dragToY = -1;
125 /** coordinates of popup menu */
126 private int _popupMenuX = -1, _popupMenuY = -1;
127 /** Flag to prevent showing too often the error message about loading maps */
128 private boolean _shownOsmErrorAlready = false;
129 /** Current drawing mode */
130 private int _drawMode = MODE_DEFAULT;
132 /** Constant for click sensitivity when selecting nearest point */
133 private static final int CLICK_SENSITIVITY = 10;
134 /** Constant for pan distance from key presses */
135 private static final int PAN_DISTANCE = 20;
136 /** Constant for pan distance from autopan */
137 private static final int AUTOPAN_DISTANCE = 75;
140 private static final Color COLOR_MESSAGES = Color.GRAY;
143 private static final int MODE_DEFAULT = 0;
144 private static final int MODE_ZOOM_RECT = 1;
145 private static final int MODE_DRAW_POINTS_START = 2;
146 private static final int MODE_DRAW_POINTS_CONT = 3;
147 private static final int MODE_DRAG_POINT = 4;
148 private static final int MODE_CREATE_MIDPOINT = 5;
149 private static final int MODE_MARK_RECTANGLE = 6;
151 private static final int INDEX_UNKNOWN = -2;
156 * @param inApp App object for callbacks
157 * @param inTrackInfo track info object
159 public MapCanvas(App inApp, TrackInfo inTrackInfo)
162 _trackInfo = inTrackInfo;
163 _track = inTrackInfo.getTrack();
164 _selection = inTrackInfo.getSelection();
165 _midpoints = new MidpointData();
166 _mapPosition = new MapPosition();
167 addMouseListener(this);
168 addMouseMotionListener(this);
169 addMouseWheelListener(this);
170 addKeyListener(this);
172 // Make listener for changes to controls
173 ItemListener itemListener = new ItemListener() {
174 public void itemStateChanged(ItemEvent e)
180 // Make special listener for changes to map checkbox
181 ItemListener mapCheckListener = new ItemListener() {
182 public void itemStateChanged(ItemEvent e)
184 _tileManager.clearMemoryCaches();
186 Config.setConfigBoolean(Config.KEY_SHOW_MAP, e.getStateChange() == ItemEvent.SELECTED);
187 UpdateMessageBroker.informSubscribers(); // to let menu know
188 // If the track is only partially visible and you turn the map off, make the track fully visible again
189 if (e.getStateChange() == ItemEvent.DESELECTED && _transparencySlider.getValue() < 0) {
190 _transparencySlider.setValue(0);
194 _topPanel = new OverlayPanel();
195 _topPanel.setLayout(new FlowLayout());
196 // Make slider for transparency
197 _transparencySlider = new JSlider(-6, 6, 0);
198 _transparencySlider.setPreferredSize(new Dimension(100, 20));
199 _transparencySlider.setMajorTickSpacing(1);
200 _transparencySlider.setSnapToTicks(true);
201 _transparencySlider.setOpaque(false);
202 _transparencySlider.setValue(0);
203 _transparencySlider.addChangeListener(new ChangeListener() {
204 public void stateChanged(ChangeEvent e)
206 int val = _transparencySlider.getValue();
207 if (val == 1 || val == -1)
208 _transparencySlider.setValue(0);
215 _transparencySlider.setFocusable(false); // stop slider from stealing keyboard focus
216 _topPanel.add(_transparencySlider);
217 // Add checkbox button for enabling scale bar
218 _scaleCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.SCALEBAR_BUTTON), true);
219 _scaleCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.SCALEBAR_BUTTON_ON));
220 _scaleCheckBox.setOpaque(false);
221 _scaleCheckBox.setToolTipText(I18nManager.getText("menu.map.showscalebar"));
222 _scaleCheckBox.addItemListener(new ItemListener() {
223 public void itemStateChanged(ItemEvent e) {
224 _scaleBar.setVisible(_scaleCheckBox.isSelected());
227 _scaleCheckBox.setFocusable(false); // stop button from stealing keyboard focus
228 _topPanel.add(_scaleCheckBox);
229 // Add checkbox button for enabling maps or not
230 _mapCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.MAP_BUTTON), false);
231 _mapCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.MAP_BUTTON_ON));
232 _mapCheckBox.setOpaque(false);
233 _mapCheckBox.setToolTipText(I18nManager.getText("menu.map.showmap"));
234 _mapCheckBox.addItemListener(mapCheckListener);
235 _mapCheckBox.setFocusable(false); // stop button from stealing keyboard focus
236 _topPanel.add(_mapCheckBox);
237 // Add checkbox button for enabling autopan or not
238 _autopanCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.AUTOPAN_BUTTON), true);
239 _autopanCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.AUTOPAN_BUTTON_ON));
240 _autopanCheckBox.setOpaque(false);
241 _autopanCheckBox.setToolTipText(I18nManager.getText("menu.map.autopan"));
242 _autopanCheckBox.addItemListener(itemListener);
243 _autopanCheckBox.setFocusable(false); // stop button from stealing keyboard focus
244 _topPanel.add(_autopanCheckBox);
245 // Add checkbox button for connecting points or not
246 _connectCheckBox = new TripleStateCheckBox();
247 _connectCheckBox.setIcon(0, IconManager.getImageIcon(IconManager.POINTS_CONNECTED_BUTTON));
248 _connectCheckBox.setIcon(1, IconManager.getImageIcon(IconManager.POINTS_DISCONNECTED_BUTTON));
249 _connectCheckBox.setIcon(2, IconManager.getImageIcon(IconManager.POINTS_HIDDEN_BUTTON));
250 _connectCheckBox.setCurrentState(0);
251 _connectCheckBox.setOpaque(false);
252 _connectCheckBox.setToolTipText(I18nManager.getText("menu.map.connect"));
253 _connectCheckBox.addItemListener(itemListener);
254 _connectCheckBox.setFocusable(false); // stop button from stealing keyboard focus
255 _topPanel.add(_connectCheckBox);
257 // Add checkbox button for edit mode or not
258 _editmodeCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON), false);
259 _editmodeCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON_ON));
260 _editmodeCheckBox.setOpaque(false);
261 _editmodeCheckBox.setToolTipText(I18nManager.getText("menu.map.editmode"));
262 _editmodeCheckBox.addItemListener(itemListener);
263 _editmodeCheckBox.setFocusable(false); // stop button from stealing keyboard focus
264 _topPanel.add(_editmodeCheckBox);
266 // Add zoom in, zoom out buttons
267 _sidePanel = new OverlayPanel();
268 _sidePanel.setLayout(new BoxLayout(_sidePanel, BoxLayout.Y_AXIS));
269 JButton zoomInButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_IN_BUTTON));
270 zoomInButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
271 zoomInButton.setContentAreaFilled(false);
272 zoomInButton.setToolTipText(I18nManager.getText("menu.map.zoomin"));
273 zoomInButton.addActionListener(new ActionListener() {
274 public void actionPerformed(ActionEvent e)
279 zoomInButton.setFocusable(false); // stop button from stealing keyboard focus
280 _sidePanel.add(zoomInButton);
281 JButton zoomOutButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_OUT_BUTTON));
282 zoomOutButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
283 zoomOutButton.setContentAreaFilled(false);
284 zoomOutButton.setToolTipText(I18nManager.getText("menu.map.zoomout"));
285 zoomOutButton.addActionListener(new ActionListener() {
286 public void actionPerformed(ActionEvent e)
291 zoomOutButton.setFocusable(false); // stop button from stealing keyboard focus
292 _sidePanel.add(zoomOutButton);
294 // Bottom panel for scale bar
295 _scaleBar = new ScaleBar();
297 // add control panels to this one
298 setLayout(new BorderLayout());
299 _topPanel.setVisible(false);
300 _sidePanel.setVisible(false);
301 add(_topPanel, BorderLayout.NORTH);
302 add(_sidePanel, BorderLayout.WEST);
303 add(_scaleBar, BorderLayout.SOUTH);
306 // Get currently selected map from Config, pass to MapTileManager
307 _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
312 * Make the popup menu for right-clicking the map
314 private void makePopup()
316 _popup = new JPopupMenu();
317 JMenuItem zoomInItem = new JMenuItem(I18nManager.getText("menu.map.zoomin"));
318 zoomInItem.addActionListener(new ActionListener() {
319 public void actionPerformed(ActionEvent e)
321 panMap((_popupMenuX - getWidth()/2)/2, (_popupMenuY - getHeight()/2)/2);
324 _popup.add(zoomInItem);
325 JMenuItem zoomOutItem = new JMenuItem(I18nManager.getText("menu.map.zoomout"));
326 zoomOutItem.addActionListener(new ActionListener() {
327 public void actionPerformed(ActionEvent e)
329 panMap(-(_popupMenuX - getWidth()/2), -(_popupMenuY - getHeight()/2));
332 _popup.add(zoomOutItem);
333 JMenuItem zoomFullItem = new JMenuItem(I18nManager.getText("menu.map.zoomfull"));
334 zoomFullItem.addActionListener(new ActionListener() {
335 public void actionPerformed(ActionEvent e)
341 _popup.add(zoomFullItem);
342 _popup.addSeparator();
344 JMenuItem setMapBgItem = new JMenuItem(
345 I18nManager.getText(FunctionLibrary.FUNCTION_SET_MAP_BG.getNameKey()));
346 setMapBgItem.addActionListener(new ActionListener() {
347 public void actionPerformed(ActionEvent e)
349 FunctionLibrary.FUNCTION_SET_MAP_BG.begin();
351 _popup.add(setMapBgItem);
353 JMenuItem newPointItem = new JMenuItem(I18nManager.getText("menu.map.newpoint"));
354 newPointItem.addActionListener(new ActionListener() {
355 public void actionPerformed(ActionEvent e)
357 _app.createPoint(createPointFromClick(_popupMenuX, _popupMenuY));
359 _popup.add(newPointItem);
361 JMenuItem drawPointsItem = new JMenuItem(I18nManager.getText("menu.map.drawpoints"));
362 drawPointsItem.addActionListener(new ActionListener() {
363 public void actionPerformed(ActionEvent e)
365 _drawMode = MODE_DRAW_POINTS_START;
368 _popup.add(drawPointsItem);
373 * Zoom to fit the current data area
375 private void zoomToFit()
377 _latRange = _track.getLatRange();
378 _lonRange = _track.getLonRange();
379 _xRange = new DoubleRange(MapUtils.getXFromLongitude(_lonRange.getMinimum()),
380 MapUtils.getXFromLongitude(_lonRange.getMaximum()));
381 _yRange = new DoubleRange(MapUtils.getYFromLatitude(_latRange.getMinimum()),
382 MapUtils.getYFromLatitude(_latRange.getMaximum()));
383 _mapPosition.zoomToXY(_xRange.getMinimum(), _xRange.getMaximum(), _yRange.getMinimum(), _yRange.getMaximum(),
384 getWidth(), getHeight());
390 * @see java.awt.Canvas#paint(java.awt.Graphics)
392 public void paint(Graphics inG)
395 if (_mapImage != null && (_mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())) {
398 if (_track.getNumPoints() > 0)
400 // Check for autopan if enabled / necessary
401 if (_autopanCheckBox.isSelected())
403 int selectedPoint = _selection.getCurrentPointIndex();
404 if (selectedPoint >= 0 && _dragFromX == -1 && selectedPoint != _prevSelectedPoint)
406 autopanToPoint(selectedPoint);
408 _prevSelectedPoint = selectedPoint;
411 // Draw the map contents if necessary
412 if ((_mapImage == null || _recalculate))
415 _scaleBar.updateScale(_mapPosition.getZoom(), _mapPosition.getYFromPixels(0, 0));
417 // Draw the prepared image onto the panel
418 if (_mapImage != null) {
419 inG.drawImage(_mapImage, 0, 0, getWidth(), getHeight(), null);
424 case MODE_DRAG_POINT:
425 drawDragLines(inG, _selection.getCurrentPointIndex()-1, _selection.getCurrentPointIndex()+1);
428 case MODE_CREATE_MIDPOINT:
429 drawDragLines(inG, _clickedPoint-1, _clickedPoint);
433 case MODE_MARK_RECTANGLE:
434 if (_dragFromX != -1 && _dragFromY != -1)
436 // Draw the zoom rectangle if necessary
437 inG.setColor(Color.RED);
438 inG.drawLine(_dragFromX, _dragFromY, _dragFromX, _dragToY);
439 inG.drawLine(_dragFromX, _dragFromY, _dragToX, _dragFromY);
440 inG.drawLine(_dragToX, _dragFromY, _dragToX, _dragToY);
441 inG.drawLine(_dragFromX, _dragToY, _dragToX, _dragToY);
445 case MODE_DRAW_POINTS_CONT:
446 // draw line to mouse position to show drawing mode
447 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
448 int prevIndex = _track.getNumPoints()-1;
449 int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(prevIndex));
450 int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(prevIndex));
451 inG.drawLine(px, py, _dragToX, _dragToY);
457 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
458 inG.fillRect(0, 0, getWidth(), getHeight());
459 inG.setColor(COLOR_MESSAGES);
460 inG.drawString(I18nManager.getText("display.nodata"), 50, getHeight()/2);
461 _scaleBar.updateScale(-1, 0);
463 // Draw slider etc on top
468 * @return true if the currently selected point is visible, false if off-screen or nothing selected
470 private boolean isCurrentPointVisible()
472 if (_trackInfo.getCurrentPoint() == null) {return false;}
473 final int selectedPoint = _selection.getCurrentPointIndex();
474 final int xFromCentre = Math.abs(_mapPosition.getXFromCentre(_track.getX(selectedPoint)));
475 if (xFromCentre > (getWidth()/2)) {return false;}
476 final int yFromCentre = Math.abs(_mapPosition.getYFromCentre(_track.getY(selectedPoint)));
477 return yFromCentre < (getHeight()/2);
481 * If the specified point isn't visible, pan to it
482 * @param inIndex index of selected point
484 private void autopanToPoint(int inIndex)
486 int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inIndex));
487 int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inIndex));
490 if (px < PAN_DISTANCE) {
491 panX = px - AUTOPAN_DISTANCE;
493 else if (px > (getWidth()-PAN_DISTANCE)) {
494 panX = AUTOPAN_DISTANCE + px - getWidth();
496 if (py < (2*PAN_DISTANCE)) {
497 panY = py - AUTOPAN_DISTANCE;
499 if (py > (getHeight()-PAN_DISTANCE)) {
500 panY = AUTOPAN_DISTANCE + py - getHeight();
502 if (panX != 0 || panY != 0) {
503 _mapPosition.pan(panX, panY);
508 * Paint the map tiles and the points on to the _mapImage
510 private void paintMapContents()
512 if (_mapImage == null || _mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())
514 _mapImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
517 Graphics g = _mapImage.getGraphics();
518 // Set antialiasing according to config
519 ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
520 Config.getConfigBoolean(Config.KEY_ANTIALIAS) ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
521 // Clear to background
522 g.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
523 g.fillRect(0, 0, getWidth(), getHeight());
525 // Check whether maps are on or not
526 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
527 _mapCheckBox.setSelected(showMap);
528 // Check whether disk cache is on or not
529 final boolean usingDiskCache = Config.getConfigString(Config.KEY_DISK_CACHE) != null;
530 // Show tip to recommend setting up a cache
531 if (showMap && !usingDiskCache && Config.getConfigBoolean(Config.KEY_ONLINE_MODE))
533 SwingUtilities.invokeLater(new Runnable() {
535 _app.showTip(TipManager.Tip_UseAMapCache);
540 // reset error message
541 if (!showMap) {_shownOsmErrorAlready = false;}
542 _recalculate = false;
543 // Only get map tiles if selected
547 _tileManager.centreMap(_mapPosition.getZoom(), _mapPosition.getCentreTileX(), _mapPosition.getCentreTileY());
549 boolean loadingFailed = false;
550 if (_mapImage == null) return;
552 if (_tileManager.isOverzoomed())
554 // display overzoom message
555 g.setColor(COLOR_MESSAGES);
556 g.drawString(I18nManager.getText("map.overzoom"), 50, getHeight()/2);
560 int numLayers = _tileManager.getNumLayers();
561 // Loop over tiles drawing each one
562 int[] tileIndices = _mapPosition.getTileIndices(getWidth(), getHeight());
563 int[] pixelOffsets = _mapPosition.getDisplayOffsets(getWidth(), getHeight());
564 for (int tileX = tileIndices[0]; tileX <= tileIndices[1] && !loadingFailed; tileX++)
566 int x = (tileX - tileIndices[0]) * 256 - pixelOffsets[0];
567 for (int tileY = tileIndices[2]; tileY <= tileIndices[3]; tileY++)
569 int y = (tileY - tileIndices[2]) * 256 - pixelOffsets[1];
571 for (int l=0; l<numLayers; l++)
573 Image image = _tileManager.getTile(l, tileX, tileY, true);
575 g.drawImage(image, x, y, 256, 256, null);
581 // Make maps brighter / fainter according to slider
582 final int brightnessIndex = Math.max(1, _transparencySlider.getValue()) - 1;
583 if (brightnessIndex > 0)
585 final int[] alphas = {0, 40, 80, 120, 160, 210};
586 Color bgColor = Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND);
587 bgColor = new Color(bgColor.getRed(), bgColor.getGreen(), bgColor.getBlue(), alphas[brightnessIndex]);
589 g.fillRect(0, 0, getWidth(), getHeight());
594 // Work out track opacity according to slider
595 final float[] opacities = {1.0f, 0.75f, 0.5f, 0.3f, 0.15f, 0.0f};
596 float trackOpacity = 1.0f;
597 if (_transparencySlider.getValue() < 0) {
598 trackOpacity = opacities[-1 - _transparencySlider.getValue()];
601 if (trackOpacity > 0.0f)
603 // Paint the track points on top
604 int pointsPainted = 1;
607 if (trackOpacity > 0.9f)
609 // Track is fully opaque, just draw it directly
610 pointsPainted = paintPoints(g);
615 // Track is partly transparent, so use a separate BufferedImage
616 if (_trackImage == null || _trackImage.getWidth() != getWidth() || _trackImage.getHeight() != getHeight())
618 _trackImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
620 // Clear to transparent
621 Graphics2D gTrack = _trackImage.createGraphics();
622 gTrack.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
623 gTrack.fillRect(0, 0, getWidth(), getHeight());
624 gTrack.setPaintMode();
625 // Draw the track onto this separate image
626 pointsPainted = paintPoints(gTrack);
627 ((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trackOpacity));
628 g.drawImage(_trackImage, 0, 0, null);
631 catch (NullPointerException npe) {} // ignore, probably due to data being changed during drawing
632 catch (ArrayIndexOutOfBoundsException obe) {} // also ignore
634 // Zoom to fit if no points found
635 if (pointsPainted <= 0 && _checkBounds)
646 _checkBounds = false;
647 // enable / disable transparency slider
648 _transparencySlider.setEnabled(showMap);
653 * Paint the points using the given graphics object
654 * @param inG Graphics object to use for painting
655 * @return number of points painted, if any
657 private int paintPoints(Graphics inG)
660 final ColourScheme cs = Config.getColourScheme();
661 final Color pointColour = cs.getColour(ColourScheme.IDX_POINT);
662 final Color rangeColour = cs.getColour(ColourScheme.IDX_SELECTION);
663 final Color currentColour = cs.getColour(ColourScheme.IDX_PRIMARY);
664 final Color secondColour = cs.getColour(ColourScheme.IDX_SECONDARY);
665 final Color textColour = cs.getColour(ColourScheme.IDX_TEXT);
666 final PointColourer pointColourer = _app.getPointColourer();
668 final int winWidth = getWidth();
669 final int winHeight = getHeight();
670 final int halfWinWidth = winWidth / 2;
671 final int halfWinHeight = winHeight / 2;
673 final int numPoints = _track.getNumPoints();
674 final int[] xPixels = new int[numPoints];
675 final int[] yPixels = new int[numPoints];
677 // try to set line width for painting
678 if (inG instanceof Graphics2D)
680 int lineWidth = Config.getConfigInt(Config.KEY_LINE_WIDTH);
681 if (lineWidth < 1 || lineWidth > 4) {lineWidth = 2;}
682 ((Graphics2D) inG).setStroke(new BasicStroke(lineWidth));
684 int pointsPainted = 0;
686 inG.setColor(pointColour);
687 int prevX = -1, prevY = -1;
688 final int connectState = _connectCheckBox.getCurrentState();
689 final boolean drawLines = (connectState % 2) == 0; // 0 or 2
690 final boolean drawPoints = (connectState <= 1); // 0 or 1
691 boolean prevPointVisible = false, currPointVisible = false;
692 boolean anyWaypoints = false;
693 boolean isWaypoint = false;
694 for (int i=0; i<numPoints; i++)
696 // Calculate pixel position of point from its x, y coordinates
697 int px = halfWinWidth + _mapPosition.getXFromCentre(_track.getX(i));
698 int py = halfWinHeight + _mapPosition.getYFromCentre(_track.getY(i));
699 px = wrapLongitudeValue(px, winWidth, _mapPosition.getZoom());
700 // Remember these calculated pixel values so they don't have to be recalculated
701 xPixels[i] = px; yPixels[i] = py;
703 currPointVisible = px >= 0 && px < winWidth && py >= 0 && py < winHeight;
704 isWaypoint = _track.getPoint(i).isWaypoint();
705 anyWaypoints = anyWaypoints || isWaypoint;
708 if (currPointVisible || (drawLines && prevPointVisible))
710 // For track points, work out which colour to use
711 if (_track.getPoint(i).getDeleteFlag()) {
712 inG.setColor(currentColour);
714 else if (pointColourer != null)
715 { // use the point colourer if there is one
716 Color trackColour = pointColourer.getColour(i);
717 inG.setColor(trackColour);
721 inG.setColor(pointColour);
724 // Draw rectangle for track point if it's visible
725 if (currPointVisible && drawPoints)
727 inG.drawRect(px-2, py-2, 3, 3);
732 // Connect track points if either of them are visible
733 if (drawLines && !(prevX == -1 && prevY == -1)
734 && !_track.getPoint(i).getSegmentStart())
736 inG.drawLine(prevX, prevY, px, py);
738 prevX = px; prevY = py;
740 prevPointVisible = currPointVisible;
743 // Loop over points, just drawing blobs for waypoints
744 inG.setColor(textColour);
745 FontMetrics fm = inG.getFontMetrics();
746 int nameHeight = fm.getHeight();
749 int numWaypoints = 0;
750 for (int i=0; i<_track.getNumPoints(); i++)
752 if (_track.getPoint(i).isWaypoint())
756 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
758 inG.fillRect(px-3, py-3, 6, 6);
764 // Take more care with waypoint names if less than 100 are visible
765 final int numNameSteps = (numWaypoints > 100 ? 1 : 4);
766 final int numPointSteps = (numWaypoints > 1000 ? 2 : 1);
768 // Loop over points again, now draw names for waypoints
769 int[] nameXs = {0, 0, 0, 0};
770 int[] nameYs = {0, 0, 0, 0};
771 for (int i=0; i<_track.getNumPoints(); i += numPointSteps)
773 if (_track.getPoint(i).isWaypoint())
777 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
779 // Figure out where to draw waypoint name so it doesn't obscure track
780 String waypointName = _track.getPoint(i).getWaypointName();
781 int nameWidth = fm.stringWidth(waypointName);
782 boolean drawnName = false;
783 // Make arrays for coordinates right left up down
784 nameXs[0] = px + 2; nameXs[1] = px - nameWidth - 2;
785 nameXs[2] = nameXs[3] = px - nameWidth/2;
786 nameYs[0] = nameYs[1] = py + (nameHeight/2);
787 nameYs[2] = py - 2; nameYs[3] = py + nameHeight + 2;
788 for (int extraSpace = 0; extraSpace < numNameSteps && !drawnName; extraSpace++)
790 // Shift arrays for coordinates right left up down
791 nameXs[0] += 3; nameXs[1] -= 3;
792 nameYs[2] -= 3; nameYs[3] += 3;
793 // Check each direction in turn right left up down
794 for (int a=0; a<4; a++)
796 if (nameXs[a] > 0 && (nameXs[a] + nameWidth) < winWidth
797 && nameYs[a] < winHeight && (nameYs[a] - nameHeight) > 0
798 && !MapUtils.overlapsPoints(_mapImage, nameXs[a], nameYs[a], nameWidth, nameHeight, textColour))
800 // Found a rectangle to fit - draw name here and quit
801 inG.drawString(waypointName, nameXs[a], nameYs[a]);
811 // Loop over points, drawing blobs for photo / audio points
812 inG.setColor(secondColour);
813 for (int i=0; i<_track.getNumPoints(); i++)
815 if (_track.getPoint(i).hasMedia())
819 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
821 inG.drawRect(px-1, py-1, 2, 2);
822 inG.drawRect(px-2, py-2, 4, 4);
828 // Draw selected range
829 if (_selection.hasRangeSelected())
831 inG.setColor(rangeColour);
832 for (int i=_selection.getStart(); i<=_selection.getEnd(); i++)
836 inG.drawRect(px-1, py-1, 2, 2);
840 // Draw crosshairs at selected point
841 int selectedPoint = _selection.getCurrentPointIndex();
842 if (selectedPoint >= 0)
844 int px = xPixels[selectedPoint];
845 int py = yPixels[selectedPoint];
846 inG.setColor(currentColour);
848 inG.drawLine(px, 0, px, winHeight);
849 inG.drawLine(0, py, winWidth, py);
851 // Return the number of points painted
852 return pointsPainted;
856 * Wrap the given pixel value if appropriate and possible
857 * @param inPx Pixel x coordinate
858 * @param inWinWidth window width in pixels
859 * @param inZoom zoom level
860 * @return modified pixel x coordinate
862 private static int wrapLongitudeValue(int inPx, int inWinWidth, int inZoom)
864 if (inPx > inWinWidth)
866 // Pixel is too far right, could we wrap it back onto the screen?
868 while (px > inWinWidth) {
869 px -= (256 << inZoom);
872 return px; // successfully wrapped back onto the screen
877 // Pixel is too far left, could we wrap it back onto the screen?
880 px += (256 << inZoom);
882 if (px < inWinWidth) {
883 return px; // successfully wrapped back onto the screen
886 // Either it's already on the screen or couldn't be wrapped
891 * Draw the lines while dragging a point
892 * @param inG graphics object
893 * @param inPrevIndex index of point to draw from
894 * @param inNextIndex index of point to draw to
896 private void drawDragLines(Graphics inG, int inPrevIndex, int inNextIndex)
898 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
899 // line from prev point to cursor
900 if (inPrevIndex > -1 && !_track.getPoint(inPrevIndex+1).getSegmentStart())
902 final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inPrevIndex));
903 final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inPrevIndex));
904 inG.drawLine(px, py, _dragToX, _dragToY);
906 if (inNextIndex < _track.getNumPoints() && !_track.getPoint(inNextIndex).getSegmentStart())
908 final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inNextIndex));
909 final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inNextIndex));
910 inG.drawLine(px, py, _dragToX, _dragToY);
915 * Inform that tiles have been updated and the map can be repainted
916 * @param inIsOk true if data loaded ok, false for error
918 public void tilesUpdated(boolean inIsOk)
922 // Show message if loading failed (but not too many times)
923 if (!inIsOk && !_shownOsmErrorAlready && _mapCheckBox.isSelected())
925 _shownOsmErrorAlready = true;
926 // use separate thread to show message about failing to load osm images
927 new Thread(new Runnable() {
929 try {Thread.sleep(500);} catch (InterruptedException ie) {}
930 _app.showErrorMessage("error.osmimage.dialogtitle", "error.osmimage.failed");
940 * Zoom out, if not already at minimum zoom
942 public void zoomOut()
944 _mapPosition.zoomOut();
950 * Zoom in, if not already at maximum zoom
954 // See if selected point is currently visible, if so (and autopan on) then autopan after zoom to keep it visible
955 boolean wasVisible = _autopanCheckBox.isSelected() && isCurrentPointVisible();
956 _mapPosition.zoomIn();
957 if (wasVisible && !isCurrentPointVisible()) {
958 autopanToPoint(_selection.getCurrentPointIndex());
966 * @param inDeltaX x shift
967 * @param inDeltaY y shift
969 public void panMap(int inDeltaX, int inDeltaY)
971 _mapPosition.pan(inDeltaX, inDeltaY);
977 * Create a DataPoint object from the given click coordinates
978 * @param inX x coordinate of click
979 * @param inY y coordinate of click
980 * @return DataPoint with given coordinates and no altitude
982 private DataPoint createPointFromClick(int inX, int inY)
984 double lat = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(inY, getHeight()));
985 double lon = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(inX, getWidth()));
986 return new DataPoint(new Latitude(lat, Coordinate.FORMAT_NONE),
987 new Longitude(lon, Coordinate.FORMAT_NONE), null);
991 * Move a DataPoint object to the given mouse coordinates
992 * @param startX start x coordinate of mouse
993 * @param startY start y coordinate of mouse
994 * @param endX end x coordinate of mouse
995 * @param endY end y coordinate of mouse
997 private void movePointToMouse(int startX, int startY, int endX, int endY )
999 double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(startY, getHeight()));
1000 double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(startX, getWidth()));
1001 double lat_delta = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(endY, getHeight())) - lat1;
1002 double lon_delta = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(endX, getWidth())) - lon1;
1004 DataPoint point = _trackInfo.getCurrentPoint();
1005 if (point == null) {
1009 // Make lists for edit and undo, and add each changed field in turn
1010 FieldEditList editList = new FieldEditList();
1011 FieldEditList undoList = new FieldEditList();
1014 FieldList fieldList = _track.getFieldList();
1015 int numFields = fieldList.getNumFields();
1016 for (int i=0; i<numFields; i++)
1018 Field field = fieldList.getField(i);
1019 if (field == Field.LATITUDE) {
1020 editList.addEdit(new FieldEdit(field, Double.toString(point.getLatitude().getDouble() + lat_delta)));
1021 undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LATITUDE)));
1023 else if (field == Field.LONGITUDE) {
1024 editList.addEdit(new FieldEdit(field, Double.toString(point.getLongitude().getDouble() + lon_delta)));
1025 undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LONGITUDE)));
1028 _app.completePointEdit(editList, undoList);
1033 * @see javax.swing.JComponent#getMinimumSize()
1035 public Dimension getMinimumSize()
1037 final Dimension minSize = new Dimension(512, 300);
1042 * @see javax.swing.JComponent#getPreferredSize()
1044 public Dimension getPreferredSize()
1046 return getMinimumSize();
1051 * Respond to mouse click events
1052 * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
1054 public void mouseClicked(MouseEvent inE)
1056 if (_track != null && _track.getNumPoints() > 0)
1058 // select point if it's a left-click
1059 if (!inE.isMetaDown())
1061 if (inE.getClickCount() == 1)
1064 if (_drawMode == MODE_DEFAULT)
1066 int pointIndex = _clickedPoint;
1067 if (pointIndex == INDEX_UNKNOWN)
1069 // index hasn't been calculated yet
1070 pointIndex = _track.getNearestPointIndex(
1071 _mapPosition.getXFromPixels(inE.getX(), getWidth()),
1072 _mapPosition.getYFromPixels(inE.getY(), getHeight()),
1073 _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY), false);
1075 // Extend selection for shift-click
1076 if (inE.isShiftDown()) {
1077 _trackInfo.extendSelection(pointIndex);
1080 _trackInfo.selectPoint(pointIndex);
1083 else if (_drawMode == MODE_DRAW_POINTS_START)
1085 _app.createPoint(createPointFromClick(inE.getX(), inE.getY()));
1086 _dragToX = inE.getX();
1087 _dragToY = inE.getY();
1088 _drawMode = MODE_DRAW_POINTS_CONT;
1090 else if (_drawMode == MODE_DRAW_POINTS_CONT)
1092 DataPoint point = createPointFromClick(inE.getX(), inE.getY());
1093 _app.createPoint(point, false); // not a new segment
1096 else if (inE.getClickCount() == 2)
1099 if (_drawMode == MODE_DEFAULT) {
1100 panMap(inE.getX() - getWidth()/2, inE.getY() - getHeight()/2);
1103 else if (_drawMode == MODE_DRAW_POINTS_START || _drawMode == MODE_DRAW_POINTS_CONT) {
1104 _drawMode = MODE_DEFAULT;
1110 // show the popup menu for right-clicks
1111 _popupMenuX = inE.getX();
1112 _popupMenuY = inE.getY();
1113 _popup.show(this, _popupMenuX, _popupMenuY);
1117 _app.setCurrentMode(App.AppMode.NORMAL);
1118 if (_drawMode == MODE_MARK_RECTANGLE) _drawMode = MODE_DEFAULT;
1122 * Ignore mouse enter events
1123 * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
1125 public void mouseEntered(MouseEvent inE)
1131 * Ignore mouse exited events
1132 * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
1134 public void mouseExited(MouseEvent inE)
1140 * React to mouse pressed events to initiate a point drag
1141 * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
1143 public void mousePressed(MouseEvent inE)
1145 _clickedPoint = INDEX_UNKNOWN;
1146 if (_track == null || _track.getNumPoints() <= 0)
1148 if (!inE.isMetaDown())
1150 // Left mouse drag - check if point is near; if so select it for dragging
1151 if (_drawMode == MODE_DEFAULT)
1153 /* Drag points if edit mode is enabled OR ALT is pressed */
1154 if (_editmodeCheckBox.isSelected() || inE.isAltDown() || inE.isAltGraphDown())
1156 final double clickX = _mapPosition.getXFromPixels(inE.getX(), getWidth());
1157 final double clickY = _mapPosition.getYFromPixels(inE.getY(), getHeight());
1158 final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
1159 _clickedPoint = _track.getNearestPointIndex(clickX, clickY, clickSens, false);
1161 if (_clickedPoint >= 0)
1163 // TODO: maybe use another color of the cross or remove the cross while dragging???
1165 _trackInfo.selectPoint(_clickedPoint);
1166 if (_trackInfo.getCurrentPoint() != null)
1168 _drawMode = MODE_DRAG_POINT;
1169 _dragFromX = _dragToX = inE.getX();
1170 _dragFromY = _dragToY = inE.getY();
1175 // Not a click on a point, so check half-way between two (connected) trackpoints
1176 int midpointIndex = _midpoints.getNearestPointIndex(clickX, clickY, clickSens);
1177 if (midpointIndex > 0)
1179 _drawMode = MODE_CREATE_MIDPOINT;
1180 _clickedPoint = midpointIndex;
1181 _dragFromX = _dragToX = inE.getX();
1182 _dragFromY = _dragToY = inE.getY();
1188 // else right-press ignored
1192 * Respond to mouse released events
1193 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
1195 public void mouseReleased(MouseEvent inE)
1197 _recalculate = true;
1199 if (_drawMode == MODE_DRAG_POINT)
1201 if (Math.abs(_dragToX - _dragFromX) > 2
1202 || Math.abs(_dragToY - _dragFromY) > 2)
1204 movePointToMouse(_dragFromX, _dragFromY, _dragToX, _dragToY );
1206 _drawMode = MODE_DEFAULT;
1208 else if (_drawMode == MODE_CREATE_MIDPOINT)
1210 _drawMode = MODE_DEFAULT;
1211 _app.createPoint(createPointFromClick(_dragToX, _dragToY), _clickedPoint);
1213 else if (_drawMode == MODE_ZOOM_RECT)
1215 if (Math.abs(_dragToX - _dragFromX) > 20
1216 && Math.abs(_dragToY - _dragFromY) > 20)
1218 _mapPosition.zoomToPixels(_dragFromX, _dragToX, _dragFromY, _dragToY, getWidth(), getHeight());
1220 _drawMode = MODE_DEFAULT;
1222 else if (_drawMode == MODE_MARK_RECTANGLE)
1225 _app.setCurrentMode(App.AppMode.NORMAL);
1226 _drawMode = MODE_DEFAULT;
1227 // Call a function to mark the points
1228 MarkPointsInRectangleFunction marker = (MarkPointsInRectangleFunction) FunctionLibrary.FUNCTION_MARK_IN_RECTANGLE;
1229 double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragFromX, getWidth()));
1230 double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragFromY, getHeight()));
1231 double lon2 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragToX, getWidth()));
1232 double lat2 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragToY, getHeight()));
1233 // Invalidate rectangle if pixel coords are (-1,-1)
1234 if (_dragFromX < 0 || _dragFromY < 0) {
1238 marker.setRectCoords(lon1, lat1, lon2, lat2);
1241 _dragFromX = _dragFromY = -1;
1246 * Respond to mouse drag events
1247 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
1249 public void mouseDragged(MouseEvent inE)
1251 if (!inE.isMetaDown())
1253 // Left mouse drag - either drag the point or pan the map
1254 if (_drawMode == MODE_DRAG_POINT || _drawMode == MODE_CREATE_MIDPOINT)
1257 _dragToX = inE.getX();
1258 _dragToY = inE.getY();
1259 _recalculate = true;
1262 else if (_drawMode == MODE_MARK_RECTANGLE)
1264 // draw a rectangle for marking points
1265 if (_dragFromX == -1) {
1266 _dragFromX = inE.getX();
1267 _dragFromY = inE.getY();
1269 _dragToX = inE.getX();
1270 _dragToY = inE.getY();
1275 // regular left-drag pans map by appropriate amount
1276 if (_dragFromX != -1)
1278 panMap(_dragFromX - inE.getX(), _dragFromY - inE.getY());
1280 _dragFromX = _dragToX = inE.getX();
1281 _dragFromY = _dragToY = inE.getY();
1286 // Right-click and drag - update rectangle
1287 _drawMode = MODE_ZOOM_RECT;
1288 if (_dragFromX == -1) {
1289 _dragFromX = inE.getX();
1290 _dragFromY = inE.getY();
1292 _dragToX = inE.getX();
1293 _dragToY = inE.getY();
1299 * Respond to mouse move events without button pressed
1300 * @param inEvent ignored
1302 public void mouseMoved(MouseEvent inEvent)
1304 boolean useCrosshairs = false;
1305 boolean useResize = false;
1306 // Ignore unless we're drawing points
1307 if (_drawMode == MODE_DRAW_POINTS_CONT)
1309 _dragToX = inEvent.getX();
1310 _dragToY = inEvent.getY();
1313 else if (_drawMode == MODE_MARK_RECTANGLE) {
1316 else if (_editmodeCheckBox.isSelected() || inEvent.isAltDown() || inEvent.isAltGraphDown())
1318 // Try to find a point or a midpoint at this location, and if there is one
1319 // then change the cursor to crosshairs
1320 final double clickX = _mapPosition.getXFromPixels(inEvent.getX(), getWidth());
1321 final double clickY = _mapPosition.getYFromPixels(inEvent.getY(), getHeight());
1322 final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
1323 useCrosshairs = (_track.getNearestPointIndex(clickX, clickY, clickSens, false) >= 0
1324 || _midpoints.getNearestPointIndex(clickX, clickY, clickSens) >= 0
1327 if (useCrosshairs && !isCursorSet()) {
1328 setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
1330 else if (useResize && !isCursorSet()) {
1331 setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1333 else if (!useCrosshairs && !useResize && isCursorSet()) {
1339 * Respond to status bar message from broker
1340 * @param inMessage message, ignored
1342 public void actionCompleted(String inMessage)
1348 * Respond to data updated message from broker
1349 * @param inUpdateType type of update
1351 public void dataUpdated(byte inUpdateType)
1353 _recalculate = true;
1354 if ((inUpdateType & DataSubscriber.DATA_ADDED_OR_REMOVED) > 0) {
1355 _checkBounds = true;
1357 if ((inUpdateType & DataSubscriber.MAPSERVER_CHANGED) > 0) {
1358 // Get the selected map source index and pass to tile manager
1359 _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
1361 if ((inUpdateType & (DataSubscriber.DATA_ADDED_OR_REMOVED + DataSubscriber.DATA_EDITED)) > 0) {
1362 _midpoints.updateData(_track);
1364 // See if rect mode has been activated
1365 if (_app.getCurrentMode() == App.AppMode.DRAWRECT)
1367 _drawMode = MODE_MARK_RECTANGLE;
1368 if (!isCursorSet()) {
1369 setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1373 // enable or disable components
1374 boolean hasData = _track.getNumPoints() > 0;
1375 _topPanel.setVisible(hasData);
1376 _sidePanel.setVisible(hasData);
1377 // grab focus for the key presses
1378 this.requestFocus();
1382 * Respond to key presses on the map canvas
1383 * @param inE key event
1385 public void keyPressed(KeyEvent inE)
1387 int code = inE.getKeyCode();
1388 int currPointIndex = _selection.getCurrentPointIndex();
1389 // Check for Ctrl key (for Linux/Win) or meta key (Clover key for Mac)
1390 if (inE.isControlDown() || inE.isMetaDown())
1392 // Shift as well makes things faster
1393 final int pointIncrement = inE.isShiftDown()?3:1;
1394 // Check for arrow keys to zoom in and out
1395 if (code == KeyEvent.VK_UP)
1397 else if (code == KeyEvent.VK_DOWN)
1399 // Key nav for next/prev point
1400 else if (code == KeyEvent.VK_LEFT && currPointIndex > 0)
1401 _trackInfo.incrementPointIndex(-pointIncrement);
1402 else if (code == KeyEvent.VK_RIGHT)
1403 _trackInfo.incrementPointIndex(pointIncrement);
1404 else if (code == KeyEvent.VK_PAGE_UP)
1405 _trackInfo.selectPoint(Checker.getPreviousSegmentStart(
1406 _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
1407 else if (code == KeyEvent.VK_PAGE_DOWN)
1408 _trackInfo.selectPoint(Checker.getNextSegmentStart(
1409 _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
1410 // Check for home and end
1411 else if (code == KeyEvent.VK_HOME)
1412 _trackInfo.selectPoint(0);
1413 else if (code == KeyEvent.VK_END)
1414 _trackInfo.selectPoint(_trackInfo.getTrack().getNumPoints()-1);
1418 // Check for arrow keys to pan
1420 if (code == KeyEvent.VK_UP)
1421 upwardsPan = -PAN_DISTANCE;
1422 else if (code == KeyEvent.VK_DOWN)
1423 upwardsPan = PAN_DISTANCE;
1424 int rightwardsPan = 0;
1425 if (code == KeyEvent.VK_RIGHT)
1426 rightwardsPan = PAN_DISTANCE;
1427 else if (code == KeyEvent.VK_LEFT)
1428 rightwardsPan = -PAN_DISTANCE;
1429 panMap(rightwardsPan, upwardsPan);
1431 if (code == KeyEvent.VK_ESCAPE)
1432 _drawMode = MODE_DEFAULT;
1433 // Check for backspace key to delete current point (delete key already handled by menu)
1434 else if (code == KeyEvent.VK_BACK_SPACE && currPointIndex >= 0) {
1435 _app.deleteCurrentPoint();
1441 * @param inE key released event, ignored
1443 public void keyReleased(KeyEvent e)
1449 * @param inE key typed event, ignored
1451 public void keyTyped(KeyEvent inE)
1457 * @param inE mouse wheel event indicating scroll direction
1459 public void mouseWheelMoved(MouseWheelEvent inE)
1461 int clicks = inE.getWheelRotation();
1463 panMap((inE.getX() - getWidth()/2)/2, (inE.getY() - getHeight()/2)/2);
1466 else if (clicks > 0) {
1467 panMap(-(inE.getX() - getWidth()/2), -(inE.getY() - getHeight()/2));
1473 * @return current map position
1475 public MapPosition getMapPosition()
1477 return _mapPosition;