shows or hides the coordinateline in the map according to it's visible property.

@param coordinateLineId
the id of the CoordinateLine object
8780
private void setCoordinateLineVisibleInMap(final String coordinateLineId) {
        if (null != coordinateLineId) {
            final WeakReference<CoordinateLine> coordinateLineWeakReference = coordinateLines.get(coordinateLineId);
            if (null != coordinateLineWeakReference) {
                final CoordinateLine coordinateLine = coordinateLineWeakReference.get();
                if (null != coordinateLine) {
                    if (coordinateLine.getVisible()) {
                        jsMapView.call("showCoordinateLine", coordinateLineId);
                    } else {
                        jsMapView.call("hideCoordinateLine", coordinateLineId);
                    }
                }
            }
        }
    }
1282480
protected void setMapVisible(boolean visible) {

        Style style = m_mapCanvas.getStyle();
        if (visible) {
            style.clearDisplay();
        } else {
            style.setDisplay(Display.NONE);
        }
    }
599351
public void fillEdgeIDs(GHIntHashSet edgeIds, Geometry geometry, EdgeFilter filter) {
        if (geometry instanceof Point) {
            GHPoint point = GHPoint.create((Point) geometry);
            findClosestEdgeToPoint(edgeIds, point, filter);
        } else if (geometry instanceof LineString) {
            PointList pl = PointList.fromLineString((LineString) geometry);
            // TODO do map matching or routing
            int lastIdx = pl.size() - 1;
            if (pl.size() >= 2) {
                double meanLat = (pl.getLatitude(0) + pl.getLatitude(lastIdx)) / 2;
                double meanLon = (pl.getLongitude(0) + pl.getLongitude(lastIdx)) / 2;
                findClosestEdge(edgeIds, meanLat, meanLon, filter);
            }
        } else if (geometry instanceof MultiPoint) {
            for (Coordinate coordinate : geometry.getCoordinates()) {
                findClosestEdge(edgeIds, coordinate.y, coordinate.x, filter);
            }
        }
    }
1123172
public void setRelationId(String relationId) {

        try {
            m_relationId = new CmsUUID(relationId);
        } catch (Throwable e) {
            setThrowable(e);
        }
    }
1225421
function(geometry, style, featureId) {
        var className = geometry.CLASS_NAME;
        if ((className == "OpenLayers.Geometry.Collection") ||
            (className == "OpenLayers.Geometry.MultiPoint") ||
            (className == "OpenLayers.Geometry.MultiLineString") ||
            (className == "OpenLayers.Geometry.MultiPolygon")) {
            for (var i = 0; i < geometry.components.length; i++) {
                this.drawGeometry(geometry.components[i], style, featureId);
            }
            return;
        }
        switch (geometry.CLASS_NAME) {
            case "OpenLayers.Geometry.Point":
                this.drawPoint(geometry, style, featureId);
                break;
            case "OpenLayers.Geometry.LineString":
                this.drawLineString(geometry, style, featureId);
                break;
            case "OpenLayers.Geometry.LinearRing":
                this.drawLinearRing(geometry, style, featureId);
                break;
            case "OpenLayers.Geometry.Polygon":
                this.drawPolygon(geometry, style, featureId);
                break;
            default:
                break;
        }
    }
1103894
public void lineTo(double x, double y, double z) {
		ensureSlots(true, 3);
		this.types[this.numTypes++] = PathElementType.LINE_TO;
		this.coords[this.numCoords++] = x;
		this.coords[this.numCoords++] = y;
		this.coords[this.numCoords++] = z;
		this.isEmpty = null;
		this.graphicalBounds = null;
		this.logicalBounds = null;
	}
1255881
public void setLine(Point2D[] points) {
        double[] pd = new double[points.length * 2];
        for (int i = 0; i < points.length; i++) {
            Point2D p = points[i];
            pd[i * 2] = p.getX();
            pd[i * 2 + 1] = p.getY();
        }
        setLine(pd);
    }
169631
private void showPlace(int position) {
    draggablePanel.setVisibility(View.VISIBLE);
    draggablePanel.maximize();
    PlaceViewModel placeViewModel = placesAdapter.getItem(position);
    placeFragment.showPlace(placeViewModel);

    mapFragment.getMap().clear();
    LatLng latitudeLongitude =
        new LatLng(placeViewModel.getLatitude(), placeViewModel.getLongitude());
    MarkerOptions marker = new MarkerOptions().position(latitudeLongitude);
    marker.title(placeViewModel.getName());
    marker.snippet(placeViewModel.getLatitude() + " , " + placeViewModel.getLongitude());
    mapFragment.getMap().addMarker(marker);
    mapFragment.getMap().moveCamera(CameraUpdateFactory.newLatLngZoom(latitudeLongitude, ZOOM));
  }
1080834
public void setVisible(boolean visible) {

        switch (shapeType) {

            case MARKER_OPTIONS:
                ((MarkerOptions) shape).visible(visible);
                break;
            case POLYLINE_OPTIONS:
                ((PolylineOptions) shape).visible(visible);
                break;
            case POLYGON_OPTIONS:
                ((PolygonOptions) shape).visible(visible);
                break;
            case MULTI_POLYLINE_OPTIONS:
                ((MultiPolylineOptions) shape).visible(visible);
                break;
            case MULTI_POLYGON_OPTIONS:
                ((MultiPolygonOptions) shape).visible(visible);
                break;
            case MARKER:
                ((Marker) shape).setVisible(visible);
                break;
            case POLYGON:
                ((Polygon) shape).setVisible(visible);
                break;
            case POLYLINE:
                ((Polyline) shape).setVisible(visible);
                break;
            case MULTI_MARKER:
                ((MultiMarker) shape).setVisible(visible);
                break;
            case MULTI_POLYLINE:
                ((MultiPolyline) shape).setVisible(visible);
                break;
            case MULTI_POLYGON:
                ((MultiPolygon) shape).setVisible(visible);
                break;
            case POLYLINE_MARKERS:
                ((PolylineMarkers) shape).setVisible(visible);
                break;
            case POLYGON_MARKERS:
                ((PolygonMarkers) shape).setVisible(visible);
                break;
            case MULTI_POLYLINE_MARKERS:
                ((MultiPolylineMarkers) shape).setVisible(visible);
                break;
            case MULTI_POLYGON_MARKERS:
                ((MultiPolygonMarkers) shape).setVisible(visible);
                break;
            case COLLECTION:
                @SuppressWarnings("unchecked")
                List<GoogleMapShape> shapeList = (List<GoogleMapShape>) shape;
                for (GoogleMapShape shapeListItem : shapeList) {
                    shapeListItem.setVisible(visible);
                }
                break;
            default:
        }

    }
572429
public MarkLine geoCoord(String name, String x, String y) {
        this.geoCoord().put(name, x, y);
        return this;
    }
1109803
void showCursor () {
		updateCurrentLine();
		if (cursorLine != firstLineShowing) {
			int step = cursorLine >= firstLineShowing ? 1 : -1;
			while (firstLineShowing > cursorLine || firstLineShowing + linesShowing - 1 < cursorLine) {
				firstLineShowing += step;
			}
		}
	}
982157
public GeometryIndex getLinearRingIndex(Geometry geometry, Coordinate location) {
		return fromDelegate(GeometryService.getLinearRingIndex(geometry, location));
	}
1292960
@SuppressFBWarnings("DM_EXIT")
    public static void showHelp(TextUICommandLine commandLine) {
        showSynopsis();
        ShowHelp.showGeneralOptions();
        FindBugs.showCommandLineOptions(commandLine);
        System.exit(1);
    }
38608
public void showOver(Node target) {
        requireNonNull(target, "Parameter 'target' is null");

        final Point2D center = center(target.localToScreen(target.getBoundsInLocal()));
        internalShow(target, target, center.getX(), center.getY());
    }
718689
public void setLine (float x1, float y1, float x2, float y2) {
        this.x1 = x1;
        this.y1 = y1;
        this.x2 = x2;
        this.y2 = y2;
    }
302520
function(id, geometry, style, featureId) {
        style = this.applyDefaultSymbolizer(style);
        // Get the node if it's already on the map.
        var node = this.nodeFactory(id, this.getNodeType(geometry, style));
        
        // Set the data for the node, then draw it.
        node._featureId = featureId;
        node._boundsBottom = geometry.getBounds().bottom;
        node._geometryClass = geometry.CLASS_NAME;
        node._style = style;

        var drawResult = this.drawGeometryNode(node, geometry, style);
        if(drawResult === false) {
            return false;
        }
         
        node = drawResult.node;
        
        // Insert the node into the indexer so it can show us where to
        // place it. Note that this operation is O(log(n)). If there's a
        // performance problem (when dragging, for instance) this is
        // likely where it would be.
        if (this.indexer) {
            var insert = this.indexer.insert(node);
            if (insert) {
                this.vectorRoot.insertBefore(node, insert);
            } else {
                this.vectorRoot.appendChild(node);
            }
        } else {
            // if there's no indexer, simply append the node to root,
            // but only if the node is a new one
            if (node.parentNode !== this.vectorRoot){ 
                this.vectorRoot.appendChild(node);
            }
        }
        
        this.postDraw(node);
        
        return drawResult.complete;
    }
867416
private void drawTicks() {
		// Abort if not attached
		if (!isAttached()) {
			return;
		}

		// Draw the ticks
		int lineWidth = lineElement.getOffsetWidth();
		if (numTicks > 0) {
			// Create the ticks or make them visible
			for (int i = 0; i <= numTicks; i++) {
				Element tick = null;
				if (i < tickElements.size()) {
					tick = tickElements.get(i);
				} else { // Create the new tick
					tick = DOM.createDiv();
					DOM.setStyleAttribute(tick, "position", "absolute");
					DOM.setStyleAttribute(tick, "display", "none");
					DOM.appendChild(getElement(), tick);
					tickElements.add(tick);
				}
				if (enabled) {
					DOM.setElementProperty(tick, "className", SLIDER_TICK);
				} else {
					DOM.setElementProperty(tick, "className", SLIDER_TICK + " "
							+ SLIDER_TICK_SLIDING);
				}
				// Position the tick and make it visible
				DOM.setStyleAttribute(tick, "visibility", "hidden");
				DOM.setStyleAttribute(tick, "display", "");
				int tickWidth = tick.getOffsetWidth();
				int tickLeftOffset = lineLeftOffset + (lineWidth * i / numTicks) - (tickWidth / 2);
				tickLeftOffset = Math.min(tickLeftOffset, lineLeftOffset + lineWidth - tickWidth);
				DOM.setStyleAttribute(tick, "left", tickLeftOffset + "px");
				DOM.setStyleAttribute(tick, "visibility", "visible");
			}

			// Hide unused ticks
			for (int i = (numTicks + 1); i < tickElements.size(); i++) {
				DOM.setStyleAttribute(tickElements.get(i), "display", "none");
			}
		} else { // Hide all ticks
			for (Element elem : tickElements) {
				DOM.setStyleAttribute(elem, "display", "none");
			}
		}
	}