2.3.2

feat: make range and marks props to work together

README.md

@@ -74,7 +74,7 @@ ReactDOM.render(<Rcslider />, container);
           <td>className</td>
           <td>String</td>
           <td>rc-slider</td>
-          <td>additional css class of root dom node</td>
+          <td>Additional css class for the root dom node</td>
         </tr>
         <tr>
           <td>min</td>
@@ -94,41 +94,47 @@ ReactDOM.render(<Rcslider />, container);
           <td>1</td>
           <td>Value to be added or subtracted on each step the slider makes. Must be greater than zero. max - min should be evenly divisible by the step value.</td>
         </tr>
-         <tr>
+        <tr>
-          <td>defaultValue</td>
+          <td>range</td>
-          <td>number</td>
+          <td>boolean</td>
-          <td>0</td>
+          <td>false</td>
-          <td>Determines the initial positions of the handles.</td>
+          <td>Determines the type of slider. If range is `true`, two handles will be rendered in order to select a range.</td>
         </tr>
-         <tr>
+        <tr>
+          <td>defaultValue</td>
+          <td>number or [number, number]</td>
+          <td>0 or [0, 0]</td>
+          <td>Set initial positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number]`</td>
+        </tr>
+        <tr>
           <td>value</td>
-          <td>number</td>
+          <td>number or [number, number]</td>
           <td></td>
-          <td>Determines the current positions of the handles.</td>
+          <td>Set current positions of handles. If range is `false`, the type of `defaultValue` should be `number`. Otherwise, `[number, number]`</td>
         </tr>
         <tr>
           <td>marks</td>
           <td>array</td>
           <td>[]</td>
-          <td>mark every step for the slider, it will ignore the `step` parameter if it has been defined</td>
+          <td>Mark every step for the slider, it will ignore the `step` parameter if it has been defined. Does not work with `range`</td>
         </tr>
         <tr>
-          <td>isIncluded</td>
+          <td>included</td>
           <td>boolean</td>
           <td>true</td>
-          <td>if the value is true, it means a continuous value interval, otherwise, it is a independent value.</td>
+          <td>If the value is `true`, it means a continuous value interval, otherwise, it is a independent value.</td>
         </tr>
         <tr>
           <td>defaultIndex</td>
           <td>number</td>
           <td>0</td>
-          <td>For step or marks slider, determine the initial positions of the handles.</td>
+          <td>For step or marks slider, determines the initial position of the handle. Does not work with `range`</td>
         </tr>
         <tr>
           <td>index</td>
           <td>number</td>
           <td></td>
-          <td>For step or marks slider, determine current positions of the handles.</td>
+          <td>For step or marks slider, determines current position of the handle. Does not work with `range`</td>
         </tr>
         <tr>
           <td>disabled</td>
@@ -143,10 +149,16 @@ ReactDOM.render(<Rcslider />, container);
           <td>Set the animation for tooltip if it shows.</td>
         </tr>
         <tr>
-          <td>withDots</td>
+          <td>tipFormatter</td>
+          <td>func</td>
+          <td></td>
+          <td>Format the value of the tooltip if it shows.</td>
+        </tr>
+        <tr>
+          <td>dots</td>
           <td>bool</td>
           <td>false</td>
-          <td>For linear slider, when the `step` value is greater than 1, you can set the `withDots` to  `true` if you want to render the slider bar with dots.</td>
+          <td>For linear slider, when the `step` value is greater than 1, you can set the `dots` to  `true` if you want to render the slider bar with dots.</td>
         </tr>
     </tbody>
 </table>

assets/index.less

@@ -146,13 +146,13 @@
       display: none;
     }
 
-    &-placement-points-bc-tc {
+    &-placement-top {
       padding: @tooltip-arrow-width 0 @tooltip-distance 0;
     }
 
     &-inner {
-      padding: 6px 0;
+      padding: 6px 2px;
-      width: 24px;
+      min-width: 24px;
       height: 24px;
       font-size: 12px;
       line-height: 1;
@@ -172,7 +172,7 @@
       border-style: solid;
     }
 
-    &-placement-points-bc-tc &-arrow {
+    &-placement-top &-arrow {
       bottom: @tooltip-distance - @tooltip-arrow-width;
       left: 50%;
       margin-left: -@tooltip-arrow-width;

examples/simple.js

@@ -3,33 +3,56 @@
 require('rc-slider/assets/index.less');
 
 var React = require('react');
+var ReactDOM = require('react-dom');
 var Slider = require('rc-slider');
+var style = {width:400,margin:50};
 
-function onChange(v) {
+var log = console.log.bind(console);
-  console.log(v);
+
+
+var marks = ["状态1","状态2","状态3","状态4"];
+
+function percentFormatter(v) {
+  return v + " %";
 }
 
-React.render(
+ReactDOM.render(
   <div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <Slider onChange={onChange} tipTransitionName='rc-slider-tooltip-zoom-down'/>
+      <p>基础滑块</p>
+      <Slider onChange={log} tipTransitionName='rc-slider-tooltip-zoom-down' />
     </div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <Slider marks={["一","二","三","四","五"]} defaultIndex={2}/>
+      <p>基础滑块，step=20</p>
+      <Slider step={20} />
     </div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <Slider withDots step={20}/>
+      <p>基础滑块，step=20 带圆点</p>
+      <Slider dots step={20} />
     </div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <Slider step={20}/>
+      <p>双滑块</p>
+      <Slider range min={10} max={90} defaultValue={[0, 30]} onChange={log} />
     </div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <p>包含关系</p>
+      <p>双滑块，step=20 </p>
-      <Slider marks={["状态1","状态2","状态3","状态4"]} defaultIndex={1} />
+      <Slider range dots step={20} defaultValue={[0, 30]} onAfterChange={log} included={false} />
     </div>
-    <div style={{width:400,margin:100}}>
+    <div style={style}>
-      <p>并列关系</p>
+      <p>分段式滑块（包含关系）</p>
-      <Slider marks={["状态1","状态2","状态3","状态4"]} isIncluded={false} defaultIndex={1} />
+      <Slider marks={marks} defaultIndex={1} />
+    </div>
+    <div style={style}>
+      <p>分段式滑块 (双)</p>
+      <Slider range marks={marks} onChange={log} defaultIndex={[1,2]} />
+    </div>
+    <div style={style}>
+      <p>分段式滑块（并列关系）</p>
+      <Slider marks={marks} included={false} defaultIndex={1} />
+    </div>
+    <div style={style}>
+      <p>基础滑块</p>
+      <Slider onChange={log} tipFormatter={percentFormatter} tipTransitionName='rc-slider-tooltip-zoom-down' />
     </div>
   </div>
   , document.getElementById('__react-content'));

package.json

@@ -1,6 +1,6 @@
 {
   "name": "rc-slider",
-  "version": "1.5.2",
+  "version": "2.3.2",
   "description": "slider ui component for react",
   "keywords": [
     "react",
@@ -40,18 +40,18 @@
   "devDependencies": {
     "expect.js": "0.3.x",
     "jquery": "^1.11.2",
-    "precommit-hook": "^1.0.7",
+    "pre-commit": "1.x",
     "rc-server": "3.x",
     "rc-tools": "4.x",
     "react": "~0.14.0",
     "react-addons-test-utils": "^0.14.0",
     "react-dom": "~0.14.0"
   },
-  "precommit": [
+  "pre-commit": [
     "lint"
   ],
   "dependencies": {
-    "rc-tooltip": "2.x",
+    "rc-tooltip": "3.x",
-    "rc-util": "2.x"
+    "rc-util": "3.x"
   }
 }

src/Handle.jsx

@@ -10,9 +10,21 @@ export default class Handle extends React.Component {
     };
   }
 
+  showTooltip() {
+    this.setState({
+      isTooltipVisible: true,
+    });
+  }
+
+  hideTooltip() {
+    this.setState({
+      isTooltipVisible: false,
+    });
+  }
+
   render() {
     const props = this.props;
-    const {className, prefixCls, offset, tipTransitionName, value} = props;
+    const {className, tipTransitionName, tipFormatter, offset, value} = props;
     const {dragging, noTip} = props;
 
     const style = { left: offset + '%' };
@@ -27,33 +39,22 @@ export default class Handle extends React.Component {
 
     const isTooltipVisible = dragging || this.state.isTooltipVisible;
     return (<Tooltip
-              prefixCls={prefixCls + '-tooltip'}
+              prefixCls={className.replace('handle', 'tooltip')}
-              placement={{points: ['bc', 'tc']}}
+              placement="top"
               visible={isTooltipVisible}
-              overlay={<span>{value}</span>}
+              overlay={<span>{tipFormatter ? tipFormatter(value) : value}</span>}
               delay={0}
               transitionName={tipTransitionName}>
               {handle}
             </Tooltip>);
   }
-
-  showTooltip() {
-    this.setState({
-      isTooltipVisible: true,
-    });
-  }
-  hideTooltip() {
-    this.setState({
-      isTooltipVisible: false,
-    });
-  }
 }
 
 Handle.propTypes = {
   className: React.PropTypes.string,
-  prefixCls: React.PropTypes.string,
   offset: React.PropTypes.number,
   tipTransitionName: React.PropTypes.string,
+  tipFormatter: React.PropTypes.func,
   value: React.PropTypes.number,
   dragging: React.PropTypes.bool,
   noTip: React.PropTypes.bool,

src/Marks.jsx

@@ -1,14 +1,14 @@
 import React from 'react';
 import rcUtil from 'rc-util';
 
-const Marks = ({className, marks, index, isIncluded}) => {
+const Marks = ({className, marks, index, included}) => {
   const marksLen = marks.length;
   const unit = 100 / (marksLen - 1);
   const markWidth = unit / 2 + '%';
 
   const elements = [];
   for (let i = 0; i < marksLen; i++) {
-    const isActived = (isIncluded && i <= index) || (!isIncluded && i === index);
+    const isActived = (included && i <= index) || (!included && i === index);
     const markClassName = rcUtil.classSet({
       [className + '-text']: true,
       [className + '-text-active']: isActived,

src/Slider.jsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import rcUtil, {Dom as DomUtils} from 'rc-util';
+import {Dom as DomUtils, classSet} from 'rc-util';
 import Track from './Track';
 import Handle from './Handle';
 import Steps from './Steps';
@@ -8,178 +8,203 @@ import Marks from './Marks';
 function noop() {
 }
 
+function isNotTouchEvent(e) {
+  return e.touches.length > 1 || (e.type.toLowerCase() === 'touchend' && e.touches.length > 0);
+}
+
+function getTouchPosition(e) {
+  return e.touches[0].pageX;
+}
+
+function getMousePosition(e) {
+  return e.pageX;
+}
+
 function pauseEvent(e) {
-  e.cancelBubble = true;
+  e.stopPropagation();
-  e.returnValue = false;
+  e.preventDefault();
-  if (e.stopPropagation) {
-    e.stopPropagation();
-  }
-  if (e.preventDefault) {
-    e.preventDefault();
-  }
 }
 
-function getValueFromIndex(props) {
+// This is an utility method, tries to get property, then defaultPropery with
-  let value;
+// special check using 'in', because propery can be '0'
-  const marksLen = props.marks.length;
+function propOrDefault(props, name, fallback) {
-  let index;
+  const defaultName = 'default' + name.charAt(0).toUpperCase() + name.substring(1);
-  if ('index' in props) {
+  const defaultValue = (defaultName in props ? props[defaultName] : fallback);
-    index = props.index;
+  return (name in props ? props[name] : defaultValue);
-  } else {
-    index = props.defaultIndex;
-  }
-  if (marksLen > 0) {
-    value = ((props.max - props.min) / (marksLen - 1)) * (index);
-    value = value.toFixed(5) / 1;
-  }
-  return value;
 }
 
-const Slider = React.createClass({
+class Slider extends React.Component {
-  propTypes: {
+  constructor(props) {
-    min: React.PropTypes.number,
+    super(props);
-    max: React.PropTypes.number,
-    step: React.PropTypes.number,
-    defaultValue: React.PropTypes.number,
-    defaultIndex: React.PropTypes.number,
-    value: React.PropTypes.number,
-    index: React.PropTypes.number,
-    marks: React.PropTypes.array,
-    isIncluded: React.PropTypes.bool,
-    className: React.PropTypes.string,
-    prefixCls: React.PropTypes.string,
-    disabled: React.PropTypes.bool,
-    children: React.PropTypes.any,
-    onBeforeChange: React.PropTypes.func,
-    onChange: React.PropTypes.func,
-    onAfterChange: React.PropTypes.func,
-    tipTransitionName: React.PropTypes.string,
-    withDots: React.PropTypes.bool,
-  },
 
-  getDefaultProps() {
+    let upperBound;
-    return {
+    let lowerBound;
-      min: 0,
+    const initialValue = props.range ? [0, 0] : 0;
-      max: 100,
+    if (props.marks.length > 0) {
-      step: 1,
+      const index = propOrDefault(props, 'index', initialValue);
-      defaultValue: 0,
+      ({lowerBound, upperBound} = this.getBoundsFromIndex(index, props));
-      marks: [],
+    } else {
-      isIncluded: true,
+      const value = propOrDefault(props, 'value', initialValue);
-      className: '',
+      if (props.range) {
-      prefixCls: 'rc-slider',
+        lowerBound = this.trimAlignValue(value[0]);
-      disabled: false,
+        upperBound = this.trimAlignValue(value[1]);
-      defaultIndex: 0,
+      } else {
-      tipTransitionName: '',
+        upperBound = this.trimAlignValue(value);
-      withDots: false,
+      }
-    };
+    }
-  },
 
-  getInitialState() {
+    let recent;
-    const props = this.props;
+    if (props.range && upperBound === lowerBound) {
-    let value = props.defaultValue;
+      if (lowerBound === props.max) {
-    if ('value' in props) {
+        recent = 'lowerBound';
-      value = props.value;
+      }
+      if (upperBound === props.min) {
+        recent = 'upperBound';
+      }
+    } else {
+      recent = 'upperBound';
     }
-    value = this._trimAlignValue(value);
+
-    const marksLen = props.marks.length;
+    this.state = {
-    if (marksLen > 0) {
+      handle: null,
-      value = getValueFromIndex(props);
+      recent: recent,
-    }
+      upperBound: upperBound,
-    return {
+      // If Slider is not range, set `lowerBound` equal to `min`.
-      dragging: false,
+      lowerBound: (lowerBound || props.min),
-      value: value,
     };
-  },
+  }
 
   componentWillReceiveProps(nextProps) {
-    if ('value' in nextProps) {
+    if (nextProps.range) {
+      const value = nextProps.value;
+      if (value) {
+        this.setState({
+          upperBound: value[1],
+          lowerBound: value[0],
+        });
+      }
+    } else if ('value' in nextProps) {
       this.setState({
-        value: nextProps.value,
+        upperBound: nextProps.value,
       });
     } else if ('index' in nextProps) {
-      this.setState({
+      const index = ('index' in nextProps ? nextProps.index : nextProps.defaultIndex);
-        value: getValueFromIndex(nextProps),
+      this.setState(this.getBoundsFromIndex(index, nextProps));
-      });
     }
-  },
+  }
-
-  onMouseUp() {
-    this._end('mouse');
-  },
-
-  onTouchUp() {
-    this._end('touch');
-  },
 
   onMouseMove(e) {
-    const position = e.pageX || (e.clientX + document.documentElement.scrollLeft); // to compat ie8
+    const position = getMousePosition(e);
     this.onMove(e, position);
-  },
+  }
 
   onTouchMove(e) {
-    if (e.touches.length > 1 || (e.type === 'touchend' && e.touches.length > 0)) {
+    if (isNotTouchEvent(e)) {
-      this._end('touch');
+      this.end('touch');
       return;
     }
 
-    const position = this._getTouchPosition(e);
+    const position = getTouchPosition(e);
-
     this.onMove(e, position);
-  },
+  }
 
   onMove(e, position) {
     pauseEvent(e);
     const props = this.props;
     const state = this.state;
 
-    let value = state.value;
-    const oldValue = value;
-
     const diffPosition = position - this.startPosition;
-
     const diffValue = diffPosition / this.getSliderLength() * (props.max - props.min);
-    value = this._trimAlignValue(this.startValue + diffValue);
 
-    if (value !== oldValue && !('value' in props) && !('index' in props)) {
+    const value = this.trimAlignValue(this.startValue + diffValue);
-      this.setState({value: value});
+    const oldValue = state[state.handle];
+    if (value === oldValue) return;
+
+    if (!('value' in props) && !('index' in props)) {
+      this.setState({[state.handle]: value}, () => {
+        this.triggerEvents('onChange', this.getValue());
+      });
     }
-    if (value !== oldValue) {
+  }
-      this._triggerEvents('onChange', value);
-    }
-  },
 
   onTouchStart(e) {
-    if (e.touches.length > 1 || (e.type.toLowerCase() === 'touchend' && e.touches.length > 0)) {
+    if (isNotTouchEvent(e)) return;
-      return;
-    }
 
-    const position = this._getTouchPosition(e);
+    const position = getTouchPosition(e);
-    const value = this._calValueByPos(position);
+    this.onStart(position);
-    this._triggerEvents('onChange', value);
+    this.addDocumentEvents('touch');
-    this._start(position, value);
-    this._addDocumentEvents('touch');
     pauseEvent(e);
-  },
+  }
 
   onSliderMouseDown(e) {
-    const position = e.pageX || (e.clientX + document.documentElement.scrollLeft); // to compat ie8
+    const position = getMousePosition(e);
-    const value = this._calValueByPos(position);
+    this.onStart(position);
-    this._triggerEvents('onChange', value);
+    this.addDocumentEvents('mouse');
-    this._start(position, value);
-    this._addDocumentEvents('mouse');
     pauseEvent(e);
-  },
+  }
 
-  getIndex(v) {
+  onStart(position) {
-    const props = this.props;
+    this.triggerEvents('onBeforeChange');
-    const value = v === undefined ? this.state.value : v;
 
-    if (props.marks.length === 0) {
+    const value = this.calcValueByPos(position);
-      return Math.floor((value - props.min) / props.step);
+    this.startValue = value;
+    this.startPosition = position;
+
+    const state = this.state;
+    const {upperBound, lowerBound} = state;
+
+    let valueNeedChanging = 'upperBound';
+    if (this.props.range) {
+      const isLowerBoundCloser = Math.abs(upperBound - value) > Math.abs(lowerBound - value);
+      if (isLowerBoundCloser) {
+        valueNeedChanging = 'lowerBound';
+      }
+
+      const isAtTheSamePoint = (upperBound === lowerBound);
+      if (isAtTheSamePoint) {
+        valueNeedChanging = state.recent;
+      }
+
+      if (isAtTheSamePoint && (value !== upperBound)) {
+        valueNeedChanging = value < upperBound ? 'lowerBound' : 'upperBound';
+      }
     }
-    const unit = ((props.max - props.min) / (props.marks.length - 1)).toFixed(5);
+
+    this.setState({
+      handle: valueNeedChanging,
+      recent: valueNeedChanging,
+      [valueNeedChanging]: value,
+    }, () => {
+      this.triggerEvents('onChange', this.getValue());
+    });
+  }
+
+  getValue() {
+    const {lowerBound, upperBound} = this.state;
+    return this.props.range ? [lowerBound, upperBound] : upperBound;
+  }
+
+  getIndex(value) {
+    const {marks, min, max, step} = this.props;
+
+    if (marks.length === 0) {
+      return Math.floor((value - min) / step);
+    }
+    const unit = ((max - min) / (marks.length - 1)).toFixed(5);
     return Math.round(value / unit);
-  },
+  }
+
+  getBoundsFromIndex(value, props) {
+    if (props.range) {
+      return {
+        lowerBound: this.calcValueFromIndex(value[0], props),
+        upperBound: this.calcValueFromIndex(value[1], props),
+      };
+    }
+    return {
+      upperBound: this.calcValueFromIndex(value, props),
+    };
+  }
 
   getSliderLength() {
     const slider = this.refs.slider;
@@ -188,82 +213,36 @@ const Slider = React.createClass({
     }
 
     return slider.clientWidth;
-  },
+  }
 
   getSliderStart() {
     const slider = this.refs.slider;
     const rect = slider.getBoundingClientRect();
 
     return rect.left;
-  },
+  }
 
-  render() {
+  trimAlignValue(v) {
-    const state = this.state;
+    const state = this.state || {};
-    const {value, dragging} = state;
     const props = this.props;
-    const {className, prefixCls, disabled, isIncluded, withDots} = props;
+    const {marks, min, max} = props;
-    const {marks, step, max, min, tipTransitionName, children} = props;
+    const step = marks.length > 0 ? (max - min) / (marks.length - 1) : props.step;
-    const marksLen = marks.length;
 
-    const sliderClassName = rcUtil.classSet({
-      [prefixCls]: true,
-      [prefixCls + '-disabled']: disabled,
-      [className]: !!className,
-    });
-
-    const offset = this._calcOffset(value);
-
-    let track = null;
-    if (isIncluded) {
-      const trackClassName = prefixCls + '-track';
-      track = <Track className={trackClassName} offset={0} length={offset - 0} />;
-    }
-
-    const handleClassName = prefixCls + '-handle';
-
-    let steps = null;
-    if (marksLen > 0 || (step > 1 && withDots)) {
-      const stepsClassName = prefixCls + '-step';
-      const stepNum = marksLen > 0 ? marksLen : Math.floor((max - min) / step) + 1;
-      steps = (<Steps className={stepsClassName} stepNum={stepNum}
-                 index={this.getIndex()} isIncluded={isIncluded} />);
-    }
-
-    let mark = null;
-    if (marksLen > 0) {
-      const markClassName = prefixCls + '-mark';
-      mark = (<Marks className={markClassName} marks={marks}
-                 index={this.getIndex()} isIncluded={isIncluded} />);
-    }
-
-    return (
-      <div ref="slider" className={sliderClassName}
-        onTouchStart={disabled ? noop : this.onTouchStart}
-        onMouseDown={disabled ? noop : this.onSliderMouseDown}>
-        {track}
-        <Handle className={handleClassName} prefixCls={prefixCls}
-          offset={offset} tipTransitionName={tipTransitionName} value={value}
-          dragging={dragging} noTip={marksLen > 0} />
-        {steps}
-        {mark}
-        {children}
-      </div>
-    );
-  },
-
-  _trimAlignValue(v, propsArg) {
     let val = v;
-    const props = propsArg || this.props;
+    if (val <= min) {
-    const step = props.marks.length > 0 ? (props.max - props.min) / (props.marks.length - 1) : props.step;
+      val = min;
-
-    if (val <= props.min) {
-      val = props.min;
     }
-    if (val >= props.max) {
+    if (val >= max) {
-      val = props.max;
+      val = max;
+    }
+    if (state.handle === 'upperBound' && val <= state.lowerBound) {
+      val = state.lowerBound;
+    }
+    if (state.handle === 'lowerBound' && val >= state.upperBound) {
+      val = state.upperBound;
     }
 
-    const valModStep = (val - props.min) % step;
+    const valModStep = (val - min) % step;
     let alignValue = val - valModStep;
 
     if (Math.abs(valModStep) * 2 >= step) {
@@ -271,40 +250,47 @@ const Slider = React.createClass({
     }
 
     return parseFloat(alignValue.toFixed(5));
-  },
+  }
 
-  _calcOffset(value) {
+  calcOffset(value) {
-    const ratio = (value - this.props.min) / (this.props.max - this.props.min);
+    const {min, max} = this.props;
+    const ratio = (value - min) / (max - min);
     return ratio * 100;
-  },
+  }
 
-  _calcValue(offset) {
+  calcValue(offset) {
+    const {min, max} = this.props;
     const ratio = offset / this.getSliderLength();
-    return ratio * (this.props.max - this.props.min) + this.props.min;
+    return ratio * (max - min) + min;
-  },
+  }
 
-  _calValueByPos(position) {
+  calcValueByPos(position) {
     const pixelOffset = position - this.getSliderStart();
-    // pixelOffset -= (this.state.onSize / 2);
+    const nextValue = this.trimAlignValue(this.calcValue(pixelOffset));
-    const nextValue = this._trimAlignValue(this._calcValue(pixelOffset));
-    this.setState({
-      value: nextValue,
-    });
     return nextValue;
-  },
+  }
 
-  _getTouchPosition(e) {
+  calcValueFromIndex(index, props) {
-    const touch = e.touches[0];
+    const marksLen = props.marks.length;
-    return touch.pageX;
+    if (marksLen > 0) {
-  },
+      const value = ((props.max - props.min) / (marksLen - 1)) * (index);
+      // `'1' / 1 => 1`, to make sure that the returned value is a `Number`.
+      return value.toFixed(5) / 1;
+    }
+    return ('value' in props ? props.value : props.defaultValue);
+  }
 
-  _triggerEvents(event, v) {
+  triggerEvents(event, v) {
     const props = this.props;
-    const hasMarks = props.marks && props.marks.length > 0;
+    const hasMarks = (props.marks.length > 0);
     if (props[event]) {
       let data;
       if (hasMarks) {
-        data = this.getIndex(v);
+        if (props.range) {
+          data = v.map(bound => this.getIndex(bound));
+        } else {
+          data = this.getIndex(v);
+        }
       } else if (v === undefined) {
         data = this.state.value;
       } else {
@@ -312,20 +298,20 @@ const Slider = React.createClass({
       }
       props[event](data);
     }
-  },
+  }
 
-  _addDocumentEvents(type) {
+  addDocumentEvents(type) {
     if (type === 'touch') {
       // just work for chrome iOS Safari and Android Browser
-      this.onTouchMoveListener = DomUtils.addEventListener(document, 'touchmove', this.onTouchMove);
+      this.onTouchMoveListener = DomUtils.addEventListener(document, 'touchmove', this.onTouchMove.bind(this));
-      this.onTouchUpListener = DomUtils.addEventListener(document, 'touchend', this.onTouchUp);
+      this.onTouchUpListener = DomUtils.addEventListener(document, 'touchend', this.end.bind(this, 'touch'));
     } else if (type === 'mouse') {
-      this.onMouseMoveListener = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove);
+      this.onMouseMoveListener = DomUtils.addEventListener(document, 'mousemove', this.onMouseMove.bind(this));
-      this.onMouseUpListener = DomUtils.addEventListener(document, 'mouseup', this.onMouseUp);
+      this.onMouseUpListener = DomUtils.addEventListener(document, 'mouseup', this.end.bind(this, 'mouse'));
     }
-  },
+  }
 
-  _removeEventons(type) {
+  removeEventons(type) {
     if (type === 'touch') {
       this.onTouchMoveListener.remove();
       this.onTouchUpListener.remove();
@@ -333,24 +319,130 @@ const Slider = React.createClass({
       this.onMouseMoveListener.remove();
       this.onMouseUpListener.remove();
     }
-  },
+  }
 
-  _start(position, value) {
+  end(type) {
-    this._triggerEvents('onBeforeChange');
+    this.removeEventons(type);
-    this.startValue = value;
+    this.triggerEvents('onAfterChange', this.getValue());
-    this.startPosition = position;
+    this.setState({handle: null});
-    this.setState({
+  }
-      dragging: true,
-    });
-  },
 
-  _end(type) {
+  render() {
-    this._removeEventons(type);
+    const {handle, upperBound, lowerBound} = this.state;
-    this._triggerEvents('onAfterChange');
+    const props = this.props;
-    this.setState({
+    const {className, prefixCls, disabled, included, isIncluded, dots, range} = props;
-      dragging: false,
+    const {marks, step, max, min, tipTransitionName, tipFormatter, children} = props;
+    const marksLen = marks.length;
+
+    const sliderClassName = classSet({
+      [prefixCls]: true,
+      [prefixCls + '-disabled']: disabled,
+      [className]: !!className,
     });
-  },
+
-});
+    const upperOffset = this.calcOffset(upperBound);
+    const lowerOffset = this.calcOffset(lowerBound);
+
+    let track = null;
+    if ((included && isIncluded) || range) {
+      const trackClassName = prefixCls + '-track';
+      track = <Track className={trackClassName} offset={lowerOffset} length={upperOffset - lowerOffset}/>;
+    }
+
+    const handleClassName = prefixCls + '-handle';
+    const isNoTip = (marksLen > 0) && !tipFormatter;
+    const upper = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip} tipFormatter={tipFormatter}
+                     offset={upperOffset} value={upperBound} dragging={handle === 'upperBound'} />);
+
+    let lower = null;
+    if (range) {
+      lower = (<Handle className={handleClassName} tipTransitionName={tipTransitionName} noTip={isNoTip} tipFormatter={tipFormatter}
+                 offset={lowerOffset} value={lowerBound} dragging={handle === 'lowerBound'} />);
+    }
+
+    const upperIndex = this.getIndex(upperBound);
+
+    let steps = null;
+    if (marksLen > 0 || (step > 1 && dots)) {
+      const stepsClassName = prefixCls + '-step';
+      const stepNum = marksLen > 0 ? marksLen : Math.floor((max - min) / step) + 1;
+      steps = (<Steps className={stepsClassName} stepNum={stepNum}
+                      lowerIndex={this.getIndex(lowerBound)} upperIndex={upperIndex}
+                      included={(included && isIncluded) || range}/>);
+    }
+
+    let mark = null;
+    if (marksLen > 0) {
+      const markClassName = prefixCls + '-mark';
+      mark = (<Marks className={markClassName} marks={marks}
+                     index={upperIndex} included={(included && isIncluded)}/>);
+    }
+
+    return (
+      <div ref="slider" className={sliderClassName}
+           onTouchStart={disabled ? noop : this.onTouchStart.bind(this)}
+           onMouseDown={disabled ? noop : this.onSliderMouseDown.bind(this)}>
+        {track}
+        {upper}
+        {lower}
+        {steps}
+        {mark}
+        {children}
+      </div>
+    );
+  }
+}
+
+Slider.propTypes = {
+  min: React.PropTypes.number,
+  max: React.PropTypes.number,
+  step: React.PropTypes.number,
+  defaultValue: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  defaultIndex: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  value: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  index: React.PropTypes.oneOfType([
+    React.PropTypes.number,
+    React.PropTypes.arrayOf(React.PropTypes.number),
+  ]),
+  marks: React.PropTypes.array,
+  isIncluded: React.PropTypes.bool, // @Deprecated
+  included: React.PropTypes.bool,
+  className: React.PropTypes.string,
+  prefixCls: React.PropTypes.string,
+  disabled: React.PropTypes.bool,
+  children: React.PropTypes.any,
+  onBeforeChange: React.PropTypes.func,
+  onChange: React.PropTypes.func,
+  onAfterChange: React.PropTypes.func,
+  tipTransitionName: React.PropTypes.string,
+  tipFormatter: React.PropTypes.func,
+  dots: React.PropTypes.bool,
+  range: React.PropTypes.bool,
+};
+
+Slider.defaultProps = {
+  min: 0,
+  max: 100,
+  step: 1,
+  defaultIndex: 0,
+  marks: [],
+  isIncluded: true, // @Deprecated
+  included: true,
+  className: '',
+  prefixCls: 'rc-slider',
+  disabled: false,
+  tipTransitionName: '',
+  dots: false,
+  range: false,
+};
 
 export default Slider;

src/Steps.jsx

@@ -1,7 +1,7 @@
 import React from 'react';
 import rcUtil from 'rc-util';
 
-const Steps = ({className, stepNum, isIncluded, index}) => {
+const Steps = ({className, stepNum, included, lowerIndex, upperIndex}) => {
   const dotClassName = className.replace('step', 'dot');
   const unit = 100 / (stepNum - 1);
 
@@ -10,7 +10,8 @@ const Steps = ({className, stepNum, isIncluded, index}) => {
     const offset = unit * i + '%';
     const style = { left: offset };
 
-    const isActived = (isIncluded && i <= index) || (!isIncluded && i === index);
+    const isActived = (included && i <= upperIndex && i >= lowerIndex ) ||
+            (!included && i === upperIndex);
     const stepClassName = rcUtil.classSet({
       [dotClassName]: true,
       [dotClassName + '-active']: isActived,

tests/index.spec.js

@@ -26,7 +26,7 @@ describe('rc-slider', function () {
     expect(node.find('.rc-slider').length).to.be(1);
     expect(node.find('.rc-slider-handle').length).to.be(1);
     expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.value).to.be(40);
+    expect(slider.state.upperBound).to.be(40);
     var trackWidth = node.find('.rc-slider-track')[0].style.width;
     expect(trackWidth).to.eql(node.find('.rc-slider-handle')[0].style.left);
   });
@@ -40,10 +40,10 @@ describe('rc-slider', function () {
     expect(node.find('.rc-slider').length).to.be(1);
     expect(node.find('.rc-slider-handle').length).to.be(1);
     expect(node.find('.rc-slider-track').length).to.be(1);
-    expect(slider.state.value).to.be(0);
+    expect(slider.state.upperBound).to.be(0);
 
-    var sliderWithDots = React.render(
+    var sliderWithDots = ReactDOM.render(
-      <Slider className='rc-slider' step={20} withDots/>,
+      <Slider className='rc-slider' step={20} dots/>,
       div
     );
     var node1 = $(div);
@@ -62,7 +62,7 @@ describe('rc-slider', function () {
     expect(node.find('.rc-slider-dot').length).to.be(slider.props.marks.length);
     expect(node.find('.rc-slider-mark').length).to.be(1);
     expect(node.find('.rc-slider-mark-text').length).to.be(slider.props.marks.length);
-    expect(slider.getIndex()).to.be(3);
+    expect(slider.getIndex(slider.state.upperBound)).to.be(3);
   });
 
   // it('should mouseDown works!', function (done) {