rsence 2.0.0.0.pre

data/js/controls/sliders/slider/themes/default/slider.html

@@ -0,0 +1,5 @@
+<div class="hslider_track_left"></div>
+<div class="hslider_track_right"></div>
+<div class="hslider_track"></div>
+<div class="hslider_thumb" id="control#{_ID}"></div>
+${this.thumbSize=21;}

data/js/controls/sliders/vslider/themes/default/vslider.css

@@ -0,0 +1,52 @@
+.vslider_track_top,
+.vslider_track_bottom,
+.vslider_track {
+  position: absolute;
+  width: 7px; left: 7px;
+  font-size: 0px;
+  background-image: #{this.getCssFilePath('vslider_tracks.png')};
+}
+
+.vslider_track_top {
+  top: 10px; height: 4px;
+  background-position: 0px 0px;
+}
+
+.vslider_track_bottom {
+  bottom: 10px; height: 4px;
+  background-position: 0px -4px;
+}
+
+.vslider_track {
+  top: 14px; bottom: 14px;
+  background-position: -14px 0px;
+}
+
+.disabled .vslider_track_top {
+  background-position: -7px 0px;
+}
+
+.disabled .vslider_track_bottom {
+  background-position: -7px -4px;
+}
+
+.disabled .vslider_track {
+  background-position: -21px 0px;
+}
+
+.vslider_thumb {
+  position: absolute;
+  font-size: 0px;
+  left: 0px; width: 21px; height: 21px;
+  background-position: 0px 0px;
+  background-image: #{this.getCssFilePath('slider_thumbs.png')};
+}
+
+.vslider_thumb:active {
+  background-position: 0px -22px;
+}
+
+.disabled .vslider_thumb {
+  background-position: 0px -44px;
+}
+

data/js/controls/sliders/vslider/themes/default/vslider.html

@@ -0,0 +1,5 @@
+<div class="vslider_track_top"></div>
+<div class="vslider_track_bottom"></div>
+<div class="vslider_track"></div>
+<div class="vslider_thumb" id="control#{_ID}"></div>
+${this.thumbSize=21;}

data/js/controls/sliders/vslider/vslider.js

@@ -0,0 +1,40 @@
+/*   Riassence Framework
+ *   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
+ */
+
+/*** = Description
+  ** HVSlider (vertical version of the slider control) is a control unit that enables the user
+  ** to choose a value in a range of values. Sliders support both dragging the handle and 
+  ** clicking the mouse anywhere on the slider to move the handle towards the mouse, 
+  ** as well as keyboard support after the handle is in active mode. 
+  ** Naturally, sliders are commonly used as colour mixers, volume controls, 
+  ** graphical equalizers and seekers in media applications. 
+  ** A typical slider is a drag-able knob along vertical or horizontal line.
+  **
+  ** = Instance variables
+  ** +minValue+::       The smallest allowed value.
+  ** +maxValue+::       The biggest allowed value.
+  ** +repeatDelay+::    The key repetition initial delay when changing the slider
+  **                    with cursor keys. Defaults to 300 (ms)
+  ** +repeatInterval+:: The key repetition interval when changing the slider
+  **                    with cursor keys. Defaults to 50 (ms)
+  ** +inveseAxis+::     Inverse Scrollwheel axis.
+  **                    As there is only one scrollwheel event, sideways
+  **                    scrolling doesn't work logically for horizonal
+  **                    scrollbars by default, so set this to true to
+  **                    have horizonal sliders work logically
+  **                    with sideways scrolling, where supported.
+  ***/
+HVSlider = HSlider.extend({
+  
+  componentName: "vslider",
+    
+  // This overrides the HSlider property.
+  _isVertical: true
+  
+});
+

data/js/controls/stepper/stepper.js

@@ -0,0 +1,212 @@
+/*   Riassence Framework
+ *   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
+ */
+
+/*** = Description
+  ** HStepper is a control unit made of two adjacent buttons with up and down arrows 
+  ** to select the previous or next of a set of contiguous values. 
+  ** Normally, a HStepper instance works in combination with a HTextControl or a HStringView instance.
+  **
+  ** = Instance Variables
+  ** +minValue+::         The smallest allowed value
+  ** +maxValue+::         The biggest allowed value
+  ** +stepSize+::         Amount of to step, defaults to +/- 1
+  ** +repeatInterval+::   Interval in milliseconds for repeat
+  ** +wrapAround+::       Boolean to control wrap-around behaviour
+  ***/
+
+HStepper = HControl.extend({
+  
+  componentName: "stepper",
+  
+  defaultEvents: {
+    mouseDown: true,
+    keyDown: true,
+    mouseWheel: true
+  },
+  
+  controlDefaults: (HControlDefaults.extend({
+    minValue: 0,
+    maxValue: 100,
+    stepSize: 1,
+    repeatInterval: 200,
+    wrapAround: false
+  })),
+  
+  /** Setter for wrap-around behaviour
+    **/
+  setWrapAround: function(_on){
+    this.options.wrapAround = _on;
+  },
+  
+  // -- Makes sure the value is in its boundaries and either wrap-around
+  // to min/max or revert to the current value ++
+  _checkValueBoundaries: function(_value){
+    
+    // -- checks for boundaries ++
+    var _this     = this,
+        _options  = _this.options,
+        _minVal   = _options.minValue,
+        _maxVal   = _options.maxValue,
+        _tooSmall = _value<_minVal,
+        _tooBig   = _value>_maxVal,
+        _overflow = ( _tooSmall || _tooBig );
+    
+    // -- The value is ok, just return it as it is ++
+    if (!_overflow) {
+      return _value;
+    }
+    
+    
+    /// -- Handle the overflow condition: ++
+    
+    // -- Wrap around uses min/max as new value as either is reached ++
+    if (_options.wrapAround) {
+      if (_tooSmall) {
+        return _maxVal;
+      }
+      else {
+        return _minVal;
+      }
+    }
+    // -- Any other condition means we just revert the changes ++
+    else {
+      return _this.value;
+    }
+    
+  },
+  
+/** Adds the step size to the value
+  **/
+  stepUp: function(){
+    this.setValue(
+      this._checkValueBoundaries(
+        this.value + this.options.stepSize
+      )
+    );
+  },
+  
+/** Subtracts the step size from the value
+  **/
+  stepDown: function(){
+    this.setValue(
+      this._checkValueBoundaries(
+        this.value - this.options.stepSize
+      )
+    );
+  },
+  
+  // -- Returns an action string for the setInterval in _setRepeatInterval ++
+  _repeatIntervalStr: function( _up ){
+    return [
+      'HSystem.views[',
+      this.viewId,
+      '].step',
+      (_up?'Up':'Down'),
+      '();'
+    ].join('');
+  },
+  
+  // -- Background-offset of the state images up/down,
+  // overrideable in the html template ++
+  bgStateUp: '0px -23px',
+  bgStateDown: '0px -46px',
+  
+  // enables the up/down effect in the image based on the _up boolean (true means up, false means down)
+  _bgStateOn: function( _up ){
+    ELEM.setStyle(this.markupElemIds.state,'background-position',_up?this.bgStateUp:this.bgStateDown);
+  },
+  
+  // reverts the up/down effect
+  _bgStateOff: function(){
+    ELEM.setStyle(this.markupElemIds.state,'background-position','');
+  },
+  
+  // Starts the repeating stepping up or down (when the mouse button or a arrow key is down)
+  _setRepeatInterval: function( _up ){
+    var _this    = this,
+        _options = _this.options;
+    _this._bgStateOn( _up );
+    if (_up) {
+      _this.stepUp();
+      _this._repeatInterval = setInterval( _this._repeatIntervalStr(1), _options.repeatInterval );
+    }
+    else {
+      _this.stepDown();
+      _this._repeatInterval = setInterval( _this._repeatIntervalStr(0), _options.repeatInterval );
+    }
+  },
+  
+  // Stops the repeating stepping up or down enabled in _setRepeatInterval
+  _clearRepeatInterval: function(){
+    this._bgStateOff();
+    clearInterval( this._repeatInterval );
+  },
+  
+  /** Checks where the mouseDown happened and adjusts the stepper up/down based on that
+    **/
+  mouseDown: function( x, y ){
+    this.setMouseUp(true);
+    this._setRepeatInterval(  ( y - ELEM.getVisiblePosition( this.elemId )[1] ) <= 11  );
+  },
+  
+  /** Stops the repeating stepping, when the mouse button goes up
+    **/
+  mouseUp: function(){
+    this._clearRepeatInterval();
+  },
+  
+  /** Stops the repeating stepping, when the control becomes inactive
+    **/
+  blur: function(){
+    this._clearRepeatInterval();
+  },
+  
+/** adjusts stepping up/down based on the arrow key pressed.
+  * up and right arrow keys steps the value up, down and left steps the value down
+  **/
+  keyDown: function( _keyCode ) {
+    this.setKeyUp(true);
+    var _keyDown  = (_keyCode === Event.KEY_DOWN),
+        _keyUp    = (_keyCode === Event.KEY_UP),
+        _keyLeft  = (_keyCode === Event.KEY_LEFT),
+        _keyRight = (_keyCode === Event.KEY_RIGHT),
+        _arrowKey = (_keyDown || _keyUp || _keyLeft || _keyRight);
+    if (_arrowKey) {
+      this._setRepeatInterval( (_keyUp || _keyRight) );
+    }
+    else if (_keyCode === Event.KEY_HOME) {
+      this.setValue(this.options.minValue);
+    }
+    else if (_keyCode === Event.KEY_END) {
+      this.setValue(this.options.maxValue);
+    }
+    // Page up and page down keys act just like arrow up/down.
+    else if (_keyCode === Event.KEY_PAGEUP) {
+      this._setRepeatInterval( 1 );
+    }
+    else if (_keyCode === Event.KEY_PAGEDOWN) {
+      this._setRepeatInterval( 0 );
+    }
+  },
+  
+/** stops the repeating when a key goes up
+  **/
+  keyUp: function(){
+    this._clearRepeatInterval();
+  },
+  
+/** steps the value up/down based on the mouse scroll wheel
+  **/
+  mouseWheel: function(_delta) {
+    (_delta>0)?this.stepUp():this.stepDown();
+  }
+  
+  
+});
+
+

data/js/controls/stepper/themes/default/stepper.css

@@ -0,0 +1,14 @@
+.stepper_state {
+ position: absolute;
+ left: 0px;
+ top: 0px;
+ width: 15px;
+ height: 23px;
+ background-position: 0px 0px;
+ background-repeat: no-repeat;
+ background-image: #{this.getCssFilePath('stepper.png')};
+}
+
+.disabled .stepper_state {
+  background-position: 0px -69px;
+}

data/js/controls/stepper/themes/default/stepper.html

@@ -0,0 +1,2 @@
+<div class="stepper_state" id="state#{_ID}"></div>
+${this.bgStateUp='0px -23px';this.bgStateDown='0px -46px';}

data/js/controls/stringview/stringview.js

@@ -0,0 +1,49 @@
+/*   Riassence Framework
+ *   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
+ */
+
+/*** = Description
+  ** HStringView is a view component that represents a non-editable line of text. 
+  ** Commonly, stringview is used as a label to control elements 
+  ** that do not have implicit labels (text fields, checkboxes and radio buttons, and menus). 
+  ** Some form controls automatically have labels associated with them (press buttons) 
+  ** while most do not have (text fields, checkboxes and radio buttons, and sliders etc.).  
+  **
+  ** = Instance variables
+  ** +type+::   '[HStringView]'
+  ** +value+::  The string that this string view displays when drawn.
+  ***/
+HStringView = HControl.extend({
+
+  componentName: "stringview",
+  componentBehaviour: ['view','control','text'],
+  
+/** = Description
+  * setStyle function
+  *
+  **/
+  setStyle: function(_name, _value, _cacheOverride) {
+    if (!this['markupElemIds']||!this.markupElemIds['value']) {
+      return;
+    }
+    ELEM.setStyle(this.markupElemIds.value, _name, _value, _cacheOverride);
+    return this;
+  },
+  
+/** = Description
+  * refreshLable function
+  *
+  **/
+  refreshLabel: function() {
+    if(this.markupElemIds) {
+      if(this.markupElemIds.value) {
+        ELEM.setAttr(this.markupElemIds.value, 'title', this.label);
+      }
+    }
+  }
+});
+

data/js/controls/stringview/themes/default/stringview.css

@@ -0,0 +1,8 @@
+.stringview {
+  color: #333;
+  padding: 1px;
+  font-size: 12px;
+  font-family: Arial, sans-serif;
+  overflow-y: visible;
+}
+

data/js/controls/stringview/themes/default/stringview.html

@@ -0,0 +1 @@
+<div class="stringview" id="value#{_ID}" title="#{this.label}"></div>

data/js/controls/tab/tab.js

@@ -0,0 +1,276 @@
+/*   Riassence Framework
+ *   Copyright 2008 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
+  ** HTabView
+  **
+  **
+  ***/
+HTabView = HView.extend({
+/** = Description
+  * draw function
+  *
+  **/
+  draw: function(){
+    var _isDrawn = this.drawn;
+    this.base();
+    if(!_isDrawn){
+      var i=0,_styles = [
+        ['overflow','auto']
+      ];
+      for(i;i<_styles.length;i++){
+        this.setStyle(_styles[i][0],_styles[i][1]);
+      }
+      this.hide();
+    }
+  }
+});
+
+/** = Description
+  * HTab
+  *
+  **/
+HTab = HControl.extend({
+  componentName: "tab",
+  componentBehaviour: ['view','control','tab'],
+  refreshOnValueChange: true,
+  refreshOnLabelChange: false,
+  
+  controlDefaults: (HControlDefaults.extend({
+    constructor: function(_ctrl){
+      this.tabInit(_ctrl);
+    },
+    tabInit: function(_ctrl){
+      _ctrl.tabs = [];
+      _ctrl.tabLabels = [];
+      _ctrl.tabLabelBounds = [];
+      _ctrl.tabLabelStrings = [];
+    }
+  })),
+  
+  rightmostPx: 0,
+  selectIdx: -1,
+  
+  // overridden in the template
+  tabLabelHeight: 20,
+  
+  // overridden in the template
+  tabLabelLeftEdge: 4,
+  
+  // overridden in the template
+  tabLabelRightEdge: 4,
+  
+  // overridden in the template
+  fontStyle: 'font-family:Arial,sans-serif;font-size:13px;',
+  
+  tabLabelHTMLPrefix1: '<div class="edge-left"></div><div class="tablabel" style="width:',
+  tabLabelHTMLPrefix2: 'px">',
+  tabLabelHTMLSuffix: '</div><div class="edge-right"></div>',
+  tabLabelParentElem: 'label',
+  tabLabelElementTagName: 'div',
+  tabLabelAlign: 'left',
+  tabLabelFillBg: false,
+  tabTriggerLink: true,
+  tabLabelNoHTMLPrefix: false,
+  
+/** = Description
+  * refreshValue function
+  *
+  **/
+  refreshValue: function(){
+    var _value = this.value;
+    if(typeof _value === 'number'){
+      var _index = parseInt(_value,10);
+      if(_index<this.tabs.length){
+        if(_index!==this.selectIdx){
+          this.selectTab(_index);
+        }
+      }
+    }
+  },
+  
+/** = Description
+  * Sets label for the tab.
+  *
+  * = Parameters
+  * +_label+::  Label for the tab
+  *
+  **/
+  setLabel: function(_label){
+    this.label = _label;
+  },
+  
+/** = Description
+  * selectTab function
+  *
+  * = Parameters
+  * +_tabIdx+::
+  *
+  **/
+  selectTab: function(_tabIdx){
+    if(_tabIdx instanceof HTabView){
+      _tabIdx = _tabIdx.tabIndex;
+    }
+    if(this.selectIdx!==-1){
+      var _tabSelectElemId = this.tabLabels[this.selectIdx],
+          _tabSelectViewId = this.tabs[this.selectIdx];
+      ELEM.removeClassName(_tabSelectElemId,'item-fg');
+      ELEM.addClassName(_tabSelectElemId,'item-bg');
+      HSystem.views[_tabSelectViewId].hide();
+    }
+    if(_tabIdx!==-1){
+      var _tabLabelElemId = this.tabLabels[_tabIdx],
+          _tabViewId = this.tabs[_tabIdx];
+      ELEM.removeClassName(_tabLabelElemId,'item-bg');
+      ELEM.addClassName(_tabLabelElemId,'item-fg');
+      HSystem.views[_tabViewId].show();
+    }
+    this.selectIdx = _tabIdx;
+    this.setValue(_tabIdx);
+  },
+  
+/** = Description
+  * addTab function
+  *
+  * = Parameters
+  * +_tabLabel+::
+  * +_doSelect+::
+  *
+  **/
+  addTab: function(_tabLabel,_doSelect){
+    var _tabIdx=this.tabs.length,
+        _tabLabelHTML='',
+        _labelTextWidth=this.stringWidth(_tabLabel),
+        _labelWidth=_labelTextWidth+this.tabLabelLeftEdge+this.tabLabelRightEdge,
+        _tab = HTabView.nu( [0,this.tabLabelHeight,null,null,0,0] ,this),
+        _tabLabelElemId = ELEM.make(this.markupElemIds[this.tabLabelParentElem],this.tabLabelElementTagName);
+    _tabIdx = this.tabs.length;
+    if(this.tabLabelNoHTMLPrefix){
+      _tabLabelHTML = _tabLabel;
+    }
+    else {
+      _tabLabelHTML = this.tabLabelHTMLPrefix1+_labelTextWidth+this.tabLabelHTMLPrefix2+_tabLabel+this.tabLabelHTMLSuffix;
+    }
+    _tab.hide();
+    ELEM.addClassName(_tabLabelElemId,'item-bg');
+    ELEM.setStyle(_tabLabelElemId,'width',_labelWidth+'px');
+    ELEM.setStyle(_tabLabelElemId,this.tabLabelAlign,this.rightmostPx+'px');
+    ELEM.setHTML(_tabLabelElemId,_tabLabelHTML);
+    this.tabLabelStrings.push(_tabLabel);
+    if(this.tabTriggerLink&&this.tabLabelElementTagName==='a'){
+      ELEM.setAttr(_tabLabelElemId,'href','javascript:HSystem.views['+this.viewId+'].selectTab('+_tabIdx+');');
+    }
+    else if (this.tabTriggerLink){
+      ELEM.setAttr(_tabLabelElemId,'onclick','HSystem.views['+this.viewId+'].selectTab('+_tabIdx+');');
+    }
+    else {
+      this.tabLabelBounds.push([this.rightmostPx,this.rightmostPx+_labelWidth]);
+    }
+    this.rightmostPx+=_labelWidth;
+    if(this.tabLabelAlign === 'right'){
+      ELEM.setStyle(this.markupElemIds[this.tabLabelParentElem],'width',this.rightmostPx+'px');
+    }
+    else if (this.tabLabelFillBg) {
+      ELEM.setStyle(this.markupElemIds.state,'left',this.rightmostPx+'px');
+    }
+    this.tabs.push(_tab.viewId);
+    this.tabLabels.push(_tabLabelElemId);
+    _tab.tabIndex = _tabIdx;
+    if(_doSelect || (this.value === _tabIdx)){
+      this.selectTab(_tabIdx);
+    }
+    return _tab;
+  },
+  
+/** = Description
+  * click function
+  *
+  * = Parameters
+  * +_x+::
+  * +_y+::
+  *
+  **/
+  click: function(_x,_y){
+    if(this.tabTriggerLink){
+      this.setClickable(false);
+      return;
+    }
+    _x -= this.pageX();
+    _y -= this.pageY();
+    if(_y<=this.tabLabelHeight){
+      if (this.tabLabelAlign === 'right') {
+        _x = this.rect.width - _x;
+      }
+      if(_x<=this.rightmostPx){
+        var i=0,_labelBounds;
+        for(i;i<this.tabLabelBounds.length;i++){
+          _labelBounds = this.tabLabelBounds[i];
+          if(_x<_labelBounds[1] && _x>=_labelBounds[0]){
+            this.selectTab(i);
+            return;
+          }
+        }
+      }
+      
+    }
+  },
+  
+/** = Description
+  * removeTab function
+  *
+  * = Parameters
+  * +_tabIdx+::
+  *
+  **/
+  removeTab: function(_tabIdx){
+    var _selIdx = this.selectIdx,
+        _tabViewId = this.tabs[_tabIdx],
+        _tabLabelElemId = this.tabViews[_tabIdx];
+    this.tabs.splice(_tabIdx,1);
+    this.tabLabels.splice(_tabIdx,1);
+    this.tabLabelBounds.splice(_tabIdx,1);
+    this.tabLabelStrings.splice(_tabIdx,1);
+    if(_tabIdx===_selIdx){
+      this.selectIdx=-1;
+      if(_tabIdx===0&&this.tabs.length===0){
+        this.selectTab(-1);
+      }
+      else if(_tabIdx===(this.tabs.length-1)){
+        this.selectTab(_tabIdx-1);
+      }
+      else{
+        this.selectTab(_tabIdx);
+      }
+    }
+    else if(_tabIdx<_selIdx){
+      this.selectIdx--;
+    }
+    ELEM.del(_tabLabelElemId);
+    HSystem.views[_tabViewId].die();
+  }
+});
+
+/** = Description
+  * HTabItem is a wrapper for creating tabs as subviews when using JSONRenderer.
+  * rect is ignored
+  * parent is the HTab instance
+  * options may contain the following:
+  * select: true|false, passed on to addTab
+  * label: true|false, passed on to addTab
+  *
+  * = Returns 
+  * a new HTabView instance returned by addTab
+  *
+  **/
+HTabItem = {
+  nu: function(_rect, _parent, _options){
+    return _parent.addTab( _options.label, _options.select );
+  }
+};
+
+