获取UIslider上的索引

Question

我有雷达图和数据，我想给出基于数据count.If的滑块索引，我正在移动滑块，图形值应该是move.If，假设我在中值滑块的下方，拇指应该到接近索引的位置。

for _ in 0..<3 {
  let mind = arc4random_uniform(mult) + min
  let bre = arc4random_uniform(mult) + min
  let rel = arc4random_uniform(mult) + min
  dataPoints.append(GraphDataPoints(mindfulness: Double(mind), breathing: Double(bre), relaxation: Double(rel)))
}
self.setChartData(mindfulness: dataPoints[0].mindfulness, breathing: dataPoints[0].breathing, relaxation: dataPoints[0].relaxation)
numberofPointsOnSlider = Float(100 / (dataPoints.count - 1))

numberofPointsOnSlider是move.In lastSliderValue的百分比，我正在存储value.pointIndex索引的滑块。

@objc func sliderTouchEvents(slider:UISlider,event: UIEvent){
        slider.isContinuous = true

        if let touchEvent = event.allTouches?.first{
            switch touchEvent.phase{

            case .began:
                    lastSliderValue = slider.value
                break
            case .moved:
                if  slider.value.truncatingRemainder(dividingBy: numberofPointsOnSlider)  == 0{

                    if lastSliderValue < slider.value || lastSliderValue > slider.value{
                        pointIndex = Int(slider.value / numberofPointsOnSlider)
                        self.isIncrement = false
                    }
                     lastSliderValue = slider.value
               }
                if !animation {
                    if pointIndex >= 0 && pointIndex < dataPoints.count  {

                        var  percentToMove:Float = 0

                        if lastSliderValue > slider.value && pointIndex > 0  {

                            percentToMove = (100 * (numberofPointsOnSlider - (slider.value.truncatingRemainder(dividingBy: numberofPointsOnSlider) ))) / numberofPointsOnSlider
                            mindfulDiff = Float(dataPoints[pointIndex].mindfulness - dataPoints[pointIndex - 1].mindfulness)

                            relaxationDiff = Float(dataPoints[pointIndex].relaxation - dataPoints[pointIndex - 1].relaxation)

                            breathingDiff = Float(dataPoints[pointIndex].breathing - dataPoints[pointIndex - 1].breathing)

                        }else if lastSliderValue < slider.value && pointIndex < dataPoints.count - 1 {

                            percentToMove = (100 * (slider.value.truncatingRemainder(dividingBy: numberofPointsOnSlider) )) / numberofPointsOnSlider

                            mindfulDiff = Float(dataPoints[pointIndex].mindfulness - dataPoints[pointIndex + 1].mindfulness)

                            relaxationDiff = Float(dataPoints[pointIndex].relaxation - dataPoints[pointIndex + 1].relaxation)
                            breathingDiff = Float(dataPoints[pointIndex].breathing - dataPoints[pointIndex + 1].breathing)
                        }

                        mp = Float(dataPoints[pointIndex].mindfulness) - (mindfulDiff / 100 ) * percentToMove
                        rp = Float(dataPoints[pointIndex].relaxation) - (relaxationDiff / 100 ) * percentToMove
                        bp = Float(dataPoints[pointIndex].breathing) - (breathingDiff / 100) * percentToMove
                        UIView.animate(withDuration: 10, animations: {
                            self.setChartData(mindfulness: Double(self.mp) , breathing: Double(self.bp) , relaxation: Double(self.rp) )
                        })

                    }
                    else {
                        if (pointIndex < 0) {
                            pointIndex = 0

                        }
                    }
                }

                break
            case .ended:

                let progDiff = lastSliderValue - slider.value
                print("End movie, \(pointIndex) , \(slider.value) ,progDiff: \(progDiff)")

                if progDiff < 0{
                    if (progDiff * -1) >= numberofPointsOnSlider / 2 {
                        animation = true

                        UIView.animate(withDuration: 10, animations: {
                            slider.value += self.numberofPointsOnSlider + progDiff
                        })
                        pointIndex = Int(slider.value / numberofPointsOnSlider)+1
//                        if isIncrement {
//                            pointIndex += pointIndex
//                        }else  {
//                            isIncrement = true
//
//                        }
                            mindfulDiff = Float(dataPoints[pointIndex].mindfulness - Double(mp))
                            relaxationDiff = Float(dataPoints[pointIndex].relaxation - Double(rp))
                            breathingDiff = Float(dataPoints[pointIndex].breathing - Double(bp))

                        doGraphAnimate()
                        }else {
                        animation = true
                        UIView.animate(withDuration: 10, animations: {
                            slider.value = self.lastSliderValue
                        })


                        mindfulDiff = Float(dataPoints[pointIndex].mindfulness - Double(mp))
                        relaxationDiff = Float(dataPoints[pointIndex].relaxation - Double(rp))
                        breathingDiff = Float(dataPoints[pointIndex].breathing - Double(bp))

                        doGraphAnimate()
                    }
                }else if progDiff > 0{

                    if progDiff >= numberofPointsOnSlider / 2 {
                        animation = true
//                        if isIncrement {
//                            print("pointIndex : \(pointIndex)")
//                            pointIndex += pointIndex
//                            print("pointIndex Incremented : \(pointIndex)")
//                        }else{
//                                isIncrement = true
//                        }
                        pointIndex = Int(slider.value / numberofPointsOnSlider)
                        UIView.animate(withDuration: 10, animations: {
                            slider.value -= self.numberofPointsOnSlider - (self.lastSliderValue - slider.value)
                        })

                        mindfulDiff = Float(dataPoints[pointIndex].mindfulness - Double(mp))
                        relaxationDiff = Float(dataPoints[pointIndex].relaxation - Double(rp))
                        breathingDiff = Float(dataPoints[pointIndex].breathing - Double(bp))
                        doGraphAnimate()

                    }
                    else {
                        animation = true
                        UIView.animate(withDuration: 10, animations: {
                            slider.value = self.lastSliderValue
                        })

                        mindfulDiff = Float(dataPoints[pointIndex].mindfulness - Double(mp))
                        relaxationDiff = Float(dataPoints[pointIndex].relaxation - Double(rp))
                        breathingDiff = Float(dataPoints[pointIndex].breathing - Double(bp))

                        doGraphAnimate()
                    }
                }

            default :
                break

            }
        }
    }

帮帮我，谢谢。

Answer 1

您的意思是，当您移动滑块时，您希望滑块仅在特定的离散位置移动？但你的规格还不是很清楚。如果是这样，这就是我的方式，所以如果滑块从0移动到14，它将显示14，从15移动到85，它将显示85。我让你适应以获得你想要的工作。我使用这个IBAction作为滑块

@IBAction fileprivate func changeRowSlider(_ sender: NSSlider) {

    let movedPosition = Int(sender.doubleValue)
    if movedPosition == 0 {
        sender.integerValue = 0
        return
    }
     if movedPosition <= 14 {
        sender.integerValue = 14
        return
    }
     if movedPosition <= 85 {
        sender.integerValue = 85
        return
    }
    sender.integerValue = 100  // last case: move to maxValue
}