rsence-pre 2.1.0.1.pre

data/js/controls/window/window.js

@@ -0,0 +1,286 @@
+/*   RSence
+ *   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
+  ** The HWindow component can contain subviews and its position and size
+  ** is modifiable by the user (within limits).
+  ** Its label is the title of the HWindow and its constructor support a
+  ** few additions to the set of HDynControl#controlDefaults.
+  ** See #controlDefaults
+  **
+  ***/
+var//RSence.Controls
+HWindow = HDynControl.extend({
+  
+  componentName:      'window',
+  
+/** = Description
+  * In addition to the standard HControl#constructor options,
+  * the following properties can be set:
+  * 
+  * Key::         Description
+  * +minX+::      The minimum X-coordinate allowed to be dragged or resized to.
+  *               Defaults to +0+.
+  * +minY+::      The minimum Y-coordinate allowed to be dragged or resized to.
+  *               Defaults to +0+.
+  * +maxX+::      The maximum X-coordinate allowed to be dragged or resized to.
+  *               Defaults to the browser window width.
+  * +maxY+::      The maximum Y-coordinate allowed to be dragged or resized to.
+  *               Defaults to the browser window height.
+  * +minSize+::   An array containing exactly two values: +[ width, height ]+.
+  *               Defines the minimum size allowed for resizing.
+  *               Defaults to +[ 96, 54 ]+
+  * +maxSize+::   An array containing exactly two values: +[ width, height ]+.
+  *               Defines the maximum size allowed for resizing.
+  *               Defaults to the browser window size.
+  * +resizeW+::   The size of the west (left) resizable edge. Defaults to +6+.
+  * +resizeE+::   The size of the east (right) resizable edge. Defaults to +6+.
+  * +resizeN+::   The size of the north (top) resizable edge. Defaults to +6+.
+  * +resizeS+::   The size of the south (bottom) resizable edge. Default to +6+.
+  * +resizeNW+::  The size of the north-west (left top) resizable corner.
+  *               Defaults to +[ 6, 6 ]+
+  * +resizeNE+::  The size of the north-east (right top) resizable corner.
+  *               Defaults to +[ 6, 6 ]+
+  * +resizeSW+::  The size of the south-west (left bottom) resizable corner.
+  *               Defaults to +[ 6, 6 ]+
+  * +resizeSE+::  The size of the south-east (right bottom) resizable corner.
+  *               Defaults to +[ 16, 16 ]+
+  * +noResize+::  A flag (when true) disables all resizing and only allows
+  *               moving.
+  * +fullWindowMove+:: A flag (when true) enables the full HWindow area 
+  *                    responds to drag events. By default it's false,
+  *                    meaning only the title bar is draggable.
+  * +closeButton+:: A flag (when true) enables the close button of HWindow.
+  *                 By default, it's disabled. When enabled, extend the
+  *                 HWindow#windowClose method. By default it destructs
+  *                 the HWindow instance.
+  * +collapseButton+:: A flag (when true) enables the collapse (or minimize)
+  *                    button of the HWindow instance. By default it's
+  *                    disabled. When enabled, extend the 
+  *                    HWindow#windowCollapse method, which by default
+  *                    zooms the window to its +minSize+.
+  * +zoomButton+:: A flag (when true) enables the zoom (or maximize)
+  *                button of the HWindow instance. By default it's
+  *                disabled. When enabled, extend the 
+  *                HWindow#windowZoom method, which by default zooms the
+  *                contents of the HWindow to fit or the +maxSize+ depending
+  *                on which is smaller.
+  *
+  **/
+  controlDefaults: (HDynControl.prototype.controlDefaults.extend({
+    constructor: function(_ctrl){
+      var _winSize = ELEM.windowSize(),
+          _winWidth = _winSize[0],
+          _winHeight = _winSize[1];
+      if(!this.minSize){
+        this.minSize = [96,54];
+      }
+      if(!this.maxSize){
+        this.maxSize = _winSize;
+      }
+      if(!this.maxX){
+        this.maxX = _winWidth-this.minSize[0];
+      }
+      if(!this.maxY){
+        this.maxY = _winHeight-this.minSize[1];
+      }
+      if(!this.events){
+        this.events = {
+          draggable: true
+        };
+      }
+      if(!this.resizeNW){
+        this.resizeNW = [ 6, 6 ];
+      }
+      if(!this.resizeNE){
+        this.resizeNE = [ 6, 6 ];
+      }
+      if(!this.resizeSW){
+        this.resizeSW = [ 6, 6 ];
+      }
+      if(!this.resizeSE){
+        this.resizeSE = [ 16, 16 ];
+      }
+    },
+    maxX: 'auto',
+    maxY: 'auto',
+    maxSize: 'auto',
+    resizeW:   4,
+    resizeE:   4,
+    resizeN:   4,
+    resizeS:   4,
+    fullWindowMove: false,
+    closeButton: false,
+    collapseButton: false,
+    zoomButton: false
+  })),
+  
+  draw: function(){
+    var _drawn = this.drawn;
+    this.base();
+    if(!_drawn){
+      HSystem.windowFocus(this);
+    }
+  },
+  
+  // -- overrides the drag rules to adapt to the !fullWindowMove as well
+  // as disabling draggability in window button areas. ++
+
+/** = Description
+  * makeRectRules function
+  *
+  *
+  **/
+  makeRectRules: function(){
+    var _this = this,
+        _rectRules = _this.base(),
+        _rect = _this.rect,
+        _opts = _this.options,
+        _leftPx=_opts.resizeW;
+    if(!_opts.fullWindowMove){
+      if(_opts.zoomButton){
+        _leftPx = 61;
+      }
+      else if(_opts.collapseButton){
+        _leftPx = 46;
+      }
+      else if(_opts.closeButton){
+        _leftPx = 27;
+      }
+      _rectRules[8] = [_leftPx,_opts.resizeN,_rect.width-_opts.resizeE,25];
+    }
+    return _rectRules;
+  },
+  
+  maxRect: function(){
+    var _rect = this.base();
+    if(_rect[2]<this.options.minSize[0]){
+      _rect[2] = this.options.minSize[0];
+    }
+    else if(_rect[2]>this.options.maxSize[0]){
+      _rect[2] = this.options.maxSize[0];
+    }
+    if(_rect[3]<this.options.minSize[1]){
+      _rect[3] = this.options.minSize[1];
+    }
+    else if(_rect[3]>this.options.maxSize[1]){
+      _rect[3] = this.options.maxSize[1];
+    }
+    return _rect;
+  },
+  
+/** Reports to HSystem that this window has the focus and the 
+  * previously active window needs to blur 
+  **/
+  gainedActiveStatus: function(){
+    HSystem.windowFocus(this);
+  },
+  
+/** HSystem calls this method, whenever this window is allowed to be focused
+  **/
+  windowFocus: function(){
+    this.toggleCSSClass(this.elemId, 'inactive', false);
+  },
+  
+/** HSystem calls this method, whenever this window needs to lose its 
+  * focus (another window focused) 
+  **/
+  windowBlur: function(){
+    this.toggleCSSClass(this.elemId, 'inactive', true);
+    this.setStyle('cursor','default');
+  },
+  
+/** This method gets called, whenever the close button has been clicked
+  **/
+  windowClose: function(){
+    this.die(); // extend this to this.app.die(), if your app needs to die instead of just the window
+  },
+  
+/** This method gets called, whenever the collapse (minimize) button has 
+  * been clicked
+  **/
+  windowCollapse: function(){
+    if(this.options.collapseUsing){
+      this.options.collapseUsing( this );
+    }
+    else {
+      var _minRect = HRect.nu(
+        this.rect.leftTop,
+        this.rect.leftTop.subtract(
+          0-this.options.minSize[0],
+          0-this.options.minSize[1]
+        )
+      );
+      if(!this.rect.equals(_minRect)){
+        this.prevRect = HRect.nu(_minRect);
+        this.animateTo( _minRect );
+      }
+    }
+  },
+  
+/** This method gets called, whenever the zoom (maximize/restore) 
+  * button has been clicked
+  **/
+  windowZoom: function(){
+    var _maxSize = this.options.maxSize === 'auto' ? this.parentSize() : this.options.maxSize,
+        _maxRect = HRect.nu(
+          this.options.minX,
+          this.options.minY,
+          _maxSize[0],
+          _maxSize[1]
+        ),
+        _fitsRect = HRect.nu( this.rect ),
+        i = 0,
+        _views = this.views,
+        _view, _size, _right, _bottom;
+    for( ; i < _views.length; i++ ){
+      _view = HSystem.views[_views[i]];
+      _size = ELEM.getVisibleSize(_view.elemId);
+      _pos  = ELEM.getVisiblePosition(_view.elemId);
+      _right = _size[0]+_pos[0]-this.pageX();
+      _bottom = _size[1]+_pos[1]-this.pageY();
+      if(_right > _fitsRect.width){
+        _fitsRect.setWidth(_right);
+      }
+      if(_bottom > _fitsRect.height){
+        _fitsRect.setHeight(_bottom);
+      }
+    }
+    if(_fitsRect.width > _maxSize[0]){
+      _fitsRect.setWidth( _maxSize[0] );
+    }
+    else if(_fitsRect.width < this.options.minSize[0]){
+      _fitsRect.setWidth( this.options.minSize[0] );
+    }
+    if(_fitsRect.height > _maxSize[1]){
+      _fitsRect.setHeight( _maxSize[1] );
+    }
+    else if(_fitsRect.height < this.options.minSize[1]){
+      _fitsRect.setHeight( this.options.minSize[1] );
+    }
+    if (!_fitsRect.equals(_maxRect) && (EVENT.status[ EVENT.button2 ] || EVENT.status[ EVENT.altKeyDown ]) ){
+      this.animateTo( _maxRect );
+      this.prevRect = HRect.nu( this.rect );
+      this.animateTo( _maxRect );
+    }
+    else if(this.rect.equals(_fitsRect)){
+      if(this.prevRect !== undefined && !this.prevRect.equals(_fitsRect)){
+        this.animateTo( HRect.nu(this.prevRect) );
+      }
+      else {
+        this.prevRect = HRect.nu( this.rect );
+        this.animateTo( _maxRect );
+      }
+    }
+    else {
+      this.prevRect = HRect.nu(_fitsRect);
+      this.animateTo( _fitsRect );
+    }
+  }
+});
+

data/js/core/class/class.js

@@ -0,0 +1,318 @@
+/*   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
+ */
+
+/** = Description
+  * The extended object model.
+  *
+  * HClass is the foundation class of all other classes. It implements
+  * a proper object oriented environment in Javascript. It supports
+  * inheritance (HClass.extend), superclass invocation ( this.base ),
+  * interfaces (HClass.implement) and such.
+  *
+  * It's derived from and backwards compatible with  Dean Edward's Base.js,
+  * so you can mix and match code written against Base.js.
+  *
+  * It is intended for the following main purposes:
+  *   * To easily create classes without the MyClass.prototype cruft
+  *   * Method overriding with intuitive access to the overridden method (like Ruby's super)
+  *   * To avoid calling a class' constructor function during the prototyping phase
+  *   * To easily add static (class) properties and methods
+  *   * To achieve the above without resorting to global functions to build prototype chains
+  *   * To achieve the above without affecting Object.prototype
+  *
+  * The HClass class extends the 'Object' object by adding one instance method (base) 
+  * and two class methods (extend, implement). Instance method extend can be also called directly.
+  *
+  * == Example:
+  *    MyClass = HClass.extend({
+  *      constructor: function( foo ){
+  *        this.setFoo( foo );
+  *      },
+  *      setFoo: function( foo ){
+  *        this.foo = foo;
+  *      }
+  *    });
+  *    
+  *    myClassInstance1 = MyClass.nu( 'rabbids' );
+  *    myClassInstance2 = new MyClass( 'ribbit' );
+  *    
+  *    MyEqualsClass = MyClass.extend({
+  *      testFoo: function( that ){
+  *        return this.foo === that.foo;
+  *      }
+  *    });
+  *    myEqualsClassInstance1 = MyEqualsClass.nu( 'woof' );
+  *    equals1 = myEqualsClassInstance1.testFoo( myClassIntance1 );
+  *    myClassInstance2.setFoo( myEqualsClassInstance1.foo );
+  *    equals2 = myEqualsClassInstance1.testFoo( myClassIntance2 );
+  *
+  **/
+var//RSence.Core
+HClass = function() {
+  if ( arguments.length ) {
+    if (this === window) {
+      HClass.prototype.extend.call( arguments[0], arguments.callee.prototype );
+    }
+    else {
+      this.extend( arguments[0] );
+    }
+  }
+};
+
+
+HClass.prototype = {
+  
+ /* The property copying method. */
+  extend: function(_source, _value) {
+    var _extend = HClass.prototype.extend,
+        _ancestor, _method, _previous, _returnValue, i, _name, _prototype, _protected;
+    if (arguments.length === 2) {
+      _ancestor = this[_source];
+      // only methods are inherited
+      if ((_ancestor instanceof Function) && (_value instanceof Function) &&
+          _ancestor.valueOf() !== _value.valueOf() && (/\bbase\b/).test(_value)) {
+        _method = _value;
+        _value = function() {
+          // saves the this.base that is the this.base method of this child
+          _previous = this.base;
+          // copies previous this.base from the direction from HClass
+          this.base = _ancestor;
+          // current class's method is called
+          // now inside the function when called this.base points to parent method
+          _returnValue = _method.apply(this, arguments);
+          // then because event this function can be called from child method
+          // resets the base to as is was before calling this function
+          this.base = _previous;
+          return _returnValue;
+        };
+        _value.valueOf = function() {
+          return _method;
+        };
+        _value.toString = function() {
+          return String(_method);
+        };
+      }
+      return this[_source] = _value;
+    // this is called when called by HClass.extend
+    } else if (_source) {
+      _prototype = {toSource: null};
+      _protected = ["toString", "valueOf"];
+      // we want default constructor function
+      if (HClass._prototyping) {
+        // 3. index
+        _protected.push("constructor");
+      }
+      for (i = 0; (_name = _protected[i]); i++) {
+        if (_source[_name] !== _prototype[_name]) {
+          _extend.call(this, _name, _source[_name]);
+        }
+      }
+      for (_name in _source) {
+        if (!_prototype[_name]) {
+          _extend.call(this, _name, _source[_name]);
+        }
+      }
+    }
+    
+    // alternative constructor (use instead of the new keywoard)
+    this.nu = function() {
+      return new (
+        this.extend( {
+          constructor: function( args ){
+            this.base.apply( this, args );
+          }
+        } )
+      )( arguments );
+    };
+    return this;
+  },
+  /** = Description
+    * If a method has been overridden then the base method provides access to the overridden method. 
+    * Call this method from any other method to invoke that method's ancestor.
+    * It is also possible to call the base method from within a constructor function.
+    *
+    **/
+  base: function() {
+    // this method can be called from any other method to invoke that method's parent
+  }
+};
+
+/** = Description
+  * The class method method to create a new extended class.
+  *
+  * If the method name constructor is defined null as the +_instance+ parameter,
+  * it will return a single instance.
+  *
+  * = Parameters:
+  * +_instance+:: An object that has properties and methods of inherited class.
+  * +_static+::   An object that has properties and methods of inherited class's
+  *               class methods if the method named constructor is defined null
+  *               in _instance parameter.
+  *
+  * = Returns:
+  *   Returns the extended class object.
+  *
+  * = Usage:
+  *   Point = HClass.extend({
+  *   constructor: function(x, y) {
+  *     this.x = x;
+  *     this.y = y;
+  *   }
+  *   });
+  *   Rectangle = Point.extend({
+  *   constructor: function(x, y, width, height) {
+  *     this.base(x, y);
+  *     this.width = width;
+  *     this.height = height;
+  *   },
+  *   getWidth: function() {
+  *     return this.width;
+  *   },
+  *   getHeight: function() {
+  *     return this.height;
+  *   }
+  *   },
+  *   {
+  *   // class methods
+  *   description: "this is a Rectangle",
+  *   getClass: function() {
+  *     return this;
+  *   }
+  *   });
+  *
+  **/
+HClass.extend = function(_instance, _static) {
+  // reference to HClass's prototype extend method (HClass's class structure extend method)
+  var _extend = HClass.prototype.extend,
+      _prototype, _constructor, _klass, _object;
+  // if _instance is undefined,null,"" etc. creates object so that code below works
+  if (!_instance) {
+    _instance = {};
+  }
+  HClass._prototyping = true;
+  // this is base for single instance or prototype (class structure) for object that are created
+  // from this class
+  _prototype = new this;
+  // copies properties and methods from _instance to _prototype (class structure)
+  _extend.call(_prototype, _instance);
+  // this constructor came from _instance
+  _constructor = _prototype.constructor;
+  _prototype.constructor = this;
+  delete HClass._prototyping;
+  
+  _klass = function() {
+    if (!HClass._prototyping) {
+      _constructor.apply(this, arguments);
+    }
+    this.constructor = _klass;
+  };
+  // this is the new class's prototype (class structure)
+  _klass.prototype = _prototype;
+  // copies static method (class method)
+  // acts like HClass.extend
+  _klass.extend = this.extend;
+  // copies static method (class method)
+  // acts like HClass.implement
+  _klass.implement = this.implement;
+  _klass.toString = function() {
+    return String(_constructor);
+  };
+  // copies properties and methods from _static directly to statc methods (class methods)
+  // of new class
+  _extend.call(_klass, _static);
+  // if _constructor is marked as null returns the created instance (that is also class structure for
+  // instances if class is returned
+  _object = (_constructor !== null) ? _klass : _prototype;
+  if (_object.init instanceof Function) {
+    _object.init();
+  }
+  return _object;
+};
+
+/** = Description
+  * Copies the prototype properties and methods from _interface or if it is an object it's properties and functions
+  * to HClass or class inherited from HClass. Mimics the interface behaviour of ordinary programming languages.
+  *
+  * = Usage:
+  * Defines an interface:
+  *  
+  *  AreaInterface = HClass.extend({
+  *  constructor: null,
+  *    // implement
+  *    // don't define here
+  *    //getWidth: function() {},
+  *    //getHeight: function() {},
+  *  area: function() {
+  *    return this.getWidth() * this.getHeight();
+  *  }
+  *  });
+  *  
+  *  Rectangle = HClass.extend({
+  *  constructor: function(x, y, width, height) {
+  *    this.x = x;
+  *    this.y = y;
+  *    this.width = width;
+  *    this.height = height;
+  *  },
+  *  getWidth: function() {
+  *    return this.width;
+  *  },
+  *  getHeight: function() {
+  *    return this.height;
+  *  }
+  *  });
+  *  
+  *  Rectangle.implement(AreaInterface);
+  *
+  **/
+HClass.implement = function(_interface) {
+  // copies prototype fields and methods (class structures properties and methods)
+  if (_interface instanceof Function) {
+    _interface = _interface.prototype;
+  }
+  this.prototype.extend(_interface);
+};
+
+//var Base = HClass;
+
+// Array fix
+if ([]['indexOf']===undefined) {
+  // Object.extend = function(_destination, _source) {
+  //   for (var _property in _source) {
+  //     _destination[_property] = _source[_property];
+  //   }
+  //   return _destination;
+  // };
+  // Object.extend(Array.prototype, {
+  Array.prototype.indexOf = function(_anObject){
+    var i = 0, l = this.length;
+    for (; i < l; i++) {
+      if (this[i] === _anObject) {
+        return i;
+      }
+    }
+    return -1;
+  };
+}
+
+
+// ff version 3.0.3 fails on this, when firebug installed: try/catch block
+try {
+
+// console.log surrogate for browsers without a console
+if(window['console']===undefined){
+  window.console = {
+    log: function(){
+    }
+  };
+}
+
+
+} catch(e) {}
+
+