ng-agm-core-lib
Version:
Angular components for Google Maps
279 lines • 31.5 kB
JavaScript
import { ContentChildren, Directive, EventEmitter, Input, Output } from '@angular/core';
import { AgmPolylineIcon } from './polyline-icon';
import { AgmPolylinePoint } from './polyline-point';
import * as i0 from "@angular/core";
import * as i1 from "../services/managers/polyline-manager";
let polylineId = 0;
/**
* AgmPolyline renders a polyline on a {@link AgmMap}
*
* ### Example
* ```typescript
* import { Component } from '@angular/core';
*
* @Component({
* selector: 'my-map-cmp',
* styles: [`
* .agm-map-container {
* height: 300px;
* }
* `],
* template: `
* <agm-map [latitude]="lat" [longitude]="lng" [zoom]="zoom">
* <agm-polyline>
* <agm-polyline-point [latitude]="latA" [longitude]="lngA">
* </agm-polyline-point>
* <agm-polyline-point [latitude]="latB" [longitude]="lngB">
* </agm-polyline-point>
* </agm-polyline>
* </agm-map>
* `
* })
* ```
*/
export class AgmPolyline {
_polylineManager;
/**
* Indicates whether this Polyline handles mouse events. Defaults to true.
*/
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
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.
*/
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.
*/
geodesic = false;
/**
* The stroke color. All CSS3 colors are supported except for extended named colors.
*/
strokeColor;
/**
* The stroke opacity between 0.0 and 1.0.
*/
strokeOpacity;
/**
* The stroke width in pixels.
*/
strokeWeight;
/**
* Whether this polyline is visible on the map. Defaults to true.
*/
visible = true;
/**
* The zIndex compared to other polys.
*/
zIndex;
/**
* This event is fired when the DOM click event is fired on the Polyline.
*/
lineClick = new EventEmitter();
/**
* This event is fired when the DOM dblclick event is fired on the Polyline.
*/
lineDblClick = new EventEmitter();
/**
* This event is repeatedly fired while the user drags the polyline.
*/
lineDrag = new EventEmitter();
/**
* This event is fired when the user stops dragging the polyline.
*/
lineDragEnd = new EventEmitter();
/**
* This event is fired when the user starts dragging the polyline.
*/
lineDragStart = new EventEmitter();
/**
* This event is fired when the DOM mousedown event is fired on the Polyline.
*/
lineMouseDown = new EventEmitter();
/**
* This event is fired when the DOM mousemove event is fired on the Polyline.
*/
lineMouseMove = new EventEmitter();
/**
* This event is fired on Polyline mouseout.
*/
lineMouseOut = new EventEmitter();
/**
* This event is fired on Polyline mouseover.
*/
lineMouseOver = new EventEmitter();
/**
* This event is fired whe the DOM mouseup event is fired on the Polyline
*/
lineMouseUp = new EventEmitter();
/**
* This event is fired when the Polyline is right-clicked on.
*/
lineRightClick = new EventEmitter();
/**
* This event is fired after Polyline's path changes.
*/
polyPathChange = new EventEmitter();
/**
* @internal
*/
points;
iconSequences;
static _polylineOptionsAttributes = [
'draggable', 'editable', 'visible', 'geodesic', 'strokeColor', 'strokeOpacity', 'strokeWeight',
'zIndex',
];
_id;
_polylineAddedToManager = false;
_subscriptions = [];
constructor(_polylineManager) {
this._polylineManager = _polylineManager;
this._id = (polylineId++).toString();
}
/** @internal */
ngAfterContentInit() {
if (this.points.length) {
this.points.forEach((point) => {
const s = point.positionChanged.subscribe(() => { this._polylineManager.updatePolylinePoints(this); });
this._subscriptions.push(s);
});
}
if (!this._polylineAddedToManager) {
this._init();
}
const pointSub = this.points.changes.subscribe(() => this._polylineManager.updatePolylinePoints(this));
this._subscriptions.push(pointSub);
this._polylineManager.updatePolylinePoints(this);
const iconSub = this.iconSequences.changes.subscribe(() => this._polylineManager.updateIconSequences(this));
this._subscriptions.push(iconSub);
}
ngOnChanges(changes) {
if (!this._polylineAddedToManager) {
this._init();
return;
}
const options = {};
const optionKeys = Object.keys(changes).filter(k => AgmPolyline._polylineOptionsAttributes.indexOf(k) !== -1);
optionKeys.forEach(k => options[k] = changes[k].currentValue);
this._polylineManager.setPolylineOptions(this, options);
}
getPath() {
return this._polylineManager.getPath(this);
}
_init() {
this._polylineManager.addPolyline(this);
this._polylineAddedToManager = true;
this._addEventListeners();
}
_addEventListeners() {
const handlers = [
{ name: 'click', handler: (ev) => this.lineClick.emit(ev) },
{ name: 'dblclick', handler: (ev) => this.lineDblClick.emit(ev) },
{ name: 'drag', handler: (ev) => this.lineDrag.emit(ev) },
{ name: 'dragend', handler: (ev) => this.lineDragEnd.emit(ev) },
{ name: 'dragstart', handler: (ev) => this.lineDragStart.emit(ev) },
{ name: 'mousedown', handler: (ev) => this.lineMouseDown.emit(ev) },
{ name: 'mousemove', handler: (ev) => this.lineMouseMove.emit(ev) },
{ name: 'mouseout', handler: (ev) => this.lineMouseOut.emit(ev) },
{ name: 'mouseover', handler: (ev) => this.lineMouseOver.emit(ev) },
{ name: 'mouseup', handler: (ev) => this.lineMouseUp.emit(ev) },
{ name: 'rightclick', handler: (ev) => this.lineRightClick.emit(ev) },
];
handlers.forEach((obj) => {
const os = this._polylineManager.createEventObservable(obj.name, this).subscribe(obj.handler);
this._subscriptions.push(os);
});
this._polylineManager.createPathEventObservable(this).then((ob$) => {
const os = ob$.subscribe(pathEvent => this.polyPathChange.emit(pathEvent));
this._subscriptions.push(os);
});
}
/** @internal */
_getPoints() {
if (this.points) {
return this.points.toArray();
}
return [];
}
_getIcons() {
if (this.iconSequences) {
return this.iconSequences.toArray();
}
return [];
}
/** @internal */
id() { return this._id; }
/** @internal */
ngOnDestroy() {
this._polylineManager.deletePolyline(this);
// unsubscribe all registered observable subscriptions
this._subscriptions.forEach((s) => s.unsubscribe());
}
static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AgmPolyline, deps: [{ token: i1.PolylineManager }], target: i0.ɵɵFactoryTarget.Directive });
static ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "14.0.0", version: "17.3.12", type: AgmPolyline, selector: "agm-polyline", inputs: { clickable: "clickable", draggable: ["polylineDraggable", "draggable"], editable: "editable", geodesic: "geodesic", strokeColor: "strokeColor", strokeOpacity: "strokeOpacity", strokeWeight: "strokeWeight", visible: "visible", zIndex: "zIndex" }, outputs: { lineClick: "lineClick", lineDblClick: "lineDblClick", lineDrag: "lineDrag", lineDragEnd: "lineDragEnd", lineDragStart: "lineDragStart", lineMouseDown: "lineMouseDown", lineMouseMove: "lineMouseMove", lineMouseOut: "lineMouseOut", lineMouseOver: "lineMouseOver", lineMouseUp: "lineMouseUp", lineRightClick: "lineRightClick", polyPathChange: "polyPathChange" }, queries: [{ propertyName: "points", predicate: AgmPolylinePoint }, { propertyName: "iconSequences", predicate: AgmPolylineIcon }], usesOnChanges: true, ngImport: i0 });
}
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: AgmPolyline, decorators: [{
type: Directive,
args: [{
selector: 'agm-polyline',
}]
}], ctorParameters: () => [{ type: i1.PolylineManager }], propDecorators: { clickable: [{
type: Input
}], draggable: [{
type: Input,
args: ['polylineDraggable']
}], editable: [{
type: Input
}], geodesic: [{
type: Input
}], strokeColor: [{
type: Input
}], strokeOpacity: [{
type: Input
}], strokeWeight: [{
type: Input
}], visible: [{
type: Input
}], zIndex: [{
type: Input
}], lineClick: [{
type: Output
}], lineDblClick: [{
type: Output
}], lineDrag: [{
type: Output
}], lineDragEnd: [{
type: Output
}], lineDragStart: [{
type: Output
}], lineMouseDown: [{
type: Output
}], lineMouseMove: [{
type: Output
}], lineMouseOut: [{
type: Output
}], lineMouseOver: [{
type: Output
}], lineMouseUp: [{
type: Output
}], lineRightClick: [{
type: Output
}], polyPathChange: [{
type: Output
}], points: [{
type: ContentChildren,
args: [AgmPolylinePoint]
}], iconSequences: [{
type: ContentChildren,
args: [AgmPolylineIcon]
}] } });
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"polyline.js","sourceRoot":"","sources":["../../../../../packages/core/src/lib/directives/polyline.ts"],"names":[],"mappings":"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","sourcesContent":["import { AfterContentInit, ContentChildren, Directive, EventEmitter, Input, OnChanges, OnDestroy, Output, QueryList, SimpleChanges } from '@angular/core';\nimport { Subscription } from 'rxjs';\n\nimport { PolylineManager } from '../services/managers/polyline-manager';\nimport { MVCEvent } from '../utils/mvcarray-utils';\nimport { AgmPolylineIcon } from './polyline-icon';\nimport { AgmPolylinePoint } from './polyline-point';\n\nlet polylineId = 0;\n/**\n * AgmPolyline renders a polyline 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-container {\n *      height: 300px;\n *    }\n * `],\n *  template: `\n *    <agm-map [latitude]=\"lat\" [longitude]=\"lng\" [zoom]=\"zoom\">\n *      <agm-polyline>\n *          <agm-polyline-point [latitude]=\"latA\" [longitude]=\"lngA\">\n *          </agm-polyline-point>\n *          <agm-polyline-point [latitude]=\"latB\" [longitude]=\"lngB\">\n *          </agm-polyline-point>\n *      </agm-polyline>\n *    </agm-map>\n *  `\n * })\n * ```\n */\n@Directive({\n  selector: 'agm-polyline',\n})\nexport class AgmPolyline implements OnDestroy, OnChanges, AfterContentInit {\n  /**\n   * Indicates whether this Polyline 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 property defines the\n   * mode of dragging. Defaults to false.\n   */\n  // tslint:disable-next-line:no-input-rename\n  @Input('polylineDraggable') draggable = false;\n\n  /**\n   * If set to true, the user can edit this shape by dragging the control points shown at the\n   * vertices and on each segment. Defaults to false.\n   */\n  @Input() editable = false;\n\n  /**\n   * When true, edges of the polygon are interpreted as geodesic and will follow the curvature of\n   * the Earth. When false, edges of the polygon are rendered as straight lines in screen space.\n   * Note that the shape of a 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 stroke color. All CSS3 colors are supported except for extended 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 polyline is visible on the map. Defaults to true.\n   */\n  @Input() visible = true;\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 Polyline.\n   */\n  @Output() lineClick: 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 Polyline.\n   */\n  @Output() lineDblClick: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is repeatedly fired while the user drags the polyline.\n   */\n  @Output() lineDrag: EventEmitter<google.maps.MouseEvent> = new EventEmitter<google.maps.MouseEvent>();\n\n  /**\n   * This event is fired when the user stops dragging the polyline.\n   */\n  @Output() lineDragEnd: EventEmitter<google.maps.MouseEvent> = new EventEmitter<google.maps.MouseEvent>();\n\n  /**\n   * This event is fired when the user starts dragging the polyline.\n   */\n  @Output() lineDragStart: 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 Polyline.\n   */\n  @Output() lineMouseDown: 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 Polyline.\n   */\n  @Output() lineMouseMove: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polyline mouseout.\n   */\n  @Output() lineMouseOut: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired on Polyline mouseover.\n   */\n  @Output() lineMouseOver: 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 Polyline\n   */\n  @Output() lineMouseUp: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired when the Polyline is right-clicked on.\n   */\n  @Output() lineRightClick: EventEmitter<google.maps.PolyMouseEvent> = new EventEmitter<google.maps.PolyMouseEvent>();\n\n  /**\n   * This event is fired after Polyline's path changes.\n   */\n  @Output() polyPathChange = new EventEmitter<MVCEvent<google.maps.LatLng>>();\n\n  /**\n   * @internal\n   */\n  @ContentChildren(AgmPolylinePoint) points: QueryList<AgmPolylinePoint>;\n\n  @ContentChildren(AgmPolylineIcon) iconSequences: QueryList<AgmPolylineIcon>;\n\n  private static _polylineOptionsAttributes: string[] = [\n    'draggable', 'editable', 'visible', 'geodesic', 'strokeColor', 'strokeOpacity', 'strokeWeight',\n    'zIndex',\n  ];\n\n  private _id: string;\n  private _polylineAddedToManager = false;\n  private _subscriptions: Subscription[] = [];\n\n  constructor(private _polylineManager: PolylineManager) { this._id = (polylineId++).toString(); }\n\n  /** @internal */\n  ngAfterContentInit() {\n    if (this.points.length) {\n      this.points.forEach((point: AgmPolylinePoint) => {\n        const s = point.positionChanged.subscribe(\n            () => { this._polylineManager.updatePolylinePoints(this); });\n        this._subscriptions.push(s);\n      });\n    }\n    if (!this._polylineAddedToManager) {\n      this._init();\n    }\n    const pointSub = this.points.changes.subscribe(() => this._polylineManager.updatePolylinePoints(this));\n    this._subscriptions.push(pointSub);\n    this._polylineManager.updatePolylinePoints(this);\n\n    const iconSub = this.iconSequences.changes.subscribe(() => this._polylineManager.updateIconSequences(this));\n    this._subscriptions.push(iconSub);\n  }\n\n  ngOnChanges(changes: SimpleChanges): any {\n    if (!this._polylineAddedToManager) {\n      this._init();\n      return;\n    }\n\n    const options: {[propName: string]: any} = {};\n    const optionKeys = Object.keys(changes).filter(\n        k => AgmPolyline._polylineOptionsAttributes.indexOf(k) !== -1);\n    optionKeys.forEach(k => options[k] = changes[k].currentValue);\n    this._polylineManager.setPolylineOptions(this, options);\n  }\n\n  getPath(): Promise<google.maps.LatLng[]> {\n    return this._polylineManager.getPath(this);\n  }\n\n  private _init() {\n    this._polylineManager.addPolyline(this);\n    this._polylineAddedToManager = true;\n    this._addEventListeners();\n  }\n\n  private _addEventListeners() {\n    const handlers = [\n      {name: 'click', handler: (ev: google.maps.PolyMouseEvent) => this.lineClick.emit(ev)},\n      {name: 'dblclick', handler: (ev: google.maps.PolyMouseEvent) => this.lineDblClick.emit(ev)},\n      {name: 'drag', handler: (ev: google.maps.MouseEvent) => this.lineDrag.emit(ev)},\n      {name: 'dragend', handler: (ev: google.maps.MouseEvent) => this.lineDragEnd.emit(ev)},\n      {name: 'dragstart', handler: (ev: google.maps.MouseEvent) => this.lineDragStart.emit(ev)},\n      {name: 'mousedown', handler: (ev: google.maps.PolyMouseEvent) => this.lineMouseDown.emit(ev)},\n      {name: 'mousemove', handler: (ev: google.maps.PolyMouseEvent) => this.lineMouseMove.emit(ev)},\n      {name: 'mouseout', handler: (ev: google.maps.PolyMouseEvent) => this.lineMouseOut.emit(ev)},\n      {name: 'mouseover', handler: (ev: google.maps.PolyMouseEvent) => this.lineMouseOver.emit(ev)},\n      {name: 'mouseup', handler: (ev: google.maps.PolyMouseEvent) => this.lineMouseUp.emit(ev)},\n      {name: 'rightclick', handler: (ev: google.maps.PolyMouseEvent) => this.lineRightClick.emit(ev)},\n    ];\n    handlers.forEach((obj) => {\n      const os = this._polylineManager.createEventObservable(obj.name, this).subscribe(obj.handler);\n      this._subscriptions.push(os);\n    });\n\n    this._polylineManager.createPathEventObservable(this).then((ob$) => {\n      const os = ob$.subscribe(pathEvent => this.polyPathChange.emit(pathEvent));\n      this._subscriptions.push(os);\n    });\n  }\n\n  /** @internal */\n  _getPoints(): AgmPolylinePoint[] {\n    if (this.points) {\n      return this.points.toArray();\n    }\n    return [];\n  }\n\n  _getIcons(): Array<AgmPolylineIcon> {\n    if (this.iconSequences) {\n      return this.iconSequences.toArray();\n    }\n    return [];\n  }\n\n  /** @internal */\n  id(): string { return this._id; }\n\n  /** @internal */\n  ngOnDestroy() {\n    this._polylineManager.deletePolyline(this);\n    // unsubscribe all registered observable subscriptions\n    this._subscriptions.forEach((s) => s.unsubscribe());\n  }\n}\n"]}