| |
| package com.github.mikephil.charting.renderer; |
| |
| import android.graphics.Canvas; |
| import android.graphics.Paint.Align; |
| import android.graphics.Path; |
| |
| import com.github.mikephil.charting.components.LimitLine; |
| import com.github.mikephil.charting.components.LimitLine.LimitLabelPosition; |
| import com.github.mikephil.charting.components.YAxis; |
| import com.github.mikephil.charting.components.YAxis.AxisDependency; |
| import com.github.mikephil.charting.components.YAxis.YAxisLabelPosition; |
| import com.github.mikephil.charting.utils.PointD; |
| import com.github.mikephil.charting.utils.Transformer; |
| import com.github.mikephil.charting.utils.Utils; |
| import com.github.mikephil.charting.utils.ViewPortHandler; |
| |
| import java.util.List; |
| |
| public class YAxisRendererHorizontalBarChart extends YAxisRenderer { |
| |
| public YAxisRendererHorizontalBarChart(ViewPortHandler viewPortHandler, YAxis yAxis, |
| Transformer trans) { |
| super(viewPortHandler, yAxis, trans); |
| |
| mLimitLinePaint.setTextAlign(Align.LEFT); |
| } |
| |
| /** |
| * Computes the axis values. |
| * |
| * @param yMin - the minimum y-value in the data object for this axis |
| * @param yMax - the maximum y-value in the data object for this axis |
| */ |
| public void computeAxis(float yMin, float yMax) { |
| |
| // calculate the starting and entry point of the y-labels (depending on |
| // zoom / contentrect bounds) |
| if (mViewPortHandler.contentHeight() > 10 && !mViewPortHandler.isFullyZoomedOutX()) { |
| |
| PointD p1 = mTrans.getValuesByTouchPoint(mViewPortHandler.contentLeft(), |
| mViewPortHandler.contentTop()); |
| PointD p2 = mTrans.getValuesByTouchPoint(mViewPortHandler.contentRight(), |
| mViewPortHandler.contentTop()); |
| |
| if (!mYAxis.isInverted()) { |
| yMin = (float) p1.x; |
| yMax = (float) p2.x; |
| } else { |
| |
| if (!mYAxis.isStartAtZeroEnabled()) |
| yMin = (float) Math.min(p1.x, p2.x); |
| else |
| yMin = 0; |
| yMax = (float) Math.max(p1.x, p2.x); |
| } |
| } |
| |
| computeAxisValues(yMin, yMax); |
| } |
| |
| /** |
| * draws the y-axis labels to the screen |
| */ |
| @Override |
| public void renderAxisLabels(Canvas c) { |
| |
| if (!mYAxis.isEnabled() || !mYAxis.isDrawLabelsEnabled()) |
| return; |
| |
| float[] positions = new float[mYAxis.mEntryCount * 2]; |
| |
| for (int i = 0; i < positions.length; i += 2) { |
| // only fill y values, x values are not needed since the y-labels |
| // are |
| // static on the x-axis |
| positions[i] = mYAxis.mEntries[i / 2]; |
| } |
| |
| mTrans.pointValuesToPixel(positions); |
| |
| mAxisLabelPaint.setTypeface(mYAxis.getTypeface()); |
| mAxisLabelPaint.setTextSize(mYAxis.getTextSize()); |
| mAxisLabelPaint.setColor(mYAxis.getTextColor()); |
| mAxisLabelPaint.setTextAlign(Align.CENTER); |
| |
| float yoffset = Utils.calcTextHeight(mAxisLabelPaint, "A") + mYAxis.getYOffset(); |
| |
| AxisDependency dependency = mYAxis.getAxisDependency(); |
| YAxisLabelPosition labelPosition = mYAxis.getLabelPosition(); |
| |
| float yPos = 0f; |
| |
| if (dependency == AxisDependency.LEFT) { |
| |
| if (labelPosition == YAxisLabelPosition.OUTSIDE_CHART) { |
| yoffset = Utils.convertDpToPixel(3f); |
| yPos = mViewPortHandler.contentTop(); |
| } else { |
| yoffset = yoffset * -1f; |
| yPos = mViewPortHandler.contentTop(); |
| } |
| |
| } else { |
| |
| if (labelPosition == YAxisLabelPosition.OUTSIDE_CHART) { |
| yoffset = yoffset * -1f; |
| yPos = mViewPortHandler.contentBottom(); |
| } else { |
| yoffset = Utils.convertDpToPixel(4f); |
| yPos = mViewPortHandler.contentBottom(); |
| } |
| } |
| |
| drawYLabels(c, yPos, positions, yoffset); |
| } |
| |
| @Override |
| public void renderAxisLine(Canvas c) { |
| |
| if (!mYAxis.isEnabled() || !mYAxis.isDrawAxisLineEnabled()) |
| return; |
| |
| mAxisLinePaint.setColor(mYAxis.getAxisLineColor()); |
| mAxisLinePaint.setStrokeWidth(mYAxis.getAxisLineWidth()); |
| |
| if (mYAxis.getAxisDependency() == AxisDependency.LEFT) { |
| c.drawLine(mViewPortHandler.contentLeft(), |
| mViewPortHandler.contentTop(), mViewPortHandler.contentRight(), |
| mViewPortHandler.contentTop(), mAxisLinePaint); |
| } else { |
| c.drawLine(mViewPortHandler.contentLeft(), |
| mViewPortHandler.contentBottom(), mViewPortHandler.contentRight(), |
| mViewPortHandler.contentBottom(), mAxisLinePaint); |
| } |
| } |
| |
| /** |
| * draws the y-labels on the specified x-position |
| * |
| * @param fixedPosition |
| * @param positions |
| */ |
| @Override |
| protected void drawYLabels(Canvas c, float fixedPosition, float[] positions, float offset) { |
| |
| mAxisLabelPaint.setTypeface(mYAxis.getTypeface()); |
| mAxisLabelPaint.setTextSize(mYAxis.getTextSize()); |
| mAxisLabelPaint.setColor(mYAxis.getTextColor()); |
| |
| for (int i = 0; i < mYAxis.mEntryCount; i++) { |
| |
| String text = mYAxis.getFormattedLabel(i); |
| |
| if (!mYAxis.isDrawTopYLabelEntryEnabled() && i >= mYAxis.mEntryCount - 1) |
| return; |
| |
| c.drawText(text, positions[i * 2], fixedPosition - offset, mAxisLabelPaint); |
| } |
| } |
| |
| @Override |
| public void renderGridLines(Canvas c) { |
| |
| if (!mYAxis.isDrawGridLinesEnabled() || !mYAxis.isEnabled()) |
| return; |
| |
| // pre alloc |
| float[] position = new float[2]; |
| |
| mGridPaint.setColor(mYAxis.getGridColor()); |
| mGridPaint.setStrokeWidth(mYAxis.getGridLineWidth()); |
| |
| // draw the horizontal grid |
| for (int i = 0; i < mYAxis.mEntryCount; i++) { |
| |
| position[0] = mYAxis.mEntries[i]; |
| mTrans.pointValuesToPixel(position); |
| |
| c.drawLine(position[0], mViewPortHandler.contentTop(), position[0], |
| mViewPortHandler.contentBottom(), |
| mGridPaint); |
| } |
| } |
| |
| /** |
| * Draws the LimitLines associated with this axis to the screen. |
| * |
| * @param c |
| */ |
| @Override |
| public void renderLimitLines(Canvas c) { |
| |
| List<LimitLine> limitLines = mYAxis.getLimitLines(); |
| |
| if (limitLines == null || limitLines.size() <= 0) |
| return; |
| |
| float[] pts = new float[4]; |
| Path limitLinePath = new Path(); |
| |
| for (int i = 0; i < limitLines.size(); i++) { |
| |
| LimitLine l = limitLines.get(i); |
| |
| pts[0] = l.getLimit(); |
| pts[2] = l.getLimit(); |
| |
| mTrans.pointValuesToPixel(pts); |
| |
| pts[1] = mViewPortHandler.contentTop(); |
| pts[3] = mViewPortHandler.contentBottom(); |
| |
| limitLinePath.moveTo(pts[0], pts[1]); |
| limitLinePath.lineTo(pts[2], pts[3]); |
| |
| mLimitLinePaint.setColor(l.getLineColor()); |
| mLimitLinePaint.setPathEffect(l.getDashPathEffect()); |
| mLimitLinePaint.setStrokeWidth(l.getLineWidth()); |
| |
| c.drawPath(limitLinePath, mLimitLinePaint); |
| limitLinePath.reset(); |
| |
| String label = l.getLabel(); |
| |
| // if drawing the limit-value label is enabled |
| if (label != null && !label.equals("")) { |
| |
| float xOffset = l.getLineWidth(); |
| float add = Utils.convertDpToPixel(4f); |
| |
| mLimitLinePaint.setPathEffect(null); |
| mLimitLinePaint.setColor(l.getTextColor()); |
| mLimitLinePaint.setStrokeWidth(0.5f); |
| mLimitLinePaint.setTextSize(l.getTextSize()); |
| |
| float yOffset = Utils.calcTextHeight(mLimitLinePaint, label) + add / 2f; |
| |
| if (l.getLabelPosition() == LimitLabelPosition.POS_RIGHT) { |
| c.drawText(label, pts[0] + xOffset, mViewPortHandler.contentBottom() - add, mLimitLinePaint); |
| |
| } else { |
| c.drawText(label, pts[0] + xOffset, mViewPortHandler.contentTop() + yOffset, mLimitLinePaint); |
| } |
| } |
| } |
| } |
| } |