src/tim/prune/gui/map/MapCanvas.java

   1 package tim.prune.gui.map;
   2
   3 import java.awt.*;
   4 import java.awt.event.*;
   5 import java.awt.image.BufferedImage;
   6
   7 import javax.swing.*;
   8 import javax.swing.event.ChangeEvent;
   9 import javax.swing.event.ChangeListener;
  10
  11 import tim.prune.App;
  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;
  26
  27 /**
  28  * Class for the map canvas, to display a background map and draw on it
  29  */
  30 public class MapCanvas extends JPanel implements MouseListener, MouseMotionListener, DataSubscriber,
  31         KeyListener, MouseWheelListener, TileConsumer
  32 {
  33         /** App object for callbacks */
  34         private App _app = null;
  35         /** Track object */
  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;
  47         /** Tile manager */
  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;
  71         /** Scale bar */
  72         private ScaleBar _scaleBar = null;
  73         /* Data */
  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;
  79         /** Map position */
  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;
  93
  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;
 100
 101         // Colours
 102         private static final Color COLOR_MESSAGES   = Color.GRAY;
 103
 104         // Drawing modes
 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;
 112
 113         private static final int INDEX_UNKNOWN  = -2;
 114
 115
 116         /**
 117          * Constructor
 118          * @param inApp App object for callbacks
 119          * @param inTrackInfo track info object
 120          */
 121         public MapCanvas(App inApp, TrackInfo inTrackInfo)
 122         {
 123                 _app = inApp;
 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);
 133
 134                 // Make listener for changes to controls
 135                 ItemListener itemListener = new ItemListener() {
 136                         public void itemStateChanged(ItemEvent e)
 137                         {
 138                                 _recalculate = true;
 139                                 repaint();
 140                         }
 141                 };
 142                 // Make special listener for changes to map checkbox
 143                 ItemListener mapCheckListener = new ItemListener() {
 144                         public void itemStateChanged(ItemEvent e)
 145                         {
 146                                 _tileManager.clearMemoryCaches();
 147                                 _recalculate = true;
 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);
 153                                 }
 154                         }
 155                 };
 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)
 167                         {
 168                                 int val = _transparencySlider.getValue();
 169                                 if (val == 1 || val == -1)
 170                                         _transparencySlider.setValue(0);
 171                                 else {
 172                                         _recalculate = true;
 173                                         repaint();
 174                                 }
 175                         }
 176                 });
 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());
 187                         }
 188                 });
 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);
 219
 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);
 228
 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)
 238                         {
 239                                 zoomIn();
 240                         }
 241                 });
 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)
 250                         {
 251                                 zoomOut();
 252                         }
 253                 });
 254                 zoomOutButton.setFocusable(false); // stop button from stealing keyboard focus
 255                 _sidePanel.add(zoomOutButton);
 256
 257                 // Bottom panel for scale bar
 258                 _scaleBar = new ScaleBar();
 259
 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);
 267                 // Make popup menu
 268                 makePopup();
 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);
 273         }
 274
 275
 276         /**
 277          * Make the popup menu for right-clicking the map
 278          */
 279         private void makePopup()
 280         {
 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)
 285                         {
 286                                 panMap((_popupMenuX - getWidth()/2)/2, (_popupMenuY - getHeight()/2)/2);
 287                                 zoomIn();
 288                         }});
 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)
 293                         {
 294                                 panMap(-(_popupMenuX - getWidth()/2), -(_popupMenuY - getHeight()/2));
 295                                 zoomOut();
 296                         }});
 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)
 301                         {
 302                                 zoomToFit();
 303                                 _recalculate = true;
 304                                 repaint();
 305                         }});
 306                 _popup.add(zoomFullItem);
 307                 _popup.addSeparator();
 308                 // Set background
 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)
 313                         {
 314                                 FunctionLibrary.FUNCTION_SET_MAP_BG.begin();
 315                         }});
 316                 _popup.add(setMapBgItem);
 317                 // new point option
 318                 JMenuItem newPointItem = new JMenuItem(I18nManager.getText("menu.map.newpoint"));
 319                 newPointItem.addActionListener(new ActionListener() {
 320                         public void actionPerformed(ActionEvent e)
 321                         {
 322                                 _app.createPoint(createPointFromClick(_popupMenuX, _popupMenuY));
 323                         }});
 324                 _popup.add(newPointItem);
 325                 // draw point series
 326                 JMenuItem drawPointsItem = new JMenuItem(I18nManager.getText("menu.map.drawpoints"));
 327                 drawPointsItem.addActionListener(new ActionListener() {
 328                         public void actionPerformed(ActionEvent e)
 329                         {
 330                                 _drawMode = MODE_DRAW_POINTS_START;
 331                         }
 332                 });
 333                 _popup.add(drawPointsItem);
 334         }
 335
 336
 337         /**
 338          * Zoom to fit the current data area
 339          */
 340         private void zoomToFit()
 341         {
 342                 if (_track.getNumPoints() > 0)
 343                 {
 344                         _latRange = _track.getLatRange();
 345                         _lonRange = _track.getLonRange();
 346                 }
 347                 if (_latRange == null || _lonRange == null
 348                         || !_latRange.hasData() || !_lonRange.hasData())
 349                 {
 350                         setDefaultLatLonRange();
 351                 }
 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());
 361         }
 362
 363         /**
 364          * Track data is empty, so find a default area on the map to show
 365          */
 366         private void setDefaultLatLonRange()
 367         {
 368                 String storedRange = Config.getConfigString(Config.KEY_LATLON_RANGE);
 369                 // Parse it into four latlon values
 370                 try
 371                 {
 372                         String[] values = storedRange.split(";");
 373                         if (values.length == 4)
 374                         {
 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)
 378                                 {
 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)
 383                                         {
 384                                                 _lonRange = new DoubleRange(lon1, lon2);
 385                                                 return;
 386                                         }
 387                                 }
 388                         }
 389                 }
 390                 catch (Exception e) {}
 391                 _latRange = new DoubleRange(45.8, 47.9);
 392                 _lonRange = new DoubleRange(5.9, 10.6);
 393         }
 394
 395         /**
 396          * Paint method
 397          * @see java.awt.Canvas#paint(java.awt.Graphics)
 398          */
 399         public void paint(Graphics inG)
 400         {
 401                 super.paint(inG);
 402                 if (_mapImage != null && (_mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())) {
 403                         _mapImage = null;
 404                 }
 405                 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
 406                 final boolean showSomething = _track.getNumPoints() > 0 || showMap;
 407                 if (showSomething)
 408                 {
 409                         // Check for autopan if enabled / necessary
 410                         if (_autopanCheckBox.isSelected())
 411                         {
 412                                 int selectedPoint = _selection.getCurrentPointIndex();
 413                                 if (selectedPoint >= 0 && _dragFromX == -1 && selectedPoint != _prevSelectedPoint)
 414                                 {
 415                                         autopanToPoint(selectedPoint);
 416                                 }
 417                                 _prevSelectedPoint = selectedPoint;
 418                         }
 419
 420                         // Recognise empty map position, if no data has been loaded
 421                         if (_mapPosition.isEmpty())
 422                         {
 423                                 // Set to some default area
 424                                 zoomToFit();
 425                                 _recalculate = true;
 426                         }
 427
 428                         // Draw the map contents if necessary
 429                         if (_mapImage == null || _recalculate)
 430                         {
 431                                 paintMapContents();
 432                                 _scaleBar.updateScale(_mapPosition.getZoom(), _mapPosition.getYFromPixels(0, 0));
 433                         }
 434                         // Draw the prepared image onto the panel
 435                         if (_mapImage != null) {
 436                                 inG.drawImage(_mapImage, 0, 0, getWidth(), getHeight(), null);
 437                         }
 438
 439                         switch (_drawMode)
 440                         {
 441                                 case MODE_DRAG_POINT:
 442                                         drawDragLines(inG, _selection.getCurrentPointIndex()-1, _selection.getCurrentPointIndex()+1);
 443                                         break;
 444
 445                                 case MODE_CREATE_MIDPOINT:
 446                                         drawDragLines(inG, _clickedPoint-1, _clickedPoint);
 447                                         break;
 448
 449                                 case MODE_ZOOM_RECT:
 450                                 case MODE_MARK_RECTANGLE:
 451                                         if (_dragFromX != -1 && _dragFromY != -1)
 452                                         {
 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);
 459                                         }
 460                                         break;
 461
 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);
 469                                         break;
 470                         }
 471                 }
 472                 else
 473                 {
 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);
 479                 }
 480                 // enable or disable panels
 481                 _topPanel.setVisible(showSomething);
 482                 _sidePanel.setVisible(showSomething);
 483                 // Draw slider etc on top
 484                 paintChildren(inG);
 485         }
 486
 487         /**
 488          * @return true if the currently selected point is visible, false if off-screen or nothing selected
 489          */
 490         private boolean isCurrentPointVisible()
 491         {
 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);
 498         }
 499
 500         /**
 501          * If the specified point isn't visible, pan to it
 502          * @param inIndex index of selected point
 503          */
 504         private void autopanToPoint(int inIndex)
 505         {
 506                 int px = getWidth() / 2 + _mapPosition.getXFromCentre(_track.getX(inIndex));
 507                 int py = getHeight() / 2 + _mapPosition.getYFromCentre(_track.getY(inIndex));
 508                 int panX = 0;
 509                 int panY = 0;
 510                 if (px < PAN_DISTANCE) {
 511                         panX = px - AUTOPAN_DISTANCE;
 512                 }
 513                 else if (px > (getWidth()-PAN_DISTANCE)) {
 514                         panX = AUTOPAN_DISTANCE + px - getWidth();
 515                 }
 516                 if (py < (2*PAN_DISTANCE)) {
 517                         panY = py - AUTOPAN_DISTANCE;
 518                 }
 519                 if (py > (getHeight()-PAN_DISTANCE)) {
 520                         panY = AUTOPAN_DISTANCE + py - getHeight();
 521                 }
 522                 if (panX != 0 || panY != 0) {
 523                         _mapPosition.pan(panX, panY);
 524                 }
 525         }
 526
 527         /**
 528          * Paint the map tiles and the points on to the _mapImage
 529          */
 530         private void paintMapContents()
 531         {
 532                 if (_mapImage == null || _mapImage.getWidth() != getWidth() || _mapImage.getHeight() != getHeight())
 533                 {
 534                         _mapImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_RGB);
 535                 }
 536
 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());
 544
 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))
 552                 {
 553                         SwingUtilities.invokeLater(new Runnable() {
 554                                 public void run() {
 555                                         _app.showTip(TipManager.Tip_UseAMapCache);
 556                                 }
 557                         });
 558                 }
 559
 560                 // reset error message
 561                 if (!showMap) {_shownMapLoadErrorAlready = false;}
 562                 _recalculate = false;
 563                 // Only get map tiles if selected
 564                 if (showMap)
 565                 {
 566                         // init tile cacher
 567                         _tileManager.centreMap(_mapPosition.getZoom(), _mapPosition.getCentreTileX(), _mapPosition.getCentreTileY());
 568
 569                         boolean loadingFailed = false;
 570                         if (_mapImage == null) return;
 571
 572                         if (_tileManager.isOverzoomed())
 573                         {
 574                                 // display overzoom message
 575                                 g.setColor(COLOR_MESSAGES);
 576                                 g.drawString(I18nManager.getText("map.overzoom"), 50, getHeight()/2);
 577                         }
 578                         else
 579                         {
 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++)
 585                                 {
 586                                         int x = (tileX - tileIndices[0]) * 256 - pixelOffsets[0];
 587                                         for (int tileY = tileIndices[2]; tileY <= tileIndices[3]; tileY++)
 588                                         {
 589                                                 int y = (tileY - tileIndices[2]) * 256 - pixelOffsets[1];
 590                                                 // Loop over layers
 591                                                 for (int l=0; l<numLayers; l++)
 592                                                 {
 593                                                         Image image = _tileManager.getTile(l, tileX, tileY, true);
 594                                                         if (image != null) {
 595                                                                 g.drawImage(image, x, y, 256, 256, null);
 596                                                         }
 597                                                 }
 598                                         }
 599                                 }
 600
 601                                 // Make maps brighter / fainter according to slider
 602                                 final int brightnessIndex = Math.max(1, _transparencySlider.getValue()) - 1;
 603                                 if (brightnessIndex > 0)
 604                                 {
 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]);
 608                                         g.setColor(bgColor);
 609                                         g.fillRect(0, 0, getWidth(), getHeight());
 610                                 }
 611                         }
 612                 }
 613
 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()];
 619                 }
 620
 621                 if (trackOpacity > 0.0f)
 622                 {
 623                         // Paint the track points on top
 624                         boolean pointsPainted = true;
 625                         try
 626                         {
 627                                 if (trackOpacity > 0.9f)
 628                                 {
 629                                         // Track is fully opaque, just draw it directly
 630                                         pointsPainted = paintPoints(g);
 631                                         _trackImage = null;
 632                                 }
 633                                 else
 634                                 {
 635                                         // Track is partly transparent, so use a separate BufferedImage
 636                                         if (_trackImage == null || _trackImage.getWidth() != getWidth() || _trackImage.getHeight() != getHeight())
 637                                         {
 638                                                 _trackImage = new BufferedImage(getWidth(), getHeight(), BufferedImage.TYPE_INT_ARGB);
 639                                         }
 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);
 649                                 }
 650                         }
 651                         catch (NullPointerException npe) {} // ignore, probably due to data being changed during drawing
 652                         catch (ArrayIndexOutOfBoundsException obe) {} // also ignore
 653
 654                         // Zoom to fit if no points found
 655                         if (!pointsPainted && _checkBounds)
 656                         {
 657                                 zoomToFit();
 658                                 _recalculate = true;
 659                                 repaint();
 660                         }
 661                 }
 662
 663                 // free g
 664                 g.dispose();
 665
 666                 _checkBounds = false;
 667                 // enable / disable transparency slider
 668                 _transparencySlider.setEnabled(showMap);
 669         }
 670
 671
 672         /**
 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
 676          */
 677         private boolean paintPoints(Graphics inG)
 678         {
 679                 // Set up colours
 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();
 687
 688                 final int winWidth  = getWidth();
 689                 final int winHeight = getHeight();
 690                 final int halfWinWidth  = winWidth / 2;
 691                 final int halfWinHeight = winHeight / 2;
 692
 693                 final int numPoints = _track.getNumPoints();
 694                 final int[] xPixels = new int[numPoints];
 695                 final int[] yPixels = new int[numPoints];
 696
 697                 final int pointSeparationForArrowsSqd = 400;
 698                 final int pointSeparation1dForArrows = (int) (Math.sqrt(pointSeparationForArrowsSqd) * 0.7);
 699                 final int hugePointSeparationForArrows = 120;
 700
 701                 // try to set line width for painting
 702                 if (inG instanceof Graphics2D)
 703                 {
 704                         int lineWidth = Config.getConfigInt(Config.KEY_LINE_WIDTH);
 705                         if (lineWidth < 1 || lineWidth > 4) {lineWidth = 2;}
 706                         ((Graphics2D) inG).setStroke(new BasicStroke(lineWidth));
 707                 }
 708
 709                 boolean pointsPainted = false;
 710                 // draw track points
 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
 717
 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++)
 723                 {
 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;
 730
 731                         currPointVisible = px >= 0 && px < winWidth && py >= 0 && py < winHeight;
 732                         isWaypoint = _track.getPoint(i).isWaypoint();
 733                         anyWaypoints = anyWaypoints || isWaypoint;
 734                         if (!isWaypoint)
 735                         {
 736                                 if (currPointVisible || (drawLines && prevPointVisible))
 737                                 {
 738                                         // For track points, work out which colour to use
 739                                         if (_track.getPoint(i).getDeleteFlag()) {
 740                                                 inG.setColor(currentColour);
 741                                         }
 742                                         else if (pointColourer != null)
 743                                         {  // use the point colourer if there is one
 744                                                 Color trackColour = pointColourer.getColour(i);
 745                                                 inG.setColor(trackColour);
 746                                         }
 747                                         else
 748                                         {
 749                                                 inG.setColor(pointColour);
 750                                         }
 751
 752                                         // Draw rectangle for track point if it's visible
 753                                         if (currPointVisible)
 754                                         {
 755                                                 if (drawPoints) {
 756                                                         inG.drawRect(px-2, py-2, 3, 3);
 757                                                 }
 758                                                 pointsPainted = true;
 759                                         }
 760                                 }
 761
 762                                 // Connect track points if either of them are visible
 763                                 if (drawLines
 764                                  && (currPointVisible || prevPointVisible)
 765                                  && !(prevX == -1 && prevY == -1)
 766                                  && !_track.getPoint(i).getSegmentStart())
 767                                 {
 768                                         inG.drawLine(prevX, prevY, px, py);
 769                                         pointsPainted = true;
 770
 771                                         // Now consider whether we need to draw an arrow as well
 772                                         if (drawArrows)
 773                                         {
 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)
 777                                                 {
 778                                                         final double pointSeparationSqd = (prevX-px) * (prevX-px) + (prevY-py) * (prevY-py);
 779                                                         if (pointSeparationSqd > pointSeparationForArrowsSqd)
 780                                                         {
 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;
 784                                                                 if (midPointVisible)
 785                                                                 {
 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);
 796                                                                 }
 797                                                                 drawnLastArrow = midPointVisible;
 798                                                         }
 799                                                 }
 800                                                 else
 801                                                 {
 802                                                         drawnLastArrow = false;
 803                                                 }
 804                                         }
 805                                 }
 806                                 prevX = px; prevY = py;
 807                         }
 808                         prevPointVisible = currPointVisible;
 809                 }
 810
 811                 // Loop over points, just drawing blobs for waypoints
 812                 inG.setColor(textColour);
 813                 FontMetrics fm = inG.getFontMetrics();
 814                 int nameHeight = fm.getHeight();
 815                 if (anyWaypoints)
 816                 {
 817                         int numWaypoints = 0;
 818                         for (int i=0; i<_track.getNumPoints(); i++)
 819                         {
 820                                 if (_track.getPoint(i).isWaypoint())
 821                                 {
 822                                         int px = xPixels[i];
 823                                         int py = yPixels[i];
 824                                         if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
 825                                         {
 826                                                 if (_waypointIconDefinition == null)
 827                                                 {
 828                                                         inG.fillRect(px-3, py-3, 6, 6);
 829                                                 }
 830                                                 else
 831                                                 {
 832                                                         ImageIcon icon = _waypointIconDefinition.getImageIcon();
 833                                                         if (icon != null)
 834                                                         {
 835                                                                 inG.drawImage(icon.getImage(), px-_waypointIconDefinition.getXOffset(),
 836                                                                         py-_waypointIconDefinition.getYOffset(), null);
 837                                                         }
 838                                                 }
 839                                                 pointsPainted = true;
 840                                                 numWaypoints++;
 841                                         }
 842                                 }
 843                         }
 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);
 847
 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)
 852                         {
 853                                 if (_track.getPoint(i).isWaypoint())
 854                                 {
 855                                         int px = xPixels[i];
 856                                         int py = yPixels[i];
 857                                         if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
 858                                         {
 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++)
 869                                                 {
 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++)
 875                                                         {
 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))
 879                                                                 {
 880                                                                         // Found a rectangle to fit - draw name here and quit
 881                                                                         inG.drawString(waypointName, nameXs[a], nameYs[a]);
 882                                                                         drawnName = true;
 883                                                                         break;
 884                                                                 }
 885                                                         }
 886                                                 }
 887                                         }
 888                                 }
 889                         }
 890                 }
 891                 // Loop over points, drawing blobs for photo / audio points
 892                 inG.setColor(secondColour);
 893                 for (int i=0; i<_track.getNumPoints(); i++)
 894                 {
 895                         if (_track.getPoint(i).hasMedia())
 896                         {
 897                                 int px = xPixels[i];
 898                                 int py = yPixels[i];
 899                                 if (px >= 0 && px < winWidth && py >= 0 && py < winHeight)
 900                                 {
 901                                         inG.drawRect(px-1, py-1, 2, 2);
 902                                         inG.drawRect(px-2, py-2, 4, 4);
 903                                         pointsPainted = true;
 904                                 }
 905                         }
 906                 }
 907
 908                 // Draw selected range
 909                 if (_selection.hasRangeSelected())
 910                 {
 911                         inG.setColor(rangeColour);
 912                         for (int i=_selection.getStart(); i<=_selection.getEnd(); i++)
 913                         {
 914                                 int px = xPixels[i];
 915                                 int py = yPixels[i];
 916                                 inG.drawRect(px-1, py-1, 2, 2);
 917                         }
 918                 }
 919
 920                 // Draw crosshairs at selected point
 921                 int selectedPoint = _selection.getCurrentPointIndex();
 922                 if (selectedPoint >= 0)
 923                 {
 924                         int px = xPixels[selectedPoint];
 925                         int py = yPixels[selectedPoint];
 926                         inG.setColor(currentColour);
 927                         // crosshairs
 928                         inG.drawLine(px, 0, px, winHeight);
 929                         inG.drawLine(0, py, winWidth, py);
 930                 }
 931                 // Return the number of points painted
 932                 return pointsPainted;
 933         }
 934
 935         /**
 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
 941          */
 942         private static int wrapLongitudeValue(int inPx, int inWinWidth, int inZoom)
 943         {
 944                 if (inPx > inWinWidth)
 945                 {
 946                         // Pixel is too far right, could we wrap it back onto the screen?
 947                         int px = inPx;
 948                         while (px > inWinWidth) {
 949                                 px -= (256 << inZoom);
 950                         }
 951                         if (px >= 0) {
 952                                 return px; // successfully wrapped back onto the screen
 953                         }
 954                 }
 955                 else if (inPx < 0)
 956                 {
 957                         // Pixel is too far left, could we wrap it back onto the screen?
 958                         int px = inPx;
 959                         while (px < 0) {
 960                                 px += (256 << inZoom);
 961                         }
 962                         if (px < inWinWidth) {
 963                                 return px; // successfully wrapped back onto the screen
 964                         }
 965                 }
 966                 // Either it's already on the screen or couldn't be wrapped
 967                 return inPx;
 968         }
 969
 970         /**
 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
 975          */
 976         private void drawDragLines(Graphics inG, int inPrevIndex, int inNextIndex)
 977         {
 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())
 981                 {
 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);
 985                 }
 986                 if (inNextIndex < _track.getNumPoints() && !_track.getPoint(inNextIndex).getSegmentStart())
 987                 {
 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);
 991                 }
 992         }
 993
 994         /**
 995          * Inform that tiles have been updated and the map can be repainted
 996          * @param inIsOk true if data loaded ok, false for error
 997          */
 998         public void tilesUpdated(boolean inIsOk)
 999         {
1000                 synchronized(this)
1001                 {
1002                         // Show message if loading failed (but not too many times)
1003                         if (!inIsOk && !_shownMapLoadErrorAlready && _mapCheckBox.isSelected())
1004                         {
1005                                 _shownMapLoadErrorAlready = true;
1006                                 // use separate thread to show message about failing to load osm images
1007                                 new Thread(new Runnable() {
1008                                         public void run() {
1009                                                 try {Thread.sleep(500);} catch (InterruptedException ie) {}
1010                                                 _app.showErrorMessage("error.osmimage.dialogtitle", "error.osmimage.failed");
1011                                         }
1012                                 }).start();
1013                         }
1014                         _recalculate = true;
1015                         repaint();
1016                 }
1017         }
1018
1019         /**
1020          * Inform that a cache failure occurred
1021          */
1022         public void reportCacheFailure()
1023         {
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);
1026         }
1027
1028         /**
1029          * Zoom out, if not already at minimum zoom
1030          */
1031         public void zoomOut()
1032         {
1033                 _mapPosition.zoomOut();
1034                 _recalculate = true;
1035                 repaint();
1036         }
1037
1038         /**
1039          * Zoom in, if not already at maximum zoom
1040          */
1041         public void zoomIn()
1042         {
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());
1048                 }
1049                 _recalculate = true;
1050                 repaint();
1051         }
1052
1053         /**
1054          * Pan map
1055          * @param inDeltaX x shift
1056          * @param inDeltaY y shift
1057          */
1058         public void panMap(int inDeltaX, int inDeltaY)
1059         {
1060                 _mapPosition.pan(inDeltaX, inDeltaY);
1061                 _recalculate = true;
1062                 repaint();
1063         }
1064
1065         /**
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
1070          */
1071         private DataPoint createPointFromClick(int inX, int inY)
1072         {
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);
1077         }
1078
1079         /**
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
1085          */
1086         private void movePointToMouse(int startX, int startY, int endX, int endY )
1087         {
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;
1092
1093                 DataPoint point = _trackInfo.getCurrentPoint();
1094                 if (point == null) {
1095                         return;
1096                 }
1097
1098                 // Make lists for edit and undo, and add each changed field in turn
1099                 FieldEditList editList = new FieldEditList();
1100                 FieldEditList undoList = new FieldEditList();
1101
1102                 // Check field list
1103                 FieldList fieldList = _track.getFieldList();
1104                 int numFields = fieldList.getNumFields();
1105                 for (int i=0; i<numFields; i++)
1106                 {
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)));
1111                         }
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)));
1115                         }
1116                 }
1117                 _app.completePointEdit(editList, undoList);
1118         }
1119
1120
1121         /**
1122          * @see javax.swing.JComponent#getMinimumSize()
1123          */
1124         public Dimension getMinimumSize()
1125         {
1126                 final Dimension minSize = new Dimension(512, 300);
1127                 return minSize;
1128         }
1129
1130         /**
1131          * @see javax.swing.JComponent#getPreferredSize()
1132          */
1133         public Dimension getPreferredSize()
1134         {
1135                 return getMinimumSize();
1136         }
1137
1138
1139         /**
1140          * Respond to mouse click events
1141          * @see java.awt.event.MouseListener#mouseClicked(java.awt.event.MouseEvent)
1142          */
1143         public void mouseClicked(MouseEvent inE)
1144         {
1145                 final boolean showMap = Config.getConfigBoolean(Config.KEY_SHOW_MAP);
1146                 final boolean hasPoints = _track != null && _track.getNumPoints() > 0;
1147                 if (showMap || hasPoints)
1148                 {
1149                         // select point if it's a left-click
1150                         if (!inE.isMetaDown())
1151                         {
1152                                 if (inE.getClickCount() == 1)
1153                                 {
1154                                         // single left click
1155                                         if (_drawMode == MODE_DEFAULT && hasPoints)
1156                                         {
1157                                                 int pointIndex = _clickedPoint;
1158                                                 if (pointIndex == INDEX_UNKNOWN)
1159                                                 {
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);
1165                                                 }
1166                                                 // Extend selection for shift-click
1167                                                 if (inE.isShiftDown()) {
1168                                                         _trackInfo.extendSelection(pointIndex);
1169                                                 }
1170                                                 else {
1171                                                         _trackInfo.selectPoint(pointIndex);
1172                                                 }
1173                                         }
1174                                         else if (_drawMode == MODE_DRAW_POINTS_START)
1175                                         {
1176                                                 _app.createPoint(createPointFromClick(inE.getX(), inE.getY()));
1177                                                 _dragToX = inE.getX();
1178                                                 _dragToY = inE.getY();
1179                                                 _drawMode = MODE_DRAW_POINTS_CONT;
1180                                         }
1181                                         else if (_drawMode == MODE_DRAW_POINTS_CONT)
1182                                         {
1183                                                 DataPoint point = createPointFromClick(inE.getX(), inE.getY());
1184                                                 _app.createPoint(point, false); // not a new segment
1185                                         }
1186                                 }
1187                                 else if (inE.getClickCount() == 2)
1188                                 {
1189                                         // double click
1190                                         if (_drawMode == MODE_DEFAULT) {
1191                                                 panMap(inE.getX() - getWidth()/2, inE.getY() - getHeight()/2);
1192                                                 zoomIn();
1193                                         }
1194                                         else if (_drawMode == MODE_DRAW_POINTS_START || _drawMode == MODE_DRAW_POINTS_CONT) {
1195                                                 _drawMode = MODE_DEFAULT;
1196                                         }
1197                                 }
1198                         }
1199                         else
1200                         {
1201                                 // show the popup menu for right-clicks
1202                                 _popupMenuX = inE.getX();
1203                                 _popupMenuY = inE.getY();
1204                                 _popup.show(this, _popupMenuX, _popupMenuY);
1205                         }
1206                 }
1207                 // Reset app mode
1208                 _app.setCurrentMode(App.AppMode.NORMAL);
1209                 if (_drawMode == MODE_MARK_RECTANGLE) _drawMode = MODE_DEFAULT;
1210         }
1211
1212         /**
1213          * Ignore mouse enter events
1214          * @see java.awt.event.MouseListener#mouseEntered(java.awt.event.MouseEvent)
1215          */
1216         public void mouseEntered(MouseEvent inE)
1217         {
1218                 // ignore
1219         }
1220
1221         /**
1222          * Ignore mouse exited events
1223          * @see java.awt.event.MouseListener#mouseExited(java.awt.event.MouseEvent)
1224          */
1225         public void mouseExited(MouseEvent inE)
1226         {
1227                 // ignore
1228         }
1229
1230         /**
1231          * React to mouse pressed events to initiate a point drag
1232          * @see java.awt.event.MouseListener#mousePressed(java.awt.event.MouseEvent)
1233          */
1234         public void mousePressed(MouseEvent inE)
1235         {
1236                 _clickedPoint = INDEX_UNKNOWN;
1237                 if (_track == null || _track.getNumPoints() <= 0)
1238                         return;
1239                 if (!inE.isMetaDown())
1240                 {
1241                         // Left mouse drag - check if point is near; if so select it for dragging
1242                         if (_drawMode == MODE_DEFAULT)
1243                         {
1244                                 /* Drag points if edit mode is enabled OR ALT is pressed */
1245                                 if (_editmodeCheckBox.isSelected() || inE.isAltDown() || inE.isAltGraphDown())
1246                                 {
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);
1251
1252                                         if (_clickedPoint >= 0)
1253                                         {
1254                                                 // TODO: maybe use another color of the cross or remove the cross while dragging???
1255
1256                                                 _trackInfo.selectPoint(_clickedPoint);
1257                                                 if (_trackInfo.getCurrentPoint() != null)
1258                                                 {
1259                                                         _drawMode = MODE_DRAG_POINT;
1260                                                         _dragFromX = _dragToX = inE.getX();
1261                                                         _dragFromY = _dragToY = inE.getY();
1262                                                 }
1263                                         }
1264                                         else
1265                                         {
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)
1269                                                 {
1270                                                         _drawMode = MODE_CREATE_MIDPOINT;
1271                                                         _clickedPoint = midpointIndex;
1272                                                         _dragFromX = _dragToX = inE.getX();
1273                                                         _dragFromY = _dragToY = inE.getY();
1274                                                 }
1275                                         }
1276                                 }
1277                         }
1278                 }
1279                 // else right-press ignored
1280         }
1281
1282         /**
1283          * Respond to mouse released events
1284          * @see java.awt.event.MouseListener#mouseReleased(java.awt.event.MouseEvent)
1285          */
1286         public void mouseReleased(MouseEvent inE)
1287         {
1288                 _recalculate = true;
1289
1290                 if (_drawMode == MODE_DRAG_POINT)
1291                 {
1292                         if (Math.abs(_dragToX - _dragFromX) > 2
1293                                 || Math.abs(_dragToY - _dragFromY) > 2)
1294                         {
1295                                 movePointToMouse(_dragFromX, _dragFromY, _dragToX, _dragToY );
1296                         }
1297                         _drawMode = MODE_DEFAULT;
1298                 }
1299                 else if (_drawMode == MODE_CREATE_MIDPOINT)
1300                 {
1301                         _drawMode = MODE_DEFAULT;
1302                         _app.createPoint(createPointFromClick(_dragToX, _dragToY), _clickedPoint);
1303                 }
1304                 else if (_drawMode == MODE_ZOOM_RECT)
1305                 {
1306                         if (Math.abs(_dragToX - _dragFromX) > 20
1307                          && Math.abs(_dragToY - _dragFromY) > 20)
1308                         {
1309                                 _mapPosition.zoomToPixels(_dragFromX, _dragToX, _dragFromY, _dragToY, getWidth(), getHeight());
1310                         }
1311                         _drawMode = MODE_DEFAULT;
1312                 }
1313                 else if (_drawMode == MODE_MARK_RECTANGLE)
1314                 {
1315                         // Reset app mode
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) {
1326                                 lon1 = lon2;
1327                                 lat1 = lat2;
1328                         }
1329                         marker.setRectCoords(lon1, lat1, lon2, lat2);
1330                         marker.begin();
1331                 }
1332                 _dragFromX = _dragFromY = -1;
1333                 repaint();
1334         }
1335
1336         /**
1337          * Respond to mouse drag events
1338          * @see java.awt.event.MouseMotionListener#mouseDragged(java.awt.event.MouseEvent)
1339          */
1340         public void mouseDragged(MouseEvent inE)
1341         {
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;
1347                 if (isRightDrag)
1348                 {
1349                         // Right-click and drag - update rectangle
1350                         _drawMode = MODE_ZOOM_RECT;
1351                         if (_dragFromX == -1) {
1352                                 _dragFromX = inE.getX();
1353                                 _dragFromY = inE.getY();
1354                         }
1355                         _dragToX = inE.getX();
1356                         _dragToY = inE.getY();
1357                         repaint();
1358                 }
1359                 else
1360                 {
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)
1364                         {
1365                                 // move point
1366                                 _dragToX = inE.getX();
1367                                 _dragToY = inE.getY();
1368                                 _recalculate = true;
1369                                 repaint();
1370                         }
1371                         else if (_drawMode == MODE_MARK_RECTANGLE)
1372                         {
1373                                 // draw a rectangle for marking points
1374                                 if (_dragFromX == -1) {
1375                                         _dragFromX = inE.getX();
1376                                         _dragFromY = inE.getY();
1377                                 }
1378                                 _dragToX = inE.getX();
1379                                 _dragToY = inE.getY();
1380                                 repaint();
1381                         }
1382                         else
1383                         {
1384                                 // regular left-drag pans map by appropriate amount
1385                                 if (_dragFromX != -1)
1386                                 {
1387                                         panMap(_dragFromX - inE.getX(), _dragFromY - inE.getY());
1388                                 }
1389                                 _dragFromX = _dragToX = inE.getX();
1390                                 _dragFromY = _dragToY = inE.getY();
1391                         }
1392                 }
1393         }
1394
1395         /**
1396          * Respond to mouse move events without button pressed
1397          * @param inEvent ignored
1398          */
1399         public void mouseMoved(MouseEvent inEvent)
1400         {
1401                 boolean useCrosshairs = false;
1402                 boolean useResize     = false;
1403                 // Ignore unless we're drawing points
1404                 if (_drawMode == MODE_DRAW_POINTS_CONT)
1405                 {
1406                         _dragToX = inEvent.getX();
1407                         _dragToY = inEvent.getY();
1408                         repaint();
1409                 }
1410                 else if (_drawMode == MODE_MARK_RECTANGLE) {
1411                         useResize = true;
1412                 }
1413                 else if (_editmodeCheckBox.isSelected() || inEvent.isAltDown() || inEvent.isAltGraphDown())
1414                 {
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
1422                         );
1423                 }
1424                 if (useCrosshairs && !isCursorSet()) {
1425                         setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));
1426                 }
1427                 else if (useResize && !isCursorSet()) {
1428                         setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1429                 }
1430                 else if (!useCrosshairs && !useResize && isCursorSet()) {
1431                         setCursor(null);
1432                 }
1433         }
1434
1435         /**
1436          * Respond to status bar message from broker
1437          * @param inMessage message, ignored
1438          */
1439         public void actionCompleted(String inMessage)
1440         {
1441                 // ignore
1442         }
1443
1444         /**
1445          * Respond to data updated message from broker
1446          * @param inUpdateType type of update
1447          */
1448         public void dataUpdated(byte inUpdateType)
1449         {
1450                 _recalculate = true;
1451                 if ((inUpdateType & DataSubscriber.DATA_ADDED_OR_REMOVED) > 0) {
1452                         _checkBounds = true;
1453                 }
1454                 if ((inUpdateType & DataSubscriber.MAPSERVER_CHANGED) > 0)
1455                 {
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)
1460                         {
1461                                 _waypointIconDefinition = null;
1462                         }
1463                         else
1464                         {
1465                                 final int wpSize = Config.getConfigInt(Config.KEY_WAYPOINT_ICON_SIZE);
1466                                 _waypointIconDefinition = WpIconLibrary.getIconDefinition(wpType, wpSize);
1467                         }
1468                 }
1469                 if ((inUpdateType & (DataSubscriber.DATA_ADDED_OR_REMOVED + DataSubscriber.DATA_EDITED)) > 0) {
1470                         _midpoints.updateData(_track);
1471                 }
1472                 // See if rect mode has been activated
1473                 if (_app.getCurrentMode() == App.AppMode.DRAWRECT)
1474                 {
1475                         _drawMode = MODE_MARK_RECTANGLE;
1476                         if (!isCursorSet()) {
1477                                 setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));
1478                         }
1479                 }
1480                 repaint();
1481                 // grab focus for the key presses
1482                 this.requestFocus();
1483         }
1484
1485         /**
1486          * Respond to key presses on the map canvas
1487          * @param inE key event
1488          */
1489         public void keyPressed(KeyEvent inE)
1490         {
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())
1495                 {
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)
1500                                 zoomIn();
1501                         else if (code == KeyEvent.VK_DOWN)
1502                                 zoomOut();
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);
1519                 }
1520                 else
1521                 {
1522                         // Check for arrow keys to pan
1523                         int upwardsPan = 0;
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);
1534                         // Check for escape
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();
1540                         }
1541                 }
1542         }
1543
1544         /**
1545          * @param inE key released event, ignored
1546          */
1547         public void keyReleased(KeyEvent e)
1548         {
1549                 // ignore
1550         }
1551
1552         /**
1553          * @param inE key typed event, ignored
1554          */
1555         public void keyTyped(KeyEvent inE)
1556         {
1557                 // ignore
1558         }
1559
1560         /**
1561          * @param inE mouse wheel event indicating scroll direction
1562          */
1563         public void mouseWheelMoved(MouseWheelEvent inE)
1564         {
1565                 int clicks = inE.getWheelRotation();
1566                 if (clicks < 0) {
1567                         panMap((inE.getX() - getWidth()/2)/2, (inE.getY() - getHeight()/2)/2);
1568                         zoomIn();
1569                 }
1570                 else if (clicks > 0) {
1571                         panMap(-(inE.getX() - getWidth()/2), -(inE.getY() - getHeight()/2));
1572                         zoomOut();
1573                 }
1574         }
1575
1576         /**
1577          * @return current map position
1578          */
1579         public MapPosition getMapPosition()
1580         {
1581                 return _mapPosition;
1582         }
1583 }