summaryrefslogtreecommitdiff
path: root/js/dojo-1.7.2/dojox/gauges/_Gauge.js
diff options
context:
space:
mode:
Diffstat (limited to 'js/dojo-1.7.2/dojox/gauges/_Gauge.js')
-rw-r--r--js/dojo-1.7.2/dojox/gauges/_Gauge.js845
1 files changed, 845 insertions, 0 deletions
diff --git a/js/dojo-1.7.2/dojox/gauges/_Gauge.js b/js/dojo-1.7.2/dojox/gauges/_Gauge.js
new file mode 100644
index 0000000..cb050fe
--- /dev/null
+++ b/js/dojo-1.7.2/dojox/gauges/_Gauge.js
@@ -0,0 +1,845 @@
+//>>built
+define("dojox/gauges/_Gauge", ["dojo/_base/declare","dojo/_base/lang","dojo/_base/html","dojo/_base/array","dojo/_base/event",
+ "dojo/_base/connect","dojo/dom-construct", "dijit/_Widget", "dojox/gfx", "./Range", "dojo/fx/easing"],
+ function(declare, lang, html, arr, event, connect, dom, Widget, gfx, Range) {
+
+ var _tooltipModule = 0;
+ var _numberModule = 0;
+
+/*=====
+ Widget = dijit._Widget;
+=====*/
+
+return declare("dojox.gauges._Gauge",[Widget],{
+ // summary:
+ // The abstract base class for gauges.
+ //
+ // description:
+ // using dojo.gfx (and thus either SVG or VML based on what is supported), this widget
+ // builds a gauge component, used to display numerical data in a familiar format.
+ // This widget is not to be used alone. it is meant to be subclassed, such as
+ // dojox.gauges.BarGauge or dojox.gauges.AnalogGauge
+
+ // width: Number
+ // The width of the gauge (default is 300)
+ width: 0,
+
+ // height: Number
+ // The height of the gauge (default is 200)
+ height: 0,
+
+ // background: Object
+ // The color of the background. This must be an object of one of two forms:
+ // {'color': 'color-name'}
+ // OR
+ // (for a gradient:)
+ // {'type': 'linear', 'x1': 0, 'x2': 0, 'y1': 0, 'y2': 200, 'colors': [{offset: 0, color:'#C0C0C0'}, {offset: 1, color: '#E0E0E0'}] }
+ background: null,
+
+ // image: String
+ // Background image for gauge (default is no image)
+ image: null,
+
+ // useRangeStyles: Number
+ // Indicates whether to use given css classes (dojoxGaugeRangeXX)
+ // to determine the color (and other style attributes?) of the ranges
+ // this value should be the number of dojoxGaugeRange classes that are
+ // defined, starting at dojoxGaugeRange1 (0 indicates falling to default
+ // hardcoded colors)
+ useRangeStyles: 0,
+
+ // useTooltip: Boolean
+ // Indicates whether tooltips should be displayed for ranges, indicators, etc.
+ useTooltip: true,
+
+ // majorTicks: Object
+ // An object representing the tick marks that should be added to the gauge. Major tick marks have a text label
+ // indicating the value. The object can have the following attributes (required are marked with a *):
+ // - offset: the distance from the 'center' of the gauge. Used differently for Analog vs. Bar
+ // - width: The width of the mark
+ // - length: The length of the mark
+ // - interval: The interval the ticks should be added on
+ // - color: The color of the mark and text
+ // - font: an object with any/all of the following parameters:
+ // {family: "Helvetica", style: "italic", variant: 'small-caps', weight: 'bold', size: "18pt"}
+ majorTicks: null,
+
+ // minorTicks: Object
+ // An object of the same format as majorTicks, indicating where the minor (label-less) marks should be placed
+ // The font parameter is ignored if provided since minor tick marks have no text label.
+ minorTicks: null,
+
+ // _defaultIndicator: Object
+ // Should be overridden by any extending classes and used to indicate what the 'default' indicator is.
+ // This object is used as the indicator when creating tick marks or when an anonymous object is passed into
+ // addIndicator.
+ _defaultIndicator: null,
+
+ // defaultColors: Array
+ // Set of default colors to color ranges with.
+ defaultColors: [[0x00,0x54,0xAA,1],
+ [0x44,0x77,0xBB,1],
+ [0x66,0x99,0xCC,1],
+ [0x99,0xBB,0xEE,1],
+ [0x99,0xCC,0xFF,1],
+ [0xCC,0xEE,0xFF,1],
+ [0xDD,0xEE,0xFF,1]],
+
+ // min: Number
+ // The minimum value of the gauge. Normally not set explicitly, as it will be determined by
+ // the ranges that are added.
+ min: null,
+
+ // max: Number
+ // The maximum value of the gauge. Normally not set explicitly, as it will be determined by
+ // the ranges that are added.
+ max: null,
+
+ // surface: Object
+ // The GFX surface that the shapes are drawn on. Can be accessed/used by indicators to draw themselves
+ surface: null,
+
+ // hideValues: Boolean
+ // Indicates whether the text boxes showing the value of the indicator (as text
+ // content) should be hidden or shown. Default is not hidden, aka shown.
+ hideValues: false,
+
+ // internal data
+ gaugeContent: undefined,
+ _backgroundDefault: {color: '#E0E0E0'},
+ _rangeData: null,
+ _indicatorData: null,
+ _drag: null,
+ _img: null,
+ _overOverlay: false,
+ _lastHover: '',
+
+ startup: function(){
+ // handle settings from HTML by making sure all the options are
+ // converted correctly to numbers and that we calculate defaults
+ // for cx, cy and radius
+ if(this.image === null){
+ this.image={};
+ }
+
+ this.connect(this.gaugeContent, 'onmousedown', this.handleMouseDown);
+ this.connect(this.gaugeContent, 'onmousemove', this.handleMouseMove);
+ this.connect(this.gaugeContent, 'onmouseover', this.handleMouseOver);
+ this.connect(this.gaugeContent, 'onmouseout', this.handleMouseOut);
+ this.connect(this.gaugeContent, 'touchstart', this.handleTouchStart);
+ this.connect(this.gaugeContent, 'touchend', this.handleTouchEnd);
+ this.connect(this.gaugeContent, 'touchmove', this.handleTouchMove);
+
+ if(!lang.isArray(this.ranges)){ this.ranges = []; }
+ if(!lang.isArray(this.indicators)){ this.indicators = []; }
+ var ranges = [], indicators = [];
+ var i;
+ if(this.hasChildren()){
+ var children = this.getChildren();
+ for(i=0; i<children.length; i++){
+ if(/.*Indicator/.test(children[i].declaredClass)){
+ indicators.push(children[i]);
+ //this.addIndicator(children[i]);
+ continue;
+ }
+
+ switch(children[i].declaredClass){
+ case Range.prototype.declaredClass:
+ ranges.push(children[i]);
+ break;
+ }
+ }
+ this.ranges = this.ranges.concat(ranges);
+ this.indicators = this.indicators.concat(indicators);
+ }
+ if(!this.background){ this.background = this._backgroundDefault; }
+ this.background = this.background.color || this.background;
+ if(!this.surface){ this.createSurface(); }
+
+ this.addRanges(this.ranges);
+ if(this.minorTicks && this.minorTicks.interval){
+ this.setMinorTicks(this.minorTicks);
+ }
+ if(this.majorTicks && this.majorTicks.interval){
+ this.setMajorTicks(this.majorTicks);
+ }
+ for(i=0; i<this.indicators.length; i++){
+ this.addIndicator(this.indicators[i]);
+ }
+ this.inherited(arguments);
+ },
+
+ hasChildren: function(){
+ // summary:
+ // Returns true if widget has children, i.e. if this.containerNode contains something.
+ return this.getChildren().length > 0; // Boolean
+ },
+
+ buildRendering: function(){
+ // summary:
+ // Overrides _Widget.buildRendering
+ var n = this.domNode = this.srcNodeRef ? this.srcNodeRef: dom.create("div");
+ this.gaugeContent = dom.create("div", {
+ className: "dojoxGaugeContent"
+ });
+ this.containerNode = dom.create("div");
+ this.mouseNode = dom.create("div");
+ while(n.hasChildNodes()){
+ this.containerNode.appendChild(n.firstChild);
+ }
+ dom.place(this.gaugeContent, n);
+ dom.place(this.containerNode, n);
+ dom.place(this.mouseNode, n);
+ },
+
+ _setTicks: function(/*Object*/ oldTicks, /*Object*/ newTicks, /*Boolean*/ major){
+ // summary:
+ // internal method used to clear existing tick marks, then add new ones
+ var i;
+ if (oldTicks && lang.isArray(oldTicks._ticks)){
+ for (i = 0; i < oldTicks._ticks.length; i++){
+ this._removeScaleTick(oldTicks._ticks[i]);
+ }
+ }
+ var t = {
+ length: newTicks.length,
+ offset: newTicks.offset,
+ noChange: true
+ };
+ if (newTicks.color){
+ t.color = newTicks.color;
+ }
+ if (newTicks.font){
+ t.font = newTicks.font;
+ }
+ if (newTicks.labelPlacement){
+ t.direction = newTicks.labelPlacement;
+ }
+ newTicks._ticks = [];
+ for (i=this.min;i<=this.max;i+=newTicks.interval){
+ if (i==this.max&&this._isScaleCircular()) continue; // do not draw last tick on fully circular gauges
+ t.value=i;
+ if (major){
+ var NumberUtils = this._getNumberModule();
+ if (NumberUtils){ // use internationalization if loaded
+ t.label = (newTicks.fixedPrecision && newTicks.precision) ? NumberUtils.format(i, {
+ places: newTicks.precision
+ }): NumberUtils.format(i);
+ }else{
+ t.label = (newTicks.fixedPrecision && newTicks.precision) ? i.toFixed(newTicks.precision): i.toString();
+ }
+ }
+ newTicks._ticks.push(this._addScaleTick(t, major));
+ }
+ return newTicks;
+ },
+
+ _isScaleCircular: function(){
+ // summary:
+ // Internal method to check if the scale is fully circular
+ return false;
+ },
+
+ setMinorTicks: function(/*Object*/ ticks){
+ // summary:
+ // Creates and draws the minor tick marks based on the passed object (expecting the same format
+ // as the minorTicks object documented above)
+ this.minorTicks = this._setTicks(this.minorTicks, ticks, false);
+ },
+
+ setMajorTicks: function(/*Object*/ ticks){
+ // summary:
+ // Creates and draws the major tick marks based on the passed object (expecting the same format
+ // as the majorTicks object documented above)
+ this.majorTicks = this._setTicks(this.majorTicks, ticks, true);
+ },
+
+ postCreate: function(){
+ if(this.hideValues){
+ html.style(this.containerNode, "display", "none");
+ }
+ html.style(this.mouseNode, 'width', '0');
+ html.style(this.mouseNode, 'height', '0');
+ html.style(this.mouseNode, 'position', 'absolute');
+ html.style(this.mouseNode, 'z-index', '100');
+
+ if(this.useTooltip){
+ require(["dijit/Tooltip"], dojo.hitch(this, function(Tooltip){
+ Tooltip.show('test', this.mouseNode, !this.isLeftToRight());
+ Tooltip.hide(this.mouseNode);
+ }));
+ }
+ },
+
+ _getNumberModule :function() {
+ // summary:
+ // Tests is AMD dojo/number is loaded
+
+ if (_numberModule == 0) {
+ try {
+ _numberModule = require("dojo/number");
+ }
+ catch (e) {
+ _numberModule = null;
+ }
+ }
+ return _numberModule;
+ },
+
+ createSurface: function(){
+ // summary:
+ // Internal method used by the gauge to create the graphics surface area
+ this.gaugeContent.style.width = this.width + 'px';
+ this.gaugeContent.style.height = this.height + 'px';
+ this.surface = gfx.createSurface(this.gaugeContent, this.width, this.height);
+
+ // create several groups where various gauge elements will be created.
+ this._backgroundGroup = this.surface.createGroup();
+ this._rangeGroup = this.surface.createGroup();
+ this._minorTicksGroup = this.surface.createGroup();
+ this._majorTicksGroup = this.surface.createGroup();
+ this._overlayGroup = this.surface.createGroup();
+ this._indicatorsGroup = this.surface.createGroup();
+ this._foregroundGroup = this.surface.createGroup();
+
+ this._background = this._backgroundGroup.createRect({x: 0, y: 0, width: this.width, height: this.height });
+ this._background.setFill(this.background);
+
+ if(this.image.url){
+ var imageGroup = this._backgroundGroup;
+ if (this.image.overlay)
+ imageGroup = this._overlayGroup;
+
+ this._img = imageGroup.createImage({width: this.image.width || this.width, height: this.image.height || this.height, src: this.image.url});
+ if(this.image.x || this.image.y){
+ this._img.setTransform({dx: this.image.x || 0, dy: this.image.y || 0});
+ }
+ }
+ },
+
+ draw: function(){
+ // summary:
+ // This function is used to draw (or redraw) the gauge.
+ // description:
+ // Draws the gauge by drawing the surface, the ranges, and the indicators.
+ var i;
+ if (!this.surface)return;
+
+ this.drawBackground(this._backgroundGroup);
+
+ if(this._rangeData){
+ for(i=0; i<this._rangeData.length; i++){
+ this.drawRange(this._rangeGroup, this._rangeData[i]);
+ }
+ }
+
+ if(this._minorTicksData){
+ for(i=0; i<this._minorTicksData.length; i++){
+ this._minorTicksData[i].draw(this._minorTicksGroup);
+ }
+ }
+ if(this._majorTicksData){
+ for(i=0; i<this._majorTicksData.length; i++){
+ this._majorTicksData[i].draw(this._majorTicksGroup);
+ }
+ }
+
+ if(this._indicatorData){
+ for(i=0; i<this._indicatorData.length; i++){
+ this._indicatorData[i].draw(this._indicatorsGroup);
+ }
+ }
+ this.drawForeground(this._foregroundGroup);
+ },
+
+
+ drawBackground:function(group){
+ // summary:
+ // This function is used to draw (or redraw) the background of the gauge.
+ // description:
+ // The method may be used by subclasses to draw (or redraw) the background of the gauge.
+
+ },
+
+ drawForeground:function(group){
+ // summary:
+ // This function is used to draw (or redraw) the foreground of the gauge.
+ // description:
+ // The method may be used by subclasses to draw (or redraw) the foreground of the gauge.
+
+ },
+
+ setBackground: function(background){
+ // summary:
+ // This method is used to set the background of the gauge after it is created.
+ // description:
+ // Sets the background using the given object. Must be the same 'type' of object
+ // as the original background argument.
+ // background: Object
+ // An object in one of the two forms:
+ // {'color': 'color-name'}
+ // OR
+ // (for a gradient:)
+ // {'type': 'linear', 'colors': [{offset: 0, color:'#C0C0C0'}, {offset: 1, color: '#E0E0E0'}] }
+ // If background is null or undefined, this will set the fill to this._backgroundDefault
+ if(!background){ background = this._backgroundDefault; }
+ this.background = background.color || background;
+ this._background.setFill(this.background);
+ },
+
+ addRange: function(/*Object*/range){
+ // summary:
+ // This method is used to add a range to the gauge.
+ // description:
+ // Creates a range (colored area on the background of the gauge)
+ // based on the given arguments.
+ // range: Object
+ // A range is either a dojox.gauges.Range object, or a object
+ // with similar parameters (low, high, hover, etc.).
+ this.addRanges([range]);
+ },
+
+ addRanges: function(/*Array*/ranges){
+ // summary:
+ // This method is used to add ranges to the gauge.
+ // description:
+ // Creates a range (colored area on the background of the gauge)
+ // based on the given arguments.
+ // range: Range
+ // A range is either a dojox.gauges.Range object, or a object
+ // with similar parameters (low, high, hover, etc.).
+ if(!this._rangeData){
+ this._rangeData = [];
+ }
+ var range;
+ for(var i=0; i<ranges.length; i++){
+ range = ranges[i];
+ if((this.min === null) || (range.low < this.min)){this.min = range.low;}
+ if((this.max === null) || (range.high > this.max)){this.max = range.high;}
+
+ if(!range.color){
+ var colorIndex = this._rangeData.length % this.defaultColors.length;
+ if(gfx.svg && this.useRangeStyles > 0){
+ colorIndex = (this._rangeData.length % this.useRangeStyles)+1;
+ range.color = {style: "dojoxGaugeRange"+colorIndex};
+ }else{
+ colorIndex = this._rangeData.length % this.defaultColors.length;
+ range.color = this.defaultColors[colorIndex];
+ }
+ }
+ this._rangeData[this._rangeData.length] = range;
+ }
+ this.draw();
+ },
+
+ _addScaleTick: function(/*Object*/indicator, /*Boolean*/ major){
+ // summary:
+ // Adds a scale ticks, that is an indicator.
+ // description:
+ // This method adds a tick mark to the gauge
+ // indicator: dojox.gauges._Indicator
+ // A dojox.gauges._Indicator or an object with similar parameters
+ // (value, color, offset, etc.).
+
+ if(!indicator.declaredClass){// !== 'dojox.gauges.Indicator'){
+ // We were passed a plain object, need to make an indicator out of it.
+ indicator = new this._defaultIndicator(indicator);
+ }
+
+ indicator._gauge = this;
+ if (major){
+ if (!this._majorTicksData){
+ this._majorTicksData = [];
+ }
+ this._majorTicksData[this._majorTicksData.length] = indicator;
+ indicator.draw(this._majorTicksGroup);
+ } else {
+ if (!this._minorTicksData){
+ this._minorTicksData = [];
+ }
+ this._minorTicksData[this._minorTicksData.length] = indicator;
+ indicator.draw(this._minorTicksGroup);
+ }
+ return indicator;
+ },
+
+ _removeScaleTick: function(/*Object*/indicator){
+ // summary:
+ // Removes the given scale tick from the gauge by calling it's remove function
+ // and removing it from the local cache.
+ var i;
+ if (this._majorTicksData) for (i = 0; i < this._majorTicksData.length; i++){
+ if (this._majorTicksData[i] === indicator){
+ this._majorTicksData.splice(i, 1);
+ indicator.remove();
+ return;
+ }
+ }
+ if (this._minorTicksData) for (i = 0; i < this._minorTicksData.length; i++){
+ if (this._minorTicksData[i] === indicator){
+ this._minorTicksData.splice(i, 1);
+ indicator.remove();
+ return;
+ }
+ }
+ },
+
+ addIndicator: function(/*Object*/indicator){
+ // summary:
+ // This method is used to add an indicator to the gauge.
+ // description:
+ // This method adds an indicator, such as a t needle,
+ // to the gauge.
+ // indicator: dojox.gauges._Indicator
+ // A dojox.gauges._Indicator or an object with similar parameters
+ // (value, color, offset, etc.).
+
+ if(!indicator.declaredClass){// !== 'dojox.gauges.Indicator'){
+ // We were passed a plain object, need to make an indicator out of it.
+ indicator = new this._defaultIndicator(indicator);
+ }
+ indicator._gauge = this;
+ if(!indicator.hideValue){
+ this.containerNode.appendChild(indicator.domNode);
+ }
+ if(!this._indicatorData){this._indicatorData = [];}
+ this._indicatorData[this._indicatorData.length] = indicator;
+ indicator.draw(this._indicatorsGroup);
+ return indicator;
+ },
+
+ removeIndicator: function(/*Object*/indicator){
+ // summary:
+ // Removes the given indicator from the gauge by calling it's remove function
+ // and removing it from the local cache.
+ // indicator: dojox.gauges._Indicator
+ // The indicator to remove.
+ for(var i=0; i<this._indicatorData.length; i++){
+ if(this._indicatorData[i] === indicator){
+ this._indicatorData.splice(i, 1);
+ indicator.remove();
+ break;
+ }
+ }
+ },
+
+ moveIndicatorToFront: function(/*Object*/indicator){
+ // summary:
+ // This function is used to move an indicator the the front (top)
+ // of the gauge
+ // indicator: dojox.gauges._Indicator
+ // A dojox.gauges._Indicator or an object with similar parameters
+ // (value, color, offset, etc.).
+ if(indicator.shape)
+ indicator.shape.moveToFront();
+
+ },
+
+ drawText: function(/*dojox.gfx.Group*/ group, /*String*/txt, /*Number*/x, /*Number*/y, /*String?*/align, /*String?*/color, /*Object?*/font){
+ // summary:
+ // This function is used draw text onto the gauge. The text object
+ // is also returned by the function so that may be removed later
+ // by calling removeText
+ // group: dojox.gfx.Group
+ // The GFX Group where the text will be added.
+ // txt: String
+ // The text to be drawn
+ // x: Number
+ // The x coordinate at which to place the text
+ // y: Number
+ // The y coordinate at which to place the text
+ // align?: String
+ // Indicates how to align the text
+ // Valid value is 'right', otherwise text is left-aligned
+ // color?: String
+ // Indicates the color of the text
+ // font?: Object
+ // A font object, generally of the following format:
+ // {family: "Helvetica", style: "italic", variant: 'small-caps', weight: 'bold', size: "18pt"}
+
+ var t = group.createText({x: x, y: y, text: txt, align: align});
+ t.setFill(color ? color: 'black');
+ if (font) t.setFont(font);
+ return t;
+ },
+
+ removeText:function(/*String*/t){
+ // summary:
+ // Removes a text element from the gauge.
+ // t: String
+ // The text to remove.
+ if (t.parent)
+ t.parent.remove(t);
+ },
+
+ updateTooltip: function(/*String*/txt, /*Event*/ e){
+ // summary:
+ // Updates the tooltip for the gauge to display the given text.
+ // txt: String
+ // The text to put in the tooltip.
+
+ if (this.useTooltip) {
+ require(["dijit/Tooltip"], dojo.hitch(this, function(Tooltip){
+ if (this._lastHover != txt) {
+ if (txt !== '') {
+ Tooltip.hide(this.mouseNode);
+ Tooltip.show(txt, this.mouseNode, !this.isLeftToRight());
+ } else {
+ Tooltip.hide(this.mouseNode);
+ }
+ this._lastHover = txt;
+ }
+ }));
+ }
+ },
+
+ handleMouseOver: function(/*Object*/e){
+ // summary:
+ // This is an internal handler used by the gauge to support
+ // hover text
+ // e: Object
+ // The event object
+
+ if (this.image && this.image.overlay){
+ if (e.target == this._img.getEventSource()){
+ var hover;
+ this._overOverlay = true;
+ var r = this.getRangeUnderMouse(e);
+ if (r && r.hover){
+ hover = r.hover;
+ }
+
+ if (this.useTooltip && !this._drag){
+ if (hover){
+ this.updateTooltip(hover, e);
+ } else {
+ this.updateTooltip('', e);
+ }
+ }
+ }
+ }
+ },
+
+ handleMouseOut: function(/*Object*/e){
+ // summary:
+ // This is an internal handler used by the gauge to support
+ // hover text
+ // e: Object
+ // The event object
+
+ this._overOverlay = false;
+ this._hideTooltip();
+ },
+
+ handleMouseMove: function(/*Object*/e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to show the tooltips
+ // e: Object
+ // The event object
+
+ if (this.useTooltip) {
+ if (e) {
+ html.style(this.mouseNode, 'left', e.pageX + 1 + 'px');
+ html.style(this.mouseNode, 'top', e.pageY + 1 + 'px');
+ }
+ if (this._overOverlay) {
+ var r = this.getRangeUnderMouse(e);
+ if (r && r.hover) {
+ this.updateTooltip(r.hover, e);
+ } else {
+ this.updateTooltip('', e);
+ }
+ }
+ }
+ },
+
+ handleMouseDown: function(e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to move indicators
+ // e: Object
+ // The event object
+ var indicator = this._getInteractiveIndicator();
+ if (indicator){
+ this._handleMouseDownIndicator(indicator, e);
+ }
+ },
+
+ _handleDragInteractionMouseMove: function(e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to drag an indicator to modify it's value
+ // e: Object
+ // The event object
+
+ if(this._drag){
+ this._dragIndicator(this, e);
+ event.stop(e);
+ }
+ },
+
+ _handleDragInteractionMouseUp: function(/*Object*/e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to drag an indicator to modify it's value
+ // e: Object
+ // The event object
+ this._drag = null;
+
+ for (var i = 0 ; i < this._mouseListeners.length; i++){
+ connect.disconnect(this._mouseListeners[i]);
+ }
+ this._mouseListeners = [];
+ event.stop(e);
+ },
+
+ _handleMouseDownIndicator: function (indicator, e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to drag an indicator to modify it's value
+ // indicator: _Indicator
+ // The indicator object
+ // e:Object
+ // The event object
+
+ if (!indicator.noChange){
+ if (!this._mouseListeners) this._mouseListeners = [];
+ this._drag = indicator;
+ this._mouseListeners.push(connect.connect(document, "onmouseup", this, this._handleDragInteractionMouseUp));
+ this._mouseListeners.push(connect.connect(document, "onmousemove", this, this._handleDragInteractionMouseMove));
+ this._mouseListeners.push(connect.connect(document, "ondragstart", this, event.stop));
+ this._mouseListeners.push(connect.connect(document, "onselectstart", this, event.stop));
+ this._dragIndicator(this, e);
+ event.stop(e);
+ }
+ },
+
+ _handleMouseOverIndicator: function (indicator, e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to drag an indicator to modify it's value
+ // indicator: _Indicator
+ // The indicator object
+ // e: Object
+ // The event object
+ if (this.useTooltip && !this._drag){
+
+ if (indicator.hover){
+ require(["dijit/Tooltip"], dojo.hitch(this, function(Tooltip){
+ html.style(this.mouseNode, 'left', e.pageX + 1 + 'px');
+ html.style(this.mouseNode, 'top', e.pageY + 1 + 'px');
+ Tooltip.show(indicator.hover, this.mouseNode, !this.isLeftToRight());
+ }));
+ } else {
+ this.updateTooltip('', e);
+ }
+ }
+
+ if (indicator.onDragMove && !indicator.noChange){
+ this.gaugeContent.style.cursor = 'pointer';
+ }
+ },
+
+ _handleMouseOutIndicator: function (indicator, e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // the mouse to drag an indicator to modify it's value
+ // indicator: _Indicator
+ // The indicator object
+ // e: Object
+ // The event object
+ this._hideTooltip();
+ this.gaugeContent.style.cursor = 'pointer';
+
+ },
+
+ _hideTooltip: function(){
+ if (this.useTooltip && this.mouseNode) {
+ require(["dijit/Tooltip"], dojo.hitch(this, function(Tooltip){
+ Tooltip.hide(this.mouseNode);
+ }));
+ }
+ },
+
+ _handleMouseOutRange: function ( range, e){
+ this._hideTooltip();
+ },
+
+ _handleMouseOverRange: function (range, e){
+ if (this.useTooltip && !this._drag){
+ if (range.hover) {
+ html.style(this.mouseNode, 'left', e.pageX + 1 + 'px');
+ html.style(this.mouseNode, 'top', e.pageY + 1 + 'px');
+ require(["dijit/Tooltip"], dojo.hitch(this, function(Tooltip){
+ Tooltip.show(range.hover, this.mouseNode, !this.isLeftToRight());
+ }));
+ } else {
+ this.updateTooltip('', e);
+ }
+ }
+ },
+
+ handleTouchStartIndicator: function(indicator, e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // touch events to drag an indicator to modify it's value
+ // indicator: _Indicator
+ // The indicator object
+ // e: Object
+ // The event object
+ if (!indicator.noChange){
+ this._drag = indicator;
+ event.stop(e);
+ }
+ },
+
+ handleTouchStart: function(e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // touch events to drag an indicator to modify it's value
+ // e: Object
+ // The touch event object
+ this._drag = this._getInteractiveIndicator();
+ this.handleTouchMove(e); //drag indicator to touch position
+ },
+
+ handleTouchEnd: function(e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // touch events to drag an indicator to modify it's value
+ // e: Object
+ // The touch e object
+ if (this._drag){
+ this._drag = null;
+ event.stop(e);
+ }
+ },
+
+ handleTouchMove: function(e){
+ // summary:
+ // This is an internal handler used by the gauge to support using
+ // touch events to drag an indicator to modify it's value
+ // e: Object
+ // The touch event object
+
+ if (this._drag && !this._drag.noChange){
+ var touches = e.touches;
+ var firstTouch = touches[0];
+ this._dragIndicatorAt(this, firstTouch.pageX, firstTouch.pageY);
+ event.stop(e);
+ }
+ },
+
+ _getInteractiveIndicator: function(){
+ for (var i = 0; i < this._indicatorData.length; i++){
+ var indicator = this._indicatorData[i];
+ if (indicator.interactionMode == "gauge" && !indicator.noChange){
+ return indicator;
+ }
+ }
+ return null;
+ }
+});
+});
+
generated by cgit v1.0-28-g1787 at 2026-01-10 00:04:04 +0000