package com.github.mikephil.charting.charts; import android.annotation.SuppressLint; import android.annotation.TargetApi; import android.content.Context; import android.graphics.Canvas; import android.graphics.Color; import android.graphics.Matrix; import android.graphics.Paint; import android.graphics.Paint.Style; import android.graphics.RectF; import android.util.AttributeSet; import android.util.Log; import android.view.MotionEvent; import com.github.mikephil.charting.components.XAxis.XAxisPosition; import com.github.mikephil.charting.components.YAxis; import com.github.mikephil.charting.components.YAxis.AxisDependency; import com.github.mikephil.charting.data.BarLineScatterCandleBubbleData; import com.github.mikephil.charting.data.Entry; import com.github.mikephil.charting.highlight.ChartHighlighter; import com.github.mikephil.charting.highlight.Highlight; import com.github.mikephil.charting.interfaces.dataprovider.BarLineScatterCandleBubbleDataProvider; import com.github.mikephil.charting.interfaces.datasets.IBarLineScatterCandleBubbleDataSet; import com.github.mikephil.charting.jobs.AnimatedMoveViewJob; import com.github.mikephil.charting.jobs.AnimatedZoomJob; import com.github.mikephil.charting.jobs.MoveViewJob; import com.github.mikephil.charting.jobs.ZoomJob; import com.github.mikephil.charting.listener.BarLineChartTouchListener; import com.github.mikephil.charting.listener.OnDrawListener; import com.github.mikephil.charting.renderer.XAxisRenderer; import com.github.mikephil.charting.renderer.YAxisRenderer; import com.github.mikephil.charting.utils.MPPointD; import com.github.mikephil.charting.utils.MPPointF; import com.github.mikephil.charting.utils.Transformer; import com.github.mikephil.charting.utils.Utils; /** * Base-class of LineChart, BarChart, ScatterChart and CandleStickChart. * * @author Philipp Jahoda */ @SuppressLint("RtlHardcoded") public abstract class BarLineChartBase>> extends Chart implements BarLineScatterCandleBubbleDataProvider { /** * the maximum number of entries to which values will be drawn * (entry numbers greater than this value will cause value-labels to disappear) */ protected int mMaxVisibleCount = 100; /** * flag that indicates if auto scaling on the y axis is enabled */ protected boolean mAutoScaleMinMaxEnabled = false; /** * flag that indicates if pinch-zoom is enabled. if true, both x and y axis * can be scaled with 2 fingers, if false, x and y axis can be scaled * separately */ protected boolean mPinchZoomEnabled = false; /** * flag that indicates if double tap zoom is enabled or not */ protected boolean mDoubleTapToZoomEnabled = true; /** * flag that indicates if highlighting per dragging over a fully zoomed out * chart is enabled */ protected boolean mHighlightPerDragEnabled = true; /** * if true, dragging is enabled for the chart */ private boolean mDragXEnabled = true; private boolean mDragYEnabled = true; private boolean mScaleXEnabled = true; private boolean mScaleYEnabled = true; /** * paint object for the (by default) lightgrey background of the grid */ protected Paint mGridBackgroundPaint; protected Paint mBorderPaint; /** * flag indicating if the grid background should be drawn or not */ protected boolean mDrawGridBackground = false; protected boolean mDrawBorders = false; protected boolean mClipValuesToContent = false; protected boolean mClipDataToContent = true; /** * Sets the minimum offset (padding) around the chart, defaults to 15 */ protected float mMinOffset = 15.f; /** * flag indicating if the chart should stay at the same position after a rotation. Default is false. */ protected boolean mKeepPositionOnRotation = false; /** * the listener for user drawing on the chart */ protected OnDrawListener mDrawListener; /** * the object representing the labels on the left y-axis */ protected YAxis mAxisLeft; /** * the object representing the labels on the right y-axis */ protected YAxis mAxisRight; protected YAxisRenderer mAxisRendererLeft; protected YAxisRenderer mAxisRendererRight; protected Transformer mLeftAxisTransformer; protected Transformer mRightAxisTransformer; protected XAxisRenderer mXAxisRenderer; // /** the approximator object used for data filtering */ // private Approximator mApproximator; public BarLineChartBase(Context context, AttributeSet attrs, int defStyle) { super(context, attrs, defStyle); } public BarLineChartBase(Context context, AttributeSet attrs) { super(context, attrs); } public BarLineChartBase(Context context) { super(context); } @Override protected void init() { super.init(); mAxisLeft = new YAxis(AxisDependency.LEFT); mAxisRight = new YAxis(AxisDependency.RIGHT); mLeftAxisTransformer = new Transformer(mViewPortHandler); mRightAxisTransformer = new Transformer(mViewPortHandler); mAxisRendererLeft = new YAxisRenderer(mViewPortHandler, mAxisLeft, mLeftAxisTransformer); mAxisRendererRight = new YAxisRenderer(mViewPortHandler, mAxisRight, mRightAxisTransformer); mXAxisRenderer = new XAxisRenderer(mViewPortHandler, mXAxis, mLeftAxisTransformer); setHighlighter(new ChartHighlighter(this)); mChartTouchListener = new BarLineChartTouchListener(this, mViewPortHandler.getMatrixTouch(), 3f); mGridBackgroundPaint = new Paint(); mGridBackgroundPaint.setStyle(Style.FILL); // mGridBackgroundPaint.setColor(Color.WHITE); mGridBackgroundPaint.setColor(Color.rgb(240, 240, 240)); // light // grey mBorderPaint = new Paint(); mBorderPaint.setStyle(Style.STROKE); mBorderPaint.setColor(Color.BLACK); mBorderPaint.setStrokeWidth(Utils.convertDpToPixel(1f)); } // for performance tracking private long totalTime = 0; private long drawCycles = 0; @Override protected void onDraw(Canvas canvas) { super.onDraw(canvas); if (mData == null) return; long starttime = System.currentTimeMillis(); // execute all drawing commands drawGridBackground(canvas); if (mAutoScaleMinMaxEnabled) { autoScale(); } if (mAxisLeft.isEnabled()) mAxisRendererLeft.computeAxis(mAxisLeft.mAxisMinimum, mAxisLeft.mAxisMaximum, mAxisLeft.isInverted()); if (mAxisRight.isEnabled()) mAxisRendererRight.computeAxis(mAxisRight.mAxisMinimum, mAxisRight.mAxisMaximum, mAxisRight.isInverted()); if (mXAxis.isEnabled()) mXAxisRenderer.computeAxis(mXAxis.mAxisMinimum, mXAxis.mAxisMaximum, false); mXAxisRenderer.renderAxisLine(canvas); mAxisRendererLeft.renderAxisLine(canvas); mAxisRendererRight.renderAxisLine(canvas); if (mXAxis.isDrawGridLinesBehindDataEnabled()) mXAxisRenderer.renderGridLines(canvas); if (mAxisLeft.isDrawGridLinesBehindDataEnabled()) mAxisRendererLeft.renderGridLines(canvas); if (mAxisRight.isDrawGridLinesBehindDataEnabled()) mAxisRendererRight.renderGridLines(canvas); if (mXAxis.isEnabled() && mXAxis.isDrawLimitLinesBehindDataEnabled()) mXAxisRenderer.renderLimitLines(canvas); if (mAxisLeft.isEnabled() && mAxisLeft.isDrawLimitLinesBehindDataEnabled()) mAxisRendererLeft.renderLimitLines(canvas); if (mAxisRight.isEnabled() && mAxisRight.isDrawLimitLinesBehindDataEnabled()) mAxisRendererRight.renderLimitLines(canvas); int clipRestoreCount = canvas.save(); if (isClipDataToContentEnabled()) { // make sure the data cannot be drawn outside the content-rect canvas.clipRect(mViewPortHandler.getContentRect()); } mRenderer.drawData(canvas); if (!mXAxis.isDrawGridLinesBehindDataEnabled()) mXAxisRenderer.renderGridLines(canvas); if (!mAxisLeft.isDrawGridLinesBehindDataEnabled()) mAxisRendererLeft.renderGridLines(canvas); if (!mAxisRight.isDrawGridLinesBehindDataEnabled()) mAxisRendererRight.renderGridLines(canvas); // if highlighting is enabled if (valuesToHighlight()) mRenderer.drawHighlighted(canvas, mIndicesToHighlight); // Removes clipping rectangle canvas.restoreToCount(clipRestoreCount); mRenderer.drawExtras(canvas); if (mXAxis.isEnabled() && !mXAxis.isDrawLimitLinesBehindDataEnabled()) mXAxisRenderer.renderLimitLines(canvas); if (mAxisLeft.isEnabled() && !mAxisLeft.isDrawLimitLinesBehindDataEnabled()) mAxisRendererLeft.renderLimitLines(canvas); if (mAxisRight.isEnabled() && !mAxisRight.isDrawLimitLinesBehindDataEnabled()) mAxisRendererRight.renderLimitLines(canvas); mXAxisRenderer.renderAxisLabels(canvas); mAxisRendererLeft.renderAxisLabels(canvas); mAxisRendererRight.renderAxisLabels(canvas); if (isClipValuesToContentEnabled()) { clipRestoreCount = canvas.save(); canvas.clipRect(mViewPortHandler.getContentRect()); mRenderer.drawValues(canvas); canvas.restoreToCount(clipRestoreCount); } else { mRenderer.drawValues(canvas); } mLegendRenderer.renderLegend(canvas); drawDescription(canvas); drawMarkers(canvas); if (mLogEnabled) { long drawtime = (System.currentTimeMillis() - starttime); totalTime += drawtime; drawCycles += 1; long average = totalTime / drawCycles; Log.i(LOG_TAG, "Drawtime: " + drawtime + " ms, average: " + average + " ms, cycles: " + drawCycles); } } /** * RESET PERFORMANCE TRACKING FIELDS */ public void resetTracking() { totalTime = 0; drawCycles = 0; } protected void prepareValuePxMatrix() { if (mLogEnabled) Log.i(LOG_TAG, "Preparing Value-Px Matrix, xmin: " + mXAxis.mAxisMinimum + ", xmax: " + mXAxis.mAxisMaximum + ", xdelta: " + mXAxis.mAxisRange); mRightAxisTransformer.prepareMatrixValuePx(mXAxis.mAxisMinimum, mXAxis.mAxisRange, mAxisRight.mAxisRange, mAxisRight.mAxisMinimum); mLeftAxisTransformer.prepareMatrixValuePx(mXAxis.mAxisMinimum, mXAxis.mAxisRange, mAxisLeft.mAxisRange, mAxisLeft.mAxisMinimum); } protected void prepareOffsetMatrix() { mRightAxisTransformer.prepareMatrixOffset(mAxisRight.isInverted()); mLeftAxisTransformer.prepareMatrixOffset(mAxisLeft.isInverted()); } @Override public void notifyDataSetChanged() { if (mData == null) { if (mLogEnabled) Log.i(LOG_TAG, "Preparing... DATA NOT SET."); return; } else { if (mLogEnabled) Log.i(LOG_TAG, "Preparing..."); } if (mRenderer != null) mRenderer.initBuffers(); calcMinMax(); mAxisRendererLeft.computeAxis(mAxisLeft.mAxisMinimum, mAxisLeft.mAxisMaximum, mAxisLeft.isInverted()); mAxisRendererRight.computeAxis(mAxisRight.mAxisMinimum, mAxisRight.mAxisMaximum, mAxisRight.isInverted()); mXAxisRenderer.computeAxis(mXAxis.mAxisMinimum, mXAxis.mAxisMaximum, false); if (mLegend != null) mLegendRenderer.computeLegend(mData); calculateOffsets(); } /** * Performs auto scaling of the axis by recalculating the minimum and maximum y-values based on the entries currently in view. */ protected void autoScale() { final float fromX = getLowestVisibleX(); final float toX = getHighestVisibleX(); mData.calcMinMaxY(fromX, toX); mXAxis.calculate(mData.getXMin(), mData.getXMax()); // calculate axis range (min / max) according to provided data if (mAxisLeft.isEnabled()) mAxisLeft.calculate(mData.getYMin(AxisDependency.LEFT), mData.getYMax(AxisDependency.LEFT)); if (mAxisRight.isEnabled()) mAxisRight.calculate(mData.getYMin(AxisDependency.RIGHT), mData.getYMax(AxisDependency.RIGHT)); calculateOffsets(); } @Override protected void calcMinMax() { mXAxis.calculate(mData.getXMin(), mData.getXMax()); // calculate axis range (min / max) according to provided data mAxisLeft.calculate(mData.getYMin(AxisDependency.LEFT), mData.getYMax(AxisDependency.LEFT)); mAxisRight.calculate(mData.getYMin(AxisDependency.RIGHT), mData.getYMax(AxisDependency .RIGHT)); } protected void calculateLegendOffsets(RectF offsets) { offsets.left = 0.f; offsets.right = 0.f; offsets.top = 0.f; offsets.bottom = 0.f; if (mLegend == null || !mLegend.isEnabled() || mLegend.isDrawInsideEnabled()) return; switch (mLegend.getOrientation()) { case VERTICAL: switch (mLegend.getHorizontalAlignment()) { case LEFT: offsets.left += Math.min(mLegend.mNeededWidth, mViewPortHandler.getChartWidth() * mLegend.getMaxSizePercent()) + mLegend.getXOffset(); break; case RIGHT: offsets.right += Math.min(mLegend.mNeededWidth, mViewPortHandler.getChartWidth() * mLegend.getMaxSizePercent()) + mLegend.getXOffset(); break; case CENTER: switch (mLegend.getVerticalAlignment()) { case TOP: offsets.top += Math.min(mLegend.mNeededHeight, mViewPortHandler.getChartHeight() * mLegend.getMaxSizePercent()) + mLegend.getYOffset(); break; case BOTTOM: offsets.bottom += Math.min(mLegend.mNeededHeight, mViewPortHandler.getChartHeight() * mLegend.getMaxSizePercent()) + mLegend.getYOffset(); break; default: break; } } break; case HORIZONTAL: switch (mLegend.getVerticalAlignment()) { case TOP: offsets.top += Math.min(mLegend.mNeededHeight, mViewPortHandler.getChartHeight() * mLegend.getMaxSizePercent()) + mLegend.getYOffset(); break; case BOTTOM: offsets.bottom += Math.min(mLegend.mNeededHeight, mViewPortHandler.getChartHeight() * mLegend.getMaxSizePercent()) + mLegend.getYOffset(); break; default: break; } break; } } private RectF mOffsetsBuffer = new RectF(); @Override public void calculateOffsets() { if (!mCustomViewPortEnabled) { float offsetLeft = 0f, offsetRight = 0f, offsetTop = 0f, offsetBottom = 0f; calculateLegendOffsets(mOffsetsBuffer); offsetLeft += mOffsetsBuffer.left; offsetTop += mOffsetsBuffer.top; offsetRight += mOffsetsBuffer.right; offsetBottom += mOffsetsBuffer.bottom; // offsets for y-labels if (mAxisLeft.needsOffset()) { offsetLeft += mAxisLeft.getRequiredWidthSpace(mAxisRendererLeft .getPaintAxisLabels()); } if (mAxisRight.needsOffset()) { offsetRight += mAxisRight.getRequiredWidthSpace(mAxisRendererRight .getPaintAxisLabels()); } if (mXAxis.isEnabled() && mXAxis.isDrawLabelsEnabled()) { float xLabelHeight = mXAxis.mLabelRotatedHeight + mXAxis.getYOffset(); // offsets for x-labels if (mXAxis.getPosition() == XAxisPosition.BOTTOM) { offsetBottom += xLabelHeight; } else if (mXAxis.getPosition() == XAxisPosition.TOP) { offsetTop += xLabelHeight; } else if (mXAxis.getPosition() == XAxisPosition.BOTH_SIDED) { offsetBottom += xLabelHeight; offsetTop += xLabelHeight; } } offsetTop += getExtraTopOffset(); offsetRight += getExtraRightOffset(); offsetBottom += getExtraBottomOffset(); offsetLeft += getExtraLeftOffset(); float minOffset = Utils.convertDpToPixel(mMinOffset); mViewPortHandler.restrainViewPort( Math.max(minOffset, offsetLeft), Math.max(minOffset, offsetTop), Math.max(minOffset, offsetRight), Math.max(minOffset, offsetBottom)); if (mLogEnabled) { Log.i(LOG_TAG, "offsetLeft: " + offsetLeft + ", offsetTop: " + offsetTop + ", offsetRight: " + offsetRight + ", offsetBottom: " + offsetBottom); Log.i(LOG_TAG, "Content: " + mViewPortHandler.getContentRect().toString()); } } prepareOffsetMatrix(); prepareValuePxMatrix(); } /** * draws the grid background */ protected void drawGridBackground(Canvas c) { if (mDrawGridBackground) { // draw the grid background c.drawRect(mViewPortHandler.getContentRect(), mGridBackgroundPaint); } if (mDrawBorders) { c.drawRect(mViewPortHandler.getContentRect(), mBorderPaint); } } /** * Returns the Transformer class that contains all matrices and is * responsible for transforming values into pixels on the screen and * backwards. * * @return */ public Transformer getTransformer(AxisDependency which) { if (which == AxisDependency.LEFT) return mLeftAxisTransformer; else return mRightAxisTransformer; } @Override public boolean onTouchEvent(MotionEvent event) { super.onTouchEvent(event); if (mChartTouchListener == null || mData == null) return false; // check if touch gestures are enabled if (!mTouchEnabled) return false; else return mChartTouchListener.onTouch(this, event); } @Override public void computeScroll() { if (mChartTouchListener instanceof BarLineChartTouchListener) ((BarLineChartTouchListener) mChartTouchListener).computeScroll(); } /** * ################ ################ ################ ################ */ /** * CODE BELOW THIS RELATED TO SCALING AND GESTURES AND MODIFICATION OF THE * VIEWPORT */ protected Matrix mZoomMatrixBuffer = new Matrix(); /** * Zooms in by 1.4f, into the charts center. */ public void zoomIn() { MPPointF center = mViewPortHandler.getContentCenter(); mViewPortHandler.zoomIn(center.x, -center.y, mZoomMatrixBuffer); mViewPortHandler.refresh(mZoomMatrixBuffer, this, false); MPPointF.recycleInstance(center); // Range might have changed, which means that Y-axis labels // could have changed in size, affecting Y-axis size. // So we need to recalculate offsets. calculateOffsets(); postInvalidate(); } /** * Zooms out by 0.7f, from the charts center. */ public void zoomOut() { MPPointF center = mViewPortHandler.getContentCenter(); mViewPortHandler.zoomOut(center.x, -center.y, mZoomMatrixBuffer); mViewPortHandler.refresh(mZoomMatrixBuffer, this, false); MPPointF.recycleInstance(center); // Range might have changed, which means that Y-axis labels // could have changed in size, affecting Y-axis size. // So we need to recalculate offsets. calculateOffsets(); postInvalidate(); } /** * Zooms out to original size. */ public void resetZoom() { mViewPortHandler.resetZoom(mZoomMatrixBuffer); mViewPortHandler.refresh(mZoomMatrixBuffer, this, false); // Range might have changed, which means that Y-axis labels // could have changed in size, affecting Y-axis size. // So we need to recalculate offsets. calculateOffsets(); postInvalidate(); } /** * Zooms in or out by the given scale factor. x and y are the coordinates * (in pixels) of the zoom center. * * @param scaleX if < 1f --> zoom out, if > 1f --> zoom in * @param scaleY if < 1f --> zoom out, if > 1f --> zoom in * @param x * @param y */ public void zoom(float scaleX, float scaleY, float x, float y) { mViewPortHandler.zoom(scaleX, scaleY, x, -y, mZoomMatrixBuffer); mViewPortHandler.refresh(mZoomMatrixBuffer, this, false); // Range might have changed, which means that Y-axis labels // could have changed in size, affecting Y-axis size. // So we need to recalculate offsets. calculateOffsets(); postInvalidate(); } /** * Zooms in or out by the given scale factor. * x and y are the values (NOT PIXELS) of the zoom center.. * * @param scaleX * @param scaleY * @param xValue * @param yValue * @param axis the axis relative to which the zoom should take place */ public void zoom(float scaleX, float scaleY, float xValue, float yValue, AxisDependency axis) { Runnable job = ZoomJob.getInstance(mViewPortHandler, scaleX, scaleY, xValue, yValue, getTransformer(axis), axis, this); addViewportJob(job); } /** * Zooms to the center of the chart with the given scale factor. * * @param scaleX * @param scaleY */ public void zoomToCenter(float scaleX, float scaleY) { MPPointF center = getCenterOffsets(); Matrix save = mZoomMatrixBuffer; mViewPortHandler.zoom(scaleX, scaleY, center.x, -center.y, save); mViewPortHandler.refresh(save, this, false); } /** * Zooms by the specified scale factor to the specified values on the specified axis. * * @param scaleX * @param scaleY * @param xValue * @param yValue * @param axis * @param duration */ @TargetApi(11) public void zoomAndCenterAnimated(float scaleX, float scaleY, float xValue, float yValue, AxisDependency axis, long duration) { MPPointD origin = getValuesByTouchPoint(mViewPortHandler.contentLeft(), mViewPortHandler.contentTop(), axis); Runnable job = AnimatedZoomJob.getInstance(mViewPortHandler, this, getTransformer(axis), getAxis(axis), mXAxis .mAxisRange, scaleX, scaleY, mViewPortHandler.getScaleX(), mViewPortHandler.getScaleY(), xValue, yValue, (float) origin.x, (float) origin.y, duration); addViewportJob(job); MPPointD.recycleInstance(origin); } protected Matrix mFitScreenMatrixBuffer = new Matrix(); /** * Resets all zooming and dragging and makes the chart fit exactly it's * bounds. */ public void fitScreen() { Matrix save = mFitScreenMatrixBuffer; mViewPortHandler.fitScreen(save); mViewPortHandler.refresh(save, this, false); calculateOffsets(); postInvalidate(); } /** * Sets the minimum scale factor value to which can be zoomed out. 1f = * fitScreen * * @param scaleX * @param scaleY */ public void setScaleMinima(float scaleX, float scaleY) { mViewPortHandler.setMinimumScaleX(scaleX); mViewPortHandler.setMinimumScaleY(scaleY); } /** * Sets the size of the area (range on the x-axis) that should be maximum * visible at once (no further zooming out allowed). If this is e.g. set to * 10, no more than a range of 10 on the x-axis can be viewed at once without * scrolling. * * @param maxXRange The maximum visible range of x-values. */ public void setVisibleXRangeMaximum(float maxXRange) { float xScale = mXAxis.mAxisRange / (maxXRange); mViewPortHandler.setMinimumScaleX(xScale); } /** * Sets the size of the area (range on the x-axis) that should be minimum * visible at once (no further zooming in allowed). If this is e.g. set to * 10, no less than a range of 10 on the x-axis can be viewed at once without * scrolling. * * @param minXRange The minimum visible range of x-values. */ public void setVisibleXRangeMinimum(float minXRange) { float xScale = mXAxis.mAxisRange / (minXRange); mViewPortHandler.setMaximumScaleX(xScale); } /** * Limits the maximum and minimum x range that can be visible by pinching and zooming. e.g. minRange=10, maxRange=100 the * smallest range to be displayed at once is 10, and no more than a range of 100 values can be viewed at once without * scrolling * * @param minXRange * @param maxXRange */ public void setVisibleXRange(float minXRange, float maxXRange) { float minScale = mXAxis.mAxisRange / minXRange; float maxScale = mXAxis.mAxisRange / maxXRange; mViewPortHandler.setMinMaxScaleX(minScale, maxScale); } /** * Sets the size of the area (range on the y-axis) that should be maximum * visible at once. * * @param maxYRange the maximum visible range on the y-axis * @param axis the axis for which this limit should apply */ public void setVisibleYRangeMaximum(float maxYRange, AxisDependency axis) { float yScale = getAxisRange(axis) / maxYRange; mViewPortHandler.setMinimumScaleY(yScale); } /** * Sets the size of the area (range on the y-axis) that should be minimum visible at once, no further zooming in possible. * * @param minYRange * @param axis the axis for which this limit should apply */ public void setVisibleYRangeMinimum(float minYRange, AxisDependency axis) { float yScale = getAxisRange(axis) / minYRange; mViewPortHandler.setMaximumScaleY(yScale); } /** * Limits the maximum and minimum y range that can be visible by pinching and zooming. * * @param minYRange * @param maxYRange * @param axis */ public void setVisibleYRange(float minYRange, float maxYRange, AxisDependency axis) { float minScale = getAxisRange(axis) / minYRange; float maxScale = getAxisRange(axis) / maxYRange; mViewPortHandler.setMinMaxScaleY(minScale, maxScale); } /** * Moves the left side of the current viewport to the specified x-position. * This also refreshes the chart by calling invalidate(). * * @param xValue */ public void moveViewToX(float xValue) { Runnable job = MoveViewJob.getInstance(mViewPortHandler, xValue, 0f, getTransformer(AxisDependency.LEFT), this); addViewportJob(job); } /** * This will move the left side of the current viewport to the specified * x-value on the x-axis, and center the viewport to the specified y value on the y-axis. * This also refreshes the chart by calling invalidate(). * * @param xValue * @param yValue * @param axis - which axis should be used as a reference for the y-axis */ public void moveViewTo(float xValue, float yValue, AxisDependency axis) { float yInView = getAxisRange(axis) / mViewPortHandler.getScaleY(); Runnable job = MoveViewJob.getInstance(mViewPortHandler, xValue, yValue + yInView / 2f, getTransformer(axis), this); addViewportJob(job); } /** * This will move the left side of the current viewport to the specified x-value * and center the viewport to the y value animated. * This also refreshes the chart by calling invalidate(). * * @param xValue * @param yValue * @param axis * @param duration the duration of the animation in milliseconds */ @TargetApi(11) public void moveViewToAnimated(float xValue, float yValue, AxisDependency axis, long duration) { MPPointD bounds = getValuesByTouchPoint(mViewPortHandler.contentLeft(), mViewPortHandler.contentTop(), axis); float yInView = getAxisRange(axis) / mViewPortHandler.getScaleY(); Runnable job = AnimatedMoveViewJob.getInstance(mViewPortHandler, xValue, yValue + yInView / 2f, getTransformer(axis), this, (float) bounds.x, (float) bounds.y, duration); addViewportJob(job); MPPointD.recycleInstance(bounds); } /** * Centers the viewport to the specified y value on the y-axis. * This also refreshes the chart by calling invalidate(). * * @param yValue * @param axis - which axis should be used as a reference for the y-axis */ public void centerViewToY(float yValue, AxisDependency axis) { float valsInView = getAxisRange(axis) / mViewPortHandler.getScaleY(); Runnable job = MoveViewJob.getInstance(mViewPortHandler, 0f, yValue + valsInView / 2f, getTransformer(axis), this); addViewportJob(job); } /** * This will move the center of the current viewport to the specified * x and y value. * This also refreshes the chart by calling invalidate(). * * @param xValue * @param yValue * @param axis - which axis should be used as a reference for the y axis */ public void centerViewTo(float xValue, float yValue, AxisDependency axis) { float yInView = getAxisRange(axis) / mViewPortHandler.getScaleY(); float xInView = getXAxis().mAxisRange / mViewPortHandler.getScaleX(); Runnable job = MoveViewJob.getInstance(mViewPortHandler, xValue - xInView / 2f, yValue + yInView / 2f, getTransformer(axis), this); addViewportJob(job); } /** * This will move the center of the current viewport to the specified * x and y value animated. * * @param xValue * @param yValue * @param axis * @param duration the duration of the animation in milliseconds */ @TargetApi(11) public void centerViewToAnimated(float xValue, float yValue, AxisDependency axis, long duration) { MPPointD bounds = getValuesByTouchPoint(mViewPortHandler.contentLeft(), mViewPortHandler.contentTop(), axis); float yInView = getAxisRange(axis) / mViewPortHandler.getScaleY(); float xInView = getXAxis().mAxisRange / mViewPortHandler.getScaleX(); Runnable job = AnimatedMoveViewJob.getInstance(mViewPortHandler, xValue - xInView / 2f, yValue + yInView / 2f, getTransformer(axis), this, (float) bounds.x, (float) bounds.y, duration); addViewportJob(job); MPPointD.recycleInstance(bounds); } /** * flag that indicates if a custom viewport offset has been set */ private boolean mCustomViewPortEnabled = false; /** * Sets custom offsets for the current ViewPort (the offsets on the sides of * the actual chart window). Setting this will prevent the chart from * automatically calculating it's offsets. Use resetViewPortOffsets() to * undo this. ONLY USE THIS WHEN YOU KNOW WHAT YOU ARE DOING, else use * setExtraOffsets(...). * * @param left * @param top * @param right * @param bottom */ public void setViewPortOffsets(final float left, final float top, final float right, final float bottom) { mCustomViewPortEnabled = true; post(new Runnable() { @Override public void run() { mViewPortHandler.restrainViewPort(left, top, right, bottom); prepareOffsetMatrix(); prepareValuePxMatrix(); } }); } /** * Resets all custom offsets set via setViewPortOffsets(...) method. Allows * the chart to again calculate all offsets automatically. */ public void resetViewPortOffsets() { mCustomViewPortEnabled = false; calculateOffsets(); } /** * ################ ################ ################ ################ */ /** CODE BELOW IS GETTERS AND SETTERS */ /** * Returns the range of the specified axis. * * @param axis * @return */ protected float getAxisRange(AxisDependency axis) { if (axis == AxisDependency.LEFT) return mAxisLeft.mAxisRange; else return mAxisRight.mAxisRange; } /** * Sets the OnDrawListener * * @param drawListener */ public void setOnDrawListener(OnDrawListener drawListener) { this.mDrawListener = drawListener; } /** * Gets the OnDrawListener. May be null. * * @return */ public OnDrawListener getDrawListener() { return mDrawListener; } protected float[] mGetPositionBuffer = new float[2]; /** * Returns a recyclable MPPointF instance. * Returns the position (in pixels) the provided Entry has inside the chart * view or null, if the provided Entry is null. * * @param e * @return */ public MPPointF getPosition(Entry e, AxisDependency axis) { if (e == null) return null; mGetPositionBuffer[0] = e.getX(); mGetPositionBuffer[1] = e.getY(); getTransformer(axis).pointValuesToPixel(mGetPositionBuffer); return MPPointF.getInstance(mGetPositionBuffer[0], mGetPositionBuffer[1]); } /** * sets the number of maximum visible drawn values on the chart only active * when setDrawValues() is enabled * * @param count */ public void setMaxVisibleValueCount(int count) { this.mMaxVisibleCount = count; } public int getMaxVisibleCount() { return mMaxVisibleCount; } /** * Set this to true to allow highlighting per dragging over the chart * surface when it is fully zoomed out. Default: true * * @param enabled */ public void setHighlightPerDragEnabled(boolean enabled) { mHighlightPerDragEnabled = enabled; } public boolean isHighlightPerDragEnabled() { return mHighlightPerDragEnabled; } /** * Sets the color for the background of the chart-drawing area (everything * behind the grid lines). * * @param color */ public void setGridBackgroundColor(int color) { mGridBackgroundPaint.setColor(color); } /** * Set this to true to enable dragging (moving the chart with the finger) * for the chart (this does not effect scaling). * * @param enabled */ public void setDragEnabled(boolean enabled) { this.mDragXEnabled = enabled; this.mDragYEnabled = enabled; } /** * Returns true if dragging is enabled for the chart, false if not. * * @return */ public boolean isDragEnabled() { return mDragXEnabled || mDragYEnabled; } /** * Set this to true to enable dragging on the X axis * * @param enabled */ public void setDragXEnabled(boolean enabled) { this.mDragXEnabled = enabled; } /** * Returns true if dragging on the X axis is enabled for the chart, false if not. * * @return */ public boolean isDragXEnabled() { return mDragXEnabled; } /** * Set this to true to enable dragging on the Y axis * * @param enabled */ public void setDragYEnabled(boolean enabled) { this.mDragYEnabled = enabled; } /** * Returns true if dragging on the Y axis is enabled for the chart, false if not. * * @return */ public boolean isDragYEnabled() { return mDragYEnabled; } /** * Set this to true to enable scaling (zooming in and out by gesture) for * the chart (this does not effect dragging) on both X- and Y-Axis. * * @param enabled */ public void setScaleEnabled(boolean enabled) { this.mScaleXEnabled = enabled; this.mScaleYEnabled = enabled; } public void setScaleXEnabled(boolean enabled) { mScaleXEnabled = enabled; } public void setScaleYEnabled(boolean enabled) { mScaleYEnabled = enabled; } public boolean isScaleXEnabled() { return mScaleXEnabled; } public boolean isScaleYEnabled() { return mScaleYEnabled; } /** * Set this to true to enable zooming in by double-tap on the chart. * Default: enabled * * @param enabled */ public void setDoubleTapToZoomEnabled(boolean enabled) { mDoubleTapToZoomEnabled = enabled; } /** * Returns true if zooming via double-tap is enabled false if not. * * @return */ public boolean isDoubleTapToZoomEnabled() { return mDoubleTapToZoomEnabled; } /** * set this to true to draw the grid background, false if not * * @param enabled */ public void setDrawGridBackground(boolean enabled) { mDrawGridBackground = enabled; } /** * When enabled, the borders rectangle will be rendered. * If this is enabled, there is no point drawing the axis-lines of x- and y-axis. * * @param enabled */ public void setDrawBorders(boolean enabled) { mDrawBorders = enabled; } /** * When enabled, the borders rectangle will be rendered. * If this is enabled, there is no point drawing the axis-lines of x- and y-axis. * * @return */ public boolean isDrawBordersEnabled() { return mDrawBorders; } /** * When enabled, the values will be clipped to contentRect, * otherwise they can bleed outside the content rect. * * @param enabled */ public void setClipValuesToContent(boolean enabled) { mClipValuesToContent = enabled; } /** * When disabled, the data and/or highlights will not be clipped to contentRect. Disabling this option can * be useful, when the data lies fully within the content rect, but is drawn in such a way (such as thick lines) * that there is unwanted clipping. * * @param enabled */ public void setClipDataToContent(boolean enabled) { mClipDataToContent = enabled; } /** * When enabled, the values will be clipped to contentRect, * otherwise they can bleed outside the content rect. * * @return */ public boolean isClipValuesToContentEnabled() { return mClipValuesToContent; } /** * When disabled, the data and/or highlights will not be clipped to contentRect. Disabling this option can * be useful, when the data lies fully within the content rect, but is drawn in such a way (such as thick lines) * that there is unwanted clipping. * * @return */ public boolean isClipDataToContentEnabled() { return mClipDataToContent; } /** * Sets the width of the border lines in dp. * * @param width */ public void setBorderWidth(float width) { mBorderPaint.setStrokeWidth(Utils.convertDpToPixel(width)); } /** * Sets the color of the chart border lines. * * @param color */ public void setBorderColor(int color) { mBorderPaint.setColor(color); } /** * Gets the minimum offset (padding) around the chart, defaults to 15.f */ public float getMinOffset() { return mMinOffset; } /** * Sets the minimum offset (padding) around the chart, defaults to 15.f */ public void setMinOffset(float minOffset) { mMinOffset = minOffset; } /** * Returns true if keeping the position on rotation is enabled and false if not. */ public boolean isKeepPositionOnRotation() { return mKeepPositionOnRotation; } /** * Sets whether the chart should keep its position (zoom / scroll) after a rotation (orientation change) */ public void setKeepPositionOnRotation(boolean keepPositionOnRotation) { mKeepPositionOnRotation = keepPositionOnRotation; } /** * Returns a recyclable MPPointD instance * Returns the x and y values in the chart at the given touch point * (encapsulated in a MPPointD). This method transforms pixel coordinates to * coordinates / values in the chart. This is the opposite method to * getPixelForValues(...). * * @param x * @param y * @return */ public MPPointD getValuesByTouchPoint(float x, float y, AxisDependency axis) { MPPointD result = MPPointD.getInstance(0, 0); getValuesByTouchPoint(x, y, axis, result); return result; } public void getValuesByTouchPoint(float x, float y, AxisDependency axis, MPPointD outputPoint) { getTransformer(axis).getValuesByTouchPoint(x, y, outputPoint); } /** * Returns a recyclable MPPointD instance * Transforms the given chart values into pixels. This is the opposite * method to getValuesByTouchPoint(...). * * @param x * @param y * @return */ public MPPointD getPixelForValues(float x, float y, AxisDependency axis) { return getTransformer(axis).getPixelForValues(x, y); } /** * returns the Entry object displayed at the touched position of the chart * * @param x * @param y * @return */ public Entry getEntryByTouchPoint(float x, float y) { Highlight h = getHighlightByTouchPoint(x, y); if (h != null) { return mData.getEntryForHighlight(h); } return null; } /** * returns the DataSet object displayed at the touched position of the chart * * @param x * @param y * @return */ public IBarLineScatterCandleBubbleDataSet getDataSetByTouchPoint(float x, float y) { Highlight h = getHighlightByTouchPoint(x, y); if (h != null) { return mData.getDataSetByIndex(h.getDataSetIndex()); } return null; } /** * buffer for storing lowest visible x point */ protected MPPointD posForGetLowestVisibleX = MPPointD.getInstance(0, 0); /** * Returns the lowest x-index (value on the x-axis) that is still visible on * the chart. * * @return */ @Override public float getLowestVisibleX() { getTransformer(AxisDependency.LEFT).getValuesByTouchPoint(mViewPortHandler.contentLeft(), mViewPortHandler.contentBottom(), posForGetLowestVisibleX); float result = (float) Math.max(mXAxis.mAxisMinimum, posForGetLowestVisibleX.x); return result; } /** * buffer for storing highest visible x point */ protected MPPointD posForGetHighestVisibleX = MPPointD.getInstance(0, 0); /** * Returns the highest x-index (value on the x-axis) that is still visible * on the chart. * * @return */ @Override public float getHighestVisibleX() { getTransformer(AxisDependency.LEFT).getValuesByTouchPoint(mViewPortHandler.contentRight(), mViewPortHandler.contentBottom(), posForGetHighestVisibleX); float result = (float) Math.min(mXAxis.mAxisMaximum, posForGetHighestVisibleX.x); return result; } /** * Returns the range visible on the x-axis. * * @return */ public float getVisibleXRange() { return Math.abs(getHighestVisibleX() - getLowestVisibleX()); } /** * returns the current x-scale factor */ public float getScaleX() { if (mViewPortHandler == null) return 1f; else return mViewPortHandler.getScaleX(); } /** * returns the current y-scale factor */ public float getScaleY() { if (mViewPortHandler == null) return 1f; else return mViewPortHandler.getScaleY(); } /** * if the chart is fully zoomed out, return true * * @return */ public boolean isFullyZoomedOut() { return mViewPortHandler.isFullyZoomedOut(); } /** * Returns the left y-axis object. In the horizontal bar-chart, this is the * top axis. * * @return */ public YAxis getAxisLeft() { return mAxisLeft; } /** * Returns the right y-axis object. In the horizontal bar-chart, this is the * bottom axis. * * @return */ public YAxis getAxisRight() { return mAxisRight; } /** * Returns the y-axis object to the corresponding AxisDependency. In the * horizontal bar-chart, LEFT == top, RIGHT == BOTTOM * * @param axis * @return */ public YAxis getAxis(AxisDependency axis) { if (axis == AxisDependency.LEFT) return mAxisLeft; else return mAxisRight; } @Override public boolean isInverted(AxisDependency axis) { return getAxis(axis).isInverted(); } /** * If set to true, both x and y axis can be scaled simultaneously with 2 fingers, if false, * x and y axis can be scaled separately. default: false * * @param enabled */ public void setPinchZoom(boolean enabled) { mPinchZoomEnabled = enabled; } /** * returns true if pinch-zoom is enabled, false if not * * @return */ public boolean isPinchZoomEnabled() { return mPinchZoomEnabled; } /** * Set an offset in dp that allows the user to drag the chart over it's * bounds on the x-axis. * * @param offset */ public void setDragOffsetX(float offset) { mViewPortHandler.setDragOffsetX(offset); } /** * Set an offset in dp that allows the user to drag the chart over it's * bounds on the y-axis. * * @param offset */ public void setDragOffsetY(float offset) { mViewPortHandler.setDragOffsetY(offset); } /** * Returns true if both drag offsets (x and y) are zero or smaller. * * @return */ public boolean hasNoDragOffset() { return mViewPortHandler.hasNoDragOffset(); } public XAxisRenderer getRendererXAxis() { return mXAxisRenderer; } /** * Sets a custom XAxisRenderer and overrides the existing (default) one. * * @param xAxisRenderer */ public void setXAxisRenderer(XAxisRenderer xAxisRenderer) { mXAxisRenderer = xAxisRenderer; } public YAxisRenderer getRendererLeftYAxis() { return mAxisRendererLeft; } /** * Sets a custom axis renderer for the left axis and overwrites the existing one. * * @param rendererLeftYAxis */ public void setRendererLeftYAxis(YAxisRenderer rendererLeftYAxis) { mAxisRendererLeft = rendererLeftYAxis; } public YAxisRenderer getRendererRightYAxis() { return mAxisRendererRight; } /** * Sets a custom axis renderer for the right acis and overwrites the existing one. * * @param rendererRightYAxis */ public void setRendererRightYAxis(YAxisRenderer rendererRightYAxis) { mAxisRendererRight = rendererRightYAxis; } @Override public float getYChartMax() { return Math.max(mAxisLeft.mAxisMaximum, mAxisRight.mAxisMaximum); } @Override public float getYChartMin() { return Math.min(mAxisLeft.mAxisMinimum, mAxisRight.mAxisMinimum); } /** * Returns true if either the left or the right or both axes are inverted. * * @return */ public boolean isAnyAxisInverted() { if (mAxisLeft.isInverted()) return true; if (mAxisRight.isInverted()) return true; return false; } /** * Flag that indicates if auto scaling on the y axis is enabled. This is * especially interesting for charts displaying financial data. * * @param enabled the y axis automatically adjusts to the min and max y * values of the current x axis range whenever the viewport * changes */ public void setAutoScaleMinMaxEnabled(boolean enabled) { mAutoScaleMinMaxEnabled = enabled; } /** * @return true if auto scaling on the y axis is enabled. * @default false */ public boolean isAutoScaleMinMaxEnabled() { return mAutoScaleMinMaxEnabled; } @Override public void setPaint(Paint p, int which) { super.setPaint(p, which); switch (which) { case PAINT_GRID_BACKGROUND: mGridBackgroundPaint = p; break; } } @Override public Paint getPaint(int which) { Paint p = super.getPaint(which); if (p != null) return p; switch (which) { case PAINT_GRID_BACKGROUND: return mGridBackgroundPaint; } return null; } protected float[] mOnSizeChangedBuffer = new float[2]; @Override protected void onSizeChanged(int w, int h, int oldw, int oldh) { // Saving current position of chart. mOnSizeChangedBuffer[0] = mOnSizeChangedBuffer[1] = 0; if (mKeepPositionOnRotation) { mOnSizeChangedBuffer[0] = mViewPortHandler.contentLeft(); mOnSizeChangedBuffer[1] = mViewPortHandler.contentTop(); getTransformer(AxisDependency.LEFT).pixelsToValue(mOnSizeChangedBuffer); } //Superclass transforms chart. super.onSizeChanged(w, h, oldw, oldh); if (mKeepPositionOnRotation) { //Restoring old position of chart. getTransformer(AxisDependency.LEFT).pointValuesToPixel(mOnSizeChangedBuffer); mViewPortHandler.centerViewPort(mOnSizeChangedBuffer, this); } else { mViewPortHandler.refresh(mViewPortHandler.getMatrixTouch(), this, true); } } }