forked from LupusNobilis/java-org.hwo.ui
239 lines
5.2 KiB
Java
239 lines
5.2 KiB
Java
package org.hwo.ui.diagram;
|
|
|
|
import java.awt.Color;
|
|
import java.beans.MethodDescriptor;
|
|
import java.lang.reflect.Field;
|
|
import java.lang.reflect.InvocationTargetException;
|
|
import java.lang.reflect.Method;
|
|
import java.lang.reflect.Type;
|
|
import java.util.Arrays;
|
|
import java.util.LinkedList;
|
|
import java.util.List;
|
|
import java.util.Vector;
|
|
|
|
import org.hwo.ui.diagram.annotation.Plot;
|
|
|
|
public class AnnotatedPlotProvider implements PlotProvider2{
|
|
|
|
private Class<?>
|
|
clazz;
|
|
|
|
private GraphDefinition[]
|
|
graphDefinitions;
|
|
|
|
private int maxOrdinate;
|
|
|
|
private Color[] colors;
|
|
|
|
private Vector<Object>
|
|
values;
|
|
|
|
private int diagram;
|
|
|
|
public AnnotatedPlotProvider(Class<?> clazz){
|
|
this.setClazz(clazz);
|
|
this.setValues(new Object[0]);
|
|
this.diagram = 0;
|
|
}
|
|
|
|
public AnnotatedPlotProvider(Class<?> clazz,int diagram){
|
|
this.diagram = diagram;
|
|
this.setClazz(clazz);
|
|
this.setValues(new Object[0]);
|
|
}
|
|
|
|
public void setClazz(Class<?> clazz) {
|
|
this.clazz = clazz;
|
|
updateClazz();
|
|
}
|
|
public Class<?> getClazz() {
|
|
return clazz;
|
|
}
|
|
|
|
|
|
|
|
public void setValues(Object[] values) {
|
|
this.values = new Vector<Object>();
|
|
this.values.addAll(Arrays.asList(values));
|
|
}
|
|
public void setValues(Vector v){
|
|
this.values = v;
|
|
}
|
|
public Vector<Object> getValues() {
|
|
return values;
|
|
}
|
|
|
|
private void updateClazz(){
|
|
LinkedList<GraphDefinition> gdl = new LinkedList<AnnotatedPlotProvider.GraphDefinition>();
|
|
|
|
for (Field f: this.clazz.getDeclaredFields()){
|
|
Plot plot = f.getAnnotation(Plot.class);
|
|
if (plot != null){
|
|
if (plot.diagram() == this.diagram)
|
|
gdl.add(new GraphDefinition(f));
|
|
}
|
|
}
|
|
for (Method m: this.clazz.getDeclaredMethods()){
|
|
Plot plot = m.getAnnotation(Plot.class);
|
|
if (plot != null){
|
|
if (plot.diagram() == this.diagram)
|
|
gdl.add(new GraphDefinition(m));
|
|
}
|
|
}
|
|
|
|
this.colors = new Color[ gdl.size() ];
|
|
|
|
for (GraphDefinition gd: gdl){
|
|
if (gd.getOrdinate() > maxOrdinate)
|
|
maxOrdinate = gd.getOrdinate();
|
|
this.colors[ gdl.indexOf(gd) ] = gd.getColor();
|
|
}
|
|
|
|
this.graphDefinitions = gdl.toArray(new GraphDefinition[0]);
|
|
}
|
|
|
|
public Color getColor(int graph){
|
|
return this.colors[graph];
|
|
}
|
|
public void setColors(int graph,Color color) {
|
|
this.colors[graph] = color;
|
|
}
|
|
|
|
@Override
|
|
public int getNumGraphs() {
|
|
return this.graphDefinitions.length;
|
|
}
|
|
|
|
@Override
|
|
public Color[] getColors() {
|
|
return this.colors;
|
|
}
|
|
|
|
public int getMaxOrdinate() {
|
|
return maxOrdinate;
|
|
}
|
|
|
|
public int getLength(){
|
|
return this.values.size();
|
|
}
|
|
|
|
public String getLabel(int graph){
|
|
return this.graphDefinitions[graph].getLabel();
|
|
}
|
|
|
|
public Float getValue(int x,int graph){
|
|
Object o = this.values.get(x);
|
|
if (o==null)
|
|
return null;
|
|
return this.graphDefinitions[graph].getValue(o);
|
|
}
|
|
|
|
public int getOrdinate(int graph){
|
|
return this.graphDefinitions[graph].getOrdinate();
|
|
}
|
|
|
|
class GraphDefinition{
|
|
|
|
Method method;
|
|
Field field;
|
|
|
|
String label;
|
|
int ordinate;
|
|
|
|
Color color;
|
|
|
|
public GraphDefinition(Method method){
|
|
this.method = method;
|
|
this.setPlot(method.getAnnotation(Plot.class));
|
|
}
|
|
public GraphDefinition(Field field){
|
|
this.field = field;
|
|
this.field.setAccessible(true);
|
|
this.setPlot(field.getAnnotation(Plot.class));
|
|
}
|
|
|
|
private void setPlot(Plot plot){
|
|
this.label = plot.label();
|
|
this.ordinate = plot.ordinate();
|
|
this.color = new Color(plot.r(), plot.g(), plot.b());
|
|
}
|
|
|
|
public int getOrdinate() {
|
|
return ordinate;
|
|
}
|
|
public String getLabel() {
|
|
return label;
|
|
}
|
|
|
|
public Color getColor() {
|
|
return color;
|
|
}
|
|
|
|
public Float getValue(Object o){
|
|
try {
|
|
if (field != null){
|
|
if (field.getType().equals(Integer.class)){
|
|
return ((Integer)field.get(o)).floatValue();
|
|
};
|
|
if (field.getType().equals(Double.class)){
|
|
return ((Double)field.get(o)).floatValue();
|
|
}
|
|
if (field.getType().equals(Float.class)){
|
|
return (Float)field.get(o);
|
|
}
|
|
}
|
|
if (method != null){
|
|
if (method.getReturnType().equals(Integer.class)){
|
|
return ((Integer)method.invoke(o, null)).floatValue();
|
|
}
|
|
if (method.getReturnType().equals(Double.class)){
|
|
return ((Double)method.invoke(o, null)).floatValue();
|
|
}
|
|
if (method.getReturnType().equals(Float.class)){
|
|
return ((Float)method.invoke(o, null));
|
|
}
|
|
}
|
|
} catch (IllegalAccessException illegalAccessException){
|
|
illegalAccessException.printStackTrace();
|
|
return null;
|
|
} catch (InvocationTargetException invocationTargetException){
|
|
invocationTargetException.printStackTrace();
|
|
return null;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
}
|
|
|
|
@Override
|
|
public Float getPosition(int x, int graph) {
|
|
return (float)x;
|
|
}
|
|
|
|
@Override
|
|
public Float getPositionMinimum() {
|
|
return 0.0f;
|
|
}
|
|
|
|
@Override
|
|
public Float getPositionMaximum() {
|
|
return this.values.size()-1.0f;
|
|
}
|
|
|
|
private LinkedList<PlotProviderListener> plotProviderListeners = new LinkedList<PlotProviderListener>();
|
|
|
|
@Override
|
|
public void addPlotProviderListener(PlotProviderListener listener) {
|
|
plotProviderListeners.add(listener);
|
|
}
|
|
@Override
|
|
public void removePlotProviderListener(PlotProviderListener listener) {
|
|
plotProviderListeners.remove(listener);
|
|
}
|
|
|
|
private void fireFundamentalsChanged(){
|
|
for (PlotProviderListener l: plotProviderListeners)
|
|
l.fundamentalsChanged(this);
|
|
}
|
|
}
|