import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
@Override
public void onOpen(Marker overlayItem) {
    title = overlayItem.getTitle();
    ref = overlayItem.getDescription();

    // Check string's length and if longer then 25 characters, we shorten
    if(title.length() > 25){
        shortTitle = title.substring(0,24)+"...";
        ((TextView) mView.findViewById(R.id.title)).setText(shortTitle);
    }else ((TextView) mView.findViewById(R.id.title)).setText(title);

    if(ref.length() > 25){
        shortRef = ref.substring(0,24)+"...";
        ((TextView) mView.findViewById(R.id.ref)).setText(shortRef);
    } else ((TextView) mView.findViewById(R.id.ref)).setText(ref);



}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
protected void createMiddleMarker(Vertex left, Vertex right) {
  if (left.equals(right) || left == null || right == null) {
    return;
  }

  LatLng middle = this.getMiddleLatLng(left.getPoint(), right.getPoint());
  Marker marker = this.createMarker(middle, this.vertexMiddleImage);

  Vertex vertex = new Vertex(left.getOwner(), marker);
  vertex.setGhost(true);

  this.vertices.add(vertex);

  left.setMiddleRight(vertex);
  right.setMiddleLeft(vertex);
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
final public Marker createMarker(LatLng latLng, Drawable image) {
  Marker marker = new Marker("", "", latLng);

  if (image != null) {
    marker.setHotspot(Marker.HotspotPlace.CENTER);
    marker.setAnchor(new PointF(0.5f, 0.5f));
    marker.setMarker(image);
  } else {
    marker.setIcon(new Icon(this.mapView.getContext(), Icon.Size.SMALL, "", "0000FF"));
  }

  this.markers.add(marker);

  this.markerOverlay.addItem(marker);
  marker.addTo(mapView);

  this.mapView.invalidate();

  return marker;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * Select a marker, showing a tooltip if the marker has content that would appear within it.
 */
public void selectMarker(final Marker marker) {
    InfoWindow toolTip = marker.getToolTip(MapView.this);

    if (mMapViewListener != null) {
        mMapViewListener.onTapMarker(MapView.this, marker);
    }
    closeCurrentTooltip();
    if (toolTip != currentTooltip && marker.hasContent()) {
        if (mMapViewListener != null) {
            mMapViewListener.onShowMarker(MapView.this, marker);
        }
        currentTooltip = toolTip;
        marker.showBubble(currentTooltip, MapView.this, true);
    }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * Constructs the view that is displayed when the InfoWindow opens.
 * This retrieves data from overlayItem and shows it in the tooltip.
 *
 * @param overlayItem the tapped overlay item
 */
public void onOpen(Marker overlayItem) {
    String title = overlayItem.getTitle();
    ((TextView) mView.findViewById(mTitleId /*R.id.title*/)).setText(title);
    String snippet = overlayItem.getDescription();
    ((TextView) mView.findViewById(mDescriptionId /*R.id.description*/)).setText(snippet);

    //handle sub-description, hiding or showing the text view:
    TextView subDescText = (TextView) mView.findViewById(mSubDescriptionId);
    String subDesc = overlayItem.getSubDescription();
    if ("".equals(subDesc)) {
        subDescText.setVisibility(View.GONE);
    } else {
        subDescText.setText(subDesc);
        subDescText.setVisibility(View.VISIBLE);
    }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * Adds a marker to the default marker overlay.
 *
 * @param marker the marker object to be added
 * @return the marker object
 */
public Marker addMarker(final Marker marker) {
    if (firstMarker) {
        defaultMarkerList.add(marker);
        setDefaultItemizedOverlay();
    } else {
        if (!getOverlays().contains(defaultMarkerOverlay)) {
            addItemizedOverlay(defaultMarkerOverlay);
        }
        defaultMarkerOverlay.addItem(marker);
    }
    marker.addTo(this);

    firstMarker = false;
    invalidate();
    return marker;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
public Marker addOSMMarker(OSMOverlay osmOverlay, Marker marker) {
    if (firstMarker) {
        defaultMarkerList.add(marker);
        setDefaultOSMItemizedOverlay(osmOverlay);
    } else {
        if (!getOverlays().contains(defaultMarkerOverlay)) {
            addItemizedOverlay(defaultMarkerOverlay);
        }
        defaultMarkerOverlay.addItem(marker);
    }
    marker.addTo(this);

    firstMarker = false;
    invalidate();
    return marker;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * Select a marker, showing a tooltip if display_bubble is set to true and
 * the marker has content that would appear within it.
 */
public void selectMarker(final Marker marker, final boolean displayBubble) {
    InfoWindow toolTip = marker.getToolTip(MapView.this);

    if (mMapViewListener != null) {
        mMapViewListener.onTapMarker(MapView.this, marker);
    }
    closeCurrentTooltip();
    if (toolTip != currentTooltip && marker.hasContent()) {
        if (mMapViewListener != null) {
            mMapViewListener.onShowMarker(MapView.this, marker);
        }
        currentTooltip = toolTip;
        if (mShouldDisplayBubble && displayBubble) {
            marker.showBubble(currentTooltip, MapView.this, true);
        }
    }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
public void setDefaultOSMItemizedOverlay(OSMOverlay osmOverlay) {
    defaultMarkerOverlay = new OSMItemizedIconOverlay(osmOverlay, getContext(), defaultMarkerList,
            new ItemizedIconOverlay.OnItemGestureListener<Marker>() {
                public boolean onItemSingleTapUp(final int index, final Marker item) {
                    selectMarker(item);
                    return true;
                }

                public boolean onItemLongPress(final int index, final Marker item) {
                    if (mMapViewListener != null) {
                        mMapViewListener.onLongPressMarker(MapView.this, item);
                    }
                    return true;
                }
            }
    );
    addListener(defaultMarkerOverlay);
    defaultMarkerOverlay.setClusteringEnabled(mIsClusteringEnabled, mOnDrawClusterListener, mMinZoomForClustering);
    addItemizedOverlay(defaultMarkerOverlay);
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
@Override
public void onOpen(Marker overlayItem) {
    title = overlayItem.getTitle();
    ref = overlayItem.getDescription();
    ((TextView) mView.findViewById(R.id.title)).setText(title);
    ((TextView) mView.findViewById(R.id.ref)).setText(ref);
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
protected void select(int index, Vertex vertex) {
  this.deselect();
  this.selected = index;

  GeometryInterface geometry = vertex.getOwner();

  Log.d("Builder", String.format("select() vertex.isGhost() ? %b.", vertex.isGhost()));
  // Promote middle vertex to real vertex.

  if (vertex.isGhost()) { // && geometry.insertLatLng(insertPos, vertex.getPoint())) {
    int insertPos = geometry.indexOfLatLng(vertex.getNext().getPoint());
    geometry.insertLatLng(insertPos, vertex.getPoint());
    vertex.setGhost(false);

    updatePrevNext(vertex.getPrev(), vertex);
    updatePrevNext(vertex, vertex.getNext());

    createMiddleMarker(vertex.getPrev(), vertex);
    createMiddleMarker(vertex, vertex.getNext());

    geometry.reset();
  }

  if (this.vertexSelectedImage != null) {
    vertex.getMarker().setHotspot(Marker.HotspotPlace.CENTER);
    vertex.getMarker().setMarker(this.vertexSelectedImage);
  } else {
    vertex.getMarker().setIcon(new Icon(this.mapView.getContext(), Icon.Size.SMALL, "", "FF0000"));
  }

  Log.d("Builder", String.format("select() this.selected: %d", this.selected));
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
protected void deselect() {
  if (this.selected < 0) {
    return;
  }
  Vertex vertex = this.vertices.get(this.selected);

  if (this.vertexImage != null) {
    vertex.getMarker().setHotspot(Marker.HotspotPlace.CENTER);
    vertex.getMarker().setMarker(this.vertexImage);
  } else {
    vertex.getMarker().setIcon(new Icon(this.mapView.getContext(), Icon.Size.SMALL, "", "0000FF"));
  }

  this.selected = -1;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
protected void initMarkers(GeometryInterface geometry, ArrayList<LatLng> latLngs) {
  ArrayList<Vertex> newVertices = new ArrayList<Vertex>();

  if (this.startFeature(geometry)) {
    // Initialize markers for all vertices.
    for (LatLng latLng : latLngs) {
      if (geometry.addLatLng(latLng)) {
        Marker marker = this.createMarker(latLng, this.vertexImage);
        Vertex vertex = new Vertex(geometry, marker);
        newVertices.add(vertex);
      }
    }

    // Add all new vertices to main collection.
    this.vertices.addAll(newVertices);

    // Initialize middle markers.
    Vertex left, right;
    int length = latLngs.size();
    for (int i = 0, j = length - 1; i < length; j = i++) {
      left = newVertices.get(j);
      right = newVertices.get(i);
      this.createMiddleMarker(left, right);
      this.updatePrevNext(left, right);
    }
    this.stopFeature();
  }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
final public void addLatLng(GeometryInterface geometry, LatLng position) {
  if (geometry.addLatLng(position)) {
    Marker marker = this.createMarker(position, this.vertexImage);
    Vertex vertex = new Vertex(geometry, marker);
    this.vertices.add(vertex);

    if (geometry.size() > 1 && this.lastAdded != null) {
      this.createMiddleMarker(this.lastAdded, vertex);
      this.updatePrevNext(this.lastAdded, vertex);
    }

    this.lastAdded = vertex;
  }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
final public void removePoint(int index) {
  if (index < 0) {
    return;
  }

  // Calling this.deselect() is necessary as removing the vertex and marker will shift
  // subsequent indices in this.vertices & this.markers.
  this.deselect();

  Vertex vertex = this.vertices.remove(index);
  Marker marker = this.markers.remove(index);

  updatePrevNext(vertex.getPrev(), vertex.getNext());
  createMiddleMarker(vertex.getPrev(), vertex.getNext());

  Vertex middleLeft = vertex.getMiddleLeft();
  Vertex middleRight = vertex.getMiddleRight();

  if (middleLeft != null) {
    this.markerOverlay.removeItem(middleLeft.getMarker());
  }
  if (middleRight != null) {
    this.markerOverlay.removeItem(middleRight.getMarker());
  }

  this.markerOverlay.removeItem(marker);

  GeometryInterface geometry = vertex.getOwner();
  geometry.remove(marker.getPoint());

  if (this.lastAdded == vertex) {
    this.lastAdded = vertex.getPrev();
  }

  marker.getDrawable().invalidateSelf();
  mapView.invalidate();
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * Adds a marker to the default marker overlay.
 *
 * @param marker the marker object to be added
 * @return the marker object
 */
public Marker addMarker(final Marker marker) {
    if (firstMarker) {
        defaultMarkerList.add(marker);
        setDefaultItemizedOverlay();
    } else {
        defaultMarkerOverlay.addItem(marker);
    }
    marker.addTo(this);
    firstMarker = false;
    return marker;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * open the window at the specified position.
 *
 * @param object the graphical object on which is hooked the view
 * @param position to place the window on the map
 * @param offsetX (&offsetY) the offset of the view to the position, in pixels.
 * This allows to offset the view from the object position.
 * @return this infowindow
 */
public InfoWindow open(Marker object, LatLng position, int offsetX, int offsetY) {
    onOpen(object);
    MapView.LayoutParams lp = new MapView.LayoutParams(MapView.LayoutParams.WRAP_CONTENT,
            MapView.LayoutParams.WRAP_CONTENT, position, MapView.LayoutParams.BOTTOM_CENTER,
            offsetX, offsetY);
    close(); //if it was already opened
    mMapView.addView(mView, lp);
    mIsVisible = true;
    return this;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
public void addMarkers(final List<Marker> markers) {
    if (firstMarker) {
        defaultMarkerList.addAll(markers);
        setDefaultItemizedOverlay();
    } else {
        if (!getOverlays().contains(defaultMarkerOverlay)) {
            addItemizedOverlay(defaultMarkerOverlay);
        }
        defaultMarkerOverlay.addItems(markers);
    }
    for (Marker marker : markers) {
        marker.addTo(this);
    }
    firstMarker = false;
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
/**
 * When the user selects a marker on the map, we want to pan
 * the map to where the marker is for selection.
 *
 * @param pMapView the map
 * @param pMarker  the marker
 */
@Override
public void onTapMarker(MapView pMapView, Marker pMarker) {
    LatLng latLng = pMarker.getPoint();
    pMapView.getController().animateTo(latLng);
    OSMNode node = ((OSMMarker)pMarker).getNode();
    OSMElement.deselectAll();
    node.select();
    if (OSMElement.hasSelectedElementsChanged() && selectionListener != null) {
        selectionListener.selectedElementsChanged(OSMElement.getSelectedElements());
    }
}
 

import com.mapbox.mapboxsdk.overlay.Marker; //导入依赖的package包/类
public OSMNode addNode(OSMNode node) {
    Marker marker = node.getMarker();
    if (marker != null) {
        marker.setVisibility(true);
    }
    jtsModel.addOSMStandaloneNode(node);
    mapView.invalidate();
    return node;
}