请教JAVA编程高手一个问题，如何在面板上绘图

用 Java绘图一直都吸引着开发人员的注意。传统上，Java 开发人员使用 javaawtGraphics 或 Java 2D API 进行绘图。一些开发人员甚至使用现成的开源工具箱（如 JSci）来绘图。但很多时候，您的选择被限定在了 AWT 或 Swing 上。为了最大限度地减少对第三方工具箱的依赖，或者为了简化绘图基础，可以考虑使用 Draw2D，并编写自己的代码来制图或绘图。

Draw2D 简介

Draw2D 是一个驻留在 SWT Composite 之上的轻量级窗口小部件系统。一个 Draw2D 实例 由一个 SWT Composite、一个轻量级系统及其内容的图形组成。图形 是 Draw2D 的构建块。关于 Draw2D API 的所有细节，可以从 Draw2D Developer’s Guide 的 Eclipse 帮助文件中找到。因为本文不打算成为一篇讲述 Draw2D 的教程，所以，为了简便起见，只要您了解 Draw2D API 可以帮助您在 SWT Canvas 上进行绘图就足够了。您可以直接使用一些标准的图形，比如 Ellipse、Polyline、RectangleFigure 和 Triangle，或者，您可以扩展它们来创建自己的图形。此外，一些容器图形，如 Panel，可以充当所有子图形的总容器。

Draw2D 有两个重要的包：orgeclipsedraw2dgeometry 和 orgeclipsedraw2dgraph，本文中使用了这两个包。orgeclipsedraw2dgeometry 包有一些有用的类，比如 Rectangle、Point 和 PointList，这些类都是自我解释的。另一个包 orgeclipsedraw2dgraph 开发人员使用的可能不是太多。这个包提供了一些重要的类，比如 DirectedGraph、Node、Edge、NodeList 和 EdgeList，这些类有助于创建图表。

在本文中，我将解释如何使用 Draw2D 编写代码，帮助您以图形的方式形象化您的数据。我将从一项技术的描述开始，该技术将位于某一范围内的数据值（比如，从 0 到 2048）按比例缩放成另一范围内的等效数据值（例如，从 0 到 100）。然后，我将举例说明如何绘制出任意个级数的 X-Y 坐标图，每个级数都包含一组数据元素。在学习了本文中的概念之后，就可以很容易地绘制其他类型的图表，比如饼图和条形图。

具体的绘图过程

步骤 1：您想绘制什么样的图形？

显然，您想以图形方式描绘来自数据源的数据。所以，您需要那些您想以图形形式形象化的数据。为了简便起见，我使用了一个名为 dataGenerator 的简单函数生成的数据，而不是从 XML 文件或其他一些数据源读取数据，该函数使用了一个 for(;;) 循环，并以数组列表的形式返回生成的值。

清单 1 生成一些数据

private ArrayList dataGenerator() {

double series1[] = new double[5];

for(int i=0; i<series1length; i++)

series1[i] = (i10) + 10; // a linear

series containing 10,20,30,40,50

double series2[] = new double[9];

series2[0] = 20; series2[1] = 150; series2[2] = 5;

series2[3] = 90; series2[4] = 35; series2[5] = 20;

series2[6] = 150; series2[7] = 5; series2[8] = 45;

double series3[] = new double[7];

for(int i=0; i<series3length; i++)

series3[i] = (i20) + 15;

seriesDataadd(series1);

seriesDataadd(series2);

seriesDataadd(series3);

return seriesData;

}

步骤 2：缩放技术 —— 从给定的数据生成 X 坐标和 Y 坐标

一些新的术语

FigureCanvas

Draw2D 中的 FigureCanvas 是 SWT Canvas 的一个扩展。FigureCanvas 可以包含 Draw2D 图形。

Panel

Panel 是 Draw2D 中的一个通用容器图形，它可以包含子图形。您可以向一个 Panel 图形中添加许多图形，然后将这个 Panel 图形提供给 FigureCanvas。

DirectedGraph

DirectedGraph 是一个 2-D 图形，拥有有限数量的 Node，每个 Node 都位于一些 Point 中，相邻的 Node 是通过 Edges 彼此连接在一起的。

当您想绘制一架 2-D 飞机上的点时，必须找出每个点的 X 坐标和 Y 坐标。绘图的奇妙之处在于能够将某一个给定数据值从一个范围按比例缩放到另一个范围中，也就是说，如果给定一组值，如 {10,20,30}，那么您应该能够确定 2-D 飞机上具体哪些点（X 坐标和 Y 坐标）表示的是 10、20 和 30 这些数据值。

绘制总是在按照某一个限定缩放比例进行的。换句话说，在同一限定区域内，可以绘制任意数量的点。因为该区域是固定的，所以您总是可以找到 X 坐标轴的跨度（长度）和 Y 坐标轴的跨度（高度）。X 坐标轴和 Y 坐标轴的跨度只是等式的一部分。另一部分是找出数据值的范围，并根据每个数据值在新范围内的等效值来计算这些值的坐标。

计算 X 坐标和 Y 坐标

X 坐标：X 坐标是某一个点距离原点的水平距离。计算元素的数量，然后将 X 坐标轴的跨度分成 n 个区段，其中，n 是给定集合中的元素的数量，通过这种方式，可以计算某一集合中的所有点的横向坐标。用这种分割方法可以获得每个区段的长度。集合中的第一个点位于等于区段长度的第一段距离内。后续的每个点则位于区段长度加上原点到前一个点的距离的那一段距离内。

例如，给出一个集合 {10,20,30,40}，您立刻就可以知道要绘制 4 个点，因为集合中包含 4 个元素。所以，应该将 X 坐标轴的跨度分成 4 个相等的区段，每个区段的长度 = 跨度/4。因此，如果 X 坐标轴的跨度是 800，那么区段的长度将是 800/4，即 200。第一个元素（10）的 X 坐标将是 200，第二个元素（20）的 X 坐标将是 400，依此类推。

清单 2 计算 X 坐标

private int[] getXCoordinates(ArrayList seriesData){

int xSpan = (int)GraFixConstantsxSpan;

int longestSeries = UtilitiesgetLongestSeries(seriesData);

int numSegments =

((double[])seriesDataget(longestSeries))length;

int sectionWidth =

(int)xSpan / numSegments; //want to divide span of xAxis

int xPositions[] =

new int[numSegments]; // will contain X-coordinate of all dots

for(int i=0; i<numSegments; i++){

xPositions[i]=

(i+1)sectionWidth;//dots spaced at distance of sectionWidth

}

return xPositions;

}

Y 坐标：Y 坐标是某一个点距离原点的纵向距离。计算 Y 坐标要将某一个值按比例从一个范围缩放到另一个范围。例如，给出相同的集合 {10,20,30,40}，您可以看出，数据的范围是 0 到 40，新的范围就是 Y 坐标轴的跨度（高度）。假设 Y 坐标轴的高度为 400，那么第一个元素（10）的高度将是100，第二个元素的高度将是 200，依此类推。

通过以下例子，您可以更好地理解如何按比例将一个值从一个范围缩放到另一个范围：假定一个范围的跨度是从 0 到 2048，而您打算将该范围内的任意值（比如说 1024）缩放到另一个从 0 到 100 的范围内，那么您立刻就可以知道，等刻度值是 50。该缩放所遵循的三值线算法是：

line 1---> 2048 / 1024 equals 2

line 2---> 100 - 0 equals 100

line 3---> 100 / 2 equals 50, which is the desired scaled value

步骤 3：您想在哪儿进行绘图？

您还需要进行绘图的地方。可以通过扩展 Eclipse ViewPart 和使用 SWT Composite 来创建您自己的视图。此外，也可以使用从 main() 函数中调用的 SWT shell。

在扩展 Eclipse ViewPart 时，至少必须实现两个函数：createPartControl(Composite parent) 和 setFocus()。函数 createPartControl(Composite parent) 是在屏幕上绘制视图时自动调用的。您的兴趣只在所接收的 SWT Composite 上。因此，将它传递给某个类，然后通过对这个类进行编码来绘制图形。

清单 3 使用 Eclipse ViewPart 绘图

public class MainGraFixView extends ViewPart{

public void createPartControl(Composite parent) {

//create or get data in an arraylist

ArrayList seriesData = dataGenerator();

//instantiate a plotter, and provide data to it

DirectedGraphXYPlotter dgXYGraph = new DirectedGraphXYPlotter(parent);

dgXYGraphsetData(seriesData);

dgXYGraphplot(); //ask it to plot

}

public void setFocus() {

}

}

步骤 4；您需要绘制哪种图形？

一旦拥有了数据以及想用来绘制图形的区域，就必须确定您需要哪种类型的可视化。在本文中，我演示了如何编写代码来创建 X-Y 坐标图和线形图。一旦知道了绘制 X-Y 坐标图的技术，就应该能够绘制出其他图形，比如条形图和饼图。要想更多地了解 X-Y 坐标图，请参阅我为本文编写的 DirectedGraphXYPlotter 类（参见所附源代码中的 \src\GraFix\Plotters\DirectedGraphXYPlotterjava）。

步骤 5：创建自己的 X-Y 坐标图

X-Y 坐标图应该能够绘制出 2-D 飞机上的任意数量的级数线。每个级数线都应该以图形形式显示出引用 X 和 Y 引用线的那些级数中的每个点的位置。每个点都应该通过一条线连接到级数中的下一个点上。通过使用表示一个点和一条线的 Draw2D 图形，您应该能够创建这样一个坐标图。例如，为了表示一个点，我通过扩展 Ellipse 图形创建了一个 Dot 图形，并使用 PolylineConnection 图形来表示连接线。

DirectedGraphXYPlotter 类只有两个公共函数：setData(ArrayList seriesData) 和 plot()。函数 setData(ArrayList seriesData) 接受您想要以图形形式形象化的数据（参见步骤 1），而 plot() 函数则开始绘图。

一旦调用了 plot() 函数，就必须依次采用以下步骤：

采用一个 SWT Composite，并将 FigureCanvas 放在它之上。然后，将一个类似 Panel 的通用容器图放在画布上。

计算将要绘制的级数的数量，然后填充创建 DirectedGraphs 所需数量的 NodeLists 和 EdgeLists。

在 Panel 图上绘制 X 坐标轴和 Y 坐标轴。（参见所附源代码中 \src\GraFix\Figure 目录下的 XRulerBarjava 和 YRulerBarjava。）

创建和级数一样多的 DirectedGraphs，以便进行绘图。

在 Panel 图上绘制点和连接线，同时采用步骤 d 中创建的 DirectedGraphs 中的图形数据。

最后，通过提供 Panel 图来设置画布的内容，其中包括到目前为止您已经准备好的所有的点和连接线。

在以下代码中：

第 6-11 行代码对应于上述的步骤 a。

第 14 行，即函数 populateNodesAndEdges()，对应于上述的步骤 b。

第 16 行，即函数 drawAxis()，对应于上述的步骤 c。

第 17 行、第 18 行和第 19 行对应于上述的步骤 d 和步骤 e。

第 20 行对应于上述的步骤 f。

清单 4 plot() 函数

1 public void plot(){

2 //if no place to plot, or no data to plot, return

3 if(null==_parent || null==_seriesData)

4 return;

5

6 Composite composite = new Composite(_parent, SWTBORDER);

7 compositesetLayout(new FillLayout());

8 FigureCanvas canvas = new FigureCanvas(composite);

9

10 Panel contents = new Panel();//A Panel is a general purpose container figure

11 contentssetLayoutManager(new XYLayout());

12 initializeSpan(contentsgetClientArea());

13

14 populateNodesAndEdges();

15

16 drawAxis(contents);

17 for(int i=0; i<_numSeries; i++){

18 drawDotsAndConnections(contents,getDirectedGraph(i)); //

draw points & connecting wires

19 }

20 canvassetContents(contents);

21 }

plot() 调用了两个重要内部函数来帮助绘制图形中的点：populateNodesAndEdges() 和 drawDotsAndConnections()。在您发现这两个函数到底完成什么功能之前，让我们来看一下 DirectedGraph。

DirectedGraph 是什么？为了使用 Draw2D 进行绘图，事实上您必须先创建一个图形，定义将要绘制的点和线。一旦创建好这个图形，就可以使用它实际在画布上进行绘图。您可以将 DirectedGraph 形象化为拥有有限数量的 Node 的一个 2-D 图形，在该图形中，每个 Node 都位于一些 Point 上，相邻的 Node 是通过 Edges 连接在一起的。

您可以通过以下代码行来了解创建 DirectedGraph 的关键所在。首先，创建一个 Node 列表和一个 Edges 列表。然后，创建一个新的 DirectedGraph，并通过刚才创建的 NodeList 和 EdgeList 设置其成员（Nodes 和 Edges）。现在，使用 GraphVisitor 来访问这个 DirectedGraph。为了简便起见，包 orgeclipsedraw2dinternalgraph 中有许多 GraphVisitor 实现，这些 GraphVisitor 有一些用来访问图形的特定算法。

因此，创建 DirectedGraph 的示例代码类似于下面这样：

清单 5 示例 DirectedGraph

//This is a sample, you will need to add actual Node(s) to this NodeList

NodeList nodes = new NodeList(); //create a list of nodes

//This is a sample, you will need to add actual Edge(s) to this EdgeList

EdgeList edges = new EdgeList(); //create a list of edges

DirectedGraph graph = new DirectedGraph();

graphnodes = nodes;

graphedges = edges;

new BreakCycles()visit(graph);//ask BreakCycles to visit the graph

//now our "graph" is ready to be used

现在，已经知道 DirectedGraph 包含许多 Node，其中，每个 Node 都可能包含一些数据，并且还存储了这些数据的 X 坐标和 Y 坐标，以及一个 Edges 的列表，每个 Edge 都知道在自己的两端分别有一个 Node，您可以通过以下技术，使用这些信息来绘图，其中涉及两个部分：部分 A —— 通过以下步骤填充 Node 和 Edge：

创建一个 NodeList，在该列表中，集合中的每个元素都有一个 Node，集合 {10,20,30,40} 需要 4 个 Node。

找出每个元素的 X 坐标和 Y 坐标，将它们存储在 nodex 和 nodey 成员变量中。

创建一个 EdgeList，在该列表中，有 n -1 个 Edge，其中，n 是集合中的元素的数量。例如，集合 {10,20,30,40} 需要三个 Edge。

将 Node 与每个 Edge 的左右端相关联，并相应地设置 edgestart 和 edgeend 成员变量。

部分 B —— 通过以下步骤绘制表示 Node 和 Edge 的图形：

绘制一个 Dot 图来表示每个 Node。

绘制一个 PolylineConnection 图形来表示每个 Edge。

界定每个 PolylineConnection 图形，以固定 Dot 图的左右端。

现在，回到内部函数的工作上来：

函数 populateNodesAndEdges() 实现了该技术的部分 A，而函数 drawDotsAndConnections() 则实现了该技术的部分 B。

函数 populateNodesAndEdges() 计算将绘制多少级数。它为每个级数创建了一个 NodeList 和一个 EdgeList。

每个 NodeList 都包含一个用于特殊级数的 Node 的列表。每个 Node 都保存着关于应该在什么地方绘制 X 坐标和 Y 坐标的信息。函数 getXCoordinates() 和 getYCoordinates() 分别用于检索 X 坐标值和 Y 坐标值。使用步骤 2 中的相同算法，这些函数也可以内部地将数据值按比例从一个范围缩放到另一个范围。

每个 EdgeList 都包含一个用于特殊级数的 Edges 的列表。每个 Edge 的左右端上都分别有一个 Node。

清单 6 populateNodesAndEdges() 函数

private void populateNodesAndEdges(){

_seriesScaledValues = new ArrayList(getScaledValues(_seriesData));

_nodeLists = new ArrayList();

_edgeLists = new ArrayList();

for(int i=0; i<_numSeries; i++){

_nodeListsadd(new NodeList());// one NodeList per series

_edgeListsadd(new EdgeList());// one EdgeList per series

}

//populate all NodeLists with the Nodes

for(int i=0; i<_numSeries; i++){//for each series

double data[] = (double[])_seriesDataget(i);//get the series

int xCoOrds[] = getXCoordinates(_seriesData);

int yCoOrds[] = getYCoordinates(i, data);

//each NodeList has as many Nodes as points in a series

for(int j=0; j<datalength; j++){

Double doubleValue = new Double(data[j]);

Node node = new Node(doubleValue);

nodex = xCoOrds[j];

nodey = yCoOrds[j];

((NodeList)_nodeListsget(i))add(node);

}

}

//populate all EdgeLists with the Edges

for(int i=0; i<_numSeries; i++){

NodeList nodes = (NodeList)_nodeListsget(i);

for(int j=0; j<nodessize()-1; j++){

Node leftNode = nodesgetNode(j);

Node rightNode = nodesgetNode(j+1);

Edge edge = new Edge(leftNode,rightNode);

edgestart = new Point(leftNodex, leftNodey);

edgeend = new Point(rightNodex, rightNodey);

((EdgeList)_edgeListsget(i))add(edge);

}

}

int breakpoint = 0;

}

一旦函数 populateNodesAndEdges() 完成了它的使命，为所有将要绘制的级数创建了 NodeLists 和 EdgeLists，另一个函数 drawDotsAndConnections() 就开始为每个 Node 绘制一个 Dot 图形，并为每个 Edge 绘制一个 PolylineConnection 图形。

清单 7 drawDotsAndConnections()、drawNode() 和 drawEdge() 函数

private void drawDotsAndConnections(IFigure contents, DirectedGraph graph){

for (int i = 0; i < graphnodessize(); i++) {

Node node = graphnodesgetNode(i);

drawNode(contents, node);

}

for (int i = 0; i < graphedgessize(); i++) {

Edge edge = graphedgesgetEdge(i);

drawEdge(contents, edge);

}

}

private void drawNode(IFigure contents, Node node){

Dot dotFigure = new Dot();

nodedata = dotFigure;

int xPos = nodex;

int yPos = nodey;

contentsadd(dotFigure);

contentssetConstraint(dotFigure, new Rectangle(xPos,yPos,-1,-1));

}

private void drawEdge(IFigure contents, Edge edge){

PolylineConnection wireFigure = new PolylineConnection();

//edgesource is the Node to the left of this edge

EllipseAnchor sourceAnchor = new EllipseAnchor((Dot)edgesourcedata);

//edgetarget is the Node to the right of this edge

EllipseAnchor targetAnchor = new EllipseAnchor((Dot)edgetargetdata);

wireFiguresetSourceAnchor(sourceAnchor);

wireFiguresetTargetAnchor(targetAnchor);

contentsadd(wireFigure);

}

绘图结果

结束语

如果您想以图形形式描绘将展示的数据，那么 Draw2D 是一个好工具。可以使用 Draw2D 编写自己的用来绘制图形的 Java 代码，这有助于您将精力集中于缩放代码和绘制代码上，把其他与绘制相关的工作留给 Draw2D 和 SWT。您还可以通过使用所选择的 Draw2D 图形来控制您的图形的外观。Draw2D 简化了绘图的基本步骤，并且可以最大限度地减少您对第三方工具箱的依赖。

找到了，很久以前写的一个简单画图，呵呵～当时要求用AWT写，很难受。

package netmiqianggui;

import javaawtBasicStroke;

import javaawtBorderLayout;

import javaawtButton;

import javaawtColor;

import javaawtCursor;

import javaawtDimension;

import javaawtFrame;

import javaawtGraphics;

import javaawtGraphics2D;

import javaawtGridLayout;

import javaawtLabel;

import javaawtPanel;

import javaawtRenderingHints;

import javaawtToolkit;

import javaawteventActionEvent;

import javaawteventActionListener;

import javaawteventMouseAdapter;

import javaawteventMouseEvent;

import javaawteventMouseListener;

import javaawteventMouseMotionListener;

import javaawteventWindowAdapter;

import javaawteventWindowEvent;

import javaawtimageBufferedImage;

/

简单画图板程序

好久没用 AWT 了，写起来真别扭，如果用 swing 会很舒服，有空再改写吧。

@author 米强

/

public class TestMain extends Frame {

// 画板

private Palette palette = null;

// 显示当前颜色的面板

private Panel nonceColor = null;

// 画笔粗细

private Label drawWidth = null;

// 画笔端点的装饰

private Label drawCap = null;

// 选取颜色按钮的监听事件类

private ButtonColorAction buttonColorAction = null;

// 鼠标进入按钮后光标样式的监听事件类

private ButtonCursor buttonCursor = null;

// 画笔样式的监听事件

private ButtonStrokeAction buttonStrokeAction = null;

/

构造方法

/

public TestMain() {

// 设置标题栏文字

super("简易画图板");

// 构造一个画图板

palette = new Palette();

Panel pane = new Panel(new GridLayout(2, 1));

// 画笔颜色选择器

Panel paneColor = new Panel(new GridLayout(1, 13));

// 12 个颜色选择按钮

Button [] buttonColor = new Button[12];

Color [] color = {Colorblack, Colorblue, Colorcyan, ColordarkGray, Colorgray, Colorgreen, Colormagenta, Colororange, Colorpink, Colorred, Colorwhite, Coloryellow};

// 显示当前颜色的面板

nonceColor = new Panel();

nonceColorsetBackground(Colorblack);

paneColoradd(nonceColor);

buttonColorAction = new ButtonColorAction();

buttonCursor = new ButtonCursor();

for(int i = 0; i < buttonColorlength; i++){

buttonColor[i] = new Button();

buttonColor[i]setBackground(color[i]);

buttonColor[i]addActionListener(buttonColorAction);

buttonColor[i]addMouseListener(buttonCursor);

paneColoradd(buttonColor[i]);

}

paneadd(paneColor);

// 画笔颜色选择器

Panel paneStroke = new Panel(new GridLayout(1, 13));

// 控制画笔样式

buttonStrokeAction = new ButtonStrokeAction();

Button [] buttonStroke = new Button[11];

buttonStroke[0] = new Button("1");

buttonStroke[1] = new Button("3");

buttonStroke[2] = new Button("5");

buttonStroke[3] = new Button("7");

buttonStroke[4] = new Button("9");

buttonStroke[5] = new Button("11");

buttonStroke[6] = new Button("13");

buttonStroke[7] = new Button("15");

buttonStroke[8] = new Button("17");

buttonStroke[9] = new Button("■");

buttonStroke[10] = new Button("●");

drawWidth = new Label("3", LabelCENTER);

drawCap = new Label("●", LabelCENTER);

drawWidthsetBackground(ColorlightGray);

drawCapsetBackground(ColorlightGray);

paneStrokeadd(drawWidth);

for(int i = 0; i < buttonStrokelength; i++){

paneStrokeadd(buttonStroke[i]);

buttonStroke[i]addMouseListener(buttonCursor);

buttonStroke[i]addActionListener(buttonStrokeAction);

if(i <= 8){

buttonStroke[i]setName("width");

}else{

buttonStroke[i]setName("cap");

}

if(i == 8){

paneStrokeadd(drawCap);

}

}

paneadd(paneStroke);

// 将画笔颜色选择器添加到窗体中

thisadd(pane, BorderLayoutNORTH);

// 将画图板添加到窗体中

thisadd(palette);

// 添加窗口监听，点击关闭按钮时退出程序

thisaddWindowListener(new WindowAdapter() {

public void windowClosing(WindowEvent e) {

Systemexit(0);

}

});

// 设置窗体 ICON 图标

thissetIconImage(ToolkitgetDefaultToolkit()createImage("images/palettepng"));

// 设置窗口的大小

thissetSize(new Dimension(400, 430));

// 设置窗口位置，处于屏幕正中央

thissetLocationRelativeTo(null);

// 显示窗口

thissetVisible(true);

}

/

程序入口

@param args

字符串数组参数

/

public static void main(String[] args) {

new TestMain();

}

/

选取颜色按钮的监听事件类

@author 米强

/

class ButtonColorAction implements ActionListener {

public void actionPerformed(ActionEvent e) {

Color color_temp = ((Button)egetSource())getBackground();

nonceColorsetBackground(color_temp);

palettesetColor(color_temp);

}

}

/

鼠标进入按钮变换光标样式监听事件类

@author 米强

/

class ButtonCursor extends MouseAdapter {

public void mouseEntered(MouseEvent e) {

((Button)egetSource())setCursor(new Cursor(CursorHAND_CURSOR));

}

public void mouseExited(MouseEvent e) {

((Button)egetSource())setCursor(new Cursor(CursorDEFAULT_CURSOR));

}

}

/

设置画笔的监听事件类

@author 米强

/

class ButtonStrokeAction implements ActionListener {

public void actionPerformed(ActionEvent e) {

Button button_temp = (Button) egetSource();

String name = button_tempgetName();

if(nameequalsIgnoreCase("width")){

drawWidthsetText(button_tempgetLabel());

palettesetStroke(FloatparseFloat(button_tempgetLabel()));

}else if(nameequalsIgnoreCase("cap")){

drawCapsetText(button_tempgetLabel());

if(button_tempgetLabel()equals("■")){

palettesetStroke(BasicStrokeCAP_SQUARE);

}else if(button_tempgetLabel()equals("●")){

palettesetStroke(BasicStrokeCAP_ROUND);

}

}

}

}

}

/

画板类

@author 米强

/

class Palette extends Panel implements MouseListener, MouseMotionListener {

// 鼠标 X 坐标的位置

private int mouseX = 0;

// 上一次 X 坐标位置

private int oldMouseX = 0;

// 鼠标 Y 坐标的位置

private int mouseY = 0;

// 上一次 Y 坐标位置

private int oldMouseY = 0;

// 画图颜色

private Color color = null;

// 画笔样式

private BasicStroke stroke = null;

// 缓存图形

private BufferedImage image = null;

/

构造一个画板类

/

public Palette() {

thisaddMouseListener(this);

thisaddMouseMotionListener(this);

// 默认黑色画笔

color = new Color(0, 0, 0);

// 设置默认画笔样式

stroke = new BasicStroke(30f, BasicStrokeCAP_ROUND, BasicStrokeJOIN_ROUND);

// 建立 1280 1024 的 RGB 缓存图象

image = new BufferedImage(1280, 1024, BufferedImageTYPE_INT_RGB);

// 设置颜色

imagegetGraphics()setColor(Colorwhite);

// 画背景

imagegetGraphics()fillRect(0, 0, 1280, 1024);

}

/

重写 paint 绘图方法

/

public void paint(Graphics g) {

superpaint(g);

// 转换为 Graphics2D

Graphics2D g2d = (Graphics2D) g;

// 获取缓存图形 Graphics2D

Graphics2D bg = imagecreateGraphics();

// 图形抗锯齿

bgsetRenderingHint(RenderingHintsKEY_ANTIALIASING, RenderingHintsVALUE_ANTIALIAS_ON);

// 设置绘图颜色

bgsetColor(color);

// 设置画笔样式

bgsetStroke(stroke);

// 画线，从上一个点到新的点

bgdrawLine(oldMouseX, oldMouseY, mouseX, mouseY);

// 将缓存中的图形画到画板上

g2ddrawImage(image, 0, 0, this);

}

/

重写 update 方法

/

public void update(Graphics g) {

thispaint(g);

}

/

@return stroke

/

public BasicStroke getStroke() {

return stroke;

}

/

@param stroke 要设置的 stroke

/

public void setStroke(BasicStroke stroke) {

thisstroke = stroke;

}

/

设置画笔粗细

@param width

/

public void setStroke(float width) {

thisstroke = new BasicStroke(width, strokegetEndCap(), strokegetLineJoin());

}

/

设置画笔端点的装饰

@param cap 参考 javaawtBasicStroke 类静态字段

/

public void setStroke(int cap) {

thisstroke = new BasicStroke(strokegetLineWidth(), cap, strokegetLineJoin());

}

/

@return color

/

public Color getColor() {

return color;

}

/

@param color 要设置的 color

/

public void setColor(Color color) {

thiscolor = color;

}

public void mouseClicked(MouseEvent mouseEvent) {

}

/

鼠标按下

/

public void mousePressed(MouseEvent mouseEvent) {

thisoldMouseX = thismouseX = mouseEventgetX();

thisoldMouseY = thismouseY = mouseEventgetY();

repaint();

}

public void mouseReleased(MouseEvent mouseEvent) {

}

/

鼠标进入棋盘

/

public void mouseEntered(MouseEvent mouseEvent) {

thissetCursor(new Cursor(CursorCROSSHAIR_CURSOR));

}

/

鼠标退出棋盘

/

public void mouseExited(MouseEvent mouseEvent) {

thissetCursor(new Cursor(CursorDEFAULT_CURSOR));

}

/

鼠标拖动

/

public void mouseDragged(MouseEvent mouseEvent) {

thisoldMouseX = thismouseX;

thisoldMouseY = thismouseY;

thismouseX = mouseEventgetX();

thismouseY = mouseEventgetY();

repaint();

}

public void mouseMoved(MouseEvent mouseEvent) {

}

}

只有矩形有圆形能移动，其它实现起来麻烦点，办法有的只是代码太多。

画圆弧改成了画曲线，圆弧稍麻烦，当然方法是很简单的，你可以自己思考一下。

双击13个颜色中的任意一个都会d出颜色选择器。

有保存与打开功能。扩展名请用 jdr

基本满足条件，细节可能不是很好，另，代码比较乱，怕不好看懂咯，呼呼。

import javaawt;

import javaawtevent;

import javaawtgeom;

import javaawtimageBufferedImage;

import javaio;

import javautilArrayList;

import javaxswing;

import javaxswingfilechooserFileNameExtensionFilter;

public class JDraw {

public static void main(String[] args) {

JFrame f=new JFrame();

fsetDefaultCloseOperation(3);

fsetSize(880,600);

fsetLocationRelativeTo(null);

fgetContentPane()add(Mc);

fgetContentPane()add(Mm,"South");

fsetVisible(true);

}

}

class CVS extends Component implements ComponentListener,MouseListener,MouseMotionListener{

public void componentHidden(ComponentEvent e) {}

public void componentMoved(ComponentEvent e) {}

public void componentResized(ComponentEvent e) {resized();}

public void componentShown(ComponentEvent e) {}

private void resized() {

int w=thisgetWidth();

int h=thisgetHeight();

tbuff=new BufferedImage(w,h,3);

makeBuff(w,h);

}

private void makeBuff(int w,int h) {

Graphics g = tbuffgetGraphics();

gdrawImage(buff,0,0,null);

gdispose();

buff=new BufferedImage(w,h,3);

g=buffgetGraphics();

gdrawImage(tbuff,0,0,null);

gdispose();

}

BufferedImage buff,tbuff;

CVS(){

thisaddComponentListener(this);

thisaddMouseListener(this);

thisaddMouseMotionListener(this);

buff=new BufferedImage(1,1,3);

}

public void paint(Graphics gr){

Graphics2D g = buffcreateGraphics();

gsetBackground(new Color(0xff000000,true));

gclearRect(0,0,getWidth(),getHeight());

gsetRenderingHint(RenderingHintsKEY_ANTIALIASING,

RenderingHintsVALUE_ANTIALIAS_ON);

MsadrawAll(g);

if(Mts!=null)

Mtsdraw(g);

gdispose();

grdrawImage(buff,0,0,this);

grdispose();

}

public void mouseClicked(MouseEvent e) {}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mousePressed(MouseEvent e) {

Mmp(egetPoint());

}

public void mouseReleased(MouseEvent e) {

Mmr(egetPoint());

}

public void mouseDragged(MouseEvent e) {

Mmd(egetPoint());

}

public void mouseMoved(MouseEvent e) {}

}

class Menu extends JComponent implements MouseListener,ActionListener{

JComboBox sbox,method;

CLabel[] cl;

JCheckBox fillC,drawB;

JRadioButton fc,bc;

ButtonGroup bg;

JButton clear,up,down,save,load;

Menu(){

thissetLayout(new FlowLayout());

method=new JComboBox(new Object[]{"draw","move","erase",});

add(method);

sbox=new JComboBox(new Object[]{"Pt","Ln","Rect","Cir","Arc",});

add(sbox);

cl=new CLabel[13];

for(int i=0; i<cllength; i++){

cl[i]=new CLabel();

cl[i]addMouseListener(this);

add(cl[i]);

}

fc=new JRadioButton("fc",true);

bc=new JRadioButton("bc");

bg=new ButtonGroup();

bgadd(fc);bgadd(bc);

add(fc);add(bc);

fcsetOpaque(true);

bcsetOpaque(true);

fcsetBackground(Colorwhite);

bcsetBackground(Colorblue);

fillC=new JCheckBox("Fill",true);

drawB=new JCheckBox("Draw",true);

fillCaddActionListener(this);

drawBaddActionListener(this);

add(fillC);add(drawB);

clear=new JButton("clear");

clearaddActionListener(this);

add(clear);

up=new JButton("zUp");

upaddActionListener(this);

add(up);

down=new JButton("zDown");

downaddActionListener(this);

add(down);

save=new JButton("Save");

saveaddActionListener(this);

add(save);

load=new JButton("Load");

loadaddActionListener(this);

add(load);

}

public void mouseClicked(MouseEvent e) {

JLabel l=(JLabel)egetSource();

if(egetClickCount()==2){

Color sc=JColorChoosershowDialog(null, "Color chooser", lgetBackground());

lsetBackground(sc);

mousePressed(e);

}

}

public void mouseEntered(MouseEvent e) {}

public void mouseExited(MouseEvent e) {}

public void mousePressed(MouseEvent e) {

Color c=((JLabel)egetSource())getBackground();

if(fcisSelected())

fcsetBackground(c);

else if(bcisSelected())

bcsetBackground(c);

Mcp();

}

public void mouseReleased(MouseEvent e) {}

public void actionPerformed(ActionEvent e) {

if(egetSource()==clear)Mclear();

else if(egetSource()==up)Mup();

else if(egetSource()==down)Mdown();

else if(egetSource()==save)Msave();

else if(egetSource()==load)Mload();

else if(egetSource()==fillC||egetSource()==drawB)Mcp();

}

}

class CLabel extends JLabel{

static Color[] cs={Colorred,Colororange,Coloryellow,Colorgreen,Colorcyan,

Colorblue,Colormagenta,Colormagentabrighter(),

Colorwhite,Colorblack,Colorgray,ColorLIGHT_GRAY,ColorDARK_GRAY,};

static int i;

CLabel(){

thissetOpaque(true);

thissetBackground(cs[i++]);

thissetBorder(BorderFactorycreateLineBorder(Colorblack));

thissetPreferredSize(new Dimension(10,20));

}

}

class M{

static JFileChooser jfc=new JFileChooser();

static Menu m=new Menu();

static CVS c=new CVS();

static SA sa=new SA();

static S ts=null,selected=null;

static Color fc,bc;

static void clear(){

sassclear();

crepaint();

}

public static void cp() {

Systemoutprintln(selected);

if(selected!=null){

selectedfillColor=mfcgetBackground();

selectedborderColor=mbcgetBackground();

selectedfc=mfillCisSelected();

selecteddb=mdrawBisSelected();

crepaint();

}

}

public static void up() {

if(selected!=null){

saupZ(selected);

crepaint();

}

}

public static void down(){

if(selected!=null){

sadownZ(selected);

crepaint();

}

}

static{

jfcsetFileFilter(new FileNameExtensionFilter("JDraw file (jdraw,jdr)","jdr","jdraw"));

}

static void save(){

int x=jfcshowSaveDialog(c);

if(x==JFileChooserAPPROVE_OPTION){

File f = jfcgetSelectedFile();

try{

ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream(f));

ooswriteObject(sa);

oosflush();

oosclose();

}catch(Exception e){}

}

}

static void load(){

int x=jfcshowOpenDialog(c);

if(x==JFileChooserAPPROVE_OPTION){

File f = jfcgetSelectedFile();

try{

ObjectInputStream oos=new ObjectInputStream(new FileInputStream(f));

Object r=oosreadObject();

if(r!=null){

sa=(SA)r;

crepaint();

}

oosclose();

}catch(Exception e){eprintStackTrace();}

}

}

static int mx,my,tx,ty,ox,oy;

static int pc=0,pmax;

static int sm;

static boolean ne=true;

static int mid;

static void mp(Point p){

mid=mmethodgetSelectedIndex();

if(mid==0){

if(ne){

mx=px;my=py;

pc=0;

sm=msboxgetSelectedIndex();

pmax=sm==42:1;

ne=false;

}

++pc;

}

else if(mid==1){

checkSel(p);

mx=px;my=py;

}

else if(mid==2){

checkSel(p);

if(selected!=null){

sassremove(selected);

crepaint();

}

}

}

private static void checkSel(Point p) {

selected=null;

for(int i=sasssize();i>0; i--)

if(sassget(i-1)shapecontains(p)){

selected=sassget(i-1);break;

}

saselect(selected);

crepaint();

}

static void mt(){

Shape s=null;

int cx,cy,cw,ch;

switch(sm){

case 0:

case 2:

cx=Mathmin(mx,tx);

cy=Mathmin(my,ty);

cw=Mathabs(mx-tx);

ch=Mathabs(my-ty);

if(sm==0)

s=new Ellipse2DDouble(cx,cy,cw,ch);

else

s=new Rectangle(cx,cy,cw,ch);

break;

case 1:

s=new Line2DFloat(mx,my,tx,ty);

break;

case 3:

cw=Mathabs(mx-tx);

ch=Mathabs(my-ty);

int cd=(int)Mathsqrt(Mathpow(mx-tx,2)+Mathpow(my-ty,2))2;

cx=mx-cd/2;

cy=my-cd/2;

s=new Ellipse2DDouble(cx,cy,cd,cd);

break;

case 4:

Path2D p=new Path2DDouble();

pmoveTo(mx,my);

if(pc==1){

plineTo(tx, ty);

}

else{

pquadTo(ox,oy,tx,ty);

}

s=p;

break;

}

ts=new S(s,mfcgetBackground(),mbcgetBackground(),mfillCisSelected(),mdrawBisSelected(),null);

crepaint();

}

static void md(Point p){

if(mid==0){

if(!sassisEmpty()){

sassget(sasssize()-1)sel=false;

}

if(pc>1){

ox=px;oy=py;

}

else{

tx=px;ty=py;

}

mt();

}

else if(mid==1){

if(selected!=null){

moveTo(selected,p);

crepaint();

}

}

else if(mid==2){

checkSel(p);

if(selected!=null){

sassremove(selected);

crepaint();

}

}

}

static void moveTo(S s, Point p) {

if(sshape instanceof Rectangle){

Rectangle r=(Rectangle)sshape;

rsetLocation(rx+px-mx,ry+py-my);

mx=px;my=py;

}

else if(sshape instanceof Ellipse2D){

Ellipse2D e=(Ellipse2D)sshape;

esetFrame(egetX()+px-mx,egetY()+py-my,egetWidth(),egetHeight());

mx=px;my=py;

}

}

static void mr(Point p) {

if(pc==pmax){

pc=0;

ne=true;

saadd(ts);

selected=ts;

ts=null;

}

}

}

class S implements Serializable{

boolean fc,db,sel=true;

Shape shape;

Color fillColor,borderColor;

Stroke stroke;

static Stroke bstroke=new MyBasicStroke();

static Stroke selectStroke=new BasicStroke(1,BasicStrokeCAP_BUTT,BasicStrokeJOIN_MITER,1,new float[]{5,2},1);

S(Shape s,Color c,Color b,boolean f,boolean d,Stroke k){

thisshape=s;thisfillColor=c;thisborderColor=b;thisfc=f;thisdb=d;thisstroke=k==nullbstroke:k;

}

void draw(Graphics2D g){

if(fc){

gsetColor(fillColor);

gfill(shape);

}

if(db){

gsetColor(borderColor);

gsetStroke(stroke);

gdraw(shape);

}

if(sel){

gsetColor(Colorgreen);

gsetStroke(selectStroke);

gdraw(shapegetBounds());

}

}

}

class MyBasicStroke extends BasicStroke implements Serializable{}

class SA implements Serializable{

ArrayList<S> ss=new ArrayList<S>();

void add(S s){

if(s!=null){

for(S sx:ss)

sxsel=false;

ssadd(s);

}

}

S remove(int i){

return ssremove(i);

}

void remove(S s){

ssremove(s);

}

void upZ(S s){

indexZ(s,1);

}

void downZ(S s){

indexZ(s,-1);

}

void indexZ(S s, int i) {

int si=ssindexOf(s);

if(si+i<0||si+i>sssize()-1)return;

swap(s,ssget(si+i));

}

void swap(S a,S b){

int ai=ssindexOf(a);

int bi=ssindexOf(b);

ssset(ai,b);

ssset(bi,a);

}

void select(S s){

for(S x:ss)

xsel=false;

if(s!=null)

ssel=true;

}

void drawAll(Graphics2D g){

for(S s:ss)

sdraw(g);

}

}

class Triangle extends drawings//空心三角形类

{

void draw(Graphics2D g2d)

{g2dsetPaint(new Color(R,G,B));

g2dsetStroke(new BasicStroke(stroke,

BasicStrokeCAP_ROUND,BasicStrokeJOIN_BEVEL));

g2ddrawLine((int)((x1+x2)/2),Mathmin(y1,y2),Mathmax(x1,x2),Mathmax(y1,y2));

g2ddrawLine(Mathmax(x1,x2),Mathmax(y1,y2),Mathmin(x1,x2),Mathmax(y1,y2));

g2ddrawLine(Mathmin(x1,x2),Mathmax(y1,y2),(int)((x1+x2)/2),Mathmin(y1,y2));

}

}

以上是通过绘制三条直线作为三角形的三条边来绘制三角形

class fillTriangle extends drawings//实心三角形

{

void draw(Graphics2D g2d)

{g2dsetPaint(new Color(R,G,B));

g2dsetStroke(new BasicStroke(stroke));

int mx=(int)((x1+x2)/2);

int[] x={mx,Mathmax(x1,x2),Mathmin(x1,x2)};

int[] y={Mathmin(y1,y2),Mathmax(y1,y2),Mathmax(y1,y2)};

g2dfillPolygon(x,y,3);

}

}

以上是用填充多边形的方式填充一个三角形,如果把最后的:g2dfillPolygon(x,y,3)改为g2ddrawPolygon(x,y,3); 则是以绘制多边形的方式绘制空心三角形

这里说明一下:因为(x1,y1,x2,y2)只能确定一个矩形区域,即鼠标拉动的起点和终点确定的矩形区域所以可以有多种方式确定三角形的三个顶点,我这个用的三个顶点是:

点1( (x1+x2)/2, min(y) ) 点2( max(x),max(y) ) 点3( min(x),max(y) )

你的补充内容太多了,没心情看啊,太累了

1．绘制图形在手动模式主画面下按f8，即进入线切割自动编程系统（scam）。主菜单画面功能键作用：f1

—

进入cad绘图；f2

—

进入cam主画面；f10

—

返回到控制系统。

scam主菜单画面在scam主菜单画面下按f1功能键进入cad绘图软件。进入绘图软件后即可绘制零件图，并且可把该零件转换成加工路径状态。

2．自动编程在cad状态下，绘制好零件图后，下拉cad的线切割菜单，选择正确、合理的“补偿量”和“线切路径”，按回车键后，屏幕显示要切割的图形及切割方向。退出cad系统返回到scam主菜单。在scam主菜单下按f2进入cam画面，在此画面中，进行图形文件、参数设定和放电参数的设定，完成后按f键即进入绘图和生成nc代码画面。（注意线切割编程起始位置与切割路线要合理选择。选择切割编程起始位置与切割路线应以工件装夹位置为依据，再考虑工件切割过程中刚性的变化以及工件内是否存在残余应力等。）

编程是编写程序的中文简称，就是让计算机为解决某个问题而使用某种程序设计语言编写程序代码，并最终得到相应结果的过程。

为了使计算机能够理解人的意图，人类就必须要将需解决的问题的思路、方法、和手段通过计算机能够理解的形式告诉计算机，使得计算机能够根据人的指令一步一步去工作，完成某种特定的任务。这种人和计算机之间交流的过程就是编程。

是这样的，如果你再程序开始添加holdon这个的画，表示这之后的每一次作图都保留以前的图，这样就可以连续画图了

反之holdoff，表示打开这个之后，每次画图，删除以前的图，

ASCII码表示字母, 声明为 char 型，你可以用 10进制，16进制，8进制数值表示，也可以用字符常量 'a','b','z', 'A','B','Z' 表示

下面用10进制，16进制数值，用 %c 格式输出 小写和大写英文字母。

#include <stdioh>

main()

{

char c;

for (c=97;c<123;c++) printf("%c ",c);

printf("\n\n");

for (c=65;c<91;c++) printf("%c ",c);

printf("\n\n");

for (c=0x61;c<0x7b;c++) printf("%c ",c);

printf("\n\n");

for (c=0x41;c<0x5b;c++) printf("%c ",c);

printf("\n\n");

}

以上就是关于请教JAVA编程高手一个问题，如何在面板上绘图全部的内容，包括:请教JAVA编程高手一个问题，如何在面板上绘图、求java版画图程序的源代码、GUI画图板（绘图板）设计，用Java编写程序代码！！谢谢！！等相关内容解答，如果想了解更多相关内容，可以关注我们，你们的支持是我们更新的动力！