view release on metacpan or  search on metacpan

lib/Apache/UploadMeter/Resources/JavaScript.pm  view on Meta::CPAN

    if (typeof options.style == 'string') {
      if(options.style.indexOf(':') == -1) {
        var cssText = '', selector = '.' + options.style;
        $A(document.styleSheets).reverse().each(function(styleSheet) {
          if (styleSheet.cssRules) cssRules = styleSheet.cssRules;
          else if (styleSheet.rules) cssRules = styleSheet.rules;
          $A(cssRules).reverse().each(function(rule) {
            if (selector == rule.selectorText) {
              cssText = rule.style.cssText;
              throw $break;
            }
          });
          if (cssText) throw $break;
        });
        this.style = cssText.parseStyle();
        options.afterFinishInternal = function(effect){
          effect.element.addClassName(effect.options.style);
          effect.transforms.each(function(transform) {
            if(transform.style != 'opacity')
              effect.element.style[transform.style.camelize()] = '';
          });
        }
      } else this.style = options.style.parseStyle();
    } else this.style = $H(options.style)
    this.start(options);
  },
  setup: function(){
    function parseColor(color){
      if(!color || ['rgba(0, 0, 0, 0)','transparent'].include(color)) color = '#ffffff';
      color = color.parseColor();
      return $R(0,2).map(function(i){
        return parseInt( color.slice(i*2+1,i*2+3), 16 ) 
      });
    }
    this.transforms = this.style.map(function(pair){
      var property = pair[0].underscore().dasherize(), value = pair[1], unit = null;

      if(value.parseColor('#zzzzzz') != '#zzzzzz') {
        value = value.parseColor();
        unit  = 'color';
      } else if(property == 'opacity') {
        value = parseFloat(value);
        if(/MSIE/.test(navigator.userAgent) && !window.opera && (!this.element.currentStyle.hasLayout))
          this.element.setStyle({zoom: 1});
      } else if(Element.CSS_LENGTH.test(value)) 
        var components = value.match(/^([\+\-]?[0-9\.]+)(.*)$/),
          value = parseFloat(components[1]), unit = (components.length == 3) ? components[2] : null;

      var originalValue = this.element.getStyle(property);
      return $H({ 
        style: property, 
        originalValue: unit=='color' ? parseColor(originalValue) : parseFloat(originalValue || 0), 
        targetValue: unit=='color' ? parseColor(value) : value,
        unit: unit
      });
    }.bind(this)).reject(function(transform){
      return (
        (transform.originalValue == transform.targetValue) ||
        (
          transform.unit != 'color' &&
          (isNaN(transform.originalValue) || isNaN(transform.targetValue))
        )
      )
    });
  },
  update: function(position) {
    var style = $H(), value = null;
    this.transforms.each(function(transform){
      value = transform.unit=='color' ?
        $R(0,2).inject('#',function(m,v,i){
          return m+(Math.round(transform.originalValue[i]+
            (transform.targetValue[i] - transform.originalValue[i])*position)).toColorPart() }) : 
        transform.originalValue + Math.round(
          ((transform.targetValue - transform.originalValue) * position) * 1000)/1000 + transform.unit;
      style[transform.style] = value;
    });
    this.element.setStyle(style);
  }
});

Effect.Transform = Class.create();
Object.extend(Effect.Transform.prototype, {
  initialize: function(tracks){
    this.tracks  = [];
    this.options = arguments[1] || {};
    this.addTracks(tracks);
  },
  addTracks: function(tracks){
    tracks.each(function(track){
      var data = $H(track).values().first();
      this.tracks.push($H({
        ids:     $H(track).keys().first(),
        effect:  Effect.Morph,
        options: { style: data }
      }));
    }.bind(this));
    return this;
  },
  play: function(){
    return new Effect.Parallel(
      this.tracks.map(function(track){
        var elements = [$(track.ids) || $$(track.ids)].flatten();
        return elements.map(function(e){ return new track.effect(e, Object.extend({ sync:true }, track.options)) });
      }).flatten(),
      this.options
    );
  }
});

Element.CSS_PROPERTIES = $w(
  'backgroundColor backgroundPosition borderBottomColor borderBottomStyle ' + 
  'borderBottomWidth borderLeftColor borderLeftStyle borderLeftWidth ' +
  'borderRightColor borderRightStyle borderRightWidth borderSpacing ' +
  'borderTopColor borderTopStyle borderTopWidth bottom clip color ' +
  'fontSize fontWeight height left letterSpacing lineHeight ' +
  'marginBottom marginLeft marginRight marginTop markerOffset maxHeight '+
  'maxWidth minHeight minWidth opacity outlineColor outlineOffset ' +
  'outlineWidth paddingBottom paddingLeft paddingRight paddingTop ' +
  'right textIndent top width wordSpacing zIndex');
  
Element.CSS_LENGTH = /^(([\+\-]?[0-9\.]+)(em|ex|px|in|cm|mm|pt|pc|\%))|0$/;

lib/Apache/UploadMeter/Resources/JavaScript.pm  view on Meta::CPAN

        } catch (e) {
            this.dispatchException(e);
        }

        if (json.finished) {
            this.stop();
            try {
                (this.options.onFinished || Prototype.emptyFunction)(json, last);
                UploadMeter.Responders.dispatch('onFinished', this, json, last);
            } catch (e) {
                this.dispatchException(e);
            }
        }
        this.__updategui(progress);
    },
     
    // Internal update function
    __updategui: function(len) {
        
        if (len > 100) {
            len = 100;
        }
        
        len = Util.formatDec(len);
        var temp = Builder.node( "div", {className:'meterunderlay slider'});
        this.main.appendChild(Element.hide(temp));
        temp = $(temp);
        Position.absolutize(temp);
        Position.clone(this.main, temp);

        temp.setStyle({
                       width: ((parseInt(this.main.getStyle('width')) * len / 100) - parseInt(this.ul.getStyle('width'))) + "px",
                        left:  (parseInt(this.ul.getStyle('left')) + parseInt(this.ul.getStyle('width'))) + "px"});
        Element.update(this.desc, len + "%");
        this.__slide(temp);
    },
    
    dispatchException: function(exception) {
        (this.options.onException || Prototype.emptyFunction)(this, exception);
        UploadMeter.Responders.dispatch('onException', this, exception);
    }   
    
};

// Global responder "hook" objects stolen from Ajax
UploadMeter.Responders = Object.extend({}, Ajax.Responders);
UploadMeter.Responders.responders = []; // Clear our responders
UploadMeter.Responders.dispatch = function(callback, meter, status, laststatus) {
    this.each(function(responder) {
      if (typeof responder[callback] == 'function') {
        try {
          responder[callback].apply(responder, [meter, status, laststatus]);
        } catch (e) {}
      }
    });
};
Object.extend(UploadMeter.Responders, Enumerable);

var Util = {
    formatTime: function(timestamp) {
        if (isNaN(timestamp)) {
            return timestamp;
        }
        
        if (!(isFinite(timestamp))) {
            return "Unknown";
        }
        
        var oH, oM, oS, str;
        
        str = "";
        oS = Math.floor(timestamp % 60);
        oM = Math.floor((timestamp / 60) % 60);
        oH = Math.floor(timestamp / 60 / 60);       
        
        if (oH > 0) {
            str = oH + ":";
        } 
        
        str = str + ((oM == 0) ? "00:" : ((oM < 10) ? "0" + oM + ":" : oM + ":"));
        str = str + ((oS == 0) ? "00" : ((oS < 10) ? "0" + oS : oS));
        
        return str;
    },
    formatDec: function (val) {
        sign = val < 0 ? "-":"";
        rval = Math.abs(Math.round(val*100));
        str = rval.toString();
        if(rval < 10) str = "0.0"+str;
        else if(rval < 100) str = "0."+str;
        else str = str.substring(0, str.length-2)
           + "." + str.substring(str.length-2, str.length);
        return sign+str;
    }
};

// Default behavior code
var aum_el;

function addMeterURL(url) {
    try {
      if (url.indexOf('?') >= 0) {
          return url + "&meter_id=" + meter_id;
      } else {
          return url + "?meter_id=" + meter_id;
      }
    } catch (e) {}
}

function aum_popup() {
    var aum = window.open(meter_url + "/styles/aum_popup.html" ,"_new","toolbar=no,location=no,directories=no,status=yes,menubar=no,scrollbars=no,resizeable=no,width=450,height=240");
    // Pass our info to the child window's global obj
    Object.extend(aum, {'meter_id': meter_id, 'meter_url': meter_url});
}

var rules={
    '.uploadform':function(el) {
      el.action = addMeterURL(el.action);
      aum_el = $(el); // Put this in a global so we can unregister later, if needed
      Event.observe(aum_el, 'submit', aum_popup);
    }