rsence-pre 2.1.0.1.pre

data/js/core/event/event.js

@@ -0,0 +1,153 @@
+/*   RSence
+ *   Copyright 2007 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+
+/*** = Description
+  ** Abstracts the DOM Event differences between browsers.
+***/
+var//RSence.Core
+Event = {
+  
+/** Returns the element of the event.
+  **/
+  element: function(e) {
+    return e.target || e.srcElement;
+  },
+  
+/** Returns the mouse cursor x -coordinate of the event.
+  **/
+  pointerX: function(e) {
+    return e.pageX || e.clientX + document.documentElement.scrollLeft;
+  },
+
+/** Returns the mouse cursor y -coordinate of the event.
+  **/
+  pointerY: function(e) {
+    return e.pageY || e.clientY + document.documentElement.scrollTop;
+  },
+
+/** Stops event propagation
+  **/
+  stop: function(e) {
+    if (e.preventDefault) {
+      e.preventDefault();
+      e.stopPropagation();
+    }
+    else {
+      e.returnValue = false;
+      e.cancelBubble = true;
+    }
+  },
+  
+/** Returns true if the left mouse butten was clicked.
+  **/
+  isLeftClick: function(e) {
+    // IE: left 1, middle 4, right 2
+    if (BROWSER_TYPE.ie) {
+      return (e.button === 1 || e.button === 3 || e.button === 5);
+    }
+    else {
+      return (e.button === 0);
+    }
+  },
+  
+/** List of event observers
+  **/
+  observers: false,
+  
+  /* Implementation of observe */
+  _observeAndCache: function(_elem, _name, _function, _useCapture) {
+    if (!Event.observers) {
+      Event.observers = [];
+    }
+    if (_elem.addEventListener) {
+      this.observers.push([_elem, _name, _function, _useCapture]);
+      _elem.addEventListener(_name, _function, _useCapture);
+    }
+    else if (_elem.attachEvent) {
+      this.observers.push([_elem, _name, _function, _useCapture]);
+      _elem.attachEvent("on" + _name, _function);
+    }
+  },
+  
+/** Flushes the event observer cache.
+  **/
+  unloadCache: function() {
+    if (!Event.observers) {
+      return;
+    }
+    var i,
+        l = Event.observers.length;
+    for (i = 0; i < l; i++) {
+      try {
+        Event.stopObserving.apply(this, Event.observers[0]);
+      }
+      catch(e){}
+    }
+    Event.observers = false;
+  },
+  
+/** Starts observing the named event of the element and 
+  * specifies a callback function.
+  **/
+  observe: function(_elem, _name, _function, _useCapture) {
+    _useCapture = _useCapture || false;
+    Event._observeAndCache(_elem, _name, _function, _useCapture);
+  },
+  
+/** Stops observing the named event of the element and
+  * removes the callback function.
+  **/
+  stopObserving: function(_elem, _name, _function, _useCapture) {
+    if (_elem === undefined) {
+      console.log('Warning Event.stopObserving of event name: "' + _name + '" called with an undefined elem!');
+      return;
+    }
+    _useCapture = _useCapture || false;
+    if (_elem['removeEventListener']) {
+      _elem.removeEventListener(_name, _function, _useCapture);
+    }
+    else if (detachEvent) {
+      _elem.detachEvent("on" + _name, _function);
+    }
+    var i = 0;
+    while (i < Event.observers.length) {
+      var eo = Event.observers[i];
+      if (eo && eo[0] === _elem && eo[1] === _name && eo[2] === _function && eo[3] === _useCapture) {
+        Event.observers[i] = null;
+        Event.observers.splice(i, 1);
+      }
+      else {
+        i++;
+      }
+    }
+  },
+  
+  // List of ASCII "special characters":
+  KEY_BACKSPACE: 8,
+  KEY_TAB: 9,
+  KEY_RETURN: 13,
+  KEY_ESC: 27,
+  KEY_LEFT: 37,
+  KEY_UP: 38,
+  KEY_RIGHT: 39,
+  KEY_DOWN: 40,
+  KEY_DELETE: 46,
+  KEY_HOME: 36,
+  KEY_END: 35,
+  KEY_PAGEUP: 33,
+  KEY_PAGEDOWN: 34
+  
+};
+
+// Activates the garbage collector of Internet Explorer 
+// when the document is unloaded:
+if (BROWSER_TYPE.ie) {
+  Event.observe(window, "unload", Event.unloadCache, false);
+}
+

data/js/core/iefix/ie_css_element.htc

@@ -0,0 +1,5 @@
+<PUBLIC:COMPONENT lightWeight="true">
+<script type="text/javascript">
+try{element.attachEvent("onpropertychange",iefix.htcElementEntry);}catch(e){window.status=e;}
+</script>
+</PUBLIC:COMPONENT>

data/js/core/iefix/ie_css_style.htc

@@ -0,0 +1,5 @@
+<PUBLIC:COMPONENT lightWeight="true">
+<script type="text/javascript">
+  element.attachEvent("onreadystatechange", iefix.htcStyleEntry);
+</script>
+</PUBLIC:COMPONENT>

data/js/core/iefix/iefix.js

@@ -0,0 +1,359 @@
+/*   RSence
+ *   Copyright 2006 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+// Injects htc stuff into IE
+ie_htc_path = null;
+function ie_early_fixes() {
+  try{
+    document.execCommand("BackgroundImageCache",false,true);
+  }
+  catch(e){}
+  
+  var _script = document.scripts[document.scripts.length - 1],
+      _src = _script.src;
+  
+  ie_htc_path = _src.substring(0, _src.lastIndexOf("/") + 1);
+  
+}
+ie_early_fixes();
+
+/***
+**** iefix contains a collection of fixes for IE's bad behavior
+***/
+iefix = {
+  
+  // call this on resize, loaded events:
+  setWinSize: function(){
+    window.innerWidth=document.documentElement.clientWidth;
+    window.innerHeight=document.documentElement.clientHeight;
+  },
+  
+  // checks if the element has the .hasLayout flag set:
+  _hasLayout: function(_element){
+    return _element.currentStyle.hasLayout;
+  },
+  
+  // finds the next parent with fixed or absolute positioning:
+  // NOTICE: .init() makes ._layoutHeight() from this by replacing width with height
+  layoutWidth: function(_element) {
+    var _this=iefix,
+        _parent,
+        i=0,
+        // gets the parent from which the width is calculated
+        _layoutParent=_element.offsetParent;
+    while(_layoutParent&&!_this._hasLayout(_layoutParent)){
+      _layoutParent=_layoutParent.offsetParent;
+    }
+    if(!_layoutParent._resizewidthElements){
+      _layoutParent._resizewidthElements=[];
+    }
+    if(!_element._addedResizewidthFix){
+      _layoutParent._resizewidthElements.push(_element);
+      _parent=_layoutParent;
+      while(_parent.offsetParent){
+        _parent=_parent.offsetParent;
+        if(_parent._resizewidthElements){_parent._resizewidthElements.push(_element);}
+        if(_parent.style.position==="absolute"||_parent.style.position==="fixed"){break;}
+      }
+      _element._addedResizewidthFix=true;
+    }
+    if(!_layoutParent._resizewidth){
+      _layoutParent.attachEvent("onpropertychange", function(){
+        if(window.event.propertyName==="style.width"){
+          for (;i<_layoutParent._resizewidthElements.length;i++){
+            _this.resizeRight(_layoutParent._resizewidthElements[i]);
+          }
+        }
+      });
+      _layoutParent._resizewidth=true;
+    }
+    return (_layoutParent||document.documentElement).clientWidth;
+  },
+  
+  // // calculates the border width of the _element:
+  // // NOTICE: .init() makes ._getBorderHeight() from this by replacing Width with Height
+  // getBorderWidth: function(_element){
+  //   return _element.offsetWidth-_element.clientWidth;
+  // },
+  
+  // calculates the actual value in pixels from _value:
+  getPixelValue: function(_element,_value) {
+    var _this=iefix,_style,_runtimeStyle;
+    if(_this._PIXEL.test(_value)){return parseInt(_value,10);}
+    // saves style in temp
+    _style=_element.style.left;
+    _runtimeStyle=_element.runtimeStyle.left;
+    _element.runtimeStyle.left=_element.currentStyle.left;
+    _this.resizing=true;
+    _element.style.left=_value||0;
+    // has pixel value
+    _value=_element.style.pixelLeft;
+    _element.style.left=_style;
+    _this.resizing=false;
+    _element.runtimeStyle.left=_runtimeStyle;
+    return _value;
+  },
+  
+  // calculates pixel value from the value given (even percentages)
+  // NOTICE: .init() makes ._getPixelHeght() from this by replacing Width with Height
+  getPixelWidth: function(_element,_value){
+    var _this=iefix;
+    if(_this._PERCENT.test(_value)){return parseInt(parseFloat(_value)/100*_this.layoutWidth(_element),10);}
+    return _this.getPixelValue(_element, _value);
+  },
+  
+  // // calculates padding width of the _element:
+  // // NOTICE: .init() makes .getPaddingHeight() from this by replacing Left/Right/Width with Top/Bottom/Height
+  // // NOTICE: .init() also makes ._getMarginWidth() and ._getMarginHeight from this.
+  // getPaddingWidth: function(_element) {
+  //   var _this=iefix;
+  //   return _this.getPixelWidth(_element,_element.currentStyle.paddingLeft)+_this.getPixelWidth(_element,_element.currentStyle.paddingRight);
+  // },
+  
+  // calculates element's position from the right edge of the parent:
+  // NOTICE: .init() makes _resizeBottom() from this by replacing left/width with top/height
+  resizeRight: function(_element){
+    var _this=iefix,_left,_width;
+    //window.status = 'resizeRight';
+    if(_element.currentStyle===null){return;}
+    _left=parseInt(_element.currentStyle.left,10);
+    _width=_this.layoutWidth(_element)-parseInt(_element.currentStyle.right,10)-_left;
+    if(parseInt(_element.runtimeStyle.width,10)===_width){return;}
+    _element.runtimeStyle.width="";
+    if(_element.offsetWidth<_width){
+      // Disabled, because no-one uses quirks mode anymore, right?
+      // _width-=_this.getBorderWidth(_element)+_this.getPaddingWidth(_element);
+      if(_width<0){_width=0;}
+      _element.runtimeStyle.width=_width;
+    }
+  },
+  
+  // (css-property) opacity fix:
+  fixOpacity: function(_element){
+    var _opacity=(parseFloat(_element.currentStyle.opacity)*100)||1,
+        _filter=_element.filters["DXImageTransform.Microsoft.Alpha"];
+    if(_filter){_filter.Opacity=_opacity;_filter.Enabled=true;}
+    else{_element.runtimeStyle.filter+="progid:DXImageTransform.Microsoft.Alpha(opacity="+_opacity+")";}
+  },
+  
+  // png background image fix:
+  fixBackgroundImage: function(_element) {
+    //window.status='fixBackgroundImage: ';
+    var _this=iefix,_url,_filter;
+    _url=_element.currentStyle.backgroundImage.match(/url\(\s*['"]?([^'")]+)['"]?\s*\)/);
+    //window.status+=' url:'+_url;
+    //window.status+=' pngCheck:'+_this.pngCheck.test(_url);
+    if(!_url){return;}
+    else{_url=_url[1];}
+    _filter=_element.filters["DXImageTransform.Microsoft.AlphaImageLoader"];
+    if(_this.pngCheck.test(_url)){ // needs more work
+      // access before filter is set makes error
+      if(_filter){
+        _filter.sizingMethod="crop";
+        _filter.src=_url;
+        _filter.Enabled=true;
+      }
+      else{
+        _element.runtimeStyle.filter+="progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+_url+"',sizingMethod='crop')";
+      }
+      _element.runtimeStyle.zoom="0";
+      _element.runtimeStyle.backgroundImage="none";
+    }
+    else if(_filter){
+      _filter.Enabled=false;
+    }
+  },
+  
+  // png img opacity fix:
+  addFilter: function(_element,_image){
+    var _this=iefix,_filter,_tempUrl;
+    _filter=_element.filters["DXImageTransform.Microsoft.AlphaImageLoader"];
+    if(_filter){_filter.src=_element.src;_filter.Enabled=true;}
+    else{_element.runtimeStyle.filter+="progid:DXImageTransform.Microsoft.AlphaImageLoader(src='"+_element.src+"',sizingMethod='scale')";}
+    _tempURL=_element.src;
+    _element.src=_this.blankGifPath;
+    _image.src=_tempURL;
+  },
+  
+  // checks if image is png
+  fixImg: function(_element){
+    var _this=iefix,_image;
+    if(_this.pngCheck.test(_element.src)){ // needs more work
+      _image=new Image(_element.width,_element.height);
+      _image.onload=function(){_element.width=_image.width;_element.height=_image.height;_image=null;};
+      _this.addFilter(_element,_image);
+    }
+  },
+  
+  _noStyleTagNames: ['PARAM','HTML'],
+  // applies fixes to the _element
+  inlineStyleChanged: function(_element){
+    var _this=iefix,
+        _currentStyle=_element.currentStyle;
+    if(_this._noStyleTagNames.indexOf(_element.tagName)!==-1){
+      return;
+    }
+    // check if element needs to be positioned from the right
+    try{
+      var _posMatch = (_currentStyle.position==="absolute"||_currentStyle.position==="fixed"),
+          _resizeWidth = _element._resizewidth,
+          _resizeHeight = _element._resizeheight,
+          _autoRight = _currentStyle.right==="auto",
+          _autoBottom = _currentStyle.bottom==="auto";
+      if(_resizeWidth||(_posMatch&&!_autoRight)){
+        _this.resizeRight(_element);
+      }
+    // check if element needs to be positioned from the bottom
+      if(_resizeHeight||(_posMatch&&!_autoBottom)){
+        _this.resizeBottom(_element);
+        if(parseInt(_element.height)>parseInt(_element.fontSize,10)){
+          // TODO: needs line height calculation here too for elements smaller than the line height or font size
+          _element.fontSize = _element.height;
+          _element.lineHeight = _element.height;
+        }
+      }
+    
+    // check if opacity needs to be fixed:
+      if(_element.currentStyle.opacity){_this.fixOpacity(_element);}
+      
+    } catch(e) {
+      console.log("iefix error! element:",_element);
+    }
+    
+    // check if background image needs to be fixed:
+    //if(_element.currentStyle.backgroundImage){_this.fixBackgroundImage(_element);}
+    
+    // check if png needs to be fixed:
+    //if(_element.tagName==="IMG"||(_element.tagName==="INPUT"&&_element.type==="image")){_this.fixImg(_element);}
+    
+    // anti-click-through fix:
+    //else 
+    if(_element.style.backgroundColor==='transparent'&&(_element.style.backgroundImage==='none'||!_element.style.backgroundImage)){
+      _element.style.backgroundImage="url("+ie_htc_path+"128.gif)"; // transparent gif, 128x128
+    }
+  },
+  
+  _traverseCount: 0,
+  // traverses from the _element node from the bottom to fix right|bottom positioning
+  _traverseTree: function(_element){
+    var _this=iefix;
+    _this._traverseCount++;
+    // console.log( 'traversecount: '+_this._traverseCount );
+    _element=_element||document.documentElement;
+    while(_element){
+      if(_element.nodeType===1){
+        _this.inlineStyleChanged(_element);
+      }
+      var _next=_element.firstChild;
+      if(!_next){ _next=_element.nextSibling;}
+      while(!_next&&_element.parentNode) {
+        _element=_element.parentNode;
+        _next=_element.nextSibling;
+      }
+      _element=_next;
+    }
+  },
+  
+  // triggers an htc style event to elements affected by the style.
+  stylesheet_refresh: function(_styleSheet){
+    _styleSheet.cssText += "";
+  },
+  
+  // initial constructs
+  init: function() {
+    var _this = iefix;
+    _this._AUTO = /^(auto|0cm)$/;
+    _this._PIXEL = /^\d+(px)?$/i;
+    _this._PERCENT = /^\d+%$/;
+    _this.pngCheck = new RegExp(".png$", "i"); // needs more work
+    //this.pngCheck = new RegExp("((\.gif)|(\.jpg))$", "i"); // needs more work
+    // needed for png hack
+    _this.blankGifPath=ie_htc_path+"0.gif";
+    // eval("_this.getMarginWidth="+String(_this.getPaddingWidth).replace(/padding/g,"margin"));
+    // eval("_this.getPaddingHeight="+String(_this.getPaddingWidth).replace(/Width/g,"Height").replace(/Left/g,"Top").replace(/Right/g,"Bottom"));
+    // eval("_this.getMarginHeight="+String(_this.getPaddingHeight).replace(/padding/g,"margin"));
+    // eval("_this.getBorderHeight="+String(_this.getBorderWidth).replace(/Width/g,"Height"));
+    eval("_this.layoutHeight="+String(_this.layoutWidth).replace(/Width/g,"Height").replace(/width/g,"height").replace(/Right/g,"Bottom"));
+    eval("_this.getPixelHeight="+String(_this.getPixelWidth).replace(/Width/g,"Height"));
+    eval("_this.resizeBottom="+String(_this.resizeRight).replace(/Width/g,"Height").replace(/width/g,"height").replace(/left/g,"top").replace(/right/g,"bottom"));
+    _this.resizing = false;
+  },
+  
+  // entry point from ie_css_style.htc
+  htcStyleEntry: function(){
+    //window.status = 'htcStyleEntry';
+    if(document.readyState==="complete"&&window.event.srcElement.readyState==="complete"){
+      iefix._traverseTree();
+    }
+  },
+  
+  _traverseStyleProperties: ['width','height','left','top','right','bottom','display','position','visibility'],
+  //_traverseStyleProperties: ['right','bottom','width','height'],
+  
+  //_elemEntryCount: 0,
+  
+  // entry point from ie_css_element.htc
+  htcElementEntry: function(){
+    //iefix._elemEntryCount++;
+    //window.status="htcElementEntry: "+iefix._elemEntryCount;
+    var _element=window.event.srcElement, _propName=window.event.propertyName;
+    if (_propName==="style.opacity"){
+      //window.status = 'htcElementEntry: '+iefix._elemEntryCount+' opacity';
+      iefix.fixOpacity(_element);
+    }
+    else if((_propName==="src"&&_element.tagName==="IMG")||(_element.tagName==="INPUT"&&_element.type==="image")){
+      window.status = 'htcElementEntry: '+iefix._elemEntryCount+' img';
+      iefix.fixImg(_element);
+    }
+    //else if(_propName==='style.cssText'){
+      //window.status = 'htcElementEntry: '+iefix._elemEntryCount+' cssText';
+      //iefix._traverseTree();
+    //}
+    else if(_propName.substring(0,6)==='style.'){
+      if(iefix._traverseStyleProperties.indexOf(_propName.split('style.')[1])!==-1){
+        //window.status = 'htcElementEntry: '+iefix._elemEntryCount+' style';
+        iefix._traverseTree();
+      }
+      
+      /*
+      else {
+        window.status+=window.event.propertyName+' ';
+      }*/
+      
+    }
+    //iefix._traverseTree(); // really should have more checks, this impacts performance heavily!
+    
+  }
+};
+iefix.init();
+
+
+ie_complete=document.readyState==="complete";
+ie_initialized=false;
+
+ie_documentLoaded=function(){if(document.readyState==="complete"){iefix._traverseTree();}};
+ie_fixes=function(){
+  if( !ie_initialized
+    ){
+    if(ie_complete){
+      //var _stylesheet=document.createStyleSheet();
+      //_stylesheet.cssText='style,link{behavior:url('+ie_htc_path+'ie_css_style.htc)}\n*{behavior:url('+ie_htc_path+'ie_css_element.htc)}';
+      ie_documentLoaded();
+    }
+    else{
+      //document.write('<style type="text/css">style,link{behavior:url('+ie_htc_path+'ie_css_style.htc)}\n*{behavior:url('+ie_htc_path+'ie_css_element.htc)}</style>');
+      document.onreadystatechange=ie_documentLoaded;
+    }
+    ie_initialized=true;
+  }
+};
+ie_fixes();
+// window.onresize=function(){iefix.setWinSize();iefix._traverseTree();};
+
+
+

data/js/core/rsence_ns/rsence_ns.js

@@ -0,0 +1,21 @@
+/*   RSence
+ *   Copyright 2010 Riassence Inc.
+ *   http://riassence.com/
+ *
+ *   You should have received a copy of the GNU General Public License along
+ *   with this software package. If not, contact licensing@riassence.com
+ */
+
+// RSence namespace, nothing here yet.
+// However, a future version of client_pkg will pack var's assigned like..
+//   var//RSence
+// ..into this namespace.
+// Additional logic for handling the namespaces will however be required.
+var RSence = {
+  serverConf: function(_clientPrefix,_helloUrl){
+    COMM.ClientPrefix=_clientPrefix;
+    COMM.Transporter.HelloUrl=_helloUrl;
+    HThemeManager.themePath=_clientPrefix+'/themes';
+  }
+};
+