From 84e6d1bec3756dc0bb5e54690e48d4826694556e Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Thu, 31 Oct 2013 11:59:04 +0400 Subject: [PATCH 1/7] Add OpenLayers map viewing library definitions --- openlayers/openlayers.d.ts | 1713 ++++++++++++++++++++++++++++++++++++ 1 file changed, 1713 insertions(+) create mode 100644 openlayers/openlayers.d.ts diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts new file mode 100644 index 0000000000..7d4d3858a0 --- /dev/null +++ b/openlayers/openlayers.d.ts @@ -0,0 +1,1713 @@ +// Type definitions for OpenLayers.js 2.10 +// Project: https://github.com/openlayers/openlayers +// Definitions by: Ilya Bolkhovsky +// Definitions: https://github.com/borisyankov/DefinitelyTyped + +declare module OpenLayers { + + export interface MapOptions { + + projection?: string; + + maxExtend?: Bounds; + + center?: LonLat; + } + + export interface DistanceOptions { + /** + * Return details from the distance calculation. Default is false. + */ + details?: boolean; + + /** + * Calculate the distance from this geometry to the nearest edge of the target geometry. Default is true. If true, calling distanceTo from a geometry that is wholly contained within the target will result in a non-zero distance. If false, whenever geometries intersect, calling distanceTo will return 0. If false, details cannot be returned. + */ + edge?: boolean; + } + + export interface BoundsOptions { + /** + * Whether or not to include the border. Default is true. + */ + inclusive?: boolean; + + /** + * If a worldBounds is provided, the + * ll will be considered as contained if it exceeds the world bounds, + * but can be wrapped around the dateline so it is contained by this + * bounds. + */ + worldBounds?: Bounds; + } + + export interface WrapDateLineOptions { + /** + * Allow for a margin of error + * with the 'left' value of this + * bound. + * Default is 0. + */ + leftTolerance?: number; + + /** + * Allow for a margin of error + * with the 'right' value of this + * bound. + * Default is 0. + */ + rightTolerance?: number; + } + + export class Animation { + // TODO + } + + export class String { + // TODO + } + + export class Number { + // TODO + } + + export class Function { + // TODO + } + + export class Array { + // TODO + } + + export class Console { + // TODO + } + + export class Control { + // TODO + } + + export class Event { + // TODO + } + + export class Events { + // TODO + } + + export class Feature { + // TODO + } + + export class Filter { + // TODO + } + + export class Format { + // TODO + } + + export class Handler { + // TODO + } + + export class Icon { + // TODO + } + + export class Kinetic { + // TODO + } + + export class Lang { + // TODO + } + + export class Layer { + // TODO + } + + export class Marker { + // TODO + } + + export class Popup { + // TODO + } + + export class Protocol { + // TODO + } + + export class Renderer { + // TODO + } + + export class Request { + // TODO + } + + export class Rule { + // TODO + } + + export class SingleFile { + // TODO + } + + export class Spherical { + // TODO + } + + export class Strategy { + // TODO + } + + export class Style { + // TODO + } + + export class Style2 { + // TODO + } + + export class StyleMap { + // TODO + } + + export class Symbolizer { + // TODO + } + + export class Tile { + // TODO + } + + export class TileManager { + // TODO + } + + export class Tween { + // TODO + } + + export class Util { + // TODO + } + + export class WPSClient { + // TODO + } + + export class WPSProcess { + // TODO + } + + export class Geometry { + /** + * A unique identifier for this geometry. + */ + id: string; + + /** + * This is set when a Geometry is added as component + * of another geometry + */ + parent: Geometry; + + /** + * The bounds of this geometry + */ + bounds: Bounds; + + /** + * A Geometry is a description of a geographic object. + */ + constructor(); + + /** + * Destroy this geometry. + */ + destroy(): void; + + /** + * Create a clone of this geometry. Does not set any non-standard properties of the cloned geometry. + */ + clone(): Geometry; + + /** + * Set the bounds for this Geometry. + */ + setBounds(bounds: Bounds): void; + + /** + * Nullify this components bounds and that of its parent as well. + */ + clearBounds(): void; + + /** + * Extend the existing bounds to include the new bounds. + * If geometry's bounds is not yet set, then set a new Bounds. + */ + extendBounds(newBounds: Bounds): void; + + /** + * Get the bounds for this Geometry. If bounds is not set, it is calculated again, this makes queries faster. + */ + getBounds(): Bounds; + + /** + * Calculate the closest distance between two geometries (on the x-y plane). + */ + distanceTo(geometry: Geometry, options: Object): Object; + + /** + * Return a list of all points in this geometry. + */ + getVertices(nodes: boolean): Array; + + /** + * Return whether or not the geometry is at the specified location + */ + atPoint(lonlat: LonLat, toleranceLon?: number, toleranceLat?: number): boolean; + + /** + * Returns the length of the collection by summing its parts + */ + getLength(): number; + + /** + * Returns the area of the collection by summing its parts + */ + getArea(): number; + + /** + * Returns a text representation of the geometry. If the WKT format is + * included in a build, this will be the Well-Known Text + * representation. + */ + toString(): string; + + /** + * Calculate the centroid of this geometry. This method is defined in subclasses. + */ + getCentroid(): Geometry.Point; + + static CLASS_NAME: string; + } + + export class Projection { + /** + * This class offers several methods for interacting with a wrapped pro4js projection object. + */ + constructor(projCode: string, options?: any); + + /** + * Get the string SRS code. + */ + getCode(): string; + + /** + * Get the units string for the projection -- returns null if proj4js is not available. + */ + getUnits(): string; + + /** + * Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. + */ + addTransform(from: string, to: string, method: () => void); + + /** + * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. + */ + transform(point: Geometry.Point, source: Projection, dest: OpenLayers.Projection): Object; + + /** + * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. + */ + transform(point: Object, source: Projection, dest: OpenLayers.Projection): Object; + + /** + * A null transformation useful for defining projection aliases when proj4js is not available: + */ + nullTransform(point: Object): Function; + } + + export class Bounds { + /** + * Minimum horizontal coordinate. + */ + left: number; + + /** + * Minimum vertical coordinate. + */ + bottom: number; + + /** + * Maximum horizontal coordinate. + */ + right: number; + + /** + * Maximum vertical coordinate. + */ + top: number; + + /** + * Construct a new bounds object. Coordinates can either be passed as four + * arguments, or as a single argument. + */ + constructor(left: number, bottom: number, right: number, top: number); + + /** + * Construct a new bounds object. Coordinates can either be passed as four + * arguments, or as a single argument. + */ + constructor(bounds: number[]); + + /** + * Create a cloned instance of this bounds. + */ + clone(): Bounds; + + /** + * Test a two bounds for equivalence. + */ + equals(bounds: Bounds): boolean; + + /** + * Returns a string representation of the bounds object. + */ + toString(): string; + + /** + * Returns an array representation of the bounds object. + */ + toArray(reverseAxisOrder?: boolean): number[]; + + /** + * Returns a boundingbox-string representation of the bounds object. + */ + toBBOX(decimal?: number, reverseAxisOrder?: boolean): string; + + /** + * Create a new polygon geometry based on this bounds. + */ + toGeometry(): OpenLayers.Geometry.Polygon; + + /** + * Returns the width of the bounds. + */ + getWidth(): number; + + /** + * Returns the height of the bounds. + */ + getHeight(): number; + + /** + * + */ + getSize(): Size; + + /** + * Returns the Pixel object which represents the center of the bounds. + */ + getCenterPixel(): Pixel; + + /** + * Returns the LonLat object which represents the center of the bounds. + */ + getCenterLonLat(): LonLat; + + /** + * Scales the bounds around a pixel or lonlat. Note that the new + * bounds may return non-integer properties, even if a pixel + * is passed. + */ + scale(ratio: number, origin?: Pixel); + + /** + * Scales the bounds around a pixel or lonlat. Note that the new + * bounds may return non-integer properties, even if a pixel + * is passed. + */ + scale(ratio: number, origin?: LonLat); + + /** + * Shifts the coordinates of the bound by the given horizontal and vertical + * deltas. + */ + add(x: number, y: number): Bounds; + + /** + * Extend the bounds. + */ + extend(object: LonLat): void; + + /** + * Extend the bounds. + */ + extend(object: Geometry.Point): void; + + /** + * Extend the bounds. + */ + extend(object: Bounds): void; + + /** + * + */ + extendXY(x: number, y: number): void; + + /** + * Returns whether the bounds object contains the given . + */ + containsLonLat(ll: LonLat, options: BoundsOptions); + + /** + * Returns whether the bounds object contains the given . + */ + containsLonLat(ll: Object, options: BoundsOptions); + + /** + * Returns whether the bounds object contains the given . + */ + containsPixel(px: Pixel, inclusive: boolean): boolean; + + /** + * Returns whether the bounds object contains the given x and y. + */ + contains(x: number, y: number, inclusive?: boolean): boolean; + + /** + * Determine whether the target bounds intersects this bounds. Bounds are + * considered intersecting if any of their edges intersect or if one + * bounds contains the other. + */ + intersectsBounds(bounds: Bounds, options: BoundsOptions): boolean; + + /** + * Returns whether the bounds object contains the given . + */ + containsBounds(bounds: Bounds, partial: boolean, inclusive: boolean): boolean; + + /** + * Returns the the quadrant ("br", "tr", "tl", "bl") in which the given + * lies. + */ + determineQuadrant(lonlat: LonLat): string; + + /** + * Transform the Bounds object from source to dest. + */ + transform(source: Projection, dest: Projection): Bounds; + + /** + * Wraps the bounds object around the dateline. + */ + wrapDateLine(maxExtent: Bounds, options: WrapDateLineOptions): Bounds; + + static CLASS_NAME: string; + + /** + * Alternative constructor that builds a new OpenLayers.Bounds from a + * parameter string. + */ + static fromString(str: string, reverseAxisOrder: boolean): Bounds; + + /** + * Alternative constructor that builds a new OpenLayers.Bounds from an array. + */ + static fromArray(bbox: number[], reverseAxisOrder: boolean): Bounds; + + /** + * Alternative constructor that builds a new OpenLayers.Bounds from a size. + */ + static fromSize(size: Size): Bounds; + + /** + * Get the opposite quadrant for a given quadrant string. + */ + static oppositeQuadrant(quadrant: string): string; + } + + export class LonLat { + /** + * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. + */ + constructor(lon: number, lat: number); + + /** + * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. + */ + constructor(lonlat: number[]); + + /** + * Shortened String representation of OpenLayers.LonLat object. + */ + toShortString(): string; + + /** + * New OpenLayers.LonLat object with the same lon and lat values + */ + clone(): LonLat; + + /** + * A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. + */ + add(lon: number, lat: number): LonLat; + + /** + * Boolean value indicating whether the passed-in OpenLayers.LonLat object has the same lon and lat components as this. Note: if ll passed in is null, returns false. + */ + equals(ll: LonLat): boolean; + + /** + * Transform the LonLat object from source to dest. This transformation is in place: if you want a new lonlat, use .clone() first. + */ + transform(source: Projection, dest: Projection): LonLat; + + /** + * Returns a copy of this lonlat, but wrapped around the "dateline" (as specified by the borders of maxExtent). + */ + wrapDateLine(maxExtend: Bounds): LonLat; + } + + export class Map { + /** + * Unique identifier for the map + */ + id: string; + + /** + * For a base layer that supports it, allow the map resolution + * to be set to a value between one of the values in the resolutions + * array. Default is false. + */ + fractionalZoom: boolean; + + /** + * An events object that handles all + * events on the map + */ + events: Events; + + /** + * Allow the map to function with "overlays" only. Defaults to + * false. If true, the lowest layer in the draw order will act as + * the base layer. In addition, if set to true, all layers will + * have isBaseLayer set to false when they are added to the map. + */ + allOverlays: boolean; + + /** + * The element that contains the map (or an id for that element). + */ + div: Object; + + /** + * The map is currently being dragged. + */ + dragging: boolean; + + /** + * Size of the main div (this.div) + */ + size: Size; + + /** + * The element that represents the map viewport + */ + viewPortDiv: HTMLDivElement; + + /** + * The lonlat at which the later container was re-initialized (on-zoom) + */ + layerContainerOrigin: LonLat; + + /** + * The element that contains the layers. + */ + layerContainerDiv: HTMLDivElement; + + /** + * Ordered list of layers in the map + */ + layers: Layer[]; + + /** + * List of controls associated with the map. + */ + controls: Control[]; + + /** + * List of popups associated with the map + */ + popups: Popup[]; + + /** + * The currently selected base layer. This determines + * min/max zoom level, projection, etc. + */ + baseLayer: Layer; + + /** + * The current center of the map + */ + center: LonLat; + + /** + * The resolution of the map. + */ + resolution: number; + + /** + * The current zoom level of the map + */ + zoom: number; + + /** + * The ratio of the current extent within which panning will tween. + */ + panRatio: number; + + /** + * The options object passed to the class constructor. Read-only. + */ + options: Object; + + /** + * Set in the map options to override the default tile size for this map. + */ + tileSize: Size; + + /** + * Set in the map options to specify the default projection + * for layers added to this map. When using a projection other than EPSG:4326 + * (CRS:84, Geographic) or EPSG:3857 (EPSG:900913, Web Mercator), + * also set maxExtent, maxResolution or resolutions. Default is "EPSG:4326". + * Note that the projection of the map is usually determined + * by that of the current baseLayer (see and ). + */ + projection: string; + + /** + * The map units. Possible values are 'degrees' (or 'dd'), 'm', + * 'ft', 'km', 'mi', 'inches'. Normally taken from the projection. + * Only required if both map and layers do not define a projection, + * or if they define a projection which does not define units + */ + units: string; + + /** + * A list of map resolutions (map units per pixel) in + * descending order. If this is not set in the layer constructor, it + * will be set based on other resolution related properties + * (maxExtent, maxResolution, maxScale, etc.). + */ + resolutions: number[]; + + /** + * Required if you are not displaying the whole world on a tile + * with the size specified in . + */ + maxResolution: number; + + + + + constructor(id: HTMLElement, options?: MapOptions); + + constructor(id: string, options?: MapOptions); + + /** + * + */ + addLayer(layer: Layer): boolean; + + /** + * Set the map center (and optionally, the zoom level). + */ + setCenter(lonlat: LonLat, zoom?: number, dragging?: boolean, forceZoomChange?: boolean): void; + + /** + * Set the map center (and optionally, the zoom level). + */ + setCenter(lonlat: number[], zoom?: number, dragging?: boolean, forceZoomChange?: boolean): void; + + /** + * + */ + prop: string; + } + + export class Class { + + } + + export class Date { + + } + + export class Element { + + } + + export class Pixel { + + } + + export class Size { + + } + + module Geometry { + + export class Collection extends Geometry { + /** + * The component parts of this geometry + */ + components: Geometry[]; + + /** + * An array of class names representing the types of + * components that the collection can include. A null value means the + * component types are not restricted. + */ + componentTypes: string[]; + + /** + * Creates a Geometry Collection -- a list of geoms. + */ + constructor(components: Geometry[]); + + /** + * Destroy this geometry. + */ + destroy(): void; + + /** + * Clone this geometry. + */ + clone(): Collection; + + /** + * Get a string representing the components for this collection + */ + getComponentsString(): string; + + /** + * Recalculate the bounds by iterating through the components and + * calling calling extendBounds() on each item. + */ + calculateBounds(); + + /** + * Add components to this geometry. + */ + addComponents(components: Geometry[]); + + /** + * Add a new component (geometry) to the collection. If this.componentTypes + * is set, then the component class name must be in the componentTypes array. + */ + addComponent(component: Geometry, index: number): boolean; + + /** + * Remove components from this geometry. + */ + removeComponents(components: Geometry[]): boolean; + + /** + * Remove a component from this geometry. + */ + removeComponent(component: Geometry): boolean; + + /** + * Calculate the length of this geometry + */ + getLength(): number; + + /** + * Calculate the area of this geometry. Note how this function is overridden + * in . + */ + getArea(): number; + + /** + * Calculate the approximate area of the polygon were it projected onto + * the earth. + */ + getGeodesicArea(projection: Projection): number; + + /** + * Compute the centroid for this geometry collection. + */ + getCentroid(weighted?: boolean): Point; + + /** + * Calculate the approximate length of the geometry were it projected onto + * the earth. + */ + getGeodesicLength(projection: Projection): number; + + /** + * Moves a geometry by the given displacement along positive x and y axes. + * This modifies the position of the geometry and clears the cached + * bounds. + */ + move(x: number, y: number): void; + + /** + * Rotate a geometry around some origin + */ + rotate(angle: number, origin: Point); + + /** + * Resize a geometry relative to some origin. Use this method to apply + * a uniform scaling to a geometry. + */ + resize(scale: number, origin: Point, ratio: number): Geometry; + + /** + * Calculate the closest distance between two geometries (on the x-y plane). + */ + distanceTo(geometry: Geometry, options: DistanceOptions): Object; + + /** + * Determine whether another geometry is equivalent to this one. Geometries + * are considered equivalent if all components have the same coordinates. + */ + equals(geometry: Geometry): boolean; + + /** + * Reproject the components geometry from source to dest. + */ + transform(source: Projection, dest: Projection): Geometry; + + /** + * Determine if the input geometry intersects this one. + */ + intersects(geometry: Geometry): boolean; + + /** + * Return a list of all points in this geometry. + */ + getVertices(nodes: boolean): Array; + + static CLASS_NAME: string; + } + + export class Point extends Geometry { + + x: number; + + y: number; + + /** + * Construct a point geometry. + */ + constructor(x: number, y: number); + + /** + * Create a clone of this geometry. + */ + clone(): Geometry; + + /** + * An exact clone of this OpenLayers.Geometry.Point + */ + clone(obj: Point): Point; + + /** + * Calculate the closest distance between two geometries (on the x-y plane). + */ + distanceTo(geometry: Geometry, options: DistanceOptions): Object; + + /** + * Determine whether another geometry is equivalent to this one. Geometries are considered equivalent if all components have the same coordinates. + */ + equals(geom: Point): boolean; + + /** + * Moves a geometry by the given displacement along positive x and y axes. This modifies the position of the geometry and clears the cached bounds. + */ + move(x: number, y: number): void; + + /** + * Rotate a point around another. + */ + rotate(angle: number, origin: Point); + + /** + * Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses. + */ + resize(scale: number, origin: Point, ratio: number): Geometry; + + /** + * Determine if the input geometry intersects this one. + */ + intersects(geometry: Geometry): boolean; + + /** + * Translate the x,y properties of the point from source to dest. + */ + transform(source: Projection, dest: Projection): Geometry; + + /** + * Return a list of all points in this geometry. + */ + getVertices(nodes: boolean): Array; + } + + export class Curve extends Geometry.MultiPoint { + + } + + export class LineString extends Geometry.Curve { + + } + + export class LinearRing extends Geometry.LineString { + + } + + export class MultiLineString extends Geometry.Collection { + + } + + export class MultiPoint extends Geometry.Collection { + + } + + export class MultiPolygon extends Geometry.Collection { + + } + + export class Polygon extends Geometry.Collection { + + } + } + + module Control { + export class ArgParser { + + } + + export class Attribution { + + } + + export class Button { + + } + + export class CacheRead { + + } + + export class CacheWrite { + + } + + export class DragFeature { + + } + + export class DragPan { + + } + + export class DrawFeature { + + } + + export class EditingToolbar { + + } + + export class Geolocate { + + } + + export class GetFeature { + + } + + export class Graticule { + + } + + export class KeyboardDefaults { + + } + + export class LayerSwitcher { + + } + + export class Measure { + + } + + export class ModifyFeature { + + } + + export class MousePosition { + + } + + export class NavToolbar { + + } + + export class Navigation { + + } + + export class NavigationHistory { + + } + + export class OverviewMap { + + } + + export class Pan { + + } + + export class PanPanel { + + } + + export class PanZoom { + + } + + export class PanZoomBar { + + } + + export class Panel { + + } + + export class Permalink { + + } + + export class PinchZoom { + + } + + export class SLDSelect { + + } + + export class Scale { + + } + + export class ScaleLine { + + } + + export class SelectFeature { + + } + + export class Snapping { + + } + + export class Split { + + } + + export class TextButtonPanel { + + } + + export class TouchNavigation { + + } + + export class TransformFeature { + + } + + export class UTFGrid { + + } + + export class WMSGetFeatureInfo { + + } + + export class WMTSGetFeatureInfo { + + } + + export class Zoom { + + } + + export class ZoomBox { + + } + + export class ZoomIn { + + } + + export class ZoomOut { + + } + + export class ZoomPanel { + + } + + export class ZoomToMaxExtent { + + } + } + + module Events { + export class buttonclick extends OpenLayers.Class { + + } + + export class featureclick extends OpenLayers.Class { + + } + } + + module Feature { + export class Vector { + + } + } + + module Filter { + export class Comparison { + + } + + export class FeatureId { + + } + + export class Function { + + } + + export class Logical { + + } + + export class Spatial { + + } + } + + module Format { + export class ArcXML { + constructor(); + } + + export class Atom { + + } + + export class CQL { + + } + + export class CSWGetDomain { + + } + + export class CSWGetRecords { + + } + + export class Context { } + export class EncodedPolyline { } + export class Filter { } + export class GML { } + export class GPX { } + export class GeoJSON { } + export class GeoRSS { } + export class JSON { } + export class KML { } + export class OGCExceptionReport { } + export class OSM { } + export class OWSCommon { } + export class OWSContext { } + export class QueryStringFilter { } + export class SLD { } + export class SOSCapabilities { } + export class SOSGetFeatureOfInterest { } + export class SOSGetObservation { } + export class TMSCapabilities { } + export class Text { } + export class WCSCapabilities { } + export class WCSDescribeCoverage { } + export class WCSGetCoverage { } + export class WFS { } + export class WFSCapabilities { } + export class WFSDescribeFeatureType { } + export class WFST { } + export class WKT { } + export class WMC { } + export class WMSCapabilities { } + export class WMSDescribeLayer { } + export class WMSGetFeatureInfo { } + export class WMTSCapabilities { } + export class WPSCapabilities { } + export class WPSDescribeProcess { } + export class WPSExecute { } + export class XLS { } + export class XML { } + + module ArcXML { + export class Features extends OpenLayers.Class { + + } + } + + module CSWGetDomain { + export class v2_0_2 { } + } + + module CSWGetRecords { + export class v2_0_2 { } + } + + module Filter { + + } + + module GML { + + } + + module OWSCommon { + + } + + module OWSContext { + + } + + module SLD { + + } + + module SOSCapabilities { + + } + + module WCSCapabilities { + + } + + module WCSDescribeCoverage { + + } + + module WFSCapabilities { + + } + + module WFST { + + } + + module WMC { + + } + + module WMSCapabilities { + + + } + + module WMSDescribeLayer { + + } + + module WMTSCapabilities { + + } + + module WPSCapabilities { + + } + + module XLS { + + } + + module XML { + + } + } + + module Handler { + export class Box { + + } + + export class Click { + + } + + export class Drag { + + } + + export class Feature { + + } + + export class Hover { + + } + + export class Keyboard { + + } + + export class MouseWheel { + + } + + export class Path { + + } + + export class Pinch { + + } + + export class Point { + + } + + export class Polygon { + + } + + export class RegularPolygon { + + } + } + + module Lang { + + } + + module Layer { + export interface WMSGetMapParams { + version?: string; + exceptions?: string; + transparent?: string; + format?: string; + styles?: string; + layers: string; + service?: string; + } + + export interface WMSOptions { + opacity?: number; + singleTile?: boolean; + isBaseLayer?: boolean; + encodeBBOX?: boolean; + noMagic?: boolean; + yx?: Object; + } + + export interface TileOptions { + crossOriginKeyword?: string; + } + + export class ArcGIS93Rest { } + export class ArcGISCache { } + export class ArcIMS { } + export class Bing { } + export class Boxes { } + export class EventPane { } + export class FixedZoomLevels { } + export class GeoRSS { } + export class Google { } + export class Grid { } + export class HTTPRequest { } + export class Image { } + export class KaMap { } + export class KaMapCache { } + export class MapGuide { } + export class MapServer { } + export class Markers { } + + export class OSM extends Layer.XYZ { + /** + * The layer name. Defaults to "OpenStreetMap" if the first + * argument to the constructor is null or undefined. + */ + name: string; + + /** + * The tileset URL scheme. Defaults to + * : http://[a|b|c].tile.openstreetmap.org/${z}/${x}/${y}.png + * (the official OSM tileset) if the second argument to the constructor + * is null or undefined. To use another tileset you can have something + * like this: + * new OpenLayers.Layer.OSM("OpenCycleMap", + * ["http://a.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", + * "http://b.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png", + * "http://c.tile.opencyclemap.org/cycle/${z}/${x}/${y}.png"]); + */ + url: string[]; + + /** + * The layer attribution. + */ + attribution: string; + + sphericalMercator: boolean; + + wrapDateLine: boolean; + + /** + * optional configuration options for instances + * created by this Layer. + */ + tileOptions: TileOptions; + + constructor(); + + constructor(name: string, url: string, options: TileOptions); + + /** + * Create a clone of this layer + */ + clone(): Layer.WMS; + + static CLASS_NAME: string; + } + + export class PointGrid { } + export class PointTrack { } + export class SphericalMercator { } + export class TMS { } + export class Text { } + export class TileCache { } + export class UTFGrid { } + export class Vector { } + + export class WMS { + /** + * Default is true for WMS layer + */ + isBaseLayer: boolean; + + /** + * Should the BBOX commas be encoded? The WMS spec says 'no', + * but some services want it that way. Default false. + */ + encodeBBOX: boolean; + + /** + * If true, the image format will not be automagicaly switched + * from image/jpeg to image/png or image/gif when using + * TRANSPARENT=TRUE. Also isBaseLayer will not changed by the + * constructor. Default false. + */ + noMagic: boolean; + + /** + * Keys in this object are EPSG codes for which the axis order + * is to be reversed (yx instead of xy, LatLon instead of LonLat), with + * true as value. This is only relevant for WMS versions >= 1.3.0, and + * only if yx is not set in for the + * used projection. + */ + yx: Object; + + /** + * Constructor: OpenLayers.Layer.WMS + * Create a new WMS layer object + * + * Examples: + * + * The code below creates a simple WMS layer using the image/jpeg format. + * (code) + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", + * "http://wms.jpl.nasa.gov/wms.cgi", + * {layers: "modis,global_mosaic"}); + * (end) + * Note the 3rd argument (params). Properties added to this object will be + * added to the WMS GetMap requests used for this layer's tiles. The only + * mandatory parameter is "layers". Other common WMS params include + * "transparent", "styles" and "format". Note that the "srs" param will + * always be ignored. Instead, it will be derived from the baseLayer's or + * map's projection. + * + * The code below creates a transparent WMS layer with additional options. + * (code) + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", + * "http://wms.jpl.nasa.gov/wms.cgi", + * { + * layers: "modis,global_mosaic", + * transparent: true + * }, { + * opacity: 0.5, + * singleTile: true + * }); + * (end) + * Note that by default, a WMS layer is configured as baseLayer. Setting + * the "transparent" param to true will apply some magic (see ). + * The default image format changes from image/jpeg to image/png, and the + * layer is not configured as baseLayer. + * + * Parameters: + * name - {String} A name for the layer + * url - {String} Base url for the WMS + * (e.g. http://wms.jpl.nasa.gov/wms.cgi) + * params - {Object} An object with key/value pairs representing the + * GetMap query string parameters and parameter values. + * options - {Object} Hashtable of extra options to tag onto the layer. + * These options include all properties listed above, plus the ones + * inherited from superclasses. + */ + constructor(name: string, url: string, params: WMSGetMapParams, options: WMSOptions); + + /** + * Create a clone of this layer + */ + clone(): Layer.WMS; + + /** + * Returns true if the axis order is reversed for the WMS version and + * projection of the layer. + */ + reverseAxisOrder(): boolean; + + /** + * Return a GetMap query string for this layer + */ + getURL(bounds: Bounds): string; + + /** + * Catch changeParams and uppercase the new params to be merged in + * before calling changeParams on the super class. + * Once params have been changed, the tiles will be reloaded with + * the new parameters. + */ + mergeNewParams(newParams): void; + + /** + * Combine the layer's url with its params and these newParams. + * + * Add the SRS parameter from projection -- this is probably + * more eloquently done via a setProjection() method, but this + * works for now and always. + */ + getFullRequestString(newParams: Object, altUrl: string): string; + + static CLASS_NAME: string; + } + + export class WMTS { } + export class WorldWind { } + export class XYZ { } + export class Zoomify { } + + module Google { + export class v3 { } + } + + module Vector { + export class RootContainer { } + } + } + + module Marker { + export class Box { } + } + + module Popup { + export class Anchored { } + export class Framed { } + export class FramedCloud { } + } + + module Protocol { + export class CSW { } + export class HTTP { } + export class SOS { } + export class Script { } + export class WFS { } + + module CSW { + export class v2_0_2 { } + } + + module SOS { + export class v1_0_0 { } + } + + module WFS { + export class v2_0_0 { } + } + } + + module Renderer { + export class Canvas { } + export class Elements { } + export class SVG { } + export class VML { } + } + + module Request { + export class XMLHttpRequest { } + } + + module Strategy { + export class BBOX { } + export class Cluster { } + export class Filter { } + export class Fixed { } + export class Paging { } + export class Refresh { } + export class Save { } + } + + module Symbolizer { + export class Line { } + export class Point { } + export class Polygon { } + export class Raster { } + export class Text { } + } + + module Tile { + export class Image { } + export class UTFGrid { } + + module Image { + export class IFrame { } + } + } + + module Util { + export class vendorPrefix { } + } +} + From 842cb25dd1a8afdf08a2f0cd722fad71c62b30b5 Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Thu, 31 Oct 2013 12:11:05 +0400 Subject: [PATCH 2/7] fix OpenLayers definitions --- openlayers/openlayers.d.ts | 469 +++++++++++++++++++++++++++++++++++++ 1 file changed, 469 insertions(+) diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts index 7d4d3858a0..1a4e70d658 100644 --- a/openlayers/openlayers.d.ts +++ b/openlayers/openlayers.d.ts @@ -16,34 +16,57 @@ declare module OpenLayers { export interface DistanceOptions { /** +<<<<<<< HEAD * Return details from the distance calculation. Default is false. +======= + *Return details from the distance calculation. Default is false. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ details?: boolean; /** +<<<<<<< HEAD * Calculate the distance from this geometry to the nearest edge of the target geometry. Default is true. If true, calling distanceTo from a geometry that is wholly contained within the target will result in a non-zero distance. If false, whenever geometries intersect, calling distanceTo will return 0. If false, details cannot be returned. +======= + *Calculate the distance from this geometry to the nearest edge of the target geometry. Default is true. If true, calling distanceTo from a geometry that is wholly contained within the target will result in a non-zero distance. If false, whenever geometries intersect, calling distanceTo will return 0. If false, details cannot be returned. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ edge?: boolean; } export interface BoundsOptions { /** +<<<<<<< HEAD * Whether or not to include the border. Default is true. +======= + *Whether or not to include the border. Default is true. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ inclusive?: boolean; /** +<<<<<<< HEAD * If a worldBounds is provided, the * ll will be considered as contained if it exceeds the world bounds, * but can be wrapped around the dateline so it is contained by this * bounds. +======= + *If a worldBounds is provided, the + *ll will be considered as contained if it exceeds the world bounds, + *but can be wrapped around the dateline so it is contained by this + *bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ worldBounds?: Bounds; } export interface WrapDateLineOptions { /** +<<<<<<< HEAD * Allow for a margin of error +======= + *Allow for a margin of error +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * with the 'left' value of this * bound. * Default is 0. @@ -51,7 +74,11 @@ declare module OpenLayers { leftTolerance?: number; /** +<<<<<<< HEAD * Allow for a margin of error +======= + *Allow for a margin of error +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * with the 'right' value of this * bound. * Default is 0. @@ -205,91 +232,161 @@ declare module OpenLayers { export class Geometry { /** +<<<<<<< HEAD * A unique identifier for this geometry. +======= + *A unique identifier for this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ id: string; /** +<<<<<<< HEAD * This is set when a Geometry is added as component * of another geometry +======= + *This is set when a Geometry is added as component + *of another geometry +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ parent: Geometry; /** +<<<<<<< HEAD * The bounds of this geometry +======= + *The bounds of this geometry +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ bounds: Bounds; /** +<<<<<<< HEAD * A Geometry is a description of a geographic object. +======= + *A Geometry is a description of a geographic object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(); /** +<<<<<<< HEAD * Destroy this geometry. +======= + *Destroy this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ destroy(): void; /** +<<<<<<< HEAD * Create a clone of this geometry. Does not set any non-standard properties of the cloned geometry. +======= + *Create a clone of this geometry. Does not set any non-standard properties of the cloned geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Geometry; /** +<<<<<<< HEAD * Set the bounds for this Geometry. +======= + *Set the bounds for this Geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ setBounds(bounds: Bounds): void; /** +<<<<<<< HEAD * Nullify this components bounds and that of its parent as well. +======= + *Nullify this components bounds and that of its parent as well. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clearBounds(): void; /** +<<<<<<< HEAD * Extend the existing bounds to include the new bounds. * If geometry's bounds is not yet set, then set a new Bounds. +======= + *Extend the existing bounds to include the new bounds. + *If geometry's bounds is not yet set, then set a new Bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extendBounds(newBounds: Bounds): void; /** +<<<<<<< HEAD * Get the bounds for this Geometry. If bounds is not set, it is calculated again, this makes queries faster. +======= + *Get the bounds for this Geometry. If bounds is not set, it is calculated again, this makes queries faster. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getBounds(): Bounds; /** +<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). +======= + *Calculate the closest distance between two geometries (on the x-y plane). +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: Object): Object; /** +<<<<<<< HEAD * Return a list of all points in this geometry. +======= + *Return a list of all points in this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; /** +<<<<<<< HEAD * Return whether or not the geometry is at the specified location +======= + *Return whether or not the geometry is at the specified location +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ atPoint(lonlat: LonLat, toleranceLon?: number, toleranceLat?: number): boolean; /** +<<<<<<< HEAD * Returns the length of the collection by summing its parts +======= + *Returns the length of the collection by summing its parts +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getLength(): number; /** +<<<<<<< HEAD * Returns the area of the collection by summing its parts +======= + *Returns the area of the collection by summing its parts +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getArea(): number; /** +<<<<<<< HEAD * Returns a text representation of the geometry. If the WKT format is +======= + *Returns a text representation of the geometry. If the WKT format is +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * included in a build, this will be the Well-Known Text * representation. */ toString(): string; /** +<<<<<<< HEAD * Calculate the centroid of this geometry. This method is defined in subclasses. +======= + *Calculate the centroid of this geometry. This method is defined in subclasses. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCentroid(): Geometry.Point; @@ -298,111 +395,195 @@ declare module OpenLayers { export class Projection { /** +<<<<<<< HEAD * This class offers several methods for interacting with a wrapped pro4js projection object. +======= + *This class offers several methods for interacting with a wrapped pro4js projection object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(projCode: string, options?: any); /** +<<<<<<< HEAD * Get the string SRS code. +======= + *Get the string SRS code. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCode(): string; /** +<<<<<<< HEAD * Get the units string for the projection -- returns null if proj4js is not available. +======= + *Get the units string for the projection -- returns null if proj4js is not available. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getUnits(): string; /** +<<<<<<< HEAD * Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. +======= + *Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addTransform(from: string, to: string, method: () => void); /** +<<<<<<< HEAD * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. +======= + *Transform a point coordinate from one projection to another. Note that the input point is transformed in place. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(point: Geometry.Point, source: Projection, dest: OpenLayers.Projection): Object; /** +<<<<<<< HEAD * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. +======= + *Transform a point coordinate from one projection to another. Note that the input point is transformed in place. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(point: Object, source: Projection, dest: OpenLayers.Projection): Object; /** +<<<<<<< HEAD * A null transformation useful for defining projection aliases when proj4js is not available: +======= + *A null transformation useful for defining projection aliases when proj4js is not available: +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ nullTransform(point: Object): Function; } export class Bounds { /** +<<<<<<< HEAD * Minimum horizontal coordinate. +======= + *Minimum horizontal coordinate. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ left: number; /** +<<<<<<< HEAD * Minimum vertical coordinate. +======= + *Minimum vertical coordinate. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ bottom: number; /** +<<<<<<< HEAD * Maximum horizontal coordinate. +======= + *Maximum horizontal coordinate. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ right: number; /** +<<<<<<< HEAD * Maximum vertical coordinate. +======= + *Maximum vertical coordinate. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ top: number; /** +<<<<<<< HEAD * Construct a new bounds object. Coordinates can either be passed as four +======= + *Construct a new bounds object. Coordinates can either be passed as four +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * arguments, or as a single argument. */ constructor(left: number, bottom: number, right: number, top: number); /** +<<<<<<< HEAD * Construct a new bounds object. Coordinates can either be passed as four +======= + *Construct a new bounds object. Coordinates can either be passed as four +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * arguments, or as a single argument. */ constructor(bounds: number[]); /** +<<<<<<< HEAD * Create a cloned instance of this bounds. +======= + *Create a cloned instance of this bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Bounds; /** +<<<<<<< HEAD * Test a two bounds for equivalence. +======= + *Test a two bounds for equivalence. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(bounds: Bounds): boolean; /** +<<<<<<< HEAD * Returns a string representation of the bounds object. +======= + *Returns a string representation of the bounds object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toString(): string; /** +<<<<<<< HEAD * Returns an array representation of the bounds object. +======= + *Returns an array representation of the bounds object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toArray(reverseAxisOrder?: boolean): number[]; /** +<<<<<<< HEAD * Returns a boundingbox-string representation of the bounds object. +======= + *Returns a boundingbox-string representation of the bounds object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toBBOX(decimal?: number, reverseAxisOrder?: boolean): string; /** +<<<<<<< HEAD * Create a new polygon geometry based on this bounds. +======= + *Create a new polygon geometry based on this bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toGeometry(): OpenLayers.Geometry.Polygon; /** +<<<<<<< HEAD * Returns the width of the bounds. +======= + *Returns the width of the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getWidth(): number; /** +<<<<<<< HEAD * Returns the height of the bounds. +======= + *Returns the height of the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getHeight(): number; @@ -417,42 +598,74 @@ declare module OpenLayers { getCenterPixel(): Pixel; /** +<<<<<<< HEAD * Returns the LonLat object which represents the center of the bounds. +======= + *Returns the LonLat object which represents the center of the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCenterLonLat(): LonLat; /** +<<<<<<< HEAD * Scales the bounds around a pixel or lonlat. Note that the new * bounds may return non-integer properties, even if a pixel * is passed. +======= + *Scales the bounds around a pixel or lonlat. Note that the new + *bounds may return non-integer properties, even if a pixel + *is passed. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ scale(ratio: number, origin?: Pixel); /** +<<<<<<< HEAD * Scales the bounds around a pixel or lonlat. Note that the new * bounds may return non-integer properties, even if a pixel * is passed. +======= + *Scales the bounds around a pixel or lonlat. Note that the new + *bounds may return non-integer properties, even if a pixel + *is passed. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ scale(ratio: number, origin?: LonLat); /** +<<<<<<< HEAD * Shifts the coordinates of the bound by the given horizontal and vertical +======= + *Shifts the coordinates of the bound by the given horizontal and vertical +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * deltas. */ add(x: number, y: number): Bounds; /** +<<<<<<< HEAD * Extend the bounds. +======= + *Extend the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: LonLat): void; /** +<<<<<<< HEAD * Extend the bounds. +======= + *Extend the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: Geometry.Point): void; /** +<<<<<<< HEAD * Extend the bounds. +======= + *Extend the bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: Bounds): void; @@ -462,120 +675,208 @@ declare module OpenLayers { extendXY(x: number, y: number): void; /** +<<<<<<< HEAD * Returns whether the bounds object contains the given . +======= + *Returns whether the bounds object contains the given . +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsLonLat(ll: LonLat, options: BoundsOptions); /** +<<<<<<< HEAD * Returns whether the bounds object contains the given . +======= + *Returns whether the bounds object contains the given . +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsLonLat(ll: Object, options: BoundsOptions); /** +<<<<<<< HEAD * Returns whether the bounds object contains the given . +======= + *Returns whether the bounds object contains the given . +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsPixel(px: Pixel, inclusive: boolean): boolean; /** +<<<<<<< HEAD * Returns whether the bounds object contains the given x and y. +======= + *Returns whether the bounds object contains the given x and y. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ contains(x: number, y: number, inclusive?: boolean): boolean; /** +<<<<<<< HEAD * Determine whether the target bounds intersects this bounds. Bounds are * considered intersecting if any of their edges intersect or if one * bounds contains the other. +======= + *Determine whether the target bounds intersects this bounds. Bounds are + *considered intersecting if any of their edges intersect or if one + *bounds contains the other. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersectsBounds(bounds: Bounds, options: BoundsOptions): boolean; /** +<<<<<<< HEAD * Returns whether the bounds object contains the given . +======= + *Returns whether the bounds object contains the given . +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsBounds(bounds: Bounds, partial: boolean, inclusive: boolean): boolean; /** +<<<<<<< HEAD * Returns the the quadrant ("br", "tr", "tl", "bl") in which the given +======= + *Returns the the quadrant ("br", "tr", "tl", "bl") in which the given +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * lies. */ determineQuadrant(lonlat: LonLat): string; /** +<<<<<<< HEAD * Transform the Bounds object from source to dest. +======= + *Transform the Bounds object from source to dest. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Bounds; /** +<<<<<<< HEAD * Wraps the bounds object around the dateline. +======= + *Wraps the bounds object around the dateline. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ wrapDateLine(maxExtent: Bounds, options: WrapDateLineOptions): Bounds; static CLASS_NAME: string; /** +<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from a * parameter string. +======= + *Alternative constructor that builds a new OpenLayers.Bounds from a + *parameter string. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromString(str: string, reverseAxisOrder: boolean): Bounds; /** +<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from an array. +======= + *Alternative constructor that builds a new OpenLayers.Bounds from an array. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromArray(bbox: number[], reverseAxisOrder: boolean): Bounds; /** +<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from a size. +======= + *Alternative constructor that builds a new OpenLayers.Bounds from a size. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromSize(size: Size): Bounds; /** +<<<<<<< HEAD * Get the opposite quadrant for a given quadrant string. +======= + *Get the opposite quadrant for a given quadrant string. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static oppositeQuadrant(quadrant: string): string; } export class LonLat { /** +<<<<<<< HEAD * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. +======= + *Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(lon: number, lat: number); /** +<<<<<<< HEAD * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. +======= + *Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(lonlat: number[]); /** +<<<<<<< HEAD * Shortened String representation of OpenLayers.LonLat object. +======= + *Shortened String representation of OpenLayers.LonLat object. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toShortString(): string; /** +<<<<<<< HEAD * New OpenLayers.LonLat object with the same lon and lat values +======= + *New OpenLayers.LonLat object with the same lon and lat values +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): LonLat; /** +<<<<<<< HEAD * A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. +======= + *A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ add(lon: number, lat: number): LonLat; /** +<<<<<<< HEAD * Boolean value indicating whether the passed-in OpenLayers.LonLat object has the same lon and lat components as this. Note: if ll passed in is null, returns false. +======= + *Boolean value indicating whether the passed-in OpenLayers.LonLat object has the same lon and lat components as this. Note: if ll passed in is null, returns false. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(ll: LonLat): boolean; /** +<<<<<<< HEAD * Transform the LonLat object from source to dest. This transformation is in place: if you want a new lonlat, use .clone() first. +======= + *Transform the LonLat object from source to dest. This transformation is in place: if you want a new lonlat, use .clone() first. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): LonLat; /** +<<<<<<< HEAD * Returns a copy of this lonlat, but wrapped around the "dateline" (as specified by the borders of maxExtent). +======= + *Returns a copy of this lonlat, but wrapped around the "dateline" (as specified by the borders of maxExtent). +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ wrapDateLine(maxExtend: Bounds): LonLat; } export class Map { +<<<<<<< HEAD /** * Unique identifier for the map */ @@ -717,10 +1018,13 @@ declare module OpenLayers { +======= +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 constructor(id: HTMLElement, options?: MapOptions); constructor(id: string, options?: MapOptions); +<<<<<<< HEAD /** * @@ -741,6 +1045,8 @@ declare module OpenLayers { * */ prop: string; +======= +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 } export class Class { @@ -767,133 +1073,240 @@ declare module OpenLayers { export class Collection extends Geometry { /** +<<<<<<< HEAD * The component parts of this geometry +======= + *The component parts of this geometry +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ components: Geometry[]; /** +<<<<<<< HEAD * An array of class names representing the types of * components that the collection can include. A null value means the * component types are not restricted. +======= + *An array of class names representing the types of + *components that the collection can include. A null value means the + *component types are not restricted. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ componentTypes: string[]; /** +<<<<<<< HEAD * Creates a Geometry Collection -- a list of geoms. +======= + *Creates a Geometry Collection -- a list of geoms. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(components: Geometry[]); /** +<<<<<<< HEAD * Destroy this geometry. +======= + *Destroy this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ destroy(): void; /** +<<<<<<< HEAD * Clone this geometry. +======= + *Clone this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Collection; /** +<<<<<<< HEAD * Get a string representing the components for this collection +======= + *Get a string representing the components for this collection +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getComponentsString(): string; /** +<<<<<<< HEAD * Recalculate the bounds by iterating through the components and * calling calling extendBounds() on each item. +======= + *Recalculate the bounds by iterating through the components and + *calling calling extendBounds() on each item. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ calculateBounds(); /** +<<<<<<< HEAD * Add components to this geometry. +======= + *Add components to this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addComponents(components: Geometry[]); /** +<<<<<<< HEAD * Add a new component (geometry) to the collection. If this.componentTypes * is set, then the component class name must be in the componentTypes array. +======= + *Add a new component (geometry) to the collection. If this.componentTypes + *is set, then the component class name must be in the componentTypes array. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addComponent(component: Geometry, index: number): boolean; /** +<<<<<<< HEAD * Remove components from this geometry. +======= + *Remove components from this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ removeComponents(components: Geometry[]): boolean; /** +<<<<<<< HEAD * Remove a component from this geometry. +======= + *Remove a component from this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ removeComponent(component: Geometry): boolean; /** +<<<<<<< HEAD * Calculate the length of this geometry +======= + *Calculate the length of this geometry +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getLength(): number; /** +<<<<<<< HEAD * Calculate the area of this geometry. Note how this function is overridden * in . +======= + *Calculate the area of this geometry. Note how this function is overridden + *in . +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getArea(): number; /** +<<<<<<< HEAD * Calculate the approximate area of the polygon were it projected onto * the earth. +======= + *Calculate the approximate area of the polygon were it projected onto + *the earth. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getGeodesicArea(projection: Projection): number; /** +<<<<<<< HEAD * Compute the centroid for this geometry collection. +======= + *Compute the centroid for this geometry collection. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCentroid(weighted?: boolean): Point; /** +<<<<<<< HEAD * Calculate the approximate length of the geometry were it projected onto * the earth. +======= + *Calculate the approximate length of the geometry were it projected onto + *the earth. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getGeodesicLength(projection: Projection): number; /** +<<<<<<< HEAD * Moves a geometry by the given displacement along positive x and y axes. * This modifies the position of the geometry and clears the cached * bounds. +======= + *Moves a geometry by the given displacement along positive x and y axes. + *This modifies the position of the geometry and clears the cached + *bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ move(x: number, y: number): void; /** +<<<<<<< HEAD * Rotate a geometry around some origin +======= + *Rotate a geometry around some origin +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ rotate(angle: number, origin: Point); /** +<<<<<<< HEAD * Resize a geometry relative to some origin. Use this method to apply * a uniform scaling to a geometry. +======= + *Resize a geometry relative to some origin. Use this method to apply + *a uniform scaling to a geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ resize(scale: number, origin: Point, ratio: number): Geometry; /** +<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). +======= + *Calculate the closest distance between two geometries (on the x-y plane). +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: DistanceOptions): Object; /** +<<<<<<< HEAD * Determine whether another geometry is equivalent to this one. Geometries * are considered equivalent if all components have the same coordinates. +======= + *Determine whether another geometry is equivalent to this one. Geometries + *are considered equivalent if all components have the same coordinates. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(geometry: Geometry): boolean; /** +<<<<<<< HEAD * Reproject the components geometry from source to dest. +======= + *Reproject the components geometry from source to dest. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Geometry; /** +<<<<<<< HEAD * Determine if the input geometry intersects this one. +======= + *Determine if the input geometry intersects this one. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersects(geometry: Geometry): boolean; /** +<<<<<<< HEAD * Return a list of all points in this geometry. +======= + *Return a list of all points in this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; @@ -907,57 +1320,101 @@ declare module OpenLayers { y: number; /** +<<<<<<< HEAD * Construct a point geometry. +======= + *Construct a point geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(x: number, y: number); /** +<<<<<<< HEAD * Create a clone of this geometry. +======= + *Create a clone of this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Geometry; /** +<<<<<<< HEAD * An exact clone of this OpenLayers.Geometry.Point +======= + *An exact clone of this OpenLayers.Geometry.Point +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(obj: Point): Point; /** +<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). +======= + *Calculate the closest distance between two geometries (on the x-y plane). +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: DistanceOptions): Object; /** +<<<<<<< HEAD * Determine whether another geometry is equivalent to this one. Geometries are considered equivalent if all components have the same coordinates. +======= + *Determine whether another geometry is equivalent to this one. Geometries are considered equivalent if all components have the same coordinates. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(geom: Point): boolean; /** +<<<<<<< HEAD * Moves a geometry by the given displacement along positive x and y axes. This modifies the position of the geometry and clears the cached bounds. +======= + *Moves a geometry by the given displacement along positive x and y axes. This modifies the position of the geometry and clears the cached bounds. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ move(x: number, y: number): void; /** +<<<<<<< HEAD * Rotate a point around another. +======= + *Rotate a point around another. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ rotate(angle: number, origin: Point); /** +<<<<<<< HEAD * Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses. +======= + *Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ resize(scale: number, origin: Point, ratio: number): Geometry; /** +<<<<<<< HEAD * Determine if the input geometry intersects this one. +======= + *Determine if the input geometry intersects this one. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersects(geometry: Geometry): boolean; /** +<<<<<<< HEAD * Translate the x,y properties of the point from source to dest. +======= + *Translate the x,y properties of the point from source to dest. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Geometry; /** +<<<<<<< HEAD * Return a list of all points in this geometry. +======= + *Return a list of all points in this geometry. +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; } @@ -1414,6 +1871,7 @@ declare module OpenLayers { } module Layer { +<<<<<<< HEAD export interface WMSGetMapParams { version?: string; exceptions?: string; @@ -1437,6 +1895,8 @@ declare module OpenLayers { crossOriginKeyword?: string; } +======= +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class ArcGIS93Rest { } export class ArcGISCache { } export class ArcIMS { } @@ -1454,6 +1914,7 @@ declare module OpenLayers { export class MapGuide { } export class MapServer { } export class Markers { } +<<<<<<< HEAD export class OSM extends Layer.XYZ { /** @@ -1502,6 +1963,9 @@ declare module OpenLayers { static CLASS_NAME: string; } +======= + export class OSM { } +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class PointGrid { } export class PointTrack { } export class SphericalMercator { } @@ -1509,6 +1973,7 @@ declare module OpenLayers { export class Text { } export class TileCache { } export class UTFGrid { } +<<<<<<< HEAD export class Vector { } export class WMS { @@ -1624,6 +2089,10 @@ declare module OpenLayers { static CLASS_NAME: string; } +======= + export class Vector { } + export class WMS { } +>>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class WMTS { } export class WorldWind { } export class XYZ { } From 2838400693d97cf347a66a1143d5b2057f72736a Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Fri, 1 Nov 2013 12:00:44 +0400 Subject: [PATCH 3/7] more definitions added --- openlayers/openlayers.d.ts | 3556 +++++++++++++++++++++++++++++------- 1 file changed, 2929 insertions(+), 627 deletions(-) diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts index 1a4e70d658..8a7f5e741c 100644 --- a/openlayers/openlayers.d.ts +++ b/openlayers/openlayers.d.ts @@ -16,57 +16,34 @@ declare module OpenLayers { export interface DistanceOptions { /** -<<<<<<< HEAD * Return details from the distance calculation. Default is false. -======= - *Return details from the distance calculation. Default is false. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ details?: boolean; /** -<<<<<<< HEAD * Calculate the distance from this geometry to the nearest edge of the target geometry. Default is true. If true, calling distanceTo from a geometry that is wholly contained within the target will result in a non-zero distance. If false, whenever geometries intersect, calling distanceTo will return 0. If false, details cannot be returned. -======= - *Calculate the distance from this geometry to the nearest edge of the target geometry. Default is true. If true, calling distanceTo from a geometry that is wholly contained within the target will result in a non-zero distance. If false, whenever geometries intersect, calling distanceTo will return 0. If false, details cannot be returned. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ edge?: boolean; } export interface BoundsOptions { /** -<<<<<<< HEAD * Whether or not to include the border. Default is true. -======= - *Whether or not to include the border. Default is true. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ inclusive?: boolean; /** -<<<<<<< HEAD * If a worldBounds is provided, the * ll will be considered as contained if it exceeds the world bounds, * but can be wrapped around the dateline so it is contained by this * bounds. -======= - *If a worldBounds is provided, the - *ll will be considered as contained if it exceeds the world bounds, - *but can be wrapped around the dateline so it is contained by this - *bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ worldBounds?: Bounds; } export interface WrapDateLineOptions { /** -<<<<<<< HEAD * Allow for a margin of error -======= - *Allow for a margin of error ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * with the 'left' value of this * bound. * Default is 0. @@ -74,11 +51,7 @@ declare module OpenLayers { leftTolerance?: number; /** -<<<<<<< HEAD * Allow for a margin of error -======= - *Allow for a margin of error ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * with the 'right' value of this * bound. * Default is 0. @@ -86,6 +59,10 @@ declare module OpenLayers { rightTolerance?: number; } + export interface LayerOptions { + + } + export class Animation { // TODO } @@ -100,490 +77,991 @@ declare module OpenLayers { export class Function { // TODO - } + } export class Array { // TODO - } + } export class Console { // TODO - } + } export class Control { // TODO - } + } export class Event { // TODO - } + } export class Events { // TODO - } + } export class Feature { // TODO - } + } export class Filter { // TODO - } + } export class Format { // TODO - } + } export class Handler { // TODO - } + } export class Icon { // TODO - } + } export class Kinetic { // TODO - } + } export class Lang { // TODO - } + } export class Layer { - // TODO - } - - export class Marker { - // TODO - } - - export class Popup { - // TODO - } - - export class Protocol { - // TODO - } - - export class Renderer { - // TODO - } - - export class Request { - // TODO - } - - export class Rule { - // TODO - } - - export class SingleFile { - // TODO - } - - export class Spherical { - // TODO - } - - export class Strategy { - // TODO - } - - export class Style { - // TODO - } - - export class Style2 { - // TODO - } - - export class StyleMap { - // TODO - } - - export class Symbolizer { - // TODO - } - - export class Tile { - // TODO - } - - export class TileManager { - // TODO - } - - export class Tween { - // TODO - } - - export class Util { - // TODO - } - - export class WPSClient { - // TODO - } - - export class WPSProcess { - // TODO - } - - export class Geometry { /** -<<<<<<< HEAD - * A unique identifier for this geometry. -======= - *A unique identifier for this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 + * + */ + id: string; + + /** + * + */ + name: string; + + /** + * + */ + div: HTMLElement; + + /** + * The layer's opacity. Float number between 0.0 and 1.0. + */ + opacity: number; + + /** + * If a layer's display should not be scale-based, this should + * be set to true. This will cause the layer, as an overlay, to always + * be 'active', by always returning true from the calculateInRange() + * function. + * + * If not explicitly specified for a layer, its value will be + * determined on startup in initResolutions() based on whether or not + * any scale-specific properties have been set as options on the + * layer. If no scale-specific options have been set on the layer, we + * assume that it should always be in range. + */ + alwaysInRange: boolean; + + /** + * The properties that are used for calculating resolutions information. + */ + RESOLUTION_PROPERTIES: string[]; + + /** + * APIProperty: events + * {} + * + * Register a listener for a particular event with the following syntax: + * (code) + * layer.events.register(type, obj, listener); + * (end) + * + * Listeners will be called with a reference to an event object. The + * properties of this event depends on exactly what happened. + * + * All event objects have at least the following properties: + * object - {Object} A reference to layer.events.object. + * element - {DOMElement} A reference to layer.events.element. + * + * Supported map event types: + * loadstart - Triggered when layer loading starts. When using a Vector + * layer with a Fixed or BBOX strategy, the event object includes + * a *filter* property holding the OpenLayers.Filter used when + * calling read on the protocol. + * loadend - Triggered when layer loading ends. When using a Vector layer + * with a Fixed or BBOX strategy, the event object includes a + * *response* property holding an OpenLayers.Protocol.Response object. + * visibilitychanged - Triggered when the layer's visibility property is + * changed, e.g. by turning the layer on or off in the layer switcher. + * Note that the actual visibility of the layer can also change if it + * gets out of range (see ). If you also want to catch + * these cases, register for the map's 'changelayer' event instead. + * move - Triggered when layer moves (triggered with every mousemove + * during a drag). + * moveend - Triggered when layer is done moving, object passed as + * argument has a zoomChanged boolean property which tells that the + * zoom has changed. + * added - Triggered after the layer is added to a map. Listeners will + * receive an object with a *map* property referencing the map and a + * *layer* property referencing the layer. + * removed - Triggered after the layer is removed from the map. Listeners + * will receive an object with a *map* property referencing the map and + * a *layer* property referencing the layer. + */ + events: Events; + + /** + * This variable is set when the layer is added to + * the map, via the accessor function setMap() + */ + map: Map; + + /** + * Whether or not the layer is a base layer. This should be set + * individually by all subclasses. Default is false + */ + isBaseLayer: boolean; + + /** + * The layer's images have an alpha channel. Default is false. + */ + alpha: boolean; + + /** + * Display the layer's name in the layer switcher. Default is true + */ + displayInLayerSwitcher: boolean; + + /** + * The layer should be displayed in the map. Default is true. + */ + visibility: boolean; + + /** + * Attribution string, displayed when an + * has been added to the map. + */ + attribution: string; + + /** + * The current map resolution is within the layer's min/max + * range. This is set in whenever the zoom + * changes. + */ + inRange: boolean; + + /** + * For layers with a gutter, the image is larger than + * the tile by twice the gutter in each dimension. + */ + imageSize: Size; + + /** + * An optional object whose properties will be set on the layer. + * Any of the layer properties can be set as a property of the options + * object and sent to the constructor when the layer is created. + */ + options: Object; + + /** + * An optional object whose properties will be set on the layer. + * Any of the layer properties can be set as a property of the options + * object and sent to the constructor when the layer is created. + */ + eventListeners: Object; + + /** + * Determines the width (in pixels) of the gutter around image + * tiles to ignore. By setting this property to a non-zero value, + * images will be requested that are wider and taller than the tile + * size by a value of 2 x gutter. This allows artifacts of rendering + * at tile edges to be ignored. Set a gutter value that is equal to + * half the size of the widest symbol that needs to be displayed. + * Defaults to zero. Non-tiled layers always have zero gutter. + */ + gutter: number; + + /** + * Specifies the projection of the layer. + * Can be set in the layer options. If not specified in the layer options, + * it is set to the default projection specified in the map, + * when the layer is added to the map. + * Projection along with default maxExtent and resolutions + * are set automatically with commercial baselayers in EPSG:3857, + * such as Google, Bing and OpenStreetMap, and do not need to be specified. + * Otherwise, if specifying projection, also set maxExtent, + * maxResolution or resolutions as appropriate. + * When using vector layers with strategies, layer projection should be set + * to the projection of the source data if that is different from the map default. + */ + projection: Projection; + + /** + * The layer map units. Defaults to null. Possible values + * are 'degrees' (or 'dd'), 'm', 'ft', 'km', 'mi', 'inches'. + * Normally taken from the projection. + * Only required if both map and layers do not define a projection, + * or if they define a projection which does not define units. + */ + units: string; + + /** + * An array of map scales in descending order. The values in the + * array correspond to the map scale denominator. Note that these + * values only make sense if the display (monitor) resolution of the + * client is correctly guessed by whomever is configuring the + * application. In addition, the units property must also be set. + * Use instead wherever possible. + */ + scales: Array; + + /** + * A list of map resolutions (map units per pixel) in descending + * order. If this is not set in the layer constructor, it will be set + * based on other resolution related properties (maxExtent, + * maxResolution, maxScale, etc.). + */ + resolutions: Array; + + /** + * The maximum extent for the layer. Defaults to null. + */ + maxExtent: Bounds; + + /** + * The minimum extent for the layer. Defaults to null. + */ + minExtent: Bounds; + + /** + * Default max is 360 deg / 256 px, which corresponds to + * zoom level 0 on gmaps. Specify a different value in the layer + * options if you are not using the default + * and displaying the whole world. + */ + maxResolution: number; + + /** + * + */ + minResolution: number; + + /** + * + */ + numZoomLevels: number; + + /** + * + */ + minScale: number; + + /** + * + */ + maxScale: number; + + /** + * Request map tiles that are completely outside of the max + * extent for this layer. Defaults to false. + */ + displayOutsideMaxExtent: boolean; + + /** + * Wraps the world at the international dateline, so the map can + * be panned infinitely in longitudinal direction. Only use this on the + * base layer, and only if the layer's maxExtent equals the world bounds. + */ + wrapDateLine: boolean; + + /** + * This object can be used to store additional information on a + * layer object. + */ + metadata: Object; + + /** + * Constructor: OpenLayers.Layer + * + * Parameters: + * name - {String} The layer name + * options - {Object} Hashtable of extra options to tag onto the layer + */ + constructor(name: string, options: LayerOptions); + + /** + * Method: destroy + * Destroy is a destructor: this is to alleviate cyclic references which + * the Javascript garbage cleaner can not take care of on its own. + * + * Parameters: + * setNewBaseLayer - {Boolean} Set a new base layer when this layer has + * been destroyed. Default is true. + */ + destroy(setNewBaseLayer?: boolean); + + /** + * Method: clone + * + * Parameters: + * obj - {} The layer to be cloned + * + * Returns: + * {} An exact clone of this + */ + clone(): Layer; + + /** + * Method: getOptions + * Extracts an object from the layer with the properties that were set as + * options, but updates them with the values currently set on the + * instance. + * + * Returns: + * {Object} the of the layer, representing the current state. + */ + private getOptions(): LayerOptions; + + /** + * APIMethod: setName + * Sets the new layer name for this layer. Can trigger a changelayer event + * on the map. + * + * Parameters: + * newName - {String} The new name. + */ + setName(newName: string): void; + + /** + * APIMethod: addOptions + * + * Parameters: + * newOptions - {Object} + * reinitialize - {Boolean} If set to true, and if resolution options of the + * current baseLayer were changed, the map will be recentered to make + * sure that it is displayed with a valid resolution, and a + * changebaselayer event will be triggered. + */ + addOptions(newOptions: LayerOptions, reinitialize: boolean): void; + + /** + * This function can be implemented by subclasses + */ + onMapResize(): void; + + /** + * APIMethod: redraw + * Redraws the layer. Returns true if the layer was redrawn, false if not. + * + * Returns: + * {Boolean} The layer was redrawn. + */ + redraw(): void; + + /** + * Method: moveTo + * + * Parameters: + * bounds - {} + * zoomChanged - {Boolean} Tells when zoom has changed, as layers have to + * do some init work in that case. + * dragging - {Boolean} + */ + moveTo(bounds: Bounds, zoomChanged: boolean, dragging: boolean): void; + + /** + * Method: moveByPx + * Move the layer based on pixel vector. To be implemented by subclasses. + * + * Parameters: + * dx - {Number} The x coord of the displacement vector. + * dy - {Number} The y coord of the displacement vector. + */ + moveByPx(dx: number, dy: number): void; + + /** + * Method: setMap + * Set the map property for the layer. This is done through an accessor + * so that subclasses can override this and take special action once + * they have their map variable set. + * + * Here we take care to bring over any of the necessary default + * properties from the map. + * + * Parameters: + * map - {} + */ + setMap(map: Map): void; + + /** + * Method: afterAdd + * Called at the end of the map.addLayer sequence. At this point, the map + * will have a base layer. To be overridden by subclasses. + */ + private afterAdd(): void; + + /** + * APIMethod: removeMap + * Just as setMap() allows each layer the possibility to take a + * personalized action on being added to the map, removeMap() allows + * each layer to take a personalized action on being removed from it. + * For now, this will be mostly unused, except for the EventPane layer, + * which needs this hook so that it can remove the special invisible + * pane. + * + * Parameters: + * map - {} + */ + removeMap(map: Map): void; + + /** + * APIMethod: getImageSize + * + * Parameters: + * bounds - {} optional tile bounds, can be used + * by subclasses that have to deal with different tile sizes at the + * layer extent edges (e.g. Zoomify) + * + * Returns: + * {} The size that the image should be, taking into + * account gutters. + */ + getImageSize(bounds: Bounds): Size; + + /** + * APIMethod: setTileSize + * Set the tile size based on the map size. This also sets layer.imageSize + * or use by Tile.Image. + * + * Parameters: + * size - {} + */ + setTileSize(size: Size): void; + + /** + * APIMethod: getVisibility + * + * Returns: + * {Boolean} The layer should be displayed (if in range). + */ + getVisibility(): boolean; + + /** + * APIMethod: setVisibility + * Set the visibility flag for the layer and hide/show & redraw + * accordingly. Fire event unless otherwise specified + * + * Note that visibility is no longer simply whether or not the layer's + * style.display is set to "block". Now we store a 'visibility' state + * property on the layer class, this allows us to remember whether or + * not we *desire* for a layer to be visible. In the case where the + * map's resolution is out of the layer's range, this desire may be + * subverted. + * + * Parameters: + * visibility - {Boolean} Whether or not to display the layer (if in range) + */ + setVisibility(visibility: boolean): void; + + /** + * APIMethod: display + * Hide or show the Layer. This is designed to be used internally, and + * is not generally the way to enable or disable the layer. For that, + * use the setVisibility function instead.. + * + * Parameters: + * display - {Boolean} + */ + display(display: boolean): void; + + /** + * APIMethod: calculateInRange + * + * Returns: + * {Boolean} The layer is displayable at the current map's current + * resolution. Note that if 'alwaysInRange' is true for the layer, + * this function will always return true. + */ + calculateInRange(): boolean; + + /** + * APIMethod: setIsBaseLayer + * + * Parameters: + * isBaseLayer - {Boolean} + */ + setIsBaseLayer(isBaseLayer: boolean): void; + + /********************************************************/ + /* */ + /* Baselayer Functions */ + /* */ + /********************************************************/ + + /** + * Method: initResolutions + * This method's responsibility is to set up the 'resolutions' array + * for the layer -- this array is what the layer will use to interface + * between the zoom levels of the map and the resolution display + * of the layer. + * + * The user has several options that determine how the array is set up. + * + * For a detailed explanation, see the following wiki from the + * openlayers.org homepage: + * http://trac.openlayers.org/wiki/SettingZoomLevels + */ + private initResolutions(): void; + + /** + * Method: resolutionsFromScales + * Derive resolutions from scales. + * + * Parameters: + * scales - {Array(Number)} Scales + * + * Returns + * {Array(Number)} Resolutions + */ + private resolutionsFromScales(scales: number[]): number[]; + + /** + * Method: calculateResolutions + * Calculate resolutions based on the provided properties. + * + * Parameters: + * props - {Object} Properties + * + * Returns: + * {Array({Number})} Array of resolutions. + */ + private calculateResolutions(props: Object): number[]; + + /** + * APIMethod: getResolution + * + * Returns: + * {Float} The currently selected resolution of the map, taken from the + * resolutions array, indexed by current zoom level. + */ + getResolution(): number; + + /** + * APIMethod: getExtent + * + * Returns: + * {} A Bounds object which represents the lon/lat + * bounds of the current viewPort. + */ + getExtent(): Bounds; + + /** + * APIMethod: getZoomForExtent + * + * Parameters: + * extent - {} + * closest - {Boolean} Find the zoom level that most closely fits the + * specified bounds. Note that this may result in a zoom that does + * not exactly contain the entire extent. + * Default is false. + * + * Returns: + * {Integer} The index of the zoomLevel (entry in the resolutions array) + * for the passed-in extent. We do this by calculating the ideal + * resolution for the given extent (based on the map size) and then + * calling getZoomForResolution(), passing along the 'closest' + * parameter. + */ + getZoomForExtent(extent: Bounds, closest?: boolean): number; + + /** + * Method: getDataExtent + * Calculates the max extent which includes all of the data for the layer. + * This function is to be implemented by subclasses. + * + * Returns: + * {} + */ + private getDataExtent(): Bounds; + + /** + * APIMethod: getResolutionForZoom + * + * Parameters: + * zoom - {Float} + * + * Returns: + * {Float} A suitable resolution for the specified zoom. + */ + getResolutionForZoom(zoom: number): number; + + /** + * APIMethod: getZoomForResolution + * + * Parameters: + * resolution - {Float} + * closest - {Boolean} Find the zoom level that corresponds to the absolute + * closest resolution, which may result in a zoom whose corresponding + * resolution is actually smaller than we would have desired (if this + * is being called from a getZoomForExtent() call, then this means that + * the returned zoom index might not actually contain the entire + * extent specified... but it'll be close). + * Default is false. + * + * Returns: + * {Integer} The index of the zoomLevel (entry in the resolutions array) + * that corresponds to the best fit resolution given the passed in + * value and the 'closest' specification. + */ + getZoomForResolution(resolution: number, closest?: boolean): number; + + /** + * APIMethod: getLonLatFromViewPortPx + * + * Parameters: + * viewPortPx - {|Object} An OpenLayers.Pixel or + * an object with a 'x' + * and 'y' properties. + * + * Returns: + * {} An OpenLayers.LonLat which is the passed-in + * view port , translated into lon/lat by the layer. + */ + getLonLatFromViewPortPx(viewPortPx: Pixel): LonLat; + + /** + * APIMethod: getViewPortPxFromLonLat + * Returns a pixel location given a map location. This method will return + * fractional pixel values. + * + * Parameters: + * lonlat - {|Object} An OpenLayers.LonLat or + * an object with a 'lon' + * and 'lat' properties. + * + * Returns: + * {} An which is the passed-in + * lonlat translated into view port pixels. + */ + getViewPortPxFromLonLat(lonlat: LonLat, resolution: number): Pixel; + + /** + * APIMethod: setOpacity + * Sets the opacity for the entire layer (all images) + * + * Parameters: + * opacity - {Float} + */ + setOpacity(opacity: number): void; + + /** + * Method: getZIndex + * + * Returns: + * {Integer} the z-index of this layer + */ + private getZIndex(): number; + + /** + * Method: setZIndex + * + * Parameters: + * zIndex - {Integer} + */ + private setZIndex(zIndex: number): void; + + /** + * Method: adjustBounds + * This function will take a bounds, and if wrapDateLine option is set + * on the layer, it will return a bounds which is wrapped around the + * world. We do not wrap for bounds which *cross* the + * maxExtent.left/right, only bounds which are entirely to the left + * or entirely to the right. + * + * Parameters: + * bounds - {} + */ + private adjustBounds(bounds: Bounds): Bounds; + + static CLASS_NAME: string; + } + + export class Marker { + // TODO + } + + export class Popup { + // TODO + } + + export class Protocol { + // TODO + } + + export class Renderer { + // TODO + } + + export class Request { + // TODO + } + + export class Rule { + // TODO + } + + export class SingleFile { + // TODO + } + + export class Spherical { + // TODO + } + + export class Strategy { + // TODO + } + + export class Style { + // TODO + } + + export class Style2 { + // TODO + } + + export class StyleMap { + // TODO + } + + export class Symbolizer { + // TODO + } + + export class Tile { + // TODO + } + + export class TileManager { + // TODO + } + + export class Tween { + // TODO + } + + export class Util { + // TODO + } + + export class WPSClient { + // TODO + } + + export class WPSProcess { + // TODO + } + + export class Geometry { + /** + * A unique identifier for this geometry. */ id: string; /** -<<<<<<< HEAD * This is set when a Geometry is added as component * of another geometry -======= - *This is set when a Geometry is added as component - *of another geometry ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ parent: Geometry; /** -<<<<<<< HEAD * The bounds of this geometry -======= - *The bounds of this geometry ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ bounds: Bounds; /** -<<<<<<< HEAD * A Geometry is a description of a geographic object. -======= - *A Geometry is a description of a geographic object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(); /** -<<<<<<< HEAD * Destroy this geometry. -======= - *Destroy this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ destroy(): void; /** -<<<<<<< HEAD * Create a clone of this geometry. Does not set any non-standard properties of the cloned geometry. -======= - *Create a clone of this geometry. Does not set any non-standard properties of the cloned geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Geometry; /** -<<<<<<< HEAD * Set the bounds for this Geometry. -======= - *Set the bounds for this Geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ setBounds(bounds: Bounds): void; /** -<<<<<<< HEAD * Nullify this components bounds and that of its parent as well. -======= - *Nullify this components bounds and that of its parent as well. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clearBounds(): void; /** -<<<<<<< HEAD * Extend the existing bounds to include the new bounds. * If geometry's bounds is not yet set, then set a new Bounds. -======= - *Extend the existing bounds to include the new bounds. - *If geometry's bounds is not yet set, then set a new Bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extendBounds(newBounds: Bounds): void; /** -<<<<<<< HEAD * Get the bounds for this Geometry. If bounds is not set, it is calculated again, this makes queries faster. -======= - *Get the bounds for this Geometry. If bounds is not set, it is calculated again, this makes queries faster. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getBounds(): Bounds; /** -<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). -======= - *Calculate the closest distance between two geometries (on the x-y plane). ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: Object): Object; /** -<<<<<<< HEAD * Return a list of all points in this geometry. -======= - *Return a list of all points in this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; /** -<<<<<<< HEAD * Return whether or not the geometry is at the specified location -======= - *Return whether or not the geometry is at the specified location ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ atPoint(lonlat: LonLat, toleranceLon?: number, toleranceLat?: number): boolean; /** -<<<<<<< HEAD * Returns the length of the collection by summing its parts -======= - *Returns the length of the collection by summing its parts ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getLength(): number; /** -<<<<<<< HEAD * Returns the area of the collection by summing its parts -======= - *Returns the area of the collection by summing its parts ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getArea(): number; /** -<<<<<<< HEAD * Returns a text representation of the geometry. If the WKT format is -======= - *Returns a text representation of the geometry. If the WKT format is ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * included in a build, this will be the Well-Known Text * representation. */ toString(): string; /** -<<<<<<< HEAD * Calculate the centroid of this geometry. This method is defined in subclasses. -======= - *Calculate the centroid of this geometry. This method is defined in subclasses. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCentroid(): Geometry.Point; static CLASS_NAME: string; - } + } export class Projection { /** -<<<<<<< HEAD * This class offers several methods for interacting with a wrapped pro4js projection object. -======= - *This class offers several methods for interacting with a wrapped pro4js projection object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(projCode: string, options?: any); /** -<<<<<<< HEAD * Get the string SRS code. -======= - *Get the string SRS code. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCode(): string; /** -<<<<<<< HEAD * Get the units string for the projection -- returns null if proj4js is not available. -======= - *Get the units string for the projection -- returns null if proj4js is not available. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getUnits(): string; /** -<<<<<<< HEAD * Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. -======= - *Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addTransform(from: string, to: string, method: () => void); /** -<<<<<<< HEAD * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. -======= - *Transform a point coordinate from one projection to another. Note that the input point is transformed in place. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(point: Geometry.Point, source: Projection, dest: OpenLayers.Projection): Object; /** -<<<<<<< HEAD * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. -======= - *Transform a point coordinate from one projection to another. Note that the input point is transformed in place. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(point: Object, source: Projection, dest: OpenLayers.Projection): Object; /** -<<<<<<< HEAD * A null transformation useful for defining projection aliases when proj4js is not available: -======= - *A null transformation useful for defining projection aliases when proj4js is not available: ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ nullTransform(point: Object): Function; } export class Bounds { /** -<<<<<<< HEAD * Minimum horizontal coordinate. -======= - *Minimum horizontal coordinate. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ left: number; /** -<<<<<<< HEAD * Minimum vertical coordinate. -======= - *Minimum vertical coordinate. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ bottom: number; /** -<<<<<<< HEAD * Maximum horizontal coordinate. -======= - *Maximum horizontal coordinate. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ right: number; /** -<<<<<<< HEAD * Maximum vertical coordinate. -======= - *Maximum vertical coordinate. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ top: number; /** -<<<<<<< HEAD * Construct a new bounds object. Coordinates can either be passed as four -======= - *Construct a new bounds object. Coordinates can either be passed as four ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * arguments, or as a single argument. */ constructor(left: number, bottom: number, right: number, top: number); /** -<<<<<<< HEAD * Construct a new bounds object. Coordinates can either be passed as four -======= - *Construct a new bounds object. Coordinates can either be passed as four ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * arguments, or as a single argument. */ constructor(bounds: number[]); /** -<<<<<<< HEAD * Create a cloned instance of this bounds. -======= - *Create a cloned instance of this bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Bounds; /** -<<<<<<< HEAD * Test a two bounds for equivalence. -======= - *Test a two bounds for equivalence. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(bounds: Bounds): boolean; /** -<<<<<<< HEAD * Returns a string representation of the bounds object. -======= - *Returns a string representation of the bounds object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toString(): string; /** -<<<<<<< HEAD * Returns an array representation of the bounds object. -======= - *Returns an array representation of the bounds object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toArray(reverseAxisOrder?: boolean): number[]; /** -<<<<<<< HEAD * Returns a boundingbox-string representation of the bounds object. -======= - *Returns a boundingbox-string representation of the bounds object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toBBOX(decimal?: number, reverseAxisOrder?: boolean): string; /** -<<<<<<< HEAD * Create a new polygon geometry based on this bounds. -======= - *Create a new polygon geometry based on this bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toGeometry(): OpenLayers.Geometry.Polygon; /** -<<<<<<< HEAD * Returns the width of the bounds. -======= - *Returns the width of the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getWidth(): number; /** -<<<<<<< HEAD * Returns the height of the bounds. -======= - *Returns the height of the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getHeight(): number; @@ -598,74 +1076,42 @@ declare module OpenLayers { getCenterPixel(): Pixel; /** -<<<<<<< HEAD * Returns the LonLat object which represents the center of the bounds. -======= - *Returns the LonLat object which represents the center of the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCenterLonLat(): LonLat; /** -<<<<<<< HEAD * Scales the bounds around a pixel or lonlat. Note that the new * bounds may return non-integer properties, even if a pixel * is passed. -======= - *Scales the bounds around a pixel or lonlat. Note that the new - *bounds may return non-integer properties, even if a pixel - *is passed. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ scale(ratio: number, origin?: Pixel); /** -<<<<<<< HEAD * Scales the bounds around a pixel or lonlat. Note that the new * bounds may return non-integer properties, even if a pixel * is passed. -======= - *Scales the bounds around a pixel or lonlat. Note that the new - *bounds may return non-integer properties, even if a pixel - *is passed. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ scale(ratio: number, origin?: LonLat); /** -<<<<<<< HEAD * Shifts the coordinates of the bound by the given horizontal and vertical -======= - *Shifts the coordinates of the bound by the given horizontal and vertical ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * deltas. */ add(x: number, y: number): Bounds; /** -<<<<<<< HEAD * Extend the bounds. -======= - *Extend the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: LonLat): void; /** -<<<<<<< HEAD * Extend the bounds. -======= - *Extend the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: Geometry.Point): void; /** -<<<<<<< HEAD * Extend the bounds. -======= - *Extend the bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ extend(object: Bounds): void; @@ -675,208 +1121,120 @@ declare module OpenLayers { extendXY(x: number, y: number): void; /** -<<<<<<< HEAD * Returns whether the bounds object contains the given . -======= - *Returns whether the bounds object contains the given . ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsLonLat(ll: LonLat, options: BoundsOptions); /** -<<<<<<< HEAD * Returns whether the bounds object contains the given . -======= - *Returns whether the bounds object contains the given . ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsLonLat(ll: Object, options: BoundsOptions); /** -<<<<<<< HEAD * Returns whether the bounds object contains the given . -======= - *Returns whether the bounds object contains the given . ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsPixel(px: Pixel, inclusive: boolean): boolean; /** -<<<<<<< HEAD * Returns whether the bounds object contains the given x and y. -======= - *Returns whether the bounds object contains the given x and y. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ contains(x: number, y: number, inclusive?: boolean): boolean; /** -<<<<<<< HEAD * Determine whether the target bounds intersects this bounds. Bounds are * considered intersecting if any of their edges intersect or if one * bounds contains the other. -======= - *Determine whether the target bounds intersects this bounds. Bounds are - *considered intersecting if any of their edges intersect or if one - *bounds contains the other. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersectsBounds(bounds: Bounds, options: BoundsOptions): boolean; /** -<<<<<<< HEAD * Returns whether the bounds object contains the given . -======= - *Returns whether the bounds object contains the given . ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ containsBounds(bounds: Bounds, partial: boolean, inclusive: boolean): boolean; /** -<<<<<<< HEAD * Returns the the quadrant ("br", "tr", "tl", "bl") in which the given -======= - *Returns the the quadrant ("br", "tr", "tl", "bl") in which the given ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 * lies. */ determineQuadrant(lonlat: LonLat): string; /** -<<<<<<< HEAD * Transform the Bounds object from source to dest. -======= - *Transform the Bounds object from source to dest. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Bounds; /** -<<<<<<< HEAD * Wraps the bounds object around the dateline. -======= - *Wraps the bounds object around the dateline. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ wrapDateLine(maxExtent: Bounds, options: WrapDateLineOptions): Bounds; static CLASS_NAME: string; /** -<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from a * parameter string. -======= - *Alternative constructor that builds a new OpenLayers.Bounds from a - *parameter string. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromString(str: string, reverseAxisOrder: boolean): Bounds; /** -<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from an array. -======= - *Alternative constructor that builds a new OpenLayers.Bounds from an array. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromArray(bbox: number[], reverseAxisOrder: boolean): Bounds; /** -<<<<<<< HEAD * Alternative constructor that builds a new OpenLayers.Bounds from a size. -======= - *Alternative constructor that builds a new OpenLayers.Bounds from a size. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static fromSize(size: Size): Bounds; /** -<<<<<<< HEAD * Get the opposite quadrant for a given quadrant string. -======= - *Get the opposite quadrant for a given quadrant string. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ static oppositeQuadrant(quadrant: string): string; } export class LonLat { /** -<<<<<<< HEAD * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. -======= - *Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(lon: number, lat: number); /** -<<<<<<< HEAD * Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. -======= - *Create a new map location. Coordinates can be passed either as two arguments, or as a single argument. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(lonlat: number[]); /** -<<<<<<< HEAD * Shortened String representation of OpenLayers.LonLat object. -======= - *Shortened String representation of OpenLayers.LonLat object. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ toShortString(): string; /** -<<<<<<< HEAD * New OpenLayers.LonLat object with the same lon and lat values -======= - *New OpenLayers.LonLat object with the same lon and lat values ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): LonLat; /** -<<<<<<< HEAD * A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. -======= - *A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ add(lon: number, lat: number): LonLat; /** -<<<<<<< HEAD * Boolean value indicating whether the passed-in OpenLayers.LonLat object has the same lon and lat components as this. Note: if ll passed in is null, returns false. -======= - *Boolean value indicating whether the passed-in OpenLayers.LonLat object has the same lon and lat components as this. Note: if ll passed in is null, returns false. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(ll: LonLat): boolean; /** -<<<<<<< HEAD * Transform the LonLat object from source to dest. This transformation is in place: if you want a new lonlat, use .clone() first. -======= - *Transform the LonLat object from source to dest. This transformation is in place: if you want a new lonlat, use .clone() first. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): LonLat; /** -<<<<<<< HEAD * Returns a copy of this lonlat, but wrapped around the "dateline" (as specified by the borders of maxExtent). -======= - *Returns a copy of this lonlat, but wrapped around the "dateline" (as specified by the borders of maxExtent). ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ wrapDateLine(maxExtend: Bounds): LonLat; } export class Map { -<<<<<<< HEAD /** * Unique identifier for the map */ @@ -1016,37 +1374,1043 @@ declare module OpenLayers { */ maxResolution: number; - - -======= ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 - - constructor(id: HTMLElement, options?: MapOptions); - - constructor(id: string, options?: MapOptions); -<<<<<<< HEAD + /** + * APIProperty: minResolution + * {Float} + */ + minResolution: number; /** + * APIProperty: maxScale + * {Float} + */ + maxScale: number; + + /** + * APIProperty: minScale + * {Float} + */ + minScale: number; + + /** + * APIProperty: maxExtent + * {|Array} If provided as an array, the array + * should consist of four values (left, bottom, right, top). + * The maximum extent for the map. + * Default depends on projection; if this is one of those defined in OpenLayers.Projection.defaults + * (EPSG:4326 or web mercator), maxExtent will be set to the value defined there; + * else, defaults to null. + * To restrict user panning and zooming of the map, use instead. + * The value for will change calculations for tile URLs. + */ + maxExtent: Bounds; + + /** + * APIProperty: minExtent + * {|Array} If provided as an array, the array + * should consist of four values (left, bottom, right, top). + * The minimum extent for the map. Defaults to null. + */ + minExtent: Bounds; + + /** + * APIProperty: restrictedExtent + * Limit map navigation to this extent where possible. + * If a non-null restrictedExtent is set, panning will be restricted + * to the given bounds. In addition, zooming to a resolution that + * displays more than the restricted extent will center the map + * on the restricted extent. If you wish to limit the zoom level + * or resolution, use maxResolution. + */ + restrictedExtent: Bounds; + + /** + * APIProperty: numZoomLevels + * {Integer} Number of zoom levels for the map. Defaults to 16. Set a + * different value in the map options if needed. + */ + numZoomLevels: number; + + /** + * APIProperty: theme + * {String} Relative path to a CSS file from which to load theme styles. + * Specify null in the map options (e.g. {theme: null}) if you + * want to get cascading style declarations - by putting links to + * stylesheets or style declarations directly in your page. + */ + theme: string; + + /** + * APIProperty: displayProjection + * {} Requires proj4js support for projections other + * than EPSG:4326 or EPSG:900913/EPSG:3857. Projection used by + * several controls to display data to user. If this property is set, + * it will be set on any control which has a null displayProjection + * property at the time the control is added to the map. + */ + displayProjection: Projection; + + /** + * APIProperty: fallThrough + * {Boolean} Should OpenLayers allow events on the map to fall through to + * other elements on the page, or should it swallow them? (#457) + * Default is to swallow. + */ + fallThrough: boolean; + + /** + * APIProperty: autoUpdateSize + * {Boolean} Should OpenLayers automatically update the size of the map + * when the resize event is fired. Default is true. + */ + autoUpdateSize: boolean; + + /** + * APIProperty: eventListeners + * {Object} If set as an option at construction, the eventListeners + * object will be registered with . Object + * structure must be a listeners object as shown in the example for + * the events.on method. + */ + eventListeners: Object; + + /** + * Property: panTween + * {} Animated panning tween object, see panTo() + */ + panTween: Tween; + + /** + * APIProperty: panMethod + * {Function} The Easing function to be used for tweening. Default is + * OpenLayers.Easing.Expo.easeOut. Setting this to 'null' turns off + * animated panning. + */ + panMethod: () => void; + + /** + * Property: panDuration + * {Integer} The number of steps to be passed to the + * OpenLayers.Tween.start() method when the map is + * panned. + * Default is 50. + */ + panDuration: number; + + /** + * Property: zoomTween + * {} Animated zooming tween object, see zoomTo() + */ + zoomTween: Tween; + + /** + * APIProperty: zoomMethod + * {Function} The Easing function to be used for tweening. Default is + * OpenLayers.Easing.Quad.easeOut. Setting this to 'null' turns off + * animated zooming. + */ + zoomMethod: () => void; + + /** + * Property: zoomDuration + * {Integer} The number of steps to be passed to the + * OpenLayers.Tween.start() method when the map is zoomed. + * Default is 20. + */ + zoomDuration: number; + + /** + * Property: paddingForPopups + * {} Outside margin of the popup. Used to prevent + * the popup from getting too close to the map border. + */ + paddingForPopups: Bounds; + + /** + * Property: layerContainerOriginPx + * {Object} Cached object representing the layer container origin (in pixels). + */ + layerContainerOriginPx: Object; + + /** + * Property: minPx + * {Object} An object with a 'x' and 'y' values that is the lower + * left of maxExtent in viewport pixel space. + * Used to verify in moveByPx that the new location we're moving to + * is valid. It is also used in the getLonLatFromViewPortPx function + * of Layer. + */ + minPx: { x: number; y: number }; + + /** + * Property: maxPx + * {Object} An object with a 'x' and 'y' values that is the top + * right of maxExtent in viewport pixel space. + * Used to verify in moveByPx that the new location we're moving to + * is valid. + */ + maxPx: { x: number; y: number }; + + /** + * Constructor: OpenLayers.Map + * Constructor for a new OpenLayers.Map instance. There are two possible + * ways to call the map constructor. See the examples below. * + * Parameters: + * div - {DOMElement|String} The element or id of an element in your page + * that will contain the map. May be omitted if the
option is + * provided or if you intend to call the method later. + * options - {Object} Optional object with properties to tag onto the map. + * + * Valid options (in addition to the listed API properties): + * center - {|Array} The default initial center of the map. + * If provided as array, the first value is the x coordinate, + * and the 2nd value is the y coordinate. + * Only specify if is provided. + * Note that if an ArgParser/Permalink control is present, + * and the querystring contains coordinates, center will be set + * by that, and this option will be ignored. + * zoom - {Number} The initial zoom level for the map. Only specify if + * is provided. + * Note that if an ArgParser/Permalink control is present, + * and the querystring contains a zoom level, zoom will be set + * by that, and this option will be ignored. + * + * Examples: + * (code) + * // create a map with default options in an element with the id "map1" + * var map = new OpenLayers.Map("map1"); + * + * // create a map with non-default options in an element with id "map2" + * var options = { + * projection: "EPSG:3857", + * maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000), + * center: new OpenLayers.LonLat(-12356463.476333, 5621521.4854095) + * }; + * var map = new OpenLayers.Map("map2", options); + * + * // map with non-default options - same as above but with a single argument, + * // a restricted extent, and using arrays for bounds and center + * var map = new OpenLayers.Map({ + * div: "map_id", + * projection: "EPSG:3857", + * maxExtent: [-18924313.432222, -15538711.094146, 18924313.432222, 15538711.094146], + * restrictedExtent: [-13358338.893333, -9608371.5085962, 13358338.893333, 9608371.5085962], + * center: [-12356463.476333, 5621521.4854095] + * }); + * + * // create a map without a reference to a container - call render later + * var map = new OpenLayers.Map({ + * projection: "EPSG:3857", + * maxExtent: new OpenLayers.Bounds(-200000, -200000, 200000, 200000) + * }); + * (end) + */ + constructor(id: HTMLElement, options?: MapOptions); + constructor(id: string, options?: MapOptions); + + /** + * APIMethod: getViewport + * Get the DOMElement representing the view port. + * + * Returns: + * {DOMElement} + */ + getViewport(): HTMLElement; + + /** + * APIMethod: render + * Render the map to a specified container. + * + * Parameters: + * div - {String|DOMElement} The container that the map should be rendered + * to. If different than the current container, the map viewport + * will be moved from the current to the new container. + */ + render(div: string): void; + render(div: HTMLElement): void; + + /** + * Method: unloadDestroy + * Function that is called to destroy the map on page unload. stored here + * so that if map is manually destroyed, we can unregister this. + */ + private unloadDestroy(): () => void; + + /** + * Method: updateSizeDestroy + * When the map is destroyed, we need to stop listening to updateSize + * events: this method stores the function we need to unregister in + * non-IE browsers. + */ + private updateSizeDestroy: () => void; + + /** + * APIMethod: destroy + * Destroy this map. + * Note that if you are using an application which removes a container + * of the map from the DOM, you need to ensure that you destroy the + * map *before* this happens; otherwise, the page unload handler + * will fail because the DOM elements that map.destroy() wants + * to clean up will be gone. (See + * http://trac.osgeo.org/openlayers/ticket/2277 for more information). + * This will apply to GeoExt and also to other applications which + * modify the DOM of the container of the OpenLayers Map. + */ + destroy(): void; + + /** + * APIMethod: setOptions + * Change the map options + * + * Parameters: + * options - {Object} Hashtable of options to tag to the map + */ + setOptions(options: {}); + + /** + * APIMethod: getTileSize + * Get the tile size for the map + * + * Returns: + * {} + */ + getTileSize(): Size; + + /** + * APIMethod: getBy + * Get a list of objects given a property and a match item. + * + * Parameters: + * array - {String} A property on the map whose value is an array. + * property - {String} A property on each item of the given array. + * match - {String | Object} A string to match. Can also be a regular + * expression literal or object. In addition, it can be any object + * with a method named test. For reqular expressions or other, if + * match.test(map[array][i][property]) evaluates to true, the item will + * be included in the array returned. If no items are found, an empty + * array is returned. + * + * Returns: + * {Array} An array of items where the given property matches the given + * criteria. + */ + getBy(array: string, property: string, match: string): Array; + getBy(array: string, property: string, match: Object): Array; + + /** + * APIMethod: getLayersBy + * Get a list of layers with properties matching the given criteria. + * + * Parameters: + * property - {String} A layer property to be matched. + * match - {String | Object} A string to match. Can also be a regular + * expression literal or object. In addition, it can be any object + * with a method named test. For reqular expressions or other, if + * match.test(layer[property]) evaluates to true, the layer will be + * included in the array returned. If no layers are found, an empty + * array is returned. + * + * Returns: + * {Array()} A list of layers matching the given criteria. + * An empty array is returned if no matches are found. + */ + getLayersBy(property: string, match: string): Layer[]; + getLayersBy(property: string, match: Object): Layer[]; + + /** + * APIMethod: getLayersByName + * Get a list of layers with names matching the given name. + * + * Parameters: + * match - {String | Object} A layer name. The name can also be a regular + * expression literal or object. In addition, it can be any object + * with a method named test. For reqular expressions or other, if + * name.test(layer.name) evaluates to true, the layer will be included + * in the list of layers returned. If no layers are found, an empty + * array is returned. + * + * Returns: + * {Array()} A list of layers matching the given name. + * An empty array is returned if no matches are found. + */ + getLayersByName(match: string): Layer[]; + getLayersByName(match: Object): Layer[]; + + /** + * APIMethod: getLayersByClass + * Get a list of layers of a given class (CLASS_NAME). + * + * Parameters: + * match - {String | Object} A layer class name. The match can also be a + * regular expression literal or object. In addition, it can be any + * object with a method named test. For reqular expressions or other, + * if type.test(layer.CLASS_NAME) evaluates to true, the layer will + * be included in the list of layers returned. If no layers are + * found, an empty array is returned. + * + * Returns: + * {Array()} A list of layers matching the given class. + * An empty array is returned if no matches are found. + */ + getLayersByClass(match: string): Layer[]; + getLayersByClass(match: Object): Layer[]; + + /** + * APIMethod: getControlsBy + * Get a list of controls with properties matching the given criteria. + * + * Parameters: + * property - {String} A control property to be matched. + * match - {String | Object} A string to match. Can also be a regular + * expression literal or object. In addition, it can be any object + * with a method named test. For reqular expressions or other, if + * match.test(layer[property]) evaluates to true, the layer will be + * included in the array returned. If no layers are found, an empty + * array is returned. + * + * Returns: + * {Array()} A list of controls matching the given + * criteria. An empty array is returned if no matches are found. + */ + getControlsBy(property: string, match: string): Control[]; + getControlsBy(property: string, match: Object): Control[]; + + /** + * APIMethod: getControlsByClass + * Get a list of controls of a given class (CLASS_NAME). + * + * Parameters: + * match - {String | Object} A control class name. The match can also be a + * regular expression literal or object. In addition, it can be any + * object with a method named test. For reqular expressions or other, + * if type.test(control.CLASS_NAME) evaluates to true, the control will + * be included in the list of controls returned. If no controls are + * found, an empty array is returned. + * + * Returns: + * {Array()} A list of controls matching the given class. + * An empty array is returned if no matches are found. + */ + getControlsByClass(match: string): Control[]; + getControlsByClass(match: Object): Control[]; + + /** + * APIMethod: getLayer + * Get a layer based on its id + * + * Parameters: + * id - {String} A layer id + * + * Returns: + * {} The Layer with the corresponding id from the map's + * layer collection, or null if not found. + */ + getLayer(id: string): Layer; + + /** + * Method: setLayerZIndex + * + * Parameters: + * layer - {} + * zIdx - {int} + */ + private setLayerZIndex(layer: Layer, zIdx: number): void; + + /** + * Method: resetLayersZIndex + * Reset each layer's z-index based on layer's array index + */ + private resetLayersZIndex(): void; + + /** + * APIMethod: addLayer + * + * Parameters: + * layer - {} + * + * Returns: + * {Boolean} True if the layer has been added to the map. */ addLayer(layer: Layer): boolean; /** - * Set the map center (and optionally, the zoom level). + * APIMethod: addLayers + * + * Parameters: + * layers - {Array()} */ - setCenter(lonlat: LonLat, zoom?: number, dragging?: boolean, forceZoomChange?: boolean): void; + addLayers(layers: Layer[]): void; /** - * Set the map center (and optionally, the zoom level). + * APIMethod: removeLayer + * Removes a layer from the map by removing its visual element (the + * layer.div property), then removing it from the map's internal list + * of layers, setting the layer's map property to null. + * + * a "removelayer" event is triggered. + * + * very worthy of mention is that simply removing a layer from a map + * will not cause the removal of any popups which may have been created + * by the layer. this is due to the fact that it was decided at some + * point that popups would not belong to layers. thus there is no way + * for us to know here to which layer the popup belongs. + * + * A simple solution to this is simply to call destroy() on the layer. + * the default OpenLayers.Layer class's destroy() function + * automatically takes care to remove itself from whatever map it has + * been attached to. + * + * The correct solution is for the layer itself to register an + * event-handler on "removelayer" and when it is called, if it + * recognizes itself as the layer being removed, then it cycles through + * its own personal list of popups, removing them from the map. + * + * Parameters: + * layer - {} + * setNewBaseLayer - {Boolean} Default is true */ + removeLayer(layer: Layer, setNewBaseLayer?: boolean): void; + + /** + * APIMethod: getNumLayers + * + * Returns: + * {Int} The number of layers attached to the map. + */ + getNumLayers(): number; + + /** + * APIMethod: getLayerIndex + * + * Parameters: + * layer - {} + * + * Returns: + * {Integer} The current (zero-based) index of the given layer in the map's + * layer stack. Returns -1 if the layer isn't on the map. + */ + getLayerIndex(layer: Layer): number; + + /** + * APIMethod: setLayerIndex + * Move the given layer to the specified (zero-based) index in the layer + * list, changing its z-index in the map display. Use + * map.getLayerIndex() to find out the current index of a layer. Note + * that this cannot (or at least should not) be effectively used to + * raise base layers above overlays. + * + * Parameters: + * layer - {} + * idx - {int} + */ + setLayerIndex(layer: Layer, idx: number): void; + + /** + * APIMethod: raiseLayer + * Change the index of the given layer by delta. If delta is positive, + * the layer is moved up the map's layer stack; if delta is negative, + * the layer is moved down. Again, note that this cannot (or at least + * should not) be effectively used to raise base layers above overlays. + * + * Paremeters: + * layer - {} + * delta - {int} + */ + raiseLayer(layer: Layer, delta: number): void; + + /** + * APIMethod: setBaseLayer + * Allows user to specify one of the currently-loaded layers as the Map's + * new base layer. + * + * Parameters: + * newBaseLayer - {} + */ + setBaseLayer(newBaseLayer): void; + + /** + * APIMethod: addControl + * Add the passed over control to the map. Optionally + * position the control at the given pixel. + * + * Parameters: + * control - {} + * px - {} + */ + addControl(control: Control, px: Pixel); + + /** + * APIMethod: addControls + * Add all of the passed over controls to the map. + * You can pass over an optional second array + * with pixel-objects to position the controls. + * The indices of the two arrays should match and + * you can add null as pixel for those controls + * you want to be autopositioned. + * + * Parameters: + * controls - {Array()} + * pixels - {Array()} + */ + addControls(controls: Control[], pixels: Pixel[]): void; + + /** + * Method: addControlToMap + * + * Parameters: + * + * control - {} + * px - {} + */ + private addControlToMap(control: Control, px: Pixel): void; + + /** + * APIMethod: getControl + * + * Parameters: + * id - {String} ID of the control to return. + * + * Returns: + * {} The control from the map's list of controls + * which has a matching 'id'. If none found, + * returns null. + */ + getControl(id: string): Control; + + /** + * APIMethod: removeControl + * Remove a control from the map. Removes the control both from the map + * object's internal array of controls, as well as from the map's + * viewPort (assuming the control was not added outsideViewport) + * + * Parameters: + * control - {} The control to remove. + */ + removeControl(control: Control): void; + + /** + * APIMethod: addPopup + * + * Parameters: + * popup - {} + * exclusive - {Boolean} If true, closes all other popups first + */ + addPopup(popup: Popup, exclusive: boolean); + + /** + * APIMethod: removePopup + * + * Parameters: + * popup - {} + */ + removePopup(popup: Popup): void; + + /** + * APIMethod: getSize + * + * Returns: + * {} An object that represents the + * size, in pixels, of the div into which OpenLayers + * has been loaded. + * Note - A clone() of this locally cached variable is + * returned, so as not to allow users to modify it. + */ + getSize(): Size; + + /** + * APIMethod: updateSize + * This function should be called by any external code which dynamically + * changes the size of the map div (because mozilla wont let us catch + * the "onresize" for an element) + */ + updateSize(): void; + + /** + * Method: getCurrentSize + * + * Returns: + * {} A new object with the dimensions + * of the map div + */ + private getCurrentSize(): Size; + + /** + * Method: calculateBounds + * + * Parameters: + * center - {} Default is this.getCenter() + * resolution - {float} Default is this.getResolution() + * + * Returns: + * {} A bounds based on resolution, center, and + * current mapsize. + */ + calculateBounds(center?: LonLat, resolution?: number): Bounds; + + /** + * APIMethod: getCenter + * + * Returns: + * {} + */ + getCenter(): LonLat; + + /** + * APIMethod: getZoom + * + * Returns: + * {Integer} + */ + getZoom(): number; + + /** + * APIMethod: pan + * Allows user to pan by a value of screen pixels + * + * Parameters: + * dx - {Integer} + * dy - {Integer} + * options - {Object} Options to configure panning: + * - *animate* {Boolean} Use panTo instead of setCenter. Default is true. + * - *dragging* {Boolean} Call setCenter with dragging true. Default is + * false. + */ + pan(dx: number, dy: number, options?: { animate?: boolean; dragging?: boolean }): void; + + /** + * APIMethod: panTo + * Allows user to pan to a new lonlat + * If the new lonlat is in the current extent the map will slide smoothly + * + * Parameters: + * lonlat - {} + */ + panTo(lonlat: LonLat): void; + + /** + * APIMethod: setCenter + * Set the map center (and optionally, the zoom level). + * + * Parameters: + * lonlat - {|Array} The new center location. + * If provided as array, the first value is the x coordinate, + * and the 2nd value is the y coordinate. + * zoom - {Integer} Optional zoom level. + * dragging - {Boolean} Specifies whether or not to trigger + * movestart/end events + * forceZoomChange - {Boolean} Specifies whether or not to trigger zoom + * change events (needed on baseLayer change) + */ + setCenter(lonlat: LonLat, zoom?: number, dragging?: boolean, forceZoomChange?: boolean): void; setCenter(lonlat: number[], zoom?: number, dragging?: boolean, forceZoomChange?: boolean): void; /** + * APIMethod: getMinZoom + * Returns the minimum zoom level for the current map view. If the base + * layer is configured with set to true, this will be the + * first zoom level that shows no more than one world width in the current + * map viewport. Components that rely on this value (e.g. zoom sliders) + * should also listen to the map's "updatesize" event and call this method + * in the "updatesize" listener. + * + * Returns: + * {Number} Minimum zoom level that shows a map not wider than its + * 's maxExtent. This is an Integer value, unless the map is + * configured with set to true. + */ + getMinZoom(): number; + + /** + * APIMethod: getProjection + * This method returns a string representing the projection. In + * the case of projection support, this will be the srsCode which + * is loaded -- otherwise it will simply be the string value that + * was passed to the projection at startup. + * + * Returns: + * {String} The Projection string from the base layer or null. + */ + getProjection(): string; + + /** + * APIMethod: getProjectionObject + * Returns the projection obect from the baselayer. + * + * Returns: + * {} The Projection of the base layer. + */ + getProjectionObject(): Projection; + + /** + * APIMethod: getMaxResolution + * + * Returns: + * {String} The Map's Maximum Resolution + */ + getMaxResolution(): string; + + /** + * APIMethod: getMaxExtent + * + * Parameters: + * options - {Object} + * + * Allowed Options: + * restricted - {Boolean} If true, returns restricted extent (if it is + * available.) + * + * Returns: + * {} The maxExtent property as set on the current + * baselayer, unless the 'restricted' option is set, in which case + * the 'restrictedExtent' option from the map is returned (if it + * is set). + */ + getMaxExtent(options: { restricted: boolean }): Bounds; + + /** + * APIMethod: getNumZoomLevels + * + * Returns: + * {Integer} The total number of zoom levels that can be displayed by the + * current baseLayer. + */ + getNumZoomLevels(): number; + + /** + * APIMethod: getExtent + * + * Returns: + * {} A Bounds object which represents the lon/lat + * bounds of the current viewPort. + * If no baselayer is set, returns null. + */ + getExtent(): Bounds; + + /** + * APIMethod: getResolution + * + * Returns: + * {Float} The current resolution of the map. + * If no baselayer is set, returns null. + */ + getResolution(): number; + + /** + * APIMethod: getUnits + * + * Returns: + * {Float} The current units of the map. + * If no baselayer is set, returns null. + */ + getUnits(): number; + + /** + * APIMethod: getScale + * + * Returns: + * {Float} The current scale denominator of the map. + * If no baselayer is set, returns null. + */ + getScale(): number; + + /** + * APIMethod: getZoomForExtent + * + * Parameters: + * bounds - {} + * closest - {Boolean} Find the zoom level that most closely fits the + * specified bounds. Note that this may result in a zoom that does + * not exactly contain the entire extent. + * Default is false. + * + * Returns: + * {Integer} A suitable zoom level for the specified bounds. + * If no baselayer is set, returns null. + */ + getZoomForExtent(bounds: Bounds, closest?: boolean): number; + + /** + * APIMethod: getResolutionForZoom + * + * Parameters: + * zoom - {Float} + * + * Returns: + * {Float} A suitable resolution for the specified zoom. If no baselayer + * is set, returns null. + */ + getResolutionForZoom(zoom: number): number; + + /** + * APIMethod: getZoomForResolution + * + * Parameters: + * resolution - {Float} + * closest - {Boolean} Find the zoom level that corresponds to the absolute + * closest resolution, which may result in a zoom whose corresponding + * resolution is actually smaller than we would have desired (if this + * is being called from a getZoomForExtent() call, then this means that + * the returned zoom index might not actually contain the entire + * extent specified... but it'll be close). + * Default is false. + * + * Returns: + * {Integer} A suitable zoom level for the specified resolution. + * If no baselayer is set, returns null. + */ + getZoomForResolution(resolution: number, closest?: boolean): number; + + /** + * APIMethod: zoomTo + * Zoom to a specific zoom level. Zooming will be animated unless the map + * is configured with {zoomMethod: null}. To zoom without animation, use + * without a lonlat argument. + * + * Parameters: + * zoom - {Integer} + */ + zoomTo(zoom: number, px: Pixel): void; + + /** + * APIMethod: zoomIn * */ - prop: string; -======= ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 + zoomIn(): void; + + /** + * APIMethod: zoomOut + * + */ + zoomOut(): void; + + /** + * APIMethod: zoomToExtent + * Zoom to the passed in bounds, recenter + * + * Parameters: + * bounds - {|Array} If provided as an array, the array + * should consist of four values (left, bottom, right, top). + * closest - {Boolean} Find the zoom level that most closely fits the + * specified bounds. Note that this may result in a zoom that does + * not exactly contain the entire extent. + * Default is false. + * + */ + zoomToExtent(bounds: Bounds, closest?: boolean): void; + zoomToExtent(bounds: number[], closest?: boolean): void; + + /** + * APIMethod: zoomToMaxExtent + * Zoom to the full extent and recenter. + * + * Parameters: + * options - {Object} + * + * Allowed Options: + * restricted - {Boolean} True to zoom to restricted extent if it is + * set. Defaults to true. + */ + zoomToMaxExtent(options?: { restricted: boolean }): void; + + /** + * APIMethod: zoomToScale + * Zoom to a specified scale + * + * Parameters: + * scale - {float} + * closest - {Boolean} Find the zoom level that most closely fits the + * specified scale. Note that this may result in a zoom that does + * not exactly contain the entire extent. + * Default is false. + * + */ + zoomToScale(scale: number, closest: boolean): void; + + /** + * APIMethod: getViewPortPxFromLonLat + * + * Parameters: + * lonlat - {} + * + * Returns: + * {} An OpenLayers.Pixel which is the passed-in + * , translated into view port + * pixels by the current base layer. + */ + getViewPortPxFromLonLat(lonlat: LonLat): Pixel; + + /** + * APIMethod: getLonLatFromPixel + * + * Parameters: + * px - {|Object} An OpenLayers.Pixel or an object with + * a 'x' and 'y' properties. + * + * Returns: + * {} An OpenLayers.LonLat corresponding to the given + * OpenLayers.Pixel, translated into lon/lat by the + * current base layer + */ + getLonLatFromPixel(px: Pixel): LonLat; + getLonLatFromPixel(px: { x: number; y: number }): LonLat; + + /** + * APIMethod: getPixelFromLonLat + * Returns a pixel location given a map location. The map location is + * translated to an integer pixel location (in viewport pixel + * coordinates) by the current base layer. + * + * Parameters: + * lonlat - {} A map location. + * + * Returns: + * {} An OpenLayers.Pixel corresponding to the + * translated into view port pixels by the current + * base layer. + */ + getPixelFromLonLat(lonlat: LonLat): Pixel; + + /** + * APIMethod: getViewPortPxFromLayerPx + * + * Parameters: + * layerPx - {} + * + * Returns: + * {} Layer Pixel translated into ViewPort Pixel + * coordinates + */ + getViewPortPxFromLayerPx(layerPx: Pixel): Pixel; + + /** + * APIMethod: getLayerPxFromViewPortPx + * + * Parameters: + * viewPortPx - {} + * + * Returns: + * {} ViewPort Pixel translated into Layer Pixel + * coordinates + */ + getLayerPxFromViewPortPx(viewPortPx: Pixel): Pixel; + + /** + * APIMethod: getLayerPxFromLonLat + * + * Parameters: + * lonlat - {} lonlat + * + * Returns: + * {} An OpenLayers.Pixel which is the passed-in + * , translated into layer pixels + * by the current base layer + */ + getLayerPxFromLonLat(lonlat: LonLat): Pixel; + + static TILE_WIDTH: string; + + static TILE_HEIGHT: string; } export class Class { @@ -1054,259 +2418,452 @@ declare module OpenLayers { } export class Date { + /** + * APIProperty: dateRegEx + * The regex to be used for validating dates. You can provide your own + * regex for instance for adding support for years before BC. Default + * value is: /^(?:(\d{4})(?:-(\d{2})(?:-(\d{2}))?)?)?(?:(?:T(\d{1,2}):(\d{2}):(\d{2}(?:\.\d+)?)(Z|(?:[+-]\d{1,2}(?::(\d{2}))?)))|Z)?$/ + */ + dateRegEx: string; + /** + * APIMethod: toISOString + * Generates a string representing a date. The format of the string follows + * the profile of ISO 8601 for date and time on the Internet (see + * http://tools.ietf.org/html/rfc3339). If the toISOString method is + * available on the Date prototype, that is used. The toISOString + * method for Date instances is defined in ECMA-262. + * + * Parameters: + * date - {Date} A date object. + * + * Returns: + * {String} A string representing the date (e.g. + * "2010-08-07T16:58:23.123Z"). If the date does not have a valid time + * (i.e. isNaN(date.getTime())) this method returns the string "Invalid + * Date". The ECMA standard says the toISOString method should throw + * RangeError in this case, but Firefox returns a string instead. For + * best results, use isNaN(date.getTime()) to determine date validity + * before generating date strings. + */ + toISOString(date: Date): string; + + /** + * APIMethod: parse + * Generate a date object from a string. The format for the string follows + * the profile of ISO 8601 for date and time on the Internet (see + * http://tools.ietf.org/html/rfc3339). We don't call the native + * Date.parse because of inconsistency between implmentations. In + * Chrome, calling Date.parse with a string that doesn't contain any + * indication of the timezone (e.g. "2011"), the date is interpreted + * in local time. On Firefox, the assumption is UTC. + * + * Parameters: + * str - {String} A string representing the date (e.g. + * "2010", "2010-08", "2010-08-07", "2010-08-07T16:58:23.123Z", + * "2010-08-07T11:58:23.123-06"). + * + * Returns: + * {Date} A date object. If the string could not be parsed, an invalid + * date is returned (i.e. isNaN(date.getTime())). + */ + parse(str: string): Date; } export class Element { + /** + * APIFunction: visible + * + * Parameters: + * element - {DOMElement} + * + * Returns: + * {Boolean} Is the element visible? + */ + visible(element: HTMLElement): boolean; + /** + * APIFunction: toggle + * Toggle the visibility of element(s) passed in + * + * Parameters: + * element - {DOMElement} Actually user can pass any number of elements + */ + toggle(element: HTMLElement): void; + + /** + * APIFunction: remove + * Remove the specified element from the DOM. + * + * Parameters: + * element - {DOMElement} + */ + remove(element: HTMLElement): void; + + /** + * APIFunction: getHeight + * + * Parameters: + * element - {DOMElement} + * + * Returns: + * {Integer} The offset height of the element passed in + */ + getHeight(element: HTMLElement): number; + + /** + * Function: hasClass + * Tests if an element has the given CSS class name. + * + * Parameters: + * element - {DOMElement} A DOM element node. + * name - {String} The CSS class name to search for. + * + * Returns: + * {Boolean} The element has the given class name. + */ + hasClass(element: HTMLElement, name: string): boolean; + + /** + * Function: addClass + * Add a CSS class name to an element. Safe where element already has + * the class name. + * + * Parameters: + * element - {DOMElement} A DOM element node. + * name - {String} The CSS class name to add. + * + * Returns: + * {DOMElement} The element. + */ + addClass(element: HTMLElement, name: string): HTMLElement; + + /** + * Function: removeClass + * Remove a CSS class name from an element. Safe where element does not + * have the class name. + * + * Parameters: + * element - {DOMElement} A DOM element node. + * name - {String} The CSS class name to remove. + * + * Returns: + * {DOMElement} The element. + */ + removeClass(element: HTMLElement, name: string): HTMLElement; + + /** + * Function: toggleClass + * Remove a CSS class name from an element if it exists. Add the class name + * if it doesn't exist. + * + * Parameters: + * element - {DOMElement} A DOM element node. + * name - {String} The CSS class name to toggle. + * + * Returns: + * {DOMElement} The element. + */ + toggleClass(element: HTMLElement, name: string): HTMLElement; + + /** + * APIFunction: getStyle + * + * Parameters: + * element - {DOMElement} + * style - {?} + * + * Returns: + * {?} + */ + getStyle(element: HTMLElement, style: any): any; } export class Pixel { + /** + * APIProperty: x + * {Number} The x coordinate + */ + x: number; + /** + * APIProperty: y + * {Number} The y coordinate + */ + y: number; + + /** + * Constructor: OpenLayers.Pixel + * Create a new OpenLayers.Pixel instance + * + * Parameters: + * x - {Number} The x coordinate + * y - {Number} The y coordinate + * + * Returns: + * An instance of OpenLayers.Pixel + */ + constructor(x: number, y: number); + + /** + * APIMethod: clone + * Return a clone of this pixel object + * + * Returns: + * {} A clone pixel + */ + clone(): Pixel; + + /** + * APIMethod: equals + * Determine whether one pixel is equivalent to another + * + * Parameters: + * px - {|Object} An OpenLayers.Pixel or an object with + * a 'x' and 'y' properties. + * + * Returns: + * {Boolean} The point passed in as parameter is equal to this. Note that + * if px passed in is null, returns false. + */ + equals(px: Pixel): boolean; + equals(px: { x: number; y: number }): boolean; + + /** + * APIMethod: distanceTo + * Returns the distance to the pixel point passed in as a parameter. + * + * Parameters: + * px - {} + * + * Returns: + * {Float} The pixel point passed in as parameter to calculate the + * distance to. + */ + distanceTo(px: Pixel): number; + + /** + * APIMethod: add + * + * Parameters: + * x - {Integer} + * y - {Integer} + * + * Returns: + * {} A new Pixel with this pixel's x&y augmented by the + * values passed in. + */ + add(x: number, y: number): Pixel; + + /** + * APIMethod: offset + * + * Parameters + * px - {|Object} An OpenLayers.Pixel or an object with + * a 'x' and 'y' properties. + * + * Returns: + * {} A new Pixel with this pixel's x&y augmented by the + * x&y values of the pixel passed in. + */ + offset(px: Pixel): Pixel; + offset(px: { x: number; y: number }): Pixel; + + CLASS_NAME: string; } export class Size { + /** + * APIProperty: w + * {Number} width + */ + w: number; + /** + * APIProperty: h + * {Number} height + */ + h: number; + + /** + * Constructor: OpenLayers.Size + * Create an instance of OpenLayers.Size + * + * Parameters: + * w - {Number} width + * h - {Number} height + */ + constructor(w: number, h: number); + + /** + * Method: toString + * Return the string representation of a size object + * + * Returns: + * {String} The string representation of OpenLayers.Size object. + * (e.g. "w=55,h=66") + */ + toString(): string; + + /** + * APIMethod: clone + * Create a clone of this size object + * + * Returns: + * {} A new OpenLayers.Size object with the same w and h + * values + */ + clone(): Size; + + /** + * + * APIMethod: equals + * Determine where this size is equal to another + * + * Parameters: + * sz - {|Object} An OpenLayers.Size or an object with + * a 'w' and 'h' properties. + * + * Returns: + * {Boolean} The passed in size has the same h and w properties as this one. + * Note that if sz passed in is null, returns false. + */ + equals(sz: Size): boolean; + + CLASS_NAME: string; } module Geometry { export class Collection extends Geometry { /** -<<<<<<< HEAD * The component parts of this geometry -======= - *The component parts of this geometry ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ components: Geometry[]; /** -<<<<<<< HEAD * An array of class names representing the types of * components that the collection can include. A null value means the * component types are not restricted. -======= - *An array of class names representing the types of - *components that the collection can include. A null value means the - *component types are not restricted. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ componentTypes: string[]; /** -<<<<<<< HEAD * Creates a Geometry Collection -- a list of geoms. -======= - *Creates a Geometry Collection -- a list of geoms. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(components: Geometry[]); /** -<<<<<<< HEAD * Destroy this geometry. -======= - *Destroy this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ destroy(): void; /** -<<<<<<< HEAD * Clone this geometry. -======= - *Clone this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Collection; /** -<<<<<<< HEAD * Get a string representing the components for this collection -======= - *Get a string representing the components for this collection ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getComponentsString(): string; /** -<<<<<<< HEAD * Recalculate the bounds by iterating through the components and * calling calling extendBounds() on each item. -======= - *Recalculate the bounds by iterating through the components and - *calling calling extendBounds() on each item. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ calculateBounds(); /** -<<<<<<< HEAD * Add components to this geometry. -======= - *Add components to this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addComponents(components: Geometry[]); /** -<<<<<<< HEAD * Add a new component (geometry) to the collection. If this.componentTypes * is set, then the component class name must be in the componentTypes array. -======= - *Add a new component (geometry) to the collection. If this.componentTypes - *is set, then the component class name must be in the componentTypes array. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ addComponent(component: Geometry, index: number): boolean; /** -<<<<<<< HEAD * Remove components from this geometry. -======= - *Remove components from this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ removeComponents(components: Geometry[]): boolean; /** -<<<<<<< HEAD * Remove a component from this geometry. -======= - *Remove a component from this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ removeComponent(component: Geometry): boolean; /** -<<<<<<< HEAD * Calculate the length of this geometry -======= - *Calculate the length of this geometry ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getLength(): number; /** -<<<<<<< HEAD * Calculate the area of this geometry. Note how this function is overridden * in . -======= - *Calculate the area of this geometry. Note how this function is overridden - *in . ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getArea(): number; /** -<<<<<<< HEAD * Calculate the approximate area of the polygon were it projected onto * the earth. -======= - *Calculate the approximate area of the polygon were it projected onto - *the earth. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getGeodesicArea(projection: Projection): number; /** -<<<<<<< HEAD * Compute the centroid for this geometry collection. -======= - *Compute the centroid for this geometry collection. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getCentroid(weighted?: boolean): Point; /** -<<<<<<< HEAD * Calculate the approximate length of the geometry were it projected onto * the earth. -======= - *Calculate the approximate length of the geometry were it projected onto - *the earth. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getGeodesicLength(projection: Projection): number; /** -<<<<<<< HEAD * Moves a geometry by the given displacement along positive x and y axes. * This modifies the position of the geometry and clears the cached * bounds. -======= - *Moves a geometry by the given displacement along positive x and y axes. - *This modifies the position of the geometry and clears the cached - *bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ move(x: number, y: number): void; /** -<<<<<<< HEAD * Rotate a geometry around some origin -======= - *Rotate a geometry around some origin ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ rotate(angle: number, origin: Point); /** -<<<<<<< HEAD * Resize a geometry relative to some origin. Use this method to apply * a uniform scaling to a geometry. -======= - *Resize a geometry relative to some origin. Use this method to apply - *a uniform scaling to a geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ resize(scale: number, origin: Point, ratio: number): Geometry; /** -<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). -======= - *Calculate the closest distance between two geometries (on the x-y plane). ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: DistanceOptions): Object; /** -<<<<<<< HEAD * Determine whether another geometry is equivalent to this one. Geometries * are considered equivalent if all components have the same coordinates. -======= - *Determine whether another geometry is equivalent to this one. Geometries - *are considered equivalent if all components have the same coordinates. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(geometry: Geometry): boolean; /** -<<<<<<< HEAD * Reproject the components geometry from source to dest. -======= - *Reproject the components geometry from source to dest. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Geometry; /** -<<<<<<< HEAD * Determine if the input geometry intersects this one. -======= - *Determine if the input geometry intersects this one. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersects(geometry: Geometry): boolean; /** -<<<<<<< HEAD * Return a list of all points in this geometry. -======= - *Return a list of all points in this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; @@ -1320,101 +2877,57 @@ declare module OpenLayers { y: number; /** -<<<<<<< HEAD * Construct a point geometry. -======= - *Construct a point geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ constructor(x: number, y: number); /** -<<<<<<< HEAD * Create a clone of this geometry. -======= - *Create a clone of this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(): Geometry; /** -<<<<<<< HEAD * An exact clone of this OpenLayers.Geometry.Point -======= - *An exact clone of this OpenLayers.Geometry.Point ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ clone(obj: Point): Point; /** -<<<<<<< HEAD * Calculate the closest distance between two geometries (on the x-y plane). -======= - *Calculate the closest distance between two geometries (on the x-y plane). ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ distanceTo(geometry: Geometry, options: DistanceOptions): Object; /** -<<<<<<< HEAD * Determine whether another geometry is equivalent to this one. Geometries are considered equivalent if all components have the same coordinates. -======= - *Determine whether another geometry is equivalent to this one. Geometries are considered equivalent if all components have the same coordinates. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ equals(geom: Point): boolean; /** -<<<<<<< HEAD * Moves a geometry by the given displacement along positive x and y axes. This modifies the position of the geometry and clears the cached bounds. -======= - *Moves a geometry by the given displacement along positive x and y axes. This modifies the position of the geometry and clears the cached bounds. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ move(x: number, y: number): void; /** -<<<<<<< HEAD * Rotate a point around another. -======= - *Rotate a point around another. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ rotate(angle: number, origin: Point); /** -<<<<<<< HEAD * Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses. -======= - *Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ resize(scale: number, origin: Point, ratio: number): Geometry; /** -<<<<<<< HEAD * Determine if the input geometry intersects this one. -======= - *Determine if the input geometry intersects this one. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ intersects(geometry: Geometry): boolean; /** -<<<<<<< HEAD * Translate the x,y properties of the point from source to dest. -======= - *Translate the x,y properties of the point from source to dest. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ transform(source: Projection, dest: Projection): Geometry; /** -<<<<<<< HEAD * Return a list of all points in this geometry. -======= - *Return a list of all points in this geometry. ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 */ getVertices(nodes: boolean): Array; } @@ -1871,7 +3384,6 @@ declare module OpenLayers { } module Layer { -<<<<<<< HEAD export interface WMSGetMapParams { version?: string; exceptions?: string; @@ -1895,8 +3407,6 @@ declare module OpenLayers { crossOriginKeyword?: string; } -======= ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class ArcGIS93Rest { } export class ArcGISCache { } export class ArcIMS { } @@ -1906,15 +3416,712 @@ declare module OpenLayers { export class FixedZoomLevels { } export class GeoRSS { } export class Google { } - export class Grid { } - export class HTTPRequest { } + + export class Grid extends HTTPRequest { + /** + * APIProperty: tileSize + * {} + */ + tileSize: Size; + + /** + * Property: tileOriginCorner + * {String} If the property is not provided, the tile origin + * will be derived from the layer's . The corner of the + * used is determined by this property. Acceptable values + * are "tl" (top left), "tr" (top right), "bl" (bottom left), and "br" + * (bottom right). Default is "bl". + */ + tileOriginCorner: string; + + /** + * APIProperty: tileOrigin + * {} Optional origin for aligning the grid of tiles. + * If provided, requests for tiles at all resolutions will be aligned + * with this location (no tiles shall overlap this location). If + * not provided, the grid of tiles will be aligned with the layer's + * . Default is ``null``. + */ + tileOrigin: LonLat; + + /** APIProperty: tileOptions + * {Object} optional configuration options for instances + * created by this Layer, if supported by the tile class. + */ + tileOptions: Object; + + /** + * APIProperty: tileClass + * {} The tile class to use for this layer. + * Defaults is OpenLayers.Tile.Image. + */ + tileClass: OpenLayers.Tile; + + /** + * Property: grid + * {Array(Array())} This is an array of rows, each row is + * an array of tiles. + */ + grid: OpenLayers.Tile[][]; + + /** + * APIProperty: singleTile + * {Boolean} Moves the layer into single-tile mode, meaning that one tile + * will be loaded. The tile's size will be determined by the 'ratio' + * property. When the tile is dragged such that it does not cover the + * entire viewport, it is reloaded. + */ + singleTile: boolean; + + /** APIProperty: ratio + * {Float} Used only when in single-tile mode, this specifies the + * ratio of the size of the single tile to the size of the map. + * Default value is 1.5. + */ + ratio: number; + + /** + * APIProperty: buffer + * {Integer} Used only when in gridded mode, this specifies the number of + * extra rows and columns of tiles on each side which will + * surround the minimum grid tiles to cover the map. + * For very slow loading layers, a larger value may increase + * performance somewhat when dragging, but will increase bandwidth + * use significantly. + */ + buffer: number; + + /** + * APIProperty: transitionEffect + * {String} The transition effect to use when the map is zoomed. + * Two posible values: + * + * "resize" - Existing tiles are resized on zoom to provide a visual + * effect of the zoom having taken place immediately. As the + * new tiles become available, they are drawn on top of the + * resized tiles (this is the default setting). + * "map-resize" - Existing tiles are resized on zoom and placed below the + * base layer. New tiles for the base layer will cover existing tiles. + * This setting is recommended when having an overlay duplicated during + * the transition is undesirable (e.g. street labels or big transparent + * fills). + * null - No transition effect. + * + * Using "resize" on non-opaque layers can cause undesired visual + * effects. Set transitionEffect to null in this case. + */ + transitionEffect: string; + + /** + * APIProperty: numLoadingTiles + * {Integer} How many tiles are still loading? + */ + numLoadingTiles: number; + + /** + * Property: serverResolutions + * {Array(Number}} This property is documented in subclasses as + * an API property. + */ + serverResolutions: number[]; + + /** + * Property: loading + * {Boolean} Indicates if tiles are being loaded. + */ + loading: boolean; + + /** + * Property: backBuffer + * {DOMElement} The back buffer. + */ + backBuffer: HTMLElement; + + /** + * Property: gridResolution + * {Number} The resolution of the current grid. Used for backbuffer and + * client zoom. This property is updated every time the grid is + * initialized. + */ + gridResolution: number; + + /** + * Property: backBufferResolution + * {Number} The resolution of the current back buffer. This property is + * updated each time a back buffer is created. + */ + backBufferResolution: number; + + /** + * Property: backBufferLonLat + * {Object} The top-left corner of the current back buffer. Includes lon + * and lat properties. This object is updated each time a back buffer + * is created. + */ + backBufferLonLat: { lon: number; lat: number }; + + /** + * Property: backBufferTimerId + * {Number} The id of the back buffer timer. This timer is used to + * delay the removal of the back buffer, thereby preventing + * flash effects caused by tile animation. + */ + backBufferTimerId: number; + + /** + * APIProperty: removeBackBufferDelay + * {Number} Delay for removing the backbuffer when all tiles have finished + * loading. Can be set to 0 when no css opacity transitions for the + * olTileImage class are used. Default is 0 for layers, + * 2500 for tiled layers. See for more information on + * tile animation. + */ + removeBackBufferDelay: number; + + /** + * APIProperty: className + * {String} Name of the class added to the layer div. If not set in the + * options passed to the constructor then className defaults to + * "olLayerGridSingleTile" for single tile layers (see ), + * and "olLayerGrid" for non single tile layers. + * + * Note: + * + * The displaying of tiles is not animated by default for single tile + * layers - OpenLayers' default theme (style.css) includes this: + * (code) + * .olLayerGrid .olTileImage { + * -webkit-transition: opacity 0.2s linear; + * -moz-transition: opacity 0.2s linear; + * -o-transition: opacity 0.2s linear; + * transition: opacity 0.2s linear; + * } + * (end) + * To animate tile displaying for any grid layer the following + * CSS rule can be used: + * (code) + * .olTileImage { + * -webkit-transition: opacity 0.2s linear; + * -moz-transition: opacity 0.2s linear; + * -o-transition: opacity 0.2s linear; + * transition: opacity 0.2s linear; + * } + * (end) + * In that case, to avoid flash effects, + * should not be zero. + */ + className: string; + + /** + * Property: gridLayout + * {Object} Object containing properties tilelon, tilelat, startcol, + * startrow + */ + gridLayout: { tilelon: number; tilelat: number; startcol: number; startrow: number; }; + + /** + * Property: rowSign + * {Number} 1 for grids starting at the top, -1 for grids starting at the + * bottom. This is used for several grid index and offset calculations. + */ + rowSign: number; + + /** + * Property: transitionendEvents + * {Array} Event names for transitionend + */ + transitionendEvents: string[]; + + /** + * Constructor: OpenLayers.Layer.Grid + * Create a new grid layer + * + * Parameters: + * name - {String} + * url - {String} + * params - {Object} + * options - {Object} Hashtable of extra options to tag onto the layer + */ + constructor(name: string, url: string, params: {}, options: {}); + + /** + * Method: initProperties + * Set any properties that depend on the value of singleTile. + * Currently sets removeBackBufferDelay and className + */ + private initProperties(): void; + + /** + * Method: setMap + * + * Parameters: + * map - {} The map. + */ + setMap(map: Map): void; + + /** + * Method: removeMap + * Called when the layer is removed from the map. + * + * Parameters: + * map - {} The map. + */ + removeMap(map: Map): void; + + /** + * APIMethod: destroy + * Deconstruct the layer and clear the grid. + */ + destroy(): void; + + /** + * Method: clearGrid + * Go through and remove all tiles from the grid, calling + * destroy() on each of them to kill circular references + */ + private clearGrid(): void; + + /** + * APIMethod: addOptions + * + * Parameters: + * newOptions - {Object} + * reinitialize - {Boolean} If set to true, and if resolution options of the + * current baseLayer were changed, the map will be recentered to make + * sure that it is displayed with a valid resolution, and a + * changebaselayer event will be triggered. + */ + addOptions(newOptions: {}, reinitialize: boolean): void; + + /** + * APIMethod: clone + * Create a clone of this layer + * + * Parameters: + * obj - {Object} Is this ever used? + * + * Returns: + * {} An exact clone of this OpenLayers.Layer.Grid + */ + clone(obj?: Object): Layer.Grid; + + /** + * Method: moveTo + * This function is called whenever the map is moved. All the moving + * of actual 'tiles' is done by the map, but moveTo's role is to accept + * a bounds and make sure the data that that bounds requires is pre-loaded. + * + * Parameters: + * bounds - {} + * zoomChanged - {Boolean} + * dragging - {Boolean} + */ + moveTo(bounds: Bounds, zoomChanged: boolean, dragging: boolean): void; + + /** + * Method: getTileData + * Given a map location, retrieve a tile and the pixel offset within that + * tile corresponding to the location. If there is not an existing + * tile in the grid that covers the given location, null will be + * returned. + * + * Parameters: + * loc - {} map location + * + * Returns: + * {Object} Object with the following properties: tile ({}), + * i ({Number} x-pixel offset from top left), and j ({Integer} y-pixel + * offset from top left). + */ + private getTileData(loc: LonLat): { tile: Tile; i: number; j: number }; + + /** + * Method: destroyTile + * + * Parameters: + * tile - {} + */ + private destroyTile(tile: Tile): void; + + /** + * Method: getServerResolution + * Return the closest server-supported resolution. + * + * Parameters: + * resolution - {Number} The base resolution. If undefined the + * map resolution is used. + * + * Returns: + * {Number} The closest server resolution value. + */ + private getServerResolution(resolution: number): number; + + /** + * Method: getServerZoom + * Return the zoom value corresponding to the best matching server + * resolution, taking into account and . + * + * Returns: + * {Number} The closest server supported zoom. This is not the map zoom + * level, but an index of the server's resolutions array. + */ + private getServerZoom(): number; + + /** + * Method: applyBackBuffer + * Create, insert, scale and position a back buffer for the layer. + * + * Parameters: + * resolution - {Number} The resolution to transition to. + */ + private applyBackBuffer(resolution: number): void; + + /** + * Method: createBackBuffer + * Create a back buffer. + * + * Returns: + * {DOMElement} The DOM element for the back buffer, undefined if the + * grid isn't initialized yet. + */ + private createBackBuffer(): HTMLElement; + + /** + * Method: removeBackBuffer + * Remove back buffer from DOM. + */ + private removeBackBuffer(): void; + + /** + * Method: moveByPx + * Move the layer based on pixel vector. + * + * Parameters: + * dx - {Number} + * dy - {Number} + */ + moveByPx(dx: number, dy: number): void; + + /** + * APIMethod: setTileSize + * Check if we are in singleTile mode and if so, set the size as a ratio + * of the map size (as specified by the layer's 'ratio' property). + * + * Parameters: + * size - {} + */ + setTileSize(size: Size): void; + + /** + * APIMethod: getTilesBounds + * Return the bounds of the tile grid. + * + * Returns: + * {} A Bounds object representing the bounds of all the + * currently loaded tiles (including those partially or not at all seen + * onscreen). + */ + getTilesBounds(): Bounds; + + /** + * Method: initSingleTile + * + * Parameters: + * bounds - {} + */ + private initSingleTile(bounds: Bounds); + + /** + * Method: calculateGridLayout + * Generate parameters for the grid layout. + * + * Parameters: + * bounds - {|Object} OpenLayers.Bounds or an + * object with a 'left' and 'top' properties. + * origin - {|Object} OpenLayers.LonLat or an + * object with a 'lon' and 'lat' properties. + * resolution - {Number} + * + * Returns: + * {Object} Object containing properties tilelon, tilelat, startcol, + * startrow + */ + private calculateGridLayout(bounds: Bounds, origin: LonLat, resolution: number): { tilelon: number; tilelat: number; startcol: number; startrow: number }; + + getImageSize(): Size; + + /** + * Method: getTileOrigin + * Determine the origin for aligning the grid of tiles. If a + * property is supplied, that will be returned. Otherwise, the origin + * will be derived from the layer's property. In this case, + * the tile origin will be the corner of the given by the + * property. + * + * Returns: + * {} The tile origin. + */ + private getTileOrigin(): LonLat; + + /** + * Method: getTileBoundsForGridIndex + * + * Parameters: + * row - {Number} The row of the grid + * col - {Number} The column of the grid + * + * Returns: + * {} The bounds for the tile at (row, col) + */ + private getTileBoundsForGridIndex(row: number, col: number): Bounds; + + /** + * Method: initGriddedTiles + * + * Parameters: + * bounds - {} + */ + private initGriddedTiles(bounds: Bounds): void; + + /** + * Method: getMaxExtent + * Get this layer's maximum extent. (Implemented as a getter for + * potential specific implementations in sub-classes.) + * + * Returns: + * {} + */ + private getMaxExtent(): Bounds; + + /** + * APIMethod: addTile + * Create a tile, initialize it, and add it to the layer div. + * + * Parameters + * bounds - {} + * position - {} + * + * Returns: + * {} The added OpenLayers.Tile + */ + addTile(bounds: Bounds, position: number): Tile; + + /** + * Method: addTileMonitoringHooks + * This function takes a tile as input and adds the appropriate hooks to + * the tile so that the layer can keep track of the loading tiles. + * + * Parameters: + * tile - {} + */ + private addTileMonitoringHooks(tile: Tile): void; + + /** + * Method: removeTileMonitoringHooks + * This function takes a tile as input and removes the tile hooks + * that were added in addTileMonitoringHooks() + * + * Parameters: + * tile - {} + */ + private removeTileMonitoringHooks(tile: Tile): void; + + /** + * Method: moveGriddedTiles + */ + private moveGriddedTiles(): void; + + /** + * Method: shiftRow + * Shifty grid work + * + * Parameters: + * prepend - {Boolean} if true, prepend to beginning. + * if false, then append to end + * tileSize - {Object} rendered tile size; object with w and h properties + */ + private shiftRow(prepend: boolean, tileSize: { w: number; h: number }): void; + + /** + * Method: shiftColumn + * Shift grid work in the other dimension + * + * Parameters: + * prepend - {Boolean} if true, prepend to beginning. + * if false, then append to end + * tileSize - {Object} rendered tile size; object with w and h properties + */ + private shiftColumn(prepend: boolean, tileSize: { w: number; h: number }): void; + + /** + * Method: removeExcessTiles + * When the size of the map or the buffer changes, we may need to + * remove some excess rows and columns. + * + * Parameters: + * rows - {Integer} Maximum number of rows we want our grid to have. + * columns - {Integer} Maximum number of columns we want our grid to have. + */ + private removeExcessTiles(rows: number, columns: number): void; + + /** + * Method: onMapResize + * For singleTile layers, this will set a new tile size according to the + * dimensions of the map pane. + */ + onMapResize(): void; + + /** + * APIMethod: getTileBounds + * Returns The tile bounds for a layer given a pixel location. + * + * Parameters: + * viewPortPx - {} The location in the viewport. + * + * Returns: + * {} Bounds of the tile at the given pixel location. + */ + getTileBounds(viewPortPx: Pixel): Bounds; + } + + export class HTTPRequest extends Layer { + /** + * Constant: URL_HASH_FACTOR + * {Float} Used to hash URL param strings for multi-WMS server selection. + * Set to the Golden Ratio per Knuth's recommendation. + */ + static URL_HASH_FACTOR: number; + + /** + * Property: url + * {Array(String) or String} This is either an array of url strings or + * a single url string. + */ + url: string[]; + + /** + * Property: params + * {Object} Hashtable of key/value parameters + */ + params: Object; + + /** + * APIProperty: reproject + * *Deprecated*. See http://docs.openlayers.org/library/spherical_mercator.html + * for information on the replacement for this functionality. + * {Boolean} Whether layer should reproject itself based on base layer + * locations. This allows reprojection onto commercial layers. + * Default is false: Most layers can't reproject, but layers + * which can create non-square geographic pixels can, like WMS. + */ + reproject: boolean; + + /** + * Constructor: OpenLayers.Layer.HTTPRequest + * + * Parameters: + * name - {String} + * url - {Array(String) or String} + * params - {Object} + * options - {Object} Hashtable of extra options to tag onto the layer + */ + constructor(name: string, url: string, params: Object, options: Object); + constructor(name: string, url: string[], params: Object, options: Object); + + /** + * APIMethod: destroy + */ + destroy(): void; + + /** + * APIMethod: clone + * + * Parameters: + * obj - {Object} + * + * Returns: + * {} An exact clone of this + * + */ + clone(obj?: Object): HTTPRequest; + + /** + * APIMethod: setUrl + * + * Parameters: + * newUrl - {String} + */ + setUrl(newUrl: string): void; + + /** + * APIMethod: mergeNewParams + * + * Parameters: + * newParams - {Object} + * + * Returns: + * redrawn: {Boolean} whether the layer was actually redrawn. + */ + mergeNewParams(newParams: Object): boolean; + + /** + * APIMethod: redraw + * Redraws the layer. Returns true if the layer was redrawn, false if not. + * + * Parameters: + * force - {Boolean} Force redraw by adding random parameter. + * + * Returns: + * {Boolean} The layer was redrawn. + */ + redraw(force?: boolean): boolean; + + /** + * Method: selectUrl + * selectUrl() implements the standard floating-point multiplicative + * hash function described by Knuth, and hashes the contents of the + * given param string into a float between 0 and 1. This float is then + * scaled to the size of the provided urls array, and used to select + * a URL. + * + * Parameters: + * paramString - {String} + * urls - {Array(String)} + * + * Returns: + * {String} An entry from the urls array, deterministically selected based + * on the paramString. + */ + private selectUrl(paramString: string, urls: string[]): string; + + /** + * Method: getFullRequestString + * Combine url with layer's params and these newParams. + * + * does checking on the serverPath variable, allowing for cases when it + * is supplied with trailing ? or &, as well as cases where not. + * + * return in formatted string like this: + * "server?key1=value1&key2=value2&key3=value3" + * + * WARNING: The altUrl parameter is deprecated and will be removed in 3.0. + * + * Parameters: + * newParams - {Object} + * altUrl - {String} Use this as the url instead of the layer's url + * + * Returns: + * {String} + */ + getFullRequestString(newParams: Object, altUrl: string): string; + } + export class Image { } export class KaMap { } export class KaMapCache { } export class MapGuide { } export class MapServer { } export class Markers { } -<<<<<<< HEAD export class OSM extends Layer.XYZ { /** @@ -1958,14 +4165,11 @@ declare module OpenLayers { /** * Create a clone of this layer */ - clone(): Layer.WMS; + clone(obj?: Object): Layer.OSM; static CLASS_NAME: string; } -======= - export class OSM { } ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class PointGrid { } export class PointTrack { } export class SphericalMercator { } @@ -1973,10 +4177,9 @@ declare module OpenLayers { export class Text { } export class TileCache { } export class UTFGrid { } -<<<<<<< HEAD - export class Vector { } + export class Vector { } - export class WMS { + export class WMS extends Layer.Grid { /** * Default is true for WMS layer */ @@ -2005,52 +4208,52 @@ declare module OpenLayers { */ yx: Object; - /** - * Constructor: OpenLayers.Layer.WMS - * Create a new WMS layer object - * - * Examples: - * - * The code below creates a simple WMS layer using the image/jpeg format. - * (code) - * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", - * "http://wms.jpl.nasa.gov/wms.cgi", - * {layers: "modis,global_mosaic"}); - * (end) - * Note the 3rd argument (params). Properties added to this object will be - * added to the WMS GetMap requests used for this layer's tiles. The only - * mandatory parameter is "layers". Other common WMS params include - * "transparent", "styles" and "format". Note that the "srs" param will - * always be ignored. Instead, it will be derived from the baseLayer's or - * map's projection. - * - * The code below creates a transparent WMS layer with additional options. - * (code) - * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", - * "http://wms.jpl.nasa.gov/wms.cgi", - * { - * layers: "modis,global_mosaic", - * transparent: true - * }, { - * opacity: 0.5, - * singleTile: true - * }); - * (end) - * Note that by default, a WMS layer is configured as baseLayer. Setting - * the "transparent" param to true will apply some magic (see ). - * The default image format changes from image/jpeg to image/png, and the - * layer is not configured as baseLayer. - * - * Parameters: - * name - {String} A name for the layer - * url - {String} Base url for the WMS - * (e.g. http://wms.jpl.nasa.gov/wms.cgi) - * params - {Object} An object with key/value pairs representing the - * GetMap query string parameters and parameter values. - * options - {Object} Hashtable of extra options to tag onto the layer. - * These options include all properties listed above, plus the ones - * inherited from superclasses. - */ + /** + * Constructor: OpenLayers.Layer.WMS + * Create a new WMS layer object + * + * Examples: + * + * The code below creates a simple WMS layer using the image/jpeg format. + * (code) + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", + * "http://wms.jpl.nasa.gov/wms.cgi", + * {layers: "modis,global_mosaic"}); + * (end) + * Note the 3rd argument (params). Properties added to this object will be + * added to the WMS GetMap requests used for this layer's tiles. The only + * mandatory parameter is "layers". Other common WMS params include + * "transparent", "styles" and "format". Note that the "srs" param will + * always be ignored. Instead, it will be derived from the baseLayer's or + * map's projection. + * + * The code below creates a transparent WMS layer with additional options. + * (code) + * var wms = new OpenLayers.Layer.WMS("NASA Global Mosaic", + * "http://wms.jpl.nasa.gov/wms.cgi", + * { + * layers: "modis,global_mosaic", + * transparent: true + * }, { + * opacity: 0.5, + * singleTile: true + * }); + * (end) + * Note that by default, a WMS layer is configured as baseLayer. Setting + * the "transparent" param to true will apply some magic (see ). + * The default image format changes from image/jpeg to image/png, and the + * layer is not configured as baseLayer. + * + * Parameters: + * name - {String} A name for the layer + * url - {String} Base url for the WMS + * (e.g. http://wms.jpl.nasa.gov/wms.cgi) + * params - {Object} An object with key/value pairs representing the + * GetMap query string parameters and parameter values. + * options - {Object} Hashtable of extra options to tag onto the layer. + * These options include all properties listed above, plus the ones + * inherited from superclasses. + */ constructor(name: string, url: string, params: WMSGetMapParams, options: WMSOptions); /** @@ -2075,7 +4278,7 @@ declare module OpenLayers { * Once params have been changed, the tiles will be reloaded with * the new parameters. */ - mergeNewParams(newParams): void; + mergeNewParams(newParams: Object): boolean; /** * Combine the layer's url with its params and these newParams. @@ -2089,13 +4292,112 @@ declare module OpenLayers { static CLASS_NAME: string; } -======= - export class Vector { } - export class WMS { } ->>>>>>> c19fb92cad220a320f0e717d542712c03c15b3c1 export class WMTS { } + export class WorldWind { } - export class XYZ { } + + export class XYZ extends Layer.Grid { + /** + * APIProperty: isBaseLayer + * Default is true, as this is designed to be a base tile source. + */ + isBaseLayer: boolean; + + /** + * APIProperty: sphericalMercator + * Whether the tile extents should be set to the defaults for + * spherical mercator. Useful for things like OpenStreetMap. + * Default is false, except for the OSM subclass. + */ + sphericalMercator: boolean; + + /** + * APIProperty: zoomOffset + * {Number} If your cache has more zoom levels than you want to provide + * access to with this layer, supply a zoomOffset. This zoom offset + * is added to the current map zoom level to determine the level + * for a requested tile. For example, if you supply a zoomOffset + * of 3, when the map is at the zoom 0, tiles will be requested from + * level 3 of your cache. Default is 0 (assumes cache level and map + * zoom are equivalent). Using is an alternative to + * setting if you only want to expose a subset + * of the server resolutions. + */ + zoomOffset: number; + + /** + * APIProperty: serverResolutions + * {Array} A list of all resolutions available on the server. Only set this + * property if the map resolutions differ from the server. This + * property serves two purposes. (a) can include + * resolutions that the server supports and that you don't want to + * provide with this layer; you can also look at , which is + * an alternative to for that specific purpose. + * (b) The map can work with resolutions that aren't supported by + * the server, i.e. that aren't in . When the + * map is displayed in such a resolution data for the closest + * server-supported resolution is loaded and the layer div is + * stretched as necessary. + */ + serverResolutions: number[]; + + /** + * Constructor: OpenLayers.Layer.XYZ + * + * Parameters: + * name - {String} + * url - {String} + * options - {Object} Hashtable of extra options to tag onto the layer + */ + constructor(name: number, url: string, options: {}); + + /** + * APIMethod: clone + * Create a clone of this layer + * + * Parameters: + * obj - {Object} Is this ever used? + * + * Returns: + * {} An exact clone of this OpenLayers.Layer.XYZ + */ + clone(obj?: Object): Layer.XYZ; + + /** + * Method: getURL + * + * Parameters: + * bounds - {} + * + * Returns: + * {String} A string with the layer's url and parameters and also the + * passed-in bounds and appropriate tile size specified as + * parameters + */ + private getURL(bounds: Bounds): string; + + /** + * Method: getXYZ + * Calculates x, y and z for the given bounds. + * + * Parameters: + * bounds - {} + * + * Returns: + * {Object} - an object with x, y and z properties. + */ + private getXYZ(bounds: Bounds): { x: number; y: number; z: number }; + + /* APIMethod: setMap + * When the layer is added to a map, then we can fetch our origin + * (if we don't have one.) + * + * Parameters: + * map - {} + */ + setMap(map: Map): void; + } + export class Zoomify { } module Google { From b5006a9086507c1d9e986dfe371370a201a79dc8 Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Fri, 1 Nov 2013 14:15:39 +0400 Subject: [PATCH 4/7] add TODO anchors to estimate amount of definitions to implement --- openlayers/openlayers.d.ts | 556 +++++++++++++++++++++++++++++++------ 1 file changed, 464 insertions(+), 92 deletions(-) diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts index 8a7f5e741c..52ea254430 100644 --- a/openlayers/openlayers.d.ts +++ b/openlayers/openlayers.d.ts @@ -2934,144 +2934,214 @@ declare module OpenLayers { export class Curve extends Geometry.MultiPoint { + // TODO + } export class LineString extends Geometry.Curve { + // TODO + } export class LinearRing extends Geometry.LineString { + // TODO + } export class MultiLineString extends Geometry.Collection { + // TODO + } export class MultiPoint extends Geometry.Collection { } + // TODO + export class MultiPolygon extends Geometry.Collection { + // TODO + } export class Polygon extends Geometry.Collection { + // TODO + } } module Control { export class ArgParser { + // TODO + } export class Attribution { + // TODO + } export class Button { + // TODO + } export class CacheRead { + // TODO + } export class CacheWrite { + // TODO + } export class DragFeature { + // TODO + } export class DragPan { + // TODO + } export class DrawFeature { + // TODO + } export class EditingToolbar { + // TODO + } export class Geolocate { + // TODO + } export class GetFeature { + // TODO + } export class Graticule { + // TODO + } export class KeyboardDefaults { + // TODO + } export class LayerSwitcher { + // TODO + } export class Measure { + // TODO + } export class ModifyFeature { + // TODO + } export class MousePosition { + // TODO + } export class NavToolbar { + // TODO + } export class Navigation { + // TODO + } export class NavigationHistory { + // TODO + } export class OverviewMap { + // TODO + } export class Pan { + // TODO + } export class PanPanel { + // TODO + } export class PanZoom { + // TODO + } export class PanZoomBar { + // TODO + } export class Panel { + // TODO + } export class Permalink { + // TODO + } export class PinchZoom { + // TODO + } export class SLDSelect { @@ -3080,108 +3150,158 @@ declare module OpenLayers { export class Scale { + // TODO + } export class ScaleLine { + // TODO + } export class SelectFeature { + // TODO + } export class Snapping { + // TODO + } export class Split { + // TODO + } export class TextButtonPanel { + // TODO + } export class TouchNavigation { + // TODO + } export class TransformFeature { + // TODO + } export class UTFGrid { + // TODO + } export class WMSGetFeatureInfo { + // TODO + } export class WMTSGetFeatureInfo { + // TODO + } export class Zoom { + // TODO + } export class ZoomBox { + // TODO + } export class ZoomIn { + // TODO + } export class ZoomOut { + // TODO + } export class ZoomPanel { + // TODO + } export class ZoomToMaxExtent { + // TODO + } } module Events { export class buttonclick extends OpenLayers.Class { + // TODO + } export class featureclick extends OpenLayers.Class { + // TODO + } } module Feature { export class Vector { + // TODO + } } module Filter { export class Comparison { + // TODO + } export class FeatureId { + // TODO + } export class Function { + // TODO + } export class Logical { + // TODO + } export class Spatial { + // TODO + } } @@ -3192,190 +3312,338 @@ declare module OpenLayers { export class Atom { + // TODO + } export class CQL { + // TODO + } export class CSWGetDomain { + // TODO + } export class CSWGetRecords { + // TODO + } - export class Context { } - export class EncodedPolyline { } - export class Filter { } - export class GML { } - export class GPX { } - export class GeoJSON { } - export class GeoRSS { } - export class JSON { } - export class KML { } - export class OGCExceptionReport { } - export class OSM { } - export class OWSCommon { } - export class OWSContext { } - export class QueryStringFilter { } - export class SLD { } - export class SOSCapabilities { } - export class SOSGetFeatureOfInterest { } - export class SOSGetObservation { } - export class TMSCapabilities { } - export class Text { } - export class WCSCapabilities { } - export class WCSDescribeCoverage { } - export class WCSGetCoverage { } - export class WFS { } - export class WFSCapabilities { } - export class WFSDescribeFeatureType { } - export class WFST { } - export class WKT { } - export class WMC { } - export class WMSCapabilities { } - export class WMSDescribeLayer { } - export class WMSGetFeatureInfo { } - export class WMTSCapabilities { } - export class WPSCapabilities { } - export class WPSDescribeProcess { } - export class WPSExecute { } - export class XLS { } - export class XML { } + export class Context { + // TODO + } + export class EncodedPolyline { + // TODO + } + export class Filter { + // TODO + } + export class GML { + // TODO + } + export class GPX { + // TODO + } + export class GeoJSON { + // TODO + } + export class GeoRSS { + // TODO + } + export class JSON { + // TODO + } + export class KML { + // TODO + } + export class OGCExceptionReport { + // TODO + } + export class OSM { + // TODO + } + export class OWSCommon { + // TODO + } + export class OWSContext { + // TODO + } + export class QueryStringFilter { + // TODO + } + export class SLD { + // TODO + } + export class SOSCapabilities { + // TODO + } + export class SOSGetFeatureOfInterest { + // TODO + } + export class SOSGetObservation { + // TODO + } + export class TMSCapabilities { + // TODO + } + export class Text { + // TODO + } + export class WCSCapabilities { + // TODO + } + export class WCSDescribeCoverage { + // TODO + } + export class WCSGetCoverage { + // TODO + } + export class WFS { + // TODO + } + export class WFSCapabilities { + // TODO + } + export class WFSDescribeFeatureType { + // TODO + } + export class WFST { + // TODO + } + export class WKT { + // TODO + } + export class WMC { + // TODO + } + export class WMSCapabilities { + // TODO + } + export class WMSDescribeLayer { + // TODO + } + export class WMSGetFeatureInfo { + // TODO + } + export class WMTSCapabilities { + // TODO + } + export class WPSCapabilities { + // TODO + } + export class WPSDescribeProcess { + // TODO + } + export class WPSExecute { + // TODO + } + export class XLS { + // TODO + } + export class XML { + // TODO + } module ArcXML { export class Features extends OpenLayers.Class { + // TODO + } } module CSWGetDomain { - export class v2_0_2 { } + export class v2_0_2 { + // TODO + } } module CSWGetRecords { - export class v2_0_2 { } + export class v2_0_2 { + // TODO + } } module Filter { + // TODO + } module GML { + // TODO + } module OWSCommon { + // TODO + } module OWSContext { + // TODO + } module SLD { + // TODO + } module SOSCapabilities { + // TODO + } module WCSCapabilities { + // TODO + } module WCSDescribeCoverage { + // TODO + } module WFSCapabilities { + // TODO + } module WFST { + // TODO + } module WMC { + // TODO + } module WMSCapabilities { + // TODO + } module WMSDescribeLayer { + // TODO + } module WMTSCapabilities { + // TODO + } module WPSCapabilities { + // TODO + } module XLS { + // TODO + } module XML { + // TODO + } } module Handler { export class Box { + // TODO + } export class Click { + // TODO + } export class Drag { + // TODO + } export class Feature { + // TODO + } export class Hover { + // TODO + } export class Keyboard { + // TODO + } export class MouseWheel { + // TODO + } export class Path { + // TODO + } export class Pinch { + // TODO + } export class Point { + // TODO + } export class Polygon { + // TODO + } export class RegularPolygon { + // TODO + } } @@ -4116,12 +4384,24 @@ declare module OpenLayers { getFullRequestString(newParams: Object, altUrl: string): string; } - export class Image { } - export class KaMap { } - export class KaMapCache { } - export class MapGuide { } - export class MapServer { } - export class Markers { } + export class Image { + // TODO + } + export class KaMap { + // TODO + } + export class KaMapCache { + // TODO + } + export class MapGuide { + // TODO + } + export class MapServer { + // TODO + } + export class Markers { + // TODO + } export class OSM extends Layer.XYZ { /** @@ -4170,14 +4450,30 @@ declare module OpenLayers { static CLASS_NAME: string; } - export class PointGrid { } - export class PointTrack { } - export class SphericalMercator { } - export class TMS { } - export class Text { } - export class TileCache { } - export class UTFGrid { } - export class Vector { } + export class PointGrid { + // TODO + } + export class PointTrack { + // TODO + } + export class SphericalMercator { + // TODO + } + export class TMS { + // TODO + } + export class Text { + // TODO + } + export class TileCache { + // TODO + } + export class UTFGrid { + // TODO + } + export class Vector { + // TODO + } export class WMS extends Layer.Grid { /** @@ -4292,9 +4588,13 @@ declare module OpenLayers { static CLASS_NAME: string; } - export class WMTS { } + export class WMTS { + // TODO + } - export class WorldWind { } + export class WorldWind { + // TODO + } export class XYZ extends Layer.Grid { /** @@ -4398,87 +4698,159 @@ declare module OpenLayers { setMap(map: Map): void; } - export class Zoomify { } + export class Zoomify { + // TODO + } module Google { - export class v3 { } + export class v3 { + // TODO + } } module Vector { - export class RootContainer { } + export class RootContainer { + // TODO + } } } module Marker { - export class Box { } + export class Box { + // TODO + } } module Popup { - export class Anchored { } - export class Framed { } - export class FramedCloud { } + export class Anchored { + // TODO + } + export class Framed { + // TODO + } + export class FramedCloud { + // TODO + } } module Protocol { - export class CSW { } - export class HTTP { } - export class SOS { } - export class Script { } - export class WFS { } + export class CSW { + // TODO + } + export class HTTP { + // TODO + } + export class SOS { + // TODO + } + export class Script { + // TODO + } + export class WFS { + // TODO + } module CSW { - export class v2_0_2 { } + export class v2_0_2 { + // TODO + } } module SOS { - export class v1_0_0 { } + export class v1_0_0 { + // TODO + } } module WFS { - export class v2_0_0 { } + export class v2_0_0 { + // TODO + } } } module Renderer { - export class Canvas { } - export class Elements { } - export class SVG { } - export class VML { } + export class Canvas { + // TODO + } + export class Elements { + // TODO + } + export class SVG { + // TODO + } + export class VML { + // TODO + } } module Request { - export class XMLHttpRequest { } + export class XMLHttpRequest { + // TODO + } } module Strategy { - export class BBOX { } - export class Cluster { } - export class Filter { } - export class Fixed { } - export class Paging { } - export class Refresh { } - export class Save { } + export class BBOX { + // TODO + } + export class Cluster { + // TODO + } + export class Filter { + // TODO + } + export class Fixed { + // TODO + } + export class Paging { + // TODO + } + export class Refresh { + // TODO + } + export class Save { + // TODO + } } module Symbolizer { - export class Line { } - export class Point { } - export class Polygon { } - export class Raster { } - export class Text { } + export class Line { + // TODO + } + export class Point { + // TODO + } + export class Polygon { + // TODO + } + export class Raster { + // TODO + } + export class Text { + // TODO + } } module Tile { - export class Image { } - export class UTFGrid { } + export class Image { + // TODO + } + export class UTFGrid { + // TODO + } module Image { - export class IFrame { } + export class IFrame { + // TODO + } } } module Util { - export class vendorPrefix { } + export class vendorPrefix { + // TODO + } } } From 2bdd32b4a692f758e4ae6d167c2fa5e608401e4f Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Fri, 1 Nov 2013 15:26:47 +0400 Subject: [PATCH 5/7] fix file encoding --- openlayers/openlayers.d.ts | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts index 52ea254430..f4a21241b2 100644 --- a/openlayers/openlayers.d.ts +++ b/openlayers/openlayers.d.ts @@ -1,4 +1,4 @@ -// Type definitions for OpenLayers.js 2.10 +// Type definitions for OpenLayers.js 2.10 // Project: https://github.com/openlayers/openlayers // Definitions by: Ilya Bolkhovsky // Definitions: https://github.com/borisyankov/DefinitelyTyped @@ -1214,7 +1214,7 @@ declare module OpenLayers { clone(): LonLat; /** - * A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. + * A new OpenLayers.LonLat object with the lon and lat passed-in added to this’s. */ add(lon: number, lat: number): LonLat; From 8b93d8b26db8f7a01abacaf28e72a4bf4f313230 Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Fri, 1 Nov 2013 15:27:12 +0400 Subject: [PATCH 6/7] add credentials --- README.md | 1 + 1 file changed, 1 insertion(+) diff --git a/README.md b/README.md index 5b2e26e789..5ebc5db2ee 100755 --- a/README.md +++ b/README.md @@ -172,6 +172,7 @@ List of Definitions * [node_zeromq](https://github.com/JustinTulloss/zeromq.node) (by [Dave McKeown](https://github.com/davemckeown)) * [node-sqlserver](https://github.com/WindowsAzure/node-sqlserver) (by [Boris Yankov](https://github.com/borisyankov)) * [Numeral.js](https://github.com/adamwdraper/Numeral-js) (by [Vincent Bortone](https://github.com/vbortone/)) +* [OpenLayers] (https://github.com/openlayers/openlayers) (by [Ilya Bolkhovsky](https://github.com/bolhovsky/)) * [Parallel.js](https://github.com/adambom/parallel.js) (by [Josh Baldwin](https://github.com/jbaldwin)) * [PDF.js](https://github.com/mozilla/pdf.js) (by [Josh Baldwin](https://github.com/jbaldwin)) * [Persona](http://www.mozilla.org/en-US/persona) (by [James Frasca](https://github.com/Nycto)) From d05a98b8817b9341898ac458c790c87d413a24e5 Mon Sep 17 00:00:00 2001 From: bolkhovsky Date: Fri, 1 Nov 2013 16:53:47 +0400 Subject: [PATCH 7/7] fix implicit annotations --- openlayers/openlayers.d.ts | 28 ++++++++++++++-------------- 1 file changed, 14 insertions(+), 14 deletions(-) diff --git a/openlayers/openlayers.d.ts b/openlayers/openlayers.d.ts index f4a21241b2..39355bb4e5 100644 --- a/openlayers/openlayers.d.ts +++ b/openlayers/openlayers.d.ts @@ -398,7 +398,7 @@ declare module OpenLayers { * setNewBaseLayer - {Boolean} Set a new base layer when this layer has * been destroyed. Default is true. */ - destroy(setNewBaseLayer?: boolean); + destroy(setNewBaseLayer?: boolean): void; /** * Method: clone @@ -974,7 +974,7 @@ declare module OpenLayers { /** * Set a custom transform method between two projections. Use this method in cases where the proj4js lib is not available or where custom projections need to be handled. */ - addTransform(from: string, to: string, method: () => void); + addTransform(from: string, to: string, method: () => void): void; /** * Transform a point coordinate from one projection to another. Note that the input point is transformed in place. @@ -1085,14 +1085,14 @@ declare module OpenLayers { * bounds may return non-integer properties, even if a pixel * is passed. */ - scale(ratio: number, origin?: Pixel); + scale(ratio: number, origin?: Pixel): void; /** * Scales the bounds around a pixel or lonlat. Note that the new * bounds may return non-integer properties, even if a pixel * is passed. */ - scale(ratio: number, origin?: LonLat); + scale(ratio: number, origin?: LonLat): void; /** * Shifts the coordinates of the bound by the given horizontal and vertical @@ -1123,12 +1123,12 @@ declare module OpenLayers { /** * Returns whether the bounds object contains the given . */ - containsLonLat(ll: LonLat, options: BoundsOptions); + containsLonLat(ll: LonLat, options: BoundsOptions): boolean; /** * Returns whether the bounds object contains the given . */ - containsLonLat(ll: Object, options: BoundsOptions); + containsLonLat(ll: Object, options: BoundsOptions): boolean; /** * Returns whether the bounds object contains the given . @@ -1666,7 +1666,7 @@ declare module OpenLayers { * Parameters: * options - {Object} Hashtable of options to tag to the map */ - setOptions(options: {}); + setOptions(options: {}): void; /** * APIMethod: getTileSize @@ -1927,7 +1927,7 @@ declare module OpenLayers { * Parameters: * newBaseLayer - {} */ - setBaseLayer(newBaseLayer): void; + setBaseLayer(newBaseLayer: Layer): void; /** * APIMethod: addControl @@ -1938,7 +1938,7 @@ declare module OpenLayers { * control - {} * px - {} */ - addControl(control: Control, px: Pixel); + addControl(control: Control, px: Pixel): void; /** * APIMethod: addControls @@ -1996,7 +1996,7 @@ declare module OpenLayers { * popup - {} * exclusive - {Boolean} If true, closes all other popups first */ - addPopup(popup: Popup, exclusive: boolean); + addPopup(popup: Popup, exclusive: boolean): void; /** * APIMethod: removePopup @@ -2772,12 +2772,12 @@ declare module OpenLayers { * Recalculate the bounds by iterating through the components and * calling calling extendBounds() on each item. */ - calculateBounds(); + calculateBounds(): void; /** * Add components to this geometry. */ - addComponents(components: Geometry[]); + addComponents(components: Geometry[]): void; /** * Add a new component (geometry) to the collection. If this.componentTypes @@ -2833,7 +2833,7 @@ declare module OpenLayers { /** * Rotate a geometry around some origin */ - rotate(angle: number, origin: Point); + rotate(angle: number, origin: Point): void; /** * Resize a geometry relative to some origin. Use this method to apply @@ -2909,7 +2909,7 @@ declare module OpenLayers { /** * Rotate a point around another. */ - rotate(angle: number, origin: Point); + rotate(angle: number, origin: Point): void; /** * Resize a point relative to some origin. For points, this has the effect of scaling a vector (from the origin to the point). This method is more useful on geometry collection subclasses.