Uniformly scale an element along both axis'.
@param {Float} progress  Current progress data of the scene, between 0 and 1.
@this {Object}
@return {void}
971810
function scale(progress) {
  var to = (this.options.to !== undefined) ? this.options.to : 1;
  var from = (this.options.from !== undefined) ? this.options.from : this.transforms.scale[0];
  var scale = (to - from) * progress + from;

  this.transforms.scale[0] = scale;
  this.transforms.scale[1] = scale;
}
1322740
function updateTimeProgression(curve, x, y) {
        var percentX = Math.round(100 * x / WIDTH_MAIN),
            percentY = Math.round(100 * ((HEIGHT_MAIN - y) / HEIGHT_MAIN));

        // Constrain horizontal percentage to [0, 100] range
        percentX = Math.min(Math.max(0, percentX), 100);

        curve.parentNode.setAttribute("data-time", percentX);
        curve.parentNode.setAttribute("data-progression", percentY);
    }
324746
function(sx, sy) {
                this.callBase({
                    beginValue: 0,
                    finishValue: 1,
                    setter: function(target, value, timeline) {
                        var delta = timeline.getDelta();
                        var kx = Math.pow(sx, delta);
                        var ky = Math.pow(sy, delta);
                        target.scale(ky, kx);
                    }
                });
            }
422332
function setTouchInProgress(val) {
			
			//Add or remove event listeners depending on touch status
			if(val===true) {
				$element.bind(MOVE_EV, touchMove);
				$element.bind(END_EV, touchEnd);
				
				//we only have leave events on desktop, we manually calcuate leave on touch as its not supported in webkit
				if(LEAVE_EV) { 
					$element.bind(LEAVE_EV, touchLeave);
				}
			} else {
				$element.unbind(MOVE_EV, touchMove, false);
				$element.unbind(END_EV, touchEnd, false);
			
				//we only have leave events on desktop, we manually calcuate leave on touch as its not supported in webkit
				if(LEAVE_EV) { 
					$element.unbind(LEAVE_EV, touchLeave, false);
				}
			}
			
		
			//strict equality to ensure only true and false can update the value
			$element.data(PLUGIN_NS+'_intouch', val === true);
		}
32230
public void updateProgress(float progress) {
        if (mLastProgress == progress) {
            return;
        }
        mLastProgress = progress;
        //TODO this makes ViewPager work, but will probably break more complex transition setup, will think of a better solution
        if (mUpdateStateAfterUpdateProgress) {
            boolean positive = progress >= 0;
            TransitionController transitionController;
            for (int i = 0, size = mTransitionControls.size(); i < size; i++) {
                transitionController = mTransitionControls.get(i);
                if (positive) {
                    if (transitionController.getEnd() > 0) {
                        transitionController.setEnable(true);
                    } else {
                        transitionController.setEnable(false);
                    }
                } else {
                    if (transitionController.getEnd() < 0) {
                        transitionController.setEnable(true);
                    } else {
                        transitionController.setEnable(false);
                    }
                }
            }
        }

        TransitionController transitionController;
        for (int i = 0, size = mTransitionControls.size(); i < size; i++) {
            transitionController = mTransitionControls.get(i);
            if (transitionController.isEnable()) {
                transitionController.updateProgress(progress);
            }
        }
    }
635515
public void scale(float sx, float sy) {
		this.sx = this.sx * sx;
		this.sy = this.sy * sy;
		
		checkPush();

		predraw();
		GL.glScalef(sx, sy, 1);
		postdraw();
	}
519246
function _progress(lengthComputable, loaded, total) {
    var event = new _Event('progress');
    event.target = this;
    event.lengthComputable = lengthComputable;
    event.loaded = loaded;
    event.total = total;
    this.dispatchEvent(event);
  }
309778
function(width, height) {
        // XXX this should subtract the axis widths...

        var MIN_PIXELS_PER_POINT = 2;
        var limit = this._attributes.downsample ? width / MIN_PIXELS_PER_POINT : Infinity;
        this.chart.set_downsample_limit(limit);
        _.each(this.dataTargets, function(target) {
            target.set_downsample_limit(limit);
        } );

        this.chart.resize(width, height);

        this.legend.resize(width, height);

        if (this.contextChart) {
            this.contextChart.resize(width);
        }
    }
1006758
function scale(x, y, z) {
         y = typeof y !== "undefined" ? y : x;
         z = typeof z !== "undefined" ? z : x;
         return this._set(this._x * x, this._y * y, this._z * z);
       }
1023466
function parallax(progress) {
  var range = this.options.range || 0;
  var offset = progress * range;        // TODO add provision for speed as well

  this.transforms.position[1] = offset;   // just vertical for now
}
173843
function (e, data) {
                var $this = $(this),
                    progress = Math.floor(data.loaded / data.total * 100),
                    globalProgressNode = $this.find('.fileupload-progress'),
                    extendedProgressNode = globalProgressNode
                        .find('.progress-extended');
                if (extendedProgressNode.length) {
                    extendedProgressNode.html(
                        ($this.data('blueimp-fileupload') || $this.data('fileupload'))
                            ._renderExtendedProgress(data)
                    );
                }
                globalProgressNode
                    .find('.progress')
                    .attr('aria-valuenow', progress)
                    .find('.bar').css(
                        'width',
                        progress + '%'
                    );
            }
53347
public void setScale(float scale) {
		this.scale = scale;
		linePaint.setStrokeWidth(scale * lineStrokeWidth);
		polygonPaint.setStrokeWidth(scale * polygonStrokeWidth);
		featurePaintCache.clear();
	}
856758
public void setProgress(float percent){
		if(mCircular)
			((CircularProgressDrawable)mProgressDrawable).setProgress(percent);
		else
			((LinearProgressDrawable)mProgressDrawable).setProgress(percent);
	}
585582
function( value, axis ){
			if( !value ) return 0;
			if( typeof value === 'number' ) return value;
			// a percentage
			return parseInt(value, 10) / 100 *
				(axis === 'x' ? this.canvas.width : this.canvas.height);
		}
975517
function ( colors, progress, type ) {
            if (progress > 1) {
                progress = 1;
            } else if (progress < 0) {
                progress = 0;
            }
            var colorNum = colors.length,
                sectionPer, section, sPercent;
            if (colorNum < 2) return colors[0];
            sectionPer = 1 / (colorNum - 1);
            section = Math.floor(progress / sectionPer);
            if (section < 0) return colors[0];
            if (section < colorNum - 1) {
                sPercent = (progress % sectionPer) / sectionPer;
                return this.mix( colors[section], colors[section + 1], sPercent, type );
            }
            return colors[colorNum - 1];
        }
155230
private void setAnimationProgress(float progress) {
        if (isAlphaUsedForScale()) {
            setColorViewAlpha((int) (progress * MAX_ALPHA));
        } else {
            ViewCompat.setScaleX(mCircleView, progress);
            ViewCompat.setScaleY(mCircleView, progress);
        }
    }
155527
public void setProgress(int progress) {
        if (progress > mMax || progress < 0) {
            throw new IllegalArgumentException(
                    String.format("Progress (%d) must be between %d and %d", progress, 0, mMax));
        }
        mProgress = progress;
        if (null != mListener) {
            if (mProgress == mMax) {
                mListener.onProgressCompleted();
            } else {
                mListener.onProgressChanged(mProgress, mMax);
            }
        }
        invalidate();
    }