~repos /gdx-studio

/*******************************************************************************
 * 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;
  }
}