rsence 2.1.10 → 2.1.11

data/js/core/event/event.js

@@ -48,7 +48,7 @@ Event = {
   **/
   isLeftClick: function(e) {
     // IE: left 1, middle 4, right 2
-    if (BROWSER_TYPE.ie) {
+    if (BROWSER_TYPE.ie && !BROWSER_TYPE.ie9) {
       return (e.button === 1 || e.button === 3 || e.button === 5);
     }
     else {
@@ -147,7 +147,7 @@ Event = {
 
 // Activates the garbage collector of Internet Explorer 
 // when the document is unloaded:
-if (BROWSER_TYPE.ie) {
+if (BROWSER_TYPE.ie && !BROWSER_TYPE.ie9) {
   Event.observe(window, "unload", Event.unloadCache, false);
 }
 

data/js/datetime/timesheet/old_timesheet.js

@@ -0,0 +1,292 @@
+/*   RSence
+ *   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
+ */
+
+/*** = Description
+  ** HTimesheet is a simple timesheet control. 
+  ***/
+var//RSence.DateTime
+HTimeSheet = HControl.extend({
+  
+  componentName: 'timesheet',
+  
+  /* Default amount of pixels per hour. Override with options when necessary. */
+  pxPerHour: 24,
+  
+  /* Default amount of pixels from left. Override with options when necessary. */
+  itemOffsetLeft: 36,
+  
+  /* Default amount of pixels from right. Override with options when necessary. */
+  itemOffsetRight: 0,
+  
+  defaultEvents: {
+    draggable: true
+  },
+  
+  controlDefaults: HControlDefaults.extend({
+    pxPerHour: null,
+    itemOffsetLeft: null,
+    itemOffsetRight: null,
+    itemMinHeight: 24,
+    newItemLabel: 'New Item',
+    constructor: function(_ctrl){
+      if(this.pxPerHour !== null){
+        _ctrl.pxPerHour = this.pxPerHour;
+      }
+      if(this.itemOffsetLeft !== null){
+        _ctrl.itemOffsetLeft = this.itemOffsetLeft;
+      }
+      if(this.itemOffsetRight !== null){
+        _ctrl.itemOffsetRight = this.itemOffsetRight;
+      }
+    }
+  }),
+  
+/** = Description
+  * Redraws the timesheet.
+  *
+  **/
+  refresh: function(){
+    if(this.drawn){
+      var _areaHeight = this.rect.height;
+      this.pxPerHour = (_areaHeight-(_areaHeight%48)) / 24;
+      if(this.options['hideLabel']){
+        this.setStyleOfPart( 'label', 'display', 'none' );
+        this.setStyleOfPart( 'state', 'left', '0px' );
+        this.itemOffsetLeft = 0;
+      }
+      else{
+        this.setStyleOfPart( 'label', 'height', (this.pxPerHour*24)+'px' );
+      }
+      this.setStyleOfPart( 'state', 'height', (this.pxPerHour*24)+'px' );
+    }
+    this.base();
+  },
+  
+/** = Description
+  * Refreshes the hour labels.
+  *
+  **/
+  refreshLabel: function(){
+    var hour = 1,
+        hours = [],
+        rowHeight = this.pxPerHour;
+        lineHeight = Math.round(this.pxPerHour/2);
+    for(; hour < 24; hour++){
+      hours.push('<div style="line-height:'+rowHeight+'px;height:'+rowHeight+'px;top:'+Math.round((hour*rowHeight)-lineHeight)+'px" class="timesheet_hours_row">'+hour+':00</div>');
+    }
+    this.markupElemIds && this.markupElemIds.label && ELEM.setHTML(this.markupElemIds.label,hours.join(''));
+    this.refreshState();
+  },
+  
+/** = Description
+  * Refreshes the lines which mark hours and half-hours.
+  *
+  **/
+  refreshState: function(){
+    var line = 0,
+        lines = [],
+        lineHeight = Math.round(this.pxPerHour/2);
+    for(; line < 48; line++){
+      lines.push('<div style="top:'+(line*lineHeight)+'px" class="timesheet_lines_row'+(line%2)+'"></div>');
+    }
+    this.markupElemIds && this.markupElemIds.label && ELEM.setHTML(this.markupElemIds.state,lines.join(''));
+  },
+  dragItem: false,
+  
+/** = Description
+  * Creates an item into timesheet with default label 'New Item'.
+  *
+  * = Parameters
+  * +origY+:: Y coordinate of the new item.
+  *
+  **/
+  createItem: function(origY){
+    var _lineHeight = Math.round(this.pxPerHour/2);
+    origY = Math.floor( origY / _lineHeight )*_lineHeight;
+    var maxY = _lineHeight*48,
+        lineHeight = Math.round(this.pxPerHour/2);
+    if(origY>maxY){
+      origY = maxY;
+    }
+    this.dragItem = this.createTimeSheetItem( { label: this.options.newItemLabel }, origY, lineHeight, 'create' );
+  },
+  
+/** = Description
+  * Dragging is used to mark items on the timesheet.
+  * 
+  * = Parameters
+  * +x+:: x coordinate of the origin of drag
+  * +y+:: y coordinate of the origin of drag
+  *
+  **/
+  startDrag: function(x,y){
+    this._startDragTime = new Date().getTime();
+    this._startDragCoords = [x,y];
+    return true;
+  },
+  
+  drag: function(x,y){
+    if(((new Date().getTime()) - this._startDragTime) < 200){
+      // only create when 200 ms has elapsed to enable clicking
+      return true;
+    }
+    if(this._startDragCoords[0]!==x && this._startDragCoords[1]!==y){
+      this.createItem(this._startDragCoords[1]-this.pageY());
+      EVENT.startDragging( this.dragItem );
+      return true;
+    }
+  },
+  
+  click: function(x,y){
+    // deactivate all items
+    EVENT.changeActiveControl(this);
+    return true;
+  },
+  
+  listItemViews: false,
+  
+/** = Description
+  * Sets the editor given as parameter as the editor of instance.
+  *
+  * = Parameters
+  * +_editor+:: 
+  *
+  **/
+  setEditor: function( _editor ){
+    this.editor = _editor;
+  },
+  
+/** = Description
+  * Returns HRect the size of given parameters and suitable for timesheet.
+  *
+  * = Parameters
+  * +_origY+::      Y coordinate.
+  * +_lineHeight+:: The height of item on time sheet.
+  *
+  **/
+  createItemRect: function(_origY, _lineHeight){
+    var _left = this.itemOffsetLeft+1,
+        _top = _origY+1,
+        _right = this.rect.width - this.itemOffsetRight - 1,
+        _bottom = _origY + _lineHeight - 2;
+    if( (_top - _bottom) < this.options.itemMinHeight ){
+      _bottom = _top + this.options.itemMinHeight;
+    }
+    return HRect.nu( _left, _top, _right, _bottom );
+  },
+
+/** = Description
+  * Destructor; destroys the editor first and commences inherited die.
+  *
+  **/
+  die: function(){
+    this.editor.die();
+    this.base();
+  },
+  
+/** = Description
+  * Returns a new time sheet item control. By default returns an instance
+  * of HTimeSheetItem. Extend to use custom time sheet controls customized
+  * for application specific purposes.
+  *
+  * = Parameters
+  * *_value*::      A value object for the item.
+  * *_top*::        Top position, 0 by default.
+  * *_height*::     Height, same as half of +#pxPerHour+ by default.
+  * *_drogMode*::   Dragging mode. 'normal' or 'create'. Is 'normal' by default.
+  *
+  **/
+  createTimeSheetItem: function( _value, _top, _height, _dragMode ) {
+    if(_dragMode===undefined){
+      _dragMode = 'normal';
+    }
+    if(_top===undefined){
+      _top = 0;
+    }
+    if(_height===undefined){
+      _height = Math.round(this.pxPerHour/2);
+    }
+    var
+    _label = _value['label'],
+    _item = HTimeSheetItem.nu(
+      this.createItemRect( _top, _height ),
+      this, {
+        label: _label,
+        value: _value,
+        events: {
+          draggable: true
+        }
+      }
+    );
+    _item.dragMode = _dragMode;    
+    return _item;
+  },
+  
+/** = Description
+  * Redraws and refreshes the values on timesheet.
+  *
+  **/
+  refreshValue: function(){
+    var
+    _data = this.value,
+    i;
+    if(this.listItemViews === false){
+      this.listItemViews = [];
+    }
+    else if(this.listItemViews.length > 0){
+      for( i=0; i<this.listItemViews.length; i++){
+        this.listItemViews[i].die();
+      }
+      this.listItemViews = [];
+    }
+    if(_data instanceof Array && _data.length > 0){
+      var
+      _value,
+      _item;
+      for( i=0; i<_data.length; i++){
+        _value = _data[i];
+        _item = this.createTimeSheetItem( _value );
+        this.listItemViews.push( _item );
+      }
+    }
+    var
+    _overlaps = [],
+    j;
+    for(i=0;i<this.listItemViews.length;i++){
+      for(j=0;j<this.listItemViews.length;j++){
+        if((i !== j) && (_overlaps.indexOf(i)===-1) && (_overlaps.indexOf(j)===-1)){
+          if(this.listItemViews[i].rect.intersects(this.listItemViews[j].rect)){
+            _overlaps.push(i);
+          }
+        }
+      }
+    }
+    var
+    _overlapCount = _overlaps.length+1,
+    _overlapLefts = {},
+    _itemWidth = ( this.rect.width - this.itemOffsetRight - this.itemOffsetLeft ),
+    _width = Math.floor( _itemWidth / _overlapCount),
+    _left = this.itemOffsetLeft;
+    for(j=0;j<_overlapCount;j++){
+      _overlapLefts[_overlaps[j]] = _left + (j*_width) + _width;
+    }
+    for(i=0;i<this.listItemViews.length;i++){
+      if(_overlaps.indexOf(i)===-1){
+        this.listItemViews[i].rect.setLeft(_left);
+      }
+      else {
+        this.listItemViews[i].rect.setLeft(_overlapLefts[i]);
+      }
+      this.listItemViews[i].rect.setWidth(_width);
+    }
+    for(i=0;i<this.listItemViews.length;i++){
+      this.listItemViews[i].drawRect();
+    }
+  }
+});
+

data/js/datetime/timesheet/themes/default/old_timesheet.css

@@ -0,0 +1,30 @@
+.timesheet_hours_col {
+  position: absolute;
+  top: 0px; left: 0px; width: 32px;
+  font-family: Arial, sans-serif;
+  font-size: 11px;
+  color: #666;
+  vertical-align: middle;
+  text-align: right;
+}
+.timesheet_hours_row {
+  position: absolute;
+  left: 0px; width: 32px;
+}
+.timesheet_lines_col {
+  position: absolute;
+  top: 0px; left: 36px; right: 0px;
+  border-left: 1px solid #aaa;
+  border-bottom: 1px solid #aaa;
+  border-right: 1px solid #aaa;
+}
+.timesheet_lines_row0,
+.timesheet_lines_row1 {
+  position: absolute;
+  left: 0px; right: 0px; height: 1px;
+  line-height: 1px; font-size: 0px;
+  background-color: #ccc;
+}
+.timesheet_lines_row0 {
+  background-color: #aaa;
+}

data/js/datetime/timesheet/themes/default/old_timesheet.html

@@ -0,0 +1,2 @@
+<div class="timesheet_hours_col" id="label#{_ID}"></div>
+<div class="timesheet_lines_col" id="state#{_ID}"></div>

data/js/datetime/timesheet_item/old_timesheet_item.js

@@ -0,0 +1,308 @@
+/*   RSence
+ *   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
+ */
+
+/*** = Description
+  ** Item class to be used with HTimeSheet.
+  ***/
+var//RSence.DateTime
+HTimeSheetItem = HControl.extend({
+  
+  componentName: 'timesheet_item',
+  
+  /* Which mode the component is in. When created by dragging, acts in 'create' mode, otherwise is 'normal'. Can be overridden in options. */
+  dragMode: 'create',
+  
+  /* The previous coordinate. Used to detect double-drag as double-click */
+  prevXY: [0,0],
+  
+  /* The time at the previous coordinate. Used to detect double-drag as double-click. */
+  prevXYTime: 0,
+  
+  defaultEvents: {
+    draggable: true,
+    click: true,
+    doubleClick: true
+  },
+  
+  controlDefaults: HControlDefaults.extend({
+    dragMode: 'create',
+    constructor: function(_ctrl){
+      _ctrl.dragMode = this.dragMode;
+    }
+  }),
+  
+/** = Description
+  * Dragging is used to change coordinates.
+  *
+  * = Parameters
+  * +x+:: X coordinate at the start of drag.
+  * +y+:: Y coordinate at the start of drag.
+  *
+  **/
+  startDrag: function(x,y){
+    this.origY = y-this.parent.pageY();
+    if(this.dragMode === 'normal'){
+      var _timeNow = new Date().getTime(),
+          _xEquals = (Math.round(this.prevXY[0]/4) === Math.round(x/4)),
+          _yEquals = (Math.round(this.prevXY[1]/4) === Math.round(y/4)),
+          _noTimeout = ((_timeNow - this.prevXYTime) < 500);
+      if( _xEquals && _yEquals && _noTimeout ) { // doubleClick
+        return true;
+      }
+      else {
+        var _diffTop = this.rect.top - this.origY,
+            _diffBottom = this.rect.bottom - this.origY;
+        if(0 >= _diffTop && _diffTop >= -3){
+          this.dragMode = 'resize-top';
+        }
+        else if(0 <= _diffBottom && _diffBottom <= 4){
+          this.dragMode = 'resize-bottom';
+        }
+        else {
+          this.dragMode = 'move';
+          this.moveDiff = this.origY - this.rect.top;
+        }
+        this.bringToFront();
+      }
+    }
+    this.prevXY = [x,y];
+    this.prevXYTime = _timeNow;
+    return true;
+  },
+  
+  doubleClick: function(x,y){
+    if( this.parent['editor'] ){
+      var _editor = this.parent.editor;
+      _editor.setTimeSheetItem(this);
+      _editor.bringToFront();
+      _editor.show();
+      return true;
+    }
+    return false;
+  },
+  
+/** = Description
+  * Label setter function.
+  *
+  * = Parameters
+  * +_label+:: New label
+  *
+  **/
+  setTimeSheetItemLabel: function(_label){
+    this.label = _label;
+    this.refreshLabel();
+  },
+  
+/** = Description
+  * Function used to calculate the right size for a new 
+  * item created by dragging.
+  *
+  * = Parameters
+  * +_y+:: Y coordinate at the start of drag.
+  *
+  **/
+  dragCreate: function(_y){
+    var _negative = (_y < this.origY),
+        _lineHeight = Math.floor(this.parent.pxPerHour/2),
+        _top, _bottom, _diff;
+    if(_negative){
+      var _floorY = Math.floor(_y/_lineHeight)*_lineHeight,
+          _ceilYo = Math.ceil(this.origY/_lineHeight)*_lineHeight;
+      if(_floorY<0){_floorY=0;}
+      _diff = _floorY-_ceilYo;
+      if( _diff <= 0-_lineHeight ){
+        _top = _floorY;
+        _bottom = _ceilYo;
+      }
+      else if( _diff === 0 ){
+        _top = _floorY-_lineHeight;
+        _bottom = _ceilYo;
+      }
+    }
+    else {
+      var _ceilY  = Math.ceil(_y/_lineHeight)*_lineHeight,
+          _floorYo = Math.floor(this.origY/_lineHeight)*_lineHeight;
+      if(_ceilY>(_lineHeight*48)){_ceilY=_lineHeight*48;}
+      _diff = _ceilY-_floorYo;
+      if( _diff >= _lineHeight ){
+        _top = _floorYo;
+        _bottom = _ceilY;
+      }
+      else if( _diff === 0 ){
+        _top = _floorYo;
+        _bottom = _ceilY+_lineHeight;
+      }
+    }
+    this.rect.setTop(_top);
+    this.rect.setBottom(_bottom);
+  },
+  
+/** = Description
+  * Resize top by dragging auxiliary function.
+  *
+  * = Parameters
+  * +_y+:: Y coordinate at the start of drag.
+  **/
+  dragResizeTop: function(_y){
+    var _lineHeight = Math.floor(this.parent.pxPerHour/2),
+        _top = Math.floor( _y/_lineHeight )*_lineHeight;
+    if(_top < 0){ _top = 0; }
+    if(_top+_lineHeight > this.rect.bottom){
+      _top = this.rect.bottom - _lineHeight;
+    }
+    this.rect.setTop( _top );
+  },
+  
+/** = Description
+  * Resize function for resizing the bottom of item.
+  *
+  * = Parameters
+  * +_y+:: Y coordinate at the start of drag.
+  *
+  **/
+  dragResizeBottom: function(_y){
+    var _lineHeight = Math.floor(this.parent.pxPerHour/2),
+        _bottom = Math.floor( _y/_lineHeight )*_lineHeight;
+    if(_bottom > _lineHeight*48){ _bottom = _lineHeight*48; }
+    if(_bottom-_lineHeight < this.rect.top){
+      _bottom = this.rect.top + _lineHeight;
+    }
+    this.rect.setBottom( _bottom );
+  },
+  
+/** = Description
+  * Move function for item by dragging and dropping.
+  *
+  * = Parameters
+  * +_y+:: Y coordinate at the start of drag.
+  *
+  **/
+  dragMove: function(_y){
+    var _lineHeight = Math.floor(this.parent.pxPerHour/2),
+        _top = Math.floor( (0-this.moveDiff+_y)/_lineHeight )*_lineHeight;
+    if(_top<0){_top = 0;}
+    if(_top+this.rect.height>_lineHeight*48){
+      _top = _lineHeight*48 - this.rect.height;
+    }
+    this.rect.offsetTo( this.rect.left, _top );
+  },
+  
+/** = Description
+  * Drag function for item. Decides whether the user wants to create a new
+  * item, resize top, resize bottom or move an existing item.
+  *
+  * = Parameters
+  * +x+:: X coordinate at the start of drag.
+  * +y+:: Y coordinate at the start of drag.
+  *
+  **/
+  drag: function(x,y){
+    var _pageY  = this.parent.pageY(),
+        _y = y - _pageY;
+    if(this.dragMode === 'create'){
+      this.dragCreate(_y);
+    }
+    else if(this.dragMode === 'resize-top'){
+      this.dragResizeTop(_y);
+    }
+    else if(this.dragMode === 'resize-bottom'){
+      this.dragResizeBottom(_y);
+    }
+    else if(this.dragMode === 'move'){
+      this.dragMove(_y);
+    }
+    this.drawRect();
+    return true;
+  },
+  
+/** = Description
+  * Modifies the existing item's coordinates or creates a new one.
+  *
+  * = Parameters
+  * +x+:: X coordinate at the end of drag.
+  * +y+:: Y coordinate at the end of drag.
+  *
+  **/
+  endDrag: function(x,y){
+    var
+    _pxPerHour = Math.floor(this.parent.pxPerHour),
+    _value,
+    _yEquals = (Math.round(this.prevXY[1]/4) === Math.round(y/4));
+    if(_yEquals){ // nothing moved, just return.
+      return true;
+    }
+    if(this.dragMode === 'create'){
+      this.parent.listItemViews.push( this );
+      _value = {};
+      this._setValueTop( _value );
+      this._setValueBottom( _value );
+      this._setValueLabel( _value );
+      if(this.parent['editor']){
+        this.parent.editor.createItem( _value );
+      }
+    }
+    else {
+      _value = COMM.Values.clone( this.value );
+      this._setValueTop( _value );
+      this._setValueBottom( _value );
+      if(this.parent['editor']){
+        this.parent.editor.modifyItem( _value );
+      }
+    }
+    this.setValue( _value );
+    this.dragMode = 'normal';
+    return true;
+  },
+  
+  _setValueTop: function( _value ) {
+    _value['timeBegin'] = this.rect.top/this.parent.pxPerHour;
+  },
+  
+  _setValueBottom: function( _value ) {
+    _value['timeEnd'] = this.rect.bottom/this.parent.pxPerHour;
+  },
+  
+  _setValueLabel: function( _value ) {
+    _value['label'] = this.label;
+  },
+  
+  _getValueLabel: function( _value ){
+    return _value.label;
+  },
+  
+  _getValueTop: function( _value ){
+    return (_value.timeBegin * this.parent.pxPerHour)+1;
+  },
+  
+  _getValueBottom: function( _value ){
+    return (_value.timeEnd * this.parent.pxPerHour)-2;
+  },
+  
+/** = Description
+  * Refreshes the object's label and place on the HTimeSheet.
+  *
+  **/
+  refreshValue: function(){
+    if ( HVM.type(this.value) === 'h' ){
+      var
+      _label  = this._getValueLabel( this.value ),
+      _top    = this._getValueTop( this.value ),
+      _bottom = this._getValueBottom( this.value ),
+      _minHeight = this.parent.options.itemMinHeight;
+      this.setLabel( _label );
+      if( (_bottom - _top) < _minHeight ){
+        _bottom = _top + _minHeight;
+      }
+      this.rect.setTop( _top );
+      this.rect.setBottom( _bottom );
+      this.drawRect();
+    }
+  }
+});
+
+