VLEX/BPM-UI/node_modules/angular2-draggable/esm2015/lib/angular-draggable.directive.js

/**
 * @fileoverview added by tsickle
 * @suppress {checkTypes,extraRequire,missingReturn,unusedPrivateMembers,uselessCode} checked by tsc
 */
import { Directive, ElementRef, Renderer2, Input, Output, HostListener, EventEmitter } from '@angular/core';
import { fromEvent } from 'rxjs';
import { Position } from './models/position';
import { HelperBlock } from './widgets/helper-block';
export class AngularDraggableDirective {
    /**
     * @param {?} el
     * @param {?} renderer
     */
    constructor(el, renderer) {
        this.el = el;
        this.renderer = renderer;
        this.allowDrag = true;
        this.moving = false;
        this.orignal = null;
        this.oldTrans = new Position(0, 0);
        this.tempTrans = new Position(0, 0);
        this.currTrans = new Position(0, 0);
        this.oldZIndex = '';
        this._zIndex = '';
        this.needTransform = false;
        this.draggingSub = null;
        /**
         * Bugfix: iFrames, and context unrelated elements block all events, and are unusable
         * https://github.com/xieziyu/angular2-draggable/issues/84
         */
        this._helperBlock = null;
        this.started = new EventEmitter();
        this.stopped = new EventEmitter();
        this.edge = new EventEmitter();
        /**
         * List of allowed out of bounds edges *
         */
        this.outOfBounds = {
            top: false,
            right: false,
            bottom: false,
            left: false
        };
        /**
         * Round the position to nearest grid
         */
        this.gridSize = 1;
        /**
         * Whether to limit the element stay in the bounds
         */
        this.inBounds = false;
        /**
         * Whether the element should use it's previous drag position on a new drag event.
         */
        this.trackPosition = true;
        /**
         * Input css scale transform of element so translations are correct
         */
        this.scale = 1;
        /**
         * Whether to prevent default event
         */
        this.preventDefaultEvent = false;
        /**
         * Set initial position by offsets
         */
        this.position = { x: 0, y: 0 };
        /**
         * Lock axis: 'x' or 'y'
         */
        this.lockAxis = null;
        /**
         * Emit position offsets when moving
         */
        this.movingOffset = new EventEmitter();
        /**
         * Emit position offsets when put back
         */
        this.endOffset = new EventEmitter();
        this._helperBlock = new HelperBlock(el.nativeElement, renderer);
    }
    /**
     * Set z-index when not dragging
     * @param {?} setting
     * @return {?}
     */
    set zIndex(setting) {
        this.renderer.setStyle(this.el.nativeElement, 'z-index', setting);
        this._zIndex = setting;
    }
    /**
     * @param {?} setting
     * @return {?}
     */
    set ngDraggable(setting) {
        if (setting !== undefined && setting !== null && setting !== '') {
            this.allowDrag = !!setting;
            /** @type {?} */
            let element = this.getDragEl();
            if (this.allowDrag) {
                this.renderer.addClass(element, 'ng-draggable');
            }
            else {
                this.putBack();
                this.renderer.removeClass(element, 'ng-draggable');
            }
        }
    }
    /**
     * @return {?}
     */
    ngOnInit() {
        if (this.allowDrag) {
            /** @type {?} */
            let element = this.getDragEl();
            this.renderer.addClass(element, 'ng-draggable');
        }
        this.resetPosition();
    }
    /**
     * @return {?}
     */
    ngOnDestroy() {
        this.bounds = null;
        this.handle = null;
        this.orignal = null;
        this.oldTrans = null;
        this.tempTrans = null;
        this.currTrans = null;
        this._helperBlock.dispose();
        this._helperBlock = null;
        if (this.draggingSub) {
            this.draggingSub.unsubscribe();
        }
    }
    /**
     * @param {?} changes
     * @return {?}
     */
    ngOnChanges(changes) {
        if (changes['position'] && !changes['position'].isFirstChange()) {
            /** @type {?} */
            let p = changes['position'].currentValue;
            if (!this.moving) {
                if (Position.isIPosition(p)) {
                    this.oldTrans.set(p);
                }
                else {
                    this.oldTrans.reset();
                }
                this.transform();
            }
            else {
                this.needTransform = true;
            }
        }
    }
    /**
     * @return {?}
     */
    ngAfterViewInit() {
        if (this.inBounds) {
            this.boundsCheck();
            this.oldTrans.add(this.tempTrans);
            this.tempTrans.reset();
        }
    }
    /**
     * @private
     * @return {?}
     */
    getDragEl() {
        return this.handle ? this.handle : this.el.nativeElement;
    }
    /**
     * @return {?}
     */
    resetPosition() {
        if (Position.isIPosition(this.position)) {
            this.oldTrans.set(this.position);
        }
        else {
            this.oldTrans.reset();
        }
        this.tempTrans.reset();
        this.transform();
    }
    /**
     * @private
     * @param {?} p
     * @return {?}
     */
    moveTo(p) {
        if (this.orignal) {
            p.subtract(this.orignal);
            this.tempTrans.set(p);
            this.tempTrans.divide(this.scale);
            this.transform();
            if (this.bounds) {
                this.edge.emit(this.boundsCheck());
            }
            this.movingOffset.emit(this.currTrans.value);
        }
    }
    /**
     * @private
     * @return {?}
     */
    transform() {
        /** @type {?} */
        let translateX = this.tempTrans.x + this.oldTrans.x;
        /** @type {?} */
        let translateY = this.tempTrans.y + this.oldTrans.y;
        if (this.lockAxis === 'x') {
            translateX = this.oldTrans.x;
            this.tempTrans.x = 0;
        }
        else if (this.lockAxis === 'y') {
            translateY = this.oldTrans.y;
            this.tempTrans.y = 0;
        }
        // Snap to grid: by grid size
        if (this.gridSize > 1) {
            translateX = Math.round(translateX / this.gridSize) * this.gridSize;
            translateY = Math.round(translateY / this.gridSize) * this.gridSize;
        }
        /** @type {?} */
        let value = `translate(${Math.round(translateX)}px, ${Math.round(translateY)}px)`;
        this.renderer.setStyle(this.el.nativeElement, 'transform', value);
        this.renderer.setStyle(this.el.nativeElement, '-webkit-transform', value);
        this.renderer.setStyle(this.el.nativeElement, '-ms-transform', value);
        this.renderer.setStyle(this.el.nativeElement, '-moz-transform', value);
        this.renderer.setStyle(this.el.nativeElement, '-o-transform', value);
        // save current position
        this.currTrans.x = translateX;
        this.currTrans.y = translateY;
    }
    /**
     * @private
     * @return {?}
     */
    pickUp() {
        // get old z-index:
        this.oldZIndex = this.el.nativeElement.style.zIndex ? this.el.nativeElement.style.zIndex : '';
        if (window) {
            this.oldZIndex = window.getComputedStyle(this.el.nativeElement, null).getPropertyValue('z-index');
        }
        if (this.zIndexMoving) {
            this.renderer.setStyle(this.el.nativeElement, 'z-index', this.zIndexMoving);
        }
        if (!this.moving) {
            this.started.emit(this.el.nativeElement);
            this.moving = true;
            /** @type {?} */
            const element = this.getDragEl();
            this.renderer.addClass(element, 'ng-dragging');
            /**
             * Fix performance issue:
             * https://github.com/xieziyu/angular2-draggable/issues/112
             */
            this.subscribeEvents();
        }
    }
    /**
     * @private
     * @return {?}
     */
    subscribeEvents() {
        this.draggingSub = fromEvent(document, 'mousemove', { passive: false }).subscribe(event => this.onMouseMove((/** @type {?} */ (event))));
        this.draggingSub.add(fromEvent(document, 'touchmove', { passive: false }).subscribe(event => this.onMouseMove((/** @type {?} */ (event)))));
        this.draggingSub.add(fromEvent(document, 'mouseup', { passive: false }).subscribe(() => this.putBack()));
        // checking if browser is IE or Edge - https://github.com/xieziyu/angular2-draggable/issues/153
        /** @type {?} */
        let isIEOrEdge = /msie\s|trident\//i.test(window.navigator.userAgent);
        if (!isIEOrEdge) {
            this.draggingSub.add(fromEvent(document, 'mouseleave', { passive: false }).subscribe(() => this.putBack()));
        }
        this.draggingSub.add(fromEvent(document, 'touchend', { passive: false }).subscribe(() => this.putBack()));
        this.draggingSub.add(fromEvent(document, 'touchcancel', { passive: false }).subscribe(() => this.putBack()));
    }
    /**
     * @private
     * @return {?}
     */
    unsubscribeEvents() {
        this.draggingSub.unsubscribe();
        this.draggingSub = null;
    }
    /**
     * @return {?}
     */
    boundsCheck() {
        if (this.bounds) {
            /** @type {?} */
            let boundary = this.bounds.getBoundingClientRect();
            /** @type {?} */
            let elem = this.el.nativeElement.getBoundingClientRect();
            /** @type {?} */
            let result = {
                'top': this.outOfBounds.top ? true : boundary.top < elem.top,
                'right': this.outOfBounds.right ? true : boundary.right > elem.right,
                'bottom': this.outOfBounds.bottom ? true : boundary.bottom > elem.bottom,
                'left': this.outOfBounds.left ? true : boundary.left < elem.left
            };
            if (this.inBounds) {
                if (!result.top) {
                    this.tempTrans.y -= (elem.top - boundary.top) / this.scale;
                }
                if (!result.bottom) {
                    this.tempTrans.y -= (elem.bottom - boundary.bottom) / this.scale;
                }
                if (!result.right) {
                    this.tempTrans.x -= (elem.right - boundary.right) / this.scale;
                }
                if (!result.left) {
                    this.tempTrans.x -= (elem.left - boundary.left) / this.scale;
                }
                this.transform();
            }
            return result;
        }
    }
    /**
     * Get current offset
     * @return {?}
     */
    getCurrentOffset() {
        return this.currTrans.value;
    }
    /**
     * @private
     * @return {?}
     */
    putBack() {
        if (this._zIndex) {
            this.renderer.setStyle(this.el.nativeElement, 'z-index', this._zIndex);
        }
        else if (this.zIndexMoving) {
            if (this.oldZIndex) {
                this.renderer.setStyle(this.el.nativeElement, 'z-index', this.oldZIndex);
            }
            else {
                this.el.nativeElement.style.removeProperty('z-index');
            }
        }
        if (this.moving) {
            this.stopped.emit(this.el.nativeElement);
            // Remove the helper div:
            this._helperBlock.remove();
            if (this.needTransform) {
                if (Position.isIPosition(this.position)) {
                    this.oldTrans.set(this.position);
                }
                else {
                    this.oldTrans.reset();
                }
                this.transform();
                this.needTransform = false;
            }
            if (this.bounds) {
                this.edge.emit(this.boundsCheck());
            }
            this.moving = false;
            this.endOffset.emit(this.currTrans.value);
            if (this.trackPosition) {
                this.oldTrans.add(this.tempTrans);
            }
            this.tempTrans.reset();
            if (!this.trackPosition) {
                this.transform();
            }
            /** @type {?} */
            const element = this.getDragEl();
            this.renderer.removeClass(element, 'ng-dragging');
            /**
             * Fix performance issue:
             * https://github.com/xieziyu/angular2-draggable/issues/112
             */
            this.unsubscribeEvents();
        }
    }
    /**
     * @param {?} target
     * @param {?} element
     * @return {?}
     */
    checkHandleTarget(target, element) {
        // Checks if the target is the element clicked, then checks each child element of element as well
        // Ignores button clicks
        // Ignore elements of type button
        if (element.tagName === 'BUTTON') {
            return false;
        }
        // If the target was found, return true (handle was found)
        if (element === target) {
            return true;
        }
        // Recursively iterate this elements children
        for (let child in element.children) {
            if (element.children.hasOwnProperty(child)) {
                if (this.checkHandleTarget(target, element.children[child])) {
                    return true;
                }
            }
        }
        // Handle was not found in this lineage
        // Note: return false is ignore unless it is the parent element
        return false;
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onMouseDown(event) {
        // 1. skip right click;
        if (event instanceof MouseEvent && event.button === 2) {
            return;
        }
        // 2. if handle is set, the element can only be moved by handle
        /** @type {?} */
        let target = event.target || event.srcElement;
        if (this.handle !== undefined && !this.checkHandleTarget(target, this.handle)) {
            return;
        }
        // 3. if allow drag is set to false, ignore the mousedown
        if (this.allowDrag === false) {
            return;
        }
        if (this.preventDefaultEvent) {
            event.stopPropagation();
            event.preventDefault();
        }
        this.orignal = Position.fromEvent(event, this.getDragEl());
        this.pickUp();
    }
    /**
     * @param {?} event
     * @return {?}
     */
    onMouseMove(event) {
        if (this.moving && this.allowDrag) {
            if (this.preventDefaultEvent) {
                event.stopPropagation();
                event.preventDefault();
            }
            // Add a transparent helper div:
            this._helperBlock.add();
            this.moveTo(Position.fromEvent(event, this.getDragEl()));
        }
    }
}
AngularDraggableDirective.decorators = [
    { type: Directive, args: [{
                selector: '[ngDraggable]',
                exportAs: 'ngDraggable'
            },] }
];
/** @nocollapse */
AngularDraggableDirective.ctorParameters = () => [
    { type: ElementRef },
    { type: Renderer2 }
];
AngularDraggableDirective.propDecorators = {
    started: [{ type: Output }],
    stopped: [{ type: Output }],
    edge: [{ type: Output }],
    handle: [{ type: Input }],
    bounds: [{ type: Input }],
    outOfBounds: [{ type: Input }],
    gridSize: [{ type: Input }],
    zIndexMoving: [{ type: Input }],
    zIndex: [{ type: Input }],
    inBounds: [{ type: Input }],
    trackPosition: [{ type: Input }],
    scale: [{ type: Input }],
    preventDefaultEvent: [{ type: Input }],
    position: [{ type: Input }],
    lockAxis: [{ type: Input }],
    movingOffset: [{ type: Output }],
    endOffset: [{ type: Output }],
    ngDraggable: [{ type: Input }],
    onMouseDown: [{ type: HostListener, args: ['mousedown', ['$event'],] }, { type: HostListener, args: ['touchstart', ['$event'],] }]
};
if (false) {
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.allowDrag;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.moving;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.orignal;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.oldTrans;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.tempTrans;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.currTrans;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.oldZIndex;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype._zIndex;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.needTransform;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.draggingSub;
    /**
     * Bugfix: iFrames, and context unrelated elements block all events, and are unusable
     * https://github.com/xieziyu/angular2-draggable/issues/84
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype._helperBlock;
    /** @type {?} */
    AngularDraggableDirective.prototype.started;
    /** @type {?} */
    AngularDraggableDirective.prototype.stopped;
    /** @type {?} */
    AngularDraggableDirective.prototype.edge;
    /**
     * Make the handle HTMLElement draggable
     * @type {?}
     */
    AngularDraggableDirective.prototype.handle;
    /**
     * Set the bounds HTMLElement
     * @type {?}
     */
    AngularDraggableDirective.prototype.bounds;
    /**
     * List of allowed out of bounds edges *
     * @type {?}
     */
    AngularDraggableDirective.prototype.outOfBounds;
    /**
     * Round the position to nearest grid
     * @type {?}
     */
    AngularDraggableDirective.prototype.gridSize;
    /**
     * Set z-index when dragging
     * @type {?}
     */
    AngularDraggableDirective.prototype.zIndexMoving;
    /**
     * Whether to limit the element stay in the bounds
     * @type {?}
     */
    AngularDraggableDirective.prototype.inBounds;
    /**
     * Whether the element should use it's previous drag position on a new drag event.
     * @type {?}
     */
    AngularDraggableDirective.prototype.trackPosition;
    /**
     * Input css scale transform of element so translations are correct
     * @type {?}
     */
    AngularDraggableDirective.prototype.scale;
    /**
     * Whether to prevent default event
     * @type {?}
     */
    AngularDraggableDirective.prototype.preventDefaultEvent;
    /**
     * Set initial position by offsets
     * @type {?}
     */
    AngularDraggableDirective.prototype.position;
    /**
     * Lock axis: 'x' or 'y'
     * @type {?}
     */
    AngularDraggableDirective.prototype.lockAxis;
    /**
     * Emit position offsets when moving
     * @type {?}
     */
    AngularDraggableDirective.prototype.movingOffset;
    /**
     * Emit position offsets when put back
     * @type {?}
     */
    AngularDraggableDirective.prototype.endOffset;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.el;
    /**
     * @type {?}
     * @private
     */
    AngularDraggableDirective.prototype.renderer;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"angular-draggable.directive.js","sourceRoot":"ng://angular2-draggable/","sources":["lib/angular-draggable.directive.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  Directive, ElementRef, Renderer2,\n  Input, Output, OnInit, HostListener,\n  EventEmitter, OnChanges, SimpleChanges, OnDestroy, AfterViewInit\n} from '@angular/core';\n\nimport { Subscription, fromEvent } from 'rxjs';\nimport { IPosition, Position } from './models/position';\nimport { HelperBlock } from './widgets/helper-block';\n\n@Directive({\n  selector: '[ngDraggable]',\n  exportAs: 'ngDraggable'\n})\nexport class AngularDraggableDirective implements OnInit, OnDestroy, OnChanges, AfterViewInit {\n  private allowDrag = true;\n  private moving = false;\n  private orignal: Position = null;\n  private oldTrans = new Position(0, 0);\n  private tempTrans = new Position(0, 0);\n  private currTrans = new Position(0, 0);\n  private oldZIndex = '';\n  private _zIndex = '';\n  private needTransform = false;\n\n  private draggingSub: Subscription = null;\n\n  /**\n   * Bugfix: iFrames, and context unrelated elements block all events, and are unusable\n   * https://github.com/xieziyu/angular2-draggable/issues/84\n   */\n  private _helperBlock: HelperBlock = null;\n\n  @Output() started = new EventEmitter<any>();\n  @Output() stopped = new EventEmitter<any>();\n  @Output() edge = new EventEmitter<any>();\n\n  /** Make the handle HTMLElement draggable */\n  @Input() handle: HTMLElement;\n\n  /** Set the bounds HTMLElement */\n  @Input() bounds: HTMLElement;\n\n  /** List of allowed out of bounds edges **/\n  @Input() outOfBounds = {\n    top: false,\n    right: false,\n    bottom: false,\n    left: false\n  };\n\n  /** Round the position to nearest grid */\n  @Input() gridSize = 1;\n\n  /** Set z-index when dragging */\n  @Input() zIndexMoving: string;\n\n  /** Set z-index when not dragging */\n  @Input() set zIndex(setting: string) {\n    this.renderer.setStyle(this.el.nativeElement, 'z-index', setting);\n    this._zIndex = setting;\n  }\n  /** Whether to limit the element stay in the bounds */\n  @Input() inBounds = false;\n\n  /** Whether the element should use it's previous drag position on a new drag event. */\n  @Input() trackPosition = true;\n\n  /** Input css scale transform of element so translations are correct */\n  @Input() scale = 1;\n\n  /** Whether to prevent default event */\n  @Input() preventDefaultEvent = false;\n\n  /** Set initial position by offsets */\n  @Input() position: IPosition = { x: 0, y: 0 };\n\n  /** Lock axis: 'x' or 'y' */\n  @Input() lockAxis: string = null;\n\n  /** Emit position offsets when moving */\n  @Output() movingOffset = new EventEmitter<IPosition>();\n\n  /** Emit position offsets when put back */\n  @Output() endOffset = new EventEmitter<IPosition>();\n\n  @Input()\n  set ngDraggable(setting: any) {\n    if (setting !== undefined && setting !== null && setting !== '') {\n      this.allowDrag = !!setting;\n\n      let element = this.getDragEl();\n\n      if (this.allowDrag) {\n        this.renderer.addClass(element, 'ng-draggable');\n      } else {\n        this.putBack();\n        this.renderer.removeClass(element, 'ng-draggable');\n      }\n    }\n  }\n\n  constructor(private el: ElementRef, private renderer: Renderer2) {\n    this._helperBlock = new HelperBlock(el.nativeElement, renderer);\n  }\n\n  ngOnInit() {\n    if (this.allowDrag) {\n      let element = this.getDragEl();\n      this.renderer.addClass(element, 'ng-draggable');\n    }\n    this.resetPosition();\n  }\n\n  ngOnDestroy() {\n    this.bounds = null;\n    this.handle = null;\n    this.orignal = null;\n    this.oldTrans = null;\n    this.tempTrans = null;\n    this.currTrans = null;\n    this._helperBlock.dispose();\n    this._helperBlock = null;\n\n    if (this.draggingSub) {\n      this.draggingSub.unsubscribe();\n    }\n  }\n\n  ngOnChanges(changes: SimpleChanges) {\n    if (changes['position'] && !changes['position'].isFirstChange()) {\n      let p = changes['position'].currentValue;\n\n      if (!this.moving) {\n        if (Position.isIPosition(p)) {\n          this.oldTrans.set(p);\n        } else {\n          this.oldTrans.reset();\n        }\n\n        this.transform();\n      } else {\n        this.needTransform = true;\n      }\n    }\n  }\n\n  ngAfterViewInit() {\n    if (this.inBounds) {\n      this.boundsCheck();\n      this.oldTrans.add(this.tempTrans);\n      this.tempTrans.reset();\n    }\n  }\n\n  private getDragEl() {\n    return this.handle ? this.handle : this.el.nativeElement;\n  }\n\n  resetPosition() {\n    if (Position.isIPosition(this.position)) {\n      this.oldTrans.set(this.position);\n    } else {\n      this.oldTrans.reset();\n    }\n    this.tempTrans.reset();\n    this.transform();\n  }\n\n  private moveTo(p: Position) {\n    if (this.orignal) {\n      p.subtract(this.orignal);\n      this.tempTrans.set(p);\n      this.tempTrans.divide(this.scale);\n      this.transform();\n\n      if (this.bounds) {\n        this.edge.emit(this.boundsCheck());\n      }\n\n      this.movingOffset.emit(this.currTrans.value);\n    }\n  }\n\n  private transform() {\n    let translateX = this.tempTrans.x + this.oldTrans.x;\n    let translateY = this.tempTrans.y + this.oldTrans.y;\n\n    if (this.lockAxis === 'x') {\n      translateX = this.oldTrans.x;\n      this.tempTrans.x = 0;\n    } else if (this.lockAxis === 'y') {\n      translateY = this.oldTrans.y;\n      this.tempTrans.y = 0;\n    }\n\n    // Snap to grid: by grid size\n    if (this.gridSize > 1) {\n      translateX = Math.round(translateX / this.gridSize) * this.gridSize;\n      translateY = Math.round(translateY / this.gridSize) * this.gridSize;\n    }\n\n    let value = `translate(${ Math.round(translateX) }px, ${ Math.round(translateY) }px)`;\n\n    this.renderer.setStyle(this.el.nativeElement, 'transform', value);\n    this.renderer.setStyle(this.el.nativeElement, '-webkit-transform', value);\n    this.renderer.setStyle(this.el.nativeElement, '-ms-transform', value);\n    this.renderer.setStyle(this.el.nativeElement, '-moz-transform', value);\n    this.renderer.setStyle(this.el.nativeElement, '-o-transform', value);\n\n    // save current position\n    this.currTrans.x = translateX;\n    this.currTrans.y = translateY;\n  }\n\n  private pickUp() {\n    // get old z-index:\n    this.oldZIndex = this.el.nativeElement.style.zIndex ? this.el.nativeElement.style.zIndex : '';\n\n    if (window) {\n      this.oldZIndex = window.getComputedStyle(this.el.nativeElement, null).getPropertyValue('z-index');\n    }\n\n    if (this.zIndexMoving) {\n      this.renderer.setStyle(this.el.nativeElement, 'z-index', this.zIndexMoving);\n    }\n\n    if (!this.moving) {\n      this.started.emit(this.el.nativeElement);\n      this.moving = true;\n\n      const element = this.getDragEl();\n      this.renderer.addClass(element, 'ng-dragging');\n\n      /**\n       * Fix performance issue:\n       * https://github.com/xieziyu/angular2-draggable/issues/112\n       */\n      this.subscribeEvents();\n    }\n  }\n\n  private subscribeEvents() {\n    this.draggingSub = fromEvent(document, 'mousemove', { passive: false }).subscribe(event => this.onMouseMove(event as MouseEvent));\n    this.draggingSub.add(fromEvent(document, 'touchmove', { passive: false }).subscribe(event => this.onMouseMove(event as TouchEvent)));\n    this.draggingSub.add(fromEvent(document, 'mouseup', { passive: false }).subscribe(() => this.putBack()));\n    // checking if browser is IE or Edge - https://github.com/xieziyu/angular2-draggable/issues/153\n    let isIEOrEdge = /msie\\s|trident\\//i.test(window.navigator.userAgent);\n    if (!isIEOrEdge) {\n      this.draggingSub.add(fromEvent(document, 'mouseleave', {passive: false}).subscribe(() => this.putBack()));\n    }\n    this.draggingSub.add(fromEvent(document, 'touchend', { passive: false }).subscribe(() => this.putBack()));\n    this.draggingSub.add(fromEvent(document, 'touchcancel', { passive: false }).subscribe(() => this.putBack()));\n  }\n\n  private unsubscribeEvents() {\n    this.draggingSub.unsubscribe();\n    this.draggingSub = null;\n  }\n\n  boundsCheck() {\n    if (this.bounds) {\n      let boundary = this.bounds.getBoundingClientRect();\n      let elem = this.el.nativeElement.getBoundingClientRect();\n      let result = {\n        'top': this.outOfBounds.top ? true : boundary.top < elem.top,\n        'right': this.outOfBounds.right ? true : boundary.right > elem.right,\n        'bottom': this.outOfBounds.bottom ? true : boundary.bottom > elem.bottom,\n        'left': this.outOfBounds.left ? true : boundary.left < elem.left\n      };\n\n      if (this.inBounds) {\n        if (!result.top) {\n          this.tempTrans.y -= (elem.top - boundary.top) / this.scale;\n        }\n\n        if (!result.bottom) {\n          this.tempTrans.y -= (elem.bottom - boundary.bottom) / this.scale;\n        }\n\n        if (!result.right) {\n          this.tempTrans.x -= (elem.right - boundary.right) / this.scale;\n        }\n\n        if (!result.left) {\n          this.tempTrans.x -= (elem.left - boundary.left) / this.scale;\n        }\n\n        this.transform();\n      }\n\n      return result;\n    }\n  }\n\n  /** Get current offset */\n  getCurrentOffset() {\n    return this.currTrans.value;\n  }\n\n  private putBack() {\n    if (this._zIndex) {\n      this.renderer.setStyle(this.el.nativeElement, 'z-index', this._zIndex);\n    } else if (this.zIndexMoving) {\n      if (this.oldZIndex) {\n        this.renderer.setStyle(this.el.nativeElement, 'z-index', this.oldZIndex);\n      } else {\n        this.el.nativeElement.style.removeProperty('z-index');\n      }\n    }\n\n    if (this.moving) {\n      this.stopped.emit(this.el.nativeElement);\n\n      // Remove the helper div:\n      this._helperBlock.remove();\n\n      if (this.needTransform) {\n        if (Position.isIPosition(this.position)) {\n          this.oldTrans.set(this.position);\n        } else {\n          this.oldTrans.reset();\n        }\n\n        this.transform();\n        this.needTransform = false;\n      }\n\n      if (this.bounds) {\n        this.edge.emit(this.boundsCheck());\n      }\n\n      this.moving = false;\n      this.endOffset.emit(this.currTrans.value);\n\n      if (this.trackPosition) {\n        this.oldTrans.add(this.tempTrans);\n      }\n\n      this.tempTrans.reset();\n\n      if (!this.trackPosition) {\n        this.transform();\n      }\n\n      const element = this.getDragEl();\n      this.renderer.removeClass(element, 'ng-dragging');\n\n      /**\n       * Fix performance issue:\n       * https://github.com/xieziyu/angular2-draggable/issues/112\n       */\n      this.unsubscribeEvents();\n    }\n  }\n\n  checkHandleTarget(target: EventTarget, element: Element) {\n    // Checks if the target is the element clicked, then checks each child element of element as well\n    // Ignores button clicks\n\n    // Ignore elements of type button\n    if (element.tagName === 'BUTTON') {\n      return false;\n    }\n\n    // If the target was found, return true (handle was found)\n    if (element === target) {\n      return true;\n    }\n\n    // Recursively iterate this elements children\n    for (let child in element.children) {\n      if (element.children.hasOwnProperty(child)) {\n        if (this.checkHandleTarget(target, element.children[child])) {\n          return true;\n        }\n      }\n    }\n\n    // Handle was not found in this lineage\n    // Note: return false is ignore unless it is the parent element\n    return false;\n  }\n\n  @HostListener('mousedown', ['$event'])\n  @HostListener('touchstart', ['$event'])\n  onMouseDown(event: MouseEvent | TouchEvent) {\n    // 1. skip right click;\n    if (event instanceof MouseEvent && event.button === 2) {\n      return;\n    }\n    // 2. if handle is set, the element can only be moved by handle\n    let target = event.target || event.srcElement;\n    if (this.handle !== undefined && !this.checkHandleTarget(target, this.handle)) {\n      return;\n    }\n\n    // 3. if allow drag is set to false, ignore the mousedown\n    if (this.allowDrag === false) {\n      return;\n    }\n\n    if (this.preventDefaultEvent) {\n      event.stopPropagation();\n      event.preventDefault();\n    }\n\n    this.orignal = Position.fromEvent(event, this.getDragEl());\n    this.pickUp();\n  }\n\n  onMouseMove(event: MouseEvent | TouchEvent) {\n    if (this.moving && this.allowDrag) {\n      if (this.preventDefaultEvent) {\n        event.stopPropagation();\n        event.preventDefault();\n      }\n\n      // Add a transparent helper div:\n      this._helperBlock.add();\n      this.moveTo(Position.fromEvent(event, this.getDragEl()));\n    }\n  }\n}\n"]}