@agm/core
Version:
Angular components for Google Maps
245 lines • 28.7 kB
JavaScript
import { Directive, EventEmitter, Input, Output } from '@angular/core';
import { PolygonManager } from '../services/managers/polygon-manager';
/**
* AgmPolygon renders a polygon on a {@link AgmMap}
*
* ### Example
* ```typescript
* import { Component } from '@angular/core';
*
* @Component({
* selector: 'my-map-cmp',
* styles: [`
* agm-map {
* height: 300px;
* }
* `],
* template: `
* <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
* <agm-polygon [paths]="paths">
* </agm-polygon>
* </agm-map>
* `
* })
* export class MyMapCmp {
* lat: number = 0;
* lng: number = 0;
* zoom: number = 10;
* paths: LatLngLiteral[] = [
* { lat: 0, lng: 10 },
* { lat: 0, lng: 20 },
* { lat: 10, lng: 20 },
* { lat: 10, lng: 10 },
* { lat: 0, lng: 10 }
* ]
* // Nesting paths will create a hole where they overlap;
* nestedPaths: LatLngLiteral[][] = [[
* { lat: 0, lng: 10 },
* { lat: 0, lng: 20 },
* { lat: 10, lng: 20 },
* { lat: 10, lng: 10 },
* { lat: 0, lng: 10 }
* ], [
* { lat: 0, lng: 15 },
* { lat: 0, lng: 20 },
* { lat: 5, lng: 20 },
* { lat: 5, lng: 15 },
* { lat: 0, lng: 15 }
* ]]
* }
* ```
*/
export class AgmPolygon {
constructor(_polygonManager) {
this._polygonManager = _polygonManager;
/**
* Indicates whether this Polygon handles mouse events. Defaults to true.
*/
this.clickable = true;
/**
* If set to true, the user can drag this shape over the map. The geodesic
* property defines the mode of dragging. Defaults to false.
*/
// tslint:disable-next-line:no-input-rename
this.draggable = false;
/**
* If set to true, the user can edit this shape by dragging the control
* points shown at the vertices and on each segment. Defaults to false.
*/
this.editable = false;
/**
* When true, edges of the polygon are interpreted as geodesic and will
* follow the curvature of the Earth. When false, edges of the polygon are
* rendered as straight lines in screen space. Note that the shape of a
* geodesic polygon may appear to change when dragged, as the dimensions
* are maintained relative to the surface of the earth. Defaults to false.
*/
this.geodesic = false;
/**
* The ordered sequence of coordinates that designates a closed loop.
* Unlike polylines, a polygon may consist of one or more paths.
* As a result, the paths property may specify one or more arrays of
* LatLng coordinates. Paths are closed automatically; do not repeat the
* first vertex of the path as the last vertex. Simple polygons may be
* defined using a single array of LatLngs. More complex polygons may
* specify an array of arrays. Any simple arrays are converted into Arrays.
* Inserting or removing LatLngs from the Array will automatically update
* the polygon on the map.
*/
this.paths = [];
/**
* This event is fired when the DOM click event is fired on the Polygon.
*/
this.polyClick = new EventEmitter();
/**
* This event is fired when the DOM dblclick event is fired on the Polygon.
*/
this.polyDblClick = new EventEmitter();
/**
* This event is repeatedly fired while the user drags the polygon.
*/
this.polyDrag = new EventEmitter();
/**
* This event is fired when the user stops dragging the polygon.
*/
this.polyDragEnd = new EventEmitter();
/**
* This event is fired when the user starts dragging the polygon.
*/
this.polyDragStart = new EventEmitter();
/**
* This event is fired when the DOM mousedown event is fired on the Polygon.
*/
this.polyMouseDown = new EventEmitter();
/**
* This event is fired when the DOM mousemove event is fired on the Polygon.
*/
this.polyMouseMove = new EventEmitter();
/**
* This event is fired on Polygon mouseout.
*/
this.polyMouseOut = new EventEmitter();
/**
* This event is fired on Polygon mouseover.
*/
this.polyMouseOver = new EventEmitter();
/**
* This event is fired whe the DOM mouseup event is fired on the Polygon
*/
this.polyMouseUp = new EventEmitter();
/**
* This event is fired when the Polygon is right-clicked on.
*/
this.polyRightClick = new EventEmitter();
/**
* This event is fired after Polygon first path changes.
*/
this.polyPathsChange = new EventEmitter();
this._polygonAddedToManager = false;
this._subscriptions = [];
}
/** @internal */
ngAfterContentInit() {
if (!this._polygonAddedToManager) {
this._init();
}
}
ngOnChanges(changes) {
if (!this._polygonAddedToManager) {
this._init();
return;
}
this._polygonManager.setPolygonOptions(this, this._updatePolygonOptions(changes));
}
_init() {
this._polygonManager.addPolygon(this);
this._polygonAddedToManager = true;
this._addEventListeners();
}
_addEventListeners() {
const handlers = [
{ name: 'click', handler: (ev) => this.polyClick.emit(ev) },
{ name: 'dblclick', handler: (ev) => this.polyDblClick.emit(ev) },
{ name: 'drag', handler: (ev) => this.polyDrag.emit(ev) },
{ name: 'dragend', handler: (ev) => this.polyDragEnd.emit(ev) },
{ name: 'dragstart', handler: (ev) => this.polyDragStart.emit(ev) },
{ name: 'mousedown', handler: (ev) => this.polyMouseDown.emit(ev) },
{ name: 'mousemove', handler: (ev) => this.polyMouseMove.emit(ev) },
{ name: 'mouseout', handler: (ev) => this.polyMouseOut.emit(ev) },
{ name: 'mouseover', handler: (ev) => this.polyMouseOver.emit(ev) },
{ name: 'mouseup', handler: (ev) => this.polyMouseUp.emit(ev) },
{ name: 'rightclick', handler: (ev) => this.polyRightClick.emit(ev) },
];
handlers.forEach((obj) => {
const os = this._polygonManager.createEventObservable(obj.name, this).subscribe(obj.handler);
this._subscriptions.push(os);
});
this._polygonManager.createPathEventObservable(this)
.then(paths$ => {
const os = paths$.subscribe(pathEvent => this.polyPathsChange.emit(pathEvent));
this._subscriptions.push(os);
});
}
_updatePolygonOptions(changes) {
return Object.keys(changes)
.filter(k => AgmPolygon._polygonOptionsAttributes.indexOf(k) !== -1)
.reduce((obj, k) => {
obj[k] = changes[k].currentValue;
return obj;
}, {});
}
/** @internal */
id() { return this._id; }
/** @internal */
ngOnDestroy() {
this._polygonManager.deletePolygon(this);
// unsubscribe all registered observable subscriptions
this._subscriptions.forEach((s) => s.unsubscribe());
}
getPath() {
return this._polygonManager.getPath(this);
}
getPaths() {
return this._polygonManager.getPaths(this);
}
}
AgmPolygon._polygonOptionsAttributes = [
'clickable', 'draggable', 'editable', 'fillColor', 'fillOpacity', 'geodesic', 'icon', 'map',
'paths', 'strokeColor', 'strokeOpacity', 'strokeWeight', 'visible', 'zIndex', 'draggable',
'editable', 'visible',
];
AgmPolygon.decorators = [
{ type: Directive, args: [{
selector: 'agm-polygon',
},] }
];
AgmPolygon.ctorParameters = () => [
{ type: PolygonManager }
];
AgmPolygon.propDecorators = {
clickable: [{ type: Input }],
draggable: [{ type: Input, args: ['polyDraggable',] }],
editable: [{ type: Input }],
fillColor: [{ type: Input }],
fillOpacity: [{ type: Input }],
geodesic: [{ type: Input }],
paths: [{ type: Input }],
strokeColor: [{ type: Input }],
strokeOpacity: [{ type: Input }],
strokeWeight: [{ type: Input }],
visible: [{ type: Input }],
zIndex: [{ type: Input }],
polyClick: [{ type: Output }],
polyDblClick: [{ type: Output }],
polyDrag: [{ type: Output }],
polyDragEnd: [{ type: Output }],
polyDragStart: [{ type: Output }],
polyMouseDown: [{ type: Output }],
polyMouseMove: [{ type: Output }],
polyMouseOut: [{ type: Output }],
polyMouseOver: [{ type: Output }],
polyMouseUp: [{ type: Output }],
polyRightClick: [{ type: Output }],
polyPathsChange: [{ type: Output }]
};
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polygon.js","sourceRoot":"","sources":["../../../../../packages/core/src/lib/directives/polygon.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, Directive, EventEmitter, Input, OnChanges, OnDestroy, Output, SimpleChanges } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { PolygonManager } from '../services/managers/polygon-manager';\nimport { MVCEvent } from '../utils/mvcarray-utils';\n\n/**\n * AgmPolygon renders a polygon on a {@link AgmMap}\n *\n * ### Example\n * ```typescript\n * import { Component } from '@angular/core';\n *\n * @Component({\n *  selector: 'my-map-cmp',\n *  styles: [`\n *    agm-map {\n *      height: 300px;\n *    }\n * `],\n *  template: `\n *    <agm-map [latitude]=\"lat\" [longitude]=\"lng\" [zoom]=\"zoom\">\n *      <agm-polygon [paths]=\"paths\">\n *      </agm-polygon>\n *    </agm-map>\n *  `\n * })\n * export class MyMapCmp {\n *   lat: number = 0;\n *   lng: number = 0;\n *   zoom: number = 10;\n *   paths: LatLngLiteral[] = [\n *     { lat: 0,  lng: 10 },\n *     { lat: 0,  lng: 20 },\n *     { lat: 10, lng: 20 },\n *     { lat: 10, lng: 10 },\n *     { lat: 0,  lng: 10 }\n *   ]\n *   // Nesting paths will create a hole where they overlap;\n *   nestedPaths: LatLngLiteral[][] = [[\n *     { lat: 0,  lng: 10 },\n *     { lat: 0,  lng: 20 },\n *     { lat: 10, lng: 20 },\n *     { lat: 10, lng: 10 },\n *     { lat: 0,  lng: 10 }\n *   ], [\n *     { lat: 0, lng: 15 },\n *     { lat: 0, lng: 20 },\n *     { lat: 5, lng: 20 },\n *     { lat: 5, lng: 15 },\n *     { lat: 0, lng: 15 }\n *   ]]\n * }\n * ```\n */\n@Directive({\n  selector: 'agm-polygon',\n})\nexport class AgmPolygon implements OnDestroy, OnChanges, AfterContentInit {\n  /**\n   * Indicates whether this Polygon handles mouse events. Defaults to true.\n   */\n  @Input() clickable = true;\n\n  /**\n   * If set to true, the user can drag this shape over the map. The geodesic\n   * property defines the mode of dragging. Defaults to false.\n   */\n  // tslint:disable-next-line:no-input-rename\n  @Input('polyDraggable') draggable = false;\n\n  /**\n   * If set to true, the user can edit this shape by dragging the control\n   * points shown at the vertices and on each segment. Defaults to false.\n   */\n  @Input() editable = false;\n\n  /**\n   * The fill color. All CSS3 colors are supported except for extended\n   * named colors.\n   */\n  @Input() fillColor: string;\n\n  /**\n   * The fill opacity between 0.0 and 1.0\n   */\n  @Input() fillOpacity: number;\n\n  /**\n   * When true, edges of the polygon are interpreted as geodesic and will\n   * follow the curvature of the Earth. When false, edges of the polygon are\n   * rendered as straight lines in screen space. Note that the shape of a\n   * geodesic polygon may appear to change when dragged, as the dimensions\n   * are maintained relative to the surface of the earth. Defaults to false.\n   */\n  @Input() geodesic = false;\n\n  /**\n   * The ordered sequence of coordinates that designates a closed loop.\n   * Unlike polylines, a polygon may consist of one or more paths.\n   *  As a result, the paths property may specify one or more arrays of\n   * LatLng coordinates. Paths are closed automatically; do not repeat the\n   * first vertex of the path as the last vertex. Simple polygons may be\n   * defined using a single array of LatLngs. More complex polygons may\n   * specify an array of arrays. Any simple arrays are converted into Arrays.\n   * Inserting or removing LatLngs from the Array will automatically update\n   * the polygon on the map.\n   */\n  @Input() paths: google.maps.LatLng[] | google.maps.LatLng[][] |\n      google.maps.MVCArray<google.maps.LatLng> | google.maps.MVCArray<google.maps.MVCArray<google.maps.LatLng>> |\n      google.maps.LatLngLiteral[] | google.maps.LatLngLiteral[][] = [];\n\n  /**\n   * The stroke color. All CSS3 colors are supported except for extended\n   * named colors.\n   */\n  @Input() strokeColor: string;\n\n  /**\n   * The stroke opacity between 0.0 and 1.0\n   */\n  @Input() strokeOpacity: number;\n\n  /**\n   * The stroke width in pixels.\n   */\n  @Input() strokeWeight: number;\n\n  /**\n   * Whether this polygon is visible on the map. Defaults to true.\n   */\n  @Input() visible: boolean;\n\n  /**\n   * The zIndex compared to other polys.\n   */\n  @Input() zIndex: number;\n\n  /**\n   * This event is fired when the DOM click event is fired on the Polygon.\n   */\n  @Output() polyClick: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the DOM dblclick event is fired on the Polygon.\n   */\n  @Output() polyDblClick: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is repeatedly fired while the user drags the polygon.\n   */\n  @Output() polyDrag: EventEmitter<google.maps.MouseEvent> = new EventEmitter<google.maps.MouseEvent>();\n\n  /**\n   * This event is fired when the user stops dragging the polygon.\n   */\n  @Output() polyDragEnd: EventEmitter<google.maps.MouseEvent> = new EventEmitter<google.maps.MouseEvent>();\n\n  /**\n   * This event is fired when the user starts dragging the polygon.\n   */\n  @Output() polyDragStart: EventEmitter<google.maps.MouseEvent> = new EventEmitter<google.maps.MouseEvent>();\n\n  /**\n   * This event is fired when the DOM mousedown event is fired on the Polygon.\n   */\n  @Output() polyMouseDown: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the DOM mousemove event is fired on the Polygon.\n   */\n  @Output() polyMouseMove: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polygon mouseout.\n   */\n  @Output() polyMouseOut: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polygon mouseover.\n   */\n  @Output() polyMouseOver: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired whe the DOM mouseup event is fired on the Polygon\n   */\n  @Output() polyMouseUp: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the Polygon is right-clicked on.\n   */\n  @Output() polyRightClick: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired after Polygon first path changes.\n   */\n  @Output() polyPathsChange = new EventEmitter<MVCEvent<google.maps.LatLng[] | google.maps.LatLngLiteral[]>>();\n\n  private static _polygonOptionsAttributes: string[] = [\n    'clickable', 'draggable', 'editable', 'fillColor', 'fillOpacity', 'geodesic', 'icon', 'map',\n    'paths', 'strokeColor', 'strokeOpacity', 'strokeWeight', 'visible', 'zIndex', 'draggable',\n    'editable', 'visible',\n  ];\n\n  private _id: string;\n  private _polygonAddedToManager = false;\n  private _subscriptions: Subscription[] = [];\n\n  constructor(private _polygonManager: PolygonManager) { }\n\n  /** @internal */\n  ngAfterContentInit() {\n    if (!this._polygonAddedToManager) {\n      this._init();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges): any {\n    if (!this._polygonAddedToManager) {\n      this._init();\n      return;\n    }\n\n    this._polygonManager.setPolygonOptions(this, this._updatePolygonOptions(changes));\n  }\n\n  private _init() {\n    this._polygonManager.addPolygon(this);\n    this._polygonAddedToManager = true;\n    this._addEventListeners();\n  }\n\n  private _addEventListeners() {\n    const handlers = [\n      { name: 'click', handler: (ev: google.maps.PolyMouseEvent) => this.polyClick.emit(ev) },\n      { name: 'dblclick', handler: (ev: google.maps.PolyMouseEvent) => this.polyDblClick.emit(ev) },\n      { name: 'drag', handler: (ev: google.maps.MouseEvent) => this.polyDrag.emit(ev) },\n      { name: 'dragend', handler: (ev: google.maps.MouseEvent) => this.polyDragEnd.emit(ev) },\n      { name: 'dragstart', handler: (ev: google.maps.MouseEvent) => this.polyDragStart.emit(ev) },\n      { name: 'mousedown', handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseDown.emit(ev) },\n      { name: 'mousemove', handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseMove.emit(ev) },\n      { name: 'mouseout', handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseOut.emit(ev) },\n      { name: 'mouseover', handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseOver.emit(ev) },\n      { name: 'mouseup', handler: (ev: google.maps.PolyMouseEvent) => this.polyMouseUp.emit(ev) },\n      { name: 'rightclick', handler: (ev: google.maps.PolyMouseEvent) => this.polyRightClick.emit(ev) },\n    ];\n    handlers.forEach((obj) => {\n      const os = this._polygonManager.createEventObservable(obj.name, this).subscribe(obj.handler);\n      this._subscriptions.push(os);\n    });\n\n    this._polygonManager.createPathEventObservable(this)\n    .then(paths$ => {\n      const os = paths$.subscribe(pathEvent => this.polyPathsChange.emit(pathEvent));\n      this._subscriptions.push(os);\n    });\n  }\n\n  private _updatePolygonOptions(changes: SimpleChanges): google.maps.PolygonOptions {\n    return Object.keys(changes)\n      .filter(k => AgmPolygon._polygonOptionsAttributes.indexOf(k) !== -1)\n      .reduce((obj: any, k: string) => {\n        obj[k] = changes[k].currentValue;\n        return obj;\n      }, {});\n  }\n\n  /** @internal */\n  id(): string { return this._id; }\n\n  /** @internal */\n  ngOnDestroy() {\n    this._polygonManager.deletePolygon(this);\n    // unsubscribe all registered observable subscriptions\n    this._subscriptions.forEach((s) => s.unsubscribe());\n  }\n\n  getPath(): Promise<google.maps.LatLng[]> {\n    return this._polygonManager.getPath(this);\n  }\n\n  getPaths(): Promise<google.maps.LatLng[][]> {\n    return this._polygonManager.getPaths(this);\n  }\n}\n"]}