interface GTileLayer
You implement this interface in order to provide custom map tile layers, either through GMapType or GTileLayerOverlay. Your implementation of this interface should use an instance of GTileLayer as a prototype, because this implements the copyright handling for you.
Constructor
| Constructor | Description |
|---|
| GTileLayer(copyrights, minResolution, maxResolution, options?) | Constructor arguments can be omitted if instantiated as a prototype. A Subclass constructor must invoke this constructor using call(). The optional options parameter specifies a set of GTileLayerOptions which should be passed as an object literal. |
Methods
These methods are called by the map and the map type to which this tile layer is passed. You will need to implement the methods marked abstract when you implement a custom tile layer.
| Methods | Return Value | Description |
|---|
| minResolution() | Number | Returns to the map type the lowest zoom level of this tile layer. |
| maxResolution() | Number | Returns to the map type the highest zoom level of this tile layer. |
| getTileUrl(tile, zoom) | String | Abstract. Returns to the map the URL of the map tile with the tile indices given by the x and y properties of the GPoint, at the given zoom level. |
| isPng() | Boolean | Abstract. Returns to the map whether the tiles are in PNG image format and hence can be transparent. Otherwise GIF is assumed. |
| getOpacity() | Number | Abstract. Returns to the map the opacity with which to display this tile layer. 1.0 is opaque, 0.0 is transparent. |
| getCopyright(bounds, zoom) | String | Abstract. Returns to the map the copyright messages for this tile layer that are pertinent for the given map region at the given zoom level. This is used to generate the copyright message of the GMapType to which this tile layer belongs. (Since 2.89) |
Events
| Events | Arguments | Description |
|---|
| newcopyright | copyright | This event is fired when a new copyright is added to the copyright collection of this tile layer. |
class GTileLayerOptions
This class represents optional arguments to the GTileLayer interface. It has no constructor, but is instantiated as an object literal.
Properties
| Properties | Type | Description |
|---|
| opacity | Number | Sets the tile opacity from 0.0 (invisible) to 1.0 (opaque). The default is 1.0. |
| isPng | Boolean | Indicates whether or not tiles are in the PNG format. |
| tileUrlTemplate | String | Specifies a template for the tile URLs that will be expanded for each tile request to refer to a unique tile based on an existing tile coordinate system. Placing a template in the GTileLayer constructor allows you to dynamically retrieve tiles using this coordinate system, similar to the way Google Maps retrieves tiles. Templates should be of the form:http://host/tile?x={X}&y={Y}&z={Z}.png where X and Y refer to latitudinal and longitudinal tile coordinates, and Z refers to the zoom level. E.g. http://host/tile?x=3&y=27&z=5.png. |
| draggingCursor | String | The cursor to display while dragging the map. (Since 2.59) |
class GTileLayerOverlay
A GTileLayerOverlay augments the map with a GTileLayer. It implements the GOverlay interface and thus is added to the map using the GMap2.addOverlay() method. The GTileLayer is presented on top of the existing map imagery - to replace the imagery instead, put the GTileLayer inside a custom GMapType.
Constructor
| Constructor | Description |
|---|
| GTileLayerOverlay(tileLayer) | Creates a GOverlay that wraps the tileLayer. (Since 2.61) |
Methods
| Methods | Return Value | Description |
|---|
| () | none | |
| hide() | none | Hides this overlay so it is not visible, but maintains its position in the stack of overlays. (Since 2.71) |
| isHidden() | none | Returns true if the tile layer overlay is hidden. Otherwise returns false. (Since 2.87) |
| show() | none | Shows a previously hidden TileLayerOverlay. (Since 2.71) |
| supportsHide() | none | Always returns true. (Since 2.87) |
| getTileLayer() | none | Returns the tile layer used by this overlay. (Since 2.83) |
class GCopyrightCollection
You use this class to manage copyright messages displayed on maps of custom map type. If you don't implement custom map types, then you don't need to use this class. A copyright collection contains information about which copyright to display for which region on the map at which zoom level. This is very important for map types that display heterogenous data such as the satellite map type.
Constructor
| Constructor | Description |
|---|
| GCopyrightCollection(prefix?) | Copyright messages produced from this copyright collection will have the common prefix given as the argument. Example: "Imagery (C) 2006" |
Methods
| Methods | Return Value | Description |
|---|
| () | none | |
| addCopyright(copyright) | none | Adds a copyright information object to the collection. |
| getCopyrights(bounds, zoom) | Array of String | Returns all copyright strings that are pertinent for the given map region at the given zoom level. Example: [ "Google", "Keyhole" ] |
| getCopyrightNotice(bounds, zoom) | String | Returns the prefix and all relevant copyright strings that are pertinent for the given map region at the given zoom level. Example: "Imagery (C) 2006 Google, Keyhole" |
Events
| Events | Arguments | Description |
|---|
| newcopyright | copyright | This event is fired when a new copyright was added to this copyright collection. |
class GCopyright
A copyright object contains information about which copyright message applies to a region of the map given by a rectangle, at a given zoom level. You need this object only if you implement custom map types or tile layers.
Constructor
| Constructor | Description |
|---|
| GCopyright(id, bounds, minZoom, text) | Creates a copyright information object with the given properties. |
Properties
| Properties | Type | Description |
|---|
| id | Number | A unique identifier for this copyright information. |
| minZoom | Number | The lowest zoom level at which this information applies. |
| bounds | GLatLngBounds | The region to which this information applies. |
| text | String | The text of the copyright message. |
interface GProjection
This is the interface for map projections. A map projection instance is passed to the constructor of GMapType. This interface is implemented by the class GMercatorProjection, which is used by all predefined map types. You can implement this interface if you want to define map types with different map projections.
Methods
These methods are called by the map. You need to implement them.
| Methods | Return Value | Description |
|---|
| fromLatLngToPixel(latlng, zoom) | GPoint | Returns the map coordinates in pixels for the point at the given geographical coordinates, and the given zoom level. |
| fromPixelToLatLng(pixel, zoom, unbounded?) | none | Returns the geographical coordinates for the point at the given map coordinates in pixels, and the given zoom level. Flag unbounded causes the geographical longitude coordinate not to wrap when beyond the -180 or 180 degrees meridian. |
| tileCheckRange(tile, zoom, tilesize) | none | Returns to the map if the tile index is in a valid range for the map type. Otherwise the map will display an empty tile. It also may modify the tile index to point to another instance of the same tile in the case that the map contains more than one copy of the earth, and hence the same tile at different tile coordinates. |
| getWrapWidth(zoom) | none | Returns to the map the periodicity in x-direction, i.e. the number of pixels after which the map repeats itself because it wrapped once round the earth. By default, returns Infinity, i.e. the map will not repeat itself. This is used by the map to compute the placement of overlays on map views that contain more than one copy of the earth (this usually happens only at low zoom levels). (Since 2.46) |
class GMercatorProjection
This implementation of the GProjection interface for the mercator projection is used by all predefined map types.
Constructor
| Constructor | Description |
|---|
| GMercatorProjection(zoomlevels) | Creates a mercator projection for the given number of zoom levels. |
Methods
| Methods | Return Value | Description |
|---|
| fromLatLngToPixel(latlng, zoom) | GPoint | See GProjection. |
| fromPixelToLatLng(pixel, zoom, unbounded?) | GLatLng | See GProjection. |
| tileCheckRange(tile, zoom, tilesize) | none | See GProjection. |
| getWrapWidth(zoom) | none | See GProjection. Mercator projection is periodic in longitude direction, therefore this returns the width of the map of the entire Earth in pixels at the given zoom level. (Since 2.46) |
namespace GEvent
This namespace contains functions that you use to register event handlers, both for custom events and for DOM events, and to fire custom events. All the events defined by this API are custom events that are internally fired by GEvent.trigger().
Static Methods
| Static Methods | Return Value | Description |
|---|
| addListener(source, event, handler) | GEventListener | Registers an event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler. The event handler will be called with this set to the source object. |
| addDomListener(source, event, handler) | GEventListener | Registers an event handler for a DOM event on the source object. The source object must be a DOM Node. Returns a handle that can be used to eventually deregister the handler. The event handler will be called with this set to the source object. This function uses the DOM methods for the current browser to register the event handler. |
| removeListener(handle) | none | Removes a handler that was installed using addListener() or addDomListener(). |
| clearListeners(source, event) | none | Removes all handlers on the given object for the given event that were installed using addListener() or addDomListener(). |
| clearInstanceListeners(source) | none | Removes all handlers on the given object for all events that were installed using addListener() or addDomListener(). |
| trigger(source, event, ...) | none | Fires a custom event on the source object. All remaining optional arguments after event are passed in turn as arguments to the event handler functions. |
| bind(source, event, object, method) | GEventListener | Registers an invocation of the method on the given object as the event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler. |
| bindDom(source, event, object, method) | GEventListener | Registers an invocation of the method on the given object as the event handler for a custom event on the source object. Returns a handle that can be used to eventually deregister the handler. |
| callback(object, method) | Function | Returns a closure that calls method on object. |
| callbackArgs(object, method, ...) | Function | Returns a closure that calls method on object. All remaining optional arguments after method are passed in turn as arguments method when the returned function is invoked. |
Events
| Events | Arguments | Description |
|---|
| clearlisteners | event? | This event is fired on object when clearListeners() or clearInstanceListeners() is called on that object. Of course, the event is fired before the functions are executed. |
class GEventListener
This class is opaque. It has no methods and no constructor. Its instances are returned from GEvent.addListener() or GEvent.addDomListener() and are eventually passed back to GEvent.removeListener().
namespace GXmlHttp
This namespace provides a factory method to create XmlHttpRequest instances in a browser independent way.
Static Methods
| Static Methods | Return Value | Description |
|---|
| create() | GXmlHttp | Factory to create a new instance of XmlHttpRequest. |
namespace GXml
This namespace provides static methods to handle XML documents and document fragments.
Static Methods
| Static Methods | Return Value | Description |
|---|
| parse(xmltext) | Node | Parses the given string as XML text and returns a DOM representation. If the browser doesn't support XML parsing natively, this returns the DOM node of an empty DIV element. |
| value(xmlnode) | String | Returns the text value (i.e., only the plain text content) of the XML document fragment given in DOM representation. |
class GXslt
This class provides methods to apply XSLT to XML in a browser-independent way.
Static Methods
| Static Methods | Return Value | Description |
|---|
| create(xsltnode) | GXslt | Creates a GXslt instance from the XSLT stylesheet given as DOM representation. |
| transformToHtml(xmlnode, htmlnode) | Boolean | Uses the XSLT stylesheet given in the constructor of this GXslt instance to transform the XML document given as DOM representation in xmlnode. Appends the resulting HTML document fragment to the given htmlnode. This only works if the browser natively supports XSL transformations, in which case it will return true. Otherwise, this function will do nothing and return false. |
namespace GLog
This namespace contains some static methods that help you to debug web applications. When you use one of the write*() methods for the first time, a floating window opens on the page and displays the written messages.
Static Methods
| Static Methods | Return Value | Description |
|---|
| write(message, color?) | none | Writes the message as plain text into the log window. HTML markup characters will be escaped so that they are visible as characters. |
| writeUrl(url) | none | Writes a link to the given URL into the log window. |
| writeHtml(html) | none | Writes text as HTML in the log window. |
class GDraggableObject
This class makes a DOM element draggable. The static members for changing the drag cursors affect all subsequently created draggable objects, such as the map, zoom control slider, and overview map rectangles. The per-instance members affect only their particular instance. For example, before creating the map, you can call GDraggableObject.setDraggableCursor('default') and GDraggableObject.setDraggingCursor('move') to get the pre-API 2.56 style. Alternatively, the Map constructor can take options to set its DraggableObject's cursor style. See the W3C CSS specification for allowable cursor values.
Constructor
| Constructor | Description |
|---|
| GDraggableObject(src, opts?) | Sets up event handlers so that the source element can be dragged. Left and top optionally position the element, and the optional container serves as a bounding box. (Since 2.59) |
Static Methods
| Static Methods | Return Value | Description |
|---|
| setDraggableCursor(cursor) | none | Sets the draggable cursor for subsequently created draggable objects. (Since 2.59) |
| setDraggingCursor(cursor) | none | Sets the dragging cursor for subsequently created draggable objects. (Since 2.59) |
| getDraggingCursor() | String | Returns the current dragging cursor in use by the map. If not set through the static setDraggingCursor() method, this returns the default cursor used by the map for its controls and markers. (Since 2.87) |
| getDraggableCursor() | String | Returns the current draggable cursor in use by the map. If not set through the static setDraggableCursor() method, this returns the default cursor used by the map for its controls and markers. (Since 2.87) |
Methods
| Methods | Return Value | Description |
|---|
| setDraggableCursor(cursor) | none | Sets the cursor when the mouse is over this draggable object. (Since 2.59) |
| setDraggingCursor(cursor) | none | Sets the cursor when the mouse is held down, dragging this draggable object. (Since 2.59) |
| moveTo(point) | none | Moves the GDraggableObject to a given absolute position. The position is in pixel coordinates relative to the parent node. This method uses the DOM coordinate system, i.e. the X coordinate increases to the left, and the Y coordinate increases downwards. (Since 2.89) |
| moveBy(size) | none | Moves the GDraggableObject by a given size offset. This method uses the DOM coordinate system, i.e. width increases to the left, and height increases downwards. (Since 2.89) |
Events
| Events | Arguments | Description |
|---|
| mousedown | none | This event is fired in response to the DOM mousedown event. Handling this event will prevent the default action of the DOM mousedown event. (Since 2.84) |
| mouseup | none | This event is fired in response to the DOM mouseup event on a draggable object. Handling this event will prevent the default action of the DOM mouseup event. (Since 2.84) |
| click | none | This event is fired when a draggable object is clicked. (Since 2.84) |
| dragstart | none | This event is fired at the start of a draggable object's drag event (when the user initiates a drag by clicking and dragging a draggable object). (Since 2.84) |
| drag | none | This event is repeatedly fired while the user drags the draggable object. (Since 2.84) |
| dragend | none | This event is fired at the end of a draggable object's drag event (when the user releases a drag). (Since 2.84) |
class GDraggableObjectOptions
This class represents optional arguments to the GDraggableObject constructor. It has no constructor, but is instantiated as an object literal.
Properties
| Properties | Type | Description |
|---|
| left | Number | The left starting position of the object. (Since 2.59) |
| top | Number | The top starting position of the object. (Since 2.59) |
| container | Node | A DOM element that will act as a bounding box for the draggable object (Since 2.59) |
| draggableCursor | String | The cursor to show on mousover. (Since 2.59) |
| draggingCursor | String | The cursor to show while dragging. (Since 2.59) |
| delayDrag | Boolean | By default, the event dragstart is fired when the DOM mousedown event is fired on a draggable DOM element. Similarly, the event dragend is fired when the DOM mouseup event is fired. Setting this value to true delays drag events until the mouse has moved from the location where the mousedown or mouseup was generated. The default value for this property is false. (Since 2.84) |
enum GGeoStatusCode
Numeric equivalents for each symbolic constant are specified in parentheses.
Constants
| Constants | Description |
|---|
| G_GEO_SUCCESS (200) | No errors occurred; the address was successfully parsed and its geocode has been returned. (Since 2.55) |
| G_GEO_BAD_REQUEST (400) | A directions request could not be successfully parsed. (Since 2.81) |
| G_GEO_SERVER_ERROR (500) | A geocoding or directions request could not be successfully processed, yet the exact reason for the failure is not known. (Since 2.55) |
| G_GEO_MISSING_QUERY (601) | The HTTP q parameter was either missing or had no value. For geocoding requests, this means that an empty address was specified as input. For directions requests, this means that no query was specified in the input. (Since 2.81) |
| G_GEO_MISSING_ADDRESS (601) | Synonym for G_GEO_MISSING_QUERY. (Since 2.55) |
| G_GEO_UNKNOWN_ADDRESS (602) | No corresponding geographic location could be found for the specified address. This may be due to the fact that the address is relatively new, or it may be incorrect. (Since 2.55) |
| G_GEO_UNAVAILABLE_ADDRESS (603) | The geocode for the given address or the route for the given directions query cannot be returned due to legal or contractual reasons. (Since 2.55) |
| G_GEO_UNKNOWN_DIRECTIONS (604) | The GDirections object could not compute directions between the points mentioned in the query. This is usually because there is no route available between the two points, or because we do not have data for routing in that region. (Since 2.81) |
| G_GEO_BAD_KEY (610) | The given key is either invalid or does not match the domain for which it was given. (Since 2.55) |
| G_GEO_TOO_MANY_QUERIES (620) | The given key has gone over the requests limit in the 24 hour period. (Since 2.55) |
enum GGeoAddressAccuracy
There are no symbolic constants defined for this enumeration.
Constants
| Constants | Description |
|---|
| 0 | Unknown location. (Since 2.59) |
| 1 | Country level accuracy. (Since 2.59) |
| 2 | Region (state, province, prefecture, etc.) level accuracy. (Since 2.59) |
| 3 | Sub-region (county, municipality, etc.) level accuracy. (Since 2.59) |
| 4 | Town (city, village) level accuracy. (Since 2.59) |
| 5 | Post code (zip code) level accuracy. (Since 2.59) |
| 6 | Street level accuracy. (Since 2.59) |
| 7 | Intersection level accuracy. (Since 2.59) |
| 8 | Address level accuracy. (Since 2.59) |
class GClientGeocoder
This class is used to communicate directly with Google servers to obtain geocodes for user specified addresses. In addition, a geocoder maintains its own cache of addresses, which allows repeated queries to be answered without a round trip to the server.
Constructor
| Constructor | Description |
|---|
| GClientGeocoder(cache?) | Creates a new instance of a geocoder that talks directly to Google servers. The optional cache parameter allows one to specify a custom client-side cache of known addresses. If none is specified, a GFactualGeocodeCache is used. (Since 2.55) |
Methods
| Methods | Return Value | Description |
|---|
| getLatLng(address, callback) | none | Sends a request to Google servers to geocode the specified address. If the address was successfully located, the user-specified callback function is invoked with a GLatLng point. Otherwise, the callback function is given a null point. In case of ambiguous addresses, only the point for the best match is passed to the callback function. (Since 2.55) |
| getLocations(address, callback) | none | Sends a request to Google servers to geocode the specified address. A reply that contains status code, and if successful, one or more Placemark objects, is passed to the user-specified callback function. Unlike the GClientGeocoder.getLatLng method, the callback function may determine the reasons for failure by examining the code value of the Status field. (Since 2.55) |
| getCache() | GGeocodeCache | Returns currently used geocode cache, or null, if no client-side caching is performed. (Since 2.55) |
| setCache(cache) | none | Sets a new client-side caching. If this method is invoked with cache set to null, client-side caching is disabled. Setting a new cache discards previously stored addresses. (Since 2.55) |
| setViewport(bounds) | none | Sets the geocoder to magnify geocoding results within or near the given viewport. The viewport is expressed as a GLatLngBounds rectangle. Note that setting a viewport does not restrict results to that bounding box, though it will elevate them in priority. (Since 2.82) |
| getViewport() | GLatLngBounds | Returns the viewport for magnifying geocoding results within that geocoder. The viewport is expressed as a GLatLngBounds rectangle. (Since 2.82) |
| setBaseCountryCode(countryCode) | none | Sets the geocoder to bias search results as if they were sent from the domain specified by the given ISO 3166-1 (alpha-2) country code. Geocoding is only supported for those countries in which Google Maps itself supports geocoding. Most ISO 3166-1 codes are identical to top-level Internet domain, with some notable exceptions. For example, "ES" refers to the top-level Internet domain for Spain: .es while "GB" refers to the top-level Internet domain for Great Britain: .co.uk. Note that the default domain is the domain from which you initially load the Maps API. Country codes are case insensitive. (Since 2.82) |
| getBaseCountryCode() | String | Returns the current country code in use by the given geocoder. (If no country code is in effect, this method returns null.) (Since 2.82) |
| reset() | none | Resets the geocoder. In particular this method calls the GGeocodeCache.reset() method on the client-side cache, if one is used by this geocoder. (Since 2.55) |
class GGeocodeCache
This class maintains a map from addresses to known locations. While this class is fully functional, it is intended as a base class from which more sophisticated caches are derived.
Constructor
| Constructor | Description |
|---|
| GGeocodeCache() | Creates a new cache for storing a map from addresses to locations. The constructor immediately calls the GGeocodeCache.reset method. (Since 2.55) |
Methods
| Methods | Return Value | Description |
|---|
| get(address) | Object | Returns the reply which was stored under the given address. If no reply was ever stored for the given address, this method returns null. (Since 2.55) |
| isCachable(reply) | Boolean | Returns whether or not the given reply should be cached. By default very rudimentary checks are performed on the reply object. In particular, this class makes sure that the object is not null and that it has the name field . This method may be overridden by extending classes to provide more precise conditions on the reply object. (Since 2.55) |
| put(address, reply) | none | Stores the given reply under the given address. This method calls the GGeocodeCache.isCachable method to verify that the reply may be cached. If it gets a go-ahead, it caches the reply under the address normalized with the help of the GGeocodeCache.toCanoninical method. (Since 2.55) |
| reset() | none | Purges all replies from the cache. After this method returns, the cache is empty. (Since 2.55) |
| toCanonical(address) | String | Returns what is considered a canonical version of the address. It converts the address parameter to lower case, replaces comas with spaces and replaces multiple spaces with one space. (Since 2.55) |
class GFactualGeocodeCache
This class refines the basic GGeocodeCache class by placing stricter conditions on cached replies. It only caches replies which are very unlikely to change within a short period of time.
Constructor
| Constructor | Description |
|---|
| GFactualGeocodeCache() | Creates a new cache that stores only replies it considers factual. (Since 2.55) |
Methods
| Methods | Return Value | Description |
|---|
| isCachable(reply) | Boolean | Overrides the default implementation of this method to perform a more thorough check of the status code. Only a reply with Status.code set to G_GEO_SUCCESS, or known to be invalid, is considered cachable. Replies that timed out or resulted in a generic server error are not cached. (Since 2.55) |
class GMarkerManager
This class is used to manage visibility of hundreds of markers on a map, based on the map's current viewport and zoom level.
Constructor
| Constructor | Description |
|---|
| GMarkerManager(map, opts?) | Creates a new marker manager that controlls visibility of markers for the specified map. (Since 2.67) |
Methods
| Methods | Return Value | Description |
|---|
| addMarkers(markers, minZoom, maxZoom?) | none | Adds a batch of markers to this marker manager. The markers are not added to the map, until the refresh() method is called. Once placed on a map, the markers are shown if they fall within the map's current viewport and the map's zoom level is greater than or equal to the specified minZoom. If the maxZoom was given, the markers are automatically removed if the map's zoom is greater than the one specified. (Since 2.67) |
| addMarker(marker, minZoom, maxZoom?) | none | Adds a single marker to a collection of markers controlled by this manager. If the marker's location falls within the map's current viewport and the map's zoom level is within the specified zoom level rage, the marker is immediately added to the map. Similar to the addMarkers method, the minZoom and the optional maxZoom parameters specify the range of zoom levels at which the marker is shown. (Since 2.67) |
| refresh() | none | Forces the manager to update markers shown on the map. This method must be called if markers were added using the addMarkers method. (Since 2.67) |
| getMarkerCount(zoom) | Number | Returns the total number of markers potentially visible at the given zoom level. This may include markers at lower zoom levels. (Since 2.67) |
Events
| Events | Arguments | Description |
|---|
| changed | bounds, markerCount | This event is fired when markers managed by a manager have been added to or removed from the map. The event handler function should be prepared to accept two arguments. The fist one is the rectangle definining the bounds of the visible grid. The second one carries the number of markers currently shown on the map. |
class GMarkerManagerOptions
This class represents optional arguments to the
5499
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
