监控界面.png
画面板 MonitorPanel
package com.wwh.test.swing.monitor;
import java.awt.Color;
import java.awt.Font;
import java.awt.FontMetrics;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.image.BufferedImage;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.List;
import javax.swing.JPanel;
/**
* <pre>
* 有XY轴的曲线图监控面板
*
* <pre>
*
* @author 313921
* @date 2015-01-28 22:11:04
*/
public class MonitorPanel extends JPanel implements MonitorPanelModelListener {
/**
* 最合适的Y轴线条高度间距
*/
private static final int bastYAxisLineHeightInterval = 26;
/**
* X轴上默认的线与线之间的像素
*/
public static final int DEFAULT_X_AXIS_LINE_INTERVAL = 70;
/**
* 默认的当前值文本宽度
*/
private static final int defaultCurrentTextWidth = 50;
/**
* 最少的Y轴线条数量
*/
private static final int minYAxisLineCount = 3;
private static final long serialVersionUID = 1L;
/**
* 图片
*/
private BufferedImage bufferImage;
/**
* 显示当前值的文本宽度
*/
private int currentTextWidth = 50;
private MonitorPanelModel dataModel;
private SimpleDateFormat dateF = new SimpleDateFormat("HH:mm");
/**
* 是否显示最后一个值
*/
private boolean displayLastValue = true;
private boolean drawEmptyGraph = true;
private Color fontColor = Color.BLACK;
/**
* 曲线区域的背景颜色
*/
private Color graphBackgroundColor = new Color(0, 100, 0);
private Graphics2D graphics;
/**
* 曲线的颜色
*/
private Color graphLineColor = new Color(250, 0, 0);
private String graphTitle = "监控面板";
private Color gridLineColor = new Color(0, 0, 0);
/**
* 图片的高度
*/
private int imgHeight;
/**
* 图片的宽度，整个组件就是一个画上去的图片
*/
private int imgWidth;
/**
* 标题字体
*/
private Font titleFont = new Font("宋体", Font.BOLD, 14);
/**
* 标题颜色
*/
private Color titleFontColor = Color.BLACK;
/**
* 标题的高度
*/
private int titleHeight = 20;
/**
* X轴上的线与线之间的像素
*/
private int xAxisLineInterval = DEFAULT_X_AXIS_LINE_INTERVAL;
/**
* X轴上的一个与像素点的比例
*/
private double xRatio;
/**
* X轴的文本高度
*/
private int XTextHeight = 20;
/**
* Y轴上一个与像素点的比例
*/
private double yRatio;
/**
* Y轴的文本宽度
*/
private int YTextWidth = 40;
public MonitorPanel() {
this(null);
}
public MonitorPanel(MonitorPanelModel model) {
if (model == null) {
model = new MonitorPanelModel();
}
setModel(model);
updateUI();
}
/**
* <pre>
* 计算X轴的比例
* </pre>
*/
private void calcXRatio() {
Long maxXCoords = dataModel.getMaxXCoords();
if (maxXCoords == null) {
return;
}
Long minXCoords = dataModel.getMinXCoords();
if (minXCoords == null) {
return;
}
// 曲线图的宽度
int graphWidth = getGraphWidth();
if (graphWidth <= 0) {
xRatio = 0;
return;
}
long xv = maxXCoords - minXCoords;
// 得到比例
xRatio = (double) graphWidth / (double) xv;
}
/**
* <pre>
* 计算Y轴比例
* 既：值与显示区域的像素的比例
* </pre>
*/
private void calcYRatio() {
Long maxYCoords = dataModel.getMaxYCoords();
if (maxYCoords == null) {
return;
}
Long minYCoords = dataModel.getMinYCoords();
if (minYCoords == null) {
return;
}
// 计算曲线图的高度
int graphHeight = getGraphHeight();
if (graphHeight <= 0) {
yRatio = 0;
return;
}
long yd = maxYCoords - minYCoords;// Y轴
if (yd <= 0) {
yRatio = 0;
return;
}
yRatio = (double) graphHeight / (double) yd;// 得到比例
}
private void clearBufferImage() {
graphics.setBackground(getBackground());
graphics.clearRect(0, 0, imgWidth, imgHeight);
}
private void drawDefaultXAxis() {
int graphWidth = getGraphWidth();
int graphHeight = getGraphHeight();
// 每隔一定的像素画一条竖线
graphics.setColor(gridLineColor);
for (int i = YTextWidth + xAxisLineInterval; i < YTextWidth + graphWidth; i += xAxisLineInterval) {
graphics.drawLine(i, titleHeight, i, titleHeight + graphHeight);
}
}
private void drawDefaultYAxis() {
// 每隔一定的像素画一条线
int graphWidth = getGraphWidth();
int graphHeight = getGraphHeight();
// 画横线
graphics.setColor(gridLineColor);
for (int i = graphHeight; i - bastYAxisLineHeightInterval > 0; i -= bastYAxisLineHeightInterval) {
int yPosition = i - bastYAxisLineHeightInterval + titleHeight;
graphics.drawLine(YTextWidth, yPosition, YTextWidth + graphWidth, yPosition);
}
}
/**
* 绘制曲线
*/
private void drawGraph() {
graphics.setColor(graphLineColor);
List<Coordinate> coordinatelist = dataModel.getCoordinatelist();
int size = coordinatelist.size();
if (size < 2) {
return;
}
int[] xPoints = new int[size];
int[] yPoints = new int[size];
for (int i = 0; i < size; i++) {
xPoints[i] = getXPoint(coordinatelist.get(i).getxValue());
yPoints[i] = getYPoint(coordinatelist.get(i).getyValue());
}
graphics.drawPolyline(xPoints, yPoints, size);
// 画一个当前值
Font font = graphics.getFont();
FontMetrics fm = graphics.getFontMetrics(font);
int descent = fm.getDescent();
graphics.setColor(fontColor);
int _yPoint = yPoints[size - 1];
int graphWidth = getGraphWidth();
int _xPoint = YTextWidth + graphWidth + 1;
long currentValue = coordinatelist.get(coordinatelist.size() - 1).getyValue();
String valueOf = String.valueOf(currentValue);
graphics.drawString(valueOf, _xPoint, _yPoint - descent);
graphics.drawLine(_xPoint, _yPoint, _xPoint + fm.stringWidth(valueOf), _yPoint);
}
/**
* <pre>
* 画背景
* </pre>
*/
private void drawGraphBackgound() {
int graphWidth = getGraphWidth();
int graphHeight = getGraphHeight();
graphics.setColor(graphBackgroundColor);
// big.fill3DRect(YTextWidth, titleHeight, imgWidth - YTextWidth
// - cutlineWidth, imgHeight - titleHeight - XTextHeight, false);
// 填充指定的矩形。该矩形左边缘和右边缘分别位于 x 和 x + width - 1。上边缘和下边缘分别位于 y 和 y + height -
// 1。得到的矩形覆盖 width 像素宽乘以 height 像素高的区域。使用图形上下文的当前颜色填充该矩形。
graphics.fillRect(YTextWidth, titleHeight, graphWidth, graphHeight);
graphics.setColor(gridLineColor);
// 绘制指定矩形的边框。矩形的左边缘和右边缘分别位于 x 和 x + width。上边缘和下边缘分别位于 y 和 y +
// height。使用图形上下文的当前颜色绘制该矩形。
graphics.drawRect(YTextWidth, titleHeight, graphWidth, graphHeight);
}
/**
* <pre>
* 将内容画在图片上
* </pre>
*/
private void drawImage() {
int tw = getWidth();
int th = getHeight();
if (tw != imgWidth || th != imgHeight) {
// 大小有变化，重建一张图片
imgWidth = tw;
imgHeight = th;
bufferImage = new BufferedImage(imgWidth, imgHeight, BufferedImage.TYPE_INT_RGB);
graphics = bufferImage.createGraphics();
}
if (bufferImage == null) {
return;
}
// 先清空图片
clearBufferImage();
// 画标题
drawTitle();
// 画内容区域 背景
drawGraphBackgound();
// 获取XY轴上的线
long[] xLine = dataModel.getXAxisLines(getBestXAxisLineCount());
long[] yLine = dataModel.getYAxisLines(getBestYAxisLineCount());
// 计算X 和 Y 的比例
calcYRatio();
calcXRatio();
// 画X坐标
if (xLine != null) {
drawXAxis(xLine);
} else {
if (drawEmptyGraph) {
// 画缺省的X坐标
drawDefaultXAxis();
}
}
// 画Y坐标
if (yLine != null) {
drawYAxis(yLine);
} else if (drawEmptyGraph) {
// 画缺省的Y坐标
drawDefaultYAxis();
}
// 画曲线
drawGraph();
}
/**
* <pre>
* 画标题
* </pre>
*/
private void drawTitle() {
if (graphTitle == null || graphTitle.isEmpty() || titleHeight < 1) {
return;
}
graphics.setColor(titleFontColor);
graphics.setFont(titleFont);
FontMetrics fm = graphics.getFontMetrics(titleFont);
int titleWidth = fm.stringWidth(graphTitle);
int graphWidth = getGraphWidth();
int titleX = (graphWidth - titleWidth) / 2 + YTextWidth;
graphics.drawString(graphTitle, titleX, fm.getAscent());
}
/**
* <pre>
* 画X轴
* </pre>
*/
private void drawXAxis(long[] xLine) {
if (xLine == null) {
return;
}
Font font = graphics.getFont();
FontMetrics fm = graphics.getFontMetrics(font);
int ascent = fm.getAscent();
// int descent = fm.getDescent();
// int fHeight = fm.getHeight();
int graphHeight = getGraphHeight();
// 画X坐标
for (long l : xLine) {
int xPoint = getXPoint(l);
graphics.setColor(gridLineColor);
graphics.drawLine(xPoint, titleHeight, xPoint, titleHeight + graphHeight);
Date date = new Date(l);
String dateStr = dateF.format(date);
graphics.setColor(fontColor);
graphics.drawString(dateStr, xPoint, titleHeight + graphHeight + ascent);
}
}
/**
* <pre>
* 画Y轴
* </pre>
*/
private void drawYAxis(long[] yLine) {
if (yLine == null) {
return;
}
Font font = graphics.getFont();
FontMetrics fm = graphics.getFontMetrics(font);
int descent = fm.getDescent();
// 先设置字体
graphics.setFont(font);
// 画最大值
// String maxYStr = String.valueOf(maxY);
// big.drawString(maxYStr, YTextWidth - fm.stringWidth(maxYStr) - 1,
// titleHeight + descent);
// // 画最小值
// String minYStr = String.valueOf(minY);
// big.drawString(minYStr, YTextWidth - fm.stringWidth(minYStr) - 1,
// titleHeight + graphHeight);
int graphWidth = getGraphWidth();
for (long l : yLine) {
String yNumberStr = String.valueOf(l);
int yPosition = getYPoint(l);
if (YTextWidth > 0) {
// 数字
graphics.setColor(fontColor);
graphics.drawString(yNumberStr, YTextWidth - fm.stringWidth(yNumberStr) - 1, yPosition + descent);
}
// 画横线
graphics.setColor(gridLineColor);
graphics.drawLine(YTextWidth, yPosition, YTextWidth + graphWidth, yPosition);
}
}
private int getBestXAxisLineCount() {
// 在X轴能显示几条线
int lineCount = getGraphWidth() / xAxisLineInterval;
lineCount = lineCount > 1 ? lineCount : 1;
return lineCount;
}
/**
* 根据坐标系高度计算最佳的横线条数
*
* @return
*/
private int getBestYAxisLineCount() {
int lineCount = getGraphHeight() / bastYAxisLineHeightInterval;
lineCount = lineCount > minYAxisLineCount ? lineCount : minYAxisLineCount;
return lineCount;
}
public int getCurrentTextWidth() {
return currentTextWidth;
}
public boolean getDisplayLastValue() {
return displayLastValue;
}
public Color getFontColor() {
return fontColor;
}
public Color getGraphBackgroundColor() {
return graphBackgroundColor;
}
/**
* 获取曲线图区域的高度
*
* @return
*/
public int getGraphHeight() {
if (bufferImage == null) {
return 0;
}
return bufferImage.getHeight() - titleHeight - XTextHeight;
}
public Color getGraphLineColor() {
return graphLineColor;
}
public String getGraphTitle() {
return graphTitle;
}
/**
* 获取曲线图区域的宽度
*
* @return
*/
public int getGraphWidth() {
if (bufferImage == null) {
return 0;
}
return bufferImage.getWidth() - YTextWidth - currentTextWidth;
}
public Color getGridLineColor() {
return gridLineColor;
}
/**
* <pre>
* 获取值对应X点坐标
* </pre>
*
* @param value
* @return
*/
private int getXPoint(long value) {
Long minXCoords = dataModel.getMinXCoords();
long v = value - minXCoords;
int x = (int) (v * xRatio);
return x + YTextWidth;
}
/**
* <pre>
* 获取值对应Y点坐标
* </pre>
*
* @param value
* @return
*/
private int getYPoint(long value) {
Long minYCoords = dataModel.getMinYCoords();
long v = value - minYCoords;
int y = (int) (v * yRatio);
int graphHeight = getGraphHeight();
return graphHeight - y + titleHeight;
}
public boolean isDrawEmptyGraph() {
return drawEmptyGraph;
}
@Override
public void monitorPanelChanged(MonitorPanelModelEvent e) {
repaint();
}
@Override
public void paint(Graphics g) {
super.paint(g);
drawImage();
// 用图片
if (bufferImage != null) {
g.drawImage(bufferImage, 0, 0, this);
}
}
public void setCurrentTextWidth(int currentTextWidth) {
this.currentTextWidth = currentTextWidth;
}
public void setDisplayLastValue(boolean display) {
displayLastValue = display;
if (display) {
currentTextWidth = defaultCurrentTextWidth;
} else {
currentTextWidth = 0;
}
}
public void setDrawEmptyGraph(boolean drawEmptyGraph) {
this.drawEmptyGraph = drawEmptyGraph;
}
public void setFontColor(Color fontColor) {
this.fontColor = fontColor;
}
public void setGraphBackgroundColor(Color graphBackgroundColor) {
this.graphBackgroundColor = graphBackgroundColor;
}
public void setGraphLineColor(Color graphLineColor) {
this.graphLineColor = graphLineColor;
}
public void setGraphTitle(String title) {
this.graphTitle = title;
}
public void setGridLineColor(Color gridLineColor) {
this.gridLineColor = gridLineColor;
}
public void setModel(MonitorPanelModel model) {
if (model == null) {
throw new IllegalArgumentException("不能为空");
}
if (this.dataModel != model) {
MonitorPanelModel old = this.dataModel;
if (old != null) {
old.removeMonitorPanelModelListener(this);
}
this.dataModel = model;
model.addMonitorPanelModelListener(this);
repaint();
}
}
}
数据模型 MonitorPanelModel
package com.wwh.test.swing.monitor;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import javax.swing.event.EventListenerList;
// 应该抽象出接口
public class MonitorPanelModel implements Serializable {
public enum XAxisMode {
AUTO, FIXED, KEEP_MOVE
}
public enum YAxisMode {
AUTO, FIXED
}
/**
* 默认的最大坐标点的数量1000
*/
public static final int DEFAULT_MAX_COORDINATE_NUMBER = 1000;
private static final long serialVersionUID = 1L;
/**
* 坐标集合
*/
private List<Coordinate> coordinatelist;
/**
* 使X轴呈现一个向左边移动的效果<br>
* 需要指定一个时间段
*/
private Long keepMoveTimeInterval;
private EventListenerList listenerList = new EventListenerList();
/**
* 最大的坐标点个数
*/
private int maxCoordinateCount = DEFAULT_MAX_COORDINATE_NUMBER;
/**
* 最大X坐标
*/
private Long maxXCoords;
/**
* X轴上的最大值
*/
private Long maxXValue;
/**
* 最大Y坐标
*/
private Long maxYCoords;
/**
* Y轴上的最大值
*/
private Long maxYValue;
/**
* 最小X坐标
*/
private Long minXCoords;
/**
* X轴上的最小值
*/
private Long minXValue;
/**
* 最小Y坐标
*/
private Long minYCoords;
/**
* Y轴上的最小值
*/
private Long minYValue;
/**
* 记录一个开始的时间
*/
private Long startTime;
/**
* X 轴间距
*/
private Long xAxisInterval;
private XAxisMode xAxisMode = XAxisMode.AUTO;
/**
* Y轴间距
*/
private Long yAxisInterval;
private YAxisMode yAxisMode = YAxisMode.AUTO;
public MonitorPanelModel() {
coordinatelist = new ArrayList<Coordinate>();
}
public void addCoordinate(Coordinate coordinate) {
coordinatelist.add(coordinate);
if (coordinatelist.size() > maxCoordinateCount) {
coordinatelist.remove(0);
fireMonitorPanelDataChanged();
} else {
fireMonitorPanelDataAdd(coordinate);
}
}
public void addMonitorPanelModelListener(MonitorPanelModelListener l) {
listenerList.add(MonitorPanelModelListener.class, l);
}
/**
* 根据间隔计算Y轴上的线条数量
*
* @param interval
* @return
*/
private int calcLineCountByInterval(long interval) {
// 计算Y轴的最大值
long tmp = maxYValue / interval;
maxYCoords = tmp * interval;
if (maxYCoords < maxYValue) {
maxYCoords += interval;
}
tmp = minYValue / interval;
minYCoords = tmp * interval;
if (minYCoords > minYValue) {
minYCoords -= interval;
}
long line = (maxYCoords - minYCoords) / interval;
yAxisInterval = interval;
return (int) line;
}
public void clearCoordinate() {
coordinatelist.clear();
fireMonitorPanelDataChanged();
}
private void fireMonitorPanelChanged(MonitorPanelModelEvent e) {
Object[] listeners = listenerList.getListenerList();
for (int i = listeners.length - 2; i >= 0; i -= 2) {
if (listeners[i] == MonitorPanelModelListener.class) {
((MonitorPanelModelListener) listeners[i + 1]).monitorPanelChanged(e);
}
}
}
private void fireMonitorPanelDataAdd(Coordinate coordinate) {
refreshValue(coordinate);
fireMonitorPanelChanged(new MonitorPanelModelEvent(this));
}
private void fireMonitorPanelDataChanged() {
// 刷新数据
refreshAllValue();
fireMonitorPanelChanged(new MonitorPanelModelEvent(this));
}
private void fireMonitorPanelPropertyChanged(String property, Object oldValue, Object newValue) {
// 属性先不管
fireMonitorPanelChanged(new MonitorPanelModelEvent(this));
}
private long[] getAutoXAxisLines(int bestXLineCount) {
if (maxXValue == null || minXValue == null) {
return null;
}
long differ = maxXValue - minXValue;
if (differ == 0) {
return null;
}
minXCoords = minXValue;
maxXCoords = maxXValue;
xAxisInterval = differ / bestXLineCount;
if (xAxisInterval < 1) {
return null;
}
List<Long> l = new ArrayList<>();
long tmp = maxXCoords;
while (tmp > minXCoords) {
l.add(tmp);
tmp -= xAxisInterval;
}
long[] ret = new long[l.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = l.get(i);
}
return ret;
}
private long[] getAutoYAxisLines(int bestYLineCount) {
if (maxYValue == null || minYValue == null) {
return null;
}
long differValue = maxYValue - minYValue;
if (differValue == 0) {
// 此时可能是一条横线
yAxisInterval = 1L;
long absMaxYValue = Math.abs(maxYValue);
if (absMaxYValue > 10) {
double log = Math.log10(absMaxYValue / 10);
// 四舍五入取整
log = Math.round(log);
// 间距
yAxisInterval = (long) Math.pow(10, log);
}
maxYCoords = ((maxYValue / yAxisInterval) + 1) * yAxisInterval;
minYCoords = ((maxYValue / yAxisInterval) - 1) * yAxisInterval;
long middleValue = (maxYValue / yAxisInterval) * yAxisInterval;
return new long[] { minYCoords, middleValue, maxYCoords };
}
long interval = 1;
if (differValue > 10) {
double log = Math.log10(differValue / 10);
// 四舍五入取整
log = Math.round(log);
// 间距
interval = (long) Math.pow(10, log);
}
readjustYAxis(interval, bestYLineCount);
// 返回Y轴上的坐标线
return getFixedYAxisLines();
}
public List<Coordinate> getCoordinatelist() {
return Collections.unmodifiableList(coordinatelist);
}
public int getCoordinateSize() {
return coordinatelist.size();
}
private long[] getFixedXAxisLines() {
if (maxXCoords == null || minXCoords == null || xAxisInterval == null) {
throw new IllegalArgumentException("固定模式下，最大值、最小值、间距都不能为空");
}
List<Long> l = new ArrayList<>();
long tmp = minXCoords;
while (tmp <= maxXCoords) {
l.add(tmp);
tmp += xAxisInterval;
}
long[] ret = new long[l.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = l.get(i);
}
return ret;
}
private long[] getFixedYAxisLines() {
if (maxYCoords == null || minYCoords == null || yAxisInterval == null) {
throw new IllegalArgumentException("固定模式下，最大值、最小值、间距都不能为空");
}
List<Long> l = new ArrayList<>();
long tmp = minYCoords;
while (tmp <= maxYCoords) {
l.add(tmp);
tmp += yAxisInterval;
}
long[] ret = new long[l.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = l.get(i);
}
return ret;
}
public Long getKeepMoveTimeInterval() {
return keepMoveTimeInterval;
}
private long[] getKeepMoveXAxisLines(int bestXLineCount) {
if (keepMoveTimeInterval == null || keepMoveTimeInterval < 1) {
throw new IllegalArgumentException("移动模式下，固定的时间段不能为空或小于1");
}
if (startTime == null) {
startTime = System.currentTimeMillis();
}
maxXCoords = System.currentTimeMillis();
minXCoords = maxXCoords - keepMoveTimeInterval;
xAxisInterval = keepMoveTimeInterval / bestXLineCount;
if (xAxisInterval < 1) {
return null;
}
List<Long> l = new ArrayList<>();
long tmp = startTime;
while (tmp <= maxXCoords) {
if (tmp >= minXCoords) {
l.add(tmp);
}
tmp += xAxisInterval;
}
long[] ret = new long[l.size()];
for (int i = 0; i < ret.length; i++) {
ret[i] = l.get(i);
}
return ret;
}
public int getMaxCoordinateCount() {
return maxCoordinateCount;
}
public Long getMaxXCoords() {
return maxXCoords;
}
public Long getMaxXValue() {
return maxXValue;
}
public Long getMaxYCoords() {
return maxYCoords;
}
public Long getMaxYValue() {
return maxYValue;
}
public Long getMinXCoords() {
return minXCoords;
}
public Long getMinXValue() {
return minXValue;
}
public Long getMinYCoords() {
return minYCoords;
}
public Long getMinYValue() {
return minYValue;
}
public MonitorPanelModelListener[] getMonitorPanelModelListeners() {
return listenerList.getListeners(MonitorPanelModelListener.class);
}
public long getXAxisFirstValue() {
if (coordinatelist.isEmpty()) {
return 0;
}
return coordinatelist.get(0).getxValue();
}
public Long getxAxisInterval() {
return xAxisInterval;
}
public long getXAxisLastValue() {
if (coordinatelist.isEmpty()) {
return 0;
}
return coordinatelist.get(coordinatelist.size() - 1).getxValue();
}
/**
* X 轴上要画的竖线
*
* @param bestXLineCount 最佳的竖线条数
* @return
*/
public long[] getXAxisLines(int bestXLineCount) {
switch (xAxisMode) {
case AUTO:
return getAutoXAxisLines(bestXLineCount);
case FIXED:
return getFixedXAxisLines();
case KEEP_MOVE:
return getKeepMoveXAxisLines(bestXLineCount);
default:
return null;
}
}
public XAxisMode getxAxisMode() {
return xAxisMode;
}
public Long getyAxisInterval() {
return yAxisInterval;
}
/**
* Y 轴上要画的横线
*
* @param bestYLineCount 最佳的横线条数
* @return
*/
public long[] getYAxisLines(int bestYLineCount) {
switch (yAxisMode) {
case AUTO:
return getAutoYAxisLines(bestYLineCount);
case FIXED:
return getFixedYAxisLines();
default:
return null;
}
}
public YAxisMode getyAxisMode() {
return yAxisMode;
}
/**
* 重新计算Y轴
*
* @param interval
*/
private void readjustYAxis(long interval, int bestYLineCount) {
// 先根据目前的间距计算一次Y轴的行数
int lineCount = calcLineCountByInterval(interval);
// 再尝试调整为最佳的
long newInterval = 0;
if (bestYLineCount > lineCount) {
// 减小间距
float f = (float) bestYLineCount / lineCount;
int p = Math.round(f);
if (p == 1) {
return;
} else {
for (int i = p; i > 1; i--) {
if (interval % i == 0) {
newInterval = interval / i;
break;
}
}
}
} else {
// 增加间距
float f = (float) lineCount / bestYLineCount;
int p = Math.round(f);
if (p == 1) {
return;
} else {
newInterval = interval * p;
}
}
if (newInterval != 0) {
// 根据调整后的间距再算一次
lineCount = calcLineCountByInterval(newInterval);
}
}
private void refreshAllValue() {
minXValue = null;
maxXValue = null;
minYValue = null;
maxYValue = null;
for (Coordinate coordinate : coordinatelist) {
refreshValue(coordinate);
}
}
private void refreshValue(Coordinate coordinate) {
long y = coordinate.getyValue();
long x = coordinate.getxValue();
if (maxYValue == null || y > maxYValue) {
maxYValue = y;
}
if (minYValue == null || y < minYValue) {
minYValue = y;
}
if (maxXValue == null || x > maxXValue) {
maxXValue = x;
}
if (minXValue == null || x < minXValue) {
minXValue = x;
}
}
public void removeMonitorPanelModelListener(MonitorPanelModelListener l) {
listenerList.remove(MonitorPanelModelListener.class, l);
}
public void setCoordinatelist(List<Coordinate> coordinatelist) {
if (coordinatelist == null) {
throw new IllegalArgumentException("不能为空");
}
this.coordinatelist = coordinatelist;
fireMonitorPanelDataChanged();
}
public void setKeepMoveTimeInterval(Long keepMoveTimeInterval) {
fireMonitorPanelPropertyChanged(null, null, null);
this.keepMoveTimeInterval = keepMoveTimeInterval;
}
public void setMaxCoordinateCount(int maxCoordinateCount) {
fireMonitorPanelPropertyChanged(null, null, null);
this.maxCoordinateCount = maxCoordinateCount;
}
public void setMaxXCoords(Long maxXCoords) {
fireMonitorPanelPropertyChanged(null, null, null);
this.maxXCoords = maxXCoords;
}
public void setMaxYCoords(Long maxYCoords) {
fireMonitorPanelPropertyChanged(null, null, null);
this.maxYCoords = maxYCoords;
}
public void setMinXCoords(Long minXCoords) {
fireMonitorPanelPropertyChanged(null, null, null);
this.minXCoords = minXCoords;
}
public void setMinYCoords(Long minYCoords) {
fireMonitorPanelPropertyChanged(null, null, null);
this.minYCoords = minYCoords;
}
public void setxAxisInterval(Long xAxisInterval) {
fireMonitorPanelPropertyChanged(null, null, null);
this.xAxisInterval = xAxisInterval;
}
public void setxAxisMode(XAxisMode xAxisMode) {
fireMonitorPanelPropertyChanged(null, null, null);
this.xAxisMode = xAxisMode;
}
public void setyAxisInterval(Long yAxisInterval) {
fireMonitorPanelPropertyChanged(null, null, null);
this.yAxisInterval = yAxisInterval;
}
public void setyAxisMode(YAxisMode yAxisMode) {
fireMonitorPanelPropertyChanged(null, null, null);
this.yAxisMode = yAxisMode;
}
}
坐标 Coordinate
package com.wwh.test.swing.monitor;
/**
* <pre>
* xy坐标
* X轴 为 具体的值
* Y轴 为 时间
* </pre>
*
* @author wwh
*/
public class Coordinate {
private long xValue;
private long yValue;
public Coordinate(long x, long y) {
this.xValue = x;
this.yValue = y;
}
public long getxValue() {
return xValue;
}
public void setxValue(long xValue) {
this.xValue = xValue;
}
public long getyValue() {
return yValue;
}
public void setyValue(long yValue) {
this.yValue = yValue;
}
}
事件 MonitorPanelModelEvent
package com.wwh.test.swing.monitor;
public class MonitorPanelModelEvent extends java.util.EventObject {
private static final long serialVersionUID = 1L;
public MonitorPanelModelEvent(Object source) {
super(source);
}
}
监听器接口 MonitorPanelModelListener
package com.wwh.test.swing.monitor;
public interface MonitorPanelModelListener extends java.util.EventListener {
public void monitorPanelChanged(MonitorPanelModelEvent e);
}
测试 MonitorPanelTest
package com.wwh.test.swing.monitor;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.EventQueue;
import java.awt.GridLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.Random;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.border.EmptyBorder;
import com.wwh.test.swing.monitor.MonitorPanelModel.XAxisMode;
import com.wwh.test.swing.monitor.MonitorPanelModel.YAxisMode;
public class MonitorPanelTest extends JFrame {
private static final long serialVersionUID = 1L;
/**
* Launch the application.
*/
public static void main(String[] args) {
EventQueue.invokeLater(new Runnable() {
public void run() {
try {
MonitorPanelTest frame = new MonitorPanelTest();
frame.setVisible(true);
} catch (Exception e) {
e.printStackTrace();
}
}
});
}
private JButton btn_clear1;
private JButton btn_clear2;
private JButton btn_clear3;
private JButton btn_clear4;
private JButton btn_start2;
private JButton btn_start3;
private JButton btn_start4;
private JButton btn_stop1;
private JButton btn_stop2;
private JButton btn_stop3;
private JButton btn_stop4;
private JPanel contentPane;
private MonitorPanel mPanel1;
private MonitorPanel mPanel2;
private MonitorPanel mPanel3;
private MonitorPanel mPanel4;
private MonitorPanelModel mpModel1;
private MonitorPanelModel mpModel2;
private MonitorPanelModel mpModel3;
private MonitorPanelModel mpModel4;
private JPanel panel_1;
private JPanel panel_2;
private JPanel panel_2_btn;
private JPanel panel_3;
private JPanel panel_3_btn;
private JPanel panel_4;
private JPanel panel_4_btn;
private boolean runFlag1 = false;
private boolean runFlag2 = false;
private boolean runFlag3 = false;
private boolean runFlag4 = false;
/**
* Create the frame.
*/
public MonitorPanelTest() {
setTitle("监控面板测试");
setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
setBounds(100, 100, 1183, 681);
contentPane = new JPanel();
contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
setContentPane(contentPane);
contentPane.setLayout(new GridLayout(2, 2, 0, 0));
createMonitorPanel1();
createMonitorPanel2();
createMonitorPanel3();
createMonitorPanel4();
}
private void createMonitorPanel1() {
panel_1 = new JPanel();
contentPane.add(panel_1);
panel_1.setLayout(new BorderLayout(0, 0));
mpModel1 = new MonitorPanelModel();
mPanel1 = new MonitorPanel(mpModel1);
panel_1.add(mPanel1);
mpModel1.setMaxCoordinateCount(200);
mPanel1.setGraphTitle("0到10000之间的随机数");
JPanel panel_1_btn = new JPanel();
panel_1.add(panel_1_btn, BorderLayout.SOUTH);
JButton btn_start1 = new JButton("启 动");
btn_start1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start1();
}
});
panel_1_btn.add(btn_start1);
btn_stop1 = new JButton("停 止");
btn_stop1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
runFlag1 = false;
}
});
panel_1_btn.add(btn_stop1);
btn_clear1 = new JButton("清 空");
btn_clear1.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
mpModel1.clearCoordinate();
}
});
panel_1_btn.add(btn_clear1);
}
private void createMonitorPanel2() {
panel_2 = new JPanel();
contentPane.add(panel_2);
panel_2.setLayout(new BorderLayout(0, 0));
mpModel2 = new MonitorPanelModel();
mpModel2.setxAxisMode(XAxisMode.KEEP_MOVE);
mpModel2.setKeepMoveTimeInterval(10 * 60 * 1000L);
mpModel2.setMaxCoordinateCount(600);
mPanel2 = new MonitorPanel(mpModel2);
mPanel2.setGraphTitle("内存图测试");
mPanel2.setGraphBackgroundColor(new Color(38, 38, 38));
mPanel2.setGridLineColor(new Color(0, 225, 34));
mPanel2.setGraphLineColor(Color.YELLOW);
panel_2.add(mPanel2);
panel_2_btn = new JPanel();
panel_2.add(panel_2_btn, BorderLayout.SOUTH);
btn_start2 = new JButton("启 动");
btn_start2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start2();
}
});
panel_2_btn.add(btn_start2);
btn_stop2 = new JButton("停 止");
btn_stop2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
runFlag2 = false;
}
});
panel_2_btn.add(btn_stop2);
btn_clear2 = new JButton("清 空");
btn_clear2.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
mpModel2.clearCoordinate();
}
});
panel_2_btn.add(btn_clear2);
}
private void createMonitorPanel3() {
panel_3 = new JPanel();
contentPane.add(panel_3);
panel_3.setLayout(new BorderLayout(0, 0));
mpModel3 = new MonitorPanelModel();
mpModel3.setxAxisMode(XAxisMode.KEEP_MOVE);
mpModel3.setKeepMoveTimeInterval(10 * 60 * 1000L);
mpModel3.setMaxCoordinateCount(1200);
mPanel3 = new MonitorPanel(mpModel3);
mPanel3.setGraphTitle("递增递减");
panel_3.add(mPanel3, BorderLayout.CENTER);
panel_3_btn = new JPanel();
panel_3.add(panel_3_btn, BorderLayout.SOUTH);
btn_start3 = new JButton("启 动");
btn_start3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start3();
}
});
panel_3_btn.add(btn_start3);
btn_stop3 = new JButton("停 止");
btn_stop3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
runFlag3 = false;
}
});
panel_3_btn.add(btn_stop3);
btn_clear3 = new JButton("清 空");
btn_clear3.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
mpModel3.clearCoordinate();
}
});
panel_3_btn.add(btn_clear3);
}
private void createMonitorPanel4() {
panel_4 = new JPanel();
contentPane.add(panel_4);
panel_4.setLayout(new BorderLayout(0, 0));
mpModel4 = new MonitorPanelModel();
mpModel4.setxAxisMode(XAxisMode.KEEP_MOVE);
mpModel4.setKeepMoveTimeInterval(360 * 1000L);
mpModel4.setMaxCoordinateCount(720);
mpModel4.setyAxisMode(YAxisMode.FIXED);
mpModel4.setMaxYCoords(100L);
mpModel4.setMinYCoords(-100L);
mpModel4.setyAxisInterval(20L);
mPanel4 = new MonitorPanel(mpModel4);
panel_4.add(mPanel4, BorderLayout.CENTER);
mPanel4.setGraphTitle("正弦函数");
mPanel4.setGraphBackgroundColor(new Color(38, 38, 38));
mPanel4.setGridLineColor(new Color(0, 225, 34));
mPanel4.setGraphLineColor(Color.YELLOW);
panel_4_btn = new JPanel();
panel_4.add(panel_4_btn, BorderLayout.SOUTH);
btn_start4 = new JButton("启 动");
btn_start4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
start4();
}
});
panel_4_btn.add(btn_start4);
btn_stop4 = new JButton("停 止");
btn_stop4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
runFlag4 = false;
}
});
panel_4_btn.add(btn_stop4);
btn_clear4 = new JButton("清 空");
btn_clear4.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
mpModel4.clearCoordinate();
}
});
panel_4_btn.add(btn_clear4);
}
private void start1() {
runFlag1 = true;
Thread t = new Thread(new Runnable() {
@Override
public void run() {
int rint;
Random r = new Random();
while (runFlag1) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
rint = r.nextInt(10000);
mpModel1.addCoordinate(new Coordinate(System.currentTimeMillis(), rint + 1));
}
}
});
t.start();
}
private void start2() {
if (runFlag2) {
return;
}
runFlag2 = true;
Thread t = new Thread(new Runnable() {
@Override
public void run() {
Runtime rt = Runtime.getRuntime();
while (runFlag2) {
try {
Thread.sleep(1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
mpModel2.addCoordinate(new Coordinate(System.currentTimeMillis(), rt.freeMemory() / 1024 / 1024));
}
}
});
t.start();
}
private void start3() {
if (runFlag3) {
return;
}
runFlag3 = true;
Thread t = new Thread(new Runnable() {
@Override
public void run() {
boolean b = true;
int i = 0;
while (runFlag3) {
if (b) {
if (i < 100) {
i++;
} else {
b = !b;
}
} else {
if (i > 0) {
i--;
} else {
b = !b;
}
}
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
mpModel3.addCoordinate(new Coordinate(System.currentTimeMillis(), i));
}
}
});
t.start();
}
private void start4() {
if (runFlag4) {
return;
}
runFlag4 = true;
Thread t = new Thread(new Runnable() {
@Override
public void run() {
int i = 0;
double d;
long l;
while (runFlag4) {
if (i == 360) {
i = 0;
}
d = Math.sin(Math.toRadians(i));
i++;
try {
Thread.sleep(500);
} catch (InterruptedException e) {
e.printStackTrace();
}
l = (long) (d * 100);
mpModel4.addCoordinate(new Coordinate(System.currentTimeMillis(), l));
}
}
});
t.start();
}
}
网友评论