LITBox = Class.create();
LITBox.prototype = {
   initialize: function(mes, contentDivId, contentUrl, contentHtml){
   this.mes = mes;
   this.contentDivId = contentDivId;
   this.contentUrl = contentUrl;   
   this.contentHtml = contentHtml;
   this._onReturn = this.onReturn.bind(this);
   this._onError = this.onError.bind(this);
   this.options = Object.extend({
      width: 600,
      height: 500,
      type: 'window',
      callback: null,
      draggable: false,
      resizable: false,
      overlay: true,
      opacity: 1,
      left: false,
      top: false,
      submitForm : true,
      strongRemove: false
   }, arguments[4] || {});
   this.setup();
   },
   setup: function(){
	  Event.observe(window,'resize',this.position.bindAsEventListener(this));
	  Event.observe(window,'scroll',this.position.bindAsEventListener(this));
      this.rn = ( Math.floor ( Math.random ( ) * 100000000 + 1 ) );
      try{
      	$$('.hideForLightbox').invoke('hide');
      	$$('.brcMenuItem').each(function(f){f.style.zIndex = 0;});
      }catch(e){}
      $$('select').invoke('hide');
      this.getWindow();
      switch(this.options.type){
         case 'window' : this.d4.appendChild(this.createBox(this.mes));
         	this.tempCall = this.options.callback;
            break;
         case 'alert' : this.d4.appendChild(this.createInformationBox(false));
            break;
         case 'confirm' : this.d4.appendChild(this.createInformationBox(true));
      }
      this.display();
   },
   getWindow: function(){
      this.over = null;
      if(this.options.overlay == true){
      this.d = document.createElement('div');
      document.body.appendChild(this.d);
      this.d.className = 'LB_overlay';   
      this.d.style.display = 'block';
      this.d.onclick=this.remove;
      }
      this.d2 = document.createElement('div');
      document.body.appendChild(this.d2);
      this.d2.className = 'LB_window';
      this.d2.style.height = parseInt(this.options.height) + 'px';

//      this.d3 = document.createElement('div');
//      this.d2.appendChild(this.d3);
//      this.d3.className='LB_closeAjaxWindow';
//      this.d3.d2 = this.d2;
//      this.d3.over = this.over;
//      this.d3.options = this.options;
      
      // AS: Removed draggable and droppable
      /*
      this.d3.onmouseover=this.getDraggable;
      this.d3.onmouseout=this.dropDraggable;
      */
      this.close = document.createElement('a');
      
      // AS: Removed close button
      
     // this.d3.appendChild(Builder.node("text", this.mes));
      /*this.d3.appendChild(this.close);
      this.close.d = this.d;
      this.close.d2 = this.d2;
      this.close.onclick=this.remove;
      this.close.href='#';
      this.close.innerHTML='Close';
      */
      this.d4 = document.createElement('div');
      this.d4.className='LB_content';
      this.d4.style.height = parseInt(this.options.height) - 30 + 'px';
      this.d4.style.width = parseInt(this.options.width) + 'px';
      this.d2.appendChild(this.d4);
      this.clear = document.createElement('div');
      this.d2.appendChild(this.clear);
      this.clear.style.clear='both';
      if(this.options.resizable){
      this.d5 = document.createElement('div');
      this.d2.appendChild(this.d5);
      this.d5.className='LB_resize';
      this.d5.d2 = this.d2;
      this.d5.d2.d4 = this.d4;
      this.d5.over = this.over;
      this.d5.options = this.options;
      this.d5.onmouseover=this.getResizer;
      this.d5.onmouseout=this.dropResizer;
      }
      if(this.options.overlay == true){
      this.d.d = this.d;
      this.d.d2 = this.d2;
      }
   },
   getDraggable: function(){
      if(this.options.draggable){
      if(this.resize)this.resize.destroy();
      if(!this.drag || (this.drag && !this.drag.dragging))
      this.drag = new Draggable(this.d2,{});
      }
   },
   getResizer: function(){
      if(this.options.resizable){
      if(this.drag)this.drag.destroy();
      if(!this.resize || (this.resize && !this.resize.dragging))
      this.resize = new Resizer(this.d2,{});
      }
   },
   dropDraggable: function(){
      if(this.options.draggable){
      if(!this.drag.dragging && this.drag){
      this.drag.destroy();
      }}
   },
   dropResizer: function(){
      if(this.options.resizable){
      if(!this.resize.dragging && this.resize){
      this.resize.destroy();
      }}
   },
   display: function(){
      Element.setOpacity(this.d2, 0);
      this.position();
      new Effect.Opacity(this.d2, {from:0,to:this.options.opacity,duration:.5});
   },
   position: function(event){
		var de = document.documentElement;
   		var w = self.innerWidth || (de&&de.clientWidth) || document.body.clientWidth;
   		var h = self.innerHeight || (de&&de.clientHeight) || document.body.clientHeight;
   		//console.debug("position::w:[" + w + "] and h:[" + h + "].");
   		      
		if (window.innerHeight && window.scrollMaxY) {	
			yScroll = window.innerHeight + window.scrollMaxY;
		} else if (document.body.scrollHeight > document.body.offsetHeight){ // all but Explorer Mac
			yScroll = document.body.scrollHeight;
		} else { // Explorer Mac...would also work in Explorer 6 Strict, Mozilla and Safari
			yScroll = document.body.offsetHeight;
		}
		//console.debug("position::yScroll:[" + yScroll + "].");
		
		var xScroll = this.getScrollXY()[0];
		//console.debug("position::xScroll:[" + xScroll + "].");		
		
		this.d2.style.width = this.options.width + 'px';
		this.d2.style.display = 'block';
		if(!this.options.left || this.options.left < 0){
			this.d2.style.left = ((w - this.options.width)/2)+ xScroll + "px";
		}else{
			this.d2.style.left=parseInt(this.options.left)+ xScroll+'px';
		}
		//console.debug("position::this.d2.style.left:[" + this.d2.style.left + "].");
   	
		var pagesize = this.getPageSize();
		var arrayPageScroll = this.getPageScrollTop();
		if(this.d2.offsetHeight > h - 100){
			if(!this.options.top || this.options.top < 0){
   				this.d2.style.top = "45px";
         	}else{
         		this.d2.style.top=parseInt(this.options.top)+'px';
         	}
   			//this.d2.style.height=h-100 + 'px';
   			//this.d4.style.height=h-145 + 'px';
   			this.d4.style.overflow ='auto';
   		} else {   
        	if(!this.options.top || this.options.top < 0){
   				this.d2.style.top = (arrayPageScroll[1] + ((pagesize[1]-this.d2.offsetHeight)/2))+"px";
         	}else{
         		this.d2.style.top=parseInt(this.options.top)+'px';
         	}
   		}
   		//console.debug("position::this.d2.style.top:[" +this.d2.style.top + "].");
   		   	
   		if(this.d){this.d.style.height =   yScroll +"px"; this.d.style.width= w + xScroll + "px";}
	},
   remove: function(){
   		//console.debug('Calling remove!');
	      if(this.temp) this.temp();
		  try{
		      $$('select').invoke('show');
              $$('.hideForLightbox').invoke('show');
              $$('.brcMenuItem').each(function(f){f.style.zIndex = 10;});		      
		  }catch(e){
		  	//console.debug(e);
		  }
		  
		  // destroy the lightbox and ignore if it doesnt exist
		  try{
		  	if(this.options && this.options.strongRemove) {
		  		//console.debug('calling armageddon!');
		  		lightBox.armageddon ();
		  	}else {
		  		//console.debug('calling destroy!');
	   	  		lightBox.destroy();
		  	}
	   	  }catch(e){
	   	  		//console.debug(e);
	   	  }
	   	  //console.debug('done remove!');
	      return false;
   },
   parseQuery: function(query){
      var Params = new Object ();
      if ( ! query ) return Params; // return empty object
      var Pairs = query.split(/[;&]/);
      for ( var i = 0; i < Pairs.length; i++ ) {
         var KeyVal = Pairs[i].split('=');
         if ( ! KeyVal || KeyVal.length != 2 ) continue;
         var key = unescape( KeyVal[0] );
         var val = unescape( KeyVal[1] );
         val = val.replace(/\+/g, ' ');
         Params[key] = val;
      }
      return Params;
   },
   getPageScrollTop: function(){
      var yScrolltop;
      if (self.pageYOffset) {
         yScrolltop = self.pageYOffset;
      } else if (document.documentElement && document.documentElement.scrollTop){    // Explorer 6 Strict
         yScrolltop = document.documentElement.scrollTop;
      } else if (document.body) {// all other Explorers
         yScrolltop = document.body.scrollTop;
      }
      arrayPageScroll = new Array('',yScrolltop) 
      return arrayPageScroll;
   },
   getPageSize: function(){
      var de = document.documentElement;
      var w = self.innerWidth || (de&&de.clientWidth) || document.body.clientWidth;
      var h = self.innerHeight || (de&&de.clientHeight) || document.body.clientHeight;
      
      arrayPageSize = new Array(w,h) 
      return arrayPageSize;
   },
   createInformationBox: function(isConfirmation){
//   		alert('calling createInformationBox with isConfirmation:' + isConfirmation);
   		var title = 'Alert:';
   		var firstButton = 'Ok';
   		if(isConfirmation) {
   			title = 'Confirmation:';
   			var firstButton = 'Yes';
   		}
//   		alert('title:' + title + ", firstButton:" + firstButton);
       	var root = Builder.node("div");
		var table = Builder.node('table', {
		  width: '100%',cellpadding: '0',cellspacing: '0'
		});
		var tbody = Builder.node('tbody'),
    			tr = Builder.node('tr'),
    			td = Builder.node('td',{id:'mainBody'});
    	var titleTable = Builder.node('table', {
		  width: '100%'});
		var titleTbody = Builder.node('tbody'),
    		   titleTr = Builder.node('tr',{className:'title'}),
    		   titleTd = Builder.node('td',[title]);
		titleTr.appendChild(titleTd);
		titleTbody.appendChild(titleTr);
		titleTable.appendChild(titleTbody);	
		
		var contentTable = Builder.node("table", {
		  width: '100%',align:'center'});
		var contentTbody = Builder.node('tbody'),
    		   contentTr = Builder.node('tr'),
    		   contentTd=Builder.node('td');
		contentTr.appendChild(contentTd);
		contentTbody.appendChild(contentTr);
		contentTable.appendChild(contentTbody);
			    		   		    		  
    	var paragraphTable = Builder.node("table", {
		  width: '100%',className:'searchTable'});
		var paragraphTbody = Builder.node('tbody');
    	var firstTr = Builder.node('tr');	  
    	var firstTd = Builder.node('td',{colspan:3},[this.mes]);		   
    	var secondTr = Builder.node('tr',{align:'right'});
    	var secondTd = Builder.node('td');    		   
    	// Adding message  
		firstTr.appendChild(firstTd);
		    		      		   	   
    	// Adding buttons    	
        this.button_y = $(Builder.node('input', {
        	type:'button', className:'default_button', value:firstButton}));
        secondTd.appendChild(this.button_y);
        this.button_y.d= this.d; 
        this.button_y.d2 = this.d2;
        this.button_y.temp = this.options.callback;
        this.button_y.onclick=this.remove;
        
        if(isConfirmation) {
	        this.button_n = $(Builder.node('input', {
	        	type:'button', className:'default_button', value:'No'}));
	        secondTd.appendChild(this.button_n);
	        this.button_n.d= this.d; 
	        this.button_n.d2 = this.d2;
	        this.button_n.onclick=this.remove.bind(this);
        }        
         		   
		secondTr.appendChild(secondTd);
		paragraphTbody.appendChild(firstTr);
		paragraphTbody.appendChild(Builder.node('tr',{align:'right'},[Builder.node('td',['.'])]));
		paragraphTbody.appendChild(secondTr);
		paragraphTable.appendChild(paragraphTbody);
		contentTd.appendChild(paragraphTable);
			     		       		   				
	    td.appendChild(titleTable);
	    td.appendChild(contentTable);
	    tr.appendChild(td);
		tbody.appendChild(tr);		
		table.appendChild(tbody);
		root.appendChild(table);	
   		return root;
   },
   createBox: function(){
   
       var root = Builder.node("div"); 
       if(this.contentUrl) {		
			var options = {
	        	method:"get",
	        	asynchronous: false,
	            onSuccess: function(response) {
		          try {
		           	response.responseText.evalScripts();
		          } catch(e) {}
	               root.innerHTML = response.responseText;
	            },
	            onFailure:function(response){
	               root.innerHTML = response.responseText;
				}
	      	};
	      	if(this.contentUrl.include('?')) {
				new Ajax.Request(this.contentUrl + '&' + Date(), options);	
			} else {
				new Ajax.Request(this.contentUrl + '?' + Date() , options);	
			}					
        } else if(this.contentHtml) {
		  var content = $(this.contentDivId);  
		  try {
	          this.contentHtml.evalScripts();
	      } catch(e) {
	      }      
          root.innerHTML = this.contentHtml;
        } else  {
		  var content = $(this.contentDivId);
		  alert(this.contentDivId);
      	  root.innerHTML = content.innerHTML;        
        }		
		      	
      	var forms = $(root).select('form');
      	forms.invoke('observe', 'submit', this.submitCall.bindAsEventListener(this));
		/*for(var i = 0; i < forms.length; i++) {
		Event.observe(forms[i], 'submit', this.submitCall.bindAsEventListener(this));
			var buttons = forms[i].select('input[type="button"]');
			for(var j = 0; j < buttons.length; j++) {
				Event.observe(buttons[j], 'click', this.submitCall.bindAsEventListener(this));
			}
		}*/

   		return root;
   },
   submitCall: function(event) {
		doOverlay(this.d, 0.5);   
   		Event.stop(event);   		
   		var element = Event.element(event);
		var options = {
        	method:"post",
        	parameters: element.serialize(true),
        	onSuccess: this._onReturn,
        	onFailure: this._onError
      	};
        // Send the AJAX request to the action specified for the form  
        if(this.options.submitForm)
			new Ajax.Request(element.action, options);
   		
   },
   onReturn: function(transport) {        
   		this.tempCall(transport.responseText);
   		hideOverlay();
   		this.destroy();
   },
   onError: function (transport) {
   		hideOverlay();
		alert("There was an error performing your action.");
		this.remove();
   },
   
    destroy: function() {
    	//console.debug('calling destroy!');
	    hideOverlay()
    	try {
   		new Effect.Opacity(this.d2, {from:1,to:0,duration:.5});
   		if(this.d){
   			new Effect.Opacity(this.d, {from:.6,to:0,duration:.5});
   			Element.remove(this.d);
   		}
     	Element.remove(this.d2);
    	}catch(e){
    		//console.debug(e);
    	}
      	return false;
   },
   
   armageddon: function() {
   		//console.debug('calling armageddon!');
   		new Effect.Opacity(this.d2, {from:1,to:0,duration:.5});
   		if(this.d){
   			new Effect.Opacity(this.d, {from:.6,to:0,duration:.5});
			try{
				$$('.' + this.d.className).each(function(lbo) {
					try{
						lbo.remove();
					}catch(ee) {
						//alert('got error when do each lbo.remove');
					}
				});
			}catch(e){
				//alert('got error when do lbo each');
			}
   		}
		try{
			$$('.' + this.d2.className).each(function(lbw) {
				try{
					lbw.remove();
				}catch(ee) {
					//alert('got error when do each lbw.remove');
				}
			});
		}catch(e1){
			//alert('got error when do lbw each');
		}

      	return false;
   },
	getScrollXY: function() {
		var scrOfX = 0, scrOfY = 0;
		if (typeof (window.pageYOffset) == "number") {
	    	//Netscape compliant
			scrOfY = window.pageYOffset;
			scrOfX = window.pageXOffset;
		} else {
			if (document.body && (document.body.scrollLeft || document.body.scrollTop)) {
	    		//DOM compliant
				scrOfY = document.body.scrollTop;
				scrOfX = document.body.scrollLeft;
			} else {
				if (document.documentElement && (document.documentElement.scrollLeft || document.documentElement.scrollTop)) {
	    			//IE6 standards compliant mode
					scrOfY = document.documentElement.scrollTop;
					scrOfX = document.documentElement.scrollLeft;
				}
			}
		}
		return [scrOfX, scrOfY];
	}   
}


var Resizers = {
  drags: [],
  observers: [],
  
  register: function(draggable) {
    if(this.drags.length == 0) {
      this.eventMouseUp   = this.endDrag.bindAsEventListener(this);
      this.eventMouseMove = this.updateDrag.bindAsEventListener(this);
      this.eventKeypress  = this.keyPress.bindAsEventListener(this);
      
      Event.observe(document, "mouseup", this.eventMouseUp);
      Event.observe(document, "mousemove", this.eventMouseMove);
      Event.observe(document, "keypress", this.eventKeypress);
    this.drags.push(draggable);

    }
  },
  
  unregister: function(draggable) {
    this.drags = this.drags.reject(function(d) { return d==draggable });
    if(this.drags.length == 1){this.drags.pop();}
    if(this.drags.length == 0) {
      Event.stopObserving(document, "mouseup", this.eventMouseUp);
      Event.stopObserving(document, "mousemove", this.eventMouseMove);
      Event.stopObserving(document, "keypress", this.eventKeypress);
    }
  },
  
  activate: function(draggable) {
    window.focus(); // allows keypress events if window isn't currently focused, fails for Safari
    this.activeDraggable = draggable;
  },
  
  deactivate: function() {
    this.activeDraggable = null;
  },
  
  updateDrag: function(event) {
    if(!this.activeDraggable) return;
    var pointer = [Event.pointerX(event), Event.pointerY(event)];
    // Mozilla-based browsers fire successive mousemove events with
    // the same coordinates, prevent needless redrawing (moz bug?)
    if(this._lastPointer && (this._lastPointer.inspect() == pointer.inspect())) return;
    this._lastPointer = pointer;
    this.activeDraggable.updateDrag(event, pointer);
  },
  
  endDrag: function(event) {
    if(!this.activeDraggable) return;
    this._lastPointer = null;
    this.activeDraggable.endDrag(event);
    this.activeDraggable = null;
  },
  
  keyPress: function(event) {
    if(this.activeDraggable)
      this.activeDraggable.keyPress(event);
  },
  
  addObserver: function(observer) {
    this.observers.push(observer);
    this._cacheObserverCallbacks();
  },
  
  removeObserver: function(element) {  // element instead of observer fixes mem leaks
    this.observers = this.observers.reject( function(o) { return o.element==element });
    this._cacheObserverCallbacks();
  },
  
  notify: function(eventName, draggable, event) {  // 'onStart', 'onEnd', 'onDrag'
    if(this[eventName+'Count'] > 0)
      this.observers.each( function(o) {
        if(o[eventName]) o[eventName](eventName, draggable, event);
      });
  },
  
  _cacheObserverCallbacks: function() {
    ['onStart','onEnd','onDrag'].each( function(eventName) {
      Resizers[eventName+'Count'] = Resizers.observers.select(
        function(o) { return o[eventName]; }
      ).length;
    });
  }
}


var Resizer = Class.create();
Resizer.prototype = {
  initialize: function(element) {
  	this.offset = Array();
    var options = Object.extend({
      handle: false,
      
      reverteffect: function(element, top_offset, left_offset) {
        var dur = Math.sqrt(Math.abs(top_offset^2)+Math.abs(left_offset^2))*0.02;
        element._revert = new Effect.Move(element, { x: -left_offset, y: -top_offset, duration: dur});
      },
      
      zindex: 1000,
      revert: false,
      scroll: false,
      scrollSensitivity: 20,
      scrollSpeed: 15,
      snap: false   // false, or xy or [x,y] or function(x,y){ return [x,y] }
    }, arguments[1] || {});
    this.element = $(element);
    
    if(options.handle && (typeof options.handle == 'string')) {
      var h = Element.childrenWithClassName(this.element, options.handle, true);
      if(h.length>0) this.handle = h[0];
    }
    if(!this.handle) this.handle = $(options.handle);
    if(!this.handle) this.handle = this.element;
    
    if(options.scroll && !options.scroll.scrollTo && !options.scroll.outerHTML)
      options.scroll = $(options.scroll);

    Element.makePositioned(this.element); // fix IE    

    this.delta    = this.currentDelta();
    this.options  = options;
    this.dragging = false;   

    this.oHeight = parseInt(this.element.style.height);
    this.oWidth = parseInt(this.element.style.width);

    this.eventMouseDown = this.initDrag.bindAsEventListener(this);
    Event.observe(this.handle, "mousedown", this.eventMouseDown);
    
    Resizers.register(this);
  },
  
  destroy: function() {
    Event.stopObserving(this.handle, "mousedown", this.eventMouseDown);
    Resizers.unregister(this);
  },
  
  currentDelta: function() {
    return([
      parseInt(Element.getStyle(this.element,'width') || '0'),
      parseInt(Element.getStyle(this.element,'height') || '0')]);
  },
  
  initDrag: function(event) {
    if(Event.isLeftClick(event)) {    
      // abort on form elements, fixes a Firefox issue
      var src = Event.element(event);
      if(src.tagName && (
        src.tagName=='INPUT' ||
        src.tagName=='SELECT' ||
        src.tagName=='OPTION' ||
        src.tagName=='BUTTON' ||
        src.tagName=='TEXTAREA')) return;
        
      if(this.element._revert) {
        this.element._revert.cancel();
        this.element._revert = null;
      }
      
      var pointer = [Event.pointerX(event), Event.pointerY(event)];
      var pos     = Position.cumulativeOffset(this.element);

      this.offset[0] = pointer[0];
      this.offset[1] = pointer[1];
      Resizers.activate(this);
      Event.stop(event);
    }
  },
  
  startDrag: function(event) {
    this.dragging = true;
    
    if(this.options.zindex) {
      this.originalZ = parseInt(Element.getStyle(this.element,'z-index') || 0);
      this.element.style.zIndex = this.options.zindex;
    }
    
    if(this.options.ghosting) {
      this._clone = this.element.cloneNode(true);
      Position.absolutize(this.element);
      this.element.parentNode.insertBefore(this._clone, this.element);
    }
    
    
    Resizers.notify('onStart', this, event);
    if(this.options.starteffect) this.options.starteffect(this.element);
  },
  
  updateDrag: function(event, pointer) {
    if(!this.dragging) this.startDrag(event);
    Position.prepare();
    Resizers.notify('onDrag', this, event);
    this.draw(pointer);
    if(this.options.change) this.options.change(this);
    
    if(this.options.scroll) {
      this.stopScrolling();
      
      var p;
      if (this.options.scroll == window) {
        with(this._getWindowScroll(this.options.scroll)) { p = [ left, top, left+width, top+height ]; }
      } else {
        p = Position.page(this.options.scroll);
        p[0] += this.options.scroll.scrollLeft;
        p[1] += this.options.scroll.scrollTop;
        p.push(p[0]+this.options.scroll.offsetWidth);
        p.push(p[1]+this.options.scroll.offsetHeight);
      }
      var speed = [0,0];
      if(pointer[0] < (p[0]+this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[0]+this.options.scrollSensitivity);
      if(pointer[1] < (p[1]+this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[1]+this.options.scrollSensitivity);
      if(pointer[0] > (p[2]-this.options.scrollSensitivity)) speed[0] = pointer[0]-(p[2]-this.options.scrollSensitivity);
      if(pointer[1] > (p[3]-this.options.scrollSensitivity)) speed[1] = pointer[1]-(p[3]-this.options.scrollSensitivity);
      this.startScrolling(speed);
    }
    
    // fix AppleWebKit rendering
    if(navigator.appVersion.indexOf('AppleWebKit')>0) window.scrollBy(0,0);
    Event.stop(event);
  },
  
  finishDrag: function(event, success) {
    this.dragging = false;

    if(this.options.ghosting) {
      Position.relativize(this.element);
      Element.remove(this._clone);
      this._clone = null;
    }

    Resizers.notify('onEnd', this, event);

    var revert = this.options.revert;
    if(revert && typeof revert == 'function') revert = revert(this.element);
    
    var d = this.currentDelta();
    if(revert && this.options.reverteffect) {
      this.options.reverteffect(this.element, 
        d[1]-this.delta[1], d[0]-this.delta[0]);
    } else {
      this.delta = d;
    }

    //if(this.options.zindex)
      this.element.style.zIndex = this.originalZ;

    if(this.options.endeffect) 
      this.options.endeffect(this.element);

    Resizers.deactivate(this);
    //Resizers.reset();
  },
  
  keyPress: function(event) {
    if(event.keyCode!=Event.KEY_ESC) return;
    this.finishDrag(event, false);
    Event.stop(event);
  },
  
  endDrag: function(event) {
    if(!this.dragging) return;
    this.stopScrolling();
    this.finishDrag(event, true);
    Event.stop(event);
    this.oWidth = parseInt(this.element.style.width);
    this.oHeight = parseInt(this.element.style.height);
  },
  
  draw: function(point) {
    var pos = Position.cumulativeOffset(this.element);
    var d = this.currentDelta();
    pos[0] -= d[0]; pos[1] -= d[1];
    var p = new Array();
  
    p[0] = this.oWidth + point[0] - this.offset[0];
    p[1] = this.oHeight + point[1] - this.offset[1];
    
    var style = this.element.style;
    if((!this.options.constraint) || (this.options.constraint=='horizontal')){
      style.width = p[0] + "px"; this.element.d4.style.width = p[0] + 'px';}
    if((!this.options.constraint) || (this.options.constraint=='vertical')){
      style.height  = p[1] + "px"; this.element.d4.style.height = p[1]-30 + 'px';}
    if(style.visibility=="hidden") style.visibility = ""; // fix gecko rendering

  },
  
  stopScrolling: function() {
    if(this.scrollInterval) {
      clearInterval(this.scrollInterval);
      this.scrollInterval = null;
      Resizers._lastScrollPointer = null;
    }
  },
  
  startScrolling: function(speed) {
    this.scrollSpeed = [speed[0]*this.options.scrollSpeed,speed[1]*this.options.scrollSpeed];
    this.lastScrolled = new Date();
    this.scrollInterval = setInterval(this.scroll.bind(this), 10);
  },
  
  scroll: function() {
    var current = new Date();
    var delta = current - this.lastScrolled;
    this.lastScrolled = current;
    if(this.options.scroll == window) {
      with (this._getWindowScroll(this.options.scroll)) {
        if (this.scrollSpeed[0] || this.scrollSpeed[1]) {
          var d = delta / 1000;
          this.options.scroll.scrollTo( left + d*this.scrollSpeed[0], top + d*this.scrollSpeed[1] );
        }
      }
    } else {
      this.options.scroll.scrollLeft += this.scrollSpeed[0] * delta / 1000;
      this.options.scroll.scrollTop  += this.scrollSpeed[1] * delta / 1000;
    }
    
    Position.prepare();
    Resizers.notify('onDrag', this);
    Resizers._lastScrollPointer = Resizers._lastScrollPointer || $A(Resizers._lastPointer);
    Resizers._lastScrollPointer[0] += this.scrollSpeed[0] * delta / 1000;
    Resizers._lastScrollPointer[1] += this.scrollSpeed[1] * delta / 1000;
    if (Resizers._lastScrollPointer[0] < 0)
      Resizers._lastScrollPointer[0] = 0;
    if (Resizers._lastScrollPointer[1] < 0)
      Resizers._lastScrollPointer[1] = 0;
    this.draw(Resizers._lastScrollPointer);
    
    if(this.options.change) this.options.change(this);
  },
  
  _getWindowScroll: function(w) {
    var T, L, W, H;
    with (w.document) {
      if (w.document.documentElement && documentElement.scrollTop) {
        T = documentElement.scrollTop;
        L = documentElement.scrollLeft;
      } else if (w.document.body) {
        T = body.scrollTop;
        L = body.scrollLeft;
      }
      if (w.innerWidth) {
        W = w.innerWidth;
        H = w.innerHeight;
      } else if (w.document.documentElement && documentElement.clientWidth) {
        W = documentElement.clientWidth;
        H = documentElement.clientHeight;
      } else {
        W = body.offsetWidth;
        H = body.offsetHeight
      }
    }
    return { top: T, left: L, width: W, height: H };
  }
}