package tim.prune.gui.map;
+import java.awt.AlphaComposite;
+import java.awt.BasicStroke;
import java.awt.BorderLayout;
import java.awt.Color;
+import java.awt.Cursor;
import java.awt.Dimension;
import java.awt.FlowLayout;
import java.awt.FontMetrics;
import java.awt.Graphics;
+import java.awt.Graphics2D;
import java.awt.Image;
import java.awt.RenderingHints;
import java.awt.event.ActionEvent;
import java.awt.event.MouseWheelEvent;
import java.awt.event.MouseWheelListener;
import java.awt.image.BufferedImage;
-import java.awt.image.RescaleOp;
import javax.swing.BorderFactory;
import javax.swing.BoxLayout;
import javax.swing.JPanel;
import javax.swing.JPopupMenu;
import javax.swing.JSlider;
+import javax.swing.SwingUtilities;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import tim.prune.DataSubscriber;
import tim.prune.FunctionLibrary;
import tim.prune.I18nManager;
+import tim.prune.UpdateMessageBroker;
+import tim.prune.config.ColourScheme;
+import tim.prune.config.Config;
+import tim.prune.data.Checker;
+import tim.prune.data.Coordinate;
+import tim.prune.data.DataPoint;
import tim.prune.data.DoubleRange;
+import tim.prune.data.Field;
+import tim.prune.data.FieldList;
+import tim.prune.data.Latitude;
+import tim.prune.data.Longitude;
+import tim.prune.data.MidpointData;
import tim.prune.data.Selection;
import tim.prune.data.Track;
import tim.prune.data.TrackInfo;
+import tim.prune.function.compress.MarkPointsInRectangleFunction;
+import tim.prune.function.edit.FieldEdit;
+import tim.prune.function.edit.FieldEditList;
import tim.prune.gui.IconManager;
+import tim.prune.gui.TripleStateCheckBox;
+import tim.prune.gui.colour.PointColourer;
+import tim.prune.tips.TipManager;
/**
* Class for the map canvas, to display a background map and draw on it
*/
public class MapCanvas extends JPanel implements MouseListener, MouseMotionListener, DataSubscriber,
- KeyListener, MouseWheelListener
+ KeyListener, MouseWheelListener, TileConsumer
{
/** App object for callbacks */
private App _app = null;
private TrackInfo _trackInfo = null;
/** Selection object */
private Selection _selection = null;
+ /** Object to keep track of midpoints */
+ private MidpointData _midpoints = null;
+ /** Index of point clicked at mouseDown */
+ private int _clickedPoint = -1;
/** Previously selected point */
private int _prevSelectedPoint = -1;
- /** Tile cacher */
- private MapTileCacher _tileCacher = new MapTileCacher(this);
+ /** Tile manager */
+ private MapTileManager _tileManager = new MapTileManager(this);
/** Image to display */
private BufferedImage _mapImage = null;
+ /** Second image for drawing track (only needed for alpha blending) */
+ private BufferedImage _trackImage = null;
/** Slider for transparency */
private JSlider _transparencySlider = null;
/** Checkbox for scale bar */
/** Checkbox for autopan */
private JCheckBox _autopanCheckBox = null;
/** Checkbox for connecting track points */
- private JCheckBox _connectCheckBox = null;
+ private TripleStateCheckBox _connectCheckBox = null;
+ /** Checkbox for enable edit mode */
+ private JCheckBox _editmodeCheckBox = null;
/** Right-click popup menu */
private JPopupMenu _popup = null;
/** Top component panel */
private boolean _checkBounds = false;
/** Map position */
private MapPosition _mapPosition = null;
- /** x coordinate of drag from point */
- private int _dragFromX = -1;
- /** y coordinate of drag from point */
- private int _dragFromY = -1;
- /** Flag set to true for right-click dragging */
- private boolean _zoomDragging = false;
- /** x coordinate of drag to point */
- private int _dragToX = -1;
- /** y coordinate of drag to point */
- private int _dragToY = -1;
- /** x coordinate of popup menu */
- private int _popupMenuX = -1;
- /** y coordinate of popup menu */
- private int _popupMenuY = -1;
+ /** coordinates of drag from point */
+ private int _dragFromX = -1, _dragFromY = -1;
+ /** coordinates of drag to point */
+ private int _dragToX = -1, _dragToY = -1;
+ /** coordinates of popup menu */
+ private int _popupMenuX = -1, _popupMenuY = -1;
/** Flag to prevent showing too often the error message about loading maps */
private boolean _shownOsmErrorAlready = false;
+ /** Current drawing mode */
+ private int _drawMode = MODE_DEFAULT;
/** Constant for click sensitivity when selecting nearest point */
private static final int CLICK_SENSITIVITY = 10;
private static final int AUTOPAN_DISTANCE = 75;
// Colours
- private static final Color COLOR_BG = Color.WHITE;
private static final Color COLOR_MESSAGES = Color.GRAY;
- private static final Color COLOR_POINT = Color.BLUE;
- private static final Color COLOR_POINT_DELETED = Color.RED;
- private static final Color COLOR_CURR_RANGE = Color.GREEN;
- private static final Color COLOR_CROSSHAIRS = Color.RED;
- private static final Color COLOR_WAYPT_NAME = Color.BLACK;
- private static final Color COLOR_PHOTO_PT = Color.ORANGE;
+
+ // Drawing modes
+ private static final int MODE_DEFAULT = 0;
+ private static final int MODE_ZOOM_RECT = 1;
+ private static final int MODE_DRAW_POINTS_START = 2;
+ private static final int MODE_DRAW_POINTS_CONT = 3;
+ private static final int MODE_DRAG_POINT = 4;
+ private static final int MODE_CREATE_MIDPOINT = 5;
+ private static final int MODE_MARK_RECTANGLE = 6;
+
+ private static final int INDEX_UNKNOWN = -2;
/**
_trackInfo = inTrackInfo;
_track = inTrackInfo.getTrack();
_selection = inTrackInfo.getSelection();
+ _midpoints = new MidpointData();
_mapPosition = new MapPosition();
addMouseListener(this);
addMouseMotionListener(this);
ItemListener mapCheckListener = new ItemListener() {
public void itemStateChanged(ItemEvent e)
{
- _tileCacher.clearAll();
+ _tileManager.clearMemoryCaches();
_recalculate = true;
- repaint();
+ Config.setConfigBoolean(Config.KEY_SHOW_MAP, e.getStateChange() == ItemEvent.SELECTED);
+ UpdateMessageBroker.informSubscribers(); // to let menu know
+ // If the track is only partially visible and you turn the map off, make the track fully visible again
+ if (e.getStateChange() == ItemEvent.DESELECTED && _transparencySlider.getValue() < 0) {
+ _transparencySlider.setValue(0);
+ }
}
};
- _topPanel = new JPanel();
+ _topPanel = new OverlayPanel();
_topPanel.setLayout(new FlowLayout());
- _topPanel.setOpaque(false);
// Make slider for transparency
- _transparencySlider = new JSlider(0, 5, 0);
+ _transparencySlider = new JSlider(-6, 6, 0);
_transparencySlider.setPreferredSize(new Dimension(100, 20));
_transparencySlider.setMajorTickSpacing(1);
_transparencySlider.setSnapToTicks(true);
_transparencySlider.setOpaque(false);
+ _transparencySlider.setValue(0);
_transparencySlider.addChangeListener(new ChangeListener() {
public void stateChanged(ChangeEvent e)
{
- _recalculate = true;
- repaint();
+ int val = _transparencySlider.getValue();
+ if (val == 1 || val == -1)
+ _transparencySlider.setValue(0);
+ else {
+ _recalculate = true;
+ repaint();
+ }
}
});
_transparencySlider.setFocusable(false); // stop slider from stealing keyboard focus
_autopanCheckBox.setFocusable(false); // stop button from stealing keyboard focus
_topPanel.add(_autopanCheckBox);
// Add checkbox button for connecting points or not
- _connectCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.POINTS_DISCONNECTED_BUTTON), true);
- _connectCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.POINTS_CONNECTED_BUTTON));
+ _connectCheckBox = new TripleStateCheckBox();
+ _connectCheckBox.setIcon(0, IconManager.getImageIcon(IconManager.POINTS_CONNECTED_BUTTON));
+ _connectCheckBox.setIcon(1, IconManager.getImageIcon(IconManager.POINTS_DISCONNECTED_BUTTON));
+ _connectCheckBox.setIcon(2, IconManager.getImageIcon(IconManager.POINTS_HIDDEN_BUTTON));
+ _connectCheckBox.setCurrentState(0);
_connectCheckBox.setOpaque(false);
_connectCheckBox.setToolTipText(I18nManager.getText("menu.map.connect"));
_connectCheckBox.addItemListener(itemListener);
_connectCheckBox.setFocusable(false); // stop button from stealing keyboard focus
_topPanel.add(_connectCheckBox);
+ // Add checkbox button for edit mode or not
+ _editmodeCheckBox = new JCheckBox(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON), false);
+ _editmodeCheckBox.setSelectedIcon(IconManager.getImageIcon(IconManager.EDIT_MODE_BUTTON_ON));
+ _editmodeCheckBox.setOpaque(false);
+ _editmodeCheckBox.setToolTipText(I18nManager.getText("menu.map.editmode"));
+ _editmodeCheckBox.addItemListener(itemListener);
+ _editmodeCheckBox.setFocusable(false); // stop button from stealing keyboard focus
+ _topPanel.add(_editmodeCheckBox);
+
// Add zoom in, zoom out buttons
- _sidePanel = new JPanel();
+ _sidePanel = new OverlayPanel();
_sidePanel.setLayout(new BoxLayout(_sidePanel, BoxLayout.Y_AXIS));
- _sidePanel.setOpaque(false);
JButton zoomInButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_IN_BUTTON));
- zoomInButton.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
+ zoomInButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
zoomInButton.setContentAreaFilled(false);
zoomInButton.setToolTipText(I18nManager.getText("menu.map.zoomin"));
zoomInButton.addActionListener(new ActionListener() {
zoomInButton.setFocusable(false); // stop button from stealing keyboard focus
_sidePanel.add(zoomInButton);
JButton zoomOutButton = new JButton(IconManager.getImageIcon(IconManager.ZOOM_OUT_BUTTON));
- zoomOutButton.setBorder(BorderFactory.createEmptyBorder(3, 3, 3, 3));
+ zoomOutButton.setBorder(BorderFactory.createEmptyBorder(5, 5, 5, 5));
zoomOutButton.setContentAreaFilled(false);
zoomOutButton.setToolTipText(I18nManager.getText("menu.map.zoomout"));
zoomOutButton.addActionListener(new ActionListener() {
add(_scaleBar, BorderLayout.SOUTH);
// Make popup menu
makePopup();
+ // Get currently selected map from Config, pass to MapTileManager
+ _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
}
zoomInItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
+ panMap((_popupMenuX - getWidth()/2)/2, (_popupMenuY - getHeight()/2)/2);
zoomIn();
}});
- zoomInItem.setEnabled(true);
_popup.add(zoomInItem);
JMenuItem zoomOutItem = new JMenuItem(I18nManager.getText("menu.map.zoomout"));
zoomOutItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
+ panMap(-(_popupMenuX - getWidth()/2), -(_popupMenuY - getHeight()/2));
zoomOut();
}});
- zoomOutItem.setEnabled(true);
_popup.add(zoomOutItem);
JMenuItem zoomFullItem = new JMenuItem(I18nManager.getText("menu.map.zoomfull"));
zoomFullItem.addActionListener(new ActionListener() {
_recalculate = true;
repaint();
}});
- zoomFullItem.setEnabled(true);
_popup.add(zoomFullItem);
_popup.addSeparator();
// Set background
newPointItem.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e)
{
- _app.createPoint(MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_popupMenuY, getHeight())),
- MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_popupMenuX, getWidth())));
+ _app.createPoint(createPointFromClick(_popupMenuX, _popupMenuY));
}});
- newPointItem.setEnabled(true);
_popup.add(newPointItem);
+ // draw point series
+ JMenuItem drawPointsItem = new JMenuItem(I18nManager.getText("menu.map.drawpoints"));
+ drawPointsItem.addActionListener(new ActionListener() {
+ public void actionPerformed(ActionEvent e)
+ {
+ _drawMode = MODE_DRAW_POINTS_START;
+ }
+ });
+ _popup.add(drawPointsItem);
}
_yRange = new DoubleRange(MapUtils.getYFromLatitude(_latRange.getMinimum()),
MapUtils.getYFromLatitude(_latRange.getMaximum()));
_mapPosition.zoomToXY(_xRange.getMinimum(), _xRange.getMaximum(), _yRange.getMinimum(), _yRange.getMaximum(),
- getWidth(), getHeight());
+ getWidth(), getHeight());
}
int selectedPoint = _selection.getCurrentPointIndex();
if (selectedPoint >= 0 && _dragFromX == -1 && selectedPoint != _prevSelectedPoint)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(selectedPoint));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(selectedPoint));
- int panX = 0;
- int panY = 0;
- if (px < PAN_DISTANCE) {
- panX = px - AUTOPAN_DISTANCE;
- }
- else if (px > (getWidth()-PAN_DISTANCE)) {
- panX = AUTOPAN_DISTANCE + px - getWidth();
- }
- if (py < PAN_DISTANCE) {
- panY = py - AUTOPAN_DISTANCE;
- }
- if (py > (getHeight()-PAN_DISTANCE)) {
- panY = AUTOPAN_DISTANCE + py - getHeight();
- }
- if (panX != 0 || panY != 0) {
- _mapPosition.pan(panX, panY);
- }
+ autopanToPoint(selectedPoint);
}
_prevSelectedPoint = selectedPoint;
}
- // Draw the mapImage if necessary
+ // Draw the map contents if necessary
if ((_mapImage == null || _recalculate))
{
- getMapTiles();
- _scaleBar.updateScale(_mapPosition.getZoom(), _mapPosition.getCentreTileY());
+ paintMapContents();
+ _scaleBar.updateScale(_mapPosition.getZoom(), _mapPosition.getYFromPixels(0, 0));
}
// Draw the prepared image onto the panel
if (_mapImage != null) {
inG.drawImage(_mapImage, 0, 0, getWidth(), getHeight(), null);
}
- // Draw the zoom rectangle if necessary
- if (_zoomDragging)
+
+ switch (_drawMode)
{
- inG.setColor(Color.RED);
- inG.drawLine(_dragFromX, _dragFromY, _dragFromX, _dragToY);
- inG.drawLine(_dragFromX, _dragFromY, _dragToX, _dragFromY);
- inG.drawLine(_dragToX, _dragFromY, _dragToX, _dragToY);
- inG.drawLine(_dragFromX, _dragToY, _dragToX, _dragToY);
+ case MODE_DRAG_POINT:
+ drawDragLines(inG, _selection.getCurrentPointIndex()-1, _selection.getCurrentPointIndex()+1);
+ break;
+
+ case MODE_CREATE_MIDPOINT:
+ drawDragLines(inG, _clickedPoint-1, _clickedPoint);
+ break;
+
+ case MODE_ZOOM_RECT:
+ case MODE_MARK_RECTANGLE:
+ if (_dragFromX != -1 && _dragFromY != -1)
+ {
+ // Draw the zoom rectangle if necessary
+ inG.setColor(Color.RED);
+ inG.drawLine(_dragFromX, _dragFromY, _dragFromX, _dragToY);
+ inG.drawLine(_dragFromX, _dragFromY, _dragToX, _dragFromY);
+ inG.drawLine(_dragToX, _dragFromY, _dragToX, _dragToY);
+ inG.drawLine(_dragFromX, _dragToY, _dragToX, _dragToY);
+ }
+ break;
+
+ case MODE_DRAW_POINTS_CONT:
+ // draw line to mouse position to show drawing mode
+ inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
+ int prevIndex = _track.getNumPoints()-1;
+ int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(prevIndex));
+ int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(prevIndex));
+ inG.drawLine(px, py, _dragToX, _dragToY);
+ break;
}
}
else
{
- inG.setColor(COLOR_BG);
+ inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
inG.fillRect(0, 0, getWidth(), getHeight());
inG.setColor(COLOR_MESSAGES);
inG.drawString(I18nManager.getText("display.nodata"), 50, getHeight()/2);
paintChildren(inG);
}
+ /**
+ * @return true if the currently selected point is visible, false if off-screen or nothing selected
+ */
+ private boolean isCurrentPointVisible()
+ {
+ if (_trackInfo.getCurrentPoint() == null) {return false;}
+ final int selectedPoint = _selection.getCurrentPointIndex();
+ final int xFromCentre = Math.abs(_mapPosition.getXFromCentre(_track.getX(selectedPoint)));
+ if (xFromCentre > (getWidth()/2)) {return false;}
+ final int yFromCentre = Math.abs(_mapPosition.getYFromCentre(_track.getY(selectedPoint)));
+ return yFromCentre < (getHeight()/2);
+ }
+
+ /**
+ * If the specified point isn't visible, pan to it
+ * @param inIndex index of selected point
+ */
+ private void autopanToPoint(int inIndex)
+ {
+ int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inIndex));
+ int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inIndex));
+ int panX = 0;
+ int panY = 0;
+ if (px < PAN_DISTANCE) {
+ panX = px - AUTOPAN_DISTANCE;
+ }
+ else if (px > (getWidth()-PAN_DISTANCE)) {
+ panX = AUTOPAN_DISTANCE + px - getWidth();
+ }
+ if (py < (2*PAN_DISTANCE)) {
+ panY = py - AUTOPAN_DISTANCE;
+ }
+ if (py > (getHeight()-PAN_DISTANCE)) {
+ panY = AUTOPAN_DISTANCE + py - getHeight();
+ }
+ if (panX != 0 || panY != 0) {
+ _mapPosition.pan(panX, panY);
+ }
+ }
/**
- * Get the map tiles for the current zoom level and given tile parameters
+ * Paint the map tiles and the points on to the _mapImage
*/
- private void getMapTiles()
+ private void paintMapContents()
{
if (_mapImage == null || _mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())
{
_mapImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
}
- // Clear map
Graphics g = _mapImage.getGraphics();
- // Clear to white
- g.setColor(COLOR_BG);
+ // Set antialiasing according to config
+ ((Graphics2D) g).setRenderingHint(RenderingHints.KEY_ANTIALIASING,
+ Config.getConfigBoolean(Config.KEY_ANTIALIAS) ? RenderingHints.VALUE_ANTIALIAS_ON : RenderingHints.VALUE_ANTIALIAS_OFF);
+ // Clear to background
+ g.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND));
g.fillRect(0, 0, getWidth(), getHeight());
+ // Check whether maps are on or not
+ final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
+ _mapCheckBox.setSelected(showMap);
+ // Check whether disk cache is on or not
+ final boolean usingDiskCache = Config.getConfigString(Config.KEY_DISK_CACHE) != null;
+ // Show tip to recommend setting up a cache
+ if (showMap && !usingDiskCache && Config.getConfigBoolean(Config.KEY_ONLINE_MODE))
+ {
+ SwingUtilities.invokeLater(new Runnable() {
+ public void run() {
+ _app.showTip(TipManager.Tip_UseAMapCache);
+ }
+ });
+ }
+
// reset error message
- if (!_mapCheckBox.isSelected()) {_shownOsmErrorAlready = false;}
+ if (!showMap) {_shownOsmErrorAlready = false;}
+ _recalculate = false;
// Only get map tiles if selected
- if (_mapCheckBox.isSelected())
+ if (showMap)
{
// init tile cacher
- _tileCacher.centreMap(_mapPosition.getZoom(), _mapPosition.getCentreTileX(), _mapPosition.getCentreTileY());
+ _tileManager.centreMap(_mapPosition.getZoom(), _mapPosition.getCentreTileX(), _mapPosition.getCentreTileY());
boolean loadingFailed = false;
if (_mapImage == null) return;
- if (_tileCacher.isOverzoomed())
+ if (_tileManager.isOverzoomed())
{
// display overzoom message
g.setColor(COLOR_MESSAGES);
}
else
{
+ int numLayers = _tileManager.getNumLayers();
// Loop over tiles drawing each one
int[] tileIndices = _mapPosition.getTileIndices(getWidth(), getHeight());
int[] pixelOffsets = _mapPosition.getDisplayOffsets(getWidth(), getHeight());
for (int tileY = tileIndices[2]; tileY <= tileIndices[3]; tileY++)
{
int y = (tileY - tileIndices[2]) * 256 - pixelOffsets[1];
- Image image = _tileCacher.getTile(tileX, tileY);
- if (image != null) {
- g.drawImage(image, x, y, 256, 256, null);
+ // Loop over layers
+ for (int l=0; l<numLayers; l++)
+ {
+ Image image = _tileManager.getTile(l, tileX, tileY, true);
+ if (image != null) {
+ g.drawImage(image, x, y, 256, 256, null);
+ }
}
}
}
- // Make maps brighter / fainter
- float[] scaleFactors = {1.0f, 1.05f, 1.1f, 1.2f, 1.6f, 2.0f};
- float scaleFactor = scaleFactors[_transparencySlider.getValue()];
- if (scaleFactor > 1.0f)
+ // Make maps brighter / fainter according to slider
+ final int brightnessIndex = Math.max(1, _transparencySlider.getValue()) - 1;
+ if (brightnessIndex > 0)
{
- RenderingHints hints = new RenderingHints(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_OFF);
- hints.put(RenderingHints.KEY_RENDERING, RenderingHints.VALUE_RENDER_QUALITY);
- RescaleOp op = new RescaleOp(scaleFactor, 0, hints);
- op.filter(_mapImage, _mapImage);
+ final int[] alphas = {0, 40, 80, 120, 160, 210};
+ Color bgColor = Config.getColourScheme().getColour(ColourScheme.IDX_BACKGROUND);
+ bgColor = new Color(bgColor.getRed(), bgColor.getGreen(), bgColor.getBlue(), alphas[brightnessIndex]);
+ g.setColor(bgColor);
+ g.fillRect(0, 0, getWidth(), getHeight());
}
}
}
- // Paint the track points on top
- int pointsPainted = 1;
- try
- {
- pointsPainted = paintPoints(g);
+ // Work out track opacity according to slider
+ final float[] opacities = {1.0f, 0.75f, 0.5f, 0.3f, 0.15f, 0.0f};
+ float trackOpacity = 1.0f;
+ if (_transparencySlider.getValue() < 0) {
+ trackOpacity = opacities[-1 - _transparencySlider.getValue()];
}
- catch (NullPointerException npe) { // ignore, probably due to data being changed during drawing
+
+ if (trackOpacity > 0.0f)
+ {
+ // Paint the track points on top
+ int pointsPainted = 1;
+ try
+ {
+ if (trackOpacity > 0.9f)
+ {
+ // Track is fully opaque, just draw it directly
+ pointsPainted = paintPoints(g);
+ _trackImage = null;
+ }
+ else
+ {
+ // Track is partly transparent, so use a separate BufferedImage
+ if (_trackImage == null || _trackImage.getWidth() != getWidth() || _trackImage.getHeight() != getHeight())
+ {
+ _trackImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
+ }
+ // Clear to transparent
+ Graphics2D gTrack = _trackImage.createGraphics();
+ gTrack.setComposite(AlphaComposite.getInstance(AlphaComposite.CLEAR, 0.0f));
+ gTrack.fillRect(0, 0, getWidth(), getHeight());
+ gTrack.setPaintMode();
+ // Draw the track onto this separate image
+ pointsPainted = paintPoints(gTrack);
+ ((Graphics2D) g).setComposite(AlphaComposite.getInstance(AlphaComposite.SRC_OVER, trackOpacity));
+ g.drawImage(_trackImage, 0, 0, null);
+ }
+ }
+ catch (NullPointerException npe) {} // ignore, probably due to data being changed during drawing
+ catch (ArrayIndexOutOfBoundsException obe) {} // also ignore
+
+ // Zoom to fit if no points found
+ if (pointsPainted <= 0 && _checkBounds)
+ {
+ zoomToFit();
+ _recalculate = true;
+ repaint();
+ }
}
// free g
g.dispose();
- _recalculate = false;
- // Zoom to fit if no points found
- if (pointsPainted <= 0 && _checkBounds) {
- zoomToFit();
- _recalculate = true;
- repaint();
- }
_checkBounds = false;
// enable / disable transparency slider
- _transparencySlider.setEnabled(_mapCheckBox.isSelected());
+ _transparencySlider.setEnabled(showMap);
}
*/
private int paintPoints(Graphics inG)
{
+ // Set up colours
+ final ColourScheme cs = Config.getColourScheme();
+ final Color pointColour = cs.getColour(ColourScheme.IDX_POINT);
+ final Color rangeColour = cs.getColour(ColourScheme.IDX_SELECTION);
+ final Color currentColour = cs.getColour(ColourScheme.IDX_PRIMARY);
+ final Color secondColour = cs.getColour(ColourScheme.IDX_SECONDARY);
+ final Color textColour = cs.getColour(ColourScheme.IDX_TEXT);
+ final PointColourer pointColourer = _app.getPointColourer();
+
+ final int winWidth = getWidth();
+ final int winHeight = getHeight();
+ final int halfWinWidth = winWidth / 2;
+ final int halfWinHeight = winHeight / 2;
+
+ final int numPoints = _track.getNumPoints();
+ final int[] xPixels = new int[numPoints];
+ final int[] yPixels = new int[numPoints];
+
+ // try to set line width for painting
+ if (inG instanceof Graphics2D)
+ {
+ int lineWidth = Config.getConfigInt(Config.KEY_LINE_WIDTH);
+ if (lineWidth < 1 || lineWidth > 4) {lineWidth = 2;}
+ ((Graphics2D) inG).setStroke(new BasicStroke(lineWidth));
+ }
int pointsPainted = 0;
// draw track points
- inG.setColor(COLOR_POINT);
+ inG.setColor(pointColour);
int prevX = -1, prevY = -1;
- boolean connectPoints = _connectCheckBox.isSelected();
+ final int connectState = _connectCheckBox.getCurrentState();
+ final boolean drawLines = (connectState % 2) == 0; // 0 or 2
+ final boolean drawPoints = (connectState <= 1); // 0 or 1
boolean prevPointVisible = false, currPointVisible = false;
- for (int i=0; i<_track.getNumPoints(); i++)
+ boolean anyWaypoints = false;
+ boolean isWaypoint = false;
+ for (int i=0; i<numPoints; i++)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(i));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(i));
- currPointVisible = px >= 0 && px < getWidth() && py >= 0 && py < getHeight();
- if (currPointVisible)
+ // Calculate pixel position of point from its x, y coordinates
+ int px = halfWinWidth + _mapPosition.getXFromCentre(_track.getX(i));
+ int py = halfWinHeight + _mapPosition.getYFromCentre(_track.getY(i));
+ px = wrapLongitudeValue(px, winWidth, _mapPosition.getZoom());
+ // Remember these calculated pixel values so they don't have to be recalculated
+ xPixels[i] = px; yPixels[i] = py;
+
+ currPointVisible = px >= 0 && px < winWidth && py >= 0 && py < winHeight;
+ isWaypoint = _track.getPoint(i).isWaypoint();
+ anyWaypoints = anyWaypoints || isWaypoint;
+ if (!isWaypoint)
{
- if (!_track.getPoint(i).isWaypoint())
+ if (currPointVisible || (drawLines && prevPointVisible))
{
- // Draw rectangle for track point
+ // For track points, work out which colour to use
if (_track.getPoint(i).getDeleteFlag()) {
- inG.setColor(COLOR_POINT_DELETED);
+ inG.setColor(currentColour);
}
- else {
- inG.setColor(COLOR_POINT);
+ else if (pointColourer != null)
+ { // use the point colourer if there is one
+ Color trackColour = pointColourer.getColour(i);
+ inG.setColor(trackColour);
+ }
+ else
+ {
+ inG.setColor(pointColour);
+ }
+
+ // Draw rectangle for track point if it's visible
+ if (currPointVisible && drawPoints)
+ {
+ inG.drawRect(px-2, py-2, 3, 3);
+ pointsPainted++;
}
- inG.drawRect(px-2, py-2, 3, 3);
- pointsPainted++;
}
- }
- if (!_track.getPoint(i).isWaypoint())
- {
+
// Connect track points if either of them are visible
- if (connectPoints && (currPointVisible || prevPointVisible)
- && !(prevX == -1 && prevY == -1)
+ if (drawLines && !(prevX == -1 && prevY == -1)
&& !_track.getPoint(i).getSegmentStart())
{
inG.drawLine(prevX, prevY, px, py);
}
// Loop over points, just drawing blobs for waypoints
- inG.setColor(COLOR_WAYPT_NAME);
+ inG.setColor(textColour);
FontMetrics fm = inG.getFontMetrics();
int nameHeight = fm.getHeight();
- int width = getWidth();
- int height = getHeight();
- for (int i=0; i<_track.getNumPoints(); i++)
+ if (anyWaypoints)
{
- if (_track.getPoint(i).isWaypoint())
+ int numWaypoints = 0;
+ for (int i=0; i<_track.getNumPoints(); i++)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(i));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(i));
- if (px >= 0 && px < getWidth() && py >= 0 && py < getHeight())
+ if (_track.getPoint(i).isWaypoint())
{
- inG.fillRect(px-3, py-3, 6, 6);
- pointsPainted++;
+ int px = xPixels[i];
+ int py = yPixels[i];
+ if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
+ {
+ inG.fillRect(px-3, py-3, 6, 6);
+ pointsPainted++;
+ numWaypoints++;
+ }
}
}
- }
- // Loop over points again, now draw names for waypoints
- for (int i=0; i<_track.getNumPoints(); i++)
- {
- if (_track.getPoint(i).isWaypoint())
+ // Take more care with waypoint names if less than 100 are visible
+ final int numNameSteps = (numWaypoints > 100 ? 1 : 4);
+ final int numPointSteps = (numWaypoints > 1000 ? 2 : 1);
+
+ // Loop over points again, now draw names for waypoints
+ int[] nameXs = {0, 0, 0, 0};
+ int[] nameYs = {0, 0, 0, 0};
+ for (int i=0; i<_track.getNumPoints(); i += numPointSteps)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(i));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(i));
- if (px >= 0 && px < getWidth() && py >= 0 && py < getHeight())
+ if (_track.getPoint(i).isWaypoint())
{
- // Figure out where to draw waypoint name so it doesn't obscure track
- String waypointName = _track.getPoint(i).getWaypointName();
- int nameWidth = fm.stringWidth(waypointName);
- boolean drawnName = false;
- // Make arrays for coordinates right left up down
- int[] nameXs = {px + 2, px - nameWidth - 2, px - nameWidth/2, px - nameWidth/2};
- int[] nameYs = {py + (nameHeight/2), py + (nameHeight/2), py - 2, py + nameHeight + 2};
- for (int extraSpace = 4; extraSpace < 13 && !drawnName; extraSpace+=2)
+ int px = xPixels[i];
+ int py = yPixels[i];
+ if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
{
- // Shift arrays for coordinates right left up down
- nameXs[0] += 2; nameXs[1] -= 2;
- nameYs[2] -= 2; nameYs[3] += 2;
- // Check each direction in turn right left up down
- for (int a=0; a<4; a++)
+ // Figure out where to draw waypoint name so it doesn't obscure track
+ String waypointName = _track.getPoint(i).getWaypointName();
+ int nameWidth = fm.stringWidth(waypointName);
+ boolean drawnName = false;
+ // Make arrays for coordinates right left up down
+ nameXs[0] = px + 2; nameXs[1] = px - nameWidth - 2;
+ nameXs[2] = nameXs[3] = px - nameWidth/2;
+ nameYs[0] = nameYs[1] = py + (nameHeight/2);
+ nameYs[2] = py - 2; nameYs[3] = py + nameHeight + 2;
+ for (int extraSpace = 0; extraSpace < numNameSteps && !drawnName; extraSpace++)
{
- if (nameXs[a] > 0 && (nameXs[a] + nameWidth) < width
- && nameYs[a] < height && (nameYs[a] - nameHeight) > 0
- && !overlapsPoints(nameXs[a], nameYs[a], nameWidth, nameHeight))
+ // Shift arrays for coordinates right left up down
+ nameXs[0] += 3; nameXs[1] -= 3;
+ nameYs[2] -= 3; nameYs[3] += 3;
+ // Check each direction in turn right left up down
+ for (int a=0; a<4; a++)
{
- // Found a rectangle to fit - draw name here and quit
- inG.drawString(waypointName, nameXs[a], nameYs[a]);
- drawnName = true;
- break;
+ if (nameXs[a] > 0 && (nameXs[a] + nameWidth) < winWidth
+ && nameYs[a] < winHeight && (nameYs[a] - nameHeight) > 0
+ && !MapUtils.overlapsPoints(_mapImage, nameXs[a], nameYs[a], nameWidth, nameHeight, textColour))
+ {
+ // Found a rectangle to fit - draw name here and quit
+ inG.drawString(waypointName, nameXs[a], nameYs[a]);
+ drawnName = true;
+ break;
+ }
}
}
}
}
}
}
- // Loop over points, drawing blobs for photo points
- inG.setColor(COLOR_PHOTO_PT);
+ // Loop over points, drawing blobs for photo / audio points
+ inG.setColor(secondColour);
for (int i=0; i<_track.getNumPoints(); i++)
{
- if (_track.getPoint(i).getPhoto() != null)
+ if (_track.getPoint(i).hasMedia())
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(i));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(i));
- if (px >= 0 && px < getWidth() && py >= 0 && py < getHeight())
+ int px = xPixels[i];
+ int py = yPixels[i];
+ if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
{
inG.drawRect(px-1, py-1, 2, 2);
inG.drawRect(px-2, py-2, 4, 4);
// Draw selected range
if (_selection.hasRangeSelected())
{
- inG.setColor(COLOR_CURR_RANGE);
+ inG.setColor(rangeColour);
for (int i=_selection.getStart(); i<=_selection.getEnd(); i++)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(i));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(i));
+ int px = xPixels[i];
+ int py = yPixels[i];
inG.drawRect(px-1, py-1, 2, 2);
}
}
- // Draw selected point, crosshairs
+ // Draw crosshairs at selected point
int selectedPoint = _selection.getCurrentPointIndex();
if (selectedPoint >= 0)
{
- int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(selectedPoint));
- int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(selectedPoint));
- inG.setColor(COLOR_CROSSHAIRS);
+ int px = xPixels[selectedPoint];
+ int py = yPixels[selectedPoint];
+ inG.setColor(currentColour);
// crosshairs
- inG.drawLine(px, 0, px, getHeight());
- inG.drawLine(0, py, getWidth(), py);
- // oval
- inG.drawOval(px - 2, py - 2, 4, 4);
- inG.drawOval(px - 3, py - 3, 6, 6);
+ inG.drawLine(px, 0, px, winHeight);
+ inG.drawLine(0, py, winWidth, py);
}
// Return the number of points painted
return pointsPainted;
}
-
/**
- * Tests whether there are any dark pixels within the specified x,y rectangle
- * @param inX left X coordinate
- * @param inY bottom Y coordinate
- * @param inWidth width of rectangle
- * @param inHeight height of rectangle
- * @return true if there's at least one data point in the rectangle
+ * Wrap the given pixel value if appropriate and possible
+ * @param inPx Pixel x coordinate
+ * @param inWinWidth window width in pixels
+ * @param inZoom zoom level
+ * @return modified pixel x coordinate
*/
- private boolean overlapsPoints(int inX, int inY, int inWidth, int inHeight)
+ private static int wrapLongitudeValue(int inPx, int inWinWidth, int inZoom)
{
- // each of the colour channels must be brighter than this to count as empty
- final int BRIGHTNESS_LIMIT = 210;
- try
+ if (inPx > inWinWidth)
{
- // loop over x coordinate of rectangle
- for (int x=0; x<inWidth; x++)
- {
- // loop over y coordinate of rectangle
- for (int y=0; y<inHeight; y++)
- {
- int pixelColor = _mapImage.getRGB(inX + x, inY - y);
- // split into four components rgba
- int lowestBit = pixelColor & 255;
- int secondBit = (pixelColor >> 8) & 255;
- int thirdBit = (pixelColor >> 16) & 255;
- //int fourthBit = (pixelColor >> 24) & 255; // alpha ignored
- if (lowestBit < BRIGHTNESS_LIMIT || secondBit < BRIGHTNESS_LIMIT || thirdBit < BRIGHTNESS_LIMIT) return true;
- }
+ // Pixel is too far right, could we wrap it back onto the screen?
+ int px = inPx;
+ while (px > inWinWidth) {
+ px -= (256 << inZoom);
+ }
+ if (px >= 0) {
+ return px; // successfully wrapped back onto the screen
}
}
- catch (NullPointerException e) {
- // ignore null pointers, just return false
+ else if (inPx < 0)
+ {
+ // Pixel is too far left, could we wrap it back onto the screen?
+ int px = inPx;
+ while (px < 0) {
+ px += (256 << inZoom);
+ }
+ if (px < inWinWidth) {
+ return px; // successfully wrapped back onto the screen
+ }
}
- return false;
+ // Either it's already on the screen or couldn't be wrapped
+ return inPx;
}
+ /**
+ * Draw the lines while dragging a point
+ * @param inG graphics object
+ * @param inPrevIndex index of point to draw from
+ * @param inNextIndex index of point to draw to
+ */
+ private void drawDragLines(Graphics inG, int inPrevIndex, int inNextIndex)
+ {
+ inG.setColor(Config.getColourScheme().getColour(ColourScheme.IDX_POINT));
+ // line from prev point to cursor
+ if (inPrevIndex > -1 && !_track.getPoint(inPrevIndex+1).getSegmentStart())
+ {
+ final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inPrevIndex));
+ final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inPrevIndex));
+ inG.drawLine(px, py, _dragToX, _dragToY);
+ }
+ if (inNextIndex < _track.getNumPoints() && !_track.getPoint(inNextIndex).getSegmentStart())
+ {
+ final int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inNextIndex));
+ final int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inNextIndex));
+ inG.drawLine(px, py, _dragToX, _dragToY);
+ }
+ }
/**
* Inform that tiles have been updated and the map can be repainted
* @param inIsOk true if data loaded ok, false for error
*/
- public synchronized void tilesUpdated(boolean inIsOk)
+ public void tilesUpdated(boolean inIsOk)
{
- // Show message if loading failed (but not too many times)
- if (!inIsOk && !_shownOsmErrorAlready && _mapCheckBox.isSelected())
+ synchronized(this)
{
- _shownOsmErrorAlready = true;
- // use separate thread to show message about failing to load osm images
- new Thread(new Runnable() {
- public void run() {
- try {Thread.sleep(500);} catch (InterruptedException ie) {}
- _app.showErrorMessage("error.osmimage.dialogtitle", "error.osmimage.failed");
- }
- }).start();
+ // Show message if loading failed (but not too many times)
+ if (!inIsOk && !_shownOsmErrorAlready && _mapCheckBox.isSelected())
+ {
+ _shownOsmErrorAlready = true;
+ // use separate thread to show message about failing to load osm images
+ new Thread(new Runnable() {
+ public void run() {
+ try {Thread.sleep(500);} catch (InterruptedException ie) {}
+ _app.showErrorMessage("error.osmimage.dialogtitle", "error.osmimage.failed");
+ }
+ }).start();
+ }
+ _recalculate = true;
+ repaint();
}
- _recalculate = true;
- repaint();
}
/**
*/
public void zoomIn()
{
+ // See if selected point is currently visible, if so (and autopan on) then autopan after zoom to keep it visible
+ boolean wasVisible = _autopanCheckBox.isSelected() && isCurrentPointVisible();
_mapPosition.zoomIn();
+ if (wasVisible && !isCurrentPointVisible()) {
+ autopanToPoint(_selection.getCurrentPointIndex());
+ }
_recalculate = true;
repaint();
}
repaint();
}
+ /**
+ * Create a DataPoint object from the given click coordinates
+ * @param inX x coordinate of click
+ * @param inY y coordinate of click
+ * @return DataPoint with given coordinates and no altitude
+ */
+ private DataPoint createPointFromClick(int inX, int inY)
+ {
+ double lat = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(inY, getHeight()));
+ double lon = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(inX, getWidth()));
+ return new DataPoint(new Latitude(lat, Coordinate.FORMAT_NONE),
+ new Longitude(lon, Coordinate.FORMAT_NONE), null);
+ }
+
+ /**
+ * Move a DataPoint object to the given mouse coordinates
+ * @param startX start x coordinate of mouse
+ * @param startY start y coordinate of mouse
+ * @param endX end x coordinate of mouse
+ * @param endY end y coordinate of mouse
+ */
+ private void movePointToMouse(int startX, int startY, int endX, int endY )
+ {
+ double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(startY, getHeight()));
+ double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(startX, getWidth()));
+ double lat_delta = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(endY, getHeight())) - lat1;
+ double lon_delta = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(endX, getWidth())) - lon1;
+
+ DataPoint point = _trackInfo.getCurrentPoint();
+ if (point == null) {
+ return;
+ }
+
+ // Make lists for edit and undo, and add each changed field in turn
+ FieldEditList editList = new FieldEditList();
+ FieldEditList undoList = new FieldEditList();
+
+ // Check field list
+ FieldList fieldList = _track.getFieldList();
+ int numFields = fieldList.getNumFields();
+ for (int i=0; i<numFields; i++)
+ {
+ Field field = fieldList.getField(i);
+ if (field == Field.LATITUDE) {
+ editList.addEdit(new FieldEdit(field, Double.toString(point.getLatitude().getDouble() + lat_delta)));
+ undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LATITUDE)));
+ }
+ else if (field == Field.LONGITUDE) {
+ editList.addEdit(new FieldEdit(field, Double.toString(point.getLongitude().getDouble() + lon_delta)));
+ undoList.addEdit(new FieldEdit(field, point.getFieldValue(Field.LONGITUDE)));
+ }
+ }
+ _app.completePointEdit(editList, undoList);
+ }
+
+
/**
* @see javax.swing.JComponent#getMinimumSize()
*/
// select point if it's a left-click
if (!inE.isMetaDown())
{
- int pointIndex = _track.getNearestPointIndex(
- _mapPosition.getXFromPixels(inE.getX(), getWidth()),
- _mapPosition.getYFromPixels(inE.getY(), getHeight()),
- _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY), false);
- _trackInfo.selectPoint(pointIndex);
+ if (inE.getClickCount() == 1)
+ {
+ // single click
+ if (_drawMode == MODE_DEFAULT)
+ {
+ int pointIndex = _clickedPoint;
+ if (pointIndex == INDEX_UNKNOWN)
+ {
+ // index hasn't been calculated yet
+ pointIndex = _track.getNearestPointIndex(
+ _mapPosition.getXFromPixels(inE.getX(), getWidth()),
+ _mapPosition.getYFromPixels(inE.getY(), getHeight()),
+ _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY), false);
+ }
+ // Extend selection for shift-click
+ if (inE.isShiftDown()) {
+ _trackInfo.extendSelection(pointIndex);
+ }
+ else {
+ _trackInfo.selectPoint(pointIndex);
+ }
+ }
+ else if (_drawMode == MODE_DRAW_POINTS_START)
+ {
+ _app.createPoint(createPointFromClick(inE.getX(), inE.getY()));
+ _dragToX = inE.getX();
+ _dragToY = inE.getY();
+ _drawMode = MODE_DRAW_POINTS_CONT;
+ }
+ else if (_drawMode == MODE_DRAW_POINTS_CONT)
+ {
+ DataPoint point = createPointFromClick(inE.getX(), inE.getY());
+ _app.createPoint(point, false); // not a new segment
+ }
+ }
+ else if (inE.getClickCount() == 2)
+ {
+ // double click
+ if (_drawMode == MODE_DEFAULT) {
+ panMap(inE.getX() - getWidth()/2, inE.getY() - getHeight()/2);
+ zoomIn();
+ }
+ else if (_drawMode == MODE_DRAW_POINTS_START || _drawMode == MODE_DRAW_POINTS_CONT) {
+ _drawMode = MODE_DEFAULT;
+ }
+ }
}
else
{
_popup.show(this, _popupMenuX, _popupMenuY);
}
}
+ // Reset app mode
+ _app.setCurrentMode(App.AppMode.NORMAL);
+ if (_drawMode == MODE_MARK_RECTANGLE) _drawMode = MODE_DEFAULT;
}
/**
}
/**
- * Ignore mouse pressed events
+ * React to mouse pressed events to initiate a point drag
* @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
*/
public void mousePressed(MouseEvent inE)
{
- // ignore
+ _clickedPoint = INDEX_UNKNOWN;
+ if (_track == null || _track.getNumPoints() <= 0)
+ return;
+ if (!inE.isMetaDown())
+ {
+ // Left mouse drag - check if point is near; if so select it for dragging
+ if (_drawMode == MODE_DEFAULT)
+ {
+ /* Drag points if edit mode is enabled OR ALT is pressed */
+ if (_editmodeCheckBox.isSelected() || inE.isAltDown() || inE.isAltGraphDown())
+ {
+ final double clickX = _mapPosition.getXFromPixels(inE.getX(), getWidth());
+ final double clickY = _mapPosition.getYFromPixels(inE.getY(), getHeight());
+ final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
+ _clickedPoint = _track.getNearestPointIndex(clickX, clickY, clickSens, false);
+
+ if (_clickedPoint >= 0)
+ {
+ // TODO: maybe use another color of the cross or remove the cross while dragging???
+
+ _trackInfo.selectPoint(_clickedPoint);
+ if (_trackInfo.getCurrentPoint() != null)
+ {
+ _drawMode = MODE_DRAG_POINT;
+ _dragFromX = _dragToX = inE.getX();
+ _dragFromY = _dragToY = inE.getY();
+ }
+ }
+ else
+ {
+ // Not a click on a point, so check half-way between two (connected) trackpoints
+ int midpointIndex = _midpoints.getNearestPointIndex(clickX, clickY, clickSens);
+ if (midpointIndex > 0)
+ {
+ _drawMode = MODE_CREATE_MIDPOINT;
+ _clickedPoint = midpointIndex;
+ _dragFromX = _dragToX = inE.getX();
+ _dragFromY = _dragToY = inE.getY();
+ }
+ }
+ }
+ }
+ }
+ // else right-press ignored
}
/**
public void mouseReleased(MouseEvent inE)
{
_recalculate = true;
- if (_zoomDragging && Math.abs(_dragToX - _dragFromX) > 20 && Math.abs(_dragToY - _dragFromY) > 20)
+
+ if (_drawMode == MODE_DRAG_POINT)
{
- //System.out.println("Finished zoom: " + _dragFromX + ", " + _dragFromY + " to " + _dragToX + ", " + _dragToY);
- _mapPosition.zoomToPixels(_dragFromX, _dragToX, _dragFromY, _dragToY, getWidth(), getHeight());
+ if (Math.abs(_dragToX - _dragFromX) > 2
+ || Math.abs(_dragToY - _dragFromY) > 2)
+ {
+ movePointToMouse(_dragFromX, _dragFromY, _dragToX, _dragToY );
+ }
+ _drawMode = MODE_DEFAULT;
+ }
+ else if (_drawMode == MODE_CREATE_MIDPOINT)
+ {
+ _drawMode = MODE_DEFAULT;
+ _app.createPoint(createPointFromClick(_dragToX, _dragToY), _clickedPoint);
+ }
+ else if (_drawMode == MODE_ZOOM_RECT)
+ {
+ if (Math.abs(_dragToX - _dragFromX) > 20
+ && Math.abs(_dragToY - _dragFromY) > 20)
+ {
+ _mapPosition.zoomToPixels(_dragFromX, _dragToX, _dragFromY, _dragToY, getWidth(), getHeight());
+ }
+ _drawMode = MODE_DEFAULT;
+ }
+ else if (_drawMode == MODE_MARK_RECTANGLE)
+ {
+ // Reset app mode
+ _app.setCurrentMode(App.AppMode.NORMAL);
+ _drawMode = MODE_DEFAULT;
+ // Call a function to mark the points
+ MarkPointsInRectangleFunction marker = (MarkPointsInRectangleFunction) FunctionLibrary.FUNCTION_MARK_IN_RECTANGLE;
+ double lon1 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragFromX, getWidth()));
+ double lat1 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragFromY, getHeight()));
+ double lon2 = MapUtils.getLongitudeFromX(_mapPosition.getXFromPixels(_dragToX, getWidth()));
+ double lat2 = MapUtils.getLatitudeFromY(_mapPosition.getYFromPixels(_dragToY, getHeight()));
+ // Invalidate rectangle if pixel coords are (-1,-1)
+ if (_dragFromX < 0 || _dragFromY < 0) {
+ lon1 = lon2;
+ lat1 = lat2;
+ }
+ marker.setRectCoords(lon1, lat1, lon2, lat2);
+ marker.begin();
}
_dragFromX = _dragFromY = -1;
- _zoomDragging = false;
repaint();
}
{
if (!inE.isMetaDown())
{
- // Left mouse drag - pan map by appropriate amount
- _zoomDragging = false;
- if (_dragFromX != -1)
+ // Left mouse drag - either drag the point or pan the map
+ if (_drawMode == MODE_DRAG_POINT || _drawMode == MODE_CREATE_MIDPOINT)
{
- panMap(_dragFromX - inE.getX(), _dragFromY - inE.getY());
+ // move point
+ _dragToX = inE.getX();
+ _dragToY = inE.getY();
_recalculate = true;
repaint();
}
- _dragFromX = inE.getX();
- _dragFromY = inE.getY();
+ else if (_drawMode == MODE_MARK_RECTANGLE)
+ {
+ // draw a rectangle for marking points
+ if (_dragFromX == -1) {
+ _dragFromX = inE.getX();
+ _dragFromY = inE.getY();
+ }
+ _dragToX = inE.getX();
+ _dragToY = inE.getY();
+ repaint();
+ }
+ else
+ {
+ // regular left-drag pans map by appropriate amount
+ if (_dragFromX != -1)
+ {
+ panMap(_dragFromX - inE.getX(), _dragFromY - inE.getY());
+ }
+ _dragFromX = _dragToX = inE.getX();
+ _dragFromY = _dragToY = inE.getY();
+ }
}
else
{
- // Right-click and drag - draw rectangle and control zoom
- _zoomDragging = true;
+ // Right-click and drag - update rectangle
+ _drawMode = MODE_ZOOM_RECT;
if (_dragFromX == -1) {
_dragFromX = inE.getX();
_dragFromY = inE.getY();
*/
public void mouseMoved(MouseEvent inEvent)
{
- // ignore
+ boolean useCrosshairs = false;
+ boolean useResize = false;
+ // Ignore unless we're drawing points
+ if (_drawMode == MODE_DRAW_POINTS_CONT)
+ {
+ _dragToX = inEvent.getX();
+ _dragToY = inEvent.getY();
+ repaint();
+ }
+ else if (_drawMode == MODE_MARK_RECTANGLE) {
+ useResize = true;
+ }
+ else if (_editmodeCheckBox.isSelected() || inEvent.isAltDown() || inEvent.isAltGraphDown())
+ {
+ // Try to find a point or a midpoint at this location, and if there is one
+ // then change the cursor to crosshairs
+ final double clickX = _mapPosition.getXFromPixels(inEvent.getX(), getWidth());
+ final double clickY = _mapPosition.getYFromPixels(inEvent.getY(), getHeight());
+ final double clickSens = _mapPosition.getBoundsFromPixels(CLICK_SENSITIVITY);
+ useCrosshairs = (_track.getNearestPointIndex(clickX, clickY, clickSens, false) >= 0
+ || _midpoints.getNearestPointIndex(clickX, clickY, clickSens) >= 0
+ );
+ }
+ if (useCrosshairs && !isCursorSet()) {
+ setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
+ }
+ else if (useResize && !isCursorSet()) {
+ setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
+ }
+ else if (!useCrosshairs && !useResize && isCursorSet()) {
+ setCursor(null);
+ }
}
/**
_checkBounds = true;
}
if ((inUpdateType & DataSubscriber.MAPSERVER_CHANGED) > 0) {
- _tileCacher.setTileConfig(new MapTileConfig());
+ // Get the selected map source index and pass to tile manager
+ _tileManager.setMapSource(Config.getConfigInt(Config.KEY_MAPSOURCE_INDEX));
+ }
+ if ((inUpdateType & (DataSubscriber.DATA_ADDED_OR_REMOVED + DataSubscriber.DATA_EDITED)) > 0) {
+ _midpoints.updateData(_track);
+ }
+ // See if rect mode has been activated
+ if (_app.getCurrentMode() == App.AppMode.DRAWRECT)
+ {
+ _drawMode = MODE_MARK_RECTANGLE;
+ if (!isCursorSet()) {
+ setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
+ }
}
repaint();
// enable or disable components
{
int code = inE.getKeyCode();
int currPointIndex = _selection.getCurrentPointIndex();
- // Check for meta key
- if (inE.isControlDown())
+ // Check for Ctrl key (for Linux/Win) or meta key (Clover key for Mac)
+ if (inE.isControlDown() || inE.isMetaDown())
{
+ // Shift as well makes things faster
+ final int pointIncrement = inE.isShiftDown()?3:1;
// Check for arrow keys to zoom in and out
if (code == KeyEvent.VK_UP)
zoomIn();
zoomOut();
// Key nav for next/prev point
else if (code == KeyEvent.VK_LEFT && currPointIndex > 0)
- _trackInfo.selectPoint(currPointIndex-1);
+ _trackInfo.incrementPointIndex(-pointIncrement);
else if (code == KeyEvent.VK_RIGHT)
- _trackInfo.selectPoint(currPointIndex+1);
+ _trackInfo.incrementPointIndex(pointIncrement);
+ else if (code == KeyEvent.VK_PAGE_UP)
+ _trackInfo.selectPoint(Checker.getPreviousSegmentStart(
+ _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
+ else if (code == KeyEvent.VK_PAGE_DOWN)
+ _trackInfo.selectPoint(Checker.getNextSegmentStart(
+ _trackInfo.getTrack(), _trackInfo.getSelection().getCurrentPointIndex()));
+ // Check for home and end
+ else if (code == KeyEvent.VK_HOME)
+ _trackInfo.selectPoint(0);
+ else if (code == KeyEvent.VK_END)
+ _trackInfo.selectPoint(_trackInfo.getTrack().getNumPoints()-1);
}
else
{
else if (code == KeyEvent.VK_LEFT)
rightwardsPan = -PAN_DISTANCE;
panMap(rightwardsPan, upwardsPan);
- // Check for delete key to delete current point
- if (code == KeyEvent.VK_DELETE && currPointIndex >= 0)
- {
+ // Check for escape
+ if (code == KeyEvent.VK_ESCAPE)
+ _drawMode = MODE_DEFAULT;
+ // Check for backspace key to delete current point (delete key already handled by menu)
+ else if (code == KeyEvent.VK_BACK_SPACE && currPointIndex >= 0) {
_app.deleteCurrentPoint();
}
}
public void mouseWheelMoved(MouseWheelEvent inE)
{
int clicks = inE.getWheelRotation();
- if (clicks < 0)
+ if (clicks < 0) {
+ panMap((inE.getX() - getWidth()/2)/2, (inE.getY() - getHeight()/2)/2);
zoomIn();
- else if (clicks > 0)
+ }
+ else if (clicks > 0) {
+ panMap(-(inE.getX() - getWidth()/2), -(inE.getY() - getHeight()/2));
zoomOut();
+ }
}
/**