rsence 2.0.0.0.pre

data/js/foundation/json_renderer/json_renderer.js

@@ -0,0 +1,231 @@
+/*   Riassence Framework
+ *   Copyright 2009 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
+ */
+
+
+/*** Constructs nodes from JSON structures as GUI
+  ** tree structures. Lowers the learning curve of GUI
+  ** development, because Javascript knowledge is not
+  ** required to define user interfaces.
+  ** The main purpose is to ease the development of
+  ** user interfaces by defining them as data on the
+  ** server, converting the data to JSON GUI trees and
+  ** letting the client handle the rest. The end result
+  ** is the same as defining the structures in
+  ** JavaScript code.
+  **
+  ** This class is still in development, so expect more
+  ** features and documentation as it matures.
+***/
+COMM.JSONRenderer = HClass.extend({
+  
+  version: 0.5,
+
+/** = Description
+  * Renders JSON structured data, see some of the demos for usage examples.
+  *
+  * = Parameters:
+  * +_data+:   The data structure used for building.
+  * +_parent+: The parent view (or app) (Optional)
+  **/
+  constructor: function(_data, _parent){
+    if((_data['type'] === 'GUITree') && (this.version >= _data['version'])){
+      this.data   = _data;
+      this.parent = _parent;
+      this.render();
+    }
+    else{
+      throw("JSONRenderer: Only GUITree version "+this.version+" or older data can be handled.");
+    }
+  },
+  render: function(){
+    this.scopes = [window];
+    this.scopeDepth = 0;
+    this.view = this.renderNode( this.data, this.parent );
+  },
+  defineInScope: function( _definition ){
+    var _isArr = (_definition instanceof Array),
+        _isObj = (_definition instanceof Object);
+    if( _isArr || !_isObj ){
+      console.log("JSONRenderer; definition must be an Object, got: '"+(typeof _definition)+"'. Definition: ",_definition);
+      return;
+    }
+    var _extension = {},
+        _reserved = ['class','extend','implement'],
+        _className = _definition[_reserved[0]],
+        _extendName = _definition[_reserved[1]],
+        _implementName = _definition[_reserved[2]],
+        _extend = _extendName?this.findInScope(_extendName):false,
+        _implement = _implementName?this.findInScope(_implementName):false,
+        _scope = this.scopes[ this.scopeDepth ],
+        _key, _value;
+    if( _className === undefined ) {
+      console.log("JSONRenderer; class name missing in definition scope.");
+      return;
+    }
+    if( !_extend ){
+      _extend = HClass;
+    }
+    for( _key in _definition ){
+      if( _reserved.indexOf( _key ) === -1 ){
+        _value = _definition[_key];
+        _extension[_key] = this.extEval( _value );
+      }
+    }
+    _scope[ _className ] = _extend.extend( _extension );
+    if( _implement ){
+      _scope[ _className ].implement( _implement );
+    }
+  },
+  undefineInScope: function( ){
+    
+  },
+  findInScope: function( _className ){
+    if(_className === undefined){
+      return false;
+    }
+    if(_className.indexOf('.') !== -1){
+      var _splitClass = _className.split('.'),
+          j = 1,
+          _classPart = _splitClass[0],
+          _classFull = this.findInScope( _classPart );
+      if( !_classFull ){
+        return false;
+      }
+      for( ; j < _splitClass.length ; j++ ){
+        _classPart = _splitClass[j];
+        _classFull = _classFull[ _classPart ];
+        if( !_classFull ){
+          return false;
+        }
+      }
+      return _classFull;
+    }
+    var _class = false,
+        _scopes = this.scopes,
+        i = _scopes.length-1,
+        _scope;
+    for( ; i > -1 ; i-- ){
+      _scope = _scopes[i];
+      if( _scope[ _className ] !== undefined ){
+        return _scope[ _className ];
+      }
+    }
+    return _class;
+  },
+  extEval: function(_block){
+    if( _block.indexOf("function(") === 0 ){
+      eval( '_block = '+_block );
+    }
+    return _block;
+  },
+  renderNode: function( _dataNode, _parent ){
+    var // Currently only window-level classes are supported
+        _className = _dataNode['class'],
+        _class = this.findInScope( _className ),
+        
+        // Currently only HView -derived classes are supported, so 
+        // the rect is mandatory.
+        _rect = _dataNode['rect'],
+        _hasRect = (_rect !== undefined) && (_rect instanceof Array || typeof _rect === 'string'),
+        
+        // Checks, if any sub-views are defined.
+        _hasSubviews = _dataNode['subviews'] !== undefined,
+        _subViews    = _hasSubviews?_dataNode['subviews']:null,
+        
+        // Checks, if any options are defined.
+        _hasOptions  = _dataNode['options'] !== undefined,
+        _options     = _hasOptions?_dataNode['options']:null,
+        
+        // JS Extension block
+        _hasExtension = _dataNode['extend'] !== undefined,
+        _extension    = _hasExtension?_dataNode['extend']:null,
+        
+        // JS Definition block
+        _hasDefinition = _dataNode['define'] !== undefined,
+        _definitions   = _hasDefinition?_dataNode['define']:null,
+        
+        // The HView-derived class instance, instance is by default the parent
+        _instance = _parent,
+        
+        i,
+        
+        _subView;
+    // console.log('className:',_className,' class:',_class);
+    this.scopeDepth ++;
+    this.scopes.push({});
+    try{
+      if(_hasDefinition){
+        if(_definitions instanceof Array){
+          for( i = 0; i < _definitions.length; i++ ){
+            this.defineInScope( _definitions[i] );
+          }
+        }
+        else {
+          console.log('renderNode definitions not Array, definitions:',_definitions);
+        }
+      }
+      if(_class){
+        if(_hasExtension){
+          var _extBlock = {},
+              _name,
+              _block;
+          for(_name in _extension){
+            _block = _extension[_name];
+            if( typeof _block === 'string' ){
+              try {
+                _block = this.extEval( _block );
+              }
+              catch(e){
+                console.log('renderNode ext eval error:',e,', name:',_name,', block:',_block);
+              }
+            }
+            _extBlock[_name] = _block;
+          }
+          _class = _class.extend( _extBlock );
+        }
+        if(_hasOptions){
+          if(_options['valueObjId'] !== undefined){
+            var _valueObjId = _options['valueObjId'];
+            _options['valueObj'] = COMM.Values.values[_options['valueObjId']];
+          }
+        }
+        // For HApplication -derived classes
+        if(!_hasRect && _hasOptions){
+          _instance = _class.nu(_options);
+        }
+        // For HView and HControl -derived classes
+        else if(_hasRect){
+          _instance = _class.nu(_rect,_parent,_options);
+        }
+      }
+      else if(!(!_class && _hasSubviews)) {
+        console.log('renderNode warning; No such class: '+_className+', node: ',_dataNode);
+      }
+    }
+    catch(e){
+      console.log('renderNode error:',e,', rect:',_rect,', class:',_dataNode['class'],', options:', _options);
+    }
+    // Iterates recursively through all subviews, if specified.
+    if(_hasSubviews){
+      for( i = 0; i < _subViews.length; i++ ){
+        _subView = this.renderNode( _subViews[i], _instance );
+      }
+    }
+    
+    this.scopes.pop();
+    this.scopeDepth --;
+    
+    // Returns the main view (or subview when recursively called).
+    return _instance;
+  }
+});
+
+/** -- Global reference ++ **/
+JSONRenderer = COMM.JSONRenderer;
+
+

data/js/foundation/system/system.js

@@ -0,0 +1,369 @@
+/*   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
+  ** Main container of global operations on +HView+ and
+  ** +HApplication+ -derived classes.
+  **
+  ** HSystem is used to keep +HApplication+ and +HView+ instances
+  ** globally managed. The managed classes themself calls +HSystem+ methods,
+  ** so there is no real need to access +HSystem+ directly from user-level code.
+  **
+***/
+HSystem = {
+  
+/** When the focus behaviour is 1, clicking on any subview brings
+  * the window to front, if attached to a HWindow instance.
+  * If the behaviour is 0, only direct clicks on the HWindow controls
+  * brings the window to front.
+  *
+  **/
+  windowFocusBehaviour: 1,
+  
+/** Singleton class; has no constructor **/
+  // constructor: null,
+  
+/** An array of HApplication instances, index is the appId **/
+  apps: [],
+  
+/** An array (in the same order as apps): holds priority values **/
+  appPriorities: [],
+  
+/** An array (in the same order as apps): holds busy status **/
+  busyApps: [],
+  
+/** This array holds free app id:s **/
+  freeAppIds: [],
+  
+/** The default HSystem ticker interval. Unit is milliseconds. **/
+  defaultInterval: 10,
+  
+/** The default HApplication priority. Unit is "On the n:th tick: poll". **/
+  defaultPriority: 20,
+  
+/** The z-index of root-level +HView+ instances. All the array operations 
+  * are done by the inner logic of +HApplication+ and +HView+ instances.
+  **/
+  viewsZOrder: [],
+  
+/** This is the internal "clock" counter. Gets updated on every tick. **/
+  ticks: 0,
+  
+/** Time in milliseconds for the timeout of a poll to finish before
+  * being classified as stuck and thus forcibly terminated.
+  **/
+  maxAppRunTime: 5000,
+  
+/** Calls applications, uses the prority as a prioritizer.
+  **/
+  scheduler: function(){
+    
+    // Loop through all applications:
+    for( var _appId=0; _appId<this.apps.length; _appId++ ){
+      // Check, if the application exists:
+      if( this.apps[ _appId ] ){
+        // Check, if the application is busy:
+        if( !this.busyApps[ _appId ] ){
+          // Check, if the tick count matches the priority of the app:
+          if( (this.ticks % this.appPriorities[ _appId ]) === 0 ){
+            // Set the app busy, the app itself should "unbusy" itself, when the idle call is done.
+            // That happens in <HApplication._startIdle>
+            
+            // If the app is not busy, then make a idle call:
+            if(HSystem.apps[_appId]){
+              HSystem.apps[_appId]._startIdle();
+            }
+          }
+        }
+      }
+    }
+    
+    if(this._updateZIndexOfChildrenBuffer.length!==0){
+      this._flushUpdateZIndexOfChilden();
+    }
+    
+  },
+  
+  
+/** Calls the scheduler and then calls itself after a timeout to keep
+  * the loop going on.
+  **/
+  ticker: function(){
+    // Increment the tick counter:
+    this.ticks++;
+    this.scheduler();
+    this._tickTimeout = setTimeout( function(){HSystem.ticker();},this.defaultInterval);
+  },
+  
+  
+/** = Description
+  * Adds the structures needed for a new +HApplication+ instance.
+  * 
+  * Called from inside the +HApplication+ constructor.
+  * Binds an app and gives it a unique id.
+  *
+  * = Parameters
+  * +_app+::       The reference to the +HApplication+ instance object.
+  * +_priority+::  The app priority.
+  *
+  * = Returns
+  * The app id.
+  *
+  **/
+  addApp: function(_app, _priority){
+    var _appId;
+    if(this.freeAppIds.length !== 0){
+      _appId = this.freeAppIds.unshift();
+      this.apps[_appId] = _app;
+    } else {
+      this.apps.push(_app);
+      _appId = this.apps.length-1;
+    }
+    
+    // sets self as parent
+    _app.parent  = this;
+    _app.parents = [this];
+    
+    _app.appId = _appId;
+    
+    this.startApp(_appId, _priority);
+    
+    return _appId;
+  },
+  
+/** = Description
+  * Starts polling an app instance (and its components).
+  *
+  * = Parameters
+  * +_appId+::      The unique id of the app.
+  * +_priority+::   The app priority.
+  *
+  **/
+  startApp: function(_appId,_priority){
+    if(_priority===undefined){
+      _priority = this.defaultInterval;
+    }
+    this.appPriorities[ _appId ] = _priority;
+    this.busyApps[_appId] = false;
+  },
+  
+/** = Description
+  * Stops polling an app instance (and its components).
+  *
+  * = Parameters
+  * +_appId+::   The id of the app.
+  *
+  **/
+  stopApp: function(_appId){
+    this.busyApps[_appId] = true;
+  },
+  
+/** = Description
+  * Changes the priority of the app. Calls +stopApp+ and +startApp+.
+  *
+  * = Parameters
+  * +_appId+::     The id of the app.
+  * +_priority+::  The app priority.
+  *
+  **/
+  reniceApp: function(_appId,_priority){
+    this.appPriorities[ _appId ] = _priority;
+  },
+  
+/** = Description
+  * Stops polling and deletes an app instance (and its components).
+  *
+  * = Parameters
+  * +_appId+::    The unique id of the app.
+  * +_forced+::   (Optional) The doesn't wait for the last poll to finish.
+  *
+  **/
+  killApp: function(_appId, _forced){
+    if( !_forced ){
+      var _startedWaiting = new Date().getTime();
+      while( this.busyApps[ _appId ] === true ) {
+        /* Waiting for the app to finish its idle loop... */
+        if (new Date().getTime() > _startedWaiting + this.maxAppRunTime) {
+          break;
+        }
+      }
+    }
+    this.busyApps[_appId] = true;
+    
+    this.apps[ _appId ].destroyAllViews();
+    this.apps[ _appId ] = null;
+    
+    this.freeAppIds.push( _appId );
+  },
+  
+/** All +HView+ instances that are defined **/
+  views: [],
+  
+/** List of free +viwes+ indexes **/
+  _freeViewIds: [],
+  
+/** = Description
+  * Adds a view and assigns it an id.
+  *
+  * = Parameters
+  * +_view+::   The +HView+ instance.
+  *
+  * = Returns
+  * The new view id.
+  *
+  **/
+  addView: function(_view){
+    var _newId;
+    if(this._freeViewIds.length===0){
+      _newId = this.views.length;
+      this.views.push(_view);
+    }
+    else {
+      _newId = this._freeViewIds.pop();
+      this.views[_newId] = _view;
+    }
+    return _newId;
+  },
+  
+/** = Description
+  * Removes a view and recycles its id.
+  *
+  * = Parameters
+  * +_viewId+::  The view id to delete.
+  *
+  **/
+  delView: function(_viewId){
+    this.views[_viewId] = null;
+    this._freeViewIds.push(_viewId);
+  },
+  
+/** The view id of the active window. 0 means none. **/
+  activeWindowId: 0,
+  
+/** = Description
+  * Focuses the window given and blurs the previous one.
+  *
+  * = Parameters
+  * +_view+::   The +HView+ instance, this is almost always a
+  *             +HWindow+ instance.
+  *
+  **/
+  windowFocus: function(_view){
+    if(!_view){
+      this.activeWindowId=0;
+      return;
+    }
+    var _activeWindowId = this.activeWindowId,
+        _views = this.views,
+        _viewId = _view.viewId;
+    if(_views[_activeWindowId]){
+      if (_views[_activeWindowId]["windowBlur"]) {
+        _views[_activeWindowId].windowBlur();        
+      }
+    }
+    this.activeWindowId=_viewId;
+    _view.bringToFront();
+    _view.windowFocus();
+  },
+  
+/** optimization of zindex buffer, see +HView+ **/
+  _updateZIndexOfChildrenBuffer: [],
+  
+/** Updates the z-indexes of the children of the given +_viewId+. **/
+  updateZIndexOfChildren: function(_viewId) {
+    if(this._updateZIndexOfChildrenBuffer.indexOf(_viewId)===-1){
+      this._updateZIndexOfChildrenBuffer.push(_viewId);
+    }
+  },
+  
+/** Flushes the z-indexes. This is a fairly expensive operation,
+  * thas's why the info is buffered.
+  **/
+  _flushUpdateZIndexOfChilden: function() {
+    
+    var j=0, // buffer index
+        
+        // reference to the HSystem namespace
+        _this = HSystem,
+        
+        // reference to the buffer
+        _buffer = this._updateZIndexOfChildrenBuffer,
+        
+        // the length of the buffer
+        _bufLen = _buffer.length;
+        
+    // loop buffer length times to get the items
+    for ( ; j < _bufLen; j++ ) {
+      
+      
+      // get and remove view the view id from the z-index flush status buffer:
+      var _viewId = _buffer.shift(),
+          
+          // reference to the view's z-index array or the system root-level views if _viewId is 0
+          _views = ((_viewId === null)?(_this.viewsZOrder):(_this.views[ _viewId ].viewsZOrder)),
+          
+          // the length of the view's z-index array
+          _viewLen = _views.length,
+          
+          // reference to the setStyle method of the element manager
+          _setStyl = ELEM.setStyle,
+          
+          // reference to HSystem.views (collection of all views, by index)
+          _sysViews = _this.views,
+          
+          
+      // assign variables for use inside the inner loop:
+          
+          // the viewId of the view to be updated
+          _subViewId,
+          
+          // the view itself with the viewId above
+          _view,
+          
+          // the elemId property, used as a [] -lookup in the loop
+          _elemIdStr = 'elemId',
+          
+          // the css property name
+          _zIdxStr = 'z-index',
+          
+          // the loop index
+          i=0,
+          
+          // the element id of the view
+          _elemId;
+      
+      // end of var declarations
+      
+      // loop through all subviews and update the indexes:
+      for ( ; i < _viewLen; i++ ) {
+        
+        // get the viewId to be updated based on the z-index array
+        _subViewId = _views[ i ];
+        
+        // reference to the view itself
+        _view = _sysViews[ _subViewId ];
+        
+        // the element id of the view
+        _elemId = _view[ _elemIdStr ];
+        
+        // do the element manager call itself to update the dom property
+        _setStyl( _elemId, _zIdxStr, i );
+      }
+    }
+  }
+};
+  
+// });
+
+// Starts the ticking, when the document is loaded:
+LOAD(
+  function(){
+    HSystem.ticker();
+  }
+);