* Copyright 2008 Google Inc.

*

* 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.

*/

* A widget that presents a viewable Google Map to a user.

*

* Note: the GEvent.trigger methods are implemented by the API but intended for

* internal testing only.

*/

    public void addVirtual(Widget w) {

      w.removeFromParent();

      getChildren().add(w);

      adopt(w);

    }

  }

  private static final LatLng DEFAULT_CENTER = new LatLng(33.781466, -84.387519);

  static {

    Window.addWindowCloseListener(new WindowCloseListener() {

      public void onWindowClosed() {

        nativeUnload();

      }

      public String onWindowClosing() {

        return null;

      }

    });

  }

  static MapWidget createPeer(JavaScriptObject jsoPeer) {

    throw new UnsupportedOperationException();

  }

  private static native void nativeUnload() /*-{

      $wnd.GUnload && $wnd.GUnload();

    }-*/;

  private ListenerCollection<MapClickListener> clickListeners;

  private ListenerCollection<MapDragListener> dragListeners;

  private HandlerCollection<MapInfoWindowBeforeCloseHandler> infoWindowBeforeCloseHandlers;

  private HandlerCollection<MapInfoWindowCloseHandler> infoWindowCloseHandlers;

  private ListenerCollection<InfoWindowListener> infoWindowListeners;

  private HandlerCollection<MapInfoWindowOpenHandler> infoWindowOpenHandlers;

  /* Reference to GMap2 object. */

  private final JavaScriptObject jsoPeer;

  private HandlerCollection<MapAddMapTypeHandler> mapAddMapTypeHandlers;

  private HandlerCollection<MapAddOverlayHandler> mapAddOverlayHandlers;

  private HandlerCollection<MapClearOverlaysHandler> mapClearOverlaysHandlers;

  private HandlerCollection<MapClickHandler> mapClickHandlers;

  private final MapPanel mapContainer = new MapPanel();

  private HandlerCollection<MapDoubleClickHandler> mapDoubleClickHandlers;

  private HandlerCollection<MapDragEndHandler> mapDragEndHandlers;

  private HandlerCollection<MapDragHandler> mapDragHandlers;

  private HandlerCollection<MapDragStartHandler> mapDragStartHandlers;

  private HandlerCollection<MapMouseMoveHandler> mapMouseMoveHandlers;

  private HandlerCollection<MapMouseOutHandler> mapMouseOutHandlers;

  private HandlerCollection<MapMouseOverHandler> mapMouseOverHandlers;

  private HandlerCollection<MapMoveEndHandler> mapMoveEndHandlers;

  private HandlerCollection<MapMoveHandler> mapMoveHandlers;

  private HandlerCollection<MapMoveStartHandler> mapMoveStartHandlers;

  private HandlerCollection<MapRemoveMapTypeHandler> mapRemoveMapTypeHandlers;

  private HandlerCollection<MapRemoveOverlayHandler> mapRemoveOverlayHandlers;

  private HandlerCollection<MapRightClickHandler> mapRightClickHandlers;

  private HandlerCollection<MapTypeChangedHandler> mapTypeChangedHandlers;

  private ListenerCollection<MapTypeListener> mapTypeListeners;

  private HandlerCollection<MapZoomEndHandler> mapZoomEndHandlers;

  private ListenerCollection<MapMouseListener> mouseListeners;

  private ListenerCollection<MapMoveListener> moveListeners;

  private ListenerCollection<OverlayListener> overlayListeners;

  /**

   * Cache of the map panes returned for this widget.

   */

  private Map<MapPaneType, MapPane> panes;

  private ListenerCollection<MapZoomListener> zoomListeners;

  public MapWidget() {

    this(DEFAULT_CENTER, 8, null, null);

  }

  /**

   * Creates a new map widget and sets the view to the given center and zoom

   * level.

   *

   * @param center the geographical point about which to center

   * @param zoomLevel the zoom level

   */

  public MapWidget(LatLng center, int zoomLevel) {

    this(center, zoomLevel, null, null);

  }

  /**

   * Creates a new map widget and sets the view to the specified center point

   * and zoom level. Also, sets the dragging and draggable cursor values. See

   * the W3C CSS spec for allowable cursor string values.

   *

   * Note: The 'load' event requires that a handler be registered before

   * GMap2.setCenter() is called. Since that method is always called in this

   * constructor, it isn't clear that gwt-google-apis users needs this event.

   *

   * @param center the geographical point about which to center

   * @param zoomLevel zoomLevel the zoom level

   * @param draggableCursor CSS name of the cursor to display when the map is

   *          draggable

   * @param draggingCursor CSS name of the cursor to display when the map is

   *          being dragged

   */

  public MapWidget(LatLng center, int zoomLevel, String draggableCursor,

      String draggingCursor) {

    initWidget(mapContainer);

    JavaScriptObject opts = MapOptionsImpl.impl.construct();

    MapOptionsImpl.impl.setDraggableCursor(opts, draggableCursor);

    MapOptionsImpl.impl.setDraggingCursor(opts, draggingCursor);

    jsoPeer = MapImpl.impl.construct(getElement(), opts);

    MapImpl.impl.bind(jsoPeer, this);

    setCenter(center, zoomLevel);

  }

  /**

   * Adds a control to the map. The default position of the control is used. A

   * control instance cannot be added more than once to the map.

   *

   * @param control the control to be added

   */

  public void addControl(Control control) {

    MapImpl.impl.addControl(jsoPeer, control);

  }

  /**

   * Adds a control to the map at the given position. A control instance cannot

   * be added more than once to the map.

   *

   * @param control the control to be added

   * @param position the position of the control

   */

  public void addControl(Control control, ControlPosition position) {

    MapImpl.impl.addControl(jsoPeer, control, position);

  }

  /**

   * Adds a Control's widget to the map.

   *

   * This method is not intended to be called by the user. To add a custom

   * control to the map, subclass

   * {@link com.google.gwt.maps.client.control.Control.CustomControl} and

   * implement the initialize(MapWidget) method.

   *

   * @param w the control widget to add to the map

   */

  public void addControlWidget(Widget w) {

    mapContainer.add(w);

  }

  /**

   * This event is fired before the info window closes. (Since 2.83)

   *

   * @param handler the handler to call when this event fires.

   */

  public void addInfoWindowBeforeCloseHandler(

      final MapInfoWindowBeforeCloseHandler handler) {

    maybeInitInfoWindowBeforeCloseHandlers();

    infoWindowBeforeCloseHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapInfoWindowBeforeCloseEvent e = new MapInfoWindowBeforeCloseEvent(

            MapWidget.this);

        handler.onInfoWindowBeforeClose(e);

      }

    });

  }

  /**

   * This event is fired when the info window closes. The handler

   * {@link MapInfoWindowBeforeCloseHandler} is fired before this event. If a

   * currently open info window is reopened at a different point using another

   * call to openInfoWindow*(), the handler

   * {@link MapInfoWindowBeforeCloseHandler}, {@link MapInfoWindowCloseHandler}

   * and {@link MapInfoWindowOpenHandler} are fired in this order

   *

   * @param handler the handler to call when this event fires.

   */

  public void addInfoWindowCloseHandler(final MapInfoWindowCloseHandler handler) {

    maybeInitInfoWindowCloseHandlers();

    infoWindowCloseHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapInfoWindowCloseEvent e = new MapInfoWindowCloseEvent(MapWidget.this);

        handler.onInfoWindowClose(e);

      }

    });

  }

  /**

   * Add a listener for InfoWindow events.

   *

   * @param listener listener to invoke on InfoWindow events

   *

   * @deprecated see

   *             {@link MapWidget#addInfoWindowBeforeCloseHandler(MapInfoWindowBeforeCloseHandler)},

   *             {@link MapWidget#addInfoWindowCloseHandler(MapInfoWindowCloseHandler)},

   *             and

   *             {@link MapWidget#addInfoWindowOpenHandler(MapInfoWindowOpenHandler)}

   */

  @Deprecated

  public void addInfoWindowListener(final InfoWindowListener listener) {

    if (infoWindowListeners == null) {

      infoWindowListeners = new ListenerCollection<InfoWindowListener>();

    }

    JavaScriptObject infoWindowEventHandles[] = {

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.INFOWINDOWOPEN,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onInfoWindowOpened(MapWidget.this);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.INFOWINDOWCLOSE,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onInfoWindowClosed(MapWidget.this);

              }

            })};

    infoWindowListeners.addListener(listener, infoWindowEventHandles);

  }

  /**

   * This event is fired when the info window opens.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addInfoWindowOpenHandler(final MapInfoWindowOpenHandler handler) {

    maybeInitInfoWindowOpenHandlers();

    infoWindowOpenHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapInfoWindowOpenEvent e = new MapInfoWindowOpenEvent(MapWidget.this);

        handler.onInfoWindowOpen(e);

      }

    });

  }

  /**

   * This event is fired when a map type is added to the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapAddMapTypeHandler(final MapAddMapTypeHandler handler) {

    maybeInitMapAddMapTypeHandlers();

    mapAddMapTypeHandlers.addHandler(handler, new MapTypeCallback() {

      @Override

      public void callback(MapType type) {

        MapAddMapTypeEvent e = new MapAddMapTypeEvent(MapWidget.this, type);

        handler.onAddMapType(e);

      }

    });

  }

  /**

   * This event is fired when a single overlay is added to the map by the method

   * addOverlay(). The new overlay is passed as an argument overlay to the event

   * handler.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapAddOverlayHandler(final MapAddOverlayHandler handler) {

    maybeInitMapAddOverlayHandlers();

    mapAddOverlayHandlers.addHandler(handler, new OverlayCallback() {

      @Override

      public void callback(Overlay overlay) {

        MapAddOverlayEvent e = new MapAddOverlayEvent(MapWidget.this, overlay);

        handler.onAddOverlay(e);

      }

    });

  }

  /**

   * This event is fired when all overlays are removed at once by the method

   * {@link MapWidget#clearOverlays()}.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapClearOverlaysHandler(final MapClearOverlaysHandler handler) {

    maybeInitMapClearOverlaysHandlers();

    mapClearOverlaysHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapClearOverlaysEvent e = new MapClearOverlaysEvent(MapWidget.this);

        handler.onClearOverlays(e);

      }

    });

  }

  /**

   * Add a click handler for mouse click events. Note: this event fires even for

   * double click events (twice!).

   *

   * @param handler handler to invoke on mouse click events.

   */

  public void addMapClickHandler(final MapClickHandler handler) {

    maybeInitMapClickHandlers();

    mapClickHandlers.addHandler(handler, new OverlayLatLngCallback() {

      @Override

      public void callback(Overlay overlay, LatLng latlng) {

        MapClickEvent e = new MapClickEvent(MapWidget.this, overlay, latlng);

        handler.onClick(e);

      }

    });

  }

  /**

   * Add a click listener for mouse click events.

   *

   * @param listener listener to invoke on mouse click events.

   *

   * @deprecated replace with

   *             {@link MapWidget#addMapClickHandler(MapClickHandler)},

   *             {@link MapWidget#addMapDoubleClickHandler(MapDoubleClickHandler)},

   *             and

   *             {@link MapWidget#addMapRightClickHandler(MapRightClickHandler)}

   */

  @Deprecated

  public void addMapClickListener(final MapClickListener listener) {

    if (clickListeners == null) {

      clickListeners = new ListenerCollection<MapClickListener>();

    }

    JavaScriptObject clickEventHandles[] = {

        EventImpl.impl.addListener(jsoPeer, MapEvent.CLICK,

            new OverlayLatLngCallback() {

              @Override

              public void callback(Overlay overlay, LatLng latlng) {

                listener.onClick(MapWidget.this, overlay, latlng);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.DBLCLICK,

            new OverlayLatLngCallback() {

              @Override

              public void callback(Overlay overlay, LatLng latlng) {

                listener.onDoubleClick(MapWidget.this, overlay, latlng);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.SINGLERIGHTCLICK,

            new PointElementOverlayCallback() {

              @Override

              public void callback(Point point, Element element, Overlay overlay) {

                listener.onRightClick(MapWidget.this, point, element, overlay);

              }

            })};

    clickListeners.addListener(listener, clickEventHandles);

  }

  /**

   * Add a double click handler for mouse double click events. Note that this

   * event will not be invoked if the double click was on a marker object.

   *

   * @param handler handler to invoke on mouse double click events.

   */

  public void addMapDoubleClickHandler(final MapDoubleClickHandler handler) {

    maybeInitMapDoubleClickHandlers();

    mapDoubleClickHandlers.addHandler(handler, new OverlayLatLngCallback() {

      @Override

      public void callback(Overlay overlay, LatLng latlng) {

        // the overlay parameter is always NULL according to the Maps API.

        MapDoubleClickEvent e = new MapDoubleClickEvent(MapWidget.this, latlng);

        handler.onDoubleClick(e);

      }

    });

  }

  /**

   * This event is fired when the user stops dragging the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapDragEndHandler(final MapDragEndHandler handler) {

    maybeInitMapDragEndHandlers();

    mapDragEndHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapDragEndEvent e = new MapDragEndEvent(MapWidget.this);

        handler.onDragEnd(e);

      }

    });

  }

  /**

   * This event is repeatedly fired while the user drags the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapDragHandler(final MapDragHandler handler) {

    maybeInitMapDragHandlers();

    mapDragHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapDragEvent e = new MapDragEvent(MapWidget.this);

        handler.onDrag(e);

      }

    });

  }

  /**

   * Add a drag listener for mouse drag events.

   *

   * @param listener listener to invoke on mouse drag events.

   *

   * @deprecated see

   *             {@link MapWidget#addMapDragStartHandler(MapDragStartHandler)},

   *             {@link MapWidget#addMapDragEndHandler(MapDragEndHandler)}, and

   *             {@link MapWidget#addMapDragHandler(MapDragHandler)}

   */

  @Deprecated

  public void addMapDragListener(final MapDragListener listener) {

    if (dragListeners == null) {

      dragListeners = new ListenerCollection<MapDragListener>();

    }

    JavaScriptObject dragEventHandles[] = {

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.DRAGSTART,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onDragStart(MapWidget.this);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.DRAG,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onDrag(MapWidget.this);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.DRAGEND,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onDragEnd(MapWidget.this);

              }

            })};

    dragListeners.addListener(listener, dragEventHandles);

  }

  /**

   * This event is fired when the user starts dragging the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapDragStartHandler(final MapDragStartHandler handler) {

    maybeInitMapDragStartHandlers();

    mapDragStartHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapDragStartEvent e = new MapDragStartEvent(MapWidget.this);

        handler.onDragStart(e);

      }

    });

  }

  /**

   * Add a listener for mouse move events.

   *

   * @param listener listener to invoke on mouse move events.

   *

   * @deprecated see

   *             {@link MapWidget#addMapMouseMoveHandler(MapMouseMoveHandler)},

   *             {@link MapWidget#addMapMouseOutHandler(MapMouseOutHandler)},

   *             and

   *             {@link MapWidget#addMapMouseOverHandler(MapMouseOverHandler)}

   */

  @Deprecated

  public void addMapMouseListener(final MapMouseListener listener) {

    if (mouseListeners == null) {

      mouseListeners = new ListenerCollection<MapMouseListener>();

    }

    JavaScriptObject mouseEventHandles[] = {

        EventImpl.impl.addListener(jsoPeer, MapEvent.MOUSEOVER,

            new LatLngCallback() {

              @Override

              public void callback(LatLng latlng) {

                listener.onMouseOver(MapWidget.this, latlng);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.MOUSEOUT,

            new LatLngCallback() {

              @Override

              public void callback(LatLng latlng) {

                listener.onMouseOut(MapWidget.this, latlng);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.MOUSEMOVE,

            new LatLngCallback() {

              @Override

              public void callback(LatLng latlng) {

                listener.onMouseMove(MapWidget.this, latlng);

              }

            })};

    mouseListeners.addListener(listener, mouseEventHandles);

  }

  /**

   * This event is fired when the user moves the mouse over the map from outside

   * the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapMouseMoveHandler(final MapMouseMoveHandler handler) {

    maybeInitMapMouseMoveHandlers();

    mapMouseMoveHandlers.addHandler(handler, new LatLngCallback() {

      @Override

      public void callback(LatLng point) {

        MapMouseMoveEvent e = new MapMouseMoveEvent(MapWidget.this, point);

        handler.onMouseMove(e);

      }

    });

  }

  /**

   * This event is fired when the user moves the mouse over the map from outside

   * the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapMouseOutHandler(final MapMouseOutHandler handler) {

    maybeInitMapMouseOutHandlers();

    mapMouseOutHandlers.addHandler(handler, new LatLngCallback() {

      @Override

      public void callback(LatLng point) {

        MapMouseOutEvent e = new MapMouseOutEvent(MapWidget.this, point);

        handler.onMouseOut(e);

      }

    });

  }

  /**

   * This event is fired when the user moves the mouse over the map from outside

   * the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapMouseOverHandler(final MapMouseOverHandler handler) {

    maybeInitMapMouseOverHandlers();

    mapMouseOverHandlers.addHandler(handler, new LatLngCallback() {

      @Override

      public void callback(LatLng point) {

        MapMouseOverEvent e = new MapMouseOverEvent(MapWidget.this, point);

        handler.onMouseOver(e);

      }

    });

  }

  /**

   * This event is fired when the change of the map view ends.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapMoveEndHandler(final MapMoveEndHandler handler) {

    maybeInitMapMoveEndHandlers();

    mapMoveEndHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapMoveEndEvent e = new MapMoveEndEvent(MapWidget.this);

        handler.onMoveEnd(e);

      }

    });

  }

  /**

   * This event is fired, possibly repeatedly, while the map view is changing.

   *

   * @param handler handler to invoke on map move events.

   */

  public void addMapMoveHandler(final MapMoveHandler handler) {

    maybeInitMapMoveHandlers();

    mapMoveHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapMoveEvent e = new MapMoveEvent(MapWidget.this);

        handler.onMove(e);

      }

    });

  }

  /**

   * Add a listener for map move events.

   *

   * @param listener listener to invoke on map move events.

   *

   * @deprecated see {@link MapWidget#addMapMoveHandler(MapMoveHandler)},

   *             {@link MapWidget#addMapMoveEndHandler(MapMoveEndHandler)}, and

   *             {@link MapWidget#addMapMoveStartHandler(MapMoveStartHandler)}

   */

  @Deprecated

  public void addMapMoveListener(final MapMoveListener listener) {

    if (moveListeners == null) {

      moveListeners = new ListenerCollection<MapMoveListener>();

    }

    JavaScriptObject moveEventHandles[] = {

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.MOVE,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onMove(MapWidget.this);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.MOVESTART,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onMoveStart(MapWidget.this);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.MOVEEND,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onMoveEnd(MapWidget.this);

              }

            })};

    moveListeners.addListener(listener, moveEventHandles);

  }

  /**

   * This event is fired when the map view starts changing. This can be caused

   * by dragging, in which case a {@link MapDragStartEvent} is also fired, or by

   * invocation of a method that changes the map view.

   *

   * @param handler handler to invoke on map move events.

   */

  public void addMapMoveStartHandler(final MapMoveStartHandler handler) {

    maybeInitMapMoveStartHandlers();

    mapMoveStartHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapMoveStartEvent e = new MapMoveStartEvent(MapWidget.this);

        handler.onMoveStart(e);

      }

    });

  }

  /**

   * This event is fired when a map type is removed from the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapRemoveMapTypeHandler(final MapRemoveMapTypeHandler handler) {

    maybeInitMapRemoveMapTypeEvent();

    mapRemoveMapTypeHandlers.addHandler(handler, new MapTypeCallback() {

      @Override

      public void callback(MapType type) {

        MapRemoveMapTypeEvent e = new MapRemoveMapTypeEvent(MapWidget.this,

            type);

        handler.onRemoveMapType(e);

      }

    });

  }

  /**

   * This handler is fired when a single overlay is removed by the method

   * {@link MapWidget#removeOverlay(Overlay)}. The overlay that was removed is

   * passed as an argument overlay to the event handler.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapRemoveOverlayHandler(final MapRemoveOverlayHandler handler) {

    maybeInitMapRemoveOverlayHandlers();

    mapRemoveOverlayHandlers.addHandler(handler, new OverlayCallback() {

      @Override

      public void callback(Overlay overlay) {

        MapRemoveOverlayEvent e = new MapRemoveOverlayEvent(MapWidget.this,

            overlay);

        handler.onRemoveOverlay(e);

      }

    });

  }

  /**

   * Add a click handler for mouse right click events.

   *

   * This event is fired when the DOM contextmenu event is fired on the map

   * container. If the right click was on a marker, then the marker is passed to

   * the event handler in the overlay argument. The pixel coordinates (in the

   * DOM element that holds the map) of the point that was right clicked and the

   * source element of the DOM event are passed in the point and src arguments

   * respectively. Note that if it is a double right click and double click to

   * zoom is enabled, then the map zooms out and no {@link MapRightClickHandler}

   * event is fired. If, however, double click to zoom is disabled, two

   * {@link MapRightClickHandler} events will be fired.

   *

   * @param handler handler to invoke on mouse click events.

   */

  public void addMapRightClickHandler(final MapRightClickHandler handler) {

    maybeInitMapRightClickHandlers();

    mapRightClickHandlers.addHandler(handler,

        new PointElementOverlayCallback() {

          @Override

          public void callback(Point point, Element elem, Overlay overlay) {

            MapRightClickEvent e = new MapRightClickEvent(MapWidget.this,

                point, elem, overlay);

            handler.onRightClick(e);

          }

        });

  }

  /**

   * Adds a new map type to the map. See section GMapType for how to define

   * custom map types.

   *

   * @param type

   */

  public void addMapType(MapType type) {

    MapImpl.impl.addMapType(jsoPeer, type);

  }

  /**

   * This event is fired when another map type is selected.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapTypeChangedHandler(final MapTypeChangedHandler handler) {

    maybeInitMapTypeChangedHandlers();

    mapTypeChangedHandlers.addHandler(handler, new VoidCallback() {

      @Override

      public void callback() {

        MapTypeChangedEvent e = new MapTypeChangedEvent(MapWidget.this);

        handler.onTypeChanged(e);

      }

    });

  }

  /**

   *

   * @param listener

   *

   * @deprecated see

   *             {@link MapWidget#addMapTypeChangedHandler(MapTypeChangedHandler)},

   *             {@link MapWidget#addMapAddMapTypeHandler(MapAddMapTypeHandler)},

   *             {@link MapWidget#addMapRemoveMapTypeHandler(MapRemoveMapTypeHandler)}

   */

  @Deprecated

  public void addMapTypeListener(final MapTypeListener listener) {

    if (mapTypeListeners == null) {

      mapTypeListeners = new ListenerCollection<MapTypeListener>();

    }

    JavaScriptObject mapTypeEventHandles[] = {

        EventImpl.impl.addListener(jsoPeer, MapEvent.ADDMAPTYPE,

            new MapTypeCallback() {

              @Override

              public void callback(MapType mapType) {

                listener.onMapTypeAdded(MapWidget.this, mapType);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.REMOVEMAPTYPE,

            new MapTypeCallback() {

              @Override

              public void callback(MapType mapType) {

                listener.onMapTypeRemoved(MapWidget.this, mapType);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.MAPTYPECHANGED,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onMapTypeChanged(MapWidget.this);

              }

            })};

    mapTypeListeners.addListener(listener, mapTypeEventHandles);

  }

  /**

   * This event is fired when a map type is added to the map.

   *

   * @param handler the handler to call when this event fires.

   */

  public void addMapZoomEndHandler(final MapZoomEndHandler handler) {

    maybeInitMapZoomEndHandlers();

    mapZoomEndHandlers.addHandler(handler, new IntIntCallback() {

      @Override

      public void callback(int oldZoomLevel, int newZoomLevel) {

        MapZoomEndEvent e = new MapZoomEndEvent(MapWidget.this, oldZoomLevel,

            newZoomLevel);

        handler.onZoomEnd(e);

      }

    });

  }

  /**

   * Add a listener for changes in the zoom level of the map.

   *

   * @param listener a listener to call back when the zoom level of the map

   *          changes.

   *

   * @deprecated see {@link MapWidget#addMapZoomEndHandler(MapZoomEndHandler)}

   */

  @Deprecated

  public void addMapZoomListener(final MapZoomListener listener) {

    if (zoomListeners == null) {

      zoomListeners = new ListenerCollection<MapZoomListener>();

    }

    JavaScriptObject zoomEventHandles[] = {EventImpl.impl.addListener(jsoPeer,

        MapEvent.ZOOMEND, new IntIntCallback() {

          @Override

          public void callback(int oldLevel, int newLevel) {

            listener.onZoom(MapWidget.this, oldLevel, newLevel);

          }

        })};

    zoomListeners.addListener(listener, zoomEventHandles);

  }

  /**

   * Adds an overlay to the map and fires any registered

   * {@link MapAddOverlayHandler}.

   *

   * @param overlay

   */

  public void addOverlay(Overlay overlay) {

    MapImpl.impl.addOverlay(jsoPeer, overlay);

  }

  /**

   * Add a listener for overlays being added and removed from the map.

   *

   * @param listener a listener to call back.

   *

   * @deprecated see

   *             {@link MapWidget#addMapAddOverlayHandler(MapAddOverlayHandler)}

   *             and

   *             {@link MapWidget#addMapRemoveOverlayHandler(MapRemoveOverlayHandler)}

   */

  public void addOverlayListener(final OverlayListener listener) {

    if (overlayListeners == null) {

      overlayListeners = new ListenerCollection<OverlayListener>();

    }

    JavaScriptObject overlayEventHandles[] = {

        EventImpl.impl.addListener(jsoPeer, MapEvent.ADDOVERLAY,

            new OverlayCallback() {

              @Override

              public void callback(Overlay overlay) {

                listener.onOverlayAdded(MapWidget.this, overlay);

              }

            }),

        EventImpl.impl.addListener(jsoPeer, MapEvent.REMOVEOVERLAY,

            new OverlayCallback() {

              @Override

              public void callback(Overlay overlay) {

                listener.onOverlayRemoved(MapWidget.this, overlay);

              }

            }),

        EventImpl.impl.addListenerVoid(jsoPeer, MapEvent.CLEAROVERLAYS,

            new VoidCallback() {

              @Override

              public void callback() {

                listener.onOverlaysCleared(MapWidget.this);