organicmaps/MPAndroidChart
13
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity Actions

Implement a more generic Fill class instead of GradientColor

Browse source 
Support HorizontalBarChart too.
This commit is contained in:
Daniel Cohen Gindi 2020-01-24 11:35:47 +02:00
parent 351e341ee7
commit c0e7f56b5d
10 changed files with 514 additions and 127 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

22
MPChartExample/src/main/java/com/xxmassdeveloper/mpchartexample/BarChartActivity.java
View file

@ -32,7 +32,7 @@ import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.interfaces.datasets.IBarDataSet;
import com.github.mikephil.charting.interfaces.datasets.IDataSet;
import com.github.mikephil.charting.listener.OnChartValueSelectedListener;
import com.github.mikephil.charting.model.GradientColor;
import com.github.mikephil.charting.utils.Fill;
import com.github.mikephil.charting.utils.MPPointF;
import com.xxmassdeveloper.mpchartexample.custom.DayAxisValueFormatter;
import com.xxmassdeveloper.mpchartexample.custom.MyValueFormatter;
@ -164,12 +164,6 @@ public class BarChartActivity extends DemoBase implements OnSeekBarChangeListene
set1.setDrawIcons(false);
// set1.setColors(ColorTemplate.MATERIAL_COLORS);
/*int startColor = ContextCompat.getColor(this, android.R.color.holo_blue_dark);
int endColor = ContextCompat.getColor(this, android.R.color.holo_blue_bright);
set1.setGradientColor(startColor, endColor);*/
int startColor1 = ContextCompat.getColor(this, android.R.color.holo_orange_light);
int startColor2 = ContextCompat.getColor(this, android.R.color.holo_blue_light);
int startColor3 = ContextCompat.getColor(this, android.R.color.holo_orange_light);
@ -181,14 +175,14 @@ public class BarChartActivity extends DemoBase implements OnSeekBarChangeListene
int endColor4 = ContextCompat.getColor(this, android.R.color.holo_red_dark);
int endColor5 = ContextCompat.getColor(this, android.R.color.holo_orange_dark);
List<GradientColor> gradientColors = new ArrayList<>();
gradientColors.add(new GradientColor(startColor1, endColor1));
gradientColors.add(new GradientColor(startColor2, endColor2));
gradientColors.add(new GradientColor(startColor3, endColor3));
gradientColors.add(new GradientColor(startColor4, endColor4));
gradientColors.add(new GradientColor(startColor5, endColor5));
List<Fill> gradientFills = new ArrayList<>();
gradientFills.add(new Fill(startColor1, endColor1));
gradientFills.add(new Fill(startColor2, endColor2));
gradientFills.add(new Fill(startColor3, endColor3));
gradientFills.add(new Fill(startColor4, endColor4));
gradientFills.add(new Fill(startColor5, endColor5));
set1.setGradientColors(gradientColors);
set1.setFills(gradientFills);
ArrayList<IBarDataSet> dataSets = new ArrayList<>();
dataSets.add(set1);

64
MPChartLib/src/main/java/com/github/mikephil/charting/data/BarDataSet.java
View file

@ -4,6 +4,7 @@ package com.github.mikephil.charting.data;
import android.graphics.Color;
import com.github.mikephil.charting.interfaces.datasets.IBarDataSet;
import com.github.mikephil.charting.utils.Fill;
import java.util.ArrayList;
import java.util.List;
@ -40,6 +41,8 @@ public class BarDataSet extends BarLineScatterCandleBubbleDataSet<BarEntry> impl
*/
private String[] mStackLabels = new String[]{};
protected List<Fill> mFills = null;
public BarDataSet(List<BarEntry> yVals, String label) {
super(yVals, label);
@ -69,6 +72,67 @@ public class BarDataSet extends BarLineScatterCandleBubbleDataSet<BarEntry> impl
barDataSet.mHighLightAlpha = mHighLightAlpha;
}
@Override
public List<Fill> getFills() {
return mFills;
}
@Override
public Fill getFill(int index) {
return mFills.get(index % mFills.size());
}
/**
* This method is deprecated.
* Use getFills() instead.
*/
@Deprecated
public List<Fill> getGradients() {
return mFills;
}
/**
* This method is deprecated.
* Use getFill(...) instead.
*
* @param index
*/
@Deprecated
public Fill getGradient(int index) {
return getFill(index);
}
/**
* Sets the start and end color for gradient color, ONLY color that should be used for this DataSet.
*
* @param startColor
* @param endColor
*/
public void setGradientColor(int startColor, int endColor) {
mFills.clear();
mFills.add(new Fill(startColor, endColor));
}
/**
* This method is deprecated.
* Use setFills(...) instead.
*
* @param gradientColors
*/
@Deprecated
public void setGradientColors(List<Fill> gradientColors) {
this.mFills = gradientColors;
}
/**
* Sets the fills for the bars in this dataset.
*
* @param fills
*/
public void setFills(List<Fill> fills) {
this.mFills = fills;
}
/**
* Calculates the total number of entries this DataSet represents, including
* stacks. All values belonging to a stack are calculated separately.

41
MPChartLib/src/main/java/com/github/mikephil/charting/data/BaseDataSet.java
View file

@ -9,7 +9,6 @@ import com.github.mikephil.charting.components.Legend;
import com.github.mikephil.charting.components.YAxis;
import com.github.mikephil.charting.formatter.ValueFormatter;
import com.github.mikephil.charting.interfaces.datasets.IDataSet;
import com.github.mikephil.charting.model.GradientColor;
import com.github.mikephil.charting.utils.ColorTemplate;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.utils.Utils;
@ -29,10 +28,6 @@ public abstract class BaseDataSet<T extends Entry> implements IDataSet<T> {
*/
protected List<Integer> mColors = null;
protected GradientColor mGradientColor = null;
protected List<GradientColor> mGradientColors = null;
/**
* List representing all colors that are used for drawing the actual values for this DataSet
*/
@ -146,21 +141,6 @@ public abstract class BaseDataSet<T extends Entry> implements IDataSet<T> {
return mColors.get(index % mColors.size());
}
@Override
public GradientColor getGradientColor() {
return mGradientColor;
}
@Override
public List<GradientColor> getGradientColors() {
return mGradientColors;
}
@Override
public GradientColor getGradientColor(int index) {
return mGradientColors.get(index % mGradientColors.size());
}
/**
* ###### ###### COLOR SETTING RELATED METHODS ##### ######
*/
@ -236,25 +216,6 @@ public abstract class BaseDataSet<T extends Entry> implements IDataSet<T> {
mColors.add(color);
}
/**
* Sets the start and end color for gradient color, ONLY color that should be used for this DataSet.
*
* @param startColor
* @param endColor
*/
public void setGradientColor(int startColor, int endColor) {
mGradientColor = new GradientColor(startColor, endColor);
}
/**
* Sets the start and end color for gradient colors, ONLY color that should be used for this DataSet.
*
* @param gradientColors
*/
public void setGradientColors(List<GradientColor> gradientColors) {
this.mGradientColors = gradientColors;
}
/**
* Sets a color with a specific alpha value.
*
@ -534,8 +495,6 @@ public abstract class BaseDataSet<T extends Entry> implements IDataSet<T> {
baseDataSet.mFormLineDashEffect = mFormLineDashEffect;
baseDataSet.mFormLineWidth = mFormLineWidth;
baseDataSet.mFormSize = mFormSize;
baseDataSet.mGradientColor = mGradientColor;
baseDataSet.mGradientColors = mGradientColors;
baseDataSet.mHighlightEnabled = mHighlightEnabled;
baseDataSet.mIconsOffset = mIconsOffset;
baseDataSet.mValueColors = mValueColors;

1
MPChartLib/src/main/java/com/github/mikephil/charting/data/LineRadarDataSet.java
View file

@ -17,6 +17,7 @@ import java.util.List;
*/
public abstract class LineRadarDataSet<T extends Entry> extends LineScatterCandleRadarDataSet<T> implements ILineRadarDataSet<T> {
// TODO: Move to using `Fill` class
/**
* the color that is used for filling the line surface
*/

7
MPChartLib/src/main/java/com/github/mikephil/charting/interfaces/datasets/IBarDataSet.java
View file

@ -1,12 +1,19 @@
package com.github.mikephil.charting.interfaces.datasets;
import com.github.mikephil.charting.data.BarEntry;
import com.github.mikephil.charting.utils.Fill;
import java.util.List;
/**
* Created by philipp on 21/10/15.
*/
public interface IBarDataSet extends IBarLineScatterCandleBubbleDataSet<BarEntry> {
List<Fill> getFills();
Fill getFill(int index);
/**
* Returns true if this DataSet is stacked (stacksize > 1) or not.
*

23
MPChartLib/src/main/java/com/github/mikephil/charting/interfaces/datasets/IDataSet.java
View file

@ -9,7 +9,6 @@ import com.github.mikephil.charting.data.DataSet;
import com.github.mikephil.charting.data.Entry;
import com.github.mikephil.charting.formatter.ValueFormatter;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.model.GradientColor;
import java.util.List;
@ -285,28 +284,6 @@ public interface IDataSet<T extends Entry> {
*/
int getColor();
/**
* Returns the Gradient color model
*
* @return
*/
GradientColor getGradientColor();
/**
* Returns the Gradient colors
*
* @return
*/
List<GradientColor> getGradientColors();
/**
* Returns the Gradient colors
*
* @param index
* @return
*/
GradientColor getGradientColor(int index);
/**
* Returns the color at the given index of the DataSet's color array.
* Performs a IndexOutOfBounds check by modulus.

73
MPChartLib/src/main/java/com/github/mikephil/charting/model/GradientColor.java
View file

@ -1,28 +1,69 @@
package com.github.mikephil.charting.model;
public class GradientColor {
import com.github.mikephil.charting.utils.Fill;
private int startColor;
private int endColor;
public GradientColor(int startColor, int endColor) {
this.startColor = startColor;
this.endColor = endColor;
/**
* Deprecated. Use `Fill`
*/
@Deprecated
public class GradientColor extends Fill
{
/**
* Deprecated. Use `Fill.getGradientColors()`
*/
@Deprecated
public int getStartColor()
{
return getGradientColors()[0];
}
public int getStartColor() {
return startColor;
/**
* Deprecated. Use `Fill.setGradientColors(...)`
*/
@Deprecated
public void setStartColor(int startColor)
{
if (getGradientColors() == null || getGradientColors().length != 2)
{
setGradientColors(new int[]{
startColor,
getGradientColors() != null && getGradientColors().length > 1
? getGradientColors()[1]
: 0
});
} else
{
getGradientColors()[0] = startColor;
}
}
public void setStartColor(int startColor) {
this.startColor = startColor;
/**
* Deprecated. Use `Fill.getGradientColors()`
*/
@Deprecated
public int getEndColor()
{
return getGradientColors()[1];
}
public int getEndColor() {
return endColor;
/**
* Deprecated. Use `Fill.setGradientColors(...)`
*/
@Deprecated
public void setEndColor(int endColor)
{
if (getGradientColors() == null || getGradientColors().length != 2)
{
setGradientColors(new int[]{
getGradientColors() != null && getGradientColors().length > 0
? getGradientColors()[0]
: 0,
endColor
});
} else
{
getGradientColors()[1] = endColor;
}
}
public void setEndColor(int endColor) {
this.endColor = endColor;
}
}

47
MPChartLib/src/main/java/com/github/mikephil/charting/renderer/BarChartRenderer.java
View file

@ -15,12 +15,11 @@ import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.highlight.Range;
import com.github.mikephil.charting.interfaces.dataprovider.BarDataProvider;
import com.github.mikephil.charting.interfaces.datasets.IBarDataSet;
import com.github.mikephil.charting.utils.Fill;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.utils.Transformer;
import com.github.mikephil.charting.utils.Utils;
import com.github.mikephil.charting.utils.ViewPortHandler;
import android.graphics.LinearGradient;
import com.github.mikephil.charting.model.GradientColor;
import java.util.List;
@ -145,13 +144,15 @@ public class BarChartRenderer extends BarLineScatterCandleBubbleRenderer {
trans.pointValuesToPixel(buffer.buffer);
final boolean isCustomFill = dataSet.getFills().size() > 0;
final boolean isSingleColor = dataSet.getColors().size() == 1;
final boolean isInverted = mChart.isInverted(dataSet.getAxisDependency());
if (isSingleColor) {
mRenderPaint.setColor(dataSet.getColor());
}
for (int j = 0; j < buffer.size(); j += 4) {
for (int j = 0, pos = 0; j < buffer.size(); j += 4, pos++) {
if (!mViewPortHandler.isInBoundsLeft(buffer.buffer[j + 2]))
continue;
@ -162,38 +163,24 @@ public class BarChartRenderer extends BarLineScatterCandleBubbleRenderer {
if (!isSingleColor) {
// Set the color for the currently drawn value. If the index
// is out of bounds, reuse colors.
mRenderPaint.setColor(dataSet.getColor(j / 4));
mRenderPaint.setColor(dataSet.getColor(pos));
}
if (dataSet.getGradientColor() != null) {
GradientColor gradientColor = dataSet.getGradientColor();
mRenderPaint.setShader(
new LinearGradient(
buffer.buffer[j],
buffer.buffer[j + 3],
buffer.buffer[j],
buffer.buffer[j + 1],
gradientColor.getStartColor(),
gradientColor.getEndColor(),
android.graphics.Shader.TileMode.MIRROR));
if (isCustomFill) {
dataSet.getFill(pos)
.fillRect(
c, mRenderPaint,
buffer.buffer[j],
buffer.buffer[j + 1],
buffer.buffer[j + 2],
buffer.buffer[j + 3],
isInverted ? Fill.Direction.DOWN : Fill.Direction.UP);
}
if (dataSet.getGradientColors() != null) {
mRenderPaint.setShader(
new LinearGradient(
buffer.buffer[j],
buffer.buffer[j + 3],
buffer.buffer[j],
buffer.buffer[j + 1],
dataSet.getGradientColor(j / 4).getStartColor(),
dataSet.getGradientColor(j / 4).getEndColor(),
android.graphics.Shader.TileMode.MIRROR));
else {
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mRenderPaint);
}
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mRenderPaint);
if (drawBorder) {
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mBarBorderPaint);

21
MPChartLib/src/main/java/com/github/mikephil/charting/renderer/HorizontalBarChartRenderer.java
View file

@ -15,6 +15,7 @@ import com.github.mikephil.charting.highlight.Highlight;
import com.github.mikephil.charting.interfaces.dataprovider.BarDataProvider;
import com.github.mikephil.charting.interfaces.dataprovider.ChartInterface;
import com.github.mikephil.charting.interfaces.datasets.IBarDataSet;
import com.github.mikephil.charting.utils.Fill;
import com.github.mikephil.charting.utils.MPPointF;
import com.github.mikephil.charting.utils.Transformer;
import com.github.mikephil.charting.utils.Utils;
@ -111,13 +112,15 @@ public class HorizontalBarChartRenderer extends BarChartRenderer {
trans.pointValuesToPixel(buffer.buffer);
final boolean isCustomFill = dataSet.getFills().size() > 0;
final boolean isSingleColor = dataSet.getColors().size() == 1;
final boolean isInverted = mChart.isInverted(dataSet.getAxisDependency());
if (isSingleColor) {
mRenderPaint.setColor(dataSet.getColor());
}
for (int j = 0; j < buffer.size(); j += 4) {
for (int j = 0, pos = 0; j < buffer.size(); j += 4, pos++) {
if (!mViewPortHandler.isInBoundsTop(buffer.buffer[j + 3]))
break;
@ -131,8 +134,20 @@ public class HorizontalBarChartRenderer extends BarChartRenderer {
mRenderPaint.setColor(dataSet.getColor(j / 4));
}
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mRenderPaint);
if (isCustomFill) {
dataSet.getFill(pos)
.fillRect(
c, mRenderPaint,
buffer.buffer[j],
buffer.buffer[j + 1],
buffer.buffer[j + 2],
buffer.buffer[j + 3],
isInverted ? Fill.Direction.LEFT : Fill.Direction.RIGHT);
}
else {
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],
buffer.buffer[j + 3], mRenderPaint);
}
if (drawBorder) {
c.drawRect(buffer.buffer[j], buffer.buffer[j + 1], buffer.buffer[j + 2],

342
MPChartLib/src/main/java/com/github/mikephil/charting/utils/Fill.java Normal file
View file

@ -0,0 +1,342 @@
package com.github.mikephil.charting.utils;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Path;
import android.graphics.RectF;
import android.graphics.drawable.Drawable;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
public class Fill
{
public enum Type
{
EMPTY, COLOR, LINEAR_GRADIENT, DRAWABLE
}
public enum Direction
{
DOWN, UP, RIGHT, LEFT
}
/**
* the type of fill
*/
private Type mType = Type.EMPTY;
/**
* the color that is used for filling
*/
@Nullable
private Integer mColor = null;
private Integer mFinalColor = null;
/**
* the drawable to be used for filling
*/
@Nullable
protected Drawable mDrawable;
@Nullable
private int[] mGradientColors;
@Nullable
private float[] mGradientPositions;
/**
* transparency used for filling
*/
private int mAlpha = 255;
public Fill()
{
}
public Fill(int color)
{
this.mType = Type.COLOR;
this.mColor = color;
calculateFinalColor();
}
public Fill(int startColor, int endColor)
{
this.mType = Type.LINEAR_GRADIENT;
this.mGradientColors = new int[]{startColor, endColor};
}
public Fill(@NonNull int[] gradientColors)
{
this.mType = Type.LINEAR_GRADIENT;
this.mGradientColors = gradientColors;
}
public Fill(@NonNull int[] gradientColors, @NonNull float[] gradientPositions)
{
this.mType = Type.LINEAR_GRADIENT;
this.mGradientColors = gradientColors;
this.mGradientPositions = gradientPositions;
}
public Fill(@NonNull Drawable drawable)
{
this.mType = Type.DRAWABLE;
this.mDrawable = drawable;
}
public Type getType()
{
return mType;
}
public void setType(Type type)
{
this.mType = type;
}
@Nullable
public Integer getColor()
{
return mColor;
}
public void setColor(int color)
{
this.mColor = color;
calculateFinalColor();
}
public int[] getGradientColors()
{
return mGradientColors;
}
public void setGradientColors(int[] colors)
{
this.mGradientColors = colors;
}
public float[] getGradientPositions()
{
return mGradientPositions;
}
public void setGradientPositions(float[] positions)
{
this.mGradientPositions = positions;
}
public void setGradientColors(int startColor, int endColor)
{
this.mGradientColors = new int[]{startColor, endColor};
}
public int getAlpha()
{
return mAlpha;
}
public void setAlpha(int alpha)
{
this.mAlpha = alpha;
calculateFinalColor();
}
private void calculateFinalColor()
{
if (mColor == null)
{
mFinalColor = null;
} else
{
int alpha = (int) Math.floor(((mColor >> 24) / 255.0) * (mAlpha / 255.0) * 255.0);
mFinalColor = (alpha << 24) | (mColor & 0xffffff);
}
}
public void fillRect(Canvas c, Paint paint,
float left, float top, float right, float bottom,
Direction gradientDirection)
{
switch (mType)
{
case EMPTY:
return;
case COLOR:
{
if (mFinalColor == null) return;
if (isClipPathSupported())
{
int save = c.save();
c.clipRect(left, top, right, bottom);
c.drawColor(mFinalColor);
c.restoreToCount(save);
}
else
{
// save
Paint.Style previous = paint.getStyle();
int previousColor = paint.getColor();
// set
paint.setStyle(Paint.Style.FILL);
paint.setColor(mFinalColor);
c.drawRect(left, top, right, bottom, paint);
// restore
paint.setColor(previousColor);
paint.setStyle(previous);
}
}
break;
case LINEAR_GRADIENT:
{
if (mGradientColors == null) return;
LinearGradient gradient = new LinearGradient(
(int) (gradientDirection == Direction.RIGHT
? right
: gradientDirection == Direction.LEFT
? left
: left),
(int) (gradientDirection == Direction.UP
? bottom
: gradientDirection == Direction.DOWN
? top
: top),
(int) (gradientDirection == Direction.RIGHT
? left
: gradientDirection == Direction.LEFT
? right
: left),
(int) (gradientDirection == Direction.UP
? top
: gradientDirection == Direction.DOWN
? bottom
: top),
mGradientColors,
mGradientPositions,
android.graphics.Shader.TileMode.MIRROR);
paint.setShader(gradient);
c.drawRect(left, top, right, bottom, paint);
}
break;
case DRAWABLE:
{
if (mDrawable == null) return;
mDrawable.setBounds((int) left, (int) top, (int) right, (int) bottom);
mDrawable.draw(c);
}
break;
}
}
public void fillPath(Canvas c, Path path, Paint paint,
@Nullable RectF clipRect)
{
switch (mType)
{
case EMPTY:
return;
case COLOR:
{
if (mFinalColor == null) return;
if (clipRect != null && isClipPathSupported())
{
int save = c.save();
c.clipPath(path);
c.drawColor(mFinalColor);
c.restoreToCount(save);
}
else
{
// save
Paint.Style previous = paint.getStyle();
int previousColor = paint.getColor();
// set
paint.setStyle(Paint.Style.FILL);
paint.setColor(mFinalColor);
c.drawPath(path, paint);
// restore
paint.setColor(previousColor);
paint.setStyle(previous);
}
}
break;
case LINEAR_GRADIENT:
{
if (mGradientColors == null) return;
LinearGradient gradient = new LinearGradient(
0,
0,
c.getWidth(),
c.getHeight(),
mGradientColors,
mGradientPositions,
android.graphics.Shader.TileMode.MIRROR);
paint.setShader(gradient);
c.drawPath(path, paint);
}
break;
case DRAWABLE:
{
if (mDrawable == null) return;
ensureClipPathSupported();
int save = c.save();
c.clipPath(path);
mDrawable.setBounds(
clipRect == null ? 0 : (int) clipRect.left,
clipRect == null ? 0 : (int) clipRect.top,
clipRect == null ? c.getWidth() : (int) clipRect.right,
clipRect == null ? c.getHeight() : (int) clipRect.bottom);
mDrawable.draw(c);
c.restoreToCount(save);
}
break;
}
}
private boolean isClipPathSupported()
{
return Utils.getSDKInt() >= 18;
}
private void ensureClipPathSupported()
{
if (Utils.getSDKInt() < 18)
{
throw new RuntimeException("Fill-drawables not (yet) supported below API level 18, " +
"this code was run on API level " + Utils.getSDKInt() + ".");
}
}
}