/*
THIS INFRAGISTICS ULTIMATE SOFTWARE LICENSE  AGREEMENT ("AGREEMENT") LOCATED HERE:
https://www.infragistics.com/legal/license/igultimate-la
https://www.infragistics.com/legal/license/igultimate-eula
GOVERNS THE LICENSING, INSTALLATION AND USE OF INFRAGISTICS SOFTWARE. BY DOWNLOADING AND/OR INSTALLING AND USING INFRAGISTICS SOFTWARE:  you are indicating that you have read and understand this Agreement, and agree to be legally bound by it on behalf of the yourself and your company.
*/
import { EventEmitter, Output, Component, ViewChild, ContentChildren, Input, ChangeDetectionStrategy, ViewContainerRef } from '@angular/core';
import { AngularRenderer, AngularWrapper } from "igniteui-angular-core";
import { TypeRegistrar } from "igniteui-angular-core";
import { XamLinearGauge } from './XamLinearGauge';
import { CollectionAdapter, brushToString, stringToBrush, toPoint, fromBrushCollection, toBrushCollection, ensureBool, ensureEnum, toSpinal, initializePropertiesFromCss, NamePatcher, arrayFindByName } from "igniteui-angular-core";
import { IgxDataContext } from "igniteui-angular-core";
import { delegateCombine } from "igniteui-angular-core";
import { NotifyCollectionChangedAction } from "igniteui-angular-core";
import { LinearGaugeStylingDefaults } from './LinearGaugeStylingDefaults';
import { LinearScaleOrientation_$type } from './LinearScaleOrientation';
import { LinearGraphNeedleShape_$type } from './LinearGraphNeedleShape';
import { IgxFormatLinearGraphLabelEventArgs } from './igx-format-linear-graph-label-event-args';
import { IgxAlignLinearGraphLabelEventArgs } from './igx-align-linear-graph-label-event-args';
import { IgxLinearGraphRangeComponent } from './igx-linear-graph-range-component';
import { IgxLinearGraphRangeCollection } from './igx-linear-graph-range-collection';
import { IgxDoubleValueChangedEventArgs } from "igniteui-angular-core";
import { HighlightedValueDisplayMode_$type } from "igniteui-angular-core";
import * as i0 from "@angular/core";
/**
 * A linear gauge for displaying a single value on a defined scale.
*/
var IgxLinearGaugeComponent = /** @class */ /*@__PURE__*/ (function () {
    function IgxLinearGaugeComponent(_renderer, _elRef, _ngZone, _componentFactoryResolver, _injector) {
        //super();
        var _this = this;
        this._renderer = _renderer;
        this._elRef = _elRef;
        this._ngZone = _ngZone;
        this._componentFactoryResolver = _componentFactoryResolver;
        this._injector = _injector;
        /**
        * The ranges actually present in the chart. Do not directly modify this array.
        * This array's contents can be modified by causing Angular to reproject the child content.
        * Or adding and removing ranges from the manual ranges collection on the ranges property.
        */
        this.actualRanges = [];
        this._ranges = null;
        this._rangesAdapter = null;
        this._tooltipTemplate = null;
        this._tooltipContent = null;
        this._defaultTooltips = null;
        this._zoneRunner = null;
        this.__p = null;
        this._hasUserValues = new Set();
        this._stylingContainer = null;
        this._stylingParent = null;
        this._inStyling = false;
        this._formatLabel = null;
        this._alignLabel = null;
        this._valueChanged = null;
        this._highlightValueChanged = null;
        this._actualMinimumValueChange = null;
        this._actualMaximumValueChange = null;
        if (this._styling) {
            NamePatcher.ensureStylablePatched(Object.getPrototypeOf(this));
        }
        this._zoneRunner = function (act) { return _this._ngZone.run(act); };
        this._implementation = this.createImplementation();
        this._container = _renderer.createElement("div");
        _renderer.appendChild(_elRef.element.nativeElement, this._container);
        _renderer.setStyle(this._container, "display", "block");
        _renderer.setStyle(this._container, "width", "100%");
        _renderer.setStyle(this._container, "height", "100%");
        var root;
        root = this._container;
        if (this._container.nativeElement != null) {
            root = this._container.nativeElement;
        }
        this._root = root;
        var ren = new AngularRenderer(root, this._renderer, window.document, this._ngZone, true, LinearGaugeStylingDefaults);
        this._wrapper = ren;
        var gauge = this.i;
        this._gauge = gauge;
        this._rangesAdapter = new CollectionAdapter([], this.i.ranges, this.actualRanges, function (c) { return c.i; }, function (i) {
            i._provideRenderer(_this._wrapper);
            if (_this._root && _this._root.parentElement) {
                i._styling(_this._root, _this, _this);
            }
        }, function (i) { i._provideRenderer(null); });
        gauge.provideContainer(ren);
        ren.addSizeWatcher(function () {
            _this._gauge.containerResized();
        });
    }
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "height", {
        get: function () {
            return this._height;
        },
        set: function (value) {
            this._height = value;
            this._renderer.setStyle(this._elRef.element.nativeElement, "height", value);
            this._gauge.containerResized();
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "width", {
        get: function () {
            return this._width;
        },
        set: function (value) {
            this._width = value;
            this._renderer.setStyle(this._elRef.element.nativeElement, "width", value);
            this._gauge.containerResized();
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "ranges", {
        /**
         * A collection or manually added axes for the chart.
        */
        get: function () {
            var _this = this;
            if (this._ranges === null) {
                var coll = new IgxLinearGraphRangeCollection();
                var inner = coll._innerColl;
                inner.addListener(function (sender, e) {
                    switch (e.action) {
                        case NotifyCollectionChangedAction.Add:
                            _this._rangesAdapter.insertManualItem(e.newStartingIndex, e.newItems.item(0));
                            break;
                        case NotifyCollectionChangedAction.Remove:
                            _this._rangesAdapter.removeManualItemAt(e.oldStartingIndex);
                            break;
                        case NotifyCollectionChangedAction.Replace:
                            _this._rangesAdapter.removeManualItemAt(e.oldStartingIndex);
                            _this._rangesAdapter.insertManualItem(e.newStartingIndex, e.newItems.item(0));
                            break;
                        case NotifyCollectionChangedAction.Reset:
                            _this._rangesAdapter.clearManualItems();
                            break;
                    }
                });
                this._ranges = coll;
            }
            return this._ranges;
        },
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent.prototype.ngOnDestroy = function () {
        this._gauge.destroy();
        this._wrapper.destroy();
    };
    IgxLinearGaugeComponent.prototype.createImplementation = function () {
        return new XamLinearGauge();
    };
    IgxLinearGaugeComponent.prototype.ngAfterContentInit = function () {
        var _this = this;
        if (TypeRegistrar.isRegistered("IgxSimpleDefaultTooltipComponent")) {
            var c = TypeRegistrar.get("IgxSimpleDefaultTooltipComponent");
            var cf = this._componentFactoryResolver.resolveComponentFactory(c);
            var cr_1 = this._dynamicContent.createComponent(cf);
            this._defaultTooltips = cr_1;
            cr_1.instance.onContentReady.subscribe(function () {
                _this._onDefaultTooltipsReady(cr_1);
            });
            this._ensureTooltipCreated();
        }
        this._rangesAdapter.updateQuery(this.contentRanges);
    };
    IgxLinearGaugeComponent.prototype.ngAfterViewInit = function () {
        this.updateStyle();
        this.i.containerResized();
    };
    IgxLinearGaugeComponent.prototype.updateStyle = function () {
        this._styling(this._root, this);
        if (this.actualRanges && this.actualRanges.length > 0) {
            var currRange = this.actualRanges;
            for (var i = 0; i < currRange.length; i++) {
                currRange[i]._styling(this._root, this, this);
            }
        }
    };
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "tooltipTemplate", {
        get: function () {
            return this._tooltipTemplate;
        },
        set: function (value) {
            this._tooltipTemplate = value;
            if (value == null) {
                if (this._tooltipContent !== null) {
                    this._tooltipContent.destroy();
                    this._tooltipContent = null;
                }
            }
            if (this._tooltipContent != null) {
                this._tooltipContent.instance.template = this._tooltipTemplate;
            }
            else {
                this._ensureTooltipCreated();
            }
        },
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent.prototype._ensureTooltipCreated = function () {
        if (this.i.toolTip == null) {
            var tooltip = this.createTooltip();
            if (tooltip == null) {
                return;
            }
            this._tooltipContent = tooltip;
            tooltip.instance.template = this._tooltipTemplate;
            this.i.toolTip = this.createWrapper(tooltip.location.nativeElement);
        }
    };
    IgxLinearGaugeComponent.prototype.createWrapper = function (ele) {
        var wrapper = new AngularWrapper(ele, this._renderer, this._ngZone);
        wrapper.updateToolTip = ele.updateToolTip;
        wrapper.hideToolTip = ele.hideToolTip;
        return wrapper;
    };
    IgxLinearGaugeComponent.prototype._ensureDefaultTooltip = function () {
        if (this._defaultTooltips == null) {
            return;
        }
        this._defaultTooltips.instance["ensureDefaultTooltip"](this);
    };
    IgxLinearGaugeComponent.prototype._onDefaultTooltipsReady = function (cr) {
        this._ensureDefaultTooltip();
    };
    IgxLinearGaugeComponent.prototype.createTooltip = function () {
        if (!TypeRegistrar.isRegistered("IgxTooltipContainerComponent")) {
            return null;
        }
        var t = TypeRegistrar.get("IgxTooltipContainerComponent");
        var cf = this._componentFactoryResolver.resolveComponentFactory(t);
        var cr = this._dynamicContent.createComponent(cf);
        var ele = cr.location.nativeElement;
        var self = this;
        ele.updateToolTip = function (c) {
            if (c.externalObject) {
                c = c.externalObject;
            }
            else {
                var ext = new IgxDataContext();
                ext._implementation = c;
                c = ext;
            }
            if (ele.parentElement != self._container) {
                if (ele.parentElement != null) {
                    ele.parentElement.removeChild(ele);
                }
                self._container.appendChild(ele);
            }
            cr.instance.context = c;
            ele.style.display = "block";
            return true;
        };
        ele.hideToolTip = function () {
            ele.style.display = "none";
        };
        ele.style.display = "none";
        return cr;
    };
    IgxLinearGaugeComponent.prototype._runInZone = function (act) {
        if (this._zoneRunner != null) {
            this._zoneRunner(act);
        }
        else {
            act();
        }
    };
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "i", {
        /**
         * @hidden
         */
        get: function () {
            return this._implementation;
        } /**
                                     * @hidden
                                     */,
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent._createFromInternal = function (internal) {
        if (!internal) {
            return null;
        }
        if (!internal.$type) {
            return null;
        }
        var name = internal.$type.name;
        var externalName = "Igx" + name + "Component";
        if (!TypeRegistrar.isRegistered(externalName)) {
            return null;
        }
        return TypeRegistrar.create(externalName);
    };
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "animating", {
        /**
     * Gets a value indicating whether the bullet graph is currently animating.
    */
        get: function () {
            return this.i.a9;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "transitionProgress", {
        /**
         * Gets the transition progress of the animation when the control is animating.
        */
        get: function () {
            return this.i.dd;
        },
        set: function (v) {
            this.i.dd = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "orientation", {
        /**
         * Gets or sets the orientation of the scale.
        */
        get: function () {
            return this.i.as;
        },
        set: function (v) {
            this.i.as = ensureEnum(LinearScaleOrientation_$type, v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "rangeBrushes", {
        /**
         * Gets or sets a collection of brushes to be used as the palette for linear gauge ranges.
        */
        get: function () {
            return fromBrushCollection(this.i.ah);
        },
        set: function (v) {
            this.i.ah = toBrushCollection(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "rangeOutlines", {
        /**
         * Gets or sets a collection of brushes to be used as the palette for linear gauge outlines.
        */
        get: function () {
            return fromBrushCollection(this.i.ai);
        },
        set: function (v) {
            this.i.ai = toBrushCollection(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minimumValue", {
        /**
         * Gets or sets the minimum value of the scale.
        */
        get: function () {
            return this.i.ci;
        },
        set: function (v) {
            this.i.ci = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualMinimumValue", {
        /**
         * Gets the resolved minimum value of the scale.
        */
        get: function () {
            return this.i.b4;
        },
        set: function (v) {
            this.i.b4 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "maximumValue", {
        /**
         * Gets or sets the maximum value of the scale.
        */
        get: function () {
            return this.i.ch;
        },
        set: function (v) {
            this.i.ch = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualMaximumValue", {
        /**
         * Gets the resolved maximum value of the scale.
        */
        get: function () {
            return this.i.b3;
        },
        set: function (v) {
            this.i.b3 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "value", {
        /**
         * Gets or sets the value at which the needle is positioned.
        */
        get: function () {
            return this.i.de;
        },
        set: function (v) {
            this.i.de = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleShape", {
        /**
         * Gets or sets the shape to use when rendering the needle from a number of options.
        */
        get: function () {
            return this.i.ap;
        },
        set: function (v) {
            this.i.ap = ensureEnum(LinearGraphNeedleShape_$type, v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleName", {
        /**
         * Gets or sets the name used for needle.
        */
        get: function () {
            return this.i.ep;
        },
        set: function (v) {
            this.i.ep = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "rangeInnerExtent", {
        /**
         * Gets or sets the position at which to start rendering the ranges, measured from the front/bottom of the control as a value from 0 to 1.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.cy;
        },
        set: function (v) {
            this.i.cy = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleInnerExtent", {
        /**
         * Gets or sets the position at which to start rendering the scale, measured from the bottom/front (when orientation is horizontal/vertical) of the control as a value from 0 to 1.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.c2;
        },
        set: function (v) {
            this.i.c2 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "rangeOuterExtent", {
        /**
         * Gets or sets the position at which to stop rendering the range as a value from 0 to 1 measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.cz;
        },
        set: function (v) {
            this.i.cz = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleOuterExtent", {
        /**
         * Gets or sets the position at which to stop rendering the scale as a value from 0 to 1 measured from the bottom/front (when orientation is horizontal/vertical) of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.c4;
        },
        set: function (v) {
            this.i.c4 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleInnerExtent", {
        /**
         * Gets or sets the position at which to start rendering the needle geometry, measured from the front/bottom of the linear gauge as a value from 0 to 1.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.cp;
        },
        set: function (v) {
            this.i.cp = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleOuterExtent", {
        /**
         * Gets or sets the position at which to stop rendering the needle geometry as a value from 0 to 1 measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.ct;
        },
        set: function (v) {
            this.i.ct = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleInnerBaseWidth", {
        /**
         * Gets or sets the width of the needle's inner base.
        */
        get: function () {
            return this.i.co;
        },
        set: function (v) {
            this.i.co = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleOuterBaseWidth", {
        /**
         * Gets or sets the width of the needle's outer base.
        */
        get: function () {
            return this.i.cs;
        },
        set: function (v) {
            this.i.cs = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleInnerPointWidth", {
        /**
         * Gets or sets the width of the needle's inner point.
        */
        get: function () {
            return this.i.cr;
        },
        set: function (v) {
            this.i.cr = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleOuterPointWidth", {
        /**
         * Gets or sets the width of the needle's outer point.
        */
        get: function () {
            return this.i.cv;
        },
        set: function (v) {
            this.i.cv = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleInnerPointExtent", {
        /**
         * Gets or sets the extent of the needle's inner point.
        */
        get: function () {
            return this.i.cq;
        },
        set: function (v) {
            this.i.cq = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleOuterPointExtent", {
        /**
         * Gets or sets the extent of the needle's outer point.
        */
        get: function () {
            return this.i.cu;
        },
        set: function (v) {
            this.i.cu = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "interval", {
        /**
         * Gets or sets the interval to use for the scale.
        */
        get: function () {
            return this.i.cc;
        },
        set: function (v) {
            this.i.cc = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "ticksPostInitial", {
        /**
         * A value to start adding tickmarks, added to the scale's MinimumValue.
        */
        get: function () {
            return this.i.c9;
        },
        set: function (v) {
            this.i.c9 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "ticksPreTerminal", {
        /**
         * A value to stop adding tickmarks, subtracted from the scale's MaximumValue.
        */
        get: function () {
            return this.i.da;
        },
        set: function (v) {
            this.i.da = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelInterval", {
        /**
         * Gets or sets the interval to use for rendering labels. This defaults to be the same interval as the tickmarks on the scale.
        */
        get: function () {
            return this.i.ce;
        },
        set: function (v) {
            this.i.ce = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelExtent", {
        /**
         * Gets or sets the position at which to put the labels as a value from 0 to 1, measured from the bottom of the scale.
         * Values further from zero than 1 can be used to hide the labels of the linear gauge.
        */
        get: function () {
            return this.i.cd;
        },
        set: function (v) {
            this.i.cd = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelsPostInitial", {
        /**
         * A value to start adding labels, added to the scale's MinimumValue.
        */
        get: function () {
            return this.i.cf;
        },
        set: function (v) {
            this.i.cf = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelsPreTerminal", {
        /**
         * A value to stop adding labels, subtracted from the scale's MaximumValue.
        */
        get: function () {
            return this.i.cg;
        },
        set: function (v) {
            this.i.cg = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minorTickCount", {
        /**
         * Gets or sets the number of minor tickmarks to place between major tickmarks.
        */
        get: function () {
            return this.i.cj;
        },
        set: function (v) {
            this.i.cj = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "tickStartExtent", {
        /**
         * Gets or sets the position at which to start rendering the major tickmarks as a value from 0 to 1, measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.db;
        },
        set: function (v) {
            this.i.db = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "tickEndExtent", {
        /**
         * Gets or sets the position at which to stop rendering the major tickmarks as a value from 0 to 1, measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.c8;
        },
        set: function (v) {
            this.i.c8 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "tickStrokeThickness", {
        /**
         * Gets or sets the stroke thickness to use when rendering ticks.
        */
        get: function () {
            return this.i.dc;
        },
        set: function (v) {
            this.i.dc = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "tickBrush", {
        /**
         * Gets or sets the brush to use for the major tickmarks.
        */
        get: function () {
            return brushToString(this.i.iw);
        },
        set: function (v) {
            this.i.iw = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "fontBrush", {
        /**
         * Gets or sets the brush to use for the label font.
        */
        get: function () {
            return brushToString(this.i.ip);
        },
        set: function (v) {
            this.i.ip = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleBreadth", {
        /**
         * Gets or sets the needle breadth.
        */
        get: function () {
            return this.i.cn;
        },
        set: function (v) {
            this.i.cn = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleBrush", {
        /**
         * Gets or sets the brush to use for needle element.
        */
        get: function () {
            return brushToString(this.i.is);
        },
        set: function (v) {
            this.i.is = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleOutline", {
        /**
         * Gets or sets the brush to use for the outline of needle element.
        */
        get: function () {
            return brushToString(this.i.it);
        },
        set: function (v) {
            this.i.it = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "needleStrokeThickness", {
        /**
         * Gets or sets the stroke thickness to use when rendering single actual value element.
        */
        get: function () {
            return this.i.cw;
        },
        set: function (v) {
            this.i.cw = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minorTickStartExtent", {
        /**
         * Gets or sets the position at which to start rendering the minor tickmarks as a value from 0 to 1, measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.cl;
        },
        set: function (v) {
            this.i.cl = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minorTickEndExtent", {
        /**
         * Gets or sets the position at which to stop rendering the minor tickmarks as a value from 0 to 1, measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.ck;
        },
        set: function (v) {
            this.i.ck = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minorTickStrokeThickness", {
        /**
         * Gets or sets the stroke thickness to use when rendering minor ticks.
        */
        get: function () {
            return this.i.cm;
        },
        set: function (v) {
            this.i.cm = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "minorTickBrush", {
        /**
         * Gets or sets the brush to use for the minor tickmarks.
        */
        get: function () {
            return brushToString(this.i.ir);
        },
        set: function (v) {
            this.i.ir = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "isScaleInverted", {
        /**
         * Gets or sets a value indicating whether the scale is inverted.
         * When the scale is inverted the direction in which the scale values increase is right to left.
        */
        get: function () {
            return this.i.bg;
        },
        set: function (v) {
            this.i.bg = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "backingBrush", {
        /**
         * Gets or sets the brush to use to fill the backing of the linear gauge.
        */
        get: function () {
            return brushToString(this.i.im);
        },
        set: function (v) {
            this.i.im = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "backingOutline", {
        /**
         * Gets or sets the brush to use for the outline of the backing.
        */
        get: function () {
            return brushToString(this.i.io);
        },
        set: function (v) {
            this.i.io = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "backingStrokeThickness", {
        /**
         * Gets or sets the stroke thickness of the backing outline.
        */
        get: function () {
            return this.i.b8;
        },
        set: function (v) {
            this.i.b8 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "backingInnerExtent", {
        /**
         * Gets or sets the inner extent of the linear gauge backing.
        */
        get: function () {
            return this.i.b6;
        },
        set: function (v) {
            this.i.b6 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "backingOuterExtent", {
        /**
         * Gets or sets the outer extent of the linear gauge backing.
        */
        get: function () {
            return this.i.b7;
        },
        set: function (v) {
            this.i.b7 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleStartExtent", {
        /**
         * Gets or sets the position at which to start rendering the scale, measured from the front/bottom of the linear gauge as a value from 0 to 1.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.c6;
        },
        set: function (v) {
            this.i.c6 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleEndExtent", {
        /**
         * Gets or sets the position at which to stop rendering the scale as a value from 0 to 1, measured from the front/bottom of the linear gauge.
         * Values further from zero than 1 can be used to make this extend further than the normal size of the linear gauge.
        */
        get: function () {
            return this.i.c1;
        },
        set: function (v) {
            this.i.c1 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleBrush", {
        /**
         * Gets or sets the brush to use to fill the scale of the linear gauge.
        */
        get: function () {
            return brushToString(this.i.iu);
        },
        set: function (v) {
            this.i.iu = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleOutline", {
        /**
         * Gets or sets the brush to use for the outline of the scale.
        */
        get: function () {
            return brushToString(this.i.iv);
        },
        set: function (v) {
            this.i.iv = stringToBrush(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "scaleStrokeThickness", {
        /**
         * Gets or sets the stroke thickness of the scale outline.
        */
        get: function () {
            return this.i.c7;
        },
        set: function (v) {
            this.i.c7 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "mergeViewports", {
        /**
         * Gets or sets whether the scale viewport will be merged with backing viewport.
        */
        get: function () {
            return this.i.bj;
        },
        set: function (v) {
            this.i.bj = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelsVisible", {
        /**
         * Gets or sets whether the labels are visible in the gauge.
        */
        get: function () {
            return this.i.bi;
        },
        set: function (v) {
            this.i.bi = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "isNeedleDraggingEnabled", {
        /**
         * Gets or sets whether needle dragging is enabled or not.
        */
        get: function () {
            return this.i.bf;
        },
        set: function (v) {
            this.i.bf = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "isHighlightNeedleDraggingEnabled", {
        /**
         * Gets or sets whether highlight needle dragging is enabled or not.
        */
        get: function () {
            return this.i.be;
        },
        set: function (v) {
            this.i.be = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelFormat", {
        /**
         * Gets or sets the label composite format used when creating label values.
        */
        get: function () {
            return this.i.d4;
        },
        set: function (v) {
            this.i.d4 = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "labelFormatSpecifiers", {
        /**
         * Gets or sets the format specifiers to use with the LabelFormat string.
        */
        get: function () {
            return this.i.ag;
        },
        set: function (v) {
            if (v && !Array.isArray(v) && typeof (v) == "string") {
                var re = /\s*(?:,|\s|$)\s*/gm;
                v = v.split(re);
            }
            this.i.ag = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "transitionDuration", {
        /**
         * Gets or sets the number of milliseconds over which changes to the linear gauge should be animated.
        */
        get: function () {
            return this.i.di;
        },
        set: function (v) {
            this.i.di = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "highlightValue", {
        /**
         * Gets or sets the highlight value at which to point the secondary needle of the gauge.
        */
        get: function () {
            return this.i.ca;
        },
        set: function (v) {
            this.i.ca = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualHighlightValueOpacity", {
        /**
         * Gets the actual opacity of the primary needle while highlighting
        */
        get: function () {
            return this.i.b2;
        },
        set: function (v) {
            this.i.b2 = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "highlightValueOpacity", {
        /**
         * Gets or sets the opacity of the primary needle while highlighting
        */
        get: function () {
            return this.i.cb;
        },
        set: function (v) {
            this.i.cb = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualHighlightValueDisplayMode", {
        /**
         * Gets whether and how to display the highlighted value.
        */
        get: function () {
            return this.i.a0;
        },
        set: function (v) {
            this.i.a0 = ensureEnum(HighlightedValueDisplayMode_$type, v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "highlightValueDisplayMode", {
        /**
         * Gets or sets whether and how to display the highlighted value.
        */
        get: function () {
            return this.i.a1;
        },
        set: function (v) {
            this.i.a1 = ensureEnum(HighlightedValueDisplayMode_$type, v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "showToolTipTimeout", {
        /**
         * Gets or sets the time in milliseconds that tooltip appearance is delayed with.
        */
        get: function () {
            return this.i.dh;
        },
        set: function (v) {
            this.i.dh = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "showToolTip", {
        /**
         * Gets or sets a value indicating whether tooltips are enabled.
        */
        get: function () {
            return this.i.bn;
        },
        set: function (v) {
            this.i.bn = ensureBool(v);
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "font", {
        /**
         * Gets or sets the font.
        */
        get: function () {
            return this.i.dt;
        },
        set: function (v) {
            this.i.dt = v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "pixelScalingRatio", {
        /**
         * Gets or sets the scaling value used to affect the pixel density of the control.
         * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
         * to appear blurry.
        */
        get: function () {
            return this.i.cx;
        },
        set: function (v) {
            this.i.cx = +v;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualPixelScalingRatio", {
        /**
         * Gets the actual pixel scaling ratio used to affect the pixel density of the control.
         * A higher scaling ratio will produce crisper visuals at the expense of memory.  Lower values will cause the control
         * to appear blurry.
        */
        get: function () {
            return this.i.b5;
        },
        set: function (v) {
            this.i.b5 = +v;
        },
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent.prototype.findByName = function (name) {
        if (this.findEphemera) {
            if (name && name.indexOf("@@e:") == 0) {
                return this.findEphemera(name);
            }
        }
        if (this.ranges != null && this.ranges.findByName && this.ranges.findByName(name)) {
            return this.ranges.findByName(name);
        }
        if (this.labelFormatSpecifiers != null && arrayFindByName(this.labelFormatSpecifiers, name)) {
            return arrayFindByName(this.labelFormatSpecifiers, name);
        }
        return null;
    };
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "hasUserValues", {
        get: function () {
            return this._hasUserValues;
        },
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent.prototype.__m = function (propertyName) {
        if (!this._inStyling) {
            this._hasUserValues.add(propertyName);
        }
    };
    IgxLinearGaugeComponent.prototype._styling = function (container, component, parent) {
        if (this._inStyling) {
            return;
        }
        this._inStyling = true;
        this._stylingContainer = container;
        this._stylingParent = component;
        var genericPrefix = "";
        var typeName = this.i.$type.name;
        if (typeName.indexOf("Xam") === 0) {
            typeName = typeName.substring(3);
        }
        genericPrefix = toSpinal("LinearGaugeComponent");
        var additionalPrefixes = [];
        var prefix = toSpinal(typeName);
        additionalPrefixes.push(prefix + "-");
        var b = this.i.$type.baseType;
        while (b && b.name != "Object" &&
            b.name != "Base" &&
            b.name != "Control" &&
            b.Name != "DependencyObject" &&
            b.Name != "FrameworkElement") {
            typeName = b.name;
            if (typeName.indexOf("Xam") === 0) {
                typeName = typeName.substring(3);
            }
            var basePrefix = toSpinal(typeName);
            additionalPrefixes.push(basePrefix + "-");
            b = b.baseType;
        }
        if (parent) {
            var parentTypeName = parent.i.$type.name;
            if (parentTypeName.indexOf("Xam") === 0) {
                parentTypeName = parentTypeName.substring(3);
            }
            var parentPrefix = toSpinal(parentTypeName);
            additionalPrefixes.push(parentPrefix + "-" + genericPrefix + "-");
            additionalPrefixes.push(parentPrefix + "-" + prefix + "-");
        }
        initializePropertiesFromCss(container, this, genericPrefix + "-", this.hasUserValues, false, additionalPrefixes);
        if (this._otherStyling) {
            this._otherStyling(container, component, parent);
        }
        this._inStyling = false;
    };
    /**
 * Gets the value for the main scale of the gauge for a given point within the bounds of the gauge.

* @param point  * The point for which to retrieve the associated value.
*/
    IgxLinearGaugeComponent.prototype.getValueForPoint = function (point) {
        var iv = this.i.b9(toPoint(point));
        return (iv);
    };
    IgxLinearGaugeComponent.prototype.needleContainsPoint = function (point, isFinger) {
        var iv = this.i.needleContainsPoint(toPoint(point), isFinger);
        return (iv);
    };
    IgxLinearGaugeComponent.prototype.highlightNeedleContainsPoint = function (point, isFinger) {
        var iv = this.i.highlightNeedleContainsPoint(toPoint(point), isFinger);
        return (iv);
    };
    /**
     * Returns visuals as a serialized string.
    
    */
    IgxLinearGaugeComponent.prototype.exportSerializedVisualData = function () {
        var iv = this.i.ds();
        return (iv);
    };
    /**
     * Use to force the linear gauge to finish any deferred work before printing or evaluating its visual.
     * This should only be called if the visual of the linear gauge needs to be synchronously saved or evaluated.
     * Calling this method too often will hinder the performance of the linear gauge.
    
    */
    IgxLinearGaugeComponent.prototype.flush = function () {
        this.i.fs();
    };
    /**
     * Called by the UI framework to provide a UI container for rendering this control.
    
    * @param container  * The UI container element.
    */
    IgxLinearGaugeComponent.prototype.provideContainer = function (container) {
        this.i.provideContainer(container);
    };
    IgxLinearGaugeComponent.prototype.containerResized = function () {
        this.i.containerResized();
    };
    IgxLinearGaugeComponent.prototype.styleUpdated = function () {
        this.i.go();
    };
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "formatLabel", {
        /**
         * Event which is raised when a label of the the gauge is formatted.
         * Function takes first argument evt and second argument ui.
         * Use ui.owner to obtain reference to the gauge widget.
         * Use ui.actualMinimumValue to obtain the minimum value of the gauge scale.
         * Use ui.actualMaximumValue to obtain the maximum value of the gauge scale.
         * Use ui.value to obtain the value on the the gauge scale associated with the label.
         * Use ui.label to obtain the string value of the label.
        */
        get: function () {
            var _this = this;
            if (this._formatLabel == null) {
                this._formatLabel = new EventEmitter();
                this.i.formatLabel = delegateCombine(this.i.formatLabel, function (o, e) {
                    _this._runInZone(function () {
                        var outerArgs = new IgxFormatLinearGraphLabelEventArgs();
                        outerArgs._provideImplementation(e);
                        if (_this.beforeFormatLabel) {
                            _this.beforeFormatLabel(_this, outerArgs);
                        }
                        _this._formatLabel.emit({
                            sender: _this,
                            args: outerArgs
                        });
                    });
                });
            }
            return this._formatLabel;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "alignLabel", {
        /**
         * Event which is raised when a label of the linear gauge is aligned along the scale.
         * Function takes first argument evt and second argument ui.
         * Use ui.owner to obtain reference to the gauge widget.
         * Use ui.actualMinimumValue to obtain the minimum value of the gauge scale.
         * Use ui.actualMaximumValue to obtain the maximum value of the gauge scale.
         * Use ui.value to obtain the value on the gauge scale associated with the label.
         * Use ui.label to obtain the string value of the label.
         * Use ui.width to obtain the width of the label.
         * Use ui.height to obtain the height of the label.
         * Use ui.offsetX to obtain the X offset of the label on the gauge scale.
         * Use ui.offsetY to obtain the Y offset of the label on the gauge scale.
        */
        get: function () {
            var _this = this;
            if (this._alignLabel == null) {
                this._alignLabel = new EventEmitter();
                this.i.alignLabel = delegateCombine(this.i.alignLabel, function (o, e) {
                    _this._runInZone(function () {
                        var outerArgs = new IgxAlignLinearGraphLabelEventArgs();
                        outerArgs._provideImplementation(e);
                        if (_this.beforeAlignLabel) {
                            _this.beforeAlignLabel(_this, outerArgs);
                        }
                        _this._alignLabel.emit({
                            sender: _this,
                            args: outerArgs
                        });
                    });
                });
            }
            return this._alignLabel;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "valueChanged", {
        /**
         * Occurs when the Value property changes.
        */
        get: function () {
            var _this = this;
            if (this._valueChanged == null) {
                this._valueChanged = new EventEmitter();
                this.i.valueChanged = delegateCombine(this.i.valueChanged, function (o, e) {
                    var outerArgs = new IgxDoubleValueChangedEventArgs();
                    outerArgs._provideImplementation(e);
                    if (_this.beforeValueChanged) {
                        _this.beforeValueChanged(_this, outerArgs);
                    }
                    _this._valueChanged.emit({
                        sender: _this,
                        args: outerArgs
                    });
                });
            }
            return this._valueChanged;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "highlightValueChanged", {
        /**
         * Occurs when the Hightlight Value property changes.
        */
        get: function () {
            var _this = this;
            if (this._highlightValueChanged == null) {
                this._highlightValueChanged = new EventEmitter();
                this.i.highlightValueChanged = delegateCombine(this.i.highlightValueChanged, function (o, e) {
                    var outerArgs = new IgxDoubleValueChangedEventArgs();
                    outerArgs._provideImplementation(e);
                    if (_this.beforeHighlightValueChanged) {
                        _this.beforeHighlightValueChanged(_this, outerArgs);
                    }
                    _this._highlightValueChanged.emit({
                        sender: _this,
                        args: outerArgs
                    });
                });
            }
            return this._highlightValueChanged;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualMinimumValueChange", {
        get: function () {
            var _this = this;
            if (this._actualMinimumValueChange == null) {
                this._actualMinimumValueChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualMinimumValue;
                    if (_this.beforeActualMinimumValueChange) {
                        _this.beforeActualMinimumValueChange(_this, ext);
                    }
                    _this._actualMinimumValueChange.emit(ext);
                });
            }
            return this._actualMinimumValueChange;
        },
        enumerable: false,
        configurable: true
    });
    Object.defineProperty(IgxLinearGaugeComponent.prototype, "actualMaximumValueChange", {
        get: function () {
            var _this = this;
            if (this._actualMaximumValueChange == null) {
                this._actualMaximumValueChange = new EventEmitter();
                this.i.propertyChanged = delegateCombine(this.i.propertyChanged, function (o, e) {
                    var iv = e;
                    var ext = _this.actualMaximumValue;
                    if (_this.beforeActualMaximumValueChange) {
                        _this.beforeActualMaximumValueChange(_this, ext);
                    }
                    _this._actualMaximumValueChange.emit(ext);
                });
            }
            return this._actualMaximumValueChange;
        },
        enumerable: false,
        configurable: true
    });
    IgxLinearGaugeComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IgxLinearGaugeComponent, deps: [{ token: i0.Renderer2 }, { token: i0.ViewContainerRef }, { token: i0.NgZone }, { token: i0.ComponentFactoryResolver }, { token: i0.Injector }], target: i0.ɵɵFactoryTarget.Component });
    IgxLinearGaugeComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.17", type: IgxLinearGaugeComponent, selector: "igx-linear-gauge", inputs: { height: "height", width: "width", tooltipTemplate: "tooltipTemplate", transitionProgress: "transitionProgress", orientation: "orientation", rangeBrushes: "rangeBrushes", rangeOutlines: "rangeOutlines", minimumValue: "minimumValue", actualMinimumValue: "actualMinimumValue", maximumValue: "maximumValue", actualMaximumValue: "actualMaximumValue", value: "value", needleShape: "needleShape", needleName: "needleName", rangeInnerExtent: "rangeInnerExtent", scaleInnerExtent: "scaleInnerExtent", rangeOuterExtent: "rangeOuterExtent", scaleOuterExtent: "scaleOuterExtent", needleInnerExtent: "needleInnerExtent", needleOuterExtent: "needleOuterExtent", needleInnerBaseWidth: "needleInnerBaseWidth", needleOuterBaseWidth: "needleOuterBaseWidth", needleInnerPointWidth: "needleInnerPointWidth", needleOuterPointWidth: "needleOuterPointWidth", needleInnerPointExtent: "needleInnerPointExtent", needleOuterPointExtent: "needleOuterPointExtent", interval: "interval", ticksPostInitial: "ticksPostInitial", ticksPreTerminal: "ticksPreTerminal", labelInterval: "labelInterval", labelExtent: "labelExtent", labelsPostInitial: "labelsPostInitial", labelsPreTerminal: "labelsPreTerminal", minorTickCount: "minorTickCount", tickStartExtent: "tickStartExtent", tickEndExtent: "tickEndExtent", tickStrokeThickness: "tickStrokeThickness", tickBrush: "tickBrush", fontBrush: "fontBrush", needleBreadth: "needleBreadth", needleBrush: "needleBrush", needleOutline: "needleOutline", needleStrokeThickness: "needleStrokeThickness", minorTickStartExtent: "minorTickStartExtent", minorTickEndExtent: "minorTickEndExtent", minorTickStrokeThickness: "minorTickStrokeThickness", minorTickBrush: "minorTickBrush", isScaleInverted: "isScaleInverted", backingBrush: "backingBrush", backingOutline: "backingOutline", backingStrokeThickness: "backingStrokeThickness", backingInnerExtent: "backingInnerExtent", backingOuterExtent: "backingOuterExtent", scaleStartExtent: "scaleStartExtent", scaleEndExtent: "scaleEndExtent", scaleBrush: "scaleBrush", scaleOutline: "scaleOutline", scaleStrokeThickness: "scaleStrokeThickness", mergeViewports: "mergeViewports", labelsVisible: "labelsVisible", isNeedleDraggingEnabled: "isNeedleDraggingEnabled", isHighlightNeedleDraggingEnabled: "isHighlightNeedleDraggingEnabled", labelFormat: "labelFormat", labelFormatSpecifiers: "labelFormatSpecifiers", transitionDuration: "transitionDuration", highlightValue: "highlightValue", actualHighlightValueOpacity: "actualHighlightValueOpacity", highlightValueOpacity: "highlightValueOpacity", actualHighlightValueDisplayMode: "actualHighlightValueDisplayMode", highlightValueDisplayMode: "highlightValueDisplayMode", showToolTipTimeout: "showToolTipTimeout", showToolTip: "showToolTip", font: "font", pixelScalingRatio: "pixelScalingRatio", actualPixelScalingRatio: "actualPixelScalingRatio" }, outputs: { formatLabel: "formatLabel", alignLabel: "alignLabel", valueChanged: "valueChanged", highlightValueChanged: "highlightValueChanged", actualMinimumValueChange: "actualMinimumValueChange", actualMaximumValueChange: "actualMaximumValueChange" }, host: { classAttribute: "igx-linear-gauge ig-linear-gauge" }, providers: [], queries: [{ propertyName: "contentRanges", predicate: IgxLinearGraphRangeComponent }], viewQueries: [{ propertyName: "_dynamicContent", first: true, predicate: ["dynamicContent"], descendants: true, read: ViewContainerRef, static: true }], ngImport: i0, template: "<ng-container #dynamicContent></ng-container>", isInline: true, styles: ["\n\t\t:host {\n\t\t\tdisplay: block;\n\t\t}\n\t"], changeDetection: i0.ChangeDetectionStrategy.OnPush });
    return IgxLinearGaugeComponent;
}());
export { IgxLinearGaugeComponent };
i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.17", ngImport: i0, type: IgxLinearGaugeComponent, decorators: [{
            type: Component,
            args: [{
                    selector: 'igx-linear-gauge',
                    template: "<ng-container #dynamicContent></ng-container>",
                    changeDetection: ChangeDetectionStrategy.OnPush,
                    providers: [],
                    host: { 'class': 'igx-linear-gauge ig-linear-gauge' },
                    styles: ["\n\t\t:host {\n\t\t\tdisplay: block;\n\t\t}\n\t"]
                }]
        }], ctorParameters: function () { return [{ type: i0.Renderer2 }, { type: i0.ViewContainerRef }, { type: i0.NgZone }, { type: i0.ComponentFactoryResolver }, { type: i0.Injector }]; }, propDecorators: { _dynamicContent: [{
                type: ViewChild,
                args: ["dynamicContent", { read: ViewContainerRef, static: true }]
            }], height: [{
                type: Input
            }], width: [{
                type: Input
            }], contentRanges: [{
                type: ContentChildren,
                args: [IgxLinearGraphRangeComponent]
            }], tooltipTemplate: [{
                type: Input
            }], transitionProgress: [{
                type: Input
            }], orientation: [{
                type: Input
            }], rangeBrushes: [{
                type: Input
            }], rangeOutlines: [{
                type: Input
            }], minimumValue: [{
                type: Input
            }], actualMinimumValue: [{
                type: Input
            }], maximumValue: [{
                type: Input
            }], actualMaximumValue: [{
                type: Input
            }], value: [{
                type: Input
            }], needleShape: [{
                type: Input
            }], needleName: [{
                type: Input
            }], rangeInnerExtent: [{
                type: Input
            }], scaleInnerExtent: [{
                type: Input
            }], rangeOuterExtent: [{
                type: Input
            }], scaleOuterExtent: [{
                type: Input
            }], needleInnerExtent: [{
                type: Input
            }], needleOuterExtent: [{
                type: Input
            }], needleInnerBaseWidth: [{
                type: Input
            }], needleOuterBaseWidth: [{
                type: Input
            }], needleInnerPointWidth: [{
                type: Input
            }], needleOuterPointWidth: [{
                type: Input
            }], needleInnerPointExtent: [{
                type: Input
            }], needleOuterPointExtent: [{
                type: Input
            }], interval: [{
                type: Input
            }], ticksPostInitial: [{
                type: Input
            }], ticksPreTerminal: [{
                type: Input
            }], labelInterval: [{
                type: Input
            }], labelExtent: [{
                type: Input
            }], labelsPostInitial: [{
                type: Input
            }], labelsPreTerminal: [{
                type: Input
            }], minorTickCount: [{
                type: Input
            }], tickStartExtent: [{
                type: Input
            }], tickEndExtent: [{
                type: Input
            }], tickStrokeThickness: [{
                type: Input
            }], tickBrush: [{
                type: Input
            }], fontBrush: [{
                type: Input
            }], needleBreadth: [{
                type: Input
            }], needleBrush: [{
                type: Input
            }], needleOutline: [{
                type: Input
            }], needleStrokeThickness: [{
                type: Input
            }], minorTickStartExtent: [{
                type: Input
            }], minorTickEndExtent: [{
                type: Input
            }], minorTickStrokeThickness: [{
                type: Input
            }], minorTickBrush: [{
                type: Input
            }], isScaleInverted: [{
                type: Input
            }], backingBrush: [{
                type: Input
            }], backingOutline: [{
                type: Input
            }], backingStrokeThickness: [{
                type: Input
            }], backingInnerExtent: [{
                type: Input
            }], backingOuterExtent: [{
                type: Input
            }], scaleStartExtent: [{
                type: Input
            }], scaleEndExtent: [{
                type: Input
            }], scaleBrush: [{
                type: Input
            }], scaleOutline: [{
                type: Input
            }], scaleStrokeThickness: [{
                type: Input
            }], mergeViewports: [{
                type: Input
            }], labelsVisible: [{
                type: Input
            }], isNeedleDraggingEnabled: [{
                type: Input
            }], isHighlightNeedleDraggingEnabled: [{
                type: Input
            }], labelFormat: [{
                type: Input
            }], labelFormatSpecifiers: [{
                type: Input
            }], transitionDuration: [{
                type: Input
            }], highlightValue: [{
                type: Input
            }], actualHighlightValueOpacity: [{
                type: Input
            }], highlightValueOpacity: [{
                type: Input
            }], actualHighlightValueDisplayMode: [{
                type: Input
            }], highlightValueDisplayMode: [{
                type: Input
            }], showToolTipTimeout: [{
                type: Input
            }], showToolTip: [{
                type: Input
            }], font: [{
                type: Input
            }], pixelScalingRatio: [{
                type: Input
            }], actualPixelScalingRatio: [{
                type: Input
            }], formatLabel: [{
                type: Output
            }], alignLabel: [{
                type: Output
            }], valueChanged: [{
                type: Output
            }], highlightValueChanged: [{
                type: Output
            }], actualMinimumValueChange: [{
                type: Output
            }], actualMaximumValueChange: [{
                type: Output
            }] } });