Example #1
0
  /**
   * Called as some kind of destructor when the last layer has been removed. Delegates the call to
   * all Destroyables within this component (e.g. MapModes)
   */
  public void destroy() {
    MapView.removeLayerChangeListener(this);
    dialogsPanel.destroy();
    for (int i = 0; i < toolBarActions.getComponentCount(); ++i) {
      if (toolBarActions.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarActions.getComponent(i)).destroy();
      }
    }
    for (int i = 0; i < toolBarToggle.getComponentCount(); ++i) {
      if (toolBarToggle.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarToggle.getComponent(i)).destroy();
      }
    }

    // MapFrame gets destroyed when the last layer is removed, but the status line background
    // thread that collects the information doesn't get destroyed automatically.
    if (statusLine.thread != null) {
      try {
        statusLine.thread.interrupt();
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
    mapView.destroy();
  }
 /**
  * Checks if the given segment is in the visible area. NOTE: This will return true for a small
  * number of non-visible segments.
  *
  * @param ls The segment to check
  * @return true if the segment is visible
  */
 protected boolean isSegmentVisible(Node n1, Node n2) {
   Point p1 = mv.getPoint(n1);
   Point p2 = mv.getPoint(n2);
   if ((p1.x < 0) && (p2.x < 0)) return false;
   if ((p1.y < 0) && (p2.y < 0)) return false;
   if ((p1.x > mv.getWidth()) && (p2.x > mv.getWidth())) return false;
   if ((p1.y > mv.getHeight()) && (p2.y > mv.getHeight())) return false;
   return true;
 }
 private void paintBox(Graphics g, MapView mv, EastNorthBound img, Color color) {
   Point[] croppedPoint = new Point[5];
   croppedPoint[0] = mv.getPoint(img.min);
   croppedPoint[1] = mv.getPoint(new EastNorth(img.min.east(), img.max.north()));
   croppedPoint[2] = mv.getPoint(img.max);
   croppedPoint[3] = mv.getPoint(new EastNorth(img.max.east(), img.min.north()));
   croppedPoint[4] = croppedPoint[0];
   for (int i = 0; i < 4; i++) {
     g.setColor(color);
     g.drawLine(
         croppedPoint[i].x, croppedPoint[i].y, croppedPoint[i + 1].x, croppedPoint[i + 1].y);
   }
 }
Example #4
0
  /**
   * @param zoom level of the tile
   * @return how many pixels of the screen occupies one pixel of the tile
   */
  private double getTileToScreenRatio(int zoom) {
    MapView mv = Main.map.mapView;
    LatLon topLeft = mv.getLatLon(0, 0);
    LatLon botLeft = mv.getLatLon(0, tileSource.getTileSize());

    TileXY topLeftTile = tileSource.latLonToTileXY(topLeft.toCoordinate(), zoom);

    ICoordinate north =
        tileSource.tileXYToLatLon(topLeftTile.getXIndex(), topLeftTile.getYIndex(), zoom);
    ICoordinate south =
        tileSource.tileXYToLatLon(topLeftTile.getXIndex(), topLeftTile.getYIndex() + 1, zoom);

    return Math.abs((north.getLat() - south.getLat()) / (topLeft.lat() - botLeft.lat()));
  }
Example #5
0
  public void addLayer(Layer layer, boolean showOnButtonList, String icon) {
    if (layer instanceof MapViewerLayer) {
      minZoom = Math.max(((MapViewerLayer) layer).getMinZoomLevel(), getMinZoom());
      maxZoom = Math.min(((MapViewerLayer) layer).getMaxZoomLevel(), getMaxZoom());
      if (zoomFactor > maxZoom || zoomFactor < minZoom) {
        zoomFactor = (maxZoom + minZoom) / 2;
      }
      zoomTo(center, zoom2Scale(zoomFactor));
    }
    if (showOnButtonList) {
      JToggleButton b = new JToggleButton(layer.name, LogicConstants.getIcon(icon), layer.visible);
      // b.setVerticalTextPosition(SwingConstants.BOTTOM);
      // b.setHorizontalTextPosition(SwingConstants.CENTER);
      b.setActionCommand(layer.name);
      b.addActionListener(layerControlListener);
      layerControls.add(b);
      layerControlPanel.removeAll();
      layerControlPanel.add(Box.createHorizontalStrut(10));
      for (JToggleButton bt : layerControls) {
        layerControlPanel.add(bt);
        layerControlPanel.add(Box.createHorizontalGlue());
      }
      layerControlPanel.updateUI();
    }

    super.addLayer(layer);
  }
Example #6
0
 /**
  * @param newCenter {@link EastNorth} of the new center
  * @param zoomFactor The OSM zoom facto to zoom to
  */
 public void zoomToFactor(EastNorth newCenter, int zoomFactor) {
   if (zoomFactor < getMinZoom() || zoomFactor > getMaxZoom()) {
     return;
   }
   this.zoomFactor = zoomFactor;
   super.zoomTo(newCenter, zoom2Scale(zoomFactor));
 }
 /**
  * Draws a circle around the node
  *
  * @param n The node
  * @param color The circle color
  */
 public void drawNode(Node n, Color color) {
   Point p = mv.getPoint(n);
   g.setColor(color);
   if (selected) {
     g.fillOval(p.x - 5, p.y - 5, 10, 10);
   } else g.drawOval(p.x - 5, p.y - 5, 10, 10);
 }
  @Override
  public void zoomChanged() {
    MapView mv = Main.map.mapView;
    Bounds bbox = mv.getLatLonBounds(mv.getBounds());

    // Have the user changed view since last time
    if (active && (lastBbox == null || !lastBbox.equals(bbox))) {
      if (task != null) {
        task.cancel();
      }

      // wait 500ms before downloading in case the user is in the middle
      // of a pan/zoom
      task = new Task(bbox);
      timer.schedule(task, Main.pref.getInteger("plugin.continuos_download.wait_time", 500));
      lastBbox = bbox;
    }
  }
Example #9
0
  /**
   * Called as some kind of destructor when the last layer has been removed. Delegates the call to
   * all Destroyables within this component (e.g. MapModes)
   */
  @Override
  public void destroy() {
    MapView.removeLayerChangeListener(this);
    dialogsPanel.destroy();
    Main.pref.removePreferenceChangeListener(sidetoolbarPreferencesChangedListener);
    for (int i = 0; i < toolBarActions.getComponentCount(); ++i) {
      if (toolBarActions.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarActions.getComponent(i)).destroy();
      }
    }
    for (int i = 0; i < toolBarToggle.getComponentCount(); ++i) {
      if (toolBarToggle.getComponent(i) instanceof Destroyable) {
        ((Destroyable) toolBarToggle.getComponent(i)).destroy();
      }
    }

    statusLine.destroy();
    mapView.destroy();
  }
  public void setProjectionBounds(ProjectionBounds bounds) {
    view_bounds = bounds;

    if (bounds.maxEast - bounds.minEast > max_east_west) {
      max_east_west = bounds.maxEast - bounds.minEast;

      /* We need to set the parent MapView's bounds (i.e.
       * zoom level) to the same as ours max possible
       * bounds to avoid WMSLayer thinking we're zoomed
       * out more than we are or it'll pop up an annoying
       * "requested area is too large" popup.
       */
      EastNorth parent_center = parent.getCenter();
      parent.zoomTo(
          new ProjectionBounds(
              new EastNorth(parent_center.east() - max_east_west / 2, parent_center.north()),
              new EastNorth(parent_center.east() + max_east_west / 2, parent_center.north())));

      /* Request again because NavigatableContent adds
       * a border just to be sure.
       */
      ProjectionBounds new_bounds = parent.getProjectionBounds();
      max_east_west = new_bounds.maxEast - new_bounds.minEast;
    }

    Point vmin = getPoint(bounds.getMin());
    Point vmax = getPoint(bounds.getMax());
    int w = vmax.x + 1;
    int h = vmin.y + 1;

    if (w <= ground_width && h <= ground_height) {
      graphics.setClip(0, 0, w, h);
      return;
    }

    if (w > ground_width) ground_width = w;
    if (h > ground_height) ground_height = h;

    ground_image = new BufferedImage(ground_width, ground_height, BufferedImage.TYPE_INT_RGB);
    graphics = ground_image.createGraphics();
    graphics.setClip(0, 0, w, h);
  }
Example #11
0
 /** If layer is the OSM Data layer, remove all errors */
 @Override
 public void layerRemoved(Layer oldLayer) {
   if (oldLayer instanceof OsmDataLayer
       && Main.isDisplayingMapView()
       && !Main.main.hasEditLayer()) {
     Main.main.removeLayer(this);
   } else if (oldLayer == this) {
     MapView.removeLayerChangeListener(this);
     OsmValidator.errorLayer = null;
   }
 }
  public FakeMapView(MapView parent, double scale) {
    super(
        null, null,
        null); // TODO MapView constructor contains registering listeners and other code, that
    // probably shouldn't be called in fake map view
    this.parent = parent;
    this.scale = scale;

    ProjectionBounds parent_bounds = parent.getProjectionBounds();
    max_east_west = parent_bounds.maxEast - parent_bounds.minEast;
  }
Example #13
0
  /**
   * Draw all primitives in this layer but do not draw modified ones (they are drawn by the edit
   * layer). Draw nodes last to overlap the ways they belong to.
   */
  @Override
  public void paint(final Graphics g, final MapView mv) {
    boolean active = true;
    boolean inactive = false;
    boolean virtual = false;

    // draw the hatched area for non-downloaded region. only draw if we're
    // the active
    // and bounds are defined; don't draw for inactive layers or loaded GPX
    // files etc
    if (active
        && Main.pref.getBoolean("draw.data.downloaded_area", true)
        && !data.dataSources.isEmpty()) {
      // initialize area with current viewport
      Rectangle b = Main.map.mapView.getBounds();
      // on some platforms viewport bounds seem to be offset from the
      // left,
      // over-grow it just to be sure
      b.grow(100, 100);
      Area a = new Area(b);

      // now succesively subtract downloaded areas
      for (DataSource src : data.dataSources) {
        if (src.bounds != null && !src.bounds.min.equals(src.bounds.max)) {
          EastNorth en1 = Main.proj.latlon2eastNorth(src.bounds.min);
          EastNorth en2 = Main.proj.latlon2eastNorth(src.bounds.max);
          Point p1 = mv.getPoint(en1);
          Point p2 = mv.getPoint(en2);
          Rectangle r =
              new Rectangle(
                  Math.min(p1.x, p2.x),
                  Math.min(p1.y, p2.y),
                  Math.abs(p2.x - p1.x),
                  Math.abs(p2.y - p1.y));
          a.subtract(new Area(r));
        }
      }

      // paint remainder
      ((Graphics2D) g).setPaint(hatched);
      ((Graphics2D) g).fill(a);
    }

    SimplePaintVisitor painter;
    if (Main.pref.getBoolean("draw.wireframe")) painter = new SimplePaintVisitor();
    else painter = new MapPaintVisitor();
    painter.setGraphics(g);
    painter.setNavigatableComponent(mv);
    painter.inactive = inactive;
    painter.visitAll(data, virtual);
    // Main.map.conflictDialog.paintConflicts(g, mv);
  }
Example #14
0
  /** Restores the previous settings in the download dialog. */
  public void restoreSettings() {
    cbDownloadOsmData.setSelected(Main.pref.getBoolean("download.osm", true));
    cbDownloadGpxData.setSelected(Main.pref.getBoolean("download.gps", false));
    cbNewLayer.setSelected(Main.pref.getBoolean("download.newlayer", false));
    cbStartup.setSelected(isAutorunEnabled());
    int idx = Main.pref.getInteger("download.tab", 0);
    if (idx < 0 || idx > tpDownloadAreaSelectors.getTabCount()) {
      idx = 0;
    }
    tpDownloadAreaSelectors.setSelectedIndex(idx);

    if (Main.isDisplayingMapView()) {
      MapView mv = Main.map.mapView;
      currentBounds = new Bounds(mv.getLatLon(0, mv.getHeight()), mv.getLatLon(mv.getWidth(), 0));
      boundingBoxChanged(currentBounds, null);
    } else {
      Bounds bounds = getSavedDownloadBounds();
      if (bounds != null) {
        currentBounds = bounds;
        boundingBoxChanged(currentBounds, null);
      }
    }
  }
Example #15
0
  @Override
  public void removeLayer(Layer layer) {
    super.removeLayer(layer);
    int index = -1;

    for (int i = 0; i < layerControls.size(); i++) {
      if (layerControls.get(i).getActionCommand().equals(layer.name)) {
        index = i;
        break;
      }
    }

    if (index != -1) layerControls.remove(index);
    layerControlPanel.updateUI();
  }
  @Override
  public void paint(Graphics2D g, MapView mv, Bounds box) {
    LatLon min = box.getMin();
    LatLon max = box.getMax();

    Envelope envelope2 =
        new Envelope(
            Math.min(min.lat(), max.lat()),
            Math.max(min.lat(), max.lat()),
            Math.min(min.lon(), max.lon()),
            Math.max(min.lon(), max.lon()));

    ReferencedEnvelope mapArea = new ReferencedEnvelope(envelope2, crsOSMI);

    renderer.setInteractive(false);
    renderer.paint(g, mv.getBounds(), mapArea);
    bIsChanged = false;
  }
Example #17
0
 /**
  * Constructs a new <code>RecentRelationsAction</code>.
  *
  * @param editButton edit button
  */
 public RecentRelationsAction(SideButton editButton) {
   this.editButton = editButton;
   arrow = editButton.createArrow(this);
   arrow.setToolTipText(tr("List of recent relations"));
   Main.main.undoRedo.addCommandQueueListener(this);
   MapView.addLayerChangeListener(this);
   enableArrow();
   shortcut =
       Shortcut.registerShortcut(
           "relationeditor:editrecentrelation",
           tr("Relation Editor: {0}", tr("Open recent relation")),
           KeyEvent.VK_ESCAPE,
           Shortcut.SHIFT);
   Main.registerActionShortcut(
       new AbstractAction() {
         @Override
         public void actionPerformed(ActionEvent e) {
           EditRelationAction.launchEditor(getLastRelation());
         }
       },
       shortcut);
 }
Example #18
0
  private void hook_up_mouse_events() {
    mouseAdapter =
        new MouseAdapter() {
          @Override
          public void mousePressed(MouseEvent e) {

            if (e.getButton() != MouseEvent.BUTTON1) return;
            if (isVisible()) {
              Main.map.mapView.repaint();
            }
          }

          @Override
          public void mouseReleased(MouseEvent ev) {
            if (ev.getButton() != MouseEvent.BUTTON1) return;
            if (!isVisible()) return;

            for (int i = data.size() - 1; i >= 0; --i) {
              ImageEntry e = data.get(i);
              if (e.getPos() == null) {
                continue;
              }
              Point p = Main.map.mapView.getPoint(e.getPos());
              Rectangle r;
              if (e.thumbnail != null) {
                Dimension d = scaledDimension(e.thumbnail);
                r = new Rectangle(p.x - d.width / 2, p.y - d.height / 2, d.width, d.height);
              } else {
                r =
                    new Rectangle(
                        p.x - icon.getIconWidth() / 2,
                        p.y - icon.getIconHeight() / 2,
                        icon.getIconWidth(),
                        icon.getIconHeight());
              }
              if (r.contains(ev.getPoint())) {
                currentPhoto = i;
                ImageViewerDialog.showImage(GeoImageLayer.this, e);
                Main.map.repaint();
                break;
              }
            }
          }
        };

    mapModeListener =
        new MapModeChangeListener() {
          public void mapModeChange(MapMode oldMapMode, MapMode newMapMode) {
            if (newMapMode instanceof org.openstreetmap.josm.actions.mapmode.SelectAction) {
              Main.map.mapView.addMouseListener(mouseAdapter);
            } else {
              Main.map.mapView.removeMouseListener(mouseAdapter);
            }
          }
        };

    MapFrame.addMapModeChangeListener(mapModeListener);
    mapModeListener.mapModeChange(null, Main.map.mapMode);

    MapView.addLayerChangeListener(
        new LayerChangeListener() {
          public void activeLayerChange(Layer oldLayer, Layer newLayer) {
            if (newLayer == GeoImageLayer.this) {
              // only in select mode it is possible to click the images
              Main.map.selectSelectTool(false);
            }
          }

          public void layerAdded(Layer newLayer) {}

          public void layerRemoved(Layer oldLayer) {
            if (oldLayer == GeoImageLayer.this) {
              if (thumbsloader != null) {
                thumbsloader.stop = true;
              }
              Main.map.mapView.removeMouseListener(mouseAdapter);
              MapFrame.removeMapModeChangeListener(mapModeListener);
              currentPhoto = -1;
              data.clear();
              data = null;
              // stop listening to layer change events
              MapView.removeLayerChangeListener(this);
            }
          }
        });
  }
Example #19
0
  @Override
  public void hookUpMapView() {
    mouseAdapter =
        new MouseAdapter() {
          private boolean isMapModeOk() {
            return Main.map.mapMode == null || isSupportedMapMode(Main.map.mapMode);
          }

          @Override
          public void mousePressed(MouseEvent e) {
            if (e.getButton() != MouseEvent.BUTTON1) return;
            if (isVisible() && isMapModeOk()) {
              Main.map.mapView.repaint();
            }
          }

          @Override
          public void mouseReleased(MouseEvent ev) {
            if (ev.getButton() != MouseEvent.BUTTON1) return;
            if (data == null || !isVisible() || !isMapModeOk()) return;

            for (int i = data.size() - 1; i >= 0; --i) {
              ImageEntry e = data.get(i);
              if (e.getPos() == null) {
                continue;
              }
              Point p = Main.map.mapView.getPoint(e.getPos());
              Rectangle r;
              if (useThumbs && e.hasThumbnail()) {
                Dimension d = scaledDimension(e.getThumbnail());
                r = new Rectangle(p.x - d.width / 2, p.y - d.height / 2, d.width, d.height);
              } else {
                r =
                    new Rectangle(
                        p.x - icon.getIconWidth() / 2,
                        p.y - icon.getIconHeight() / 2,
                        icon.getIconWidth(),
                        icon.getIconHeight());
              }
              if (r.contains(ev.getPoint())) {
                clearOtherCurrentPhotos();
                currentPhoto = i;
                ImageViewerDialog.showImage(GeoImageLayer.this, e);
                Main.map.repaint();
                break;
              }
            }
          }
        };

    mapModeListener =
        new MapModeChangeListener() {
          @Override
          public void mapModeChange(MapMode oldMapMode, MapMode newMapMode) {
            if (newMapMode == null || isSupportedMapMode(newMapMode)) {
              Main.map.mapView.addMouseListener(mouseAdapter);
            } else {
              Main.map.mapView.removeMouseListener(mouseAdapter);
            }
          }
        };

    MapFrame.addMapModeChangeListener(mapModeListener);
    mapModeListener.mapModeChange(null, Main.map.mapMode);

    MapView.addLayerChangeListener(
        new LayerChangeListener() {
          @Override
          public void activeLayerChange(Layer oldLayer, Layer newLayer) {
            if (newLayer == GeoImageLayer.this) {
              // only in select mode it is possible to click the images
              Main.map.selectSelectTool(false);
            }
          }

          @Override
          public void layerAdded(Layer newLayer) {}

          @Override
          public void layerRemoved(Layer oldLayer) {
            if (oldLayer == GeoImageLayer.this) {
              stopLoadThumbs();
              Main.map.mapView.removeMouseListener(mouseAdapter);
              MapFrame.removeMapModeChangeListener(mapModeListener);
              currentPhoto = -1;
              if (data != null) {
                data.clear();
              }
              data = null;
              // stop listening to layer change events
              MapView.removeLayerChangeListener(this);
            }
          }
        });

    Main.map.mapView.addPropertyChangeListener(this);
    if (Main.map.getToggleDialog(ImageViewerDialog.class) == null) {
      ImageViewerDialog.newInstance();
      Main.map.addToggleDialog(ImageViewerDialog.getInstance());
    }
  }
 /**
  * Checks if the given node is in the visible area.
  *
  * @param n The node to check for visibility
  * @return true if the node is visible
  */
 protected boolean isNodeVisible(Node n) {
   Point p = mv.getPoint(n);
   return !((p.x < 0) || (p.y < 0) || (p.x > mv.getWidth()) || (p.y > mv.getHeight()));
 }
Example #21
0
  @Override
  public void paint(Graphics2D g, MapView mv, Bounds box) {
    final int iconHeight = ImageProvider.ImageSizes.SMALLICON.getAdjustedHeight();
    final int iconWidth = ImageProvider.ImageSizes.SMALLICON.getAdjustedWidth();

    for (Note note : noteData.getNotes()) {
      Point p = mv.getPoint(note.getLatLon());

      ImageIcon icon;
      if (note.getId() < 0) {
        icon = ImageProvider.get("dialogs/notes", "note_new", ImageProvider.ImageSizes.SMALLICON);
      } else if (note.getState() == State.CLOSED) {
        icon =
            ImageProvider.get("dialogs/notes", "note_closed", ImageProvider.ImageSizes.SMALLICON);
      } else {
        icon = ImageProvider.get("dialogs/notes", "note_open", ImageProvider.ImageSizes.SMALLICON);
      }
      int width = icon.getIconWidth();
      int height = icon.getIconHeight();
      g.drawImage(icon.getImage(), p.x - (width / 2), p.y - height, Main.map.mapView);
    }
    if (noteData.getSelectedNote() != null) {
      StringBuilder sb = new StringBuilder("<html>");
      sb.append(tr("Note")).append(' ').append(noteData.getSelectedNote().getId());
      for (NoteComment comment : noteData.getSelectedNote().getComments()) {
        String commentText = comment.getText();
        // closing a note creates an empty comment that we don't want to show
        if (commentText != null && !commentText.trim().isEmpty()) {
          sb.append("<hr/>");
          String userName = XmlWriter.encode(comment.getUser().getName());
          if (userName == null || userName.trim().isEmpty()) {
            userName = "******";
          }
          sb.append(userName);
          sb.append(" on ");
          sb.append(
              DateUtils.getDateFormat(DateFormat.MEDIUM).format(comment.getCommentTimestamp()));
          sb.append(":<br/>");
          String htmlText = XmlWriter.encode(comment.getText(), true);
          htmlText =
              htmlText.replace(
                  "&#xA;", "<br/>"); // encode method leaves us with entity instead of \n
          htmlText =
              htmlText.replace("/", "/\u200b"); // zero width space to wrap long URLs (see #10864)
          sb.append(htmlText);
        }
      }
      sb.append("</html>");
      JToolTip toolTip = new JToolTip();
      toolTip.setTipText(sb.toString());
      Point p = mv.getPoint(noteData.getSelectedNote().getLatLon());

      g.setColor(ColorHelper.html2color(Main.pref.get("color.selected")));
      g.drawRect(p.x - (iconWidth / 2), p.y - iconHeight, iconWidth - 1, iconHeight - 1);

      int tx = p.x + (iconWidth / 2) + 5;
      int ty = p.y - iconHeight - 1;
      g.translate(tx, ty);

      // Carried over from the OSB plugin. Not entirely sure why it is needed
      // but without it, the tooltip doesn't get sized correctly
      for (int x = 0; x < 2; x++) {
        Dimension d = toolTip.getUI().getPreferredSize(toolTip);
        d.width = Math.min(d.width, mv.getWidth() / 2);
        if (d.width > 0 && d.height > 0) {
          toolTip.setSize(d);
          try {
            toolTip.paint(g);
          } catch (IllegalArgumentException e) {
            // See #11123 - https://bugs.openjdk.java.net/browse/JDK-6719550
            // Ignore the exception, as Netbeans does:
            // http://hg.netbeans.org/main-silver/rev/c96f4d5fbd20
            Main.error(e, false);
          }
        }
      }
      g.translate(-tx, -ty);
    }
  }
Example #22
0
 /**
  * Change the operating map mode for the view. Will call unregister on the old MapMode and
  * register on the new one. Now this function also verifies if new map mode is correct mode for
  * current layer and does not change mode in such cases.
  *
  * @param newMapMode The new mode to set.
  * @return {@code true} if mode is really selected
  */
 public boolean selectMapMode(MapMode newMapMode) {
   return selectMapMode(newMapMode, mapView.getActiveLayer());
 }
Example #23
0
  /**
   * Constructs a new {@code MapFrame}.
   *
   * @param contentPane The content pane used to register shortcuts in its {@link
   *     javax.swing.InputMap} and {@link javax.swing.ActionMap}
   * @param viewportData the initial viewport of the map. Can be null, then the viewport is derived
   *     from the layer data.
   */
  public MapFrame(JPanel contentPane, ViewportData viewportData) {
    setSize(400, 400);
    setLayout(new BorderLayout());

    mapView = new MapView(contentPane, viewportData);
    new FileDrop(mapView);

    splitPane = new JSplitPane(JSplitPane.HORIZONTAL_SPLIT, true);

    leftPanel = new JPanel();
    leftPanel.setLayout(new GridBagLayout());
    leftPanel.add(mapView, GBC.std().fill());
    splitPane.setLeftComponent(leftPanel);

    dialogsPanel = new DialogsPanel(splitPane);
    splitPane.setRightComponent(dialogsPanel);

    /** All additional space goes to the mapView */
    splitPane.setResizeWeight(1.0);

    /** Some beautifications. */
    splitPane.setDividerSize(5);
    splitPane.setBorder(null);
    splitPane.setUI(
        new BasicSplitPaneUI() {
          @Override
          public BasicSplitPaneDivider createDefaultDivider() {
            return new BasicSplitPaneDivider(this) {
              @Override
              public void setBorder(Border b) {}
            };
          }
        });

    // JSplitPane supports F6 and F8 shortcuts by default, but we need them for Audio actions
    splitPane
        .getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
        .put(KeyStroke.getKeyStroke(KeyEvent.VK_F6, 0), new Object());
    splitPane
        .getInputMap(JComponent.WHEN_ANCESTOR_OF_FOCUSED_COMPONENT)
        .put(KeyStroke.getKeyStroke(KeyEvent.VK_F8, 0), new Object());

    add(splitPane, BorderLayout.CENTER);

    dialogsPanel.setLayout(new BoxLayout(dialogsPanel, BoxLayout.Y_AXIS));
    dialogsPanel.setPreferredSize(
        new Dimension(Main.pref.getInteger("toggleDialogs.width", DEF_TOGGLE_DLG_WIDTH), 0));
    dialogsPanel.setMinimumSize(new Dimension(24, 0));
    mapView.setMinimumSize(new Dimension(10, 0));

    // toolBarActions, map mode buttons
    addMapMode(new IconToggleButton(mapModeSelect = new SelectAction(this)));
    addMapMode(new IconToggleButton(new LassoModeAction(), true));
    addMapMode(new IconToggleButton(mapModeDraw = new DrawAction(this)));
    addMapMode(new IconToggleButton(mapModeZoom = new ZoomAction(this)));
    addMapMode(new IconToggleButton(new DeleteAction(this), true));
    addMapMode(new IconToggleButton(new ParallelWayAction(this), true));
    addMapMode(new IconToggleButton(new ExtrudeAction(this), true));
    addMapMode(new IconToggleButton(new ImproveWayAccuracyAction(Main.map), false));
    toolBarActionsGroup.setSelected(allMapModeButtons.get(0).getModel(), true);
    toolBarActions.setFloatable(false);

    // toolBarToggles, toggle dialog buttons
    LayerListDialog.createInstance(this);
    addToggleDialog(LayerListDialog.getInstance());
    addToggleDialog(propertiesDialog = new PropertiesDialog());
    addToggleDialog(selectionListDialog = new SelectionListDialog());
    addToggleDialog(relationListDialog = new RelationListDialog());
    addToggleDialog(new CommandStackDialog());
    addToggleDialog(new UserListDialog());
    addToggleDialog(new HistoryDialog(), true);
    addToggleDialog(conflictDialog = new ConflictDialog());
    addToggleDialog(validatorDialog = new ValidatorDialog());
    addToggleDialog(filterDialog = new FilterDialog());
    addToggleDialog(new ChangesetDialog(), true);
    addToggleDialog(new MapPaintDialog());
    toolBarToggle.setFloatable(false);

    // status line below the map
    statusLine = new MapStatus(this);
    MapView.addLayerChangeListener(this);

    boolean unregisterTab = Shortcut.findShortcut(KeyEvent.VK_TAB, 0) != null;
    if (unregisterTab) {
      for (JComponent c : allDialogButtons) c.setFocusTraversalKeysEnabled(false);
      for (JComponent c : allMapModeButtons) c.setFocusTraversalKeysEnabled(false);
    }
  }
Example #24
0
  @Override
  public void paint(Graphics2D g, MapView mv, Bounds bounds) {
    int width = Main.map.mapView.getWidth();
    int height = Main.map.mapView.getHeight();
    Rectangle clip = g.getClipBounds();
    if (useThumbs) {
      if (null == offscreenBuffer
          || offscreenBuffer.getWidth() != width // reuse the old buffer if possible
          || offscreenBuffer.getHeight() != height) {
        offscreenBuffer = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        updateOffscreenBuffer = true;
      }

      if (updateOffscreenBuffer) {
        Graphics2D tempG = offscreenBuffer.createGraphics();
        tempG.setColor(new Color(0, 0, 0, 0));
        Composite saveComp = tempG.getComposite();
        tempG.setComposite(AlphaComposite.Clear); // remove the old images
        tempG.fillRect(0, 0, width, height);
        tempG.setComposite(saveComp);

        for (ImageEntry e : data) {
          if (e.getPos() == null) {
            continue;
          }
          Point p = mv.getPoint(e.getPos());
          if (e.thumbnail != null) {
            Dimension d = scaledDimension(e.thumbnail);
            Rectangle target =
                new Rectangle(p.x - d.width / 2, p.y - d.height / 2, d.width, d.height);
            if (clip.intersects(target)) {
              tempG.drawImage(e.thumbnail, target.x, target.y, target.width, target.height, null);
            }
          } else { // thumbnail not loaded yet
            icon.paintIcon(
                mv, tempG, p.x - icon.getIconWidth() / 2, p.y - icon.getIconHeight() / 2);
          }
        }
        updateOffscreenBuffer = false;
      }
      g.drawImage(offscreenBuffer, 0, 0, null);
    } else {
      for (ImageEntry e : data) {
        if (e.getPos() == null) {
          continue;
        }
        Point p = mv.getPoint(e.getPos());
        icon.paintIcon(mv, g, p.x - icon.getIconWidth() / 2, p.y - icon.getIconHeight() / 2);
      }
    }

    if (currentPhoto >= 0 && currentPhoto < data.size()) {
      ImageEntry e = data.get(currentPhoto);

      if (e.getPos() != null) {
        Point p = mv.getPoint(e.getPos());

        if (e.thumbnail != null) {
          Dimension d = scaledDimension(e.thumbnail);
          g.setColor(new Color(128, 0, 0, 122));
          g.fillRect(p.x - d.width / 2, p.y - d.height / 2, d.width, d.height);
        } else {
          if (e.getExifImgDir() != null) {
            double arrowlength = 25;
            double arrowwidth = 18;

            double dir = e.getExifImgDir();
            // Rotate 90 degrees CCW
            double headdir = (dir < 90) ? dir + 270 : dir - 90;
            double leftdir = (headdir < 90) ? headdir + 270 : headdir - 90;
            double rightdir = (headdir > 270) ? headdir - 270 : headdir + 90;

            double ptx = p.x + Math.cos(Math.toRadians(headdir)) * arrowlength;
            double pty = p.y + Math.sin(Math.toRadians(headdir)) * arrowlength;

            double ltx = p.x + Math.cos(Math.toRadians(leftdir)) * arrowwidth / 2;
            double lty = p.y + Math.sin(Math.toRadians(leftdir)) * arrowwidth / 2;

            double rtx = p.x + Math.cos(Math.toRadians(rightdir)) * arrowwidth / 2;
            double rty = p.y + Math.sin(Math.toRadians(rightdir)) * arrowwidth / 2;

            g.setColor(Color.white);
            int[] xar = {(int) ltx, (int) ptx, (int) rtx, (int) ltx};
            int[] yar = {(int) lty, (int) pty, (int) rty, (int) lty};
            g.fillPolygon(xar, yar, 4);
          }

          selectedIcon.paintIcon(
              mv, g, p.x - selectedIcon.getIconWidth() / 2, p.y - selectedIcon.getIconHeight() / 2);
        }
      }
    }
  }
Example #25
0
  @Override
  public void paint(Graphics g) {
    Main.mapView = this;
    if (follow != null) {
      follow();
    }
    try {
      super.paint(g); // Esto ya llama a paintComponents
    } catch (ConcurrentModificationException ex) {
      log.warn("Redibujando, datos aun no cargados...");
      return;
    }

    // ============= DEBUG DEBAJO DE ESTA LINEA ================

    // g.drawString(
    // "zoom: " + zoomFactor + ", angle:" + Math.toDegrees(angle),
    // 300, 15);
    // g.drawString((Runtime.getRuntime().freeMemory() / (1024 * 1024))
    // + "M / " + (Runtime.getRuntime().totalMemory() / (1024 * 1024))
    // + "M", 20, getHeight() - 5);

    // Rectangle r = getBoundingBox();
    // // g.drawRect(r.x + 200, r.y + 200, r.width - 400, r.height - 400);
    // LatLon tl, br;
    // tl = getLatLon(r.x, r.y);
    // br = getLatLon(r.x + r.width, r.y + r.height);
    // UTM u = new UTM();
    // // EastNorth etl = u.latlon2eastNorth(tl);
    // // EastNorth ebr = u.latlon2eastNorth(br);
    // EastNorth etl = Main.proj.latlon2eastNorth(tl);
    // EastNorth ebr = Main.proj.latlon2eastNorth(br);
    // Point pmi, pma;
    // pmi = getPoint(etl);
    // pma = getPoint(ebr);
    // Rectangle draw = new Rectangle(pmi.x, pma.y, pma.x - pmi.x, pma.y -
    // pmi.y);
    // g.setColor(Color.GREEN);
    // g.drawRect(draw.x + 201, draw.y + 201, draw.width - 402, draw.height
    // - 402);
    // g.drawString("+  " + draw, getWidth() / 2, 300);

    // g.setColor(Color.RED);
    // g.drawRect(200, 200, getWidth() - 400, getHeight() - 400);

    // g.setColor(Color.RED);
    // Point p = getPoint(Main.proj.latlon2eastNorth(getLatLon(getWidth() /
    // 2,
    // getHeight() / 2 - 200)));
    // g.fillOval(p.x - 10, p.y - 10, 20, 20);
    // g.setColor(Color.BLACK);
    // g.fillRect(getWidth() / 2 - 5, getHeight() / 2 - 5, 10, 10);

    // EastNorth mi = getEastNorth(0, getHeight() - 1);
    // EastNorth ma = getEastNorth(getWidth() - 1, 0);
    // Point pmi, pma;
    // pmi = getPoint(mi);
    // pma = getPoint(ma);
    // Rectangle r = new Rectangle(pmi.x, pma.y, pma.x - pmi.x, pmi.y -
    // pma.y);
    // g.drawString("+  " + r, getWidth() / 2, 300);
    // g.drawRect(r.x + 200, r.y + 200, r.width - 400, r.height - 400);
    // LatLon ll = getLatLon(getWidth()/2, getHeight()/2);
    // g.drawString("+  " + ll.lat() + " x " + ll.lon(), getWidth()/2,
    // getHeight()/2);
    // drawCompass(g);

  }
Example #26
0
 Point getPoint(LatLon p) {
   return mv.getPoint(p);
 }
 /**
  * Draws a line around the segment
  *
  * @param s The segment
  * @param color The color
  */
 public void drawSegment(Node n1, Node n2, Color color) {
   drawSegment(mv.getPoint(n1), mv.getPoint(n2), color);
 }
 public ChartImage(ImageryInfo info) {
   super(info);
   MapView.addZoomChangeListener(this);
   zoomChanged();
 }
Example #29
0
  @Override
  public void paint(Graphics2D g, MapView mv, Bounds bounds) {
    int width = mv.getWidth();
    int height = mv.getHeight();
    Rectangle clip = g.getClipBounds();
    if (useThumbs) {
      if (!thumbsLoaded) {
        startLoadThumbs();
      }

      if (null == offscreenBuffer
          || offscreenBuffer.getWidth() != width // reuse the old buffer if possible
          || offscreenBuffer.getHeight() != height) {
        offscreenBuffer = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
        updateOffscreenBuffer = true;
      }

      if (updateOffscreenBuffer) {
        Graphics2D tempG = offscreenBuffer.createGraphics();
        tempG.setColor(new Color(0, 0, 0, 0));
        Composite saveComp = tempG.getComposite();
        tempG.setComposite(AlphaComposite.Clear); // remove the old images
        tempG.fillRect(0, 0, width, height);
        tempG.setComposite(saveComp);

        if (data != null) {
          for (ImageEntry e : data) {
            if (e.getPos() == null) {
              continue;
            }
            Point p = mv.getPoint(e.getPos());
            if (e.hasThumbnail()) {
              Dimension d = scaledDimension(e.getThumbnail());
              Rectangle target =
                  new Rectangle(p.x - d.width / 2, p.y - d.height / 2, d.width, d.height);
              if (clip.intersects(target)) {
                tempG.drawImage(
                    e.getThumbnail(), target.x, target.y, target.width, target.height, null);
              }
            } else { // thumbnail not loaded yet
              icon.paintIcon(
                  mv, tempG, p.x - icon.getIconWidth() / 2, p.y - icon.getIconHeight() / 2);
            }
          }
        }
        updateOffscreenBuffer = false;
      }
      g.drawImage(offscreenBuffer, 0, 0, null);
    } else if (data != null) {
      for (ImageEntry e : data) {
        if (e.getPos() == null) {
          continue;
        }
        Point p = mv.getPoint(e.getPos());
        icon.paintIcon(mv, g, p.x - icon.getIconWidth() / 2, p.y - icon.getIconHeight() / 2);
      }
    }

    if (currentPhoto >= 0 && currentPhoto < data.size()) {
      ImageEntry e = data.get(currentPhoto);

      if (e.getPos() != null) {
        Point p = mv.getPoint(e.getPos());

        int imgWidth;
        int imgHeight;
        if (useThumbs && e.hasThumbnail()) {
          Dimension d = scaledDimension(e.getThumbnail());
          imgWidth = d.width;
          imgHeight = d.height;
        } else {
          imgWidth = selectedIcon.getIconWidth();
          imgHeight = selectedIcon.getIconHeight();
        }

        if (e.getExifImgDir() != null) {
          // Multiplier must be larger than sqrt(2)/2=0.71.
          double arrowlength = Math.max(25, Math.max(imgWidth, imgHeight) * 0.85);
          double arrowwidth = arrowlength / 1.4;

          double dir = e.getExifImgDir();
          // Rotate 90 degrees CCW
          double headdir = (dir < 90) ? dir + 270 : dir - 90;
          double leftdir = (headdir < 90) ? headdir + 270 : headdir - 90;
          double rightdir = (headdir > 270) ? headdir - 270 : headdir + 90;

          double ptx = p.x + Math.cos(Math.toRadians(headdir)) * arrowlength;
          double pty = p.y + Math.sin(Math.toRadians(headdir)) * arrowlength;

          double ltx = p.x + Math.cos(Math.toRadians(leftdir)) * arrowwidth / 2;
          double lty = p.y + Math.sin(Math.toRadians(leftdir)) * arrowwidth / 2;

          double rtx = p.x + Math.cos(Math.toRadians(rightdir)) * arrowwidth / 2;
          double rty = p.y + Math.sin(Math.toRadians(rightdir)) * arrowwidth / 2;

          g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
          g.setColor(new Color(255, 255, 255, 192));
          int[] xar = {(int) ltx, (int) ptx, (int) rtx, (int) ltx};
          int[] yar = {(int) lty, (int) pty, (int) rty, (int) lty};
          g.fillPolygon(xar, yar, 4);
          g.setColor(Color.black);
          g.setStroke(new BasicStroke(1.2f));
          g.drawPolyline(xar, yar, 3);
        }

        if (useThumbs && e.hasThumbnail()) {
          g.setColor(new Color(128, 0, 0, 122));
          g.fillRect(p.x - imgWidth / 2, p.y - imgHeight / 2, imgWidth, imgHeight);
        } else {
          selectedIcon.paintIcon(mv, g, p.x - imgWidth / 2, p.y - imgHeight / 2);
        }
      }
    }
  }
Example #30
0
 /** Constructs a new Validator layer */
 public ValidatorLayer() {
   super(tr("Validation errors"));
   MapView.addLayerChangeListener(this);
 }