From 0e7c26bbd9b15bca7784d2d611a5e44ee470a865 Mon Sep 17 00:00:00 2001 From: Daniel Cohen Gindi Date: Sun, 1 May 2016 21:44:02 +0300 Subject: [PATCH] Highlight enhancements There are certain cases (ie. bubbles) which make sense to have multiple values per xIndex. This fixes that - and adds more granular highlight for Combined Chart. --- Charts/Classes/Charts/BarChartView.swift | 2 +- .../Classes/Charts/BarLineChartViewBase.swift | 2 +- Charts/Classes/Charts/ChartViewBase.swift | 11 +- .../Charts/HorizontalBarChartView.swift | 2 +- .../Charts/PieRadarChartViewBase.swift | 2 +- .../Implementations/ChartBaseDataSet.swift | 10 + .../Implementations/Standard/ChartData.swift | 13 +- .../Standard/ChartDataSet.swift | 36 +++- .../Standard/CombinedChartData.swift | 39 +++- .../Data/Interfaces/IChartDataSet.swift | 7 + .../Highlight/BarChartHighlighter.swift | 180 +++++++++--------- Charts/Classes/Highlight/ChartHighlight.swift | 101 ++++++++-- .../Classes/Highlight/ChartHighlighter.swift | 72 +++---- .../Highlight/CombinedHighlighter.swift | 52 ++--- .../HorizontalBarChartHighlighter.swift | 111 +++++------ .../Renderers/BubbleChartRenderer.swift | 18 +- .../Renderers/CombinedChartRenderer.swift | 29 ++- .../Classes/Utils/ChartSelectionDetail.swift | 26 ++- Charts/Classes/Utils/ChartUtils.swift | 69 ++++++- .../Classes/Data/RealmBaseDataSet.swift | 44 +++++ 20 files changed, 563 insertions(+), 263 deletions(-) diff --git a/Charts/Classes/Charts/BarChartView.swift b/Charts/Classes/Charts/BarChartView.swift index 6e48b6f2d2..9afd35a3f5 100644 --- a/Charts/Classes/Charts/BarChartView.swift +++ b/Charts/Classes/Charts/BarChartView.swift @@ -66,7 +66,7 @@ public class BarChartView: BarLineChartViewBase, BarChartDataProvider return nil } - return self.highlighter?.getHighlight(x: Double(pt.x), y: Double(pt.y)) + return self.highlighter?.getHighlight(x: pt.x, y: pt.y) } /// - returns: the bounding box of the specified Entry in the specified DataSet. Returns null if the Entry could not be found in the charts data. diff --git a/Charts/Classes/Charts/BarLineChartViewBase.swift b/Charts/Classes/Charts/BarLineChartViewBase.swift index 803dfbc95d..6d92118779 100644 --- a/Charts/Classes/Charts/BarLineChartViewBase.swift +++ b/Charts/Classes/Charts/BarLineChartViewBase.swift @@ -1618,7 +1618,7 @@ public class BarLineChartViewBase: ChartViewBase, BarLineScatterCandleBubbleChar return nil } - return self.highlighter?.getHighlight(x: Double(pt.x), y: Double(pt.y)) + return self.highlighter?.getHighlight(x: pt.x, y: pt.y) } /// - returns: the x and y values in the chart at the given touch point diff --git a/Charts/Classes/Charts/ChartViewBase.swift b/Charts/Classes/Charts/ChartViewBase.swift index ad43c0e9d5..9b66050f28 100755 --- a/Charts/Classes/Charts/ChartViewBase.swift +++ b/Charts/Classes/Charts/ChartViewBase.swift @@ -448,6 +448,13 @@ public class ChartViewBase: NSUIView, ChartDataProvider, ChartAnimatorDelegate highlightValue(highlight: highlight, callDelegate: false) } + /// Highlights the value at the given x-index in the given DataSet. + /// Provide -1 as the x-index to undo all highlighting. + public func highlightValue(xIndex xIndex: Int, dataSetIndex: Int) + { + highlightValue(xIndex: xIndex, dataSetIndex: dataSetIndex, callDelegate: true) + } + /// Highlights the value at the given x-index in the given DataSet. /// Provide -1 as the x-index to undo all highlighting. public func highlightValue(xIndex xIndex: Int, dataSetIndex: Int, callDelegate: Bool) @@ -482,7 +489,9 @@ public class ChartViewBase: NSUIView, ChartDataProvider, ChartAnimatorDelegate { // set the indices to highlight entry = _data?.getEntryForHighlight(h!) - if (entry === nil || entry!.xIndex != h?.xIndex) + if (entry == nil || + entry?.xIndex != h?.xIndex || + (entry?.value != h!.value && !isnan(h!.value))) { h = nil entry = nil diff --git a/Charts/Classes/Charts/HorizontalBarChartView.swift b/Charts/Classes/Charts/HorizontalBarChartView.swift index 283d07f72c..56c868b8b2 100644 --- a/Charts/Classes/Charts/HorizontalBarChartView.swift +++ b/Charts/Classes/Charts/HorizontalBarChartView.swift @@ -157,7 +157,7 @@ public class HorizontalBarChartView: BarChartView return nil } - return self.highlighter?.getHighlight(x: Double(pt.y), y: Double(pt.x)) + return self.highlighter?.getHighlight(x: pt.y, y: pt.x) } public override var lowestVisibleXIndex: Int diff --git a/Charts/Classes/Charts/PieRadarChartViewBase.swift b/Charts/Classes/Charts/PieRadarChartViewBase.swift index 5eea92d73c..f0c13e3a92 100755 --- a/Charts/Classes/Charts/PieRadarChartViewBase.swift +++ b/Charts/Classes/Charts/PieRadarChartViewBase.swift @@ -897,7 +897,7 @@ public class PieRadarChartViewBase: ChartViewBase // get the dataset that is closest to the selection (PieChart only has one DataSet) if (self.isKindOfClass(RadarChartView)) { - dataSetIndex = ChartUtils.closestDataSetIndex(valsAtIndex, value: Double(distance / (self as! RadarChartView).factor), axis: nil) + dataSetIndex = ChartUtils.closestDataSetIndexByValue(valsAtIndex: valsAtIndex, value: Double(distance / (self as! RadarChartView).factor), axis: nil) ?? -1 } if (dataSetIndex < 0) diff --git a/Charts/Classes/Data/Implementations/ChartBaseDataSet.swift b/Charts/Classes/Data/Implementations/ChartBaseDataSet.swift index c5313e7c49..d6800dd98d 100644 --- a/Charts/Classes/Data/Implementations/ChartBaseDataSet.swift +++ b/Charts/Classes/Data/Implementations/ChartBaseDataSet.swift @@ -71,6 +71,11 @@ public class ChartBaseDataSet: NSObject, IChartDataSet fatalError("yValForXIndex is not implemented in ChartBaseDataSet") } + public func yValsForXIndex(x: Int) -> [Double] + { + fatalError("yValsForXIndex is not implemented in ChartBaseDataSet") + } + public func entryForIndex(i: Int) -> ChartDataEntry? { fatalError("entryForIndex is not implemented in ChartBaseDataSet") @@ -86,6 +91,11 @@ public class ChartBaseDataSet: NSObject, IChartDataSet fatalError("entryForXIndex is not implemented in ChartBaseDataSet") } + public func entriesForXIndex(x: Int) -> [ChartDataEntry] + { + fatalError("entriesForXIndex is not implemented in ChartBaseDataSet") + } + public func entryIndex(xIndex x: Int, rounding: ChartDataSetRounding) -> Int { fatalError("entryIndex is not implemented in ChartBaseDataSet") diff --git a/Charts/Classes/Data/Implementations/Standard/ChartData.swift b/Charts/Classes/Data/Implementations/Standard/ChartData.swift index 072437cf9b..bb08b8a56c 100644 --- a/Charts/Classes/Data/Implementations/Standard/ChartData.swift +++ b/Charts/Classes/Data/Implementations/Standard/ChartData.swift @@ -439,7 +439,18 @@ public class ChartData: NSObject } else { - return _dataSets[highlight.dataSetIndex].entryForXIndex(highlight.xIndex) + // The value of the highlighted entry could be NaN - if we are not interested in highlighting a specific value. + + let entries = _dataSets[highlight.dataSetIndex].entriesForXIndex(highlight.xIndex) + for e in entries + { + if e.value == highlight.value || isnan(highlight.value) + { + return e + } + } + + return nil } } diff --git a/Charts/Classes/Data/Implementations/Standard/ChartDataSet.swift b/Charts/Classes/Data/Implementations/Standard/ChartDataSet.swift index 03adda37f5..34e2aa3f1d 100644 --- a/Charts/Classes/Data/Implementations/Standard/ChartDataSet.swift +++ b/Charts/Classes/Data/Implementations/Standard/ChartDataSet.swift @@ -152,6 +152,20 @@ public class ChartDataSet: ChartBaseDataSet else { return Double.NaN } } + /// - returns: all of the y values of the Entry objects at the given xIndex. Returns NaN if no value is at the given x-index. + public override func yValsForXIndex(x: Int) -> [Double] + { + let entries = self.entriesForXIndex(x) + + var yVals = [Double]() + for e in entries + { + yVals.append(e.value) + } + + return yVals + } + /// - returns: the entry object found at the given index (not x-index!) /// - throws: out of bounds /// if `i` is out of bounds, it may throw an out-of-bounds exception @@ -181,7 +195,9 @@ public class ChartDataSet: ChartBaseDataSet return entryForXIndex(x, rounding: .Closest) } - public func entriesForXIndex(x: Int) -> [ChartDataEntry] + /// - returns: all Entry objects found at the given xIndex with binary search. + /// An empty array if no Entry object at that index. + public override func entriesForXIndex(x: Int) -> [ChartDataEntry] { var entries = [ChartDataEntry]() @@ -190,7 +206,7 @@ public class ChartDataSet: ChartBaseDataSet while (low <= high) { - var m = Int((high + low) / 2) + var m = (high + low) / 2 var entry = _yVals[m] if (x == entry.xIndex) @@ -215,15 +231,19 @@ public class ChartDataSet: ChartBaseDataSet m += 1 } - } - - if (x > _yVals[m].xIndex) - { - low = m + 1 + + break } else { - high = m - 1 + if (x > _yVals[m].xIndex) + { + low = m + 1 + } + else + { + high = m - 1 + } } } diff --git a/Charts/Classes/Data/Implementations/Standard/CombinedChartData.swift b/Charts/Classes/Data/Implementations/Standard/CombinedChartData.swift index 2b9723255b..de809172ce 100644 --- a/Charts/Classes/Data/Implementations/Standard/CombinedChartData.swift +++ b/Charts/Classes/Data/Implementations/Standard/CombinedChartData.swift @@ -177,7 +177,7 @@ public class CombinedChartData: BarLineScatterCandleBubbleChartData data.append(bubbleData) } - return data; + return data } public override func notifyDataChanged() @@ -205,4 +205,41 @@ public class CombinedChartData: BarLineScatterCandleBubbleChartData super.notifyDataChanged() // recalculate everything } + + + /// Get the Entry for a corresponding highlight object + /// + /// - parameter highlight: + /// - returns: the entry that is highlighted + public override func getEntryForHighlight(highlight: ChartHighlight) -> ChartDataEntry? + { + let dataObjects = allData + + if highlight.dataIndex >= dataObjects.count + { + return nil + } + + let data = dataObjects[highlight.dataIndex] + + if highlight.dataSetIndex >= data.dataSetCount + { + return nil + } + else + { + // The value of the highlighted entry could be NaN - if we are not interested in highlighting a specific value. + + let entries = data.getDataSetByIndex(highlight.dataSetIndex).entriesForXIndex(highlight.xIndex) + for e in entries + { + if e.value == highlight.value || isnan(highlight.value) + { + return e + } + } + + return nil + } + } } diff --git a/Charts/Classes/Data/Interfaces/IChartDataSet.swift b/Charts/Classes/Data/Interfaces/IChartDataSet.swift index c799c22dd9..b7f43f7d56 100644 --- a/Charts/Classes/Data/Interfaces/IChartDataSet.swift +++ b/Charts/Classes/Data/Interfaces/IChartDataSet.swift @@ -40,6 +40,9 @@ public protocol IChartDataSet /// - returns: the value of the Entry object at the given xIndex. Returns NaN if no value is at the given x-index. func yValForXIndex(x: Int) -> Double + /// - returns: all of the y values of the Entry objects at the given xIndex. Returns NaN if no value is at the given x-index. + func yValsForXIndex(x: Int) -> [Double] + /// - returns: the entry object found at the given index (not x-index!) /// - throws: out of bounds /// if `i` is out of bounds, it may throw an out-of-bounds exception @@ -55,6 +58,10 @@ public protocol IChartDataSet /// nil if no Entry object at that index. func entryForXIndex(x: Int) -> ChartDataEntry? + /// - returns: all Entry objects found at the given xIndex with binary search. + /// An empty array if no Entry object at that index. + func entriesForXIndex(x: Int) -> [ChartDataEntry] + /// - returns: the array-index of the specified entry /// /// - parameter x: x-index of the entry to search for diff --git a/Charts/Classes/Highlight/BarChartHighlighter.swift b/Charts/Classes/Highlight/BarChartHighlighter.swift index e4496bd375..84ee718a70 100644 --- a/Charts/Classes/Highlight/BarChartHighlighter.swift +++ b/Charts/Classes/Highlight/BarChartHighlighter.swift @@ -17,40 +17,55 @@ import CoreGraphics public class BarChartHighlighter: ChartHighlighter { - public override func getHighlight(x x: Double, y: Double) -> ChartHighlight? + public override func getHighlight(x x: CGFloat, y: CGFloat) -> ChartHighlight? { - let h = super.getHighlight(x: x, y: y) - - if h === nil - { - return h - } - else + if let barData = self.chart?.data as? BarChartData { - if let set = self.chart?.data?.getDataSetByIndex(h!.dataSetIndex) as? BarChartDataSet + let xIndex = getXIndex(x) + let baseNoSpace = getBase(x) + let setCount = barData.dataSetCount + var dataSetIndex = Int(baseNoSpace) % setCount + + if dataSetIndex < 0 { - if set.isStacked - { - // create an array of the touch-point - var pt = CGPoint() - pt.y = CGFloat(y) - - // take any transformer to determine the x-axis value - self.chart?.getTransformer(set.axisDependency).pixelToValue(&pt) - - return getStackedHighlight(old: h, set: set, xIndex: h!.xIndex, dataSetIndex: h!.dataSetIndex, yValue: Double(pt.y)) - } + dataSetIndex = 0 + } + else if dataSetIndex >= setCount + { + dataSetIndex = setCount - 1 + } + + guard let selectionDetail = getSelectionDetail(xIndex: xIndex, y: y, dataSetIndex: dataSetIndex) + else { return nil } + + if let set = barData.getDataSetByIndex(dataSetIndex) as? IBarChartDataSet + where set.isStacked + { + var pt = CGPoint(x: 0.0, y: y) + + // take any transformer to determine the x-axis value + self.chart?.getTransformer(set.axisDependency).pixelToValue(&pt) + + return getStackedHighlight(selectionDetail: selectionDetail, + set: set, + xIndex: xIndex, + yValue: Double(pt.y)) } - return h + return ChartHighlight(xIndex: xIndex, + value: selectionDetail.value, + dataIndex: selectionDetail.dataIndex, + dataSetIndex: selectionDetail.dataSetIndex, + stackIndex: -1) } + return nil } - public override func getXIndex(x: Double) -> Int + public override func getXIndex(x: CGFloat) -> Int { - if let barChartData = self.chart?.data as? BarChartData + if let barData = self.chart?.data as? BarChartData { - if !barChartData.isGrouped + if !barData.isGrouped { return super.getXIndex(x) } @@ -58,10 +73,10 @@ public class BarChartHighlighter: ChartHighlighter { let baseNoSpace = getBase(x) - let setCount = barChartData.dataSetCount + let setCount = barData.dataSetCount var xIndex = Int(baseNoSpace) / setCount - let valCount = barChartData.xValCount + let valCount = barData.xValCount if xIndex < 0 { @@ -81,62 +96,59 @@ public class BarChartHighlighter: ChartHighlighter } } - public override func getDataSetIndex(xIndex xIndex: Int, x: Double, y: Double) -> Int + public override func getSelectionDetail(xIndex xIndex: Int, y: CGFloat, dataSetIndex: Int?) -> ChartSelectionDetail? { - if let barChartData = self.chart?.data as? BarChartData + if let barData = self.chart?.data as? BarChartData { - if !barChartData.isGrouped - { - return 0 - } - else - { - let baseNoSpace = getBase(x) - - let setCount = barChartData.dataSetCount - var dataSetIndex = Int(baseNoSpace) % setCount - - if dataSetIndex < 0 - { - dataSetIndex = 0 - } - else if dataSetIndex >= setCount - { - dataSetIndex = setCount - 1 - } - - return dataSetIndex - } + let dataSetIndex = dataSetIndex ?? 0 + let dataSet = barData.dataSetCount > dataSetIndex ? barData.getDataSetByIndex(dataSetIndex) : nil + let yValue = dataSet.yValForXIndex(xIndex) + + if isnan(yValue) { return nil } + + return ChartSelectionDetail(value: yValue, dataSetIndex: dataSetIndex, dataSet: dataSet) } else { - return 0 + return nil } } /// This method creates the Highlight object that also indicates which value of a stacked BarEntry has been selected. - /// - parameter old: the old highlight object before looking for stacked values + /// - parameter selectionDetail: the selection detail to work with /// - parameter set: /// - parameter xIndex: - /// - parameter dataSetIndex: /// - parameter yValue: /// - returns: - public func getStackedHighlight(old old: ChartHighlight?, set: BarChartDataSet, xIndex: Int, dataSetIndex: Int, yValue: Double) -> ChartHighlight? + public func getStackedHighlight(selectionDetail selectionDetail: ChartSelectionDetail, + set: IBarChartDataSet, + xIndex: Int, + yValue: Double) -> ChartHighlight? { - let entry = set.entryForXIndex(xIndex) as? BarChartDataEntry + guard let entry = set.entryForXIndex(xIndex) as? BarChartDataEntry + else { return nil } - if entry?.values === nil + if entry.values == nil { - return old + return ChartHighlight(xIndex: xIndex, + value: entry.value, + dataIndex: selectionDetail.dataIndex, + dataSetIndex: selectionDetail.dataSetIndex, + stackIndex: -1) } - if let ranges = getRanges(entry: entry!) + if let ranges = getRanges(entry: entry) where ranges.count > 0 { let stackIndex = getClosestStackIndex(ranges: ranges, value: yValue) - let h = ChartHighlight(xIndex: xIndex, dataSetIndex: dataSetIndex, stackIndex: stackIndex, range: ranges[stackIndex]) - return h + return ChartHighlight(xIndex: xIndex, + value: entry.positiveSum - entry.negativeSum, + dataIndex: selectionDetail.dataIndex, + dataSetIndex: selectionDetail.dataSetIndex, + stackIndex: stackIndex, + range: ranges[stackIndex]) } + return nil } @@ -173,33 +185,29 @@ public class BarChartHighlighter: ChartHighlighter /// Returns the base x-value to the corresponding x-touch value in pixels. /// - parameter x: /// - returns: - public func getBase(x: Double) -> Double + public func getBase(x: CGFloat) -> Double { - if let barChartData = self.chart?.data as? BarChartData - { - // create an array of the touch-point - var pt = CGPoint() - pt.x = CGFloat(x) - - // take any transformer to determine the x-axis value - self.chart?.getTransformer(ChartYAxis.AxisDependency.Left).pixelToValue(&pt) - let xVal = Double(pt.x) - - let setCount = barChartData.dataSetCount ?? 0 - - // calculate how often the group-space appears - let steps = Int(xVal / (Double(setCount) + Double(barChartData.groupSpace))) - - let groupSpaceSum = Double(barChartData.groupSpace) * Double(steps) - - let baseNoSpace = xVal - groupSpaceSum - - return baseNoSpace - } - else - { - return 0.0 - } + guard let barData = self.chart?.data as? BarChartData + else { return 0.0 } + + // create an array of the touch-point + var pt = CGPoint() + pt.x = CGFloat(x) + + // take any transformer to determine the x-axis value + self.chart?.getTransformer(ChartYAxis.AxisDependency.Left).pixelToValue(&pt) + let xVal = Double(pt.x) + + let setCount = barData.dataSetCount ?? 0 + + // calculate how often the group-space appears + let steps = Int(xVal / (Double(setCount) + Double(barData.groupSpace))) + + let groupSpaceSum = Double(barData.groupSpace) * Double(steps) + + let baseNoSpace = xVal - groupSpaceSum + + return baseNoSpace } /// Splits up the stack-values of the given bar-entry into Range objects. diff --git a/Charts/Classes/Highlight/ChartHighlight.swift b/Charts/Classes/Highlight/ChartHighlight.swift index 1417d86939..9ea695d519 100644 --- a/Charts/Classes/Highlight/ChartHighlight.swift +++ b/Charts/Classes/Highlight/ChartHighlight.swift @@ -19,6 +19,12 @@ public class ChartHighlight: NSObject /// the x-index of the highlighted value private var _xIndex = Int(0) + /// the y-value of the highlighted value + private var _value = Double.NaN + + /// the index of the data object - in case it refers to more than one + private var _dataIndex = Int(0) + /// the index of the dataset the highlighted value is in private var _dataSetIndex = Int(0) @@ -35,39 +41,74 @@ public class ChartHighlight: NSObject super.init() } - public init(xIndex x: Int, dataSetIndex: Int) + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter value: the y-value of the highlighted value + /// - parameter dataIndex: the index of the Data the highlighted value belongs to + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to + /// - parameter stackIndex: references which value of a stacked-bar entry has been selected + /// - parameter range: the range the selected stack-value is in + public init(xIndex x: Int, value: Double, dataIndex: Int, dataSetIndex: Int, stackIndex: Int, range: ChartRange?) { super.init() _xIndex = x + _value = value + _dataIndex = dataIndex _dataSetIndex = dataSetIndex + _stackIndex = stackIndex + _range = range } - public init(xIndex x: Int, dataSetIndex: Int, stackIndex: Int) + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter value: the y-value of the highlighted value + /// - parameter dataIndex: the index of the Data the highlighted value belongs to + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to + /// - parameter stackIndex: references which value of a stacked-bar entry has been selected + public convenience init(xIndex x: Int, value: Double, dataIndex: Int, dataSetIndex: Int, stackIndex: Int) { - super.init() - - _xIndex = x - _dataSetIndex = dataSetIndex - _stackIndex = stackIndex + self.init(xIndex: x, value: value, dataIndex: dataIndex, dataSetIndex: dataSetIndex, stackIndex: stackIndex, range: nil) } - /// Constructor, only used for stacked-barchart. - /// - /// - parameter x: the index of the highlighted value on the x-axis - /// - parameter dataSet: the index of the DataSet the highlighted value belongs to + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter value: the y-value of the highlighted value + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to /// - parameter stackIndex: references which value of a stacked-bar entry has been selected /// - parameter range: the range the selected stack-value is in - public convenience init(xIndex x: Int, dataSetIndex: Int, stackIndex: Int, range: ChartRange) + public convenience init(xIndex x: Int, value: Double, dataSetIndex: Int, stackIndex: Int, range: ChartRange?) { - self.init(xIndex: x, dataSetIndex: dataSetIndex, stackIndex: stackIndex) - - _range = range + self.init(xIndex: x, value: value, dataIndex: 0, dataSetIndex: dataSetIndex, stackIndex: stackIndex, range: range) } - - public var dataSetIndex: Int { return _dataSetIndex; } - public var xIndex: Int { return _xIndex; } - public var stackIndex: Int { return _stackIndex; } + + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter value: the y-value of the highlighted value + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to + /// - parameter stackIndex: references which value of a stacked-bar entry has been selected + /// - parameter range: the range the selected stack-value is in + public convenience init(xIndex x: Int, value: Double, dataSetIndex: Int, stackIndex: Int) + { + self.init(xIndex: x, value: value, dataIndex: 0, dataSetIndex: dataSetIndex, stackIndex: stackIndex, range: nil) + } + + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to + /// - parameter stackIndex: references which value of a stacked-bar entry has been selected + public convenience init(xIndex x: Int, dataSetIndex: Int, stackIndex: Int) + { + self.init(xIndex: x, value: Double.NaN, dataSetIndex: dataSetIndex, stackIndex: stackIndex, range: nil) + } + + /// - parameter xIndex: the index of the highlighted value on the x-axis + /// - parameter dataSetIndex: the index of the DataSet the highlighted value belongs to + public convenience init(xIndex x: Int, dataSetIndex: Int) + { + self.init(xIndex: x, value: Double.NaN, dataSetIndex: dataSetIndex, stackIndex: -1, range: nil) + } + + public var xIndex: Int { return _xIndex } + public var value: Double { return _value } + public var dataIndex: Int { return _dataIndex } + public var dataSetIndex: Int { return _dataSetIndex } + public var stackIndex: Int { return _stackIndex } /// - returns: the range of values the selected value of a stacked bar is in. (this is only relevant for stacked-barchart) public var range: ChartRange? { return _range } @@ -76,7 +117,7 @@ public class ChartHighlight: NSObject public override var description: String { - return "Highlight, xIndex: \(_xIndex), dataSetIndex: \(_dataSetIndex), stackIndex (only stacked barentry): \(_stackIndex)" + return "Highlight, xIndex: \(_xIndex), dataIndex (combined charts): \(_dataIndex),dataSetIndex: \(_dataSetIndex), stackIndex (only stacked barentry): \(_stackIndex), value: \(_value)" } public override func isEqual(object: AnyObject?) -> Bool @@ -96,6 +137,11 @@ public class ChartHighlight: NSObject return false } + if (object!.dataIndex != dataIndex) + { + return false + } + if (object!.dataSetIndex != _dataSetIndex) { return false @@ -106,6 +152,11 @@ public class ChartHighlight: NSObject return false } + if (object!.value != value) + { + return false + } + return true } } @@ -127,6 +178,11 @@ func ==(lhs: ChartHighlight, rhs: ChartHighlight) -> Bool return false } + if (lhs._dataIndex != rhs._dataIndex) + { + return false + } + if (lhs._dataSetIndex != rhs._dataSetIndex) { return false @@ -137,5 +193,10 @@ func ==(lhs: ChartHighlight, rhs: ChartHighlight) -> Bool return false } + if (lhs._value != rhs._value) + { + return false + } + return true } \ No newline at end of file diff --git a/Charts/Classes/Highlight/ChartHighlighter.swift b/Charts/Classes/Highlight/ChartHighlighter.swift index e02c4c4da5..ae24e0d73b 100644 --- a/Charts/Classes/Highlight/ChartHighlighter.swift +++ b/Charts/Classes/Highlight/ChartHighlighter.swift @@ -29,27 +29,21 @@ public class ChartHighlighter : NSObject /// - parameter x: /// - parameter y: /// - returns: - public func getHighlight(x x: Double, y: Double) -> ChartHighlight? + public func getHighlight(x x: CGFloat, y: CGFloat) -> ChartHighlight? { let xIndex = getXIndex(x) - if (xIndex == -Int.max) - { - return nil - } - let dataSetIndex = getDataSetIndex(xIndex: xIndex, x: x, y: y) - if (dataSetIndex == -Int.max) - { - return nil - } + guard let + selectionDetail = getSelectionDetail(xIndex: xIndex, y: y, dataSetIndex: nil) + else { return nil } - return ChartHighlight(xIndex: xIndex, dataSetIndex: dataSetIndex) + return ChartHighlight(xIndex: xIndex, value: selectionDetail.value, dataIndex: selectionDetail.dataIndex, dataSetIndex: selectionDetail.dataSetIndex, stackIndex: -1) } /// Returns the corresponding x-index for a given touch-position in pixels. /// - parameter x: /// - returns: - public func getXIndex(x: Double) -> Int + public func getXIndex(x: CGFloat) -> Int { // create an array of the touch-point var pt = CGPoint(x: x, y: 0.0) @@ -60,57 +54,65 @@ public class ChartHighlighter : NSObject return Int(round(pt.x)) } - /// Returns the corresponding dataset-index for a given xIndex and xy-touch position in pixels. + /// Returns the corresponding ChartSelectionDetail for a given xIndex and y-touch position in pixels. /// - parameter xIndex: - /// - parameter x: /// - parameter y: + /// - parameter dataSetIndex: A dataset index to look at - or nil, to figure that out automatically /// - returns: - public func getDataSetIndex(xIndex xIndex: Int, x: Double, y: Double) -> Int + public func getSelectionDetail(xIndex xIndex: Int, y: CGFloat, dataSetIndex: Int?) -> ChartSelectionDetail? { - let valsAtIndex = getSelectionDetailsAtIndex(xIndex) + let valsAtIndex = getSelectionDetailsAtIndex(xIndex, dataSetIndex: dataSetIndex) - let leftdist = ChartUtils.getMinimumDistance(valsAtIndex, val: y, axis: ChartYAxis.AxisDependency.Left) - let rightdist = ChartUtils.getMinimumDistance(valsAtIndex, val: y, axis: ChartYAxis.AxisDependency.Right) + let leftdist = ChartUtils.getMinimumDistance(valsAtIndex, y: y, axis: ChartYAxis.AxisDependency.Left) + let rightdist = ChartUtils.getMinimumDistance(valsAtIndex, y: y, axis: ChartYAxis.AxisDependency.Right) let axis = leftdist < rightdist ? ChartYAxis.AxisDependency.Left : ChartYAxis.AxisDependency.Right - let dataSetIndex = ChartUtils.closestDataSetIndex(valsAtIndex, value: y, axis: axis) + let detail = ChartUtils.closestSelectionDetailByPixelY(valsAtIndex: valsAtIndex, y: y, axis: axis) - return dataSetIndex + return detail } /// Returns a list of SelectionDetail object corresponding to the given xIndex. /// - parameter xIndex: + /// - parameter dataSetIndex: A dataset index to look at - or nil, to figure that out automatically /// - returns: - public func getSelectionDetailsAtIndex(xIndex: Int) -> [ChartSelectionDetail] + public func getSelectionDetailsAtIndex(xIndex: Int, dataSetIndex: Int?) -> [ChartSelectionDetail] { var vals = [ChartSelectionDetail]() var pt = CGPoint() - for i in 0 ..< (self.chart?.data?.dataSetCount ?? 0) + guard let + data = self.chart?.data + else { return vals } + + for i in 0 ..< data.dataSetCount { - let dataSet = self.chart!.data!.getDataSetByIndex(i) - - // dont include datasets that cannot be highlighted - if !dataSet.isHighlightEnabled + if dataSetIndex != nil && dataSetIndex != i { continue } - // extract all y-values from all DataSets at the given x-index - let yVal: Double = dataSet.yValForXIndex(xIndex) - if yVal.isNaN + let dataSet = data.getDataSetByIndex(i) + + // dont include datasets that cannot be highlighted + if !dataSet.isHighlightEnabled { continue } - pt.y = CGFloat(yVal) - - self.chart!.getTransformer(dataSet.axisDependency).pointValueToPixel(&pt) - - if !pt.y.isNaN + // extract all y-values from all DataSets at the given x-index + let yVals: [Double] = dataSet.yValsForXIndex(xIndex) + for yVal in yVals { - vals.append(ChartSelectionDetail(value: Double(pt.y), dataSetIndex: i, dataSet: dataSet)) + pt.y = CGFloat(yVal) + + self.chart!.getTransformer(dataSet.axisDependency).pointValueToPixel(&pt) + + if !pt.y.isNaN + { + vals.append(ChartSelectionDetail(y: pt.y, value: yVal, dataSetIndex: i, dataSet: dataSet)) + } } } diff --git a/Charts/Classes/Highlight/CombinedHighlighter.swift b/Charts/Classes/Highlight/CombinedHighlighter.swift index 658e298cd5..68a3f9499f 100644 --- a/Charts/Classes/Highlight/CombinedHighlighter.swift +++ b/Charts/Classes/Highlight/CombinedHighlighter.swift @@ -20,43 +20,43 @@ public class CombinedHighlighter: ChartHighlighter /// Returns a list of SelectionDetail object corresponding to the given xIndex. /// - parameter xIndex: /// - returns: - public override func getSelectionDetailsAtIndex(xIndex: Int) -> [ChartSelectionDetail] + public override func getSelectionDetailsAtIndex(xIndex: Int, dataSetIndex: Int?) -> [ChartSelectionDetail] { var vals = [ChartSelectionDetail]() + var pt = CGPoint() - if let data = self.chart?.data as? CombinedChartData + guard let + data = self.chart?.data as? CombinedChartData + else { return vals } + + // get all chartdata objects + var dataObjects = data.allData + + for i in 0 ..< dataObjects.count { - // get all chartdata objects - var dataObjects = data.allData - - var pt = CGPoint() - - for i in 0 ..< dataObjects.count + for j in 0 ..< dataObjects[i].dataSetCount { - for j in 0 ..< dataObjects[i].dataSetCount + let dataSet = dataObjects[i].getDataSetByIndex(j) + + // dont include datasets that cannot be highlighted + if !dataSet.isHighlightEnabled + { + continue + } + + // extract all y-values from all DataSets at the given x-index + let yVals: [Double] = dataSet.yValsForXIndex(xIndex) + for yVal in yVals { - let dataSet = dataObjects[i].getDataSetByIndex(j) - - // dont include datasets that cannot be highlighted - if !dataSet.isHighlightEnabled - { - continue - } - - // extract all y-values from all DataSets at the given x-index - let yVal = dataSet.yValForXIndex(xIndex) - if yVal.isNaN - { - continue - } - pt.y = CGFloat(yVal) - self.chart!.getTransformer(dataSet.axisDependency).pointValueToPixel(&pt) + self.chart! + .getTransformer(dataSet.axisDependency) + .pointValueToPixel(&pt) if !pt.y.isNaN { - vals.append(ChartSelectionDetail(value: Double(pt.y), dataSetIndex: j, dataSet: dataSet)) + vals.append(ChartSelectionDetail(y: pt.y, value: yVal, dataIndex: i, dataSetIndex: j, dataSet: dataSet)) } } } diff --git a/Charts/Classes/Highlight/HorizontalBarChartHighlighter.swift b/Charts/Classes/Highlight/HorizontalBarChartHighlighter.swift index 5103ba32cf..7f63b29f24 100644 --- a/Charts/Classes/Highlight/HorizontalBarChartHighlighter.swift +++ b/Charts/Classes/Highlight/HorizontalBarChartHighlighter.swift @@ -17,82 +17,75 @@ import CoreGraphics public class HorizontalBarChartHighlighter: BarChartHighlighter { - public override func getHighlight(x x: Double, y: Double) -> ChartHighlight? + public override func getHighlight(x x: CGFloat, y: CGFloat) -> ChartHighlight? { - let h = super.getHighlight(x: x, y: y) - - if h === nil + if let barData = self.chart?.data as? BarChartData { - return h - } - else - { - if let set = self.chart?.data?.getDataSetByIndex(h!.dataSetIndex) as? BarChartDataSet + let xIndex = getXIndex(x) + let baseNoSpace = getBase(x) + let setCount = barData.dataSetCount + var dataSetIndex = Int(baseNoSpace) % setCount + + if dataSetIndex < 0 { - if set.isStacked - { - // create an array of the touch-point - var pt = CGPoint() - pt.x = CGFloat(y) - - // take any transformer to determine the x-axis value - self.chart?.getTransformer(set.axisDependency).pixelToValue(&pt) - - return getStackedHighlight(old: h, set: set, xIndex: h!.xIndex, dataSetIndex: h!.dataSetIndex, yValue: Double(pt.x)) - } + dataSetIndex = 0 } - - return h - } - } - - public override func getXIndex(x: Double) -> Int - { - if let barChartData = self.chart?.data as? BarChartData - { - if !barChartData.isGrouped + else if dataSetIndex >= setCount { - // create an array of the touch-point - var pt = CGPoint(x: 0.0, y: x) - - // take any transformer to determine the x-axis value - self.chart?.getTransformer(ChartYAxis.AxisDependency.Left).pixelToValue(&pt) - - return Int(round(pt.y)) + dataSetIndex = setCount - 1 } - else + + guard let selectionDetail = getSelectionDetail(xIndex: xIndex, y: y, dataSetIndex: dataSetIndex) + else { return nil } + + if let set = barData.getDataSetByIndex(dataSetIndex) as? IBarChartDataSet + where set.isStacked { - let baseNoSpace = getBase(x) + var pt = CGPoint(x: y, y: 0.0) - let setCount = barChartData.dataSetCount - var xIndex = Int(baseNoSpace) / setCount - - let valCount = barChartData.xValCount - - if xIndex < 0 - { - xIndex = 0 - } - else if xIndex >= valCount - { - xIndex = valCount - 1 - } + // take any transformer to determine the x-axis value + self.chart?.getTransformer(set.axisDependency).pixelToValue(&pt) - return xIndex + return getStackedHighlight(selectionDetail: selectionDetail, + set: set, + xIndex: xIndex, + yValue: Double(pt.x)) } + + return ChartHighlight(xIndex: xIndex, + value: selectionDetail.value, + dataIndex: selectionDetail.dataIndex, + dataSetIndex: selectionDetail.dataSetIndex, + stackIndex: -1) + } + return nil + } + + public override func getXIndex(x: CGFloat) -> Int + { + if let barData = self.chart?.data as? BarChartData + where !barData.isGrouped + { + // create an array of the touch-point + var pt = CGPoint(x: 0.0, y: x) + + // take any transformer to determine the x-axis value + self.chart?.getTransformer(ChartYAxis.AxisDependency.Left).pixelToValue(&pt) + + return Int(round(pt.y)) } else { - return 0 + return getXIndex(x) } } /// Returns the base y-value to the corresponding x-touch value in pixels. /// - parameter y: /// - returns: - public override func getBase(y: Double) -> Double + public override func getBase(y: CGFloat) -> Double { - if let barChartData = self.chart?.data as? BarChartData + if let barData = self.chart?.data as? BarChartData { // create an array of the touch-point var pt = CGPoint() @@ -102,12 +95,12 @@ public class HorizontalBarChartHighlighter: BarChartHighlighter self.chart?.getTransformer(ChartYAxis.AxisDependency.Left).pixelToValue(&pt) let yVal = Double(pt.y) - let setCount = barChartData.dataSetCount ?? 0 + let setCount = barData.dataSetCount ?? 0 // calculate how often the group-space appears - let steps = Int(yVal / (Double(setCount) + Double(barChartData.groupSpace))) + let steps = Int(yVal / (Double(setCount) + Double(barData.groupSpace))) - let groupSpaceSum = Double(barChartData.groupSpace) * Double(steps) + let groupSpaceSum = Double(barData.groupSpace) * Double(steps) let baseNoSpace = yVal - groupSpaceSum diff --git a/Charts/Classes/Renderers/BubbleChartRenderer.swift b/Charts/Classes/Renderers/BubbleChartRenderer.swift index 7013db9980..7679100661 100644 --- a/Charts/Classes/Renderers/BubbleChartRenderer.swift +++ b/Charts/Classes/Renderers/BubbleChartRenderer.swift @@ -241,12 +241,14 @@ public class BubbleChartRenderer: ChartDataRendererBase for indice in indices { - guard let dataSet = bubbleData.getDataSetByIndex(indice.dataSetIndex) as? IBubbleChartDataSet else { continue } + guard let dataSet = bubbleData.getDataSetByIndex(indice.dataSetIndex) as? IBubbleChartDataSet + where dataSet.isHighlightEnabled + else { continue } - if (!dataSet.isHighlightEnabled) - { - continue - } + guard let + entry = bubbleData.getEntryForHighlight(indice) as? BubbleChartDataEntry + where entry.xIndex == indice.xIndex + else { continue } let entryFrom = dataSet.entryForXIndex(self.minX) let entryTo = dataSet.entryForXIndex(self.maxX) @@ -254,12 +256,6 @@ public class BubbleChartRenderer: ChartDataRendererBase let minx = max(dataSet.entryIndex(entry: entryFrom!), 0) let maxx = min(dataSet.entryIndex(entry: entryTo!) + 1, dataSet.entryCount) - let entry: BubbleChartDataEntry! = bubbleData.getEntryForHighlight(indice) as! BubbleChartDataEntry - if (entry === nil || entry.xIndex != indice.xIndex) - { - continue - } - let trans = dataProvider.getTransformer(dataSet.axisDependency) _sizeBuffer[0].x = 0.0 diff --git a/Charts/Classes/Renderers/CombinedChartRenderer.swift b/Charts/Classes/Renderers/CombinedChartRenderer.swift index 6cf5416a51..ae8fd16817 100644 --- a/Charts/Classes/Renderers/CombinedChartRenderer.swift +++ b/Charts/Classes/Renderers/CombinedChartRenderer.swift @@ -121,7 +121,34 @@ public class CombinedChartRenderer: ChartDataRendererBase { for renderer in _renderers { - renderer.drawHighlighted(context: context, indices: indices) + var data: ChartData? + + if renderer is BarChartRenderer + { + data = (renderer as! BarChartRenderer).dataProvider?.barData + } + else if renderer is LineChartRenderer + { + data = (renderer as! LineChartRenderer).dataProvider?.lineData + } + else if renderer is CandleStickChartRenderer + { + data = (renderer as! CandleStickChartRenderer).dataProvider?.candleData + } + else if renderer is ScatterChartRenderer + { + data = (renderer as! ScatterChartRenderer).dataProvider?.scatterData + } + else if renderer is BubbleChartRenderer + { + data = (renderer as! BubbleChartRenderer).dataProvider?.bubbleData + } + + let dataIndex = data == nil ? nil : (chart?.data as? CombinedChartData)?.allData.indexOf(data!) + + let dataIndices = indices.filter{ $0.dataIndex == dataIndex } + + renderer.drawHighlighted(context: context, indices: dataIndices) } } diff --git a/Charts/Classes/Utils/ChartSelectionDetail.swift b/Charts/Classes/Utils/ChartSelectionDetail.swift index a2bd4832d2..4682468e51 100644 --- a/Charts/Classes/Utils/ChartSelectionDetail.swift +++ b/Charts/Classes/Utils/ChartSelectionDetail.swift @@ -16,7 +16,9 @@ import Foundation public class ChartSelectionDetail: NSObject { + private var _y = CGFloat.NaN private var _value = Double(0) + private var _dataIndex = Int(0) private var _dataSetIndex = Int(0) private var _dataSet: IChartDataSet! @@ -25,20 +27,42 @@ public class ChartSelectionDetail: NSObject super.init() } - public init(value: Double, dataSetIndex: Int, dataSet: IChartDataSet) + public init(y: CGFloat, value: Double, dataIndex: Int, dataSetIndex: Int, dataSet: IChartDataSet) { super.init() + _y = y _value = value + _dataIndex = dataIndex _dataSetIndex = dataSetIndex _dataSet = dataSet } + public convenience init(y: CGFloat, value: Double, dataSetIndex: Int, dataSet: IChartDataSet) + { + self.init(y: y, value: value, dataIndex: 0, dataSetIndex: dataSetIndex, dataSet: dataSet) + } + + public convenience init(value: Double, dataSetIndex: Int, dataSet: IChartDataSet) + { + self.init(y: CGFloat.NaN, value: value, dataIndex: 0, dataSetIndex: dataSetIndex, dataSet: dataSet) + } + + public var y: CGFloat + { + return _y + } + public var value: Double { return _value } + public var dataIndex: Int + { + return _dataIndex + } + public var dataSetIndex: Int { return _dataSetIndex diff --git a/Charts/Classes/Utils/ChartUtils.swift b/Charts/Classes/Utils/ChartUtils.swift index 7036ce4007..8cc191f0d9 100755 --- a/Charts/Classes/Utils/ChartUtils.swift +++ b/Charts/Classes/Utils/ChartUtils.swift @@ -67,12 +67,60 @@ public class ChartUtils return number + DBL_EPSILON } } - - /// - returns: the index of the DataSet that contains the closest value on the y-axis. This will return -Integer.MAX_VALUE if failure. - internal class func closestDataSetIndex(valsAtIndex: [ChartSelectionDetail], value: Double, axis: ChartYAxis.AxisDependency?) -> Int + + /// - returns: the index of the DataSet that contains the closest value on the y-axis + internal class func closestDataSetIndexByPixelY( + valsAtIndex valsAtIndex: [ChartSelectionDetail], + y: CGFloat, + axis: ChartYAxis.AxisDependency?) -> Int? + { + return closestSelectionDetailByPixelY(valsAtIndex: valsAtIndex, y: y, axis: axis)?.dataSetIndex + } + + /// - returns: the index of the DataSet that contains the closest value on the y-axis + internal class func closestDataSetIndexByValue( + valsAtIndex valsAtIndex: [ChartSelectionDetail], + value: Double, + axis: ChartYAxis.AxisDependency?) -> Int? + { + return closestSelectionDetailByValue(valsAtIndex: valsAtIndex, value: value, axis: axis)?.dataSetIndex + } + + /// - returns: the `ChartSelectionDetail` of the closest value on the y-axis + internal class func closestSelectionDetailByPixelY( + valsAtIndex valsAtIndex: [ChartSelectionDetail], + y: CGFloat, + axis: ChartYAxis.AxisDependency?) -> ChartSelectionDetail? + { + var distance = CGFloat.max + var detail: ChartSelectionDetail? + + for i in 0 ..< valsAtIndex.count + { + let sel = valsAtIndex[i] + + if (axis == nil || sel.dataSet?.axisDependency == axis) + { + let cdistance = abs(sel.y - y) + if (cdistance < distance) + { + detail = sel + distance = cdistance + } + } + } + + return detail + } + + /// - returns: the `ChartSelectionDetail` of the closest value on the y-axis + internal class func closestSelectionDetailByValue( + valsAtIndex valsAtIndex: [ChartSelectionDetail], + value: Double, + axis: ChartYAxis.AxisDependency?) -> ChartSelectionDetail? { - var index = -Int.max var distance = DBL_MAX + var detail: ChartSelectionDetail? for i in 0 ..< valsAtIndex.count { @@ -83,19 +131,22 @@ public class ChartUtils let cdistance = abs(sel.value - value) if (cdistance < distance) { - index = valsAtIndex[i].dataSetIndex + detail = sel distance = cdistance } } } - return index + return detail } /// - returns: the minimum distance from a touch-y-value (in pixels) to the closest y-value (in pixels) that is displayed in the chart. - internal class func getMinimumDistance(valsAtIndex: [ChartSelectionDetail], val: Double, axis: ChartYAxis.AxisDependency) -> Double + internal class func getMinimumDistance( + valsAtIndex: [ChartSelectionDetail], + y: CGFloat, + axis: ChartYAxis.AxisDependency) -> CGFloat { - var distance = DBL_MAX + var distance = CGFloat.max for i in 0 ..< valsAtIndex.count { @@ -103,7 +154,7 @@ public class ChartUtils if (sel.dataSet!.axisDependency == axis) { - let cdistance = abs(sel.value - val) + let cdistance = abs(sel.y - y) if (cdistance < distance) { distance = cdistance diff --git a/ChartsRealm/Classes/Data/RealmBaseDataSet.swift b/ChartsRealm/Classes/Data/RealmBaseDataSet.swift index abe7a3fab7..2357392365 100644 --- a/ChartsRealm/Classes/Data/RealmBaseDataSet.swift +++ b/ChartsRealm/Classes/Data/RealmBaseDataSet.swift @@ -294,6 +294,20 @@ public class RealmBaseDataSet: ChartBaseDataSet else { return Double.NaN } } + /// - returns: all of the y values of the Entry objects at the given xIndex. Returns NaN if no value is at the given x-index. + public override func yValsForXIndex(x: Int) -> [Double] + { + let entries = self.entriesForXIndex(x) + + var yVals = [Double]() + for e in entries + { + yVals.append(e.value) + } + + return yVals + } + /// - returns: the entry object found at the given index (not x-index!) /// - throws: out of bounds /// if `i` is out of bounds, it may throw an out-of-bounds exception @@ -327,6 +341,36 @@ public class RealmBaseDataSet: ChartBaseDataSet return entryForXIndex(x, rounding: .Closest) } + /// - returns: all Entry objects found at the given xIndex with binary search. + /// An empty array if no Entry object at that index. + public override func entriesForXIndex(x: Int) -> [ChartDataEntry] + { + var entries = [ChartDataEntry]() + + guard let results = _results else { return entries } + + if _xIndexField == nil + { + if results.count > UInt(x) + { + entries.append(buildEntryFromResultObject(results.objectAtIndex(UInt(x)), atIndex: UInt(x))) + } + } + else + { + let foundObjects = results.objectsWithPredicate( + NSPredicate(format: "%K == %d", _xIndexField!, x) + ) + + for e in foundObjects + { + entries.append(buildEntryFromResultObject(e as! RLMObject, atIndex: UInt(x))) + } + } + + return entries + } + /// - returns: the array-index of the specified entry /// /// - parameter x: x-index of the entry to search for