From d4805e4d7452791adb356bc5116f203d0ead4c68 Mon Sep 17 00:00:00 2001 From: Charles Anderson Date: Wed, 19 Oct 2016 08:15:03 -0400 Subject: [PATCH 1/3] Implement Horizontal Bar Chart. This includes the basics of setting a ColumnChartData as "horizontal", automatic reorientation of the axes to properly reflect that the X-Axis becomes vertical, and the Y-Axis becomes horizontal in this style of chart. It also auto-reverses the vertical axis values to start from the top. Bumped both the VERSION_NAME and VERSION_CODE to reflect the changes, though none of these are breaking changes with existing versions. Gradle versions were bumped to be compatible with the latest version of Android Studio. --- build.gradle | 2 +- gradle.properties | 4 +- gradle/wrapper/gradle-wrapper.properties | 4 +- hellocharts-library/build.gradle | 2 +- .../src/lecho/lib/hellocharts/model/Axis.java | 26 ++++ .../hellocharts/model/ColumnChartData.java | 51 +++++++ .../hellocharts/renderer/AxesRenderer.java | 16 ++- .../renderer/ColumnChartRenderer.java | 134 +++++++++++------- .../lib/hellocharts/view/ColumnChartView.java | 2 +- 9 files changed, 182 insertions(+), 59 deletions(-) diff --git a/build.gradle b/build.gradle index b4d37b7b..a17d2fa4 100644 --- a/build.gradle +++ b/build.gradle @@ -4,6 +4,6 @@ buildscript { mavenCentral() } dependencies { - classpath 'com.android.tools.build:gradle:2.1.0' + classpath 'com.android.tools.build:gradle:2.2.1' } } diff --git a/gradle.properties b/gradle.properties index 5a92b125..f155df88 100644 --- a/gradle.properties +++ b/gradle.properties @@ -1,5 +1,5 @@ -VERSION_NAME=1.5.8 -VERSION_CODE=13 +VERSION_NAME=1.5.9 +VERSION_CODE=14 GROUP=com.github.lecho POM_DESCRIPTION=Charting library for Android compatible with API 8+(Android 2.2). diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties index 0c44860e..02653dce 100644 --- a/gradle/wrapper/gradle-wrapper.properties +++ b/gradle/wrapper/gradle-wrapper.properties @@ -1,6 +1,6 @@ -#Wed Apr 10 15:27:10 PDT 2013 +#Tue Oct 18 14:18:39 EDT 2016 distributionBase=GRADLE_USER_HOME distributionPath=wrapper/dists zipStoreBase=GRADLE_USER_HOME zipStorePath=wrapper/dists -distributionUrl=http\://services.gradle.org/distributions/gradle-2.2.1-all.zip +distributionUrl=https\://services.gradle.org/distributions/gradle-2.14.1-all.zip diff --git a/hellocharts-library/build.gradle b/hellocharts-library/build.gradle index acd91eac..b8b46fc6 100644 --- a/hellocharts-library/build.gradle +++ b/hellocharts-library/build.gradle @@ -11,7 +11,7 @@ buildscript { mavenCentral() } dependencies { - classpath 'com.android.tools.build:gradle:2.1.0' + classpath 'com.android.tools.build:gradle:2.2.1' } } diff --git a/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java b/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java index e4d3ef95..e46be98c 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java @@ -4,6 +4,7 @@ import android.graphics.Typeface; import java.util.ArrayList; +import java.util.Collections; import java.util.List; import lecho.lib.hellocharts.formatter.AxisValueFormatter; @@ -63,6 +64,11 @@ public class Axis { */ private Typeface typeface; + /** + * Allow for the values to be reversed. Specifically used for horizontal bar charts + */ + private boolean isReversed = false; + /** * Formatter used to format labels. */ @@ -158,6 +164,13 @@ public static Axis generateAxisFromCollection(List axisValues, List getValues() { + //Copy and transfer to ensure that other value logic stays intact + if (isReversed) { + ArrayList copy = new ArrayList(); + Collections.copy(copy, values); + Collections.reverse(copy); + return copy; + } return values; } @@ -302,4 +315,17 @@ public Axis setHasTiltedLabels(boolean hasTiltedLabels) { return this; } + /** + * Set to true when the natural direction of the axis should be reversed + * @param isReversed + * @return + */ + public Axis setIsReversed(boolean isReversed) { + this.isReversed = isReversed; + return this; + } + + public boolean getIsReversed() { + return isReversed; + } } diff --git a/hellocharts-library/src/lecho/lib/hellocharts/model/ColumnChartData.java b/hellocharts-library/src/lecho/lib/hellocharts/model/ColumnChartData.java index 42c11be0..4db22f56 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/model/ColumnChartData.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/model/ColumnChartData.java @@ -16,6 +16,7 @@ public class ColumnChartData extends AbstractChartData { private float baseValue = DEFAULT_BASE_VALUE; private List columns = new ArrayList(); private boolean isStacked = false; + private boolean isHorizontal = true; public ColumnChartData() { } @@ -97,6 +98,21 @@ public ColumnChartData setStacked(boolean isStacked) { return this; } + public boolean isHorizontal() { + return isHorizontal; + } + + /** + * Set true if you want a horizontal column chart. + * + * @param isHorizontal + * @return + */ + public ColumnChartData setHorizontal(boolean isHorizontal) { + this.isHorizontal = isHorizontal; + return this; + } + public float getFillRatio() { return fillRatio; } @@ -134,4 +150,39 @@ public ColumnChartData setBaseValue(float baseValue) { return this; } + @Override + public Axis getAxisXTop() { + if (isHorizontal) + return super.getAxisYRight(); + return super.getAxisXTop(); + } + + @Override + public Axis getAxisXBottom() { + if (isHorizontal) + return super.getAxisYLeft(); + return super.getAxisXBottom(); + } + + @Override + public Axis getAxisYLeft() { + if (isHorizontal) { + Axis x = super.getAxisXBottom(); + if (x != null) + x.setIsReversed(true); + return x; + } + return super.getAxisYLeft(); + } + + @Override + public Axis getAxisYRight() { + if (isHorizontal) { + Axis x = super.getAxisXTop(); + if (x != null) + x.setIsReversed(true); + return x; + } + return super.getAxisYRight(); + } } diff --git a/hellocharts-library/src/lecho/lib/hellocharts/renderer/AxesRenderer.java b/hellocharts-library/src/lecho/lib/hellocharts/renderer/AxesRenderer.java index a4eecc45..2ce17ea3 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/renderer/AxesRenderer.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/renderer/AxesRenderer.java @@ -574,13 +574,14 @@ private void drawAxisLabelsAndName(Canvas canvas, Axis axis, int position) { float labelX, labelY; labelX = labelY = 0; boolean isAxisVertical = isAxisVertical(position); + boolean isAxisReversed = axis.getIsReversed(); if (LEFT == position || RIGHT == position) { labelX = labelBaselineTab[position]; } else if (TOP == position || BOTTOM == position) { labelY = labelBaselineTab[position]; } - - for (int valueToDrawIndex = 0; valueToDrawIndex < valuesToDrawNumTab[position]; ++valueToDrawIndex) { + int reverseIndex = isAxisReversed ? 0 : valuesToDrawNumTab[position]; + for (int valueToDrawIndex = isAxisReversed ? valuesToDrawNumTab[position] - 1 : 0; isAxisReversed ? valueToDrawIndex >= 0 : valueToDrawIndex < valuesToDrawNumTab[position];) { int charsNumber = 0; if (axis.isAutoGenerated()) { final float value = autoValuesToDrawTab[position][valueToDrawIndex]; @@ -592,9 +593,9 @@ private void drawAxisLabelsAndName(Canvas canvas, Axis axis, int position) { } if (isAxisVertical) { - labelY = rawValuesTab[position][valueToDrawIndex]; + labelY = rawValuesTab[position][isAxisReversed ? reverseIndex : valueToDrawIndex]; } else { - labelX = rawValuesTab[position][valueToDrawIndex]; + labelX = rawValuesTab[position][isAxisReversed ? reverseIndex : valueToDrawIndex]; } if (axis.hasTiltedLabels()) { @@ -608,6 +609,13 @@ private void drawAxisLabelsAndName(Canvas canvas, Axis axis, int position) { canvas.drawText(labelBuffer, labelBuffer.length - charsNumber, charsNumber, labelX, labelY, labelPaintTab[position]); } + if (isAxisReversed) { + --valueToDrawIndex; + ++reverseIndex; + } else { + ++valueToDrawIndex; + --reverseIndex; + } } // Drawing axis name diff --git a/hellocharts-library/src/lecho/lib/hellocharts/renderer/ColumnChartRenderer.java b/hellocharts-library/src/lecho/lib/hellocharts/renderer/ColumnChartRenderer.java index da677138..ff086e5e 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/renderer/ColumnChartRenderer.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/renderer/ColumnChartRenderer.java @@ -5,6 +5,7 @@ import android.graphics.Paint; import android.graphics.Paint.Cap; import android.graphics.PointF; +import android.graphics.Rect; import android.graphics.RectF; import lecho.lib.hellocharts.model.Column; @@ -96,15 +97,16 @@ public void onChartViewportChanged() { public void draw(Canvas canvas) { final ColumnChartData data = dataProvider.getColumnChartData(); + boolean isHorizontal = data.isHorizontal(); if (data.isStacked()) { - drawColumnForStacked(canvas); + drawColumnForStacked(canvas, isHorizontal); if (isTouched()) { - highlightColumnForStacked(canvas); + highlightColumnForStacked(canvas, isHorizontal); } } else { - drawColumnsForSubcolumns(canvas); + drawColumnsForSubcolumns(canvas, isHorizontal); if (isTouched()) { - highlightColumnsForSubcolumns(canvas); + highlightColumnsForSubcolumns(canvas, isHorizontal); } } } @@ -118,9 +120,9 @@ public boolean checkTouch(float touchX, float touchY) { selectedValue.clear(); final ColumnChartData data = dataProvider.getColumnChartData(); if (data.isStacked()) { - checkTouchForStacked(touchX, touchY); + checkTouchForStacked(touchX, touchY, data.isHorizontal()); } else { - checkTouchForSubcolumns(touchX, touchY); + checkTouchForSubcolumns(touchX, touchY, data.isHorizontal()); } return isTouched(); } @@ -130,7 +132,10 @@ private void calculateMaxViewport() { // Column chart always has X values from 0 to numColumns-1, to add some margin on the left and right I added // extra 0.5 to the each side, that margins will be negative scaled according to number of columns, so for more // columns there will be less margin. - tempMaximumViewport.set(-0.5f, baseValue, data.getColumns().size() - 0.5f, baseValue); + if (data.isHorizontal()) + tempMaximumViewport.set(baseValue, data.getColumns().size() - 0.5f, baseValue, -0.5f); + else + tempMaximumViewport.set(-0.5f, baseValue, data.getColumns().size() - 0.5f, baseValue); if (data.isStacked()) { calculateMaxViewportForStacked(data); } else { @@ -139,19 +144,32 @@ private void calculateMaxViewport() { } private void calculateMaxViewportForSubcolumns(ColumnChartData data) { + boolean isHorizontal = data.isHorizontal(); + float tempMax = isHorizontal ? tempMaximumViewport.right : tempMaximumViewport.top; + float tempMin = isHorizontal ? tempMaximumViewport.left : tempMaximumViewport.bottom; for (Column column : data.getColumns()) { for (SubcolumnValue columnValue : column.getValues()) { - if (columnValue.getValue() >= baseValue && columnValue.getValue() > tempMaximumViewport.top) { - tempMaximumViewport.top = columnValue.getValue(); + if (columnValue.getValue() >= baseValue && columnValue.getValue() > tempMax) { + tempMax = columnValue.getValue(); } - if (columnValue.getValue() < baseValue && columnValue.getValue() < tempMaximumViewport.bottom) { - tempMaximumViewport.bottom = columnValue.getValue(); + if (columnValue.getValue() < baseValue && columnValue.getValue() < tempMin) { + tempMin = columnValue.getValue(); } } } + if (isHorizontal) { + tempMaximumViewport.right = tempMax; + tempMaximumViewport.left = tempMin; + } else { + tempMaximumViewport.top = tempMax; + tempMaximumViewport.bottom = tempMin; + } } private void calculateMaxViewportForStacked(ColumnChartData data) { + boolean isHorizontal = data.isHorizontal(); + float tempMax = isHorizontal ? tempMaximumViewport.right : tempMaximumViewport.top; + float tempMin = isHorizontal ? tempMaximumViewport.left : tempMaximumViewport.bottom; for (Column column : data.getColumns()) { float sumPositive = baseValue; float sumNegative = baseValue; @@ -162,48 +180,55 @@ private void calculateMaxViewportForStacked(ColumnChartData data) { sumNegative += columnValue.getValue(); } } - if (sumPositive > tempMaximumViewport.top) { - tempMaximumViewport.top = sumPositive; + if (sumPositive > tempMax) { + tempMax = sumPositive; } - if (sumNegative < tempMaximumViewport.bottom) { - tempMaximumViewport.bottom = sumNegative; + if (sumNegative < tempMin) { + tempMin = sumNegative; } } + if (isHorizontal) { + tempMaximumViewport.right = tempMax; + tempMaximumViewport.left = tempMin; + } else { + tempMaximumViewport.top = tempMax; + tempMaximumViewport.bottom = tempMin; + } } - private void drawColumnsForSubcolumns(Canvas canvas) { + private void drawColumnsForSubcolumns(Canvas canvas, boolean isHorizontal) { final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); int columnIndex = 0; for (Column column : data.getColumns()) { - processColumnForSubcolumns(canvas, column, columnWidth, columnIndex, MODE_DRAW); + processColumnForSubcolumns(canvas, column, columnWidth, columnIndex, MODE_DRAW, isHorizontal); ++columnIndex; } } - private void highlightColumnsForSubcolumns(Canvas canvas) { + private void highlightColumnsForSubcolumns(Canvas canvas, boolean isHorizontal) { final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); Column column = data.getColumns().get(selectedValue.getFirstIndex()); - processColumnForSubcolumns(canvas, column, columnWidth, selectedValue.getFirstIndex(), MODE_HIGHLIGHT); + processColumnForSubcolumns(canvas, column, columnWidth, selectedValue.getFirstIndex(), MODE_HIGHLIGHT, isHorizontal); } - private void checkTouchForSubcolumns(float touchX, float touchY) { + private void checkTouchForSubcolumns(float touchX, float touchY, boolean isHorizontal) { // Using member variable to hold touch point to avoid too much parameters in methods. touchedPoint.x = touchX; touchedPoint.y = touchY; final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); int columnIndex = 0; for (Column column : data.getColumns()) { // canvas is not needed for checking touch - processColumnForSubcolumns(null, column, columnWidth, columnIndex, MODE_CHECK_TOUCH); + processColumnForSubcolumns(null, column, columnWidth, columnIndex, MODE_CHECK_TOUCH, isHorizontal); ++columnIndex; } } private void processColumnForSubcolumns(Canvas canvas, Column column, float columnWidth, int columnIndex, - int mode) { + int mode, boolean isHorizontal) { // For n subcolumns there will be n-1 spacing and there will be one // subcolumn for every columnValue float subcolumnWidth = (columnWidth - (subcolumnSpacing * (column.getValues().size() - 1))) @@ -212,9 +237,9 @@ private void processColumnForSubcolumns(Canvas canvas, Column column, float colu subcolumnWidth = 1; } // Columns are indexes from 0 to n, column index is also column X value - final float rawX = computator.computeRawX(columnIndex); + final float rawX = isHorizontal ? computator.computeRawY(columnIndex) : computator.computeRawX(columnIndex); final float halfColumnWidth = columnWidth / 2; - final float baseRawY = computator.computeRawY(baseValue); + final float baseRawY = isHorizontal ? computator.computeRawX(baseValue) : computator.computeRawY(baseValue); // First subcolumn will starts at the left edge of current column, // rawValueX is horizontal center of that column float subcolumnRawX = rawX - halfColumnWidth; @@ -224,8 +249,8 @@ private void processColumnForSubcolumns(Canvas canvas, Column column, float colu if (subcolumnRawX > rawX + halfColumnWidth) { break; } - final float rawY = computator.computeRawY(columnValue.getValue()); - calculateRectToDraw(columnValue, subcolumnRawX, subcolumnRawX + subcolumnWidth, baseRawY, rawY); + final float rawY = isHorizontal ? computator.computeRawX(columnValue.getValue()) : computator.computeRawY(columnValue.getValue()); + calculateRectToDraw(isHorizontal, columnValue, subcolumnRawX, subcolumnRawX + subcolumnWidth, baseRawY, rawY); switch (mode) { case MODE_DRAW: drawSubcolumn(canvas, column, columnValue, false); @@ -246,40 +271,40 @@ private void processColumnForSubcolumns(Canvas canvas, Column column, float colu } } - private void drawColumnForStacked(Canvas canvas) { + private void drawColumnForStacked(Canvas canvas, boolean isHorizontal) { final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); // Columns are indexes from 0 to n, column index is also column X value int columnIndex = 0; for (Column column : data.getColumns()) { - processColumnForStacked(canvas, column, columnWidth, columnIndex, MODE_DRAW); + processColumnForStacked(canvas, column, columnWidth, columnIndex, MODE_DRAW, isHorizontal); ++columnIndex; } } - private void highlightColumnForStacked(Canvas canvas) { + private void highlightColumnForStacked(Canvas canvas, boolean isHorizontal) { final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); // Columns are indexes from 0 to n, column index is also column X value Column column = data.getColumns().get(selectedValue.getFirstIndex()); - processColumnForStacked(canvas, column, columnWidth, selectedValue.getFirstIndex(), MODE_HIGHLIGHT); + processColumnForStacked(canvas, column, columnWidth, selectedValue.getFirstIndex(), MODE_HIGHLIGHT, isHorizontal); } - private void checkTouchForStacked(float touchX, float touchY) { + private void checkTouchForStacked(float touchX, float touchY, boolean isHorizontal) { touchedPoint.x = touchX; touchedPoint.y = touchY; final ColumnChartData data = dataProvider.getColumnChartData(); - final float columnWidth = calculateColumnWidth(); + final float columnWidth = calculateColumnWidth(isHorizontal); int columnIndex = 0; for (Column column : data.getColumns()) { // canvas is not needed for checking touch - processColumnForStacked(null, column, columnWidth, columnIndex, MODE_CHECK_TOUCH); + processColumnForStacked(null, column, columnWidth, columnIndex, MODE_CHECK_TOUCH, isHorizontal); ++columnIndex; } } - private void processColumnForStacked(Canvas canvas, Column column, float columnWidth, int columnIndex, int mode) { - final float rawX = computator.computeRawX(columnIndex); + private void processColumnForStacked(Canvas canvas, Column column, float columnWidth, int columnIndex, int mode, boolean isHorizontal) { + final float rawX = isHorizontal ? computator.computeRawY(columnIndex) : computator.computeRawX(columnIndex); final float halfColumnWidth = columnWidth / 2; float mostPositiveValue = baseValue; float mostNegativeValue = baseValue; @@ -296,9 +321,9 @@ private void processColumnForStacked(Canvas canvas, Column column, float columnW subcolumnBaseValue = mostNegativeValue; mostNegativeValue += columnValue.getValue(); } - final float rawBaseY = computator.computeRawY(subcolumnBaseValue); - final float rawY = computator.computeRawY(subcolumnBaseValue + columnValue.getValue()); - calculateRectToDraw(columnValue, rawX - halfColumnWidth, rawX + halfColumnWidth, rawBaseY, rawY); + final float rawBaseY = isHorizontal ? computator.computeRawX(subcolumnBaseValue) : computator.computeRawY(subcolumnBaseValue); + final float rawY = isHorizontal ? computator.computeRawX(subcolumnBaseValue + columnValue.getValue()) : computator.computeRawY(subcolumnBaseValue + columnValue.getValue()); + calculateRectToDraw(isHorizontal, columnValue, rawX - halfColumnWidth, rawX + halfColumnWidth, rawBaseY, rawY); switch (mode) { case MODE_DRAW: drawSubcolumn(canvas, column, columnValue, true); @@ -343,18 +368,31 @@ private void checkRectToDraw(int columnIndex, int valueIndex) { } } - private float calculateColumnWidth() { - // columnWidht should be at least 2 px - float columnWidth = fillRatio * computator.getContentRectMinusAllMargins().width() / computator - .getVisibleViewport().width(); + private float calculateColumnWidth(boolean isHorizontal) { + // columnWidth should be at least 2 px + Rect rawRect = computator.getContentRectMinusAllMargins(); + Viewport rawViewport = computator.getVisibleViewport(); + float columnWidth = fillRatio * (isHorizontal ? rawRect.height() : rawRect.width()) / (isHorizontal ? rawViewport.height() : rawViewport.width()); if (columnWidth < 2) { columnWidth = 2; } return columnWidth; } - private void calculateRectToDraw(SubcolumnValue columnValue, float left, float right, float rawBaseY, float rawY) { + private void calculateRectToDraw(boolean isHorizontal, SubcolumnValue columnValue, float left, float right, float rawBaseY, float rawY) { // Calculate rect that will be drawn as column, subcolumn or label background. + if (isHorizontal) { + if (columnValue.getValue() >= baseValue) { + drawRect.top = left; + drawRect.bottom = right - subcolumnSpacing; + } else { + drawRect.top = left; + drawRect.bottom = right + subcolumnSpacing; + } + drawRect.left = rawBaseY; + drawRect.right = rawY; + return; + } drawRect.left = left; drawRect.right = right; if (columnValue.getValue() >= baseValue) { diff --git a/hellocharts-library/src/lecho/lib/hellocharts/view/ColumnChartView.java b/hellocharts-library/src/lecho/lib/hellocharts/view/ColumnChartView.java index 4f3dc7c6..3aebd5dd 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/view/ColumnChartView.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/view/ColumnChartView.java @@ -14,7 +14,7 @@ import lecho.lib.hellocharts.renderer.ColumnChartRenderer; /** - * ColumnChart/BarChart, supports subcolumns, stacked collumns and negative values. + * ColumnChart/BarChart, supports subcolumns, stacked columns, horizontal mode, and negative values. * * @author Leszek Wach */ From 31ab6e3a78143ab87b14a29016e6baa9177bf936 Mon Sep 17 00:00:00 2001 From: Charles Anderson Date: Wed, 19 Oct 2016 08:23:25 -0400 Subject: [PATCH 2/3] Added a menu item to toggle the horizontal sample view. --- hellocharts-samples/res/menu/column_chart.xml | 4 ++++ .../hellocharts/samples/ColumnChartActivity.java | 16 ++++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/hellocharts-samples/res/menu/column_chart.xml b/hellocharts-samples/res/menu/column_chart.xml index 5c959c93..1ae82e4f 100644 --- a/hellocharts-samples/res/menu/column_chart.xml +++ b/hellocharts-samples/res/menu/column_chart.xml @@ -31,6 +31,10 @@ android:id="@+id/action_toggle_axes_names" android:title="Toggle axes names" app:showAsAction="never"/> + Date: Wed, 19 Oct 2016 20:07:53 -0400 Subject: [PATCH 3/3] Change how the axis values array is copied to be more robust. --- .../src/lecho/lib/hellocharts/model/Axis.java | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java b/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java index e46be98c..2de0fdef 100644 --- a/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java +++ b/hellocharts-library/src/lecho/lib/hellocharts/model/Axis.java @@ -166,9 +166,9 @@ public static Axis generateAxisFromCollection(List axisValues, List getValues() { //Copy and transfer to ensure that other value logic stays intact if (isReversed) { - ArrayList copy = new ArrayList(); - Collections.copy(copy, values); - Collections.reverse(copy); + ArrayList copy = new ArrayList<>(); + for (int i = values.size() - 1; i >= 0; i--) + copy.add(values.get(i)); return copy; } return values;