/*******************************************************************************
* Copyright 2011 See AUTHORS file.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
******************************************************************************/
package com.badlogic.gdx.tools.particleeditor;
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.GridBagLayout;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.MouseMotionListener;
import java.util.ArrayList;
import javax.swing.JPanel;
class Chart extends JPanel {
static private final int POINT_SIZE = 6;
static private final int POINT_SIZE_EXPANDED = 10;
ArrayList<Point> points = new ArrayList();
private int numberHeight;
int chartX, chartY;
int chartWidth, chartHeight;
int maxX, maxY;
int overIndex = -1;
int movingIndex = -1;
boolean isExpanded;
String title;
public Chart (String title) {
this.title = title;
setLayout(new GridBagLayout());
addMouseListener(new MouseAdapter() {
public void mousePressed (MouseEvent event) {
movingIndex = overIndex;
}
public void mouseReleased (MouseEvent event) {
movingIndex = -1;
}
public void mouseClicked (MouseEvent event) {
if (event.getClickCount() == 2) {
if (overIndex <= 0) return;
points.remove(overIndex);
pointsChanged();
repaint();
return;
}
if (movingIndex != -1) return;
if (overIndex != -1) return;
int mouseX = event.getX();
int mouseY = event.getY();
if (mouseX < chartX || mouseX > chartX + chartWidth) return;
if (mouseY < chartY || mouseY > chartY + chartHeight) return;
Point newPoint = pixelToPoint(mouseX, mouseY);
int i = 0;
Point lastPoint = null;
for (Point point : points) {
if (point.x > newPoint.x) {
if (Math.abs(point.x - newPoint.x) < 0.001f) return;
if (lastPoint != null && Math.abs(lastPoint.x - newPoint.x) < 0.001f) return;
points.add(i, newPoint);
overIndex = i;
pointsChanged();
repaint();
return;
}
lastPoint = point;
i++;
}
overIndex = points.size();
points.add(newPoint);
pointsChanged();
repaint();
}
});
addMouseMotionListener(new MouseMotionListener() {
public void mouseDragged (MouseEvent event) {
if (movingIndex == -1) return;
float nextX = movingIndex == points.size() - 1 ? maxX : points.get(movingIndex + 1).x - 0.001f;
if (movingIndex == 0) nextX = 0;
float prevX = movingIndex == 0 ? 0 : points.get(movingIndex - 1).x + 0.001f;
Point point = points.get(movingIndex);
point.x = Math.min(nextX, Math.max(prevX, (event.getX() - chartX) / (float)chartWidth * maxX));
point.y = Math.min(maxY, Math.max(0, chartHeight - (event.getY() - chartY)) / (float)chartHeight * maxY);
pointsChanged();
repaint();
}
public void mouseMoved (MouseEvent event) {
int mouseX = event.getX();
int mouseY = event.getY();
int oldIndex = overIndex;
overIndex = -1;
int pointSize = isExpanded ? POINT_SIZE_EXPANDED : POINT_SIZE;
int i = 0;
for (Point point : points) {
int x = chartX + (int)(chartWidth * (point.x / (float)maxX));
int y = chartY + chartHeight - (int)(chartHeight * (point.y / (float)maxY));
if (Math.abs(x - mouseX) <= pointSize && Math.abs(y - mouseY) <= pointSize) {
overIndex = i;
break;
}
i++;
}
if (overIndex != oldIndex) repaint();
}
});
}
public void addPoint (float x, float y) {
points.add(new Point(x, y));
}
public void pointsChanged () {
}
public float[] getValuesX () {
float[] values = new float[points.size()];
int i = 0;
for (Point point : points)
values[i++] = point.x;
return values;
}
public float[] getValuesY () {
float[] values = new float[points.size()];
int i = 0;
for (Point point : points)
values[i++] = point.y;
return values;
}
public void setValues (float[] x, float[] y) {
points.clear();
for (int i = 0; i < x.length; i++)
points.add(new Point(x[i], y[i]));
}
Point pixelToPoint (float x, float y) {
Point point = new Point();
point.x = Math.min(maxX, Math.max(0, x - chartX) / (float)chartWidth * maxX);
point.y = Math.min(maxY, Math.max(0, chartHeight - (y - chartY)) / (float)chartHeight * maxY);
return point;
}
Point pointToPixel (Point point) {
Point pixel = new Point();
pixel.x = chartX + (int)(chartWidth * (point.x / (float)maxX));
pixel.y = chartY + chartHeight - (int)(chartHeight * (point.y / (float)maxY));
return pixel;
}
protected void paintComponent (Graphics graphics) {
// setOpaque(true);
// setBackground(Color.red);
super.paintComponent(graphics);
Graphics2D g = (Graphics2D)graphics;
FontMetrics metrics = g.getFontMetrics();
if (numberHeight == 0) {
numberHeight = getFont().layoutGlyphVector(g.getFontRenderContext(), new char[] {'0'}, 0, 1, Font.LAYOUT_LEFT_TO_RIGHT)
.getGlyphPixelBounds(0, g.getFontRenderContext(), 0, 0).height;
}
int width = getWidth();
if (!isExpanded) width = Math.min(150, width);
width = Math.max(100, width);
int height = getHeight();
int maxAxisLabelWidth;
int yAxisWidth;
if (isExpanded) {
maxAxisLabelWidth = metrics.stringWidth("100%");
yAxisWidth = maxAxisLabelWidth + 8;
chartX = yAxisWidth;
chartY = numberHeight / 2 + 1;
chartWidth = width - yAxisWidth - 2;
chartHeight = height - chartY - numberHeight - 8;
} else {
maxAxisLabelWidth = 0;
yAxisWidth = 2;
chartX = yAxisWidth;
chartY = 2;
chartWidth = width - yAxisWidth - 2;
chartHeight = height - chartY - 3;
}
g.setColor(Color.white);
g.fillRect(chartX, chartY, chartWidth, chartHeight);
g.setColor(Color.black);
g.drawRect(chartX, chartY, chartWidth, chartHeight);
maxX = 1;
{
int y = height;
if (isExpanded)
y -= numberHeight;
else
y += 5;
int xSplit = (int)Math.min(10, chartWidth / (maxAxisLabelWidth * 1.5f));
for (int i = 0; i <= xSplit; i++) {
float percent = i / (float)xSplit;
String label = axisLabel(maxX * percent);
int labelWidth = metrics.stringWidth(label);
int x = (int)(yAxisWidth + chartWidth * percent);
if (i != 0 && i != xSplit) {
g.setColor(Color.lightGray);
g.drawLine(x, chartY + 1, x, chartY + chartHeight);
g.setColor(Color.black);
}
g.drawLine(x, y - 4, x, y - 8);
if (isExpanded) {
x -= labelWidth / 2;
if (i == xSplit) x = Math.min(x, width - labelWidth);
g.drawString(label, x, y + numberHeight);
}
}
}
maxY = 1;
{
int ySplit = isExpanded ? Math.min(10, chartHeight / (numberHeight * 3)) : 4;
for (int i = 0; i <= ySplit; i++) {
float percent = i / (float)ySplit;
String label = axisLabel(maxY * percent);
int labelWidth = metrics.stringWidth(label);
int y = (int)(chartY + chartHeight - chartHeight * percent);
if (isExpanded) g.drawString(label, yAxisWidth - 6 - labelWidth, y + numberHeight / 2);
if (i != 0 && i != ySplit) {
g.setColor(Color.lightGray);
g.drawLine(chartX, y, chartX + chartWidth - 1, y);
g.setColor(Color.black);
}
g.drawLine(yAxisWidth - 4, y, yAxisWidth, y);
}
}
{
int titleWidth = metrics.stringWidth(title);
int x = yAxisWidth + chartWidth / 2 - titleWidth / 2;
int y = chartY + chartHeight / 2 - numberHeight / 2;
g.setColor(Color.white);
g.fillRect(x - 2, y - 2, titleWidth + 4, numberHeight + 4);
g.setColor(Color.lightGray);
g.drawString(title, x, y + numberHeight);
}
g.setColor(Color.blue);
g.setStroke(new BasicStroke(isExpanded ? 3 : 2));
int lastX = -1, lastY = -1;
for (Point point : points) {
Point pixel = pointToPixel(point);
if (lastX != -1) g.drawLine(lastX, lastY, (int)pixel.x, (int)pixel.y);
lastX = (int)pixel.x;
lastY = (int)pixel.y;
}
g.drawLine(lastX, lastY, chartX + chartWidth - 1, lastY);
for (int i = 0, n = points.size(); i < n; i++) {
Point point = points.get(i);
Point pixel = pointToPixel(point);
if (overIndex == i)
g.setColor(Color.red);
else
g.setColor(Color.black);
String label = valueLabel(point.y);
int labelWidth = metrics.stringWidth(label);
int pointSize = isExpanded ? POINT_SIZE_EXPANDED : POINT_SIZE;
int x = (int)pixel.x - pointSize / 2;
int y = (int)pixel.y - pointSize / 2;
g.fillOval(x, y, pointSize, pointSize);
if (isExpanded) {
g.setColor(Color.black);
x = Math.max(chartX + 2, Math.min(chartX + chartWidth - labelWidth, x));
y -= 3;
if (y < chartY + numberHeight + 3)
y += 27;
else if (n > 1) {
Point comparePoint = i == n - 1 ? points.get(i - 1) : points.get(i + 1);
if (y < chartY + chartHeight - 27 && comparePoint.y > point.y) y += 27;
}
g.drawString(label, x, y);
}
}
}
private String valueLabel (float value) {
value = (int)(value * 1000) / 10f;
if (value % 1 == 0)
return String.valueOf((int)value) + '%';
else
return String.valueOf(value) + '%';
}
private String axisLabel (float value) {
value = (int)(value * 100);
if (value % 1 == 0)
return String.valueOf((int)value) + '%';
else
return String.valueOf(value) + '%';
}
static public class Point {
public float x;
public float y;
public Point () {
}
public Point (float x, float y) {
this.x = x;
this.y = y;
}
}
public boolean isExpanded () {
return isExpanded;
}
public void setExpanded (boolean isExpanded) {
this.isExpanded = isExpanded;
}
}