rsence 2.0.0.0.pre

data/js/comm/values/value/value.js

@@ -0,0 +1,182 @@
+/*   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
+  ** Data value synchonization container object.
+  **
+  ** +HValue+ is the default class to use for data syrchronization purposes.
+  ** It's smart enough to tell COMM.Values (Value Manager) that it has
+  ** been changed.
+  **
+  ** A single HValue instance can be bound to any number of responders, the
+  ** main client-side responder class is +HControl+.
+  **
+  ** When you change the value in one of the instances bound to the HValue
+  ** instances, all other instances get notified too and the server is also
+  ** notified and can be further bound on the server side to any number of
+  ** responders there too.
+  **
+  ** An instance constructed with "false" (Boolean) as its id is not reported
+  ** to the server. Such an instance can be used for client-side responder
+  ** synchronization.
+  **
+  ** Priority-wise, only the server can create a value id. If a value id is
+  ** created on the client, the server won't recognize nor accept it.
+  **
+  ** If a value is changed on the server, it overrides the changes on
+  ** the client, so no server-client lock is needed in this model.
+  **
+  ** = Instance variables:
+  **  +id+::     Value Id, used by the whole value management system to identify individual values.
+  **  +type+::   '[HValue]'
+  **  +value+::  The container/"payload" data value itself.
+  **  +views+::  A list of Components that uses this value. 
+  **             Used for automatic value syncronization between responders.
+***/
+HValue = HClass.extend({
+  
+/** = Description
+  * Constructs a value with the initial value +_value+ and the unique id +_id+.
+  *
+  * Only the server can create value id's, so use false when constructing
+  * from the client. A value with a false id is not reported to the server.
+  *
+  * = Parameters
+  * +_id+::     The source id (ideally set by server, should be unique)
+  * +_value+::  The initial data 
+  *
+  **/
+  constructor: function(_id,_value){
+    this.id    = _id;
+    this.value = _value;
+    this.views = [];
+    if(_id){
+      COMM.Values.add(_id,this);
+    }
+  },
+  
+/** Destructor method. Releases all bindings.
+  **/
+  die: function(){
+    for(var _viewNum=0;_viewNum<this.views.length;_viewNum++){
+      var _tryObj = this.views[_viewNum];
+      _tryObj.setValueObj( HDummyValue.nu() );
+      this.views.splice(_viewNum,1);
+    }
+    if(this.id){
+      COMM.Values.del(this.id);
+    }
+  },
+  
+/** = Description
+  * Replaces the data of the value.
+  *
+  * Extend this method, if you want client-side validation in the value itself.
+  *
+  * = Parameters
+  * +_value+::  The new data to replace the old data with.
+  *
+  **/
+  set: function(_value){
+    if(this.differs(_value)){
+      this.value = _value;
+      if(this.id){
+        COMM.Values.changed(this);
+      }
+      this.refresh();
+    }
+  },
+  
+/** Compares +_value+ with +self.value+.
+  * = Returns
+  * true or false, depending on the equality
+  **/
+  differs: function(_value){
+    return (COMM.Values.encode(_value) !== COMM.Values.encode(this.value));
+  },
+  
+/** = Description
+  * Setter for the server.
+  * 
+  * Just as +self.set+, but doesn't re-notify the server about the change.
+  **/
+  s: function(_value){
+    this.value = _value;
+    this.refresh();
+  },
+  
+/** = Description
+  * Return the data, returns the +self.value+ instance variable
+  *
+  * Returns:
+  *  The value instance variable (the data "payload")
+  **/
+  get: function(){
+    return this.value;
+  },
+  
+/** = Description
+  * Bind a responder to the value, use to attach HValues to responders derived from HControl.
+  *
+  * = Parameters
+  * +_responder+::   Any responder that is derived from HControl or any other 
+  *                  class instance that implements HValueResponder or has
+  *                  compatible typing.
+  **/
+  bind: function(_responder){
+    if(_responder===undefined){
+      throw("HValueBindError: responder is undefined!");
+    }
+    if(this.views.indexOf(_responder)===-1){
+      this.views.push(_responder);
+      _responder.setValueObj( this );
+    }
+  },
+  
+/** = Description
+  * Release a responder bound to the HValue instance itself.
+  *
+  * = Parameters
+  * +_responder+::   Any responder that is derived from HControl or any other 
+  *                  class instance that implements HValueResponder or has
+  *                  compatible typing.
+  **/
+  unbind: function(_responder){
+    for(var _viewNum=0;_viewNum<this.views.length;_viewNum++){
+      var _tryObj = this.views[_viewNum];
+      if(_tryObj===_responder){
+        this.views.splice(_viewNum,1);
+        return;
+      }
+    }
+  },
+
+/** Alias of +self.unbind+, opposite of +bind+.
+  **/
+  release: function(_responder){
+    return this.unbind(_responder);
+  },
+  
+/** Calls the setValue method all responders bound to this HValue.
+  **/
+  refresh: function(){
+    for(var _viewNum=0;_viewNum<this.views.length;_viewNum++){
+      var _responder = this.views[_viewNum];
+      if(_responder.value !== this.value){
+        if(!_responder._valueIsBeingSet){
+          _responder._valueIsBeingSet=true;
+          _responder.setValue( this.value );
+          _responder._valueIsBeingSet=false;
+        }
+      }
+    }
+  }
+  
+});
+
+

data/js/comm/values/valuematrix/valuematrix.js

@@ -0,0 +1,138 @@
+/*   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
+  ** An interface to implement for classes that are members of +HValueMatrix+.
+  **
+  ** A HRadioButton is an example of an class that implements
+  ** the HValueMatrixInterface.
+***/
+HValueMatrixInterface = {
+  
+  componentBehaviour: ['view','control','matrix'],
+  
+/** = Description
+  * Standard +HControl+ constructor model.
+  * Passes parameters through to its base class's constructor,
+  * then calls +self.setValueMatrix+.
+  *
+  **/
+  constructor: function(_rect, _parent, _options) {
+    this.base(_rect, _parent, _options);
+    this.setValueMatrix();
+  },
+  
+/** = Description
+  * Binds itself to the parent's HValueMatrix instance.
+  *
+  * Creates a valueMatrix member into the parent of itself, if none is present yet.
+  * Sets the +self.value+ to true or false depending on the parent's valueMatrix value.
+  *
+  **/
+  setValueMatrix: function(){
+    if(this.parent['valueMatrix'] === undefined){
+      this.parent.valueMatrix = HValueMatrix.nu();
+    }
+    this.valueMatrixIndex = this.parent.valueMatrix.addControl(this);
+  },
+  
+/** Sets itself active using the parent's valueMatrix on the click event.
+  **/
+  click: function(){
+    if (this.parent.valueMatrix instanceof HValueMatrix) {
+      this.parent.valueMatrix.setValue( this.valueMatrixIndex );
+    }
+  },
+  
+/** The destructor makes sure +self+ is released from the parent's valueMatrix
+  * upon destruction.
+  **/
+  die: function(){
+    if(this['parent']){
+      if(this.parent['valueMatrix']){
+        this.parent.valueMatrix.release(this);
+      }
+    }
+    this.base();
+  }
+};
+
+// Alias for backwards compatibility.
+HValueMatrixComponentExtension = HValueMatrixInterface;
+
+/*** = Description
+  ** A HValueMatrix operates a number of components that operate on boolean
+  ** values, like the HRadioButton using a separate value for selecting the
+  ** index of selected items.
+***/
+HValueMatrix = HClass.extend({
+  
+/** The constructor doesn't take parameters.
+  **/
+  constructor: function(){
+    // An array to hold member components
+    this.ctrls = [];
+    // The index of the value member chosen
+    this.value = -1;
+    this.valueObj = new HDummyValue();
+  },
+  
+/** Method for value interfaces, called by the HValue instance when bound.
+  **/
+  setValueObj: function(_valueObj){
+    this.valueObj = _valueObj;
+    this.setValue(_valueObj.value);
+  },
+  
+/** Method for value interfaces, the +_index+ is the 
+  * index of the item to select.
+  **/
+  setValue: function(_index){
+    if( _index !== this.value ){
+      // Set the previous value object to false (reflects to its container component(s))
+      if(this.value !== -1){
+        if(this.ctrls[this.value]){
+          this.ctrls[this.value].setValue(false);
+        }
+      }
+      // Store the new index as the currently active value
+      this.value = _index;
+      if(_index !== -1){
+        // Set the new value object to true (reflects to its container component(s))
+        if(_index<this.ctrls.length){
+          this.ctrls[_index].setValue(true);
+        }
+      }
+      this.valueObj.set(_index);
+    }
+  },
+  
+/** A method for attaching a +HControl+ -derived class to the matrix.
+  **/
+  addControl: function(_ctrl) {
+    this.ctrls.push(_ctrl);
+    var _newIndex = this.ctrls.length-1;
+    if(_ctrl.value){
+      this.setValue(_newIndex);
+    }
+    return _newIndex;
+  },
+  
+/** A method for releasing a +HControl+ -derived class from the matrix.
+  **/
+  release: function(_ctrl) {
+    var _index = this.ctrls.indexOf(_ctrl);
+    if(_index !== -1){
+      this.ctrls.splice( _index, 1 );
+      if(_index === this.value){
+        this.setValue(-1);
+      }
+    }
+  }
+});
+

data/js/controls/button/button.js

@@ -0,0 +1,57 @@
+/*   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
+  ** Simple button component, designed to be extended for any
+  ** actual functionality above regular HControl.
+  ** It's limited to 24px height by the default theme, because
+  ** it's much simpler to render that way.
+  ***/
+HButton = HControl.extend({
+  componentName: 'button',
+/** = Description
+  * setStyle function for button.
+  *
+  **/
+  setStyle: function(_name, _value){
+    ELEM.setStyle(this.markupElemIds.label,_name,_value);
+    return this;
+  }
+});
+
+/*** = Description
+  ** Simple HButton extension, operates on its value so it's useful
+  ** for sending button clicks to the server and the like.
+  ** For the value responder, reset the value to 0 when read to make
+  ** the button clickable again.
+  **
+  ** = Value states
+  ** +0+::     Enabled, clickable
+  ** +1+::     Disabled, clicked
+  ** +Other+:: Disabled, not clickable, not clicked
+  ***/
+HClickValueButton = HButton.extend({
+/** = Description
+  * Sets the button enabled if this.value is 0.
+  *
+  **/
+  refreshValue: function(){
+    this.setEnabled( this.value === 0 );
+  },
+/** = Description
+  * Click method, sets the value to disabled if the button is enabled.
+  *
+  **/
+  click: function(){
+    if(this.enabled){
+      this.setValue(1);
+    }
+  }
+});
+

data/js/controls/button/themes/bright/button.css

@@ -0,0 +1,89 @@
+
+.button_control,
+.button_edge_left,
+.button_center,
+.button_edge_right,
+.button_label,
+.button_antiselect {
+  position: absolute;
+  top: 0px; height: 24px;
+}
+
+.button_control {
+  left: 0px; right: 0px;
+  cursor: pointer;
+}
+.disabled .button_control {
+  cursor: default;
+}
+
+.button_edge_left,
+.button_center,
+.button_edge_right {
+  background-repeat: repeat-x;
+  background-image: #{this.getCssFilePath('button_parts1.png')};
+}
+
+.button_edge_left {
+  left: 0px; width: 24px;
+  background-position: 0px 0px;
+}
+.disabled > .button_control > .button_edge_left {
+  background-position: 0px -144px;
+}
+.enabled > .button_control:hover > .button_edge_left {
+  background-position: 0px -48px;
+}
+.enabled > .button_control:active > .button_edge_left {
+  background-position: 0px -96px;
+}
+
+.button_edge_right {
+  right: 0px; width: 24px;
+  background-position: -24px 0px;
+}
+.disabled > .button_control > .button_edge_right {
+  background-position: -24px -144px;
+}
+.enabled > .button_control:hover > .button_edge_right {
+  background-position: -24px -48px;
+}
+.enabled > .button_control:active > .button_edge_right {
+  background-position: -24px -96px;
+}
+
+.button_center {
+  left: 24px; right: 24px;
+  background-position: 0px -24px;
+}
+.disabled > .button_control > .button_center {
+  background-position: 0px -168px;
+}
+.enabled > .button_control:hover > .button_center {
+  background-position: 0px -72px;
+}
+.enabled > .button_control:active > .button_center {
+  background-position: 0px -120px;
+}
+
+.button_label {
+  left: 6px; right: 6px; top: 2px;
+  height: 20px; line-height: 21px;
+  text-align: center; vertical-align: middle;
+  font-family: Arial, sans-serif;
+  font-size: 12px; font-weight: bold;
+  color: #333;
+}
+.disabled > .button_control > .button_label {
+  color: #999;
+}
+.enabled > .button_control:hover > .button_label {
+  color: #000;
+}
+.enabled > .button_control:active > .button_label {
+  color: #000;
+}
+
+.button_antiselect {
+  left: 0px; right: 0px;
+}