net.team2xh.environment.widgets.graphs.BarChart.java Source code

Introduction

Here is the source code for net.team2xh.environment.widgets.graphs.BarChart.java

Source

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package net.team2xh.environment.widgets.graphs;

import com.badlogic.gdx.Gdx;
import com.badlogic.gdx.graphics.Color;
import com.badlogic.gdx.graphics.GL20;
import com.badlogic.gdx.graphics.g2d.Batch;
import com.badlogic.gdx.graphics.g2d.BitmapFont;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer;
import com.badlogic.gdx.graphics.glutils.ShapeRenderer.ShapeType;
import java.util.Map;
import net.team2xh.environment.constants.Colors;
import net.team2xh.environment.util.MathHelpers;
import net.team2xh.environment.widgets.graphs.datasets.MapDataset;

/**
 *
 * @author Tenchi
 */
public class BarChart extends Graph {

    private final MapDataset data;

    public boolean horizontal = true;
    public boolean showAxis = true;
    public boolean showLabels = true;
    public boolean showValues = true;
    public boolean valuesAsPercentage = false;

    private float xAxisMargin;
    private float yAxisMargin;
    private float thickness;
    private float maxLength;
    private float maxValue;
    private float padding;

    private Colors[] colors = Colors.getArrangement();
    private int color = 0;

    // Temporarily using default bitmap font
    private BitmapFont font = new BitmapFont();

    public BarChart(MapDataset data) {
        super();
        this.data = data;
    }

    @Override
    public void update(float delta) {
        updateDimensions();
        color = 0;
    }

    private void updateDimensions() {
        padding = 0.02f * getWidth();
        if (horizontal) {
            yAxisMargin = (2 * padding) + data.getLargestLabelWidth();
            thickness = (getHeight() - (data.getSize() + 2) * padding - xAxisMargin) / data.getSize();
            maxLength = (getWidth() - yAxisMargin - padding);

        } else {
            yAxisMargin = (2 * padding) + data.getLargestValueWidth();
            thickness = (getWidth() - (data.getSize() + 2) * padding - yAxisMargin) / data.getSize();
            maxLength = (getHeight() - xAxisMargin - padding);
        }
        xAxisMargin = 2 * padding + font.getCapHeight();
        maxValue = MathHelpers.getCeiling(data.getMaxValue().doubleValue());
    }

    private void nextColor() {
        color = (color + 1) % colors.length;
    }

    @Override
    public void render(ShapeRenderer renderer, Batch batch) {

        Gdx.gl.glEnable(GL20.GL_BLEND);
        Gdx.gl.glBlendFunc(GL20.GL_SRC_ALPHA, GL20.GL_ONE_MINUS_SRC_ALPHA);

        renderer.setAutoShapeType(true);
        renderer.begin();
        {
            //Gdx.gl.glLineWidth(1.0f);
            renderer.translate(getX(), getY(), 0);

            renderer.set(ShapeType.Line);
            renderer.setColor(Color.GRAY);
            renderer.rect(0, 0, getWidth(), getHeight());

            // TODO: Grid

            renderer.set(ShapeType.Line);
            renderer.setColor(Color.WHITE);
            if (showAxis) {
                // Vertical
                renderer.line(yAxisMargin, xAxisMargin, yAxisMargin, getHeight() - padding);
                // Horizontal
                renderer.line(yAxisMargin, xAxisMargin, getWidth() - padding, xAxisMargin);
            }

            // Bars
            renderer.translate(0, 0, -1);
            int i = 1;
            for (Map.Entry<String, Number> e : data) {
                float length = maxLength * (e.getValue().floatValue() / maxValue);
                Colors c = colors[color];
                renderer.set(ShapeType.Filled);
                renderer.setColor(c.transparent());
                if (horizontal) {
                    renderer.rect(yAxisMargin, getHeight() - (i + 1) * padding - i * thickness, length, thickness);
                } else {
                    renderer.rect(yAxisMargin + i * padding + (i - 1) * thickness, xAxisMargin, thickness, length);
                }
                renderer.set(ShapeType.Line);
                renderer.setColor(c.color());
                if (horizontal) {
                    renderer.rect(yAxisMargin, getHeight() - (i + 1) * padding - i * thickness,
                            maxLength * (e.getValue().floatValue() / maxValue), thickness);
                } else {
                    renderer.rect(yAxisMargin + i * padding + (i - 1) * thickness, xAxisMargin, thickness, length);
                }
                ++i;
                nextColor();
            }
            renderer.translate(0, 0, +1);

            renderer.translate(-getX(), -getY(), 0);
        }
        renderer.end();

        batch.begin();
        {
            int i = 0;
            for (Map.Entry<String, Number> e : data) {
                if (horizontal) {
                    font.draw(batch, e.getKey(), getX() + yAxisMargin - padding - font.getBounds(e.getKey()).width,
                            getY() + getHeight() + font.getCapHeight() / 2
                                    - (xAxisMargin + 2 * padding + i * (thickness + padding)));
                    // TODO: Values axis    
                }
                // TODO: Vertical
                ++i;
            }
        }
        batch.end();

        Gdx.gl.glDisable(GL20.GL_BLEND);

    }

    public MapDataset getData() {
        return data;
    }

}