1 package tim.prune.gui.map;
4 import java.awt.event.*;
5 import java.awt.image.BufferedImage;
8 import javax.swing.event.ChangeEvent;
9 import javax.swing.event.ChangeListener;
12 import tim.prune.DataSubscriber;
13 import tim.prune.FunctionLibrary;
14 import tim.prune.I18nManager;
15 import tim.prune.UpdateMessageBroker;
16 import tim.prune.config.ColourScheme;
17 import tim.prune.config.Config;
18 import tim.prune.data.*;
19 import tim.prune.function.compress.MarkPointsInRectangleFunction;
20 import tim.prune.function.edit.FieldEdit;
21 import tim.prune.function.edit.FieldEditList;
22 import tim.prune.gui.IconManager;
23 import tim.prune.gui.MultiStateCheckBox;
24 import tim.prune.gui.colour.PointColourer;
25 import tim.prune.tips.TipManager;
28 * Class for the map canvas, to display a background map and draw on it
30 public class MapCanvas extends JPanel implements MouseListener, MouseMotionListener, DataSubscriber,
31 KeyListener, MouseWheelListener, TileConsumer
33 /** App object for callbacks */
34 private App _app = null;
36 private Track _track = null;
37 /** TrackInfo object */
38 private TrackInfo _trackInfo = null;
39 /** Selection object */
40 private Selection _selection = null;
41 /** Object to keep track of midpoints */
42 private MidpointData _midpoints = null;
43 /** Index of point clicked at mouseDown */
44 private int _clickedPoint = -1;
45 /** Previously selected point */
46 private int _prevSelectedPoint = -1;
48 private MapTileManager _tileManager = new MapTileManager(this);
49 /** Image to display */
50 private BufferedImage _mapImage = null;
51 /** Second image for drawing track (only needed for alpha blending) */
52 private BufferedImage _trackImage = null;
53 /** Slider for transparency */
54 private JSlider _transparencySlider = null;
55 /** Checkbox for scale bar */
56 private JCheckBox _scaleCheckBox = null;
57 /** Checkbox for maps */
58 private JCheckBox _mapCheckBox = null;
59 /** Checkbox for autopan */
60 private JCheckBox _autopanCheckBox = null;
61 /** Checkbox for connecting track points */
62 private MultiStateCheckBox _connectCheckBox = null;
63 /** Checkbox for enable edit mode */
64 private JCheckBox _editmodeCheckBox = null;
65 /** Right-click popup menu */
66 private JPopupMenu _popup = null;
67 /** Top component panel */
68 private JPanel _topPanel = null;
69 /** Side component panel */
70 private JPanel _sidePanel = null;
72 private ScaleBar _scaleBar = null;
74 private DoubleRange _latRange = null, _lonRange = null;
75 private DoubleRange _xRange = null, _yRange = null;
76 private boolean _recalculate = false;
77 /** Flag to check bounds on next paint */
78 private boolean _checkBounds = false;
80 private MapPosition _mapPosition = null;
81 /** coordinates of drag from point */
82 private int _dragFromX = -1, _dragFromY = -1;
83 /** coordinates of drag to point */
84 private int _dragToX = -1, _dragToY = -1;
85 /** coordinates of popup menu */
86 private int _popupMenuX = -1, _popupMenuY = -1;
87 /** Flag to prevent showing too often the error message about loading maps */
88 private boolean _shownMapLoadErrorAlready = false;
89 /** Current drawing mode */
90 private int _drawMode = MODE_DEFAULT;
91 /** Current waypoint icon definition */
92 WpIconDefinition _waypointIconDefinition = null;
94 /** Constant for click sensitivity when selecting nearest point */
95 private static final int CLICK_SENSITIVITY = 30;
96 /** Constant for pan distance from key presses */
97 private static final int PAN_DISTANCE = 20;
98 /** Constant for pan distance from autopan */
99 private static final int AUTOPAN_DISTANCE = 75;
102 private static final Color COLOR_MESSAGES = Color.GRAY;
105 private static final int MODE_DEFAULT = 0;
106 private static final int MODE_ZOOM_RECT = 1;
107 private static final int MODE_DRAW_POINTS_START = 2;
108 private static final int MODE_DRAW_POINTS_CONT = 3;
109 private static final int MODE_DRAG_POINT = 4;
110 private static final int MODE_CREATE_MIDPOINT = 5;
111 private static final int MODE_MARK_RECTANGLE = 6;
113 private static final int INDEX_UNKNOWN = -2;
118 * @param inApp App object for callbacks
119 * @param inTrackInfo track info object
121 public MapCanvas(App inApp, TrackInfo inTrackInfo)
124 _trackInfo = inTrackInfo;
125 _track = inTrackInfo.getTrack();
126 _selection = inTrackInfo.getSelection();
127 _midpoints = new MidpointData();
128 _mapPosition = new MapPosition();
129 addMouseListener(this);
130 addMouseMotionListener(this);
131 addMouseWheelListener(this);
132 addKeyListener(this);
134 // Make listener for changes to controls
135 ItemListener itemListener = new ItemListener() {
136 public void itemStateChanged(ItemEvent e)
142 // Make special listener for changes to map checkbox
143 ItemListener mapCheckListener = new ItemListener() {
144 public void itemStateChanged(ItemEvent e)
146 _tileManager.clearMemoryCaches();
148 Config.setConfigBoolean(Config.KEY_SHOW_MAP, e.getStateChange() == ItemEvent.SELECTED);
149 UpdateMessageBroker.informSubscribers(); // to let menu know
150 // If the track is only partially visible and you turn the map off, make the track fully visible again
151 if (e.getStateChange() == ItemEvent.DESELECTED && _transparencySlider.getValue() < 0) {
152 _transparencySlider.setValue(0);
156 _topPanel = new OverlayPanel();
157 _topPanel.setLayout(new FlowLayout());
158 // Make slider for transparency
159 _transparencySlider = new JSlider(-6, 6, 0);
160 _transparencySlider.setPreferredSize(new Dimension(100, 20));
161 _transparencySlider.setMajorTickSpacing(1);
162 _transparencySlider.setSnapToTicks(true);
163 _transparencySlider.setOpaque(false);
164 _transparencySlider.setValue(0);
165 _transparencySlider.addChangeListener(new ChangeListener() {
166 public void stateChanged(ChangeEvent e)
168 int val = _transparencySlider.getValue();
169 if (val == 1 || val == -1)
170 _transparencySlider.setValue(0);
177 _transparencySlider.setFocusable(false); // stop slider from stealing keyboard focus
178 _topPanel.add(_transparencySlider);
179 // Add checkbox button for enabling scale bar
180 _scaleCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.SCALEBAR_BUTTON), true);
181 _scaleCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.SCALEBAR_BUTTON_ON));
182 _scaleCheckBox.setOpaque(false);
183 _scaleCheckBox.setToolTipText(I18nManager.getText("menu.map.showscalebar"));
184 _scaleCheckBox.addItemListener(new ItemListener() {
185 public void itemStateChanged(ItemEvent e) {
186 _scaleBar.setVisible(_scaleCheckBox.isSelected());
189 _scaleCheckBox.setFocusable(false); // stop button from stealing keyboard focus
190 _topPanel.add(_scaleCheckBox);
191 // Add checkbox button for enabling maps or not
192 _mapCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.MAP_BUTTON), false);
193 _mapCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.MAP_BUTTON_ON));
194 _mapCheckBox.setOpaque(false);
195 _mapCheckBox.setToolTipText(I18nManager.getText("menu.map.showmap"));
196 _mapCheckBox.addItemListener(mapCheckListener);
197 _mapCheckBox.setFocusable(false); // stop button from stealing keyboard focus
198 _topPanel.add(_mapCheckBox);
199 // Add checkbox button for enabling autopan or not
200 _autopanCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.AUTOPAN_BUTTON), true);
201 _autopanCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.AUTOPAN_BUTTON_ON));
202 _autopanCheckBox.setOpaque(false);
203 _autopanCheckBox.setToolTipText(I18nManager.getText("menu.map.autopan"));
204 _autopanCheckBox.addItemListener(itemListener);
205 _autopanCheckBox.setFocusable(false); // stop button from stealing keyboard focus
206 _topPanel.add(_autopanCheckBox);
207 // Add checkbox button for connecting points or not
208 _connectCheckBox = new MultiStateCheckBox(4);
209 _connectCheckBox.setIcon(0, IconManager.getImageIcon(IconManager.POINTS_WITH_ARROWS_BUTTON));
210 _connectCheckBox.setIcon(1, IconManager.getImageIcon(IconManager.POINTS_HIDDEN_BUTTON));
211 _connectCheckBox.setIcon(2, IconManager.getImageIcon(IconManager.POINTS_CONNECTED_BUTTON));
212 _connectCheckBox.setIcon(3, IconManager.getImageIcon(IconManager.POINTS_DISCONNECTED_BUTTON));
213 _connectCheckBox.setCurrentState(0);
214 _connectCheckBox.setOpaque(false);
215 _connectCheckBox.setToolTipText(I18nManager.getText("menu.map.connect"));
216 _connectCheckBox.addItemListener(itemListener);
217 _connectCheckBox.setFocusable(false); // stop button from stealing keyboard focus
218 _topPanel.add(_connectCheckBox);
220 // Add checkbox button for edit mode or not
221 _editmodeCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON), false);
222 _editmodeCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON_ON));
223 _editmodeCheckBox.setOpaque(false);
224 _editmodeCheckBox.setToolTipText(I18nManager.getText("menu.map.editmode"));
225 _editmodeCheckBox.addItemListener(itemListener);
226 _editmodeCheckBox.setFocusable(false); // stop button from stealing keyboard focus
227 _topPanel.add(_editmodeCheckBox);
229 // Add zoom in, zoom out buttons
230 _sidePanel = new OverlayPanel();
231 _sidePanel.setLayout(new BoxLayout(_sidePanel, BoxLayout.Y_AXIS));
232 JButton zoomInButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_IN_BUTTON));
233 zoomInButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
234 zoomInButton.setContentAreaFilled(false);
235 zoomInButton.setToolTipText(I18nManager.getText("menu.map.zoomin"));
236 zoomInButton.addActionListener(new ActionListener() {
237 public void actionPerformed(ActionEvent e)
242 zoomInButton.setFocusable(false); // stop button from stealing keyboard focus
243 _sidePanel.add(zoomInButton);
244 JButton zoomOutButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_OUT_BUTTON));
245 zoomOutButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
246 zoomOutButton.setContentAreaFilled(false);
247 zoomOutButton.setToolTipText(I18nManager.getText("menu.map.zoomout"));
248 zoomOutButton.addActionListener(new ActionListener() {
249 public void actionPerformed(ActionEvent e)
254 zoomOutButton.setFocusable(false); // stop button from stealing keyboard focus
255 _sidePanel.add(zoomOutButton);
257 // Bottom panel for scale bar
258 _scaleBar = new ScaleBar();
260 // add control panels to this one
261 setLayout(new BorderLayout());
262 _topPanel.setVisible(false);
263 _sidePanel.setVisible(false);
264 add(_topPanel, BorderLayout.NORTH);
265 add(_sidePanel, BorderLayout.WEST);
266 add(_scaleBar, BorderLayout.SOUTH);
269 // Get currently selected map from Config, pass to MapTileManager
270 _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
271 // Update display settings
272 dataUpdated(MAPSERVER_CHANGED);
277 * Make the popup menu for right-clicking the map
279 private void makePopup()
281 _popup = new JPopupMenu();
282 JMenuItem zoomInItem = new JMenuItem(I18nManager.getText("menu.map.zoomin"));
283 zoomInItem.addActionListener(new ActionListener() {
284 public void actionPerformed(ActionEvent e)
286 panMap((_popupMenuX - getWidth()/2)/2, (_popupMenuY - getHeight()/2)/2);
289 _popup.add(zoomInItem);
290 JMenuItem zoomOutItem = new JMenuItem(I18nManager.getText("menu.map.zoomout"));
291 zoomOutItem.addActionListener(new ActionListener() {
292 public void actionPerformed(ActionEvent e)
294 panMap(-(_popupMenuX - getWidth()/2), -(_popupMenuY - getHeight()/2));
297 _popup.add(zoomOutItem);
298 JMenuItem zoomFullItem = new JMenuItem(I18nManager.getText("menu.map.zoomfull"));
299 zoomFullItem.addActionListener(new ActionListener() {
300 public void actionPerformed(ActionEvent e)
306 _popup.add(zoomFullItem);
307 _popup.addSeparator();
309 JMenuItem setMapBgItem = new JMenuItem(
310 I18nManager.getText(FunctionLibrary.FUNCTION_SET_MAP_BG.getNameKey()));
311 setMapBgItem.addActionListener(new ActionListener() {
312 public void actionPerformed(ActionEvent e)
314 FunctionLibrary.FUNCTION_SET_MAP_BG.begin();
316 _popup.add(setMapBgItem);
318 JMenuItem newPointItem = new JMenuItem(I18nManager.getText("menu.map.newpoint"));
319 newPointItem.addActionListener(new ActionListener() {
320 public void actionPerformed(ActionEvent e)
322 _app.createPoint(createPointFromClick(_popupMenuX, _popupMenuY));
324 _popup.add(newPointItem);
326 JMenuItem drawPointsItem = new JMenuItem(I18nManager.getText("menu.map.drawpoints"));
327 drawPointsItem.addActionListener(new ActionListener() {
328 public void actionPerformed(ActionEvent e)
330 _drawMode = MODE_DRAW_POINTS_START;
333 _popup.add(drawPointsItem);
338 * Zoom to fit the current data area
340 private void zoomToFit()
342 if (_track.getNumPoints() > 0)
344 _latRange = _track.getLatRange();
345 _lonRange = _track.getLonRange();
347 if (_latRange == null || _lonRange == null
348 || !_latRange.hasData() || !_lonRange.hasData())
350 setDefaultLatLonRange();
352 _xRange = new DoubleRange(MapUtils.getXFromLongitude(_lonRange.getMinimum()),
353 MapUtils.getXFromLongitude(_lonRange.getMaximum()));
354 _yRange = new DoubleRange(MapUtils.getYFromLatitude(_latRange.getMinimum()),
355 MapUtils.getYFromLatitude(_latRange.getMaximum()));
356 _mapPosition.zoomToXY(
357 _xRange.getMinimum(), _xRange.getMaximum(),
358 _yRange.getMinimum(), _yRange.getMaximum(),
359 getWidth(), getHeight(),
360 _tileManager.getMaxZoomLevel());
364 * Track data is empty, so find a default area on the map to show
366 private void setDefaultLatLonRange()
368 String storedRange = Config.getConfigString(Config.KEY_LATLON_RANGE);
369 // Parse it into four latlon values
372 String[] values = storedRange.split(";");
373 if (values.length == 4)
375 final double lat1 = Double.valueOf(values[0]);
376 final double lat2 = Double.valueOf(values[1]);
377 if (lat1 >= -90.0 && lat1 <= 90.0 && lat2 >= -90.0 && lat2 <= 90.0 && lat1 != lat2)
379 _latRange = new DoubleRange(lat1, lat2);
380 final double lon1 = Double.valueOf(values[2]);
381 final double lon2 = Double.valueOf(values[3]);
382 if (lon1 >= -180.0 && lon1 <= 180.0 && lon2 >= -180.0 && lon2 <= 180.0 && lon1 != lon2)
384 _lonRange = new DoubleRange(lon1, lon2);
390 catch (Exception e) {}
391 _latRange = new DoubleRange(45.8, 47.9);
392 _lonRange = new DoubleRange(5.9, 10.6);
397 * @see java.awt.Canvas#paint(java.awt.Graphics)
399 public void paint(Graphics inG)
402 if (_mapImage != null && (_mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())) {
405 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
406 final boolean showSomething = _track.getNumPoints() > 0 || showMap;
409 // Check for autopan if enabled / necessary
410 if (_autopanCheckBox.isSelected())
412 int selectedPoint = _selection.getCurrentPointIndex();
413 if (selectedPoint >= 0 && _dragFromX == -1 && selectedPoint != _prevSelectedPoint)
415 autopanToPoint(selectedPoint);
417 _prevSelectedPoint = selectedPoint;
420 // Recognise empty map position, if no data has been loaded
421 if (_mapPosition.isEmpty())
423 // Set to some default area
428 // Draw the map contents if necessary
429 if (_mapImage == null || _recalculate)
432 _scaleBar.updateScale(_mapPosition.getZoom(), _mapPosition.getYFromPixels(0, 0));
434 // Draw the prepared image onto the panel
435 if (_mapImage != null) {
436 inG.drawImage(_mapImage, 0, 0, getWidth(), getHeight(), null);
441 case MODE_DRAG_POINT:
442 drawDragLines(inG, _selection.getCurrentPointIndex()-1, _selection.getCurrentPointIndex()+1);
445 case MODE_CREATE_MIDPOINT:
446 drawDragLines(inG, _clickedPoint-1, _clickedPoint);
450 case MODE_MARK_RECTANGLE:
451 if (_dragFromX != -1 && _dragFromY != -1)
453 // Draw the zoom rectangle if necessary
454 inG.setColor(Color.RED);
455 inG.drawLine(_dragFromX, _dragFromY, _dragFromX, _dragToY);
456 inG.drawLine(_dragFromX, _dragFromY, _dragToX, _dragFromY);
457 inG.drawLine(_dragToX, _dragFromY, _dragToX, _dragToY);
458 inG.drawLine(_dragFromX, _dragToY, _dragToX, _dragToY);
462 case MODE_DRAW_POINTS_CONT:
463 // draw line to mouse position to show drawing mode
464 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
465 int prevIndex = _track.getNumPoints()-1;
466 int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(prevIndex));
467 int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(prevIndex));
468 inG.drawLine(px, py, _dragToX, _dragToY);
474 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
475 inG.fillRect(0, 0, getWidth(), getHeight());
476 inG.setColor(COLOR_MESSAGES);
477 inG.drawString(I18nManager.getText("display.nodata"), 50, getHeight()/2);
478 _scaleBar.updateScale(-1, 0);
480 // enable or disable panels
481 _topPanel.setVisible(showSomething);
482 _sidePanel.setVisible(showSomething);
483 // Draw slider etc on top
488 * @return true if the currently selected point is visible, false if off-screen or nothing selected
490 private boolean isCurrentPointVisible()
492 if (_trackInfo.getCurrentPoint() == null) {return false;}
493 final int selectedPoint = _selection.getCurrentPointIndex();
494 final int xFromCentre = Math.abs(_mapPosition.getXFromCentre(_track.getX(selectedPoint)));
495 if (xFromCentre > (getWidth()/2)) {return false;}
496 final int yFromCentre = Math.abs(_mapPosition.getYFromCentre(_track.getY(selectedPoint)));
497 return yFromCentre < (getHeight()/2);
501 * If the specified point isn't visible, pan to it
502 * @param inIndex index of selected point
504 private void autopanToPoint(int inIndex)
506 int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inIndex));
507 int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inIndex));
510 if (px < PAN_DISTANCE) {
511 panX = px - AUTOPAN_DISTANCE;
513 else if (px > (getWidth()-PAN_DISTANCE)) {
514 panX = AUTOPAN_DISTANCE + px - getWidth();
516 if (py < (2*PAN_DISTANCE)) {
517 panY = py - AUTOPAN_DISTANCE;
519 if (py > (getHeight()-PAN_DISTANCE)) {
520 panY = AUTOPAN_DISTANCE + py - getHeight();
522 if (panX != 0 || panY != 0) {
523 _mapPosition.pan(panX, panY);
528 * Paint the map tiles and the points on to the _mapImage
530 private void paintMapContents()
532 if (_mapImage == null || _mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())
534 _mapImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
537 Graphics g = _mapImage.getGraphics();
538 // Set antialiasing according to config
539 ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
540 Config.getConfigBoolean(Config.KEY_ANTIALIAS) ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
541 // Clear to background
542 g.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
543 g.fillRect(0, 0, getWidth(), getHeight());
545 // Check whether maps are on or not
546 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
547 _mapCheckBox.setSelected(showMap);
548 // Check whether disk cache is on or not
549 final boolean usingDiskCache = Config.getConfigString(Config.KEY_DISK_CACHE) != null;
550 // Show tip to recommend setting up a cache
551 if (showMap && !usingDiskCache && Config.getConfigBoolean(Config.KEY_ONLINE_MODE))
553 SwingUtilities.invokeLater(new Runnable() {
555 _app.showTip(TipManager.Tip_UseAMapCache);
560 // reset error message
561 if (!showMap) {_shownMapLoadErrorAlready = false;}
562 _recalculate = false;
563 // Only get map tiles if selected
567 _tileManager.centreMap(_mapPosition.getZoom(), _mapPosition.getCentreTileX(), _mapPosition.getCentreTileY());
569 boolean loadingFailed = false;
570 if (_mapImage == null) return;
572 if (_tileManager.isOverzoomed())
574 // display overzoom message
575 g.setColor(COLOR_MESSAGES);
576 g.drawString(I18nManager.getText("map.overzoom"), 50, getHeight()/2);
580 int numLayers = _tileManager.getNumLayers();
581 // Loop over tiles drawing each one
582 int[] tileIndices = _mapPosition.getTileIndices(getWidth(), getHeight());
583 int[] pixelOffsets = _mapPosition.getDisplayOffsets(getWidth(), getHeight());
584 for (int tileX = tileIndices[0]; tileX <= tileIndices[1] && !loadingFailed; tileX++)
586 int x = (tileX - tileIndices[0]) * 256 - pixelOffsets[0];
587 for (int tileY = tileIndices[2]; tileY <= tileIndices[3]; tileY++)
589 int y = (tileY - tileIndices[2]) * 256 - pixelOffsets[1];
591 for (int l=0; l<numLayers; l++)
593 Image image = _tileManager.getTile(l, tileX, tileY, true);
595 g.drawImage(image, x, y, 256, 256, null);
601 // Make maps brighter / fainter according to slider
602 final int brightnessIndex = Math.max(1, _transparencySlider.getValue()) - 1;
603 if (brightnessIndex > 0)
605 final int[] alphas = {0, 40, 80, 120, 160, 210};
606 Color bgColor = Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND);
607 bgColor = new Color(bgColor.getRed(), bgColor.getGreen(), bgColor.getBlue(), alphas[brightnessIndex]);
609 g.fillRect(0, 0, getWidth(), getHeight());
614 // Work out track opacity according to slider
615 final float[] opacities = {1.0f, 0.75f, 0.5f, 0.3f, 0.15f, 0.0f};
616 float trackOpacity = 1.0f;
617 if (_transparencySlider.getValue() < 0) {
618 trackOpacity = opacities[-1 - _transparencySlider.getValue()];
621 if (trackOpacity > 0.0f)
623 // Paint the track points on top
624 boolean pointsPainted = true;
627 if (trackOpacity > 0.9f)
629 // Track is fully opaque, just draw it directly
630 pointsPainted = paintPoints(g);
635 // Track is partly transparent, so use a separate BufferedImage
636 if (_trackImage == null || _trackImage.getWidth() != getWidth() || _trackImage.getHeight() != getHeight())
638 _trackImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
640 // Clear to transparent
641 Graphics2D gTrack = _trackImage.createGraphics();
642 gTrack.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
643 gTrack.fillRect(0, 0, getWidth(), getHeight());
644 gTrack.setPaintMode();
645 // Draw the track onto this separate image
646 pointsPainted = paintPoints(gTrack);
647 ((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trackOpacity));
648 g.drawImage(_trackImage, 0, 0, null);
651 catch (NullPointerException npe) {} // ignore, probably due to data being changed during drawing
652 catch (ArrayIndexOutOfBoundsException obe) {} // also ignore
654 // Zoom to fit if no points found
655 if (!pointsPainted && _checkBounds)
666 _checkBounds = false;
667 // enable / disable transparency slider
668 _transparencySlider.setEnabled(showMap);
673 * Paint the points using the given graphics object
674 * @param inG Graphics object to use for painting
675 * @return true if any points or lines painted
677 private boolean paintPoints(Graphics inG)
680 final ColourScheme cs = Config.getColourScheme();
681 final Color pointColour = cs.getColour(ColourScheme.IDX_POINT);
682 final Color rangeColour = cs.getColour(ColourScheme.IDX_SELECTION);
683 final Color currentColour = cs.getColour(ColourScheme.IDX_PRIMARY);
684 final Color secondColour = cs.getColour(ColourScheme.IDX_SECONDARY);
685 final Color textColour = cs.getColour(ColourScheme.IDX_TEXT);
686 final PointColourer pointColourer = _app.getPointColourer();
688 final int winWidth = getWidth();
689 final int winHeight = getHeight();
690 final int halfWinWidth = winWidth / 2;
691 final int halfWinHeight = winHeight / 2;
693 final int numPoints = _track.getNumPoints();
694 final int[] xPixels = new int[numPoints];
695 final int[] yPixels = new int[numPoints];
697 final int pointSeparationForArrowsSqd = 400;
698 final int pointSeparation1dForArrows = (int) (Math.sqrt(pointSeparationForArrowsSqd) * 0.7);
699 final int hugePointSeparationForArrows = 120;
701 // try to set line width for painting
702 if (inG instanceof Graphics2D)
704 int lineWidth = Config.getConfigInt(Config.KEY_LINE_WIDTH);
705 if (lineWidth < 1 || lineWidth > 4) {lineWidth = 2;}
706 ((Graphics2D) inG).setStroke(new BasicStroke(lineWidth));
709 boolean pointsPainted = false;
711 inG.setColor(pointColour);
712 int prevX = -1, prevY = -1;
713 final int connectState = _connectCheckBox.getCurrentState();
714 final boolean drawLines = (connectState != 3); // 0, 1 or 2
715 final boolean drawPoints = (connectState != 1); // 0, 2 or 3
716 final boolean drawArrows = (connectState == 0); // 0
718 boolean prevPointVisible = false, currPointVisible = false;
719 boolean anyWaypoints = false;
720 boolean isWaypoint = false;
721 boolean drawnLastArrow = false; // avoid painting arrows on adjacent lines, looks too busy
722 for (int i=0; i<numPoints; i++)
724 // Calculate pixel position of point from its x, y coordinates
725 int px = halfWinWidth + _mapPosition.getXFromCentre(_track.getX(i));
726 int py = halfWinHeight + _mapPosition.getYFromCentre(_track.getY(i));
727 px = wrapLongitudeValue(px, winWidth, _mapPosition.getZoom());
728 // Remember these calculated pixel values so they don't have to be recalculated
729 xPixels[i] = px; yPixels[i] = py;
731 currPointVisible = px >= 0 && px < winWidth && py >= 0 && py < winHeight;
732 isWaypoint = _track.getPoint(i).isWaypoint();
733 anyWaypoints = anyWaypoints || isWaypoint;
736 if (currPointVisible || (drawLines && prevPointVisible))
738 // For track points, work out which colour to use
739 if (_track.getPoint(i).getDeleteFlag()) {
740 inG.setColor(currentColour);
742 else if (pointColourer != null)
743 { // use the point colourer if there is one
744 Color trackColour = pointColourer.getColour(i);
745 inG.setColor(trackColour);
749 inG.setColor(pointColour);
752 // Draw rectangle for track point if it's visible
753 if (currPointVisible)
756 inG.drawRect(px-2, py-2, 3, 3);
758 pointsPainted = true;
762 // Connect track points if either of them are visible
764 && (currPointVisible || prevPointVisible)
765 && !(prevX == -1 && prevY == -1)
766 && !_track.getPoint(i).getSegmentStart())
768 inG.drawLine(prevX, prevY, px, py);
769 pointsPainted = true;
771 // Now consider whether we need to draw an arrow as well
774 final double pointDist = Math.max(Math.abs(prevX - px), Math.abs(prevY - py));
775 final int separationLimit = (drawnLastArrow ? hugePointSeparationForArrows : pointSeparation1dForArrows);
776 if (pointDist > separationLimit)
778 final double pointSeparationSqd = (prevX-px) * (prevX-px) + (prevY-py) * (prevY-py);
779 if (pointSeparationSqd > pointSeparationForArrowsSqd)
781 final double midX = (prevX + px) / 2.0;
782 final double midY = (prevY + py) / 2.0;
783 final boolean midPointVisible = midX >= 0 && midX < winWidth && midY >= 0 && midY < winHeight;
786 final double alpha = Math.atan2(py - prevY, px - prevX);
787 //System.out.println("Draw arrow from (" + prevX + "," + prevY + ") to (" + px + "," + py
788 // + ") with angle" + (int) (alpha * 180/Math.PI));
789 final double MID_TO_VERTEX = 3.0;
790 final double arrowX = MID_TO_VERTEX * Math.cos(alpha);
791 final double arrowY = MID_TO_VERTEX * Math.sin(alpha);
792 final double vertexX = midX + arrowX;
793 final double vertexY = midY + arrowY;
794 inG.drawLine((int)(midX-arrowX-2*arrowY), (int)(midY-arrowY+2*arrowX), (int)vertexX, (int)vertexY);
795 inG.drawLine((int)(midX-arrowX+2*arrowY), (int)(midY-arrowY-2*arrowX), (int)vertexX, (int)vertexY);
797 drawnLastArrow = midPointVisible;
802 drawnLastArrow = false;
806 prevX = px; prevY = py;
808 prevPointVisible = currPointVisible;
811 // Loop over points, just drawing blobs for waypoints
812 inG.setColor(textColour);
813 FontMetrics fm = inG.getFontMetrics();
814 int nameHeight = fm.getHeight();
817 int numWaypoints = 0;
818 for (int i=0; i<_track.getNumPoints(); i++)
820 if (_track.getPoint(i).isWaypoint())
824 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
826 if (_waypointIconDefinition == null)
828 inG.fillRect(px-3, py-3, 6, 6);
832 ImageIcon icon = _waypointIconDefinition.getImageIcon();
835 inG.drawImage(icon.getImage(), px-_waypointIconDefinition.getXOffset(),
836 py-_waypointIconDefinition.getYOffset(), null);
839 pointsPainted = true;
844 // Take more care with waypoint names if less than 100 are visible
845 final int numNameSteps = (numWaypoints > 100 ? 1 : 4);
846 final int numPointSteps = (numWaypoints > 1000 ? 2 : 1);
848 // Loop over points again, now draw names for waypoints
849 int[] nameXs = {0, 0, 0, 0};
850 int[] nameYs = {0, 0, 0, 0};
851 for (int i=0; i<_track.getNumPoints(); i += numPointSteps)
853 if (_track.getPoint(i).isWaypoint())
857 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
859 // Figure out where to draw waypoint name so it doesn't obscure track
860 String waypointName = _track.getPoint(i).getWaypointName();
861 int nameWidth = fm.stringWidth(waypointName);
862 boolean drawnName = false;
863 // Make arrays for coordinates right left up down
864 nameXs[0] = px + 2; nameXs[1] = px - nameWidth - 2;
865 nameXs[2] = nameXs[3] = px - nameWidth/2;
866 nameYs[0] = nameYs[1] = py + (nameHeight/2);
867 nameYs[2] = py - 2; nameYs[3] = py + nameHeight + 2;
868 for (int extraSpace = 0; extraSpace < numNameSteps && !drawnName; extraSpace++)
870 // Shift arrays for coordinates right left up down
871 nameXs[0] += 3; nameXs[1] -= 3;
872 nameYs[2] -= 3; nameYs[3] += 3;
873 // Check each direction in turn right left up down
874 for (int a=0; a<4; a++)
876 if (nameXs[a] > 0 && (nameXs[a] + nameWidth) < winWidth
877 && nameYs[a] < winHeight && (nameYs[a] - nameHeight) > 0
878 && !MapUtils.overlapsPoints(_mapImage, nameXs[a], nameYs[a], nameWidth, nameHeight, textColour))
880 // Found a rectangle to fit - draw name here and quit
881 inG.drawString(waypointName, nameXs[a], nameYs[a]);
891 // Loop over points, drawing blobs for photo / audio points
892 inG.setColor(secondColour);
893 for (int i=0; i<_track.getNumPoints(); i++)
895 if (_track.getPoint(i).hasMedia())
899 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
901 inG.drawRect(px-1, py-1, 2, 2);
902 inG.drawRect(px-2, py-2, 4, 4);
903 pointsPainted = true;
908 // Draw selected range
909 if (_selection.hasRangeSelected())
911 inG.setColor(rangeColour);
912 for (int i=_selection.getStart(); i<=_selection.getEnd(); i++)
916 inG.drawRect(px-1, py-1, 2, 2);
920 // Draw crosshairs at selected point
921 int selectedPoint = _selection.getCurrentPointIndex();
922 if (selectedPoint >= 0)
924 int px = xPixels[selectedPoint];
925 int py = yPixels[selectedPoint];
926 inG.setColor(currentColour);
928 inG.drawLine(px, 0, px, winHeight);
929 inG.drawLine(0, py, winWidth, py);
931 // Return the number of points painted
932 return pointsPainted;
936 * Wrap the given pixel value if appropriate and possible
937 * @param inPx Pixel x coordinate
938 * @param inWinWidth window width in pixels
939 * @param inZoom zoom level
940 * @return modified pixel x coordinate
942 private static int wrapLongitudeValue(int inPx, int inWinWidth, int inZoom)
944 if (inPx > inWinWidth)
946 // Pixel is too far right, could we wrap it back onto the screen?
948 while (px > inWinWidth) {
949 px -= (256 << inZoom);
952 return px; // successfully wrapped back onto the screen
957 // Pixel is too far left, could we wrap it back onto the screen?
960 px += (256 << inZoom);
962 if (px < inWinWidth) {
963 return px; // successfully wrapped back onto the screen
966 // Either it's already on the screen or couldn't be wrapped
971 * Draw the lines while dragging a point
972 * @param inG graphics object
973 * @param inPrevIndex index of point to draw from
974 * @param inNextIndex index of point to draw to
976 private void drawDragLines(Graphics inG, int inPrevIndex, int inNextIndex)
978 inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
979 // line from prev point to cursor
980 if (inPrevIndex > -1 && !_track.getPoint(inPrevIndex+1).getSegmentStart())
982 final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inPrevIndex));
983 final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inPrevIndex));
984 inG.drawLine(px, py, _dragToX, _dragToY);
986 if (inNextIndex < _track.getNumPoints() && !_track.getPoint(inNextIndex).getSegmentStart())
988 final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inNextIndex));
989 final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inNextIndex));
990 inG.drawLine(px, py, _dragToX, _dragToY);
995 * Inform that tiles have been updated and the map can be repainted
996 * @param inIsOk true if data loaded ok, false for error
998 public void tilesUpdated(boolean inIsOk)
1002 // Show message if loading failed (but not too many times)
1003 if (!inIsOk && !_shownMapLoadErrorAlready && _mapCheckBox.isSelected())
1005 _shownMapLoadErrorAlready = true;
1006 // use separate thread to show message about failing to load osm images
1007 new Thread(new Runnable() {
1009 try {Thread.sleep(500);} catch (InterruptedException ie) {}
1010 _app.showErrorMessage("error.osmimage.dialogtitle", "error.osmimage.failed");
1014 _recalculate = true;
1020 * Inform that a cache failure occurred
1022 public void reportCacheFailure()
1024 // Cache can't be used, so disable it - user will be reminded to set it up by the tips
1025 Config.setConfigString(Config.KEY_DISK_CACHE, null);
1029 * Zoom out, if not already at minimum zoom
1031 public void zoomOut()
1033 _mapPosition.zoomOut();
1034 _recalculate = true;
1039 * Zoom in, if not already at maximum zoom
1041 public void zoomIn()
1043 // See if selected point is currently visible, if so (and autopan on) then autopan after zoom to keep it visible
1044 boolean wasVisible = _autopanCheckBox.isSelected() && isCurrentPointVisible();
1045 _mapPosition.zoomIn();
1046 if (wasVisible && !isCurrentPointVisible()) {
1047 autopanToPoint(_selection.getCurrentPointIndex());
1049 _recalculate = true;
1055 * @param inDeltaX x shift
1056 * @param inDeltaY y shift
1058 public void panMap(int inDeltaX, int inDeltaY)
1060 _mapPosition.pan(inDeltaX, inDeltaY);
1061 _recalculate = true;
1066 * Create a DataPoint object from the given click coordinates
1067 * @param inX x coordinate of click
1068 * @param inY y coordinate of click
1069 * @return DataPoint with given coordinates and no altitude
1071 private DataPoint createPointFromClick(int inX, int inY)
1073 double lat = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(inY, getHeight()));
1074 double lon = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(inX, getWidth()));
1075 return new DataPoint(new Latitude(lat, Coordinate.FORMAT_NONE),
1076 new Longitude(lon, Coordinate.FORMAT_NONE), null);
1080 * Move a DataPoint object to the given mouse coordinates
1081 * @param startX start x coordinate of mouse
1082 * @param startY start y coordinate of mouse
1083 * @param endX end x coordinate of mouse
1084 * @param endY end y coordinate of mouse
1086 private void movePointToMouse(int startX, int startY, int endX, int endY )
1088 double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(startY, getHeight()));
1089 double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(startX, getWidth()));
1090 double lat_delta = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(endY, getHeight())) - lat1;
1091 double lon_delta = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(endX, getWidth())) - lon1;
1093 DataPoint point = _trackInfo.getCurrentPoint();
1094 if (point == null) {
1098 // Make lists for edit and undo, and add each changed field in turn
1099 FieldEditList editList = new FieldEditList();
1100 FieldEditList undoList = new FieldEditList();
1103 FieldList fieldList = _track.getFieldList();
1104 int numFields = fieldList.getNumFields();
1105 for (int i=0; i<numFields; i++)
1107 Field field = fieldList.getField(i);
1108 if (field == Field.LATITUDE) {
1109 editList.addEdit(new FieldEdit(field, Double.toString(point.getLatitude().getDouble() + lat_delta)));
1110 undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LATITUDE)));
1112 else if (field == Field.LONGITUDE) {
1113 editList.addEdit(new FieldEdit(field, Double.toString(point.getLongitude().getDouble() + lon_delta)));
1114 undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LONGITUDE)));
1117 _app.completePointEdit(editList, undoList);
1122 * @see javax.swing.JComponent#getMinimumSize()
1124 public Dimension getMinimumSize()
1126 final Dimension minSize = new Dimension(512, 300);
1131 * @see javax.swing.JComponent#getPreferredSize()
1133 public Dimension getPreferredSize()
1135 return getMinimumSize();
1140 * Respond to mouse click events
1141 * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
1143 public void mouseClicked(MouseEvent inE)
1145 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
1146 final boolean hasPoints = _track != null && _track.getNumPoints() > 0;
1147 if (showMap || hasPoints)
1149 // select point if it's a left-click
1150 if (!inE.isMetaDown())
1152 if (inE.getClickCount() == 1)
1154 // single left click
1155 if (_drawMode == MODE_DEFAULT && hasPoints)
1157 int pointIndex = _clickedPoint;
1158 if (pointIndex == INDEX_UNKNOWN)
1160 // index hasn't been calculated yet
1161 pointIndex = _track.getNearestPointIndex(
1162 _mapPosition.getXFromPixels(inE.getX(), getWidth()),
1163 _mapPosition.getYFromPixels(inE.getY(), getHeight()),
1164 _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY), false);
1166 // Extend selection for shift-click
1167 if (inE.isShiftDown()) {
1168 _trackInfo.extendSelection(pointIndex);
1171 _trackInfo.selectPoint(pointIndex);
1174 else if (_drawMode == MODE_DRAW_POINTS_START)
1176 _app.createPoint(createPointFromClick(inE.getX(), inE.getY()));
1177 _dragToX = inE.getX();
1178 _dragToY = inE.getY();
1179 _drawMode = MODE_DRAW_POINTS_CONT;
1181 else if (_drawMode == MODE_DRAW_POINTS_CONT)
1183 DataPoint point = createPointFromClick(inE.getX(), inE.getY());
1184 _app.createPoint(point, false); // not a new segment
1187 else if (inE.getClickCount() == 2)
1190 if (_drawMode == MODE_DEFAULT) {
1191 panMap(inE.getX() - getWidth()/2, inE.getY() - getHeight()/2);
1194 else if (_drawMode == MODE_DRAW_POINTS_START || _drawMode == MODE_DRAW_POINTS_CONT) {
1195 _drawMode = MODE_DEFAULT;
1201 // show the popup menu for right-clicks
1202 _popupMenuX = inE.getX();
1203 _popupMenuY = inE.getY();
1204 _popup.show(this, _popupMenuX, _popupMenuY);
1208 _app.setCurrentMode(App.AppMode.NORMAL);
1209 if (_drawMode == MODE_MARK_RECTANGLE) _drawMode = MODE_DEFAULT;
1213 * Ignore mouse enter events
1214 * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
1216 public void mouseEntered(MouseEvent inE)
1222 * Ignore mouse exited events
1223 * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
1225 public void mouseExited(MouseEvent inE)
1231 * React to mouse pressed events to initiate a point drag
1232 * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
1234 public void mousePressed(MouseEvent inE)
1236 _clickedPoint = INDEX_UNKNOWN;
1237 if (_track == null || _track.getNumPoints() <= 0)
1239 if (!inE.isMetaDown())
1241 // Left mouse drag - check if point is near; if so select it for dragging
1242 if (_drawMode == MODE_DEFAULT)
1244 /* Drag points if edit mode is enabled OR ALT is pressed */
1245 if (_editmodeCheckBox.isSelected() || inE.isAltDown() || inE.isAltGraphDown())
1247 final double clickX = _mapPosition.getXFromPixels(inE.getX(), getWidth());
1248 final double clickY = _mapPosition.getYFromPixels(inE.getY(), getHeight());
1249 final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
1250 _clickedPoint = _track.getNearestPointIndex(clickX, clickY, clickSens, false);
1252 if (_clickedPoint >= 0)
1254 // TODO: maybe use another color of the cross or remove the cross while dragging???
1256 _trackInfo.selectPoint(_clickedPoint);
1257 if (_trackInfo.getCurrentPoint() != null)
1259 _drawMode = MODE_DRAG_POINT;
1260 _dragFromX = _dragToX = inE.getX();
1261 _dragFromY = _dragToY = inE.getY();
1266 // Not a click on a point, so check half-way between two (connected) trackpoints
1267 int midpointIndex = _midpoints.getNearestPointIndex(clickX, clickY, clickSens);
1268 if (midpointIndex > 0)
1270 _drawMode = MODE_CREATE_MIDPOINT;
1271 _clickedPoint = midpointIndex;
1272 _dragFromX = _dragToX = inE.getX();
1273 _dragFromY = _dragToY = inE.getY();
1279 // else right-press ignored
1283 * Respond to mouse released events
1284 * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
1286 public void mouseReleased(MouseEvent inE)
1288 _recalculate = true;
1290 if (_drawMode == MODE_DRAG_POINT)
1292 if (Math.abs(_dragToX - _dragFromX) > 2
1293 || Math.abs(_dragToY - _dragFromY) > 2)
1295 movePointToMouse(_dragFromX, _dragFromY, _dragToX, _dragToY );
1297 _drawMode = MODE_DEFAULT;
1299 else if (_drawMode == MODE_CREATE_MIDPOINT)
1301 _drawMode = MODE_DEFAULT;
1302 _app.createPoint(createPointFromClick(_dragToX, _dragToY), _clickedPoint);
1304 else if (_drawMode == MODE_ZOOM_RECT)
1306 if (Math.abs(_dragToX - _dragFromX) > 20
1307 && Math.abs(_dragToY - _dragFromY) > 20)
1309 _mapPosition.zoomToPixels(_dragFromX, _dragToX, _dragFromY, _dragToY, getWidth(), getHeight());
1311 _drawMode = MODE_DEFAULT;
1313 else if (_drawMode == MODE_MARK_RECTANGLE)
1316 _app.setCurrentMode(App.AppMode.NORMAL);
1317 _drawMode = MODE_DEFAULT;
1318 // Call a function to mark the points
1319 MarkPointsInRectangleFunction marker = (MarkPointsInRectangleFunction) FunctionLibrary.FUNCTION_MARK_IN_RECTANGLE;
1320 double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragFromX, getWidth()));
1321 double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragFromY, getHeight()));
1322 double lon2 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragToX, getWidth()));
1323 double lat2 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragToY, getHeight()));
1324 // Invalidate rectangle if pixel coords are (-1,-1)
1325 if (_dragFromX < 0 || _dragFromY < 0) {
1329 marker.setRectCoords(lon1, lat1, lon2, lat2);
1332 _dragFromX = _dragFromY = -1;
1337 * Respond to mouse drag events
1338 * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
1340 public void mouseDragged(MouseEvent inE)
1342 // Note: One would expect inE.isMetaDown() to give information about whether this is a
1343 // drag with the right mouse button or not - but since java 9 this is buggy,
1344 // so we use the beautifully-named getModifiersEx() instead.
1345 // And logically BUTTON3 refers to the secondary mouse button, not the tertiary one!
1346 final boolean isRightDrag = (inE.getModifiersEx() & InputEvent.BUTTON3_DOWN_MASK) > 0;
1349 // Right-click and drag - update rectangle
1350 _drawMode = MODE_ZOOM_RECT;
1351 if (_dragFromX == -1) {
1352 _dragFromX = inE.getX();
1353 _dragFromY = inE.getY();
1355 _dragToX = inE.getX();
1356 _dragToY = inE.getY();
1361 // Left mouse drag - decide whether to drag the point, drag the
1362 // marking rectangle or pan the map
1363 if (_drawMode == MODE_DRAG_POINT || _drawMode == MODE_CREATE_MIDPOINT)
1366 _dragToX = inE.getX();
1367 _dragToY = inE.getY();
1368 _recalculate = true;
1371 else if (_drawMode == MODE_MARK_RECTANGLE)
1373 // draw a rectangle for marking points
1374 if (_dragFromX == -1) {
1375 _dragFromX = inE.getX();
1376 _dragFromY = inE.getY();
1378 _dragToX = inE.getX();
1379 _dragToY = inE.getY();
1384 // regular left-drag pans map by appropriate amount
1385 if (_dragFromX != -1)
1387 panMap(_dragFromX - inE.getX(), _dragFromY - inE.getY());
1389 _dragFromX = _dragToX = inE.getX();
1390 _dragFromY = _dragToY = inE.getY();
1396 * Respond to mouse move events without button pressed
1397 * @param inEvent ignored
1399 public void mouseMoved(MouseEvent inEvent)
1401 boolean useCrosshairs = false;
1402 boolean useResize = false;
1403 // Ignore unless we're drawing points
1404 if (_drawMode == MODE_DRAW_POINTS_CONT)
1406 _dragToX = inEvent.getX();
1407 _dragToY = inEvent.getY();
1410 else if (_drawMode == MODE_MARK_RECTANGLE) {
1413 else if (_editmodeCheckBox.isSelected() || inEvent.isAltDown() || inEvent.isAltGraphDown())
1415 // Try to find a point or a midpoint at this location, and if there is one
1416 // then change the cursor to crosshairs
1417 final double clickX = _mapPosition.getXFromPixels(inEvent.getX(), getWidth());
1418 final double clickY = _mapPosition.getYFromPixels(inEvent.getY(), getHeight());
1419 final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
1420 useCrosshairs = (_track.getNearestPointIndex(clickX, clickY, clickSens, false) >= 0
1421 || _midpoints.getNearestPointIndex(clickX, clickY, clickSens) >= 0
1424 if (useCrosshairs && !isCursorSet()) {
1425 setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
1427 else if (useResize && !isCursorSet()) {
1428 setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1430 else if (!useCrosshairs && !useResize && isCursorSet()) {
1436 * Respond to status bar message from broker
1437 * @param inMessage message, ignored
1439 public void actionCompleted(String inMessage)
1445 * Respond to data updated message from broker
1446 * @param inUpdateType type of update
1448 public void dataUpdated(byte inUpdateType)
1450 _recalculate = true;
1451 if ((inUpdateType & DataSubscriber.DATA_ADDED_OR_REMOVED) > 0) {
1452 _checkBounds = true;
1454 if ((inUpdateType & DataSubscriber.MAPSERVER_CHANGED) > 0)
1456 // Get the selected map source index and pass to tile manager
1457 _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
1458 final int wpType = Config.getConfigInt(Config.KEY_WAYPOINT_ICONS);
1459 if (wpType == WpIconLibrary.WAYPT_DEFAULT)
1461 _waypointIconDefinition = null;
1465 final int wpSize = Config.getConfigInt(Config.KEY_WAYPOINT_ICON_SIZE);
1466 _waypointIconDefinition = WpIconLibrary.getIconDefinition(wpType, wpSize);
1469 if ((inUpdateType & (DataSubscriber.DATA_ADDED_OR_REMOVED + DataSubscriber.DATA_EDITED)) > 0) {
1470 _midpoints.updateData(_track);
1472 // See if rect mode has been activated
1473 if (_app.getCurrentMode() == App.AppMode.DRAWRECT)
1475 _drawMode = MODE_MARK_RECTANGLE;
1476 if (!isCursorSet()) {
1477 setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1481 // grab focus for the key presses
1482 this.requestFocus();
1486 * Respond to key presses on the map canvas
1487 * @param inE key event
1489 public void keyPressed(KeyEvent inE)
1491 int code = inE.getKeyCode();
1492 int currPointIndex = _selection.getCurrentPointIndex();
1493 // Check for Ctrl key (for Linux/Win) or meta key (Clover key for Mac)
1494 if (inE.isControlDown() || inE.isMetaDown())
1496 // Shift as well makes things faster
1497 final int pointIncrement = inE.isShiftDown()?3:1;
1498 // Check for arrow keys to zoom in and out
1499 if (code == KeyEvent.VK_UP)
1501 else if (code == KeyEvent.VK_DOWN)
1503 // Key nav for next/prev point
1504 else if (code == KeyEvent.VK_LEFT && currPointIndex > 0)
1505 _trackInfo.incrementPointIndex(-pointIncrement);
1506 else if (code == KeyEvent.VK_RIGHT)
1507 _trackInfo.incrementPointIndex(pointIncrement);
1508 else if (code == KeyEvent.VK_PAGE_UP)
1509 _trackInfo.selectPoint(Checker.getPreviousSegmentStart(
1510 _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
1511 else if (code == KeyEvent.VK_PAGE_DOWN)
1512 _trackInfo.selectPoint(Checker.getNextSegmentStart(
1513 _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
1514 // Check for home and end
1515 else if (code == KeyEvent.VK_HOME)
1516 _trackInfo.selectPoint(0);
1517 else if (code == KeyEvent.VK_END)
1518 _trackInfo.selectPoint(_trackInfo.getTrack().getNumPoints()-1);
1522 // Check for arrow keys to pan
1524 if (code == KeyEvent.VK_UP)
1525 upwardsPan = -PAN_DISTANCE;
1526 else if (code == KeyEvent.VK_DOWN)
1527 upwardsPan = PAN_DISTANCE;
1528 int rightwardsPan = 0;
1529 if (code == KeyEvent.VK_RIGHT)
1530 rightwardsPan = PAN_DISTANCE;
1531 else if (code == KeyEvent.VK_LEFT)
1532 rightwardsPan = -PAN_DISTANCE;
1533 panMap(rightwardsPan, upwardsPan);
1535 if (code == KeyEvent.VK_ESCAPE)
1536 _drawMode = MODE_DEFAULT;
1537 // Check for backspace key to delete current point (delete key already handled by menu)
1538 else if (code == KeyEvent.VK_BACK_SPACE && currPointIndex >= 0) {
1539 _app.deleteCurrentPoint();
1545 * @param inE key released event, ignored
1547 public void keyReleased(KeyEvent e)
1553 * @param inE key typed event, ignored
1555 public void keyTyped(KeyEvent inE)
1561 * @param inE mouse wheel event indicating scroll direction
1563 public void mouseWheelMoved(MouseWheelEvent inE)
1565 int clicks = inE.getWheelRotation();
1567 panMap((inE.getX() - getWidth()/2)/2, (inE.getY() - getHeight()/2)/2);
1570 else if (clicks > 0) {
1571 panMap(-(inE.getX() - getWidth()/2), -(inE.getY() - getHeight()/2));
1577 * @return current map position
1579 public MapPosition getMapPosition()
1581 return _mapPosition;