git.gag.com Git - fw/altos/blob - altosuilib/AltosUIMap.java

   1 /*
   2  * Copyright © 2010 Anthony Towns <aj@erisian.com.au>
   3  *
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful, but
  10  * WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA.
  17  */
  18
  19 package org.altusmetrum.altosuilib_13;
  20
  21 import java.awt.*;
  22 import java.awt.event.*;
  23 import java.awt.image.*;
  24 import javax.swing.*;
  25 import java.io.*;
  26 import java.lang.Math;
  27 import java.awt.geom.*;
  28 import java.util.*;
  29 import java.util.concurrent.*;
  30 import javax.imageio.*;
  31 import org.altusmetrum.altoslib_13.*;
  32
  33 public class AltosUIMap extends JComponent implements AltosFlightDisplay, AltosMapInterface {
  34
  35         AltosMap        map;
  36         Graphics2D      g;
  37         Font            tile_font;
  38         Font            line_font;
  39
  40         static Point2D.Double point2d(AltosPointDouble pt) {
  41                 return new Point2D.Double(pt.x, pt.y);
  42         }
  43
  44         static final AltosPointDouble point_double(Point pt) {
  45                 return new AltosPointDouble(pt.x, pt.y);
  46         }
  47
  48         class MapMark extends AltosMapMark {
  49                 public void paint(AltosMapTransform t) {
  50                         AltosPointDouble pt = t.screen(lat_lon);
  51
  52                         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
  53                                            RenderingHints.VALUE_ANTIALIAS_ON);
  54                         g.setStroke(new BasicStroke(stroke_width, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
  55
  56                         if (0 <= state && state < AltosUIMap.stateColors.length)
  57                                 g.setColor(AltosUIMap.stateColors[state]);
  58                         else
  59                                 g.setColor(AltosUIMap.stateColors[AltosLib.ao_flight_invalid]);
  60
  61                         g.drawOval((int)pt.x-5, (int)pt.y-5, 10, 10);
  62                         g.drawOval((int)pt.x-20, (int)pt.y-20, 40, 40);
  63                         g.drawOval((int)pt.x-35, (int)pt.y-35, 70, 70);
  64                 }
  65
  66                 MapMark(double lat, double lon, int state) {
  67                         super(lat, lon, state);
  68                 }
  69         }
  70
  71         class MapView extends JComponent implements MouseMotionListener, MouseListener, ComponentListener, MouseWheelListener {
  72
  73                 private VolatileImage create_back_buffer() {
  74                         return getGraphicsConfiguration().createCompatibleVolatileImage(getWidth(), getHeight());
  75                 }
  76
  77                 private void do_paint(Graphics my_g) {
  78                         g = (Graphics2D) my_g;
  79
  80                         map.paint();
  81                 }
  82
  83                 public void paint(Graphics my_g) {
  84                         VolatileImage   back_buffer = create_back_buffer();
  85
  86                         Graphics2D      top_g = (Graphics2D) my_g;
  87
  88                         do {
  89                                 GraphicsConfiguration gc = getGraphicsConfiguration();
  90                                 int code = back_buffer.validate(gc);
  91                                 if (code == VolatileImage.IMAGE_INCOMPATIBLE)
  92                                         back_buffer = create_back_buffer();
  93
  94                                 Graphics g_back = back_buffer.getGraphics();
  95                                 g_back.setClip(top_g.getClip());
  96                                 do_paint(g_back);
  97                                 g_back.dispose();
  98
  99                                 top_g.drawImage(back_buffer, 0, 0, this);
 100                         } while (back_buffer.contentsLost());
 101                         back_buffer.flush();
 102                 }
 103
 104                 public void repaint(AltosRectangle damage) {
 105                         repaint(damage.x, damage.y, damage.width, damage.height);
 106                 }
 107
 108                 private boolean is_drag_event(MouseEvent e) {
 109                         return e.getModifiersEx() == InputEvent.BUTTON1_DOWN_MASK;
 110                 }
 111
 112                 /* MouseMotionListener methods */
 113
 114                 public void mouseDragged(MouseEvent e) {
 115                         map.touch_continue(e.getPoint().x, e.getPoint().y, is_drag_event(e));
 116                 }
 117
 118                 public void mouseMoved(MouseEvent e) {
 119                 }
 120
 121                 /* MouseListener methods */
 122                 public void mouseClicked(MouseEvent e) {
 123                 }
 124
 125                 public void mouseEntered(MouseEvent e) {
 126                 }
 127
 128                 public void mouseExited(MouseEvent e) {
 129                 }
 130
 131                 public void mousePressed(MouseEvent e) {
 132                         map.touch_start(e.getPoint().x, e.getPoint().y, is_drag_event(e));
 133                 }
 134
 135                 public void mouseReleased(MouseEvent e) {
 136                 }
 137
 138                 /* MouseWheelListener methods */
 139
 140                 public void mouseWheelMoved(MouseWheelEvent e) {
 141                         int     zoom_change = e.getWheelRotation();
 142
 143                         map.set_zoom_centre(map.get_zoom() - zoom_change, new AltosPointInt(e.getPoint().x, e.getPoint().y));
 144                 }
 145
 146                 /* ComponentListener methods */
 147
 148                 public void componentHidden(ComponentEvent e) {
 149                 }
 150
 151                 public void componentMoved(ComponentEvent e) {
 152                 }
 153
 154                 public void componentResized(ComponentEvent e) {
 155                         map.set_transform();
 156                 }
 157
 158                 public void componentShown(ComponentEvent e) {
 159                         map.set_transform();
 160                 }
 161
 162                 MapView() {
 163                         addComponentListener(this);
 164                         addMouseMotionListener(this);
 165                         addMouseListener(this);
 166                         addMouseWheelListener(this);
 167                 }
 168         }
 169
 170         class MapLine extends AltosMapLine {
 171
 172                 public void paint(AltosMapTransform t) {
 173
 174                         if (start == null || end == null)
 175                                 return;
 176
 177                         g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 178
 179                         Line2D.Double line = new Line2D.Double(point2d(t.screen(start)),
 180                                                                point2d(t.screen(end)));
 181
 182                         g.setColor(Color.WHITE);
 183                         g.setStroke(new BasicStroke(stroke_width+4, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
 184                         g.draw(line);
 185
 186                         g.setColor(Color.BLUE);
 187                         g.setStroke(new BasicStroke(stroke_width, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
 188                         g.draw(line);
 189
 190                         String  message = line_dist();
 191                         Rectangle2D     bounds;
 192                         bounds = line_font.getStringBounds(message, g.getFontRenderContext());
 193
 194                         float x = (float) line.x1;
 195                         float y = (float) line.y1 + (float) bounds.getHeight() / 2.0f;
 196
 197                         if (line.x1 < line.x2) {
 198                                 x -= (float) bounds.getWidth() + 2.0f;
 199                         } else {
 200                                 x += 2.0f;
 201                         }
 202
 203                         g.setFont(line_font);
 204                         g.setColor(Color.WHITE);
 205                         for (int dy = -2; dy <= 2; dy += 2)
 206                                 for (int dx = -2; dx <= 2; dx += 2)
 207                                         g.drawString(message, x + dx, y + dy);
 208                         g.setColor(Color.BLUE);
 209                         g.drawString(message, x, y);
 210                 }
 211
 212                 public MapLine() {
 213                 }
 214         }
 215
 216         class MapPath extends AltosMapPath {
 217                 public void paint(AltosMapTransform t) {
 218                         Point2D.Double  prev = null;
 219
 220                         g.setRenderingHint(RenderingHints.KEY_ANTIALIASING,
 221                                            RenderingHints.VALUE_ANTIALIAS_ON);
 222                         g.setStroke(new BasicStroke(stroke_width, BasicStroke.CAP_ROUND, BasicStroke.JOIN_ROUND));
 223
 224                         for (AltosMapPathPoint point : points) {
 225                                 Point2D.Double  cur = point2d(t.screen(point.lat_lon));
 226                                 if (prev != null) {
 227                                         Line2D.Double   line = new Line2D.Double (prev, cur);
 228                                         Rectangle       bounds = line.getBounds();
 229
 230                                         if (g.hitClip(bounds.x, bounds.y, bounds.width, bounds.height)) {
 231                                                 if (0 <= point.state && point.state < AltosUIMap.stateColors.length)
 232                                                         g.setColor(AltosUIMap.stateColors[point.state]);
 233                                                 else
 234                                                         g.setColor(AltosUIMap.stateColors[AltosLib.ao_flight_invalid]);
 235
 236                                                 g.draw(line);
 237                                         }
 238                                 }
 239                                 prev = cur;
 240                         }
 241                 }
 242         }
 243
 244         class MapTile extends AltosMapTile {
 245                 public MapTile(AltosMapCache cache, AltosLatLon upper_left, AltosLatLon center, int zoom, int maptype, int px_size, int scale) {
 246                         super(cache, upper_left, center, zoom, maptype, px_size, scale);
 247                 }
 248
 249                 public void paint(AltosMapTransform t) {
 250
 251                         AltosPointDouble        point_double = t.screen(upper_left);
 252                         Point                   point = new Point((int) (point_double.x + 0.5),
 253                                                                   (int) (point_double.y + 0.5));
 254
 255                         if (!g.hitClip(point.x, point.y, px_size, px_size))
 256                                 return;
 257
 258                         AltosImage      altos_image = get_image();
 259                         AltosUIImage    ui_image = (AltosUIImage) altos_image;
 260                         Image           image = null;
 261
 262                         if (ui_image != null)
 263                                 image = ui_image.image;
 264
 265                         if (image != null) {
 266                                 g.drawImage(image, point.x, point.y, null);
 267 /*
 268  * Useful when debugging map fetching problems
 269  *
 270                                 String message = String.format("%.6f %.6f", center.lat, center.lon);
 271                                 g.setFont(tile_font);
 272                                 g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 273                                 Rectangle2D bounds = tile_font.getStringBounds(message, g.getFontRenderContext());
 274
 275                                 float x = px_size / 2.0f;
 276                                 float y = px_size / 2.0f;
 277                                 x = x - (float) bounds.getWidth() / 2.0f;
 278                                 y = y + (float) bounds.getHeight() / 2.0f;
 279                                 g.setColor(Color.RED);
 280                                 g.drawString(message, (float) point_double.x + x, (float) point_double.y + y);
 281 */
 282                         } else {
 283                                 g.setColor(Color.GRAY);
 284                                 g.fillRect(point.x, point.y, px_size, px_size);
 285
 286                                 if (t.has_location()) {
 287                                         String  message = null;
 288                                         switch (status) {
 289                                         case AltosMapTile.fetching:
 290                                                 message = "Fetching...";
 291                                                 break;
 292                                         case AltosMapTile.bad_request:
 293                                                 message = "Internal error";
 294                                                 break;
 295                                         case AltosMapTile.failed:
 296                                                 message = "Network error";
 297                                                 break;
 298                                         case AltosMapTile.forbidden:
 299                                                 message = "Outside of known launch areas";
 300                                                 break;
 301                                         }
 302                                         if (message != null && tile_font != null) {
 303                                                 g.setFont(tile_font);
 304                                                 g.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING, RenderingHints.VALUE_TEXT_ANTIALIAS_ON);
 305                                                 Rectangle2D bounds = tile_font.getStringBounds(message, g.getFontRenderContext());
 306
 307                                                 float x = px_size / 2.0f;
 308                                                 float y = px_size / 2.0f;
 309                                                 x = x - (float) bounds.getWidth() / 2.0f;
 310                                                 y = y + (float) bounds.getHeight() / 2.0f;
 311                                                 g.setColor(Color.BLACK);
 312                                                 g.drawString(message, (float) point_double.x + x, (float) point_double.y + y);
 313                                         }
 314                                 }
 315                         }
 316                 }
 317         }
 318
 319         public static final Color stateColors[] = {
 320                 Color.WHITE,  // startup
 321                 Color.WHITE,  // idle
 322                 Color.WHITE,  // pad
 323                 Color.RED,    // boost
 324                 Color.PINK,   // fast
 325                 Color.YELLOW, // coast
 326                 Color.CYAN,   // drogue
 327                 Color.BLUE,   // main
 328                 Color.BLACK,  // landed
 329                 Color.BLACK,  // invalid
 330                 Color.CYAN,   // stateless
 331         };
 332
 333         /* AltosMapInterface functions */
 334
 335         public AltosMapPath new_path() {
 336                 return new MapPath();
 337         }
 338
 339         public AltosMapLine new_line() {
 340                 return new MapLine();
 341         }
 342
 343         public AltosImage load_image(File file) throws Exception {
 344                 return new AltosUIImage(ImageIO.read(file));
 345         }
 346
 347         public AltosMapMark new_mark(double lat, double lon, int state) {
 348                 return new MapMark(lat, lon, state);
 349         }
 350
 351         public AltosMapTile new_tile(AltosMapCache cache, AltosLatLon upper_left, AltosLatLon center, int zoom, int maptype, int px_size, int scale) {
 352                 return new MapTile(cache, upper_left, center, zoom, maptype, px_size, scale);
 353         }
 354
 355         public int width() {
 356                 return view.getWidth();
 357         }
 358
 359         public int height() {
 360                 return view.getHeight();
 361         }
 362
 363         public void repaint() {
 364                 view.repaint();
 365         }
 366
 367         public void repaint(AltosRectangle damage) {
 368                 view.repaint(damage);
 369         }
 370
 371         public void set_zoom_label(String label) {
 372                 zoom_label.setText(label);
 373         }
 374
 375         public void select_object(AltosLatLon latlon) {
 376                 debug("select at %f,%f\n", latlon.lat, latlon.lon);
 377         }
 378
 379         public void debug(String format, Object ... arguments) {
 380                 if (AltosUIPreferences.serial_debug())
 381                         System.out.printf(format, arguments);
 382         }
 383
 384
 385         /* AltosFlightDisplay interface */
 386
 387         public void set_font() {
 388                 tile_font = AltosUILib.value_font;
 389                 line_font = AltosUILib.status_font;
 390         }
 391
 392         public void font_size_changed(int font_size) {
 393                 set_font();
 394                 repaint();
 395         }
 396
 397         public void units_changed(boolean imperial_units) {
 398                 repaint();
 399         }
 400
 401         JLabel  zoom_label;
 402
 403         public void set_maptype(int type) {
 404 /*
 405                 map.set_maptype(type);
 406                 maptype_combo.setSelectedIndex(type);
 407 */
 408         }
 409
 410         /* AltosUIMapPreload functions */
 411
 412         public void set_zoom(int zoom) {
 413                 map.set_zoom(zoom);
 414         }
 415
 416         public void add_mark(double lat, double lon, int status) {
 417                 map.add_mark(lat, lon, status);
 418         }
 419
 420         public void clear_marks() {
 421                 map.clear_marks();
 422         }
 423
 424         /* AltosFlightDisplay interface */
 425         public void reset() {
 426                 // nothing
 427         }
 428
 429         public void show(AltosState state, AltosListenerState listener_state) {
 430                 map.show(state, listener_state);
 431         }
 432
 433         public void show(AltosGPS gps, int state) {
 434                 map.show(gps, state);
 435         }
 436
 437         public String getName() {
 438                 return "Map";
 439         }
 440
 441         /* AltosGraphUI interface */
 442         public void centre(AltosState state) {
 443                 map.centre(state);
 444         }
 445
 446         public void centre(AltosGPS gps) {
 447                 map.centre(gps);
 448         }
 449
 450         /* internal layout bits */
 451         private GridBagLayout layout = new GridBagLayout();
 452
 453 /*
 454         JComboBox<String>       maptype_combo;
 455 */
 456
 457         MapView view;
 458
 459         public AltosUIMap() {
 460
 461                 set_font();
 462
 463                 view = new MapView();
 464
 465                 view.setPreferredSize(new Dimension(500,500));
 466                 view.setVisible(true);
 467                 view.setEnabled(true);
 468
 469                 GridBagLayout   my_layout = new GridBagLayout();
 470
 471                 setLayout(my_layout);
 472
 473                 GridBagConstraints c = new GridBagConstraints();
 474                 c.anchor = GridBagConstraints.CENTER;
 475                 c.fill = GridBagConstraints.BOTH;
 476                 c.gridx = 0;
 477                 c.gridy = 0;
 478                 c.gridwidth = 1;
 479                 c.gridheight = 10;
 480                 c.weightx = 1;
 481                 c.weighty = 1;
 482                 add(view, c);
 483
 484                 int     y = 0;
 485
 486                 zoom_label = new JLabel("", JLabel.CENTER);
 487
 488                 c = new GridBagConstraints();
 489                 c.anchor = GridBagConstraints.CENTER;
 490                 c.fill = GridBagConstraints.HORIZONTAL;
 491                 c.gridx = 1;
 492                 c.gridy = y++;
 493                 c.weightx = 0;
 494                 c.weighty = 0;
 495                 add(zoom_label, c);
 496
 497                 JButton zoom_reset = new JButton("0");
 498                 zoom_reset.addActionListener(new ActionListener() {
 499                                 public void actionPerformed(ActionEvent e) {
 500                                         map.set_zoom(map.default_zoom);
 501                                 }
 502                         });
 503
 504                 c = new GridBagConstraints();
 505                 c.anchor = GridBagConstraints.CENTER;
 506                 c.fill = GridBagConstraints.HORIZONTAL;
 507                 c.gridx = 1;
 508                 c.gridy = y++;
 509                 c.weightx = 0;
 510                 c.weighty = 0;
 511                 add(zoom_reset, c);
 512
 513                 JButton zoom_in = new JButton("+");
 514                 zoom_in.addActionListener(new ActionListener() {
 515                                 public void actionPerformed(ActionEvent e) {
 516                                         map.set_zoom(map.get_zoom() + 1);
 517                                 }
 518                         });
 519
 520                 c = new GridBagConstraints();
 521                 c.anchor = GridBagConstraints.CENTER;
 522                 c.fill = GridBagConstraints.HORIZONTAL;
 523                 c.gridx = 1;
 524                 c.gridy = y++;
 525                 c.weightx = 0;
 526                 c.weighty = 0;
 527                 add(zoom_in, c);
 528
 529                 JButton zoom_out = new JButton("-");
 530                 zoom_out.addActionListener(new ActionListener() {
 531                                 public void actionPerformed(ActionEvent e) {
 532                                         map.set_zoom(map.get_zoom() - 1);
 533                                 }
 534                         });
 535                 c = new GridBagConstraints();
 536                 c.anchor = GridBagConstraints.CENTER;
 537                 c.fill = GridBagConstraints.HORIZONTAL;
 538                 c.gridx = 1;
 539                 c.gridy = y++;
 540                 c.weightx = 0;
 541                 c.weighty = 0;
 542                 add(zoom_out, c);
 543
 544 /*
 545                 maptype_combo = new JComboBox<String>(map.maptype_labels);
 546
 547                 maptype_combo.setEditable(false);
 548                 maptype_combo.setMaximumRowCount(maptype_combo.getItemCount());
 549                 maptype_combo.addItemListener(new ItemListener() {
 550                                 public void itemStateChanged(ItemEvent e) {
 551                                         map.set_maptype(maptype_combo.getSelectedIndex());
 552                                 }
 553                         });
 554
 555                 c = new GridBagConstraints();
 556                 c.anchor = GridBagConstraints.CENTER;
 557                 c.fill = GridBagConstraints.HORIZONTAL;
 558                 c.gridx = 1;
 559                 c.gridy = y++;
 560                 c.weightx = 0;
 561                 c.weighty = 0;
 562                 add(maptype_combo, c);
 563 */
 564                 map = new AltosMap(this);
 565         }
 566 }