DualSlider  = function(element, realValueMinField, realValueMaxField, minValueField, maxValueField, appending, min, max, steps, autoPostBackelement) {
    this.autoPostBackElement = autoPostBackelement;
    this.Appending = appending;
    this.elNode = element;
    
    this.MinValueFieldElement = minValueField;
    this.MaxValueFieldElement = maxValueField;
    this.RealValueMinFieldElement = realValueMinField;
    this.RealValueMaxFieldElement = realValueMaxField;
    
    this.MaxSize = 270;
    this.MinValue = Math.round(this.MinValueFieldElement.value);
    this.MaxValue = Math.round(this.MaxValueFieldElement.value);
    this.Steps = steps; //<%#Steps%>;
    this.Min =  min; //<%#MinValue%>;
    this.Max = max; //<%#MaxValue%>;
    if(this.Steps > 0)
    {
        this.UseSteping = true;
    }else
    {
        this.UserSteping = false;
    }
    

    this.CoverLeft = new Object();
    this.CoverLeft.elNode = document.createElement("div");
    this.CoverLeft.elNode.className = 'CoverLeft';
    this.CoverLeft.elNode.style.width = this.MinValue + "px";
    this.CoverLeft.elNode.style.left = "9px";
    this.elNode.appendChild(this.CoverLeft.elNode);

    this.CoverRight = new Object();
    this.CoverRight.elNode = document.createElement("div");
    this.CoverRight.elNode.className = 'CoverRight';
    
    if((this.MaxSize - 7 - this.MaxValue) < 0)
    {
        this.CoverRight.elNode.style.width = "0px";
    }
    else
    {
        this.CoverRight.elNode.style.width = (this.MaxSize - 7 - this.MaxValue) + "px";
    }
    
    this.CoverRight.elNode.style.left = (this.MaxValue+13) +"px";
    this.elNode.appendChild(this.CoverRight.elNode);

    this.MinHandle = new Object();
    this.MinHandle.elNode = document.createElement('Div');
    this.MinHandle.elNode.className = 'MinHandle';
    this.MinHandle.elNode.style.left = this.MinValue + "px";
    this.elNode.appendChild(this.MinHandle.elNode);

    this.MaxHandle = new Object();
    this.MaxHandle.elNode = document.createElement('Div');
    this.MaxHandle.elNode.className = 'MaxHandle';
    this.MaxHandle.elNode.style.left =  this.MaxValue + "px";
    this.elNode.appendChild(this.MaxHandle.elNode);
    
    this.RealValueMinLabel = document.createElement('Div');
    this.elNode.appendChild(this.RealValueMinLabel);
    this.RealValueMinLabel.className = this.RealValueMinFieldElement.className;
    
    this.RealValueMaxLabel = document.createElement('Div');
    this.elNode.appendChild(this.RealValueMaxLabel);
    this.RealValueMaxLabel.className = this.RealValueMaxFieldElement.className;
    
    this.RealValueMaxFieldElement.style.display = 'none';
    this.RealValueMinFieldElement.style.display = 'none';

    
    this.Initialize();
    
    var RealMinValue = Math.round(this.Min + ((this.MinValue/this.MaxSize)*(this.Max - this.Min)));
    var RealMaxValue = Math.round(this.Min + ((this.MaxValue/this.MaxSize)*(this.Max - this.Min)));
    
    this.RealValueMinFieldElement.value = roundMinMax(RealMinValue, "");
    if ( this.Max != RealMaxValue) {
        this.RealValueMaxFieldElement.value = roundMinMax(RealMaxValue, "");
        var larger = "";
    } else {
        var larger = ">";
    }
    
    if (this.Appending != "rum") {
        this.RealValueMaxLabel.innerHTML = larger + roundMinMax(RealMaxValue, this.Appending) + " "+this.Appending;
    } else {
        this.RealValueMaxLabel.innerHTML = larger + roundMinMax(RealMaxValue - 1, this.Appending) + " "+this.Appending;
    }
    this.RealValueMinLabel.innerHTML = roundMinMax(RealMinValue, this.Appending) + " "+this.Appending;
    
}
function roundMinMax(minMax, appending){
    if (appending == "kr") {
        if (minMax >= 100000) {
            price = Math.round(minMax/250000)*250000;
            return formatNumber(price);
        } else {
            price = Math.round(minMax/100)*100;
            return formatNumber(price);
        }
    } else if (appending == "rum") {
        return minMax;
    } else {
        if (minMax >= 100000) {
            return Math.round(minMax/250000)*250000;
        } else {
            return minMax;
        }
    }
}
function formatNumber(obj) {
	   anynum=eval(obj);

	   workNum= anynum;

	   workStr=""+workNum

	   if (workStr.indexOf(".")==-1){workStr+="."}

	   dStr=workStr.substr(0,workStr.indexOf("."));dNum=dStr-0
	   pStr=workStr.substr(workStr.indexOf("."))

	   //while (pStr.length-1< decimal){pStr+="0"}

	   if(pStr =='.') pStr ='';

	   //--- Adds a comma in the thousands place.    
	   if (dNum>=1000) {
		  dLen=dStr.length
		  dStr=parseInt(""+(dNum/1000))+" "+dStr.substring(dLen-3,dLen)
	   }

	   //-- Adds a comma in the millions place.
	   if (dNum>=1000000) {
		  dLen=dStr.length
		  dStr=parseInt(""+(dNum/1000000))+" "+dStr.substring(dLen-7,dLen)
	   }
	   retval = dStr + pStr
	   //-- Put numbers in parentheses if negative.
	  if (anynum<0) {retval="("+retval+")";}

	  
    //You could include a dollar sign in the return value.
    //retval =  "$"+retval
  
    return retval;
}
 
DualSlider.prototype = {

    Initialize: function()
    {
        var slider = this;
        
        this.dragMinHandler = function() {
            slider.dragMinHandle.apply(slider, arguments);
        };
        
        this.dragMaxHandler = function() {
            slider.dragMaxHandle.apply(slider, arguments);
        };        
        
        this.dragMinGoHandler = function() {
            slider.dragMinGo.apply(slider, arguments);
        };
        
        this.dragMaxGoHandler = function() {
            slider.dragMaxGo.apply(slider, arguments);
        };
        
        this.dragStopHandler = function() {
            slider.dragStop.apply(slider, arguments);
        };
        
        if(document.attachEvent)
        {
            this.MinHandle.elNode.attachEvent("onmousedown", this.dragMinHandler);
            this.MaxHandle.elNode.attachEvent("onmousedown", this.dragMaxHandler);
        }
        if(document.addEventListener)
        {
            this.MinHandle.elNode.addEventListener("mousedown", this.dragMinHandler, true);
            this.MaxHandle.elNode.addEventListener("mousedown", this.dragMaxHandler, true);
        }
    }, 
    
    dragMinHandle: function(event)
    {
      if (window.event) {
        this.MinValue = window.event.clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
      } else {
        this.MinValue = event.clientX + window.scrollX;
      }
      
      this.MinHandle.cursorStartX = this.MinValue;
      this.MinHandle.elStartLeft  = parseInt(this.MinHandle.elNode.style.left, 10);

      if (isNaN(this.MinHandle.elStartLeft)) this.MinHandle.elStartLeft = 0;
      
      //this.MinHandle.elNode.style.zIndex = ++this.MinHandle.zIndex;
      
      // Capture mousemove and mouseup events on the page.

      if (document.attachEvent) {
        document.attachEvent("onmousemove", this.dragMinGoHandler);
        document.attachEvent("onmouseup",   this.dragStopHandler);
        window.event.cancelBubble = true;
        window.event.returnValue = false;
      }
      if (document.addEventListener) {
        document.addEventListener("mousemove", this.dragMinGoHandler,   true);
        document.addEventListener("mouseup",   this.dragStopHandler, true);
        event.preventDefault();
      }
    },

    dragMinGo: function(event) {
      // Get cursor position with respect to the page.
      var MinMoved;
      if (window.event) 
      {
        MinMoved = window.event.clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
      } else {
        MinMoved =  event.clientX + window.scrollX;
      }

      // Move drag element by the same amount the cursor has moved.
      if(this.MinHandle.elStartLeft + MinMoved - this.MinHandle.cursorStartX > (this.MaxValue - 18))
      {
        this.MinValue = (this.MaxValue - 18);
      }
      else if(this.MinHandle.elStartLeft + MinMoved - this.MinHandle.cursorStartX < 0)
      {
        this.MinValue = 0;
      }
      else
      {
         this.MinValue = (this.MinHandle.elStartLeft + MinMoved - this.MinHandle.cursorStartX);
      }
      
      if(this.UseSteping)
      {
        var RealMinValue = Math.round((this.MinValue/this.MaxSize)*(this.Steps));
        this.MinValue = Math.round(RealMinValue * (this.MaxSize/this.Steps));
      }
      
      this.MinHandle.elNode.style.left = this.MinValue +"px";
      
      
      this.CoverLeft.elNode.style.width = this.MinHandle.elNode.style.left;
      
      // 1
      this.RealValueMinLabel.innerHTML = roundMinMax(Math.round(this.Min + ((this.MinValue/this.MaxSize)*(this.Max - this.Min))), this.Appending) + " "+this.Appending;

      if (window.event) {
        window.event.cancelBubble = true;
        window.event.returnValue = false;
     } else {
        event.preventDefault();
      }
    },

    dragMaxHandle: function(event)
    {
        
      if (window.event) {
        this.MaxValue = window.event.clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
      }else {
        this.MaxValue = event.clientX + window.scrollX;
      }
      
      
      this.MaxHandle.cursorStartX = this.MaxValue;
      this.MaxHandle.elStartLeft  = parseInt(this.MaxHandle.elNode.style.left, 10);

      if (isNaN(this.MaxHandle.elStartLeft)) this.MaxHandle.elStartLeft = 0;
      
      //this.MaxHandle.elNode.style.zIndex = ++this.MaxHandle.zIndex;
      
      // Capture mousemove and mouseup events on the page.

      if(document.attachEvent)
      {
        document.attachEvent("onmousemove", this.dragMaxGoHandler);
        document.attachEvent("onmouseup",   this.dragStopHandler);
        window.event.cancelBubble = true;
        window.event.returnValue = false;
      }
      if(document.addEventListener)
      {
        document.addEventListener("mousemove", this.dragMaxGoHandler,   true);
        document.addEventListener("mouseup",   this.dragStopHandler, true);
        event.preventDefault();
      }
      
    },

    dragMaxGo: function(event) {
      // Get cursor position with respect to the page.
      var MaxMoved;

      if (window.event) {
        MaxMoved = window.event.clientX + document.documentElement.scrollLeft + document.body.scrollLeft;
      } else {
        MaxMoved =  event.clientX + window.scrollX;
      }


      // Move drag element by the same amount the cursor has moved.
      if(this.MaxHandle.elStartLeft + MaxMoved - this.MaxHandle.cursorStartX > (this.MaxSize))
      {
          this.MaxValue = this.MaxSize;
      }
      else if(this.MaxHandle.elStartLeft + MaxMoved - this.MaxHandle.cursorStartX < (this.MinValue + 18))
      {
         this.MaxValue = this.MinValue + 18;
      }
      else
      {
         this.MaxValue = this.MaxHandle.elStartLeft + MaxMoved - this.MaxHandle.cursorStartX;
      }
      
      if(this.UseSteping)
      {
        var RealMaxValue = Math.round((this.MaxValue/this.MaxSize)*(this.Steps));
        this.MaxValue = Math.round(RealMaxValue * (this.MaxSize/this.Steps));
      }
      
      this.MaxHandle.elNode.style.left = this.MaxValue + "px";
      
      //MinHandle.elNode.style.left = (MinHandle.elStartLeft + x - MinHandle.cursorStartX) + "px";
      if(this.MaxValue < this.MaxSize)
      {
        this.CoverRight.elNode.style.width = (this.MaxSize - 7 - this.MaxValue) + "px";
        this.CoverRight.elNode.style.left = (this.MaxValue+13) +"px";
      }else
      {
        this.CoverRight.elNode.style.width = 0;
      }

      if (this.Max  != RealMaxValue) {
           this.RealValueMaxFieldElement.value = roundMinMax(RealMaxValue, "");
           var larger = "";
      } else {
          this.RealValueMaxFieldElement.value = 0;
          var larger = ">";
      }
      if (this.Appending != "rum") {
          this.RealValueMaxLabel.innerHTML = larger + roundMinMax(Math.round(this.Min + ((this.MaxValue/this.MaxSize)*(this.Max - this.Min))), this.Appending) + " "+this.Appending;
      } else {
          this.RealValueMaxLabel.innerHTML = larger + roundMinMax(RealMaxValue, this.Appending) + " "+this.Appending;
      }

      if (window.event) {
        window.event.cancelBubble = true;
        window.event.returnValue = false;
      } else {
        event.preventDefault();
      }      
    }, 

    dragStop: function(event) {

      // Stop capturing mousemove and mouseup events.
      //$get("Slider1_MinValue").value = this.MinValue;
      //$get("Slider1_MaxValue").value = this.MaxValue;
      
      //alert("Min: " + this.Min + "\nMinValue: " + this.MinValue + "\nMax: " +this.Max + "\nMaxValue: " + this.MaxValue);
      if ( this.MaxValue > 270) {
              this.MaxValue = 270;
      }
      var RealMaxValue = Math.round(this.Min + ((this.MaxValue/this.MaxSize)*(this.Max - this.Min)));
      this.MaxValueFieldElement.value = this.MaxValue;
        
      if ( this.MinValue > this.MaxValue) {
            this.MinValue = 0;
      }

      var RealMinValue = Math.round(this.Min + ((this.MinValue/this.MaxSize)*(this.Max - this.Min)));
      this.MinValueFieldElement.value = this.MinValue;
      
      
      this.RealValueMinFieldElement.value = roundMinMax(RealMinValue, "");
      
      
          if ( this.Max != RealMaxValue) {
              this.RealValueMaxFieldElement.value = roundMinMax(RealMaxValue, "");
               var larger = "";
          } else {
              this.RealValueMaxFieldElement.value = 0;
              var larger = ">";
          }
          if (this.Appending != "rum") {
              this.RealValueMaxLabel.innerHTML = larger + roundMinMax(RealMaxValue, this.Appending) + " "+this.Appending;
          } else {
              this.RealValueMaxLabel.innerHTML = larger + roundMinMax(RealMaxValue - 1, this.Appending) + " "+this.Appending;
          }
      this.RealValueMinLabel.innerHTML = roundMinMax(RealMinValue, this.Appending) + " "+this.Appending;
          
      if (document.detachEvent) {
        document.detachEvent("onmousemove", this.dragMaxGoHandler);
        document.detachEvent("onmousemove", this.dragMinGoHandler);
        document.detachEvent("onmouseup",   this.dragStopHandler);
      }
      if (document.removeEventListener) {
        document.removeEventListener("mousemove", this.dragMaxGoHandler,   true);
        document.removeEventListener("mousemove", this.dragMinGoHandler,   true);
        document.removeEventListener("mouseup",   this.dragStopHandler, true);
      }
      
      if(this.autoPostBackElement)
      {
        __doPostBack(this.autoPostBackElement.id, "click");
      }
    }
}