Java tutorial
package com.google.gwt.maps.client; /* * #%L * GWT Maps API V3 - Core API * %% * Copyright (C) 2011 - 2012 GWT Maps API V3 * %% * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. * #L% */ import java.util.Collection; import java.util.HashMap; import java.util.Iterator; import com.google.gwt.core.client.JavaScriptObject; import com.google.gwt.dom.client.Element; import com.google.gwt.event.shared.HandlerRegistration; import com.google.gwt.maps.client.base.LatLng; import com.google.gwt.maps.client.base.LatLngBounds; import com.google.gwt.maps.client.controls.ControlPosition; import com.google.gwt.maps.client.events.MapHandlerRegistration; import com.google.gwt.maps.client.events.MapPanel; import com.google.gwt.maps.client.events.bounds.BoundsChangeMapHandler; import com.google.gwt.maps.client.events.center.CenterChangeMapHandler; import com.google.gwt.maps.client.events.click.ClickMapHandler; import com.google.gwt.maps.client.events.dblclick.DblClickMapHandler; import com.google.gwt.maps.client.events.drag.DragMapHandler; import com.google.gwt.maps.client.events.dragend.DragEndMapHandler; import com.google.gwt.maps.client.events.dragstart.DragStartMapHandler; import com.google.gwt.maps.client.events.heading.HeadingChangeMapHandler; import com.google.gwt.maps.client.events.idle.IdleMapHandler; import com.google.gwt.maps.client.events.maptypeid.MapTypeIdChangeMapHandler; import com.google.gwt.maps.client.events.mousemove.MouseMoveMapHandler; import com.google.gwt.maps.client.events.mouseout.MouseOutMapHandler; import com.google.gwt.maps.client.events.mouseover.MouseOverMapHandler; import com.google.gwt.maps.client.events.projection.ProjectionChangeMapHandler; import com.google.gwt.maps.client.events.resize.ResizeMapHandler; import com.google.gwt.maps.client.events.rightclick.RightClickMapHandler; import com.google.gwt.maps.client.events.tiles.TilesLoadedMapHandler; import com.google.gwt.maps.client.events.tilt.TiltChangeMapHandler; import com.google.gwt.maps.client.events.zoom.ZoomChangeMapHandler; import com.google.gwt.maps.client.maptypes.MapTypeRegistry; import com.google.gwt.maps.client.maptypes.Projection; import com.google.gwt.maps.client.maptypes.StyledMapType; import com.google.gwt.maps.client.mvc.MVCArray; import com.google.gwt.maps.client.mvc.MVCObjectWidget; import com.google.gwt.maps.client.streetview.StreetViewPanoramaImpl; import com.google.gwt.user.client.DOM; import com.google.gwt.user.client.ui.Widget; public class MapWidget extends MVCObjectWidget<MapImpl> { /** * added controls, must remove them when finished */ private HashMap<Integer, Widget> controls = null; /** * Reconstruct the mapWidget from JSO * * @param impl * @return NULL if input is NULL */ public static MapWidget newInstance(MapImpl impl) { if (impl == null) { return null; } return new MapWidget(impl); } /** * create a new Map Widget * * @param options {@link MapOptions} */ public MapWidget(MapOptions options) { Element div = DOM.createDiv(); setElement(div); impl = MapImpl.newInstance(div, options); } @Override protected void onDetach() { super.onDetach(); removeControls(); } private void removeControls() { if (controls == null) { return; } Collection<Widget> widgets = controls.values(); Iterator<Widget> itr = widgets.iterator(); while (itr.hasNext()) { Widget w = itr.next(); w.removeFromParent(); } } /** * reconstruct the mapWidget from jso * * @param impl JavaScriptObject */ private MapWidget(MapImpl impl) { this.impl = impl; setElement(impl.getDiv()); } /** * get JavaScriptObject instance. * * @return {@link MapImpl} */ public MapImpl getJso() { return impl; } /** * sets JavaScriptObject instance. * * @param impl {@link MapImpl} */ public void setJso(MapImpl impl) { this.impl = impl; } /** * Sets the viewport to contain the given bounds. * * @param bounds {@link LatLngBounds} */ public void fitBounds(LatLngBounds bounds) { impl.fitBounds(bounds); } /** * Returns the lat/lng bounds of the current viewport. If the map is not yet initialized (i.e. the mapType is still * null), or center and zoom have not been set then the result is null or undefined. * * @return {@link LatLngBounds} */ public LatLngBounds getBounds() { return impl.getBounds(); } /** * get Center * * @return {@link LatLng} */ public LatLng getCenter() { return impl.getCenter(); } /** * get Element */ public Element getDiv() { return impl.getDiv(); } /** * Returns the compass heading of aerial imagery. The heading value is measured in degrees (clockwise) from cardinal * direction North. * * @return int */ public int getHeading() { return impl.getHeading(); } /** * gets {@link MapTypeId} * * @return {@link MapTypeId} */ public final MapTypeId getMapTypeId() { return impl.getMapTypeId(); } /** * Returns the current Projection. If the map is not yet initialized (i.e. the mapType is still null) then the result * is null. Listen to projection_changed and check its value to ensure it is not null. * * @return {@link Projection} */ public Projection getProjection() { return impl.getProjection(); } /** * Returns the default StreetViewPanorama bound to the map, which may be a default panorama embedded within the map, * or the panorama set using setStreetView(). Changes to the map's streetViewControl will be reflected in the display * of such a bound panorama. * * @return {@link StreetViewPanoramaImpl} */ public StreetViewPanoramaImpl getStreetView() { return impl.getStreetView(); }; /** * gets Returns the angle of incidence for aerial imagery (available for SATELLITE and HYBRID map types) measured in * degrees from the viewport plane to the map plane. A value of 0 indicates no angle of incidence (no tilt) while 45 * imagery will return a value of 45. */ public int getTilt() { return impl.getTilt(); }; /** * get zoom */ public int getZoom() { return impl.getZoom(); }; /** * Changes the center of the map by the given distance in pixels. If the distance is less than both the width and * height of the map, the transition will be smoothly animated. Note that the map coordinate system increases from * west to east (for x values) and north to south (for y values). * * @param x * @param y */ public void panBy(int x, int y) { impl.panBy(x, y); }; /** * Changes the center of the map to the given LatLng. If the change is less than both the width and height of the map, * the transition will be smoothly animated. * * @param latLng */ public void panTo(LatLng latLng) { impl.panTo(latLng); }; /** * Pans the map by the minimum amount necessary to contain the given LatLngBounds. It makes no guarantee where on the * map the bounds will be, except that as much of the bounds as possible will be visible. The bounds will be * positioned inside the area bounded by the map type and navigation (pan, zoom, and Street View) controls, if they * are present on the map. If the bounds is larger than the map, the map will be shifted to include the northwest * corner of the bounds. If the change in the map's position is less than both the width and height of the map, the * transition will be smoothly animated. * * @param latLngBounds */ public void panToBounds(LatLngBounds latLngBounds) { impl.panToBounds(latLngBounds); }; /** * set center * * @param latlng */ public void setCenter(LatLng latlng) { impl.setCenter(latlng); }; /** * Sets the compass heading for aerial imagery measured in degrees from cardinal direction North. * * @param heading */ public void setHeading(int heading) { impl.setHeading(heading); }; /** * set MapTypeId * * @param mapTypeId */ public final void setMapTypeId(MapTypeId mapTypeId) { impl.setMapTypeId(mapTypeId); } /** * set MapTypeId (custom id if not in standard enum) * * @param mapTypeId */ public final void setMapTypeId(String mapTypeId) { impl.setMapTypeId(mapTypeId); } /** * set MapOptions * * @param options */ public void setOptions(MapOptions options) { impl.setOptions(options); }; /** * Sets the angle of incidence for aerial imagery (available for SATELLITE and HYBRID map types) measured in degrees * from the viewport plane to the map plane. The only supported values are 0, indicating no angle of incidence (no * tilt), and 45 indicating a tilt of 45°. * * @param panorama */ public void setStreetView(StreetViewPanoramaImpl panorama) { impl.setStreetView(panorama); }; /** * Sets the angle of incidence for aerial imagery (available for SATELLITE and HYBRID map types) measured in degrees * from the viewport plane to the map plane. The only supported values are 0, indicating no angle of incidence (no * tilt), and 45 indicating a tilt of 45°. * * @param tilt */ public void setTilt(int tilt) { impl.setTilt(tilt); }; /** * sets map zoom * * @param zoom */ public void setZoom(int zoom) { impl.setZoom(zoom); }; /** * TODO sets Additional controls to attach to the map. To add a control to the map, add the control's * <code><div></code> to the MVCArray corresponding to the ControlPosition where it should be rendered. * * @param controls */ public void setControls(MVCArray<Element> controls) { impl.setControls(controls); }; /** * sets Additional controls to attach to the map. To add a control to the map, add the control's * <code><div></code> to the MVCArray corresponding to the ControlPosition where it should be rendered. * * @param controlPosition * @param element */ public void setControls(ControlPosition controlPosition, Element element) { impl.setControls(controlPosition, element); }; /** * sets Additional controls to attach to the map. To add a control to the map, add the control's * <code><div></code> to the MVCArray corresponding to the ControlPosition where it should be rendered. * * @param controlPosition * @param widget */ public void setControls(ControlPosition controlPosition, Widget widget) { // remove any pre-existing controls removePriorControlFirst(controlPosition); // use a panel that controls onAttatch MapPanel mapPanel = new MapPanel(); mapPanel.add(widget); // add it to array for detaching if (controls == null) { controls = new HashMap<Integer, Widget>(); } controls.put(controlPosition.value(), mapPanel); // add it to the map impl.setControls(controlPosition, mapPanel.getElement()); }; /** * remove an pre-existing control so we don't get a mem leak * * @param controlPosition * @param widget */ private void removePriorControlFirst(ControlPosition controlPosition) { if (controls == null) { return; } Widget w = controls.get(controlPosition.value()); if (w == null) { return; } w.removeFromParent(); } /** * TODO gets Additional controls to attach to the map. To add a control to the map, add the control's * <code><div></code> to the MVCArray corresponding to the ControlPosition where it should be rendered. */ public MVCArray<Element> getControls() { return impl.getControls(); } /** * returns all controls for a controlPosition * * @param controlPosition * @return controls */ public MVCArray<Element> getControls(ControlPosition controlPosition) { return impl.getControls(controlPosition); } /** * TODO sets A registry of MapType instances by string ID. * * @param mapTypes */ public void setMapTypesRegistry(MapTypeRegistry mapTypes) { impl.setMapTypesRegistry(mapTypes); }; /** * Set the custom map type into the map's registry * * @param mapTypeId * @param styledType */ public void setCustomMapType(String mapTypeId, StyledMapType styledType) { impl.setCustomMapType(mapTypeId, styledType); } /** * gets a registry of MapType instances */ public MapTypeRegistry getMapTypeRegistry() { return impl.getMapTypeRegistry(); }; /** * TODO sets Additional map types to overlay. * * @param overlayMapTypes */ public void setOverlayMapTypes(MVCArray<JavaScriptObject> overlayMapTypes) { impl.setOverlayMapTypes(overlayMapTypes); }; /** * TODO gets Additional map types to overlay. */ public MVCArray<JavaScriptObject> getOverlayMapTypes() { return impl.getOverlayMapTypes(); }; /** * This event is fired when the viewport bounds have changed. * * @param handler {@link BoundsChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addBoundsChangeHandler(BoundsChangeMapHandler handler) { return impl.addBoundsChangeHandler(handler); } /** * This event is fired when the map center property changes. * * @param handler {@link CenterChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addCenterChangeHandler(CenterChangeMapHandler handler) { return impl.addCenterChangeHandler(handler); } /** * This event is fired when the user clicks on the map (but not when they click on a marker or infowindow). * * @param handler {@link ClickMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addClickHandler(ClickMapHandler handler) { return impl.addClickHandler(handler); } /** * This event is fired when the user double-clicks on the map. Note that the click event will also fire, right before * this one. * * @param handler {@link DblClickMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addDblClickHandler(DblClickMapHandler handler) { return impl.addDblClickHandler(handler); } /** * This event is repeatedly fired while the user drags the map. * * @param handler {@link DragMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addDragHandler(DragMapHandler handler) { return impl.addDragHandler(handler); } /** * This event is fired when the user stops dragging the map. * * @param handler {@link DragEndMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addDragEndHandler(DragEndMapHandler handler) { return impl.addDragEndHandler(handler); } /** * This event is fired when the user starts dragging the map. * * @param handler {@link DragStartMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addDragStartHandler(DragStartMapHandler handler) { return impl.addDragStartHandler(handler); } /** * This event is fired when the map heading property changes. * * @param handler {@link HeadingChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addHeadingChangeHandler(HeadingChangeMapHandler handler) { return impl.addHeadingChangeHandler(handler); } /** * This event is fired when the map becomes idle after panning or zooming. * * @param handler {@link IdleMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addIdleHandler(IdleMapHandler handler) { return impl.addIdleHandler(handler); } /** * This event is fired when the mapTypeId property changes. * * @param handler {@link MapTypeIdChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addMapTypeIdChangeHandler(MapTypeIdChangeMapHandler handler) { return impl.addMapTypeIdChangeHandler(handler); } /** * This event is fired whenever the user's mouse moves over the map container. * * @param handler {@link MouseMoveMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addMouseMoveHandler(MouseMoveMapHandler handler) { return impl.addMouseMoveHandler(handler); } /** * This event is fired when the user's mouse exits the map container. * * @param handler {@link MouseOutMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addMouseOutMoveHandler(MouseOutMapHandler handler) { return impl.addMouseOutMoveHandler(handler); } /** * This event is fired when the user's mouse enters the map container. * * @param handler {@link MouseOverMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addMouseOverHandler(MouseOverMapHandler handler) { return impl.addMouseOverHandler(handler); } /** * This event is fired when the projection has changed. * * @param handler {@link ProjectionChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addProjectionChangeHandler(ProjectionChangeMapHandler handler) { return impl.addProjectionChangeHandler(handler); } /** * Developers should trigger this event on the map when the div changes size: google.maps.event.trigger(map, 'resize') * . * * @param handler {@link ResizeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addResizeHandler(ResizeMapHandler handler) { return impl.addResizeHandler(handler); } /** * This event is fired when the DOM contextmenu event is fired on the map container. * * @param handler {@link RightClickMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addRightClickHandler(RightClickMapHandler handler) { return impl.addRightClickHandler(handler); } /** * This event is fired when the visible tiles have finished loading. * * @param handler {@link TilesLoadedMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addTilesLoadedHandler(TilesLoadedMapHandler handler) { return impl.addTilesLoadedHandler(handler); } /** * This event is fired when the map tilt property changes. * * @param handler {@link TiltChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addTiltChangeHandler(TiltChangeMapHandler handler) { return impl.addTiltChangeHandler(handler); } /** * This event is fired when the map zoom property changes. * * @param handler {@link ZoomChangeMapHandler} * @return {@link MapHandlerRegistration} */ public HandlerRegistration addZoomChangeHandler(ZoomChangeMapHandler handler) { return impl.addZoomChangeHandler(handler); } /** * Has to be called to resize the map if the canvas has changed. */ public final void triggerResize() { final LatLng center = getCenter(); impl.triggerResize(); setCenter(center); } }