Highcharts可拖动点拖动步长

在下面的示例中，我需要将点拖动一定的步长，例如10。看

drag: function (e) {

---

作为替代方案，这里是一个修改版的

可拖动点.js

（），它允许在某些步长下拖动一些参数。已为系列添加以下选项：

• dragStepSizeX

  ：X轴的数值步长

• dragStepSizeY

  ：Y轴的数值步长

• dragStepSize

  ：使用参数

  XorY

  和

  点

  的函数，您可以根据轴和被拖动的点实现该函数以返回所需的步长

• dragStepAllowMinMax

  ：布尔值，是否允许您拖动到最小/最大限制，或强制执行步骤

• dragStepRelative

  ：布尔值，是否应相对于原始值点执行拖动步骤

请参见用于在Y轴上对8个第一点强制5步，对其余点强制2步的步骤。不是X轴上的步长

在

draggable points.js

中修改了以下函数以适应此要求：

/**
 * Adjust value according to step size
 */
function dragStepAdjustment(value, prevValue, stepSize, relative) {
    if(stepSize === undefined) {
        return value;
    }

    const midpoint = stepSize/2;
    const modulus = relative === true ? (value-prevValue)%stepSize : value%stepSize;
    return modulus > midpoint ? value + (stepSize-modulus) : value - modulus;
}

/**
 * Filter by dragMin and dragMax
 */
function filterRange(newY, point, series, stepSize, XOrY) {
    var options = series.options,
        dragMin = pick(options.dragMin ? options.dragMin(XOrY, point) : undefined, options['dragMin' + XOrY], undefined),
        dragMax = pick(options.dragMax ? options.dragMax(XOrY, point) : undefined, options['dragMax' + XOrY], undefined),
        precision = pick(options['dragPrecision' + XOrY], undefined),
        allowMinMax = options.dragStepAllowMinMax === true;

    if (!isNaN(precision)) {
        newY = Math.round(newY / precision) * precision;
    }

    if (newY < dragMin) {
        if(stepSize !== undefined) {
            allowMinMax ? newY = dragMin : newY += stepSize;
        }
        else {
            newY = dragMin;
        }
    } else if (newY > dragMax) {
        if(stepSize !== undefined) {
            allowMinMax ? newY = dragMax : newY -= stepSize;
        }
        else {
            newY = dragMax;
        }
    }

    if(newY < dragMin || newY > dragMax) {
        newY = 'X' == XOrY ? point.x : point.y;
    }

    return newY;
}

/**
 * Get the new values based on the drag event
 */
function getNewPos(e) {
    var originalEvent = e.originalEvent || e,
        pageX = originalEvent.changedTouches ? originalEvent.changedTouches[0].pageX : e.pageX,
        pageY = originalEvent.changedTouches ? originalEvent.changedTouches[0].pageY : e.pageY,
        series = dragPoint.series,
        draggableX = series.options.draggableX && dragPoint.draggableX !== false,
        draggableY = series.options.draggableY && dragPoint.draggableY !== false,
        dragSensitivity = pick(series.options.dragSensitivity, 1),
        deltaX = draggableX ? dragX - pageX : 0,
        deltaY = draggableY ? dragY - pageY : 0,
        newPlotX = dragPlotX - deltaX,
        newPlotY = dragPlotY - deltaY,
        newX = dragX === undefined ? dragPoint.x : series.xAxis.toValue(newPlotX, true),
        newY = dragY === undefined ? dragPoint.y : series.yAxis.toValue(newPlotY, true),
        dragStepSizeX = pick(series.options.dragStepSize ? series.options.dragStepSize('X', dragPoint) : undefined, series.options.dragStepSizeX, undefined),
        dragStepSizeY = pick(series.options.dragStepSize ? series.options.dragStepSize('Y', dragPoint) : undefined, series.options.dragStepSizeY, undefined),
        ret;

    newX = dragStepAdjustment(newX, dragPoint.x, dragStepSizeX, series.options.dragStepRelative);
    newY = dragStepAdjustment(newY, dragPoint.y, dragStepSizeY, series.options.dragStepRelative);
    newX = filterRange(newX, dragPoint, series, dragStepSizeX, 'X');
    newY = filterRange(newY, dragPoint, series, dragStepSizeY, 'Y');
    if (dragPoint.low) {
        var newPlotHigh = dragPlotHigh - deltaY,
            newPlotLow = dragPlotLow - deltaY;
        newHigh = dragY === undefined ? dragPoint.high : series.yAxis.toValue(newPlotHigh, true);
        newLow = dragY === undefined ? dragPoint.low : series.yAxis.toValue(newPlotLow, true);
        newHigh = dragStepAdjustment(newHigh, dragPoint.y, dragStepSizeY, series.options.dragStepRelative);
        newLow = dragStepAdjustment(newLow, dragPoint.y, dragStepSizeY, series.options.dragStepRelative);
        newHigh = filterRange(newHigh, dragPoint, series, dragStepSizeY, 'Y');
        newLow = filterRange(newLow, dragPoint, series, dragStepSizeY, 'Y');
    }
    if (Math.sqrt(Math.pow(deltaX, 2) + Math.pow(deltaY, 2)) > dragSensitivity) {
        return {
            x: draggableX ? newX : dragPoint.x,
            y: draggableY ? newY : dragPoint.y,
            high: (draggableY && !changeLow) ? newHigh : dragPoint.high,
            low: (draggableY && changeLow) ? newLow : dragPoint.low,
            dragStart: dragStart,
            originalEvent: e
        };
    } else {
        return null;
    }
}

/**
*根据步长调整值
*/
函数dragStepAdjustment（值、prevValue、步长、相对）{
如果（步长===未定义）{
返回值；
}
常数中点=步长/2；
常量模数=相对===真？（值prevValue）%stepSize:值%stepSize；
返回模数>中点？值+（步长模数）：值-模数；
}
/**
*通过dragMin和dragMax进行过滤
*/
函数过滤器（新、点、系列、步长、XOrY）{
var options=series.options，
dragMin=pick（options.dragMin？options.dragMin（XOrY，point）：未定义，选项['dragMin'+XOrY]，未定义），
dragMax=pick（options.dragMax？options.dragMax（XOrY，点）：未定义，选项['dragMax'+XOrY]，未定义），
精度=拾取（选项['dragPrecision'+XOrY]，未定义），
allowMinMax=options.dragStepAllowMinMax==true；
if（！isNaN（精度））{
newY=数学圆整（newY/精度）*精度；
}
如果（新的dragMax）{
如果（步长！==未定义）{
allowMinMax？newY=dragMax:newY-=步长；
}
否则{
newY=德拉格马克；
}
}
if（newYdragMax）{
newY='X'==XOrY？点.X：点.y；
}
返回newY；
}
/**
*根据拖动事件获取新值
*/
函数getNewPos（e）{
var originalEvent=e.originalEvent | | e，
pageX=originalEvent.changedTouches？originalEvent.changedTouches[0]。pageX:e.pageX，
pageY=originalEvent.changedTouches？originalEvent.changedTouches[0]。pageY:e.pageY，
series=dragPoint.series，
draggableX=series.options.draggableX&&dragPoint.draggableX！==false，
draggableY=series.options.draggableY&&dragPoint.draggableY！==false，
dragSensitivity=拾取（series.options.dragSensitivity，1），
deltaX=DragTablex？dragX-pageX:0，
deltaY=Dragabley？dragY-pageY:0，
newPlotX=dragPlotX-deltaX，
newPlotY=dragPlotY-deltaY，
newX=dragX==未定义？dragPoint.x:series.xAxis.toValue（newPlotX，true），
newY=dragY===未定义？dragPoint.y:series.yAxis.toValue（newPlotY，true），
dragStepSizeX=拾取（series.options.dragStepSize？series.options.dragStepSize（'X'，dragPoint）：未定义，series.options.dragStepSizeX，未定义），
dragStepSizeY=拾取（series.options.dragStepSize？series.options.dragStepSize（'Y'，dragPoint））：未定义，series.options.dragStepSizeY，未定义），
ret；
newX=dragStepAdjustment（newX，dragPoint.x，dragStepSizeX，series.options.dragStepRelative）；
newY=dragStepAdjustment（newY，dragPoint.y，dragStepSizeY，series.options.dragStepRelative）；
newX=filterge（newX，dragPoint，series，dragStepSizeX，'X'）；
newY=过滤（newY，dragPoint，series，dragStepSizeY，'Y'）；
如果（拖动点低）{
var newPlotHigh=dragPlotHigh-deltaY，
newPlotLow=dragPlotLow-deltaY；
newHigh=dragY===未定义？dragPoint.high:series.yAxis.toValue（newPlotHigh，true）；
newLow=dragY===未定义？dragPoint.low:series.yAxis.toValue（newPlotLow，true）；
newHigh=dragStepAdjustment（newHigh，dragPoint.y，dragStepSizeY，series.options.dragStepRelative）；
newLow=dragStepAdjustment（newLow，dragPoint.y，dragStepSizeY，series.options.dragStepRelative）；
newHigh=filterge（newHigh，dragPoint，series，dragStepSizeY，'Y'）；
newLow=过滤（newLow，dragPoint，series，dragStepSizeY，'Y'）；
}
if（Math.sqrt（Math.pow（deltaX，2）+Math.pow（deltaY，2））>dragSensitivity）{
返回{
x:draggableX？newX:dragPoint.x，
y:Dragabley？newY:dragPoint.y，
high：（Dragabley&！changeLow）？newHigh:dragPoint.high，
low：（draggableY&changeLow）？newLow:dragPoint.low，
dragStart:dragStart，
原文：e
};
}否则{
返回null；
}
}

---

这是对Highsoft Torstein Honsi代码的修改，在MIT许可下。

您有什么问题？你可能需要复习。你的问题应该包括所有相关的代码，以及一个明确的问题和迄今为止所做的任何尝试。“步骤”也有点含糊不清，因为直线图是

Step:'left'

。你能描述一下（问题中）一些拖拉步骤的场景吗？例如，步长是否应相对于点的原始值？如果点的值为92，步长为5，则转到95还是97