001    package com.google.gwt.maps.client;
002    
003    import com.google.gwt.core.client.JavaScriptObject;
004    import com.google.gwt.dom.client.Element;
005    import com.google.gwt.event.shared.HandlerRegistration;
006    import com.google.gwt.maps.client.base.LatLng;
007    import com.google.gwt.maps.client.base.LatLngBounds;
008    import com.google.gwt.maps.client.controls.ControlPosition;
009    import com.google.gwt.maps.client.events.MapEventType;
010    import com.google.gwt.maps.client.events.MapHandlerRegistration;
011    import com.google.gwt.maps.client.events.bounds.BoundsChangeEventFormatter;
012    import com.google.gwt.maps.client.events.bounds.BoundsChangeMapHandler;
013    import com.google.gwt.maps.client.events.center.CenterChangeEventFormatter;
014    import com.google.gwt.maps.client.events.center.CenterChangeMapHandler;
015    import com.google.gwt.maps.client.events.click.ClickEventFormatter;
016    import com.google.gwt.maps.client.events.click.ClickMapHandler;
017    import com.google.gwt.maps.client.events.dblclick.DblClickEventFormatter;
018    import com.google.gwt.maps.client.events.dblclick.DblClickMapHandler;
019    import com.google.gwt.maps.client.events.drag.DragEventFormatter;
020    import com.google.gwt.maps.client.events.drag.DragMapHandler;
021    import com.google.gwt.maps.client.events.dragend.DragEndEventFormatter;
022    import com.google.gwt.maps.client.events.dragend.DragEndMapHandler;
023    import com.google.gwt.maps.client.events.dragstart.DragStartEventFormatter;
024    import com.google.gwt.maps.client.events.dragstart.DragStartMapHandler;
025    import com.google.gwt.maps.client.events.heading.HeadingChangeEventFormatter;
026    import com.google.gwt.maps.client.events.heading.HeadingChangeMapHandler;
027    import com.google.gwt.maps.client.events.idle.IdleEventFormatter;
028    import com.google.gwt.maps.client.events.idle.IdleMapHandler;
029    import com.google.gwt.maps.client.events.maptypeid.MapTypeIdChangeEventFormatter;
030    import com.google.gwt.maps.client.events.maptypeid.MapTypeIdChangeMapHandler;
031    import com.google.gwt.maps.client.events.mousemove.MouseMoveEventFormatter;
032    import com.google.gwt.maps.client.events.mousemove.MouseMoveMapHandler;
033    import com.google.gwt.maps.client.events.mouseout.MouseOutEventFormatter;
034    import com.google.gwt.maps.client.events.mouseout.MouseOutMapHandler;
035    import com.google.gwt.maps.client.events.mouseover.MouseOverEventFormatter;
036    import com.google.gwt.maps.client.events.mouseover.MouseOverMapHandler;
037    import com.google.gwt.maps.client.events.projection.ProjectionChangeEventFormatter;
038    import com.google.gwt.maps.client.events.projection.ProjectionChangeMapHandler;
039    import com.google.gwt.maps.client.events.resize.ResizeEventFormatter;
040    import com.google.gwt.maps.client.events.resize.ResizeMapHandler;
041    import com.google.gwt.maps.client.events.rightclick.RightClickEventFormatter;
042    import com.google.gwt.maps.client.events.rightclick.RightClickMapHandler;
043    import com.google.gwt.maps.client.events.tiles.TilesLoadedEventFormatter;
044    import com.google.gwt.maps.client.events.tiles.TilesLoadedMapHandler;
045    import com.google.gwt.maps.client.events.tilt.TiltChangeEventFormatter;
046    import com.google.gwt.maps.client.events.tilt.TiltChangeMapHandler;
047    import com.google.gwt.maps.client.events.zoom.ZoomChangeEventFormatter;
048    import com.google.gwt.maps.client.events.zoom.ZoomChangeMapHandler;
049    import com.google.gwt.maps.client.maptypes.MapTypeRegistry;
050    import com.google.gwt.maps.client.maptypes.Projection;
051    import com.google.gwt.maps.client.maptypes.StyledMapType;
052    import com.google.gwt.maps.client.mvc.MVCArray;
053    import com.google.gwt.maps.client.mvc.MVCObject;
054    import com.google.gwt.maps.client.streetview.StreetViewPanoramaImpl;
055    
056    /**
057     * Creates a new map inside of the given HTML container, which is typically a DIV element
058     * <br><br>
059     * See <a href="https://developers.google.com/maps/documentation/javascript/reference#Map">Map API Doc</a>
060     */
061    public class MapImpl extends MVCObject<MapImpl> {
062      
063      /**
064       * Creates a new map inside of the given HTML container, which is typically a DIV element.
065       */
066      protected MapImpl() {}
067     
068      /**
069       * Creates a new map inside of the given HTML container, which is typically a DIV element.
070       * @param element - map dom element container, like a div
071       * @param options - {@link MapOptions}
072       * @return {@link MapImpl}
073       */
074      public final static MapImpl newInstance(Element element, MapOptions options) {
075        return createJso(element, options);
076      }
077      
078      /**
079       * private native method
080       * @param id - dom element id
081       * @param {@link MapOptions}
082       */
083      private final static native MapImpl createJso(Element element, MapOptions options) /*-{
084        return new $wnd.google.maps.Map(element, options);
085      }-*/;
086      
087      /**
088       * Sets the viewport to contain the given bounds.
089       * @param bounds {@link LatLngBounds}
090       */
091      public final native void fitBounds(LatLngBounds bounds) /*-{
092        this.fitBounds(bounds);
093      }-*/;
094      
095      /**
096       * 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.
097       * @return {@link LatLngBounds}
098       */
099      public final native LatLngBounds getBounds() /*-{
100        return this.getBounds();
101      }-*/;
102      
103      /**
104       * return map center in coordinates
105       */
106      public final native LatLng getCenter() /*-{
107        return this.getCenter();
108      }-*/;
109      
110      /**
111       * Get map's containing element
112       */
113      public final native Element getDiv() /*-{
114        return this.getDiv();
115      }-*/; 
116      
117      /**
118       * Returns the compass heading of aerial imagery. The heading value is measured in degrees (clockwise) from cardinal direction North.
119       * @return int
120       */
121      public final native int getHeading() /*-{
122        return this.getHeading() || 0;
123      }-*/;
124      
125      /**
126       * gets {@link MapTypeId}
127       * @return {@link MapTypeId}
128       */
129      public final MapTypeId getMapTypeId() {
130        return MapTypeId.fromValue(getMapTypeIdImpl());
131      }
132     
133      private final native String getMapTypeIdImpl() /*-{
134        return this.getMapTypeId();
135      }-*/;
136      
137      /**
138       * 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.
139       * @return {@link Projection}
140       */
141      public final native Projection getProjection() /*-{
142        return this.getProjection();
143      }-*/;
144      
145      /**
146       * 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.
147       * @return {@link StreetViewPanoramaImpl}
148       */
149      public final native StreetViewPanoramaImpl getStreetView() /*-{
150        return this.getStreetView();
151      }-*/;
152      
153      /**
154       * 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.
155       */
156      public final native int getTilt() /*-{
157        return this.getTilt();
158      }-*/;
159      
160      /**
161       * get zoom
162       */
163      public final native int getZoom() /*-{
164        return this.getZoom();
165      }-*/;
166      
167      /**
168       * 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).
169       * @param x
170       * @param y
171       */
172      public final native void panBy(int x, int y) /*-{
173        this.panBy(x, y);
174      }-*/;
175      
176      /**
177       * 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.
178       * @param latLng
179       */
180      public final native void panTo(LatLng latLng) /*-{
181        this.panTo(latLng);
182      }-*/;
183      
184      /**
185       * 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.
186       * @param latLngBounds
187       */
188      public final native void panToBounds(LatLngBounds latLngBounds) /*-{
189        this.panToBounds(latLngBounds);
190      }-*/;
191      
192      /**
193       * set center
194       * @param latlng
195       */
196      public final native void setCenter(LatLng latlng) /*-{
197        this.setCenter(latlng);
198      }-*/;
199      
200      /**
201       * Sets the compass heading for aerial imagery measured in degrees from cardinal direction North.
202       * @param heading
203       */
204      public final native void setHeading(int heading) /*-{
205        this.setHeading(heading);
206      }-*/;
207      
208      /**
209       * set MapTypeId
210       * @param mapTypeId
211       */
212      public final void setMapTypeId(MapTypeId mapTypeId) { 
213        setMapTypeIdImpl(mapTypeId.name());
214      }
215      
216      private final native void setMapTypeIdImpl(String mapTypeId) /*-{
217        this.setMapTypeId(mapTypeId);
218      }-*/;
219      
220      /**
221       * set MapOptions
222       * @param options
223       */
224      public final native void setOptions(MapOptions options) /*-{
225        this.setOptions(options);
226      }-*/;
227      
228      /**
229       * 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&deg;.
230       * @param panorama
231       */
232      public final native void setStreetView(StreetViewPanoramaImpl panorama) /*-{
233        this.setStreetView(panorama);
234      }-*/;
235      
236      /**
237       * 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&deg;.
238       * @param tilt
239       */
240      public final native void setTilt(int tilt) /*-{
241        this.setTilt(tilt);
242      }-*/; 
243      
244      /**
245       * sets map zoom
246       * @param zoom
247       */
248      public final native void setZoom(int zoom) /*-{
249        this.setZoom(zoom);
250      }-*/;
251      
252      /**
253       * TODO
254       * sets Additional controls to attach to the map. To add a control to the map, add the control's <code>&lt;div&gt;</code> to the MVCArray corresponding to the ControlPosition where it should be rendered.
255       * @param controls
256       */
257      public final native void setControls(MVCArray<Element> controls) /*-{
258        this.controls = controls;
259      }-*/;
260      
261      /**
262       * sets Additional controls to attach to the map. To add a control to the map, add the control's <code>&lt;div&gt;</code> to the MVCArray corresponding to the ControlPosition where it should be rendered.
263       * @param controlPosition
264       * @param element
265       */
266      public final void setControls(ControlPosition controlPosition, Element element) {
267        setControls(controlPosition.value(), element);
268      }
269      
270      private final native void setControls(int controlPosition, Element element) /*-{
271        this.controls[controlPosition].push(element);
272      }-*/;
273      
274      /**
275       * TODO
276       * gets Additional controls to attach to the map. To add a control to the map, add the control's <code>&lt;div&gt;</code> to the MVCArray corresponding to the ControlPosition where it should be rendered.
277       */
278      public final native MVCArray<Element> getControls() /*-{
279        return controls;
280      }-*/;
281      
282      /**
283       * TODO
284       * sets A registry of MapType instances by string ID.
285       * @param mapTypes
286       */
287      public final native void setMapTypesRegistry(MapTypeRegistry mapTypes) /*-{
288        this.mapTypes = mapTypes;
289      }-*/;
290      
291      /**
292       * Set the custom map type into the map's registry
293       * @param mapTypeId
294       * @param styledType
295       */
296      public final native void setCustomMapType(String mapTypeId, StyledMapType styledType) /*-{
297        this.mapTypes.set(mapTypeId, styledType);
298      }-*/;
299      
300      /**
301       * gets A registry of MapType instances by string ID.
302       */
303      public final native MapTypeRegistry getMapTypeRegistry() /*-{
304        return this.mapTypes;
305      }-*/;
306      
307      /**
308       * TODO
309       * sets Additional map types to overlay.
310       * @param overlayMapTypes
311       */
312      public final native void setOverlayMapTypes(MVCArray<JavaScriptObject> overlayMapTypes) /*-{
313        this.overlayMapTypes = overlayMapTypes;
314      }-*/;
315      
316      /**
317       * TODO
318       * gets Additional map types to overlay.
319       */
320      public final native MVCArray<JavaScriptObject> getOverlayMapTypes() /*-{
321        return this.overlayMapTypes;
322      }-*/;
323      
324      /**
325       * This event is fired when the viewport bounds have changed.
326       * @param handler {@link BoundsChangeMapHandler}
327       * @return {@link MapHandlerRegistration}
328       */
329      public final HandlerRegistration addBoundsChangeHandler(BoundsChangeMapHandler handler) {
330        return MapHandlerRegistration.addHandler(this, MapEventType.BOUNDS_CHANGED, handler, new BoundsChangeEventFormatter());
331      }
332    
333      /**
334       * This event is fired when the map center property changes.
335       * @param handler {@link CenterChangeMapHandler}
336       * @return {@link MapHandlerRegistration}
337       */
338      public final HandlerRegistration addCenterChangeHandler(CenterChangeMapHandler handler) {
339        return MapHandlerRegistration.addHandler(this, MapEventType.CENTER_CHANGED, handler, new CenterChangeEventFormatter());
340      }
341    
342      /**
343       * This event is fired when the user clicks on the map (but not when they click on a marker or infowindow).
344       * @param handler {@link ClickMapHandler}
345       * @return {@link MapHandlerRegistration}
346       */
347      public final HandlerRegistration addClickHandler(ClickMapHandler handler) {
348        return MapHandlerRegistration.addHandler(this, MapEventType.CLICK, handler, new ClickEventFormatter());
349      }
350    
351      /**
352       * This event is fired when the user double-clicks on the map. Note that the click event will also fire, right before this one.
353       * @param handler {@link DblClickMapHandler}
354       * @return {@link MapHandlerRegistration}
355       */
356      public final HandlerRegistration addDblClickHandler(DblClickMapHandler handler) {
357        return MapHandlerRegistration.addHandler(this, MapEventType.DBLCLICK, handler, new DblClickEventFormatter());
358      }
359    
360      /**
361       * This event is repeatedly fired while the user drags the map.
362       * @param handler {@link DragMapHandler}
363       * @return {@link MapHandlerRegistration}
364       */
365      public final HandlerRegistration addDragHandler(DragMapHandler handler) {
366        return MapHandlerRegistration.addHandler(this, MapEventType.DRAG, handler, new DragEventFormatter());
367      }
368    
369      /**
370       * This event is fired when the user stops dragging the map.
371       * @param handler {@link DragEndMapHandler}
372       * @return {@link MapHandlerRegistration}
373       */
374      public final HandlerRegistration addDragEndHandler(DragEndMapHandler handler) {
375        return MapHandlerRegistration.addHandler(this, MapEventType.DRAGEND, handler, new DragEndEventFormatter());
376      }
377    
378      /**
379       * This event is fired when the user starts dragging the map.
380       * @param handler {@link DragStartMapHandler}
381       * @return {@link MapHandlerRegistration}
382       */
383      public final HandlerRegistration addDragStartHandler(DragStartMapHandler handler) {
384        return MapHandlerRegistration.addHandler(this, MapEventType.DRAGSTART, handler, new DragStartEventFormatter());
385      }
386    
387      /**
388       * This event is fired when the map heading property changes.
389       * @param handler {@link HeadingChangeMapHandler}
390       * @return {@link MapHandlerRegistration}
391       */
392      public final HandlerRegistration addHeadingChangeHandler(HeadingChangeMapHandler handler) {
393        return MapHandlerRegistration.addHandler(this, MapEventType.HEADING_CHANGED, handler, new HeadingChangeEventFormatter());
394      }
395    
396      /**
397       * This event is fired when the map becomes idle after panning or zooming.
398       * @param handler {@link IdleMapHandler}
399       * @return {@link MapHandlerRegistration}
400       */
401      public final HandlerRegistration addIdleHandler(IdleMapHandler handler) {
402        return MapHandlerRegistration.addHandler(this, MapEventType.IDLE, handler, new IdleEventFormatter());
403      }
404    
405      /**
406       * This event is fired when the mapTypeId property changes.
407       * @param handler {@link MapTypeIdChangeMapHandler}
408       * @return {@link MapHandlerRegistration}
409       */
410      public final HandlerRegistration addMapTypeIdChangeHandler(MapTypeIdChangeMapHandler handler) {
411        return MapHandlerRegistration.addHandler(this, MapEventType.MAPTYPEID_CHANGED, handler, new MapTypeIdChangeEventFormatter());
412      }
413    
414      /**
415       * This event is fired whenever the user's mouse moves over the map container.
416       * @param handler {@link MouseMoveMapHandler}
417       * @return {@link MapHandlerRegistration}
418       */
419      public final HandlerRegistration addMouseMoveHandler(MouseMoveMapHandler handler) {
420        return MapHandlerRegistration.addHandler(this, MapEventType.MOUSEMOVE, handler, new MouseMoveEventFormatter());
421      }
422    
423      /**
424       * This event is fired when the user's mouse exits the map container.
425       * @param handler {@link MouseOutMapHandler}
426       * @return {@link MapHandlerRegistration}
427       */
428      public final HandlerRegistration addMouseOutMoveHandler(MouseOutMapHandler handler) {
429        return MapHandlerRegistration.addHandler(this, MapEventType.MOUSEOUT, handler, new MouseOutEventFormatter());
430      }
431    
432      /**
433       * This event is fired when the user's mouse enters the map container.
434       * @param handler {@link MouseOverMapHandler}
435       * @return {@link MapHandlerRegistration}
436       */
437      public final HandlerRegistration addMouseOverHandler(MouseOverMapHandler handler) {
438        return MapHandlerRegistration.addHandler(this, MapEventType.MOUSEOVER, handler, new MouseOverEventFormatter());
439      }
440    
441      /**
442       * This event is fired when the projection has changed.
443       * @param handler {@link ProjectionChangeMapHandler}
444       * @return {@link MapHandlerRegistration}
445       */
446      public final HandlerRegistration addProjectionChangeHandler(ProjectionChangeMapHandler handler) {
447        return MapHandlerRegistration.addHandler(this, MapEventType.PROJECTION_CHANGED, handler, new ProjectionChangeEventFormatter());
448      }
449    
450      /**
451       * Developers should trigger this event on the map when the div changes size: google.maps.event.trigger(map, 'resize') .
452       * @param handler {@link ResizeMapHandler}
453       * @return {@link MapHandlerRegistration}
454       */
455      public final HandlerRegistration addResizeHandler(ResizeMapHandler handler) {
456        return MapHandlerRegistration.addHandler(this, MapEventType.RESIZE, handler, new ResizeEventFormatter());
457      }
458    
459      /**
460       * This event is fired when the DOM contextmenu event is fired on the map container.
461       * @param handler {@link RightClickMapHandler}
462       * @return {@link MapHandlerRegistration}
463       */
464      public final HandlerRegistration addRightClickHandler(RightClickMapHandler handler) {
465        return MapHandlerRegistration.addHandler(this, MapEventType.RIGHTCLICK, handler, new RightClickEventFormatter());
466      }
467    
468      /**
469       * This event is fired when the visible tiles have finished loading.
470       * @param handler {@link TilesLoadedMapHandler}
471       * @return {@link MapHandlerRegistration}
472       */
473      public final HandlerRegistration addTilesLoadedHandler(TilesLoadedMapHandler handler) {
474        return MapHandlerRegistration.addHandler(this, MapEventType.TILESLOADED, handler, new TilesLoadedEventFormatter());
475      }
476    
477      /**
478       * This event is fired when the map tilt property changes.
479       * @param handler {@link TiltChangeMapHandler}
480       * @return {@link MapHandlerRegistration}
481       */
482      public final HandlerRegistration addTiltChangeHandler(TiltChangeMapHandler handler) {
483        return MapHandlerRegistration.addHandler(this, MapEventType.TILT_CHANGED, handler, new TiltChangeEventFormatter());
484      }
485    
486      /**
487       * This event is fired when the map zoom property changes.
488       * @param handler {@link ZoomChangeMapHandler}
489       * @return {@link MapHandlerRegistration}
490       */
491      public final HandlerRegistration addZoomChangeHandler(ZoomChangeMapHandler handler) {
492        return MapHandlerRegistration.addHandler(this, MapEventType.ZOOM_CHANGED, handler, new ZoomChangeEventFormatter());
493      }
494    
495    }