版本1

82.源码82，公共程序，表单设计器。可视化设置界面。为单记录数据维护部件9等程序布局。界面可以包括全局性列表框、单指某字段列表框、组合框、文本域、文本框、图形框、按钮、水平直线、竖直直线等各种控件，任意布置位置与大小。可以规定每个文本框、按钮、文本域的字体、字号、颜色。

/*

 * 程序文件名：ControlPosition.java

 * 作者：程学先

 * 功能：表单设计器。可视化设置界面。为单记录数据维护部件9等程序布局。

 * 工具程序，直接用程序名ControlPosition调用。 

 * 设计思想：类是方法与数据的集成，部件是程序模块、构件、组件、类的集成。

 * 面向对象的秘诀或创新是"冗余"，在每次应用时都不一定用到其全部的方法和数据，

 * 可以通过选择方法与数据使用于某一种界面和某一种应用。

 * 例如“文本框”类，将数据显示、录入、修改等操作方法与有关数据都集成到同一个类中，

 * 在其子类中还包括密码框。在实际使用时往往只根据录入或显示的需求选用其部分方法和数据。

 * 这样的冗余设计使其复用粒度加大，复用范围拓广，开创了软件设计的面向对象时代。

 * 软部件的设计思想也是冗余，

 * 将用于某一类界面和完成某一类具体的工作的程序模块、构件、组件、中间件、类等集成到一个封装体中。

 * 这样的冗余设计目的是提高软件复用粒度，扩大软件复用范围，

 * 在每次调用时通过选择数据表、选择布局、选择字段与按钮及其他参数使其用作某种模块或构件，完成一种应用。

 * 就能用较少的软部件覆盖或满足更多的应用，只有这样的设计才能成为软件生产线的设计基础，

 * 才有可能更好地实现软件设计自动化。

 * 需要说明的是，软件复用有利于提高编码效率，有利于实现软件生产自动化，可以降低软件设计难度，

 * 减少直接的代码量，降低软件成本，降低软件维保费用等。

 * 但它是以降低软件运行效率、缩小软件应用范围为代价的，

 * 因此需要根据应用需要恰当地选取软件复用度，不要一味追求高复用，对于对时间要求高的软件和一些有特殊要求的软件，

 * 只能用复用度低的软件，例如使用用C语言甚至汇编语言编写的程序。

 * 表单9界面图形包括：文本框、文本域、下拉组合框、列表框、图形、声音、按钮、标签。

 * 列表框可以针对全部字段，也可以只针对单个字段；其他代表数据类控件只对单个字段。

 * 文本框、文本域、下拉组合框、图形、声音、标签，可以变换标签显示内容，

 * 文本框、下拉组合框、列表框可以显示代码表数据，约定与其他单记录式程序相同。

 * 文本框、下拉组合框、列表框有关数据包括完整性条件参数。

 * 可以在选定表、字段号、按钮号后点击“自动布局”，将生成一个初步格式的图形，之后可进一步修改。

 * 当点击工具条中有关控件后，首先输入字段名称和有关参数。

 * 对于文本框字段输入参数包括完整性条件：最大值、最小值、值域、条件式

 * 对于图形、声音字段，输入图形或声音图形框全名称。

 * 对于下拉组合框和列表框，输入代码表名称，或全部 * 标志，或SQL语句。

 * 如果是代码表，存放到数据表中的数据字段名与代码表中某字段名名字必须相同。

 * 之后在面板上点击，可在面板点击处显示相应图像，图像初始高度和宽度等于设计结构定义的数据。

 * 所有图像的数据将保存在数组队列(ArrayList)： 存储结构7的存储数据中

 * 所有图像数据临时在“存储结构7”中保存，

 * 标签高度=20

 * 可以点击“查看数据按钮”了解保存在存储结构7中的数据情况。

 * 如果用左键点击并拖动控件，可将控件移动到新位置。

 * 在没有点击图像或线条按钮情况下用右键点击图形，可以输入新的名称，改变参数。

 * 在没有点击图像或线条按钮情况下用右键点击并拖动图形，将询问是否删除控件

 * 如果回答删除控件，将从界面中删除图形，并从“存储结构7”中删除有关数据。

 * 可以用鼠标靠近控件每边中部或4角，鼠标形状会改变，如果有拖动余地，

 * 之后用右键拖动可以改变控件的图形形状和大小。

 * 在完成设计或需要临时保存数据时可点击“存盘”按钮，将数据保存在所预定的图形框中。

 *   0   1     2    3    4     5      6    7   8     9

 * 序号 图形代码 图形名称 x1坐标 y1坐标 标签内容 x2坐标 y2坐标 行号 y3坐标;

 *  10     11      12      13     14      15        16

 * 字段名0 更换列名0 字段类型0 代码表名0 关键字0 标签左边距0 标签到顶距0;

 *   17     18        19       20      21     22    23   24

 * 标签宽度0 标签高度0 字段左边距0 字段到顶距0 字段宽度0 高度0 字体0 字号0;

 *  25     26   27    28    29       30 

 * 颜色0 最大值0 最小值0 值域0 条件表达式0 只作显示0;

 * 说明：数字化修改参数可以更精细地调整界面，

 * 设置“批修改”按钮可以进入表格程序手工修改有关数据。

 * 在进行界面设计后，点击“进入表单”可以进入表单9运行

 * 点击“打印表单”可以 调用“打印预览单记录报表”预览，

 * 也可调用“打印表格报表”打印

 * 运行本程序需要在项目文件夹中有如下图标文件：

 * 文本框.png、下拉组合框.png、列表框.png、按钮.png、线条.png、图片.png

 * 可从光盘中拷贝，也可自行绘制图标文件。

* 必须提供的参数：“表名”、“关键字段名”

 * 可选择提供的参数： “要求按钮号表”、“要求字段号表”、“接口参数表名称”、“窗口宽”、“窗口高” 等如果不在调用时给定，由主程序带入。 

 */

import java.awt.*;

import java.awt.event.*;

import java.awt.geom.Line2D;

import java.awt.image.BufferedImage;

import java.io.*;

import java.sql.*;

import java.util.ArrayList;

import javax.imageio.ImageIO;

import javax.swing.*;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableColumn;

import javax.swing.text.JTextComponent;

class 存储结构7 {

int 序号;

String 图形代码;

String 图形名称; // 标签、文本框、文本域、下拉组合框、列表框、图形框、声音框、按钮、线条

int x1坐标; // 图形左上角坐标

int y1坐标;

String 标签内容; // 标签新名或图形图形框名或声音图形框名

int x2坐标; // 图形右上角坐标

int y2坐标;

int 行号; // 图形左下角坐标

int 列号;

String 字段名0;

String 更换列名0;

String 字段类型0;

String 代码表名0;

String 关键字0;

int 标签左边距0;

int 标签到顶距0;

int 标签宽度0;

int 标签高度0;

int 字段左边距0;

int 字段到顶距0;

int 字段宽度0;

int 高度0;

String 字体0;

int 字号0;

String 颜色0;

double 最大值0;

double 最小值0;

String 值域0;

String 条件表达式0;

String 只作显示0;

public 存储结构7(int 序号, String 图形代码, String 图形名称, int x1坐标, int y1坐标,

String 标签内容, int x2坐标, int y2坐标, int 行号, int 列号, String 字段名0,

String 更换列名0, String 字段类型0, String 代码表名0, String 关键字0, int 标签左边距0,

int 标签到顶距0, int 标签宽度0, int 标签高度0, int 字段左边距0, int 字段到顶距0,

int 字段宽度0, int 高度0, String 字体0, int 字号0, String 颜色0, double 最大值0,

double 最小值0, String 值域0, String 条件表达式0, String 只作显示0) {

this.序号 = 序号;

this.图形代码 = 图形代码;

this.图形名称 = 图形名称;

this.x1坐标 = x1坐标;

this.y1坐标 = y1坐标;

this.标签内容 = 标签内容;

this.x2坐标 = x2坐标;

this.y2坐标 = y2坐标;

this.行号 = 行号;

this.列号 = 列号;

this.字段名0 = 字段名0;

this.更换列名0 = 更换列名0;

this.字段类型0 = 字段类型0;

this.代码表名0 = 代码表名0;

this.关键字0 = 关键字0;

this.标签左边距0 = 标签左边距0;

this.标签到顶距0 = 标签到顶距0;

this.标签宽度0 = 标签宽度0;

this.标签高度0 = 标签高度0;

this.字段左边距0 = 字段左边距0;

this.字段到顶距0 = 字段到顶距0;

this.字段宽度0 = 字段宽度0;

this.高度0 = 高度0;

this.字体0 = 字体0;

this.字号0 = 字号0;

this.颜色0 = 颜色0;

this.最大值0 = 最大值0;

this.最小值0 = 最小值0;

this.值域0 = 值域0;

this.条件表达式0 = 条件表达式0;

this.只作显示0 = 只作显示0;

}

}

public class ControlPosition extends JFrame {

static ControlPosition frame;

static JPanel panel;

static ControlPosition frame1, frame2;

static String[][] 表格数据1; // frame2中的表格

static int 记录条数;

static int 表格列数0;

static JScrollPane scrollPane1 = new JScrollPane(); // 创建滚动面板

static String[] 列名2 = { "序号", "图形代码", "图形名称", "标签名", "字段名", "更换列名", "字段类型",

"代码表名", "关键字", "标签左边距", "标签到顶距", "标签宽度", "标签高度", "字段左边距", "字段到顶距",

"字段宽度", "高度", "字体", "字号", "颜色", "最大值", "最小值", "值域", "条件表达式", "只作显示" };

static int 列宽度[] = new int[25];

static DefaultTableModel 表格模型;

static JTable 表格;

private static Connection cont4; // 连接数据库

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs; // 数据库数据集

private static JPanel panel1, panel2;

public static int 序号0 = 0, 序号1 = 0, 开始运行 = 0, 元素索引 = 0, 元素索引2 = 0;

public static int 选中按钮号 = 0, 字数 = 0, 临时变量1x, 临时变量2x, 临时变量4x, 临时变量1y;

private static int 临时变量2y, 临时变量3x, 临时变量3y, 临时变量4y, 标签字数1, 光标标志 = 0,

光标标志0 = 0;

public static String 标签内容1, 图形名称1, 图形代码1, 图形框名1, 声音框名1;

private static String[] 图名 = { "", "", "文本框", "", "下拉组合框", "列表框", "按钮",

"线条", "图片" };

private static int 窗口宽 = 1350, 窗口高 = 700;

static int mouseX1 = 0, mouseY1 = 0;

static int mouseX3 = 0, mouseY3 = 0;

static int mouseX2 = 0, mouseY2 = 0;

static int mouseX4 = 0, mouseY4 = 0; // 右键点下位置

static int mouseX5 = 0, mouseY5 = 0; // 更名标签位置

static int mouseX6 = 0, mouseY6 = 0; // 左键释放时记录准备移动到的位置

static int mouseX7 = 6, mouseY7 = 0; // 移动图形位置

static int 右键标志 = 0;

static int 图像宽度 = 60, 图像高度 = 50;

static char x1 = 10, x2 = 13;

static Graphics g;

static Graphics2D g2 = (Graphics2D) g;

static ArrayList<存储结构7> 存储数据 = new ArrayList<存储结构7>();

static String 标签标识, 文本框名, 文本域名, 下拉组合框名, 列表框名;

static String 图形框名, 声音框名, 按钮名, 线条名, 线条名1;

static JLabel fl0;

private static float[] arr = { 3.0f, 3.0f }; // 文本域每段长度3，间距3

static String 表名表 = "", 表名 = "";

static Connection con;

static String DBMS系统 = "sql server";

static String ODBC数据源 = "sql1";

private static Statement sta3;

private static ResultSetMetaData rsmd3;

private static JComboBox 组合框5 = new JComboBox();

private static JTextField fa1 = new JTextField("");

private static JTextField fa2 = new JTextField("");

private static JTextField fa3 = new JTextField("");

private static JTextField fa4 = new JTextField("");

private static int 列数 = 0, 行号 = 0, 列号 = 0;

private static String[] 列数据类型; // 定义列数据类型数组

private static String[] 列名 = null;

private static List list1;// 公共列表框

private static String kuangm = "";

private static String[] 按钮名称 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘",

"查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

private static int[][] 按钮位置;

private static int 行间距离 = 0, 按钮数;

private static int 本行当前宽度 = 0;

private static int 起始左边距 = 0;

private static int 起始到顶距 = 0;

private static int[][] 位置参数;

private static int 按钮行数;

private static int 文本区宽度 = 0;

private static String[] 文本数组值;

private static int[][] 位置数据001;

private static int 文本域宽度, 文本域高度;

private static int 列名长度 = 0;

private static int 大数据个数 = 0;

private static int 最大字段宽 = 0;

private static int 需求面积 = 0, 原窗口宽 = 窗口宽, 原窗口高 = 窗口高;

private static int 控件个数 = 0;

private static int 字符宽度 = 15, 字符高度 = 20;

private static int 窗口左边距 = 10, 窗口到顶距 = 10;

private static int 表格列数;

private static String[] 表格列名;

private static String[] 表列数据类型, 表列数据类型1; // 存放表格各列数据类型的数组

private static int[] 列数据宽度; // 存放当前记录各字段数据宽度的数组

private static int[] 表列数据宽度; // 存放表格各列数据宽度的数组

private static String 列名表 = ""; // 包括全部列名的字符串

static String 字段名1, 更换列名1, 字段类型1, 代码表名1, 关键字1, 字体1;

static String 颜色1, 值域1, 条件表达式1, 只作显示1;

static int 标签左边距1, 标签到顶距1, 标签宽度1, 标签高度1, 字段左边距1, 字段到顶距1, 字段宽度1, 高度1, 字号1;

static double 最大值1, 最小值1;

private static String 要求按钮号表 = "";

private static int 实际按钮数 = 0;

private static String[][] 位置参数表 = null;

private static String[][] 标签位置 = null;

private static String[] 按钮集;

private static int 位置参数条数 = 0;

private static String 字段名字串 = "";

private static String[][] 字典数据 = new String[0][0];

public static boolean find(int EdgeX, int EdgeY, int l) { // 查询所点击点是否点中某图像

int z = 0, i = 0;

if (l == 1) { // 从调入处给出，在鼠标左键点击时调用,l=1建立或l=2修改

for (i = 0; i < 存储数据.size(); i++) {

图形代码1 = 存储数据.get(i).图形代码;

int x15 = 存储数据.get(i).标签左边距0;

int x16 = 存储数据.get(i).字段左边距0 + 存储数据.get(i).字段宽度0;

int x17 = 存储数据.get(i).标签左边距0 + 存储数据.get(i).标签宽度0;

int y15 = 存储数据.get(i).标签到顶距0;

int y16 = 存储数据.get(i).字段到顶距0 + 存储数据.get(i).高度0;

int y17 = 存储数据.get(i).标签到顶距0 + 存储数据.get(i).标签高度0;

boolean b1 = ((x15 + 5 <= EdgeX) && (y15 + 5 <= EdgeY) // 查文本框

&& ((x16 - 5 >= EdgeX) && (y16 - 5 >= EdgeY)));

boolean b2 = ((x15 + 5 <= EdgeX) && (y15 + 5 <= EdgeY) // 查按钮

&& ((x17 - 5 >= EdgeX) && (y17 - 5 >= EdgeY)));

double f1 = Math.sqrt((Math.pow(0.000 + y16 - y15, 2) // 测线条

+ Math.pow(x16 - x15, 2)));

double f2 = Math.sqrt((Math.pow(0.000 + EdgeY - y15, 2) + Math

.pow(EdgeX - x15, 2))); // 点击点方均根

double f3 = Math.sqrt((Math.pow(0.000 + EdgeY - y16, 2) + Math

.pow(EdgeX - x16, 2)));

int n1 = Integer.parseInt(存储数据.get(i).图形代码); // 取图形代码

if ((图形代码1.equals("7")) && (f1 * 1.005 >= f2 + f3)

&& (f1 * 0.995 <= f2 + f3)) {

z = 1; // 找到线条

序号1 = 存储数据.get(i).序号;

图形名称1 = 存储数据.get(i).图形名称;

标签左边距1 = 存储数据.get(i).标签左边距0;

标签到顶距1 = 存储数据.get(i).标签到顶距0;

字段左边距1 = 存储数据.get(i).字段左边距0;

字段到顶距1 = 存储数据.get(i).字段到顶距0;

元素索引 = i;

break;

}

else if (((b1) && (n1 < 6)) || ((b2) && (n1 == 6))

|| ((b2) && (n1 == 8))) {

z = 1; // 找到文本框、组合框、列表框、按钮

临时变量1x = 存储数据.get(i).x1坐标;

临时变量1y = 存储数据.get(i).y1坐标;

临时变量2x = 存储数据.get(i).x2坐标;

临时变量2y = 存储数据.get(i).y2坐标;

临时变量3x = 存储数据.get(i).行号;

临时变量3y = 存储数据.get(i).列号;

标签内容1 = 存储数据.get(i).标签内容;// 标签字数1=存储数据.get(i).标签字数;

序号1 = 存储数据.get(i).序号;

图形代码1 = 存储数据.get(i).图形代码;

图形名称1 = 存储数据.get(i).图形名称;

字段名1 = 存储数据.get(i).字段名0;

更换列名1 = 存储数据.get(i).更换列名0;

字段类型1 = 存储数据.get(i).字段类型0;

代码表名1 = 存储数据.get(i).代码表名0;

关键字1 = 存储数据.get(i).关键字0;

字体1 = 存储数据.get(i).字体0;

颜色1 = 存储数据.get(i).颜色0;

值域1 = 存储数据.get(i).值域0;

条件表达式1 = 存储数据.get(i).条件表达式0;

只作显示1 = 存储数据.get(i).只作显示0;

标签左边距1 = 存储数据.get(i).标签左边距0;

标签到顶距1 = 存储数据.get(i).标签到顶距0;

标签宽度1 = 存储数据.get(i).标签宽度0;

标签高度1 = 存储数据.get(i).标签高度0;

字段左边距1 = 存储数据.get(i).字段左边距0;

字段到顶距1 = 存储数据.get(i).字段到顶距0;

字段宽度1 = 存储数据.get(i).字段宽度0;

高度1 = 存储数据.get(i).高度0;

字号1 = 存储数据.get(i).字号0;

最大值1 = 存储数据.get(i).最大值0;

最小值1 = 存储数据.get(i).最小值0;

行号 = 存储数据.get(i).行号;

列号 = 存储数据.get(i).列号;

元素索引 = i;

break;

}

}

}

if (z == 1)

return true;

else {

标签内容1 = "";

序号1 = -1;

图形代码1 = "";

图形名称1 = "";

字段名1 = "";

return false;

}

}

public static void 打开图形框() {// 根据接口参数文件恢复画图

if (fa2.getText().length() > 0)

临时变量1x = 100;

临时变量1y = 150;

序号0 = 0;

try {

FileReader f0;

File f1 = new File(fa2.getText());

if (f1.exists()) { // 如果接口参数文件存在

f0 = new FileReader(fa2.getText());

BufferedReader file = new BufferedReader(f0);

String str = "";

Double z26 = 0.0;

Double z27 = 0.0;

while ((str = file.readLine()) != null) { // 读取下拉组合框图图形框内容

String[] o1 = str.split("。");

int x21 = Integer.parseInt(o1[3]);

int y21 = Integer.parseInt(o1[4]);

int x22 = Integer.parseInt(o1[6]);

int y22 = Integer.parseInt(o1[7]);

int x23 = Integer.parseInt(o1[8]);

int y23 = Integer.parseInt(o1[9]);

int z15 = Integer.parseInt(o1[15]);

int z16 = Integer.parseInt(o1[16]);

int z17 = Integer.parseInt(o1[17]);

int z18 = Integer.parseInt(o1[18]);

int z19 = Integer.parseInt(o1[19]);

int z20 = Integer.parseInt(o1[20]);

int z21 = Integer.parseInt(o1[21]);

int z22 = Integer.parseInt(o1[22]);

int z24 = Integer.parseInt(o1[24]);

if ((o1[26] != null) && (o1[26].length() > 0))

z26 = Double.parseDouble(o1[26]);

if ((o1[27] != null) && (o1[27].length() > 0))

z27 = Double.parseDouble(o1[27]);

mouseX2 = x21;

mouseY2 = y21;

标签字数1 = o1[11].length();

存储数据.add(new 存储结构7(序号0, o1[1], o1[2], x21, y21, o1[5], x22,

y22, x23, y23, o1[10], o1[11], o1[12], o1[13],

o1[14], z15, z16, z17, z18, z19, z20, z21, z22,

o1[23], z24, o1[25], z26, z27, o1[28], o1[29],

o1[30]));

序号0++;

}

file.close();

}

} catch (IOException e1) {

JOptionPane.showMessageDialog(null, "发生异常:" + e1);

}

开始运行 = 1;

选中按钮号 = 10;

frame.repaint();

}

public static void 删除类图及线条() {

int a1 = 0, b1 = 0, a2 = 0, b2 = 0, a3 = 0, b3 = 0, x11 = 0, y11 = 0;

x11 = 50;

y11 = 60;

存储数据.remove(元素索引);// 删除所存储的有关数据，倒着删除

选中按钮号 = 10;

frame.repaint();// 重新调用面板的paint()方法显示删除结果

}

public static void 画图形1() { // 根据结构数据画图形,刷新屏幕

Graphics2D g2 = (Graphics2D) g;

g2.setStroke(new BasicStroke(1f));

g.setColor(Color.BLACK);// 将画笔颜色设置成黑色

int k1 = 存储数据.size();

for (int i2 = 0; i2 < k1; i2++) {

临时变量1x = 存储数据.get(i2).x1坐标;

临时变量1y = 存储数据.get(i2).y1坐标;

临时变量2x = 存储数据.get(i2).x2坐标;

临时变量2y = 存储数据.get(i2).y2坐标;

临时变量3x = 存储数据.get(i2).行号;

临时变量3y = 存储数据.get(i2).列号;

标签内容1 = 存储数据.get(i2).标签内容;

序号1 = 存储数据.get(i2).序号;

图形代码1 = 存储数据.get(i2).图形代码;

图形名称1 = 存储数据.get(i2).图形名称;

字段名1 = 存储数据.get(i2).字段名0;

更换列名1 = 存储数据.get(i2).更换列名0;

字段类型1 = 存储数据.get(i2).字段类型0;

代码表名1 = 存储数据.get(i2).代码表名0;

关键字1 = 存储数据.get(i2).关键字0;

字体1 = 存储数据.get(i2).字体0;

颜色1 = 存储数据.get(i2).颜色0;

值域1 = 存储数据.get(i2).值域0;

条件表达式1 = 存储数据.get(i2).条件表达式0;

只作显示1 = 存储数据.get(i2).只作显示0;

标签左边距1 = 存储数据.get(i2).标签左边距0;

标签到顶距1 = 存储数据.get(i2).标签到顶距0;

标签宽度1 = 存储数据.get(i2).标签宽度0;

标签高度1 = 存储数据.get(i2).标签高度0;

字段左边距1 = 存储数据.get(i2).字段左边距0;

字段到顶距1 = 存储数据.get(i2).字段到顶距0;

字段宽度1 = 存储数据.get(i2).字段宽度0;

高度1 = 存储数据.get(i2).高度0;

字号1 = 存储数据.get(i2).字号0;

最大值1 = 存储数据.get(i2).最大值0;

最小值1 = 存储数据.get(i2).最小值0;// 以下画标签外框

if ((图形代码1.equals("6")) || (图形代码1.equals("8"))) { // 画按钮边框

g.drawLine(标签左边距1, 标签到顶距1, 标签左边距1 + 标签宽度1, 标签到顶距1); // 画标签

g.drawLine(标签左边距1, 标签到顶距1, 标签左边距1, 标签到顶距1 + 标签高度1);

g.drawLine(标签左边距1 + 标签宽度1, 标签到顶距1, 标签左边距1 + 标签宽度1, 标签到顶距1

+ 标签高度1);

g.drawLine(标签左边距1, 标签到顶距1 + 标签高度1, 标签左边距1 + 标签宽度1, 标签到顶距1

+ 标签高度1);

}

if ((! 更换列名1.equals("*")) && (! 图形代码1.equals("8"))) {

g.drawString(更换列名1, 标签左边距1 + 5, 标签到顶距1 + 15); // 画标签名

}

if (图形代码1.equals("4")) {

g.drawString("组合框", 字段左边距1 + 5, 字段到顶距1 + 15); // 画组合框

g.drawString("▼", 字段左边距1 + 字段宽度1 - 15, 字段到顶距1 + 13); // 画组合框

}

if (图形代码1.equals("5")) {

g.drawString("列表框", 字段左边距1 + 5, 字段到顶距1 + 15); // 画列表框

g.drawString("▼", 字段左边距1 + 字段宽度1 - 15, 字段到顶距1 + 13); // 画列表框

g.drawString("▲", 字段左边距1 + 字段宽度1 - 15, 字段到顶距1 + 高度1 - 6); // 画列表框

}

g.drawLine(字段左边距1, 字段到顶距1, 字段左边距1 + 字段宽度1, 字段到顶距1); // 画字段

g.drawLine(字段左边距1, 字段到顶距1, 字段左边距1, 字段到顶距1 + 高度1);

g.drawLine(字段左边距1 + 字段宽度1, 字段到顶距1, 字段左边距1 + 字段宽度1, 字段到顶距1 + 高度1);

g.drawLine(字段左边距1, 字段到顶距1 + 高度1, 字段左边距1 + 字段宽度1, 字段到顶距1 + 高度1);

if (图形代码1.equals("7"))

g.drawLine(标签左边距1, 标签到顶距1, 字段左边距1, 字段到顶距1); // 画线条

if (图形代码1.equals("8")) {

String sm = "";

if (更换列名1.lastIndexOf("\\") > 0)

if (更换列名1.lastIndexOf("p1") > 0)

sm = ".."+ 更换列名1.substring(更换列名1.lastIndexOf("p1") - 1,

更换列名1.length());

else

sm = 更换列名1.substring(更换列名1.lastIndexOf("\\") + 1,

更换列名1.length());

else

sm = 更换列名1;

if (sm.trim().length() > 0) {

File file = new File(sm);

try {

BufferedImage image = ImageIO.read(file);

g.drawImage(image, 标签左边距1 + 1, 标签到顶距1 + 1, 标签宽度1,

标签高度1, null); 

} catch (Exception e) {

}

} else {

g.drawString(字段名1, 标签左边距1 + 5, 标签到顶距1 + 10); // 画标签名

}

}

元素索引 = i2;

mouseX2 = 临时变量1x;

mouseY2 = 临时变量1y;

选中按钮号 = 0;

}

选中按钮号 = 0;

}

public static void 移动图形(int 元素索引, int 图形代码0) { // 移动图形到新位置

if ((图形代码0 < 7) || (图形代码0 == 8)) // 移动文本框、下拉组合框、列表框、按钮

存储数据.set(元素索引, new 存储结构7(序号1, 图形代码1, 图形名称1, 标签左边距1, 标签到顶距1, 标签内容1,

标签宽度1, 标签高度1, 字段左边距1, 高度1, 字段名1, 更换列名1, 字段类型1, 代码表名1, 关键字1,

标签左边距1 + mouseX6 - mouseX1, 标签到顶距1 + mouseY6 - mouseY1,

标签宽度1, 标签高度1, 字段左边距1 + mouseX6 - mouseX1, 字段到顶距1 + mouseY6

- mouseY1, 字段宽度1, 高度1, 字体1, 字号1, 颜色1, 最大值1, 最小值1,

值域1, 条件表达式1, 只作显示1));

else { // 线条

存储数据.get(元素索引).标签左边距0 = 存储数据.get(元素索引).标签左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签到顶距0 = 存储数据.get(元素索引).标签到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).字段左边距0 = 存储数据.get(元素索引).字段左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段到顶距0 = 存储数据.get(元素索引).字段到顶距0 + mouseY6 - mouseY1;

}

选中按钮号 = 10;

frame.repaint();

}

public static void 图形变换(int 元素索引) { // 变换图形大小

switch (光标标志0) {

case 1: {

存储数据.get(元素索引).标签左边距0 = 存储数据.get(元素索引).标签左边距0 + mouseX6 - mouseX1;

;

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 - mouseX6 + mouseX1;

;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 2: {

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 + mouseX6 - mouseX1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 3: {

存储数据.get(元素索引).标签到顶距0 = 存储数据.get(元素索引).标签到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 4: {

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 5: {

存储数据.get(元素索引).标签左边距0 = 存储数据.get(元素索引).标签左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 - mouseX6 + mouseX1;

存储数据.get(元素索引).标签到顶距0 = 存储数据.get(元素索引).标签到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 6: {

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签到顶距0 = 存储数据.get(元素索引).标签到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 7: {

存储数据.get(元素索引).标签左边距0 = 存储数据.get(元素索引).标签左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 - mouseX6 + mouseX1;

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 8: {

存储数据.get(元素索引).标签宽度0 = 存储数据.get(元素索引).标签宽度0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签高度0 = 存储数据.get(元素索引).标签高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 11: {

存储数据.get(元素索引).字段左边距0 = 存储数据.get(元素索引).字段左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 - mouseX6 + mouseX1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 12: {

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 + mouseX6 - mouseX1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 13: {

存储数据.get(元素索引).字段到顶距0 = 存储数据.get(元素索引).字段到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 14: {

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 15: {

存储数据.get(元素索引).字段左边距0 = 存储数据.get(元素索引).字段左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 - mouseX6 + mouseX1;

存储数据.get(元素索引).字段到顶距0 = 存储数据.get(元素索引).字段到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 16: {

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段到顶距0 = 存储数据.get(元素索引).字段到顶距0 + mouseY6 - mouseY1;

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 - mouseY6 + mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 17: {

存储数据.get(元素索引).字段左边距0 = 存储数据.get(元素索引).字段左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 - mouseX6 + mouseX1;

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 18: {

存储数据.get(元素索引).字段宽度0 = 存储数据.get(元素索引).字段宽度0 + mouseX6 - mouseX1;

存储数据.get(元素索引).高度0 = 存储数据.get(元素索引).高度0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 9: {

存储数据.get(元素索引).标签左边距0 = 存储数据.get(元素索引).标签左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).标签到顶距0 = 存储数据.get(元素索引).标签到顶距0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

case 19: {

存储数据.get(元素索引).字段左边距0 = 存储数据.get(元素索引).字段左边距0 + mouseX6 - mouseX1;

存储数据.get(元素索引).字段到顶距0 = 存储数据.get(元素索引).字段到顶距0 + mouseY6 - mouseY1;

选中按钮号 = 10;

光标标志0 = 0;

frame.repaint();

break;

}

}

}

public ControlPosition() { 

addMouseListener(new MouseMonitor());

addMouseMotionListener(new MouseMonitor());

}

public static void main(String[] args) {

scrollPane1 = new JScrollPane();

列名2[0] = "序号";

列名2[1] = "图形代码";

列名2[2] = "图形名称";

列名2[3] = "标签名";

列名2[4] = "字段名";

列名2[5] = "更换列名";

列名2[6] = "字段类型";

列名2[7] = "代码表名";

列名2[8] = "关键字";

列名2[9] = "标签左边距";

列名2[10] = "标签到顶距";

列名2[11] = "标签宽度";

列名2[12] = "标签高度";

列名2[13] = "字段左边距";

列名2[14] = "字段到顶距";

列名2[15] = "字段宽度";

列名2[16] = "高度";

列名2[17] = "字体";

列名2[18] = "字号";

列名2[19] = "颜色";

列名2[20] = "最大值";

列名2[21] = "最小值";

列名2[22] = "值域";

列名2[23] = "条件表达式";

列名2[24] = "只作显示";

列宽度 = new int[25];

序号0 = 0;

序号1 = 0;

开始运行 = 0;

元素索引 = 0;

元素索引2 = 0;

选中按钮号 = 0;

字数 = 0;

光标标志 = 0;

光标标志0 = 0;

图名[0] = "";

图名[1] = "";

图名[2] = "文本框";

图名[3] = "";

图名[4] = "下拉组合框";

图名[5] = "列表框";

图名[6] = "按钮";

图名[7] = "线条";

窗口宽 = 1350;

窗口高 = 700;

mouseX1 = 0;

mouseY1 = 0;

mouseX3 = 0;

mouseY3 = 0;

mouseX2 = 0;

mouseY2 = 0;

mouseX4 = 0;

mouseY4 = 0; // 右键点下位置

mouseX5 = 0;

mouseY5 = 0; // 更名标签位置

mouseX6 = 0;

mouseY6 = 0; // 左键释放时记录准备移动到的位置

mouseX7 = 6;

mouseY7 = 0; // 移动图形位置

右键标志 = 0;

图像宽度 = 60;

图像高度 = 50;

x1 = 10;

x2 = 13;

g2 = (Graphics2D) g;

存储数据 = new ArrayList<存储结构7>();

arr[0] = 3.0f;

arr[1] = 3.0f; // 文本域每段长度3，间距3

DBMS系统 = "sql server";

ODBC数据源 = "sql1";

组合框5 = new JComboBox();

fa1 = new JTextField("");

fa2 = new JTextField("");

fa3 = new JTextField("");

fa4 = new JTextField("");

列数 = 0;

列名 = null;

按钮名称[0] = "第一条";

按钮名称[1] = "下一条";

按钮名称[3] = "上一条";

按钮名称[2] = "末一条";

按钮名称[4] = "浏览";

按钮名称[5] = "存盘";

按钮名称[6] = "查询";

按钮名称[7] = "清屏";

按钮名称[8] = "修改";

按钮名称[9] = "批修改";

按钮名称[10] = "删除";

按钮名称[11] = "录入图形";

按钮名称[12] = "播放声音";

按钮名称[13] = "连续播放";

按钮名称[14] = "退出";

行间距离 = 0;

int 本行当前宽度 = 0;

起始左边距 = 0;

起始到顶距 = 0;

文本区宽度 = 0;

列名长度 = 0;

大数据个数 = 0;

最大字段宽 = 0;

需求面积 = 0;

原窗口宽 = 窗口宽;

原窗口高 = 窗口高;

控件个数 = 0;

字符宽度 = 15;

字符高度 = 20;

窗口左边距 = 10;

窗口到顶距 = 10;

列名表 = "";

要求按钮号表 = "";

实际按钮数 = 0;

位置参数表 = null;

标签位置 = null;

位置参数条数 = 0;

字段名字串 = "";

字典数据 = new String[0][0];

String[] 按钮集01 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘", "查询", "清屏",

"修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

要求按钮号表 = "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14";

按钮集 = new String[按钮集01.length];

按钮数 = 0;

for (int i0 = 0; i0 < 按钮集01.length; i0++)

按钮集[i0] = 按钮集01[i0];

frame = new ControlPosition();

frame.setTitle("表单设计程序               作者：程学先");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setBounds(10, 10, 窗口宽, 窗口高);

frame.getContentPane().setLayout(null); // 关闭布局管理器

panel = new JPanel();

panel.setBounds(0, 0, 窗口宽, 窗口高); 

panel.setLayout(null);// 设置此容器的布局管理器

try {

String[] tableType = { "TABLE" };

表名表 = "";

con = main1.getConn();

DatabaseMetaData databaseMetaData = con.getMetaData();

ResultSet resultSet = databaseMetaData.getTables(null, null, "%",

tableType);

while (resultSet.next()) {

表名表 = 表名表 + resultSet.getString("TABLE_NAME") + ",";

}

con.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "获取表名失败！");

}

JLabel la1 = new JLabel("表名"); // 定义下拉组合框图图形框名输入框

la1.setBounds(10, 5, 65, 25);

la1.setForeground(Color.red);

panel.add(la1);

组合框5.setFont(new java.awt.Font("Dialog", 0, 12));

组合框5.setBounds(new Rectangle(80, 5, 150, 25));

panel.add(组合框5);

String[] s8 = 表名表.split(",");

for (int i = 0; i < s8.length; i++) {

组合框5.addItem(s8[i]);

}

if (组合框5.getItemCount() > 0) {

组合框5.setSelectedIndex(-1);

}

JLabel la2 = new JLabel("存储文件名"); // 定义下拉组合框图图形框名输入框

la2.setBounds(235, 5, 85, 25);

panel.add(la2);

fa2.setBounds(320, 5, 300, 25);

panel.add(fa2);

fa2.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

存储数据.clear();

final JFileChooser fc = new JFileChooser(".\\"); // 文件夹对话框

fc.showOpenDialog(null); // 打开文件夹对话框

String s7 = "";

if (fc.getSelectedFile() != null) {

s7 = fc.getSelectedFile().toString();

}

if (s7.indexOf("txt") < 0)

s7 = s7 + ".txt";

fa2.setText(s7);

打开图形框();

开始运行 = 1;

}

});

JLabel la3 = new JLabel("字段号表"); // 定义下拉组合框图图形框名输入框

la3.setBounds(10, 30, 65, 25);

panel.add(la3);

fa3.setBounds(80, 30, 150, 25);

panel.add(fa3);

fa3.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

final JFileChooser fc = new JFileChooser(".\\"); // 文件夹对话框

kuangm = "fa3"; // 准备读取字段号

list1.removeAll();

for (int i = 0; i < 列数; i++)

list1.add(列名[i]);

frame1.setVisible(true);

}

});

JLabel la4 = new JLabel("按钮号表"); // 定义下拉组合框图图形框名输入框

la4.setBounds(235, 30, 85, 25);

panel.add(la4);

fa4.setBounds(320, 30, 300, 25);

panel.add(fa4); // 准备读取按钮号

fa4.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

final JFileChooser fc = new JFileChooser(".\\"); // 文件夹对话框

list1.removeAll();

kuangm = "fa4";

for (int i = 0; i < 按钮名称.length; i++)

list1.add(按钮名称[i]);

frame1.setVisible(true); 

}

});

JToolBar toolBar = new JToolBar(); // 定义工具条

toolBar.setBounds(610, 10, 700, 50);

JButton 文本框 = new JButton(new ImageIcon("文本框.png"));

文本框.setToolTipText("文本框");

toolBar.add(文本框);

JButton 下拉组合框 = new JButton(new ImageIcon("下拉组合框.png"));

下拉组合框.setToolTipText("下拉组合框");

toolBar.add(下拉组合框);

JButton 列表框 = new JButton(new ImageIcon("列表框.png"));

列表框.setToolTipText("列表框");

toolBar.add(列表框);

JButton 按钮 = new JButton(new ImageIcon("按钮.png"));

按钮.setToolTipText("按钮");

toolBar.add(按钮);

JButton 线条 = new JButton(new ImageIcon("线条.png"));

线条.setToolTipText("线条");

toolBar.add(线条);

JButton 图片 = new JButton(new ImageIcon("图片.png"));

图片.setToolTipText("图片");

toolBar.add(图片);

JButton 查看数据 = new JButton("查看数据");

toolBar.add(查看数据);

JButton 存盘 = new JButton(" 存  盘 ");

toolBar.add(存盘);

JButton 自动布局 = new JButton("自动布局");

toolBar.add(自动布局);

JButton 批修改 = new JButton("批 修 改");

toolBar.add(批修改); // 数字化修改参数

批修改.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

表格数据1 = new String[存储数据.size()][列名2.length];

for (int i1 = 0; i1 < 存储数据.size(); i1++) {

表格数据1[i1][0] = 存储数据.get(i1).序号 + "";

表格数据1[i1][1] = 存储数据.get(i1).图形代码;

表格数据1[i1][2] = 存储数据.get(i1).图形名称;

表格数据1[i1][3] = 存储数据.get(i1).标签内容;

表格数据1[i1][4] = 存储数据.get(i1).字段名0;

表格数据1[i1][5] = 存储数据.get(i1).更换列名0;

表格数据1[i1][6] = 存储数据.get(i1).字段类型0;

表格数据1[i1][7] = 存储数据.get(i1).代码表名0;

表格数据1[i1][8] = 存储数据.get(i1).关键字0;

表格数据1[i1][9] = 存储数据.get(i1).标签左边距0 + "";

表格数据1[i1][10] = 存储数据.get(i1).标签到顶距0 + "";

表格数据1[i1][11] = 存储数据.get(i1).标签宽度0 + "";

表格数据1[i1][12] = 存储数据.get(i1).标签高度0 + "";

表格数据1[i1][13] = 存储数据.get(i1).字段左边距0 + "";

表格数据1[i1][14] = 存储数据.get(i1).字段到顶距0 + "";

表格数据1[i1][15] = 存储数据.get(i1).字段宽度0 + "";

表格数据1[i1][16] = 存储数据.get(i1).高度0 + "";

表格数据1[i1][17] = 存储数据.get(i1).字体0;

表格数据1[i1][18] = 存储数据.get(i1).字号0 + "";

表格数据1[i1][19] = 存储数据.get(i1).颜色0;

表格数据1[i1][20] = 存储数据.get(i1).最大值0 + "";

表格数据1[i1][21] = 存储数据.get(i1).最小值0 + "";

表格数据1[i1][22] = 存储数据.get(i1).值域0;

表格数据1[i1][23] = 存储数据.get(i1).条件表达式0;

表格数据1[i1][24] = 存储数据.get(i1).只作显示0;

}

表列数据类型1 = new String[列名2.length];

列宽度 = new int[列名2.length];

for (int i = 0; i < 列名2.length; i++) {

if (((i > 1) && (i < 7)) || (i == 22))

列宽度[i] = 8;

else if ((i != 7) && (i != 23))

列宽度[i] = 4;

else

列宽度[i] = 14; // 代码表与条件表达式

表列数据类型1[i] = "char";

}

tableTenance0.tableModel(1350, 600, 列名2, 列宽度, 表格数据1, 表列数据类型1);

}

});

JButton 进入表单 = new JButton("进入表单");

toolBar.add(进入表单); 

进入表单.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String[] parameter = new String[23];

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

parameter[i] = "";

parameter[4] = fa1.getText(); // 数据表名

for (int i1 = 0; i1 < 存储数据.size(); i1++) {

if (存储数据.get(i1).关键字0.equals("是"))

if (parameter[6].length() <= 0)

parameter[6] = 存储数据.get(i1).字段名0;

else

parameter[6] = parameter[6] + ","

+ 存储数据.get(i1).字段名0;

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

parameter[17] = 窗口宽 + "";

parameter[18] = (窗口高 + 100) + "";

parameter[4] = 表名;

parameter[5] = fa2.getText();

parameter[0] = 表名表;

parameter[19] = 字段名字串;

dataTenance9.means(parameter);

}

});

JButton 打印表单 = new JButton("打印表单");

toolBar.add(打印表单);

打印表单.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String[] parameter = new String[23];

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

parameter[i] = "";

parameter[4] = 表名; // 数据表名

parameter[15] = fa2.getText();

dataPreview2.means(parameter);

}

});

JButton 退出 = new JButton(" 退  出 ");

toolBar.add(退出);

退出.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

frame.setVisible(false);

frame.dispose();

}

});

panel.add(toolBar, BorderLayout.NORTH);

frame.setContentPane(panel);

frame.setVisible(true);

文本框.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

图形框名 = "";

选中按钮号 = 2;

}

});

下拉组合框.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

图形框名 = "";

选中按钮号 = 4;

}

});

列表框.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

图形框名 = "";

选中按钮号 = 5;

}

});

按钮.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

按钮名 = "";

选中按钮号 = 6;

}

});

线条.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

线条名 = "";

选中按钮号 = 7;

}

});

图片.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

线条名1 = "";

选中按钮号 = 8;

}

});

查看数据.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String 查看数据 = "";

char x1 = 10, x2 = 13;

for (int i = 0; i < 存储数据.size(); i++) {

查看数据 = 查看数据 + 存储数据.get(i).序号 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).图形代码 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).图形名称 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).x1坐标 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).y1坐标 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).标签内容 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).行号 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).列号 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字段名0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).更换列名0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字段类型0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).代码表名0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).关键字0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).标签左边距0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).标签到顶距0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).标签宽度0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).标签高度0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字段左边距0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字段到顶距0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字段宽度0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).高度0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字体0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).字号0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).颜色0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).最大值0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).最小值0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).值域0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).条件表达式0 + "  ";

查看数据 = 查看数据 + 存储数据.get(i).只作显示0 + "  ";

查看数据 = 查看数据 + x1 + x2;

}

printClass1.main3(查看数据, 1000, 500);

选中按钮号 = 0;

}

});

存盘.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

选中按钮号 = 0;

String sn = fa2.getText();

if (sn.trim().length() < 1) {

sn = JOptionPane.showInputDialog("请输入文件名称。");

if (sn.indexOf("txt") < 0)

sn = sn + ".txt";

fa2.setText(sn);

}

try {

File f1 = new File(sn);

f1.createNewFile();// 创建图形框

BufferedWriter f0 = new BufferedWriter(new FileWriter(f1));

String s11 = "";

for (int i = 0; i < 存储数据.size(); i++) {

s11 = s11 + 存储数据.get(i).序号 + "。";

s11 = s11 + 存储数据.get(i).图形代码 + "。";

s11 = s11 + 存储数据.get(i).图形名称 + "。";

s11 = s11 + 存储数据.get(i).x1坐标 + "。";

s11 = s11 + 存储数据.get(i).y1坐标 + "。";

s11 = s11 + 存储数据.get(i).标签内容 + "。";

s11 = s11 + 存储数据.get(i).x2坐标 + "。";

s11 = s11 + 存储数据.get(i).y2坐标 + "。";

s11 = s11 + 存储数据.get(i).行号 + "。";

s11 = s11 + 存储数据.get(i).列号 + "。";

s11 = s11 + 存储数据.get(i).字段名0 + "。";

s11 = s11 + 存储数据.get(i).更换列名0 + "。";

s11 = s11 + 存储数据.get(i).字段类型0 + "。";

s11 = s11 + 存储数据.get(i).代码表名0 + "。";

s11 = s11 + 存储数据.get(i).关键字0 + "。";

s11 = s11 + 存储数据.get(i).标签左边距0 + "。";

s11 = s11 + 存储数据.get(i).标签到顶距0 + "。";

s11 = s11 + 存储数据.get(i).标签宽度0 + "。";

s11 = s11 + 存储数据.get(i).标签高度0 + "。";

s11 = s11 + 存储数据.get(i).字段左边距0 + "。";

s11 = s11 + 存储数据.get(i).字段到顶距0 + "。";

s11 = s11 + 存储数据.get(i).字段宽度0 + "。";

s11 = s11 + 存储数据.get(i).高度0 + "。";

s11 = s11 + 存储数据.get(i).字体0 + "。";

s11 = s11 + 存储数据.get(i).字号0 + "。";

s11 = s11 + 存储数据.get(i).颜色0 + "。";

s11 = s11 + 存储数据.get(i).最大值0 + "。";

s11 = s11 + 存储数据.get(i).最小值0 + "。";

s11 = s11 + 存储数据.get(i).值域0 + "。";

s11 = s11 + 存储数据.get(i).条件表达式0 + "。";

s11 = s11 + 存储数据.get(i).只作显示0 + "。";

f0.write(s11);

f0.newLine();

s11 = "";

}

f0.flush();

f0.close();

} catch (IOException e1) {

JOptionPane.showMessageDialog(null, "发生异常:" + e1);

}

}

});

自动布局.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

选中按钮号 = 0;

起始到顶距 = 5;

数据表查询结构001(fa1.getText());

计算文本框001();

int k = 0;

存储数据 = new ArrayList<存储结构7>();

序号0 = 0;

for (int j = 0; j < 控件个数; j++) {

存储数据.add(new 存储结构7(序号0, "2", "文本框", Integer

.parseInt(位置参数表[j][6]), Integer

.parseInt(位置参数表[j][4]), 位置参数表[j][1], 0, 0, Integer

.parseInt(标签位置[j][5]),

Integer.parseInt(标签位置[j][6]), 位置参数表[j][0],

位置参数表[j][1], 标签位置[j][4], "", "否", Integer

.parseInt(位置参数表[j][6]), Integer

.parseInt(位置参数表[j][7]), Integer

.parseInt(位置参数表[j][3]), Integer

.parseInt(位置参数表[j][2]), Integer

.parseInt(标签位置[j][0]), Integer

.parseInt(标签位置[j][1]), Integer

.parseInt(位置参数表[j][4]), Integer

.parseInt(位置参数表[j][5]), 位置参数表[j][8],

Integer.parseInt(位置参数表[j][9]), 位置参数表[j][10], 0.0,

0.0, "", "", "可读写"));

序号0++;

}

for (int j = 0; j < 按钮数; j++) {

if (按钮位置[j][0] > 0) {

存储数据.add(new 存储结构7(序号0, "6", "按钮", 按钮位置[j][0],

按钮位置[j][1], 按钮集[j], 按钮位置[j][0], 按钮位置[j][1],

按钮位置[j][2], 按钮位置[j][3], 按钮集[j], 按钮集[j], "按钮",

按钮位置[j][4] + "", "否", 按钮位置[j][0], 按钮位置[j][1],

按钮位置[j][2], 按钮位置[j][3], 0, 0, 0, 0, "宋体", 10,

"5   black黑色", 0.0, 0.0, "", "", "可读写"));

序号0++;

}

}

选中按钮号 = 50; // 刷新屏幕

frame.repaint();// 重新调用面板的paint()方法

}

});

组合框5.addItemListener(new ItemListener() {

public void itemStateChanged(ItemEvent arg0) {

表名 = 组合框5.getSelectedItem().toString();

数据表查询结构001(表名);

列名表 = 字段名字串;

开始运行 = 1;

}

}); 

frame1 = new ControlPosition();

frame1.setBounds(100, 150, 100, 400);

frame1.getContentPane().setLayout(null); // 关闭布局管理器

panel1 = new JPanel();

panel1.setBounds(0, 0, 100, 400);

panel1.setLayout(null);// 设置此容器的布局管理器

list1 = new List(130, false);

list1.setBounds(0, 0, 140, 340); 

JScrollPane listScroll = new JScrollPane(list1);// 加滚动条到list1

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

if (list1.getSelectedIndex() >= 0)

if (kuangm.equals("fa3")) {

if (fa3.getText().length() > 0) {

if (("," + fa3.getText() + ",").indexOf(","

+ list1.getSelectedIndex() + ",") < 0)

fa3.setText(fa3.getText() + ","

+ list1.getSelectedIndex());

} else

fa3.setText("" + list1.getSelectedIndex());

} else if (kuangm.equals("fa4")) {

if (fa4.getText().length() > 0) {

if (("," + fa4.getText() + ",").indexOf(","

+ list1.getSelectedIndex() + ",") < 0)

fa4.setText(fa4.getText() + ","

+ list1.getSelectedIndex());

} else

fa4.setText("" + list1.getSelectedIndex());

}

}

});

panel1.add(list1);

frame1.setContentPane(panel1);

final int 窗口宽度 = 1350, 窗口高度 = 700;

frame2 = new ControlPosition();

frame2.setBounds(10, 100, 窗口宽度, 窗口高度 - 100);

frame2.getContentPane().setLayout(null); // 关闭布局管理器

panel2 = new JPanel();

panel2.setBounds(0, 0, 窗口宽度 - 30, 窗口高度 - 10);

panel2.setLayout(null);// 设置此容器的布局管理器

scrollPane1.setBounds(0, 0, 窗口宽度 - 30, 窗口高度 - 100); // 定义滚动面板大小位置

panel2.add(scrollPane1); // 在窗体中央添加滚动面板

表格数据1 = new String[存储数据.size()][列名2.length];

表格模型 = new DefaultTableModel(表格数据1, 列名2); // 建立表格模型

表格 = new JTable(表格模型);

scrollPane1.getViewport().add(表格, null);

JButton 返回 = new JButton("返回");

返回.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame.setVisible(true);

frame2.setVisible(false);

frame2.dispose();

}

});

返回.setBounds(10, 520, 窗口宽度 - 100, 20);

panel2.add(返回);

frame2.add(panel2); // 在窗体中央添加滚动面板

frame2.setLayout(null);

frame2.setVisible(false);

} 

public void paint(Graphics g1) {

g = g1;

if (开始运行 == 0) {

super.paint(g1);

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

g1.fillRect(0, 95, 原窗口宽, 原窗口高);// 使用白色填充整个面板

g1.setColor(Color.black);// 将画笔颜色设置成黑色

return;

} else if (选中按钮号 == 10) { // 刷新屏幕

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

g1.fillRect(0, 95, 原窗口宽, 原窗口高);// 使用白色填充整个面板

g1.setColor(Color.black);// 将画笔颜色设置成黑色

画图形1(); 

选中按钮号 = 0;

} else if (选中按钮号 == 19) { // 新建返回

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

g1.fillRect(0, 95, 原窗口宽, 原窗口高);// 使用白色填充整个面板

g1.setColor(Color.black);// 将画笔颜色设置成黑色

int a2 = mouseX2 + 标签宽度1;

int b2 = mouseY2 + 高度1;

int a3 = a2;

int b3 = a3;

标签内容1 = 字段名1;

if ((图形代码1.equals("4")) || (图形代码1.equals("5"))) {

字段宽度1 = 字段宽度1 + 15;

if (图形代码1.equals("5"))

高度1 = 高度1 + 40;

}

存储数据.add(new 存储结构7(序号0, 图形代码1, 图形名称1, mouseX2, mouseY2, 标签内容1, a2,

b2, a3, b3, 字段名1, 更换列名1, 字段类型1, 代码表名1, 关键字1, 标签左边距1,

标签到顶距1, 标签宽度1, 标签高度1, 字段左边距1, 字段到顶距1, 字段宽度1, 高度1, 字体1, 字号1,

颜色1, 最大值1, 最小值1, 值域1, 条件表达式1, 只作显示1));

序号0++;

画图形1(); // 重画图形

选中按钮号 = 0;

} else if (选中按钮号 == 18) { // 修改返回

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

g1.fillRect(0, 95, 原窗口宽, 原窗口高);// 使用白色填充整个面板

g1.setColor(Color.black);// 将画笔颜色设置成黑色

int a2 = mouseX2 + 标签宽度1;

int b2 = mouseY2 + 高度1;

int a3 = a2;

int b3 = a3;

标签内容1 = 字段名1;

存储数据.set(序号1, new 存储结构7(序号1, 图形代码1, 图形名称1, mouseX2, mouseY2, 标签内容1,

a2, b2, a3, b3, 字段名1, 更换列名1, 字段类型1, 代码表名1, 关键字1, 标签左边距1,

标签到顶距1, 标签宽度1, 标签高度1, 字段左边距1, 字段到顶距1, 字段宽度1, 高度1, 字体1, 字号1,

颜色1, 最大值1, 最小值1, 值域1, 条件表达式1, 只作显示1));

画图形1(); // 重画图形

选中按钮号 = 0;

} else if (选中按钮号 == 50) { // 自动布局

g1.setColor(Color.WHITE);// 将画笔颜色设置成白色

g1.fillRect(0, 95, 原窗口宽, 原窗口高);// 使用白色填充整个面板

g1.setColor(Color.black);// 将画笔颜色设置成黑色

画图形1(); // 重画图形

选中按钮号 = 0;

} else if (选中按钮号 == 7) {

g.drawLine(mouseX1, mouseY1, mouseX3, mouseY3); // 画线条

选中按钮号 = 0;

}

}

class MouseMonitor implements MouseListener, MouseMotionListener {// 鼠标监听

public void mouseEntered(MouseEvent arg0) {

if ((选中按钮号 == 20) || (选中按钮号 == 33)) { 

选中按钮号 = 10; // 刷新屏幕

frame.repaint();// 重新调用面板的paint()方法

} else if (选中按钮号 == 15) { 

选中按钮号 = 19; // 刷新屏幕

frame.repaint();// 重新调用面板的paint()方法

} else if (选中按钮号 == 16) { 

元素索引2 = 元素索引;

选中按钮号 = 18; // 刷新屏幕

frame.repaint();// 重新调用面板的paint()方法

}

}

public void mousePressed(MouseEvent me) {// 鼠标按下事件

右键标志 = me.getModifiers();

mouseX4 = 0;

if (右键标志 == 4) { // 右键按下位置

mouseX4 = me.getX();

mouseY4 = me.getY();

}

mouseX1 = me.getX();

mouseY1 = me.getY();

if (光标标志 > 0) {

光标标志0 = 光标标志;

光标标志 = 0; // 如果在光标标志大于0 情况下出现点击，先换标志，再将光标标志复0

} else

光标标志0 = 0;

}

public void mouseReleased(MouseEvent me) {// 鼠标释放事件

mouseX3 = me.getX();

mouseY3 = me.getY();

Object[] options = { "修改图形参数并重画类图", "删除图形", "退出" };

int 处理参数 = 0;

if ((右键标志 == 4) && (光标标志0 > 0) && (选中按钮号 == 0)) { // 右键操作,光标标志0>0表示鼠标形状变换了

if (((mouseX1 != me.getX()) || (mouseY1 != me.getY()))) { // 鼠标点击后离开原位

mouseX6 = me.getX(); // 改变图形边界，扩大或缩小

mouseY6 = me.getY();

图形变换(元素索引);

}

} 

else if ((选中按钮号 == 7) && (右键标志 != 4)) { // 画线条

if ((mouseX1 != me.getX()) || (mouseY1 != me.getY())) {

开始运行 = 1;

frame.repaint();// 重新调用面板的paint()方法

if ((Math.abs(0.0 + mouseX1 - mouseX3)

/ Math.abs(mouseY1 - mouseY3) < 0.07))

mouseX3 = mouseX1; // 如果线条近似水平或近似垂直，就校正为水平或垂直

if ((Math.abs(0.0 + mouseY1 - mouseY3)

/ Math.abs(mouseX1 - mouseX3) < 0.07))

mouseY3 = mouseY1;

存储数据.add(new 存储结构7(序号0, "7", "线条", mouseX1, mouseY1, " ",

mouseX1, mouseY1, mouseX3, mouseY3, "线条", " ", " ",

" ", " ", mouseX1, mouseY1, 1, 1, mouseX3, mouseY3,

1, 1, "宋体", 10, "5", 0, 0, " ", " ", " ")); // 画线条

序号0++;

选中按钮号 = 10;

frame.repaint();// 显示删除结果

}

} else if ((右键标志 == 4) && (find(mouseX1, mouseY1, 1))

&& (选中按钮号 == 0) && (光标标志 == 0)) {// 查到目标

int 图形代码0 = Integer.parseInt(图形代码1);

if (((mouseX1 != me.getX()) || (mouseY1 != me.getY()))) {

mouseX6 = me.getX(); // 移动到新位置

mouseY6 = me.getY();

移动图形(元素索引, 图形代码0);

} // 如果是右键点击，查到了图形，鼠标基本上在点外另外处释放，表示移动位置

else if ((图形代码0 < 7) || (图形代码0 == 8)) {// 如是在当地释放、右键点击，询问是改参数，还是删除

处理参数 = (JOptionPane.showOptionDialog(null,

"请确定是修改图形参数还是删除图形。", "确定是修改图形参数还是删除图形。",

JOptionPane.YES_NO_OPTION,

JOptionPane.QUESTION_MESSAGE, null, options,

options[1]));

if (处理参数 == 0) { // 修改图形参数

sysParametric4.main2(15, 图形代码0, 元素索引, 列名, 列数据宽度,

标签左边距1, 标签到顶距1, 行号, 列号);

} else if (处理参数 == 1) {

删除类图及线条();

}

} 

else if (图形代码0 == 7) {// 如是线条且在当地释放、右键点击，询问是否删除线条

存储数据.remove(元素索引);// 删除线条

选中按钮号 = 10;

frame.repaint();// 显示删除结果

}

} 

}

public void mouseExited(MouseEvent arg0) {}// 鼠标不点击移动进出大窗口

public void mouseMoved(MouseEvent e) { // 鼠标不点击在窗口内移动过程中

if (选中按钮号 != 7)

for (int i = 0; i < 存储数据.size(); i++) {

int 图形代码0 = Integer.parseInt(存储数据.get(i).图形代码);

临时变量1x = 存储数据.get(i).标签左边距0;

临时变量2x = 存储数据.get(i).标签左边距0 + 存储数据.get(i).标签宽度0;

临时变量3x = 存储数据.get(i).字段左边距0;

临时变量4x = 存储数据.get(i).字段左边距0 + 存储数据.get(i).字段宽度0;

临时变量1y = 存储数据.get(i).标签到顶距0;

临时变量2y = 存储数据.get(i).标签到顶距0 + 存储数据.get(i).标签高度0;

临时变量3y = 存储数据.get(i).字段到顶距0;

临时变量4y = 存储数据.get(i).字段到顶距0 + 存储数据.get(i).高度0;

if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量1x - 2 <= e.getX())

&& (临时变量1x + 2 >= e.getX())

&& (临时变量1y < e.getY() - 2)

&& (临时变量2y > e.getY() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));// 一字光标左边框

光标标志 = 1;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量2x - 2 <= e.getX())

&& (临时变量2x + 2 >= e.getX())

&& (临时变量1y < e.getY() - 2)

&& (临时变量2y > e.getY() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));// 一字光标

光标标志 = 2;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量1y - 2 <= e.getY())

&& (临时变量1y + 2 >= e.getY())

&& (临时变量1x < e.getX() - 2)

&& (临时变量2x > e.getX() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));// |字光标

光标标志 = 3;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量2y - 2 <= e.getY())

&& (临时变量2y + 2 >= e.getY())

&& (临时变量1x < e.getX() - 2)

&& (临时变量2x > e.getX() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));// |字光标

光标标志 = 4;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量1x - 2 <= e.getX())

&& (临时变量1x + 2 >= e.getX())

&& (临时变量1y + 2 > e.getY())

&& (临时变量1y - 2 < e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));// \字光标

光标标志 = 5;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量2x - 2 <= e.getX())

&& (临时变量2x + 2 >= e.getX())

&& (临时变量1y + 2 > e.getY())

&& (临时变量1y - 2 < e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));// /字光标

光标标志 = 6;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量2y - 2 <= e.getY())

&& (临时变量2y + 2 >= e.getY())

&& (临时变量1x + 2 > e.getX())

&& (临时变量1x - 2 < e.getX())) {

setCursor(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR)); // /字光标

光标标志 = 7;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量2y - 2 <= e.getY())

&& (临时变量2y + 2 >= e.getY())

&& (临时变量2x + 2 > e.getX())

&& (临时变量2x - 2 < e.getX())) {

setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR)); // \字光标

光标标志 = 8;

元素索引 = i;

break;

}

else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量3x - 2 <= e.getX())

&& (临时变量3x + 2 >= e.getX())

&& (临时变量3y < e.getY() - 2)

&& (临时变量4y > e.getY() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));// 一字光标左边框

光标标志 = 11;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量4x - 2 <= e.getX())

&& (临时变量4x + 2 >= e.getX())

&& (临时变量3y < e.getY() - 2)

&& (临时变量4y > e.getY() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));// 一字光标

光标标志 = 12;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量3y - 2 <= e.getY())

&& (临时变量3y + 2 >= e.getY())

&& (临时变量3x < e.getX() - 2)

&& (临时变量4x > e.getX() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));// |字光标

光标标志 = 13;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量4y - 2 <= e.getY())

&& (临时变量4y + 2 >= e.getY())

&& (临时变量3x < e.getX() - 2)

&& (临时变量4x > e.getX() + 2)) {

setCursor(Cursor.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));// |字光标

光标标志 = 14;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量3x - 2 <= e.getX())

&& (临时变量3x + 2 >= e.getX())

&& (临时变量3y + 2 > e.getY())

&& (临时变量3y - 2 < e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));// \字光标

光标标志 = 15;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量4x - 2 <= e.getX())

&& (临时变量4x + 2 >= e.getX())

&& (临时变量3y + 2 > e.getY())

&& (临时变量3y - 2 < e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));// /字光标

光标标志 = 16;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量4y - 2 <= e.getY())

&& (临时变量4y + 2 >= e.getY())

&& (临时变量3x + 2 > e.getX())

&& (临时变量3x - 2 < e.getX())) {

setCursor(Cursor.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR)); // /字光标

光标标志 = 17;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量4y - 2 <= e.getY())

&& (临时变量4y + 2 >= e.getY())

&& (临时变量4x + 2 > e.getX())

&& (临时变量4x - 2 < e.getX())) {

setCursor(Cursor.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR)); // \字光标

光标标志 = 18;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量1x - 2 <= e.getX())

&& (临时变量1x + 2 >= e.getX())

&& (临时变量1y - 2 < e.getY())

&& (临时变量2y + 2 > e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));// 十字光标

光标标志 = 9;

元素索引 = i;

break;

} else if (((图形代码0 < 7) || (图形代码0 == 8))

&& (临时变量3x - 2 <= e.getX())

&& (临时变量3x + 2 >= e.getX())

&& (临时变量3y - 2 < e.getY())

&& (临时变量3y + 2 > e.getY())) {

setCursor(Cursor.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));// 十字光标

光标标志 = 19;

元素索引 = i;

break;

} else { // 如果鼠标在目标处点击，光标标志将复0

光标标志 = 0;

元素索引 = 0;

setCursor(Cursor.getPredefinedCursor(Cursor.DEFAULT_CURSOR));// 默认光标

}

}

}

public void mouseClicked(MouseEvent me) {// 鼠标点击事件，修改标签名称

mouseX2 = me.getX();

mouseY2 = me.getY();

if ((选中按钮号 > 0) && ((选中按钮号 < 7) || (选中按钮号 == 8)) && (右键标志 != 4)) {

if ((列数 == 0) && (选中按钮号 < 6)) {

JOptionPane.showMessageDialog(null, "请先选择数据表名！");

return;

}

mouseX2 = me.getX(); // 画图

mouseY2 = me.getY();

图形代码1 = 选中按钮号 + "";

图形名称1 = 图名[选中按钮号];

if (!(find(mouseX2, mouseY2, 1))) { // 查询所点击的是否图像，没找到意味添加

sysParametric4.main2(14, 选中按钮号, -1, 列名, 列数据宽度, mouseX2,

mouseY2, 0, 0);

}

}

}

public void mouseDragged(MouseEvent arg0) {}

}

static void 计算文本框001() { // 计算控件位置、大小参数

int 行间距离 = 0;

int 本行当前宽度 = 0;

int 起始左边距 = 10;

int 当前列列号 = 1;

int 当前行行号 = 1;

位置参数 = new int[列数][2];

位置参数条数 = 列数;

int 文本控件行数 = 1;

文本区宽度 = 窗口宽 - 80;

起始到顶距 = 100;

int y1 = 起始左边距;

int y2 = 起始到顶距;

int 最大标签宽度 = 0;

if ((大数据个数 == 0) && (列数 * 字符高度 < 窗口高 - 120)) {

文本控件行数 = 列数;

行间距离 = (窗口高 - 120 - 列数 * 字符高度) / (列数 + 1);

int n1 = 1, n2 = 1; // 行号、列号

for (int j = 0; j < 列数; j++) { // 求最大标签宽度

if (位置参数表[j][1].length() > 最大标签宽度)

最大标签宽度 = 位置参数表[j][1].length();

}

for (int j = 0; j < 列数; j++) {

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = (文本区宽度 - Integer.parseInt(标签位置[j][0])) + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y2 = y2 + 字符高度 + 行间距离;

起始到顶距 = y2;

标签位置[j][5] = n1 + ""; // 行号

标签位置[j][6] = n2 + ""; // 列号

n1++;

}

} else // 字段比较多，或者有大数据

{

当前列列号 = 1;

y1 = 起始左边距; // 当前位置

y2 = 起始到顶距;

当前行行号 = 1;

for (int j = 0; j < 列数; j++) { // 先处理非大数据

列名长度 = 位置参数表[j][1].length(); // 翻译后字段名宽度

if (("ntext,text,memo,image,long,lob,").lastIndexOf(列数据类型[j]) < 0) {

if ((y1 + (列名长度 + 列数据宽度[j]) * 字符宽度) > 文本区宽度) { // 如果放不下，换行

当前行行号++;

当前列列号 = 1;

y1 = 起始左边距;

y2 = y2 + 字符高度;

}

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 列名长度 * 字符宽度 + ""; // 标签宽度

if ((y1 == 起始左边距) && (列名长度 > 最大标签宽度))

最大标签宽度 = 列名长度;

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 列名长度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = 列数据宽度[j] * 字符宽度 + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y1 = y1 + 列名长度 * 字符宽度 + 列数据宽度[j] * 字符宽度;

标签位置[j][5] = 当前行行号 + "";

标签位置[j][6] = 当前列列号 + "";

当前列列号++;

} 

} // 非大数据处理完成

if (大数据个数 == 0)

行间距离 = (窗口高 - 120) / (当前行行号 + 1) - 字符高度;

else

行间距离 = 0;

if (行间距离 < 0)

行间距离 = 0;

int z = 0; // 每行左移数值

int z1 = 0; // 每行下移数值

int z3 = 0; // 最后一个非大数据字段号

for (int j = 0; j < 列数; j++) { // 先处理非大数据位置调整

if (main1.文本数据类型.lastIndexOf(列数据类型[j]) < 0) {

if (Integer.parseInt(位置参数表[j][6]) == 起始左边距) { // 每行第一列

z = 最大标签宽度 * 字符宽度 - Integer.parseInt(位置参数表[j][3]); // 修正标签宽度

z1 = z1 + 行间距离;

if (j > 0)

位置参数表[z3][4] = (文本区宽度 - Integer

.parseInt(标签位置[z3][0])) + "";

}

位置参数表[j][6] = (Integer.parseInt(位置参数表[j][6]) + z) + ""; // 标签左边

标签位置[j][0] = (Integer.parseInt(标签位置[j][0]) + z) + ""; // 字段左边

位置参数表[j][7] = (Integer.parseInt(位置参数表[j][7]) + z1) + ""; // 标签到顶

标签位置[j][1] = (Integer.parseInt(标签位置[j][1]) + z1) + ""; // 字段到顶

y2 = Integer.parseInt(标签位置[j][1]) + z1;

z3 = j;

}

} 

位置参数表[z3][4] = (文本区宽度 - Integer.parseInt(标签位置[z3][0])) + "";

起始到顶距 = y2;

if (大数据个数 > 0) {

y2 = y2 + 字符高度; // 剩下空间高度

int z2 = (窗口高 - y2 - 120) / 大数据个数; // 大数据高度

for (int i3 = 0; i3 < 列数; i3++) { // 处理大数据位置

if (main1.文本数据类型.lastIndexOf(列数据类型[i3]) >= 0) {

当前行行号++;

当前列列号 = 1;

位置参数表[i3][6] = 起始左边距 + ""; // 标签左边

位置参数表[i3][7] = y2 + ""; // 标签到顶

位置参数表[i3][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[i3][2] = 字符高度 + ""; // 标签高度

标签位置[i3][0] = (起始左边距 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[i3][1] = y2 + ""; // 字段到顶

y2 = y2 + z2;

位置参数表[i3][4] = (文本区宽度 - 最大标签宽度 * 字符宽度 - 10) + ""; // 字段宽度

位置参数表[i3][5] = z2 + ""; // 字段高度

位置参数表[i3][8] = "宋体";

位置参数表[i3][9] = "10"; // 字号

位置参数表[i3][10] = "5"; // 颜色

标签位置[i3][2] = "2"; // 图形代号

if ((",image,long,lob,").lastIndexOf(列数据类型[i3]) >= 0)

标签位置[i3][4] = "图像字段"; // 字段类型

else

标签位置[i3][4] = "文本字段"; // 字段类型

标签位置[i3][5] = 当前行行号 + "";

标签位置[i3][6] = 当前列列号 + "";

当前列列号++;

}

}

} // 处理非大数据与大数据完成

}

int zzb = 1000;

String bqk = "";

for (int i3 = 0; i3 < 列数; i3++) {

if (Integer.parseInt(标签位置[i3][6]) == 1) // 第一列

if (zzb > Integer.parseInt(位置参数表[i3][6]))

zzb = Integer.parseInt(位置参数表[i3][6]);

bqk = 位置参数表[i3][3];

}

for (int i3 = 0; i3 < 列数; i3++)

if (Integer.parseInt(标签位置[i3][6]) == 1) { // 第一列

位置参数表[i3][6] = zzb + ""; // 标签左边

位置参数表[i3][3] = bqk;

}

起始到顶距 = y2;

if (fa4.getText().length() > 0)

要求按钮号表 = fa4.getText();// 需要显示的按钮的顺序号

按钮数 = 按钮集.length; // 可以供选择的按钮数

按钮位置 = new int[按钮数][15];

String[] t5 = 要求按钮号表.split(",");

实际按钮数 = t5.length;

按钮位置 = new int[按钮数][15];

for (int j = 0; j < 按钮数; j++) { 

按钮位置[j][0] = 0;

按钮位置[j][1] = 0;

按钮位置[j][2] = 0;

按钮位置[j][3] = 0;

按钮位置[j][4] = 0;

}

int 按钮行数, 按钮宽度;

按钮宽度 = (int) (字符宽度 * 6.3);

if ((实际按钮数 * 按钮宽度) % (窗口宽 - 50) == 0)

按钮行数 = (int) (实际按钮数 * 按钮宽度) % (窗口宽 - 50);

else

按钮行数 = (int) (实际按钮数 * 按钮宽度) / (窗口宽 - 50) + 1;

起始左边距 = 20;

if (大数据个数 == 0)

起始到顶距 = 起始到顶距 + 字符高度 * 2;

else

起始到顶距 = 起始到顶距 + 字符高度;

int 一行按钮数 = (窗口宽 - 30) / (int) (6.6 * 字符宽度);

if (一行按钮数 < 1)

一行按钮数 = 1; // 每行最少一个按钮

if (实际按钮数 <= 一行按钮数)

按钮宽度 = (窗口宽 - 60) / 实际按钮数;

else

按钮宽度 = (窗口宽 - 60) / 一行按钮数;

int n = 0, n1 = 0, n2 = 0, n3 = 0; // n：当行按钮数，n1：已排按钮数,n2：按钮行数,n3:一行按钮宽

n3 = 一行按钮数 * 按钮宽度;

for (int j = 0; j < 按钮数; j++) { 

if (("," + 要求按钮号表 + ",").lastIndexOf("," + j + ",") >= 0) {

按钮位置[j][0] = 起始左边距; // 起始左边距

按钮位置[j][1] = 起始到顶距; // 起始到顶距

if (按钮集[j].length() > 4) {

按钮位置[j][2] = (int) (按钮集[j].length() * (字符宽度 * 1.2));

n3 = n3 + 按钮位置[j][2] - 按钮宽度;

起始左边距 = 起始左边距 + 按钮位置[j][2];

} else {

按钮位置[j][2] = 按钮宽度; // 按钮宽度

起始左边距 = 起始左边距 + 按钮宽度;

}

按钮位置[j][3] = 字符高度; // 按钮高度

按钮位置[j][4] = j; // 按钮序号

n++;

n1++;

if (实际按钮数 - n1 == 0)

break;

if ((n >= 一行按钮数) && ((实际按钮数 - n1) - 一行按钮数 != 0)) { // 如果按钮换行

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

if ((实际按钮数 - n1) <= 一行按钮数)

按钮宽度 = (窗口宽 - 60) / (实际按钮数 - n1);

else

按钮宽度 = (窗口宽 - 60) / 一行按钮数;

n = 0;

n2++; // 按钮行数

} else if (n >= 一行按钮数) { 

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

n = 0;

n2++;

}

}

}

}

static void 数据表查询结构001(String 数据表名001) {

String 要求字段名表 = "";

if (组合框5.getSelectedItem().toString().length() <= 0) {

JOptionPane.showMessageDialog(null, "请先选择数据表。");

return;

}

数据表名001 = 组合框5.getSelectedItem().toString();

if (fa3.getText().length() > 0) {

String[] sj = fa3.getText().split(",");

String[] sj1 = 列名表.split(",");

for (int i = 0; i < sj.length; i++)

if (i == 0)

要求字段名表 = sj1[Integer.parseInt(sj[i])];

else

要求字段名表 = 要求字段名表 + "," + sj1[Integer.parseInt(sj[i])];

}

String s1 = "";

int 需求面积 = 0;

字段名字串 = "";

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

if (要求字段名表.length() <= 0)

s1 = "select * from " + 数据表名001;

else

s1 = "select " + 要求字段名表 + "  from " + 数据表名001;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数];

列数据类型 = new String[列数];

列数据宽度 = new int[列数];

标签位置 = new String[列数][8];

位置参数表 = new String[列数][15];

大数据个数 = 0;

控件个数 = 0;

for (int i = 0; i < 列数; i++) {

列名[i] = rsmdt4.getColumnName(i + 1);

if (字段名字串.length() < 1)

字段名字串 = 列名[i];

else

字段名字串 = 字段名字串 + "," + 列名[i];

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

控件个数++;

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

if (("ntext,text,memo,image,long,lob,").lastIndexOf(列数据类型[i]) < 0)

需求面积 = 需求面积 + 列名[i].length() * 20 * 30 + 列数据宽度[i] * 20 * 30;

else

需求面积 = 需求面积 + 列名[i].length() * 20 * 30 + 400 * 40; // 大数据面积

if (标签位置[i][3] == null)

标签位置[i][3] = "";

if (标签位置[i][4] == null)

标签位置[i][4] = "";

if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名[i] + "表,") >= 0) && (列名[i]

.indexOf("代码") >= 0))) {

标签位置[i][3] = 列名[i] + "表";

标签位置[i][4] = "组合框";

列数据宽度[i] = 列数据宽度[i] + 10;

} else if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名[i] + "代码表,") >= 0) && (列名[i]

.indexOf("代码") < 0))) {

标签位置[i][3] = 列名[i] + "代码表";

标签位置[i][4] = "组合框";

列数据宽度[i] = 列数据宽度[i] + 10;

}

位置参数表[i][0] = 列名[i];

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() == 0))

for (int j = 0; j < 字典数据.length; j++) {

if (列名[i].equals(字典数据[j][0]))

位置参数表[i][1] = 字典数据[j][1]; // 完成字典名（标签）改变

else if (列名[i].equals(字典数据[j][1]))

位置参数表[i][1] = 字典数据[j][0]; // 完成字典名（标签）改变

}

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() == 0))

位置参数表[i][1] = 列名[i];

if (标签位置[i][4].length() < 1)

if (main1.文本数据类型.indexOf("," + 列数据类型[i] + ",") >= 0) {

标签位置[i][4] = "文本字段";

大数据个数++;

} else if (main1.图形数据类型.indexOf(","+列数据类型[i]+",")>=0) {

标签位置[i][4] = "图像字段";

大数据个数++;

} else

标签位置[i][4] = "普通字段";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

需求面积 = 需求面积 + 100 * 30 * 14; // 留下按钮面积

窗口高 = (int) Math.sqrt((需求面积 * 2 * 3 / 4));

窗口宽 = 窗口高 * 4 / 3;// 黄金分割点

while ((窗口高 > 650) && (窗口宽 < 1000)) {

窗口高 = (int) (窗口高 * 0.9);

窗口宽 = (int) (窗口宽 / 0.9);

}

}

   }

83.源码83，部件程序，自定义表单。界面可以包括全局性列表框、单指某字段列表框、组合框、文本域、文本框、图形框、按钮、水平直线、竖直直线等各种控件，任意布置位置与大小。可以规定每个文本框、按钮、文本域的字体、字号、颜色。具有数据录入、修改、删除、图形输入、指定图形输入、指定记录播放语音、连续播放语音、批修改、查询等功能。具有变换标签、提供代码录入方便功能，具有安全性、数据实体完整性、域完整性控制功能。

/**

 * 程序文件名：dataTenance9.java

 * 作者：程学先 

 * 功能：自定义表单。界面可以包括全局性列表框、单指某字段列表框、组合框、文本域、文本框、

 * 图形框、按钮、水平直线、竖直直线等各种控件，任意布置位置与大小。

 * 可以规定每个文本框、按钮、文本域的字体、字号、颜色。

 * 具有数据录入、修改、删除、图形输入、指定图形输入、指定记录播放语音、

 * 连续播放语音、批修改、查询等功能。

 * 具有变换标签、提供代码录入方便功能，具有安全性、数据实体完整性、域完整性控制功能。

 * 完成日期：2014年1月20日

 * 被调用语句：dataTenance9.means(parameter);

 * 要求提供的参数：“窗口宽”、“窗口高” 等如果不在调用时给定，由主程序带入。

 * 数据“表名”、“关键字段名”、 “要求按钮号表”等由菜单设置的字符串数组变量parameter带入。

 * 操作方法与注意事项：以上所有参数均为字符串数据类型的全局变量。

 * 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，可以是单一字段，

 * 也可以是多个字段，如果是多字段，以英文逗号分隔。

 * 本部件预设的按钮控件"第一条", "下一条", "末一条", "上一条", "浏览", "存盘",

"查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", 

"连续播放", "退出"共 15 个。

 * 通过“要求按钮号表”提供所需要显示的按钮在该部件原设计的界面 中的顺序号，各按钮号用逗号分隔。 

 * 每录入一条记录后必须点击“存盘”按钮。

 * 如果存在image字段，在点击“存盘”按钮或“修改存盘”按钮后，将提问图片文件名，之后将文件名找到并填入。

 * 如果有多个图形字段，将逐一提问逐一录入。

 * 也可以在确定记录后先点击某个图形区域，再点击“存入图形”按钮，将只录入该一个图形。

 * 如果先未点击图形区域，就点击“存入图形”按钮，将逐一提问逐一录入所有图形。

 * 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。

 * 每删除一条记录，必须点击“删除”按钮。

 * 接口参数表由controPosition表单设计器生成，每一行31项：依次为：

 *  0     1      2     3  4   5   6  7  8  9

 * 序号，图形代码，图形名称，a1,b1,标签名,a2,b2,a3,b3,

 *   10     11      12     13      14     15       16  

 * 字段名1,更换列名1,字段类型1,代码表名1,关键字1,标签左边距1,标签到顶距1,   

 *    17     18      19       20       21      22   23  24

 * 标签宽度1,标签高度1,字段左边距1,字段到顶距1,字段宽度1,高度1,字体1,字号1   

 *   25    26    27    28     29      30

 * ,颜色1,最大值1,最小值1,值域1,条件表达式1,只作显示1));

 * 为兼容性，也允许采用completeTool.java等三程序定义的接口参数表，

 * 但建议不使用这样的接口参数表。

 */

import java.awt.Color;

import java.awt.Component;

import java.awt.Font;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.io.InputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashSet;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.text.JTextComponent;

import javax.swing.JFileChooser;

import javax.sound.sampled.AudioFormat;

import javax.sound.sampled.AudioInputStream;

import javax.sound.sampled.AudioSystem;

import javax.sound.sampled.DataLine;

import javax.sound.sampled.LineUnavailableException;

import javax.sound.sampled.SourceDataLine;

import javax.sound.sampled.UnsupportedAudioFileException;

public class dataTenance9 extends JFrame {

static dataTenance9 frame1 = null;

static String ODBC数据源 = main1.ODBC数据源;

static JTextField[] 文本框 = null;

private static Connection cont4; // 连接数据库

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String 表名 = ""; // 数据表名

private static int 窗口宽 = main1.窗口宽;

private static int 窗口高 = main1.窗口高;// 窗口高

private static int 窗口左边距 = 10, 窗口到顶距 = 10;

private static int 列数 = 0, 当前列号 = 0; // 数据表列数

private static String[] 列名 = null; // 数据表列名

private static String 字段名字串 = "", 限只读字段号表 = "";

private static String[] 列数据类型 = null; // 存放当前记录各字段数据类型的数组

private static int[] 列数据宽度 = null; // 存放当前记录各字段数据宽度的数组

private static int 记录条数 = 0;

private static int 记录条数1 = 0, 记录条数2 = 0;

private static int 列号 = 0;

private static String[][] 表格数据 = null;

private static String[] 文本数组值 = null;

static String[][] 备份数据 = null;

private static String 要求按钮号表 = "";

private static int 实际按钮数 = 0;

private static String 要求字段号表 = "";

private static String[] 一条空记录 = null;

private static String[] 关键字段名 = null;// 存放关键字字段名的数组

private static int[] 关键字序号 = null;

private static String s1 = "", s2 = "", s3 = "", s4 = "";

private static int b = 0, c = 0;

private static int[][] 位置参数 = null;

private static int 控件个数 = 0;

private static int 控件个数0 = 0;

private static JLabel[] 图片数组 = null;

private static int 字符宽度 = 15, 字符高度 = 20;

private static String[] 按钮集 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘",

"查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

private static JButton 第一条, 下一条, 末一条, 上一条, 浏览, 存盘, 查询, 清屏, 修改存盘, 批修改, 删除,

录入图形, 播放声音, 连续播放, 退出;

private static ArrayList<String> list = new ArrayList<String>();

private static ArrayList<String> list0 = new ArrayList<String>();

private static String[][] 位置参数表 = null;

private static String[][] 标签位置 = null;

private static String[][] 完整性参数表 = null;

private static String[][] 安全性参数表 = null;

private static String[][] 字典数据 = new String[0][0];

private static int 位置参数条数 = 0, 完整性参数条数 = 0, 安全性参数条数 = 0;

private static int 最大宽度 = 0, 最大高度 = 0;

private static int 锁 = 0, x11 = 0;

public static String username = main1.username;

public static int 字号 = 9, 颜色 = 5;

private static String 字体 = "宋体";

private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;

private static int 起始左边距 = 0;

private static int 起始到顶距 = 0, 起始到顶距0 = 0;

private static int 文本域宽度 = 0, 文本域高度 = 0;

private static int[] 文本数组号 = null;

private static int 行间距离 = 0;

private static int[][] 位置数据001 = null;

private static JPanel panel1 = new JPanel(false); // 定义面板

private static int 需求面积 = 0, 原窗口宽 = 窗口宽, 原窗口高 = 窗口高;

private static int 文本区宽度 = 0, 声音字段号 = 0;

private static int 大数据个数 = 0, ann = 0; // 是否已经定义了按钮位置标志

private static int 列名长度 = 0;

private static JTextArea[] 文本域 = null;

private static JComboBox[] 组合框 = null;

private static JTextComponent[] 文本数组 = null;

private static String[][] 代码表数据 = null;

private static String 表名表 = "", 声音字段名 = "";

private static String 字典表名 = "";

private static int[][] 按钮位置 = null;

private static JButton[] 按钮数组 = new JButton[15];

private static List list1;// 公共列表框

private static List[] 列表框;

public static String MUSIC_FILE = "notify.wav";

public static byte[] v;

public static Xyz xyz;

public static Thread t;

public static int t0 = 0;

public static String[] t5;

public static String[] 临时按钮参数;

public static String sk, 查询条件;

public static int k3, lbk; // lbk=1为有列表框且选择字段为*的标志

static int 按钮数 = 0, 按钮宽 = 0;

private static int 按钮定义标志;

static int 线条数量 = 0;

static int[][] 线条位置 = new int[20][6]; // 最多限20根线条或标签,5为线号,5表示7是线条，8是标签

static String[][] 标签数据 = new String[20][5]; // 最多限20个标签,0为文本,1为图形文件名，2为颜色，3为字体，4为字号

static String[][] 按钮数据 = new String[20][5]; // 最多限20个按钮,0为文本,1为图形文件名，2为颜色，3为字体，4为字号

private static HashSet set01 = new HashSet();

public static String sd0;

static void color1(int c, JLabel fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color2(int c, JTextField fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color3(int c, JTextArea fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color4(int c, JButton fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void means(String parameter[]) {

列数 = 0;

当前列号 = 0;

字段名字串 = "";

记录条数 = 0;

记录条数1 = 0;

列号 = 0;

要求按钮号表 = "";

实际按钮数 = 0;

要求字段号表 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

b = 0;

c = 0;

x11 = 0;

控件个数 = 0;

控件个数0 = 0;

字符宽度 = 18;

字符高度 = 20;

位置参数条数 = 0;

完整性参数条数 = 0;

安全性参数条数 = 0;

最大宽度 = 0;

最大高度 = 0;

锁 = 0;

字号 = 9;

颜色 = 5;

字体 = "宋体";

起始左边距 = 0;

起始到顶距 = 0;

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

文本域宽度 = 0;

文本域高度 = 0;

行间距离 = 0;

需求面积 = 0;

原窗口宽 = 窗口宽;

原窗口高 = 窗口高;

文本区宽度 = 0;

大数据个数 = 0;

列名长度 = 0;

表名表 = "";

字典表名 = "";

ann = 0;

声音字段号 = 0;

声音字段名 = "";

按钮定义标志 = 0;

lbk = 0;

线条数量 = 0;

list = new ArrayList<String>();

list0 = new ArrayList<String>();

ODBC数据源 = main1.ODBC数据源;

sk = "";

k3 = 0;

按钮宽 = 0;

限只读字段号表 = "";

字典数据 = new String[0][0];

username = main1.username;

xyz = new Xyz();

t = new Thread(xyz); // 线程类

panel1 = new JPanel(true);

frame1 = new dataTenance9();

frame1.setTitle("自定义表单程序                           作者：程学先"); 

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null); // 关闭布局管理器

frame1.getContentPane().add(panel1, null); // 安装面板

声音字段名 = "";

list1 = new List();

list = new ArrayList<String>();

大数据类型 = main1.文本数据类型 + main1.图形数据类型;

按钮数组 = new JButton[20];

String[] 按钮集01 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘", "查询", "清屏",

"修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

按钮集 = new String[按钮集01.length];

按钮数 = 0;

for (int i0 = 0; i0 < 按钮集01.length; i0++)

按钮集[i0] = 按钮集01[i0];

if (parameter[11].length() > 0) {

要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号

要求按钮号表 = 要求按钮号表.replaceAll("；", ";");

要求按钮号表 = 要求按钮号表.replaceAll("。", ";");

要求按钮号表 = 要求按钮号表.replaceAll(":", ";");

要求按钮号表 = 要求按钮号表.replaceAll("：", ";");

if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

if (s602[0] != null)

按钮集[Integer.parseInt((s602[0]))] = s602[1];

要求按钮号表 = 要求按钮号表 + "," + s602[0];// 只留号，去更名

} else {

要求按钮号表 = 要求按钮号表 + "," + s601[i01];// 只留号，原无更名

}

}

} else {

String s601[] = 要求按钮号表.split(",");

要求按钮号表 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

要求按钮号表 = s601[i01];

else

要求按钮号表 = 要求按钮号表 + "," + s601[i01];

}

}

} else {

要求按钮号表 = ""; // 没输入要求按钮号，定全部按钮号

for (int i1 = 0; i1 < 按钮集.length; i1++) {

if (i1 == 0)

要求按钮号表 = 要求按钮号表 + i1;

else

要求按钮号表 = 要求按钮号表 + "," + i1;

}

}

要求按钮号表 = "," + 要求按钮号表 + ",";

要求按钮号表 = 要求按钮号表.replaceAll(",,", ",");

按钮数 = 按钮集.length; // 可以供选择的按钮数

按钮位置 = new int[按钮数][15];

int m1 = 0, m2 = 0;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

if (parameter[17] != null)

m1 = Integer.parseInt(parameter[17]);// 宽度参数

if (parameter[18] != null)

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

窗口宽 = m1;

原窗口宽 = m1;

窗口高 = m2;

}

} catch (Exception e2) {

}

panel1.setLayout(null); // 空面板

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

标签数据[i][2] = "宋体";

标签数据[i][3] = "10";

标签数据[i][4] = "5";

按钮数据[i][2] = "宋体";

按钮数据[i][3] = "10";

按钮数据[i][4] = "5";

}

表名表 = "," + parameter[0] + ",";

表名 = parameter[4]; // 数据表名

String[] t1 = parameter[0].split(","); // 表名数组

字段名字串 = parameter[19];

String 接口参数文件名 = parameter[5];

String[] t2 = parameter[19].split(","); // 字段名数组

字典表名 = "";

if (表名表.lastIndexOf(表名 + "字典表") >= 0)

for (int i = 0; i < t1.length; i++)

if (t1[i].lastIndexOf(表名 + "字典表") >= 0) {

字典表名 = t1[i];

数据表查询数据0011(); // 查询字典表

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

关键字段名 = parameter[6].split(",");

要求字段号表 = parameter[8];

限只读字段号表 = "," + parameter[9] + ",";

关键字序号 = new int[关键字段名.length];

String 字段名字串0 = "", 字段名字串1 = "";

if (要求字段号表.length() > 0) {

String[] t3 = 要求字段号表.split(","); // 字段号数组

for (int i = 0; i < t3.length; i++) {

if (t3[i] != null)

if (i > 0)

字段名字串0 = 字段名字串0 + "," + t2[Integer.parseInt(t3[i])];

else

字段名字串0 = t2[Integer.parseInt(t3[i])];

}

字段名字串 = 字段名字串0;

for (int i = 0; i < 关键字段名.length; i++)

if (("," + 字段名字串 + ",").indexOf("," + 关键字段名[i] + ",") < 0)

字段名字串 = 字段名字串 + "," + 关键字段名[i];

}

t2 = 字段名字串.split(",");

文本数组号 = new int[t2.length];

标签位置 = new String[t2.length][6];

位置参数表 = new String[t2.length][15];

t5 = 要求按钮号表.split(",");

临时按钮参数 = new String[按钮集.length];

if (parameter[5].length() > 1) { // 接口参数表文件

File file1 = new File(parameter[5]);

try {

if (file1.exists()) {

FileReader fr = new FileReader(file1);

BufferedReader br = new BufferedReader(fr);

String tempStr = null;

字段名字串1 = "";

String[] d1;

int d2 = 0;

k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1) // 参数由非表单生成器产生，即由completeTool等三个程序产生

list0.add(tempStr); // 将文件内容全部读到集合中，先统计参数中不同类型数据条数

if (d2 == 0) { // 只要找到一句项数超过15就证明该文件是表单设计器产生

d1 = tempStr.split("。");

if (d1.length > 15)

d2 = 1; // 表示参数表示由可视化程序表单生成器产生的表

}

}

sk = "";

for (int i = 0; i < list0.size(); i++) {

sk = list0.get(i);

if (d2 == 0) { // 参数由非表单生成器产生，即由completeTool等三个程序产生

list.add(sk);

if (sk.substring(0, 2).equals("1,"))

位置参数条数++;

if (sk.substring(0, 2).equals("2,"))

安全性参数条数++;

if (sk.substring(0, 2).equals("3,"))

完整性参数条数++;

} else if (sk.length() > 1) { // 参数由表单生成器产生

d1 = sk.split("。"); // 包括i=0时分解接口参数

if (d1[1].equals("2") || d1[1].equals("4")

|| d1[1].equals("5")) {

list.add(sk); // 只统计非按钮（6）、线条（7）的数据

if ((d1[1].equals("5")) && (d1[10].equals("*"))) {

lbk = 1; // 有公共列表框

if ((d1[19] != null) && (d1[20] != null)

&& (d1[21] != null)

&& (d1[22] != null))

list1.setBounds(

Integer.parseInt(d1[19]),

Integer.parseInt(d1[20]),

Integer.parseInt(d1[21]),

Integer.parseInt(d1[22]));

panel1.add(list1);

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

String s4 = "";

String[] s5;

for (int i = 0; i < 文本数组.length; i++)

文本数组[b].setText(list1

.getSelectedItem());

}

});

} else

位置参数条数++; 

if ((d1[26].length() > 0)

|| (d1[27].length() > 0) // 最大、最小值

|| (d1[28].length() > 0)

|| (d1[29].length() > 0)) // 值域、条件式

完整性参数条数++;

if (d1[30].length() > 0) // 只读

安全性参数条数++;

} else if (d1[1].equals("6")) { // 按钮

String[] nl = sk.split("。");

int xl = 0;

if (nl[13] != null)

xl = Integer.parseInt(nl[13]);

临时按钮参数[k3] = sk; // 保存按钮参数数据

k3++;

按钮集[xl] = nl[11]; // 改换按钮标签

按钮位置[xl][0] = Integer.parseInt(nl[15]);

按钮位置[xl][1] = Integer.parseInt(nl[16]);

按钮位置[xl][2] = Integer.parseInt(nl[17]);

按钮位置[xl][3] = Integer.parseInt(nl[18]);

按钮数据[xl][0] = nl[10];

按钮数据[xl][1] = nl[11];

按钮数据[xl][2] = nl[23];

按钮数据[xl][3] = nl[24];

按钮数据[xl][4] = nl[25];

} else if (d1[1].equals("7")) { // 线条

String[] nl = sk.split("。");

线条位置[线条数量][0] = Integer.parseInt(nl[15]);

线条位置[线条数量][1] = Integer.parseInt(nl[16]);

线条位置[线条数量][2] = Integer.parseInt(nl[19]);

线条位置[线条数量][3] = Integer.parseInt(nl[20]);

线条位置[线条数量][4] = Integer.parseInt(nl[24]);

线条位置[线条数量][5] = 7;

线条数量++;

} else if (d1[1].equals("8")) { // 线条

String[] nl = sk.split("。");

线条位置[线条数量][0] = Integer.parseInt(nl[15]);

线条位置[线条数量][1] = Integer.parseInt(nl[16]);

线条位置[线条数量][2] = Integer.parseInt(nl[17]);

线条位置[线条数量][3] = Integer.parseInt(nl[18]);

线条位置[线条数量][4] = Integer.parseInt(nl[24]);

线条位置[线条数量][5] = 8;

标签数据[线条数量][0] = nl[10];

标签数据[线条数量][1] = nl[11];

标签数据[线条数量][2] = nl[23];

标签数据[线条数量][3] = nl[24];

标签数据[线条数量][4] = nl[25];

线条数量++;

}

}

}

实际按钮数 = k3;

if (k3 > 0) {

按钮定义标志 = 1;

} // 以上完成对参数表数据分类统计条数

if (位置参数条数 > 0) {

if (lbk == 1) {

标签位置 = new String[位置参数条数 + 1][6];// 0、1字段左边距到顶距，2字段类型

位置参数表 = new String[位置参数条数 + 1][13];

} else {

标签位置 = new String[位置参数条数][6];// 0、1字段左边距到顶距，2字段类型

位置参数表 = new String[位置参数条数][13];

}

} else { // 位置参数条数==0

位置参数表 = new String[t2.length][13];

标签位置 = new String[t2.length][6];// 0、1字段左边距到顶距，2字段类型

}

安全性参数表 = new String[安全性参数条数][4];

完整性参数表 = new String[完整性参数条数][6];

int m3 = 0;

m1 = 0;

m2 = 0;

int y = 2, n1 = 0;

String s = "";

s2 = "";

最大宽度 = 0; // 如果没有接口参数或接口参数中无位置数据，要自动布局

最大高度 = 0;

int 最大宽度1 = 0;

窗口宽 = 0;

for (int i = 0; i < list.size(); i++) {

s = list.get(i); // 再取出接口参数

if (d2 == 0) { // 如果是从completeTool等三个程序产生的参数

if (s.substring(0, 2).equals("1,")) {

位置参数表[m1] = s.substring(2, s.length()).split(

"。");

位置参数表[m1][1] = "";

位置参数表[m1][2] = 位置参数表[m1][5];

标签位置[m1][0] = Integer.parseInt(位置参数表[m1][3])

+ Integer.parseInt(位置参数表[m1][6]) + "";// 字段左边距

标签位置[m1][1] = 位置参数表[m1][7]; // 字段到顶距

if (Integer.parseInt(位置参数表[m1][5])

+ Integer.parseInt(标签位置[m1][1]) > 起始到顶距)

起始到顶距 = Integer.parseInt(位置参数表[m1][5])

+ Integer.parseInt(标签位置[m1][1]);

if (Integer.parseInt(位置参数表[m1][4])

+ Integer.parseInt(位置参数表[m1][6]) + 80 > 窗口宽)

窗口宽 = Integer.parseInt(位置参数表[m1][4])

+ Integer.parseInt(位置参数表[m1][6])

+ 80;

标签位置[m1][2] = ""; // 图形代码

标签位置[m1][3] = ""; // 代码表名

标签位置[m1][4] = ""; // 字段类型（普通字段、文本、图形）

s2 = s2 + 位置参数表[m1][0] + ","; // 字段名表

m1++;

位置参数条数 = m1; // 重定义位置参数条数

} else if (s.substring(0, 2).equals("2,")) {

y = 2;

n1 = 0;

int n0 = 0;

String[] sf = s.split("。");

安全性参数表[m2][0] = sf[0]; // 标志号2+用户名

安全性参数表[m2][1] = sf[1]; // 表名或字段名

安全性参数表[m2][2] = sf[2]; // 权限

sf = 安全性参数表[m2][0].split(",");

安全性参数表[m2][0] = sf[1]; // 用户名

if ((安全性参数表[m2][0].equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0)

&& // 权限内容不空,无a

((安全性参数表[m2][1].length() == 0)

|| (安全性参数表[m2][1].equals("*")) || (安全性参数表[m2][1]

.toLowerCase().equals(表名

.toLowerCase())))) { // 字段名为空、为星号、为表名表示是全表单权限，决定按钮显示否

if (安全性参数表[m2][2].indexOf("i") < 0) { // 不包含i录入权

要求按钮号表 = 要求按钮号表.replaceAll("5,", ""); // 删除5,

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("u") < 0) { // 不包含u修改权

要求按钮号表 = 要求按钮号表.replaceAll("7,", ""); // 删除7,

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("d") < 0) { // 不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("8,", ""); // 删除8,

n0 = 1;

}

n0 = 1;

} else if ((安全性参数表[m2][0]

.equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0) && // 权限内容不空,无a

(安全性参数表[m2][2].indexOf("d") < 0)) { // 如果任何一个字段不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("8,", ""); // 删除8,去掉删除按钮

n0 = 1;

} else if ((安全性参数表[m2][0]

.equalsIgnoreCase(username))

&& (安全性参数表[m2][2].length() > 0)

&& (安全性参数表[m2][2].indexOf("a") < 0)

&& // 权限内容不空,无a

(安全性参数表[m2][2].indexOf("i") < 0)

&& (安全性参数表[m2][2].indexOf("u") < 0)) { // 如果任何一个字段不包含iu权

安全性参数表[m2][0] = "只读"; // 原用户名改为“只读”

安全性参数表[m2][2] = "q,";

}

if (n0 == 0) {

m2++; // 未处理的安全参数条数，在后处理中部再核对用户名

安全性参数条数 = m2; // 重定义安全性参数条数

}

} else if (s.substring(0, 2).equals("3,")) {

y = 2;

n1 = 0;

for (int k = 2; k < s.length(); k++)

if (s.substring(k, k + 1).equals("。")) {

完整性参数表[m3][n1] = s.substring(y, k);

y = k + 1;

n1++;

}

完整性参数表[m3][n1] = s.substring(y, s.length());

if (完整性参数表[m3][3].isEmpty())

完整性参数表[m3][3] = "";

m3++;

完整性参数条数 = m3; // 重定义完整性参数条数

}

} else { // 参数来自表单设计器

d1 = s.split("。");

if (d1[13] == null)

d1[13] = "";

标签位置[m1][0] = d1[19]; // 字段左边距

标签位置[m1][1] = d1[20]; // 字段到顶距

if (Integer.parseInt(d1[20])

+ Integer.parseInt(d1[22]) > 起始到顶距)

起始到顶距 = Integer.parseInt(d1[20])

+ Integer.parseInt(d1[22]);

if (Integer.parseInt(d1[19])

+ Integer.parseInt(d1[21]) + 80 > 窗口宽)

窗口宽 = Integer.parseInt(d1[19])

+ Integer.parseInt(d1[21]) + 80;

标签位置[m1][2] = d1[1]; // 图形代码

标签位置[m1][3] = d1[13]; // 代码表名

标签位置[m1][4] = d1[12]; // 字段类型（普通字段、文本、图形）

位置参数表[m1][0] = d1[10]; // 字段名

位置参数表[m1][1] = d1[11]; // 更换字段名

位置参数表[m1][2] = d1[18]; // 标签高度

位置参数表[m1][3] = d1[17]; // 标签宽度

位置参数表[m1][4] = d1[21]; // 字段宽度

位置参数表[m1][5] = d1[22]; // 字段高度

位置参数表[m1][6] = d1[15]; // 标签左边距

位置参数表[m1][7] = d1[16]; // 标签到顶距

位置参数表[m1][8] = d1[23]; // 字体

位置参数表[m1][9] = d1[24]; // 字号

位置参数表[m1][10] = d1[25]; // 颜色

位置参数表[m1][11] = d1[0]; // 序号

s2 = s2 + 位置参数表[m1][0] + ","; // 字段名表

if (!d1[11].equals("*"))

m1++;

位置参数条数 = m1; // 重定义位置参数条数

if ((d1[26].length() > 0)

|| (d1[27].length() > 0) // 最大、最小值

|| (d1[28].length() > 0)

|| (d1[29].length() > 0)) { // 值域、条件式

完整性参数表[m3][0] = d1[10]; // 字段名

完整性参数表[m3][1] = d1[26]; // 最大值

完整性参数表[m3][2] = d1[27]; // 最小值

完整性参数表[m3][3] = d1[28]; // 值域

完整性参数表[m3][4] = d1[29]; // 条件表达式

m3++;

完整性参数条数 = m3; // 重定义完整性参数条数

}

if (d1[30].trim().equals("只读")) { // 是否只读

安全性参数表[m2][1] = d1[10]; // 字段名

安全性参数表[m2][0] = "只读"; // 只读

安全性参数表[m2][2] = "q,"; // 只读标志

m2++;

安全性参数条数 = m2; // 重定义安全参数条数

}

}

位置数据001 = new int[位置参数表.length][10];

文本数组号 = new int[位置参数表.length];

文本数组值 = new String[位置参数表.length];

}

if (位置参数条数 > 0) {

字段名字串 = "";

for (int i = 0; i < 位置参数条数; i++) {

if (i == 0)

字段名字串 = 位置参数表[i][0];

else

字段名字串 = 字段名字串 + "," + 位置参数表[i][0];

}

}

}

} catch (IOException e2) {

JOptionPane.showMessageDialog(null, "打开文件错！");

}

} else { // 无接口参数表文件，根据选定的字段情况处理

位置参数表 = new String[t2.length][13];

标签位置 = new String[t2.length][6];// 0、1字段左边距到顶距，2字段类型

安全性参数表 = new String[0][4];

完整性参数表 = new String[0][6];

位置数据001 = new int[t2.length][10];

文本数组号 = new int[t2.length];

文本数组值 = new String[t2.length];

}

for (int i = 0; i < 安全性参数条数; i++) {

t2 = 字段名字串.split(",");

for (int j = 0; j < t2.length; j++) {

if (安全性参数表[i][1] == null)

continue;

if (安全性参数表[i][1].toLowerCase().indexOf(t2[j].toLowerCase()) >= 0) { // 字段名相同

if (安全性参数表[i][0].equals("只读"))

限只读字段号表 = 限只读字段号表 + j + ",";

安全性参数表[i][1] = j + ""; // 原为字段名改为字段号

}

}

}

if (窗口宽 < 原窗口宽)

窗口宽 = 原窗口宽;

数据表查询结构001(表名); // 得到数据表结构，产生全部字段名、数据类型、宽度

数据表查询数据001(表名, ""); // 求当前表中所有数据

if (位置参数条数 == 0)

计算文本框001();

计算文本框002(); // 是否已经定义了按钮位置

安装文本框002();

t2 = 字段名字串.split(",");

for (int i = 0; i < t2.length; i++)

if (t2[i].equals("声音文件名")) {

声音字段名 = t2[i];

声音字段号 = i;

}

String sd = "";

for (int i0 = 0; i0 < 记录条数; i0++) {

sd = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++) {

if (文本数组号[i] == 关键字序号[j]) {

sd = sd + 表格数据[i0][文本数组号[i]].trim() + ",";

break;

}

}

}

set01.add(sd);

}

第一条 = new JButton(按钮集[0]);

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

记录条数1 = 0;

记录条数2 = 记录条数1;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0))

if (!标签位置[i][4].equals("列表框")) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型[文本数组号[i]] + ",")) >= 0)

if ((文本数组[i].getText() == null)

|| (文本数组[i].getText().trim()

.length() < 1))

文本数组[i].setText("0");

} else {

列表框[i].select(记录条数1);

}

}

}

下一条.setEnabled(true);

上一条.setEnabled(false);

t.stop();

t = new Thread(xyz); // 线程类

}

});

if (按钮位置[0][0] > 0) {

第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);

Font font = new Font(按钮数据[0][2], Font.BOLD,

Integer.parseInt(按钮数据[0][3])); // 设置字体与文字大小

String s01 = 按钮数据[0][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

第一条.setFont(font);

color4(s02, 第一条);// 设置颜色

panel1.add(第一条);

}

下一条 = new JButton(按钮集[1]);

下一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 < 记录条数 - 1) {

记录条数1++;

记录条数2 = 记录条数1;

if (记录条数1 == 记录条数 - 1)

下一条.setEnabled(false);

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0))

if (!标签位置[i][4].equals("列表框")) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型[文本数组号[i]] + ",")) >= 0)

if ((文本数组[i].getText() == null)

|| (文本数组[i].getText().trim()

.length() < 1))

文本数组[i].setText("0");

} else {

列表框[i].select(记录条数1);

}

}

}

}

上一条.setEnabled(true);

t.stop();

t = new Thread(xyz); // 线程类

}

});

if (按钮位置[1][0] > 0) {

下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);

Font font = new Font(按钮数据[1][2], Font.BOLD,

Integer.parseInt(按钮数据[1][3])); // 设置字体与文字大小

String s01 = 按钮数据[1][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

下一条.setFont(font);

color4(s02, 下一条);// 设置颜色

panel1.add(下一条);

}

末一条 = new JButton(按钮集[2]);

末一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数 > 1)

记录条数1 = 记录条数 - 1; // 记录指针

else

记录条数1 = 0;

记录条数2 = 记录条数1; // 记录指针

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0))

if (!标签位置[i][4].equals("列表框")) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型[文本数组号[i]] + ",")) >= 0)

if ((文本数组[i].getText() == null)

|| (文本数组[i].getText().trim()

.length() < 1))

文本数组[i].setText("0");

} else {

列表框[i].select(记录条数1);

}

}

}

上一条.setEnabled(true);

下一条.setEnabled(false);

t.stop();

t = new Thread(xyz); // 线程类

}

});

if (按钮位置[2][0] > 0) {

末一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);

Font font = new Font(按钮数据[2][2], Font.BOLD,

Integer.parseInt(按钮数据[2][3])); // 设置字体与文字大小

String s01 = 按钮数据[2][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

末一条.setFont(font);

color4(s02, 末一条);// 设置颜色

panel1.add(末一条);

}

上一条 = new JButton(按钮集[3]);

上一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 > 0) {

记录条数1--;

记录条数2 = 记录条数1; // 记录指针

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0))

if (!标签位置[i][4].equals("列表框")) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf(","

+ 列数据类型[文本数组号[i]] + ",")) >= 0)

if ((文本数组[i].getText() == null)

|| (文本数组[i].getText().trim()

.length() < 1))

文本数组[i].setText("0");

} else {

列表框[i].select(记录条数1);

}

}

}

下一条.setEnabled(true);

} else

上一条.setEnabled(false);

t.stop();

t = new Thread(xyz); // 线程类

}

});

if (按钮位置[3][0] > 0) {

上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);

Font font = new Font(按钮数据[3][2], Font.BOLD,

Integer.parseInt(按钮数据[3][3])); // 设置字体与文字大小

String s01 = 按钮数据[3][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

上一条.setFont(font);

color4(s02, 上一条);// 设置颜色

panel1.add(上一条);

上一条.setEnabled(false);

}

浏览 = new JButton(按钮集[4]);

浏览.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (浏览.getText().trim().equals("浏览")) {

浏览.setText("转当前行");

备份数据 = new String[记录条数][列数];

int[] n = new int[列数据宽度.length];

for (int i = 0; i < 记录条数; i++)

for (int j = 0; j < 列数; j++) {

备份数据[i][j] = 表格数据[i][j];

if (备份数据[i][j] == null)

备份数据[i][j] = "";

if (备份数据[i][j].length() > 50)

备份数据[i][j] = 备份数据[i][j].substring(0, 50);

}

for (int j = 0; j < 列数; j++) {

n[j] = 列数据宽度[j];

if (n[j] > 50)

n[j] = 50;

}

tableTenance.tableModel(窗口宽, 窗口高, 列名, n, 备份数据, 列数据类型);

} else {

浏览.setText("浏览");

记录条数1 = main1.当前行行号; // 记录指针

for (int i = 0; i < 控件个数; i++) {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0))

文本数组[i].setText(表格数据[main1.当前行行号][文本数组号[i]]);

}

}

}

});

if (按钮位置[4][0] > 0) {

浏览.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);

Font font = new Font(按钮数据[4][2], Font.BOLD,

Integer.parseInt(按钮数据[4][3])); // 设置字体与文字大小

String s01 = 按钮数据[4][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

浏览.setFont(font);

color4(s02, 浏览);// 设置颜色

panel1.add(浏览);

}

存盘 = new JButton(按钮集[5]);

存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[控件个数];

String s = "";

String[] s0 = new String[控件个数];

int b = 0;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0) {

if (标签位置[i][4].equals("组合框")) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

s = (String) 组合框[当前列号].getSelectedItem();

文本数组值[i] = s;

if (文本数组值[i] == null)

文本数组值[i] = " ";

} else {

文本数组值[i] = 文本数组[i].getText().trim();

if (文本数组值[i] == null) {

文本数组值[i] = " ";

文本数组[i].setText(一条空记录[i]);

}

}

} else {

文本数组值[i] = "?";

}

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++) {

if (文本数组号[i] == 关键字序号[j]) {

if ((文本数组值[i] == null)

|| (文本数组值[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值[i].trim() + ",";

break;

}

}

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

set01.add(sd);

if (set01.size() == kd) {

JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");

return;

}

set01.remove(sd); // 本句是准备生成SQL语句，在执行成功后再加到set中

sd0 = sd;

c = 0;

int a1 = 0;

for (int i = 0; i < 控件个数; i++)

if ((完整性参数条数 > 0) && (!完整性检查(c, i))) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

cont4 = main1.getConn();

try {

记录条数++;

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "insert into " + 表名 + "(";

for (int j = 0; j < 控件个数; j++) {

a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("i") < 0))

a1 = 1;

}

if (a1 == 0)

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[j]]

+ ",") < 0)

s1 = s1 + 列名[文本数组号[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 文本数组.length; i++)

if (文本数组号[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[j]

+ ",") >= 0) {

if (文本数组值[i].length() < 1)

文本数组值[i] = "0";

s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];

} else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

d1: for (int j = 0; j < 控件个数; j++) {

int a2 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("i") < 0)) {

a2 = 1;

continue d1;

}

}

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[文本数组号[j]]

+ ",") >= 0) {

s1 = s1 + 文本数组值[j] + ",";

} else if (文本数组值[j].trim().equals("?")) {

s0[b] = "update " + 表名 + " set " + 列名[文本数组号[j]]

+ " = ?" + " where " + s2;

x0[b] = j;

b++;

} else {

s1 = s1 + "'" + 文本数组值[j].trim() + "',";

}

}

s1 = s1.substring(0, s1.length() - 1) + ")";

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

记录条数++;

set01.add(sd0); // 添加新记录成功后将关键字加入set

for (int j = 0; j < 文本数组.length; j++) {

表格数据[记录条数][j] = "";

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

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

图片存盘(s0[i], x0[i]);

for (int i = 0; i < 控件个数; i++)

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0))

文本数组[i].setText(一条空记录[i]);

}

});

if (按钮位置[5][0] > 0) {

存盘.setBounds(按钮位置[5][0], 按钮位置[5][1], 按钮位置[5][2], 按钮位置[5][3]);

Font font = new Font(按钮数据[5][2], Font.BOLD,

Integer.parseInt(按钮数据[5][3])); // 设置字体与文字大小

String s01 = 按钮数据[5][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

存盘.setFont(font);

color4(s02, 存盘);// 设置颜色

panel1.add(存盘);

}

查询 = new JButton(按钮集[6]);

查询.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (查询.getText().trim().equals("查询")) {

查询.setText("还原");

第一条.setEnabled(true);

下一条.setEnabled(true);

上一条.setEnabled(true);

末一条.setEnabled(true);

批修改.setEnabled(true);

数据表查询数据001(表名, " where " + 查询条件); // 求当前表中所有数据

第一条0();

} else {

查询.setText("查询");

记录条数1 = 0;

第一条.setEnabled(true);

下一条.setEnabled(true);

上一条.setEnabled(true);

末一条.setEnabled(true);

数据表查询数据001(表名, ""); // 求当前表中所有数据

第一条0();

批修改.setEnabled(false);

}

}

});

if (按钮位置[6][0] > 0) {

查询.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);

Font font = new Font(按钮数据[6][2], Font.BOLD,

Integer.parseInt(按钮数据[6][3])); // 设置字体与文字大小

String s01 = 按钮数据[6][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

查询.setFont(font);

color4(s02, 查询);// 设置颜色

panel1.add(查询);

}

清屏 = new JButton(按钮集[7]);

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < 控件个数; i++) {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0))

文本数组[i].setText(一条空记录[i]);

}

}

});

if (按钮位置[7][0] > 0) {

清屏.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);

Font font = new Font(按钮数据[7][2], Font.BOLD,

Integer.parseInt(按钮数据[7][3])); // 设置字体与文字大小

String s01 = 按钮数据[7][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

清屏.setFont(font);

color4(s02, 清屏);// 设置颜色

panel1.add(清屏);

}

修改存盘 = new JButton(按钮集[8]);

修改存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

for (int i = 0; i < 控件个数; i++)

if ((完整性参数条数 > 0) && (!完整性检查(c, i))) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String[] s0 = new String[控件个数];

int b = 0;

int[] x0 = new int[控件个数];

for (int i = 0; i < 文本数组.length; i++)

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0) {

if (标签位置[i][4].equals("组合框")) {

当前列号 = i;

if (标签位置[i][4].equals("组合框")) {

文本数组值[i] = (String) 组合框[当前列号].getSelectedItem();

}

if (文本数组值[i] == null)

文本数组值[i] = " ";

} else {

文本数组值[i] = 文本数组[i].getText().trim();

if (文本数组值[i] == null) {

文本数组值[i] = " ";

文本数组[i].setText(一条空记录[i]);

}

}

} else {

文本数组值[i] = "?";

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号[i] == 关键字序号[j]) {

if ((文本数组值[i] == null)

|| (文本数组值[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请改为生成数据录入语句！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 文本数组.length; i++)

if (文本数组号[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {

if (文本数组值[i].length() < 1)

文本数组值[i] = "0";

s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];

} else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "update " + 表名 + " set ";

d2: for (int j = 0; j < 文本数组.length; j++) {

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j

+ ",") >= 0)

&& (安全性参数表[i][2].indexOf("u") < 0))

continue d2;

}

if (!文本数组值[j].trim().equals("?")) {

s1 = s1 + 列名[文本数组号[j]] + "=";

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[文本数组号[j]]

+ ",") >= 0)

s1 = s1 + 文本数组值[j];

else

s1 = s1 + "'" + 文本数组值[j].trim() + "'";

s1 = s1 + ",";

} else {

s0[b] = "update " + 表名 + " set " + 列名[文本数组号[j]]

+ "=? where " + s2;

x0[b] = j;

b++;

}

}

s1 = s1.substring(0, s1.length() - 1) + " where " + s2;

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

for (int k = 0; k < 文本数组.length; k++) {

表格数据[记录条数1][文本数组号[k]] = 文本数组值[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

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

图片存盘(s0[i], x0[i]);

}

});

if (按钮位置[8][0] > 0) {

修改存盘.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);

Font font = new Font(按钮数据[8][2], Font.BOLD,

Integer.parseInt(按钮数据[8][3])); // 设置字体与文字大小

String s01 = 按钮数据[8][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

修改存盘.setFont(font);

color4(s02, 修改存盘);// 设置颜色

panel1.add(修改存盘);

}

批修改 = new JButton(按钮集[9]);

批修改.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

}

});

if (按钮位置[9][0] > 0) {

批修改.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[8][3]);

Font font = new Font(按钮数据[9][2], Font.BOLD,

Integer.parseInt(按钮数据[9][3])); // 设置字体与文字大小

String s01 = 按钮数据[9][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

批修改.setFont(font);

color4(s02, 批修改);// 设置颜色

panel1.add(批修改);

批修改.setEnabled(false);

}

删除 = new JButton(按钮集[10]);

删除.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0)

文本数组值[i] = 文本数组[i].getText().trim();

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号[i] == 关键字序号[j]) {

if ((文本数组值[i] == null)

|| (文本数组值[i].trim().length() == 0))

kd0 = 1;

sd = sd + 文本数组值[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

set01.add(sd);

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请修改后重新生成！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 控件个数; i++)

if (文本数组号[i] == 关键字序号[j]) {

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[j] + ",") >= 0)

s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];

else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn(); // 连接数据库

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + 表名 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

set01.remove(sd0);

deleteData(记录条数1);

for (int i = 0; i < 控件个数; i++) {

if (记录条数1 == 记录条数 - 1)

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") < 0)

文本数组[i].setText(一条空记录[i]);

else if (main1.图形数据类型.lastIndexOf(","

+ 列数据类型[文本数组号[i]] + ",") < 0) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if (按钮位置[10][0] > 0) {

删除.setBounds(按钮位置[10][0], 按钮位置[10][1], 按钮位置[10][2], 按钮位置[10][3]);

Font font = new Font(按钮数据[10][2], Font.BOLD,

Integer.parseInt(按钮数据[10][3])); // 设置字体与文字大小

String s01 = 按钮数据[10][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

删除.setFont(font);

color4(s02, 删除);// 设置颜色

panel1.add(删除);

}

录入图形 = new JButton(按钮集[11]);

录入图形.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String s;

s2 = "";

for (int j = 0; j < 关键字段名.length; j++) {

for (int i = 0; i < 文本数组.length; i++)

if (文本数组号[i] == 关键字序号[j]) {

文本数组值[i] = 文本数组[i].getText().trim();

if (main1.数字数据类型.lastIndexOf("," + 列数据类型[j] + ",") >= 0) {

if (文本数组值[i].length() < 1)

文本数组值[i] = "0";

s2 = s2 + 关键字段名[j] + "=" + 文本数组值[i];

} else

s2 = s2 + 关键字段名[j] + "='" + 文本数组值[i].trim()

+ "'";

break;

}

if (j < 关键字段名.length - 1)

s2 = s2 + " and ";

}

if (控件个数0 > 0) {

s1 = "update " + 表名 + " set " + 列名[控件个数0] + "=? where "

+ s2;

图片存盘(s1, 控件个数0);

} else

for (int i = 0; i < 文本数组.length; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]]

+ ",") >= 0) {

文本数组值[i] = "?";

s1 = "update " + 表名 + " set " + 列名[文本数组号[i]]

+ "=? where " + s2;

图片存盘(s1, i);

}

}

}

});

if (按钮位置[11][0] > 0) {

录入图形.setBounds(按钮位置[11][0], 按钮位置[11][1], 按钮位置[11][2], 按钮位置[11][3]);

Font font = new Font(按钮数据[11][2], Font.BOLD,

Integer.parseInt(按钮数据[11][3])); // 设置字体与文字大小

String s01 = 按钮数据[11][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

录入图形.setFont(font);

color4(s02, 录入图形);// 设置颜色

panel1.add(录入图形);

}

播放声音 = new JButton(按钮集[12]);

播放声音.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

t0 = 0;

if (声音字段名.length() > 0)

t.start();

}

});

if (按钮位置[12][0] > 0) {

播放声音.setBounds(按钮位置[12][0], 按钮位置[12][1], 按钮位置[12][2], 按钮位置[12][3]);

Font font = new Font(按钮数据[12][2], Font.BOLD,

Integer.parseInt(按钮数据[12][3])); // 设置字体与文字大小

String s01 = 按钮数据[12][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

播放声音.setFont(font);

color4(s02, 播放声音);// 设置颜色

panel1.add(播放声音);

}

连续播放 = new JButton(按钮集[13]);

连续播放.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

t0 = 1;

if (声音字段名.length() > 0) {

t = new Thread(xyz); // 线程类

t.start();

}

}

});

if (按钮位置[13][0] > 0) {

连续播放.setBounds(按钮位置[13][0], 按钮位置[13][1], 按钮位置[13][2], 按钮位置[13][3]);

Font font = new Font(按钮数据[13][2], Font.BOLD,

Integer.parseInt(按钮数据[13][3])); // 设置字体与文字大小

String s01 = 按钮数据[13][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

连续播放.setFont(font);

color4(s02, 连续播放);// 设置颜色

panel1.add(连续播放);

}

退出 = new JButton(按钮集[14]);

按钮数组[9] = 退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if (按钮位置[14][0] > 0) {

退出.setBounds(按钮位置[14][0], 按钮位置[14][1], 按钮位置[14][2], 按钮位置[14][3]);

Font font = new Font(按钮数据[14][2], Font.BOLD,

Integer.parseInt(按钮数据[14][3])); // 设置字体与文字大小

String s01 = 按钮数据[14][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

退出.setFont(font);

color4(s02, 退出);// 设置颜色

panel1.add(退出);

}

if (窗口高 - 起始到顶距 - 行间距离 - 100 < 0)

窗口高 = 起始到顶距 + 行间距离 + 100;

panel1.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 20);

int w1, h1;

if (1200 - 窗口宽 > 0)

w1 = (1200 - 窗口宽) / 2;

else

w1 = 0;

if (600 - 窗口高 > 0)

h1 = (600 - 窗口高) / 2;

else

h1 = 0;

if (窗口高 < 起始到顶距 + 20)

窗口高 = 起始到顶距 + 20;

frame1.setBounds(w1, h1, 窗口宽, 窗口高); // 主程序窗口位置大小

frame1.setVisible(true); // 安装窗口

}

static void 计算文本框001() { // 如果没有接口参数表，计算控件位置、大小参数

if (位置参数条数 > 0)

return;

int 行间距离 = 0;

int 本行当前宽度 = 0;

int 起始左边距 = 10;

位置参数 = new int[列数][2];

位置参数条数 = 列数;

int 文本控件行数 = 1;

文本区宽度 = 窗口宽 - 80;

起始到顶距 = 20;

int y1 = 起始左边距;

int y2 = 起始到顶距;

int 最大标签宽度 = 0;

if ((大数据个数 == 0) && (列数 * 字符高度 < 窗口高 - 120)) {

文本控件行数 = 列数;

行间距离 = (窗口高 - 150 - 列数 * 字符高度) / (列数 + 1);

for (int j = 0; j < 列数; j++)

if (位置参数表[j][1].length() > 最大标签宽度)

最大标签宽度 = 位置参数表[j][1].length();

for (int j = 0; j < 列数; j++) {

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = (文本区宽度 - Integer.parseInt(标签位置[j][0])) + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y2 = y2 + 字符高度 + 行间距离;

起始到顶距 = y2;

}

} else // 字段比较多，或者有大数据

{

int 当前列列号 = 1;

y1 = 起始左边距; // 当前位置

y2 = 起始到顶距;

int 当前行行号 = 1;

for (int j = 0; j < 列数; j++) { // 先处理非大数据

列名长度 = 位置参数表[j][1].length(); // 翻译后字段名宽度

if (大数据类型.lastIndexOf("," + 列数据类型[j] + ",") < 0) {

if ((y1 + (列名长度 + 列数据宽度[j]) * 字符宽度) > 文本区宽度) { // 如果放不下，换行

当前行行号++;

当前列列号 = 1;

y1 = 起始左边距;

y2 = y2 + 字符高度;

}

位置参数表[j][6] = y1 + ""; // 标签左边

位置参数表[j][7] = y2 + ""; // 标签到顶

位置参数表[j][3] = 列名长度 * 字符宽度 + ""; // 标签宽度

if ((y1 == 起始左边距) && (列名长度 > 最大标签宽度))

最大标签宽度 = 列名长度;

位置参数表[j][2] = 字符高度 + ""; // 标签高度

标签位置[j][0] = (y1 + 列名长度 * 字符宽度) + ""; // 字段左边

标签位置[j][1] = y2 + ""; // 字段到顶

位置参数表[j][4] = 列数据宽度[j] * 字符宽度 + ""; // 字段宽度

位置参数表[j][5] = 字符高度 + ""; // 字段高度

位置参数表[j][8] = "宋体";

位置参数表[j][9] = "10"; // 字号

位置参数表[j][10] = "5"; // 颜色

标签位置[j][2] = "2"; // 图形代号

y1 = y1 + 列名长度 * 字符宽度 + 列数据宽度[j] * 字符宽度;

当前列列号++;

} // 以下换行

} // 非大数据处理完成

if (大数据个数 == 0)

行间距离 = (窗口高 - 150) / (当前行行号 + 1) - 字符高度;

else

行间距离 = 0;

if (行间距离 < 0)

行间距离 = 0;

int z = 0; // 每行左移数值

int z1 = 0; // 每行下移数值

int z3 = 0; // 最后一个非大数据字段号

for (int j = 0; j < 列数; j++) { // 先处理非大数据位置调整

if (大数据类型.lastIndexOf("," + 列数据类型[j] + ",") < 0) {

if (Integer.parseInt(位置参数表[j][6]) == 起始左边距) { // 每行第一列

z = 最大标签宽度 * 字符宽度 - Integer.parseInt(位置参数表[j][3]); // 修正标签宽度

z1 = z1 + 行间距离;

if (j > 0)

位置参数表[z3][4] = (文本区宽度 - Integer

.parseInt(标签位置[z3][0])) + "";

}

位置参数表[j][6] = (Integer.parseInt(位置参数表[j][6]) + z) + ""; // 标签左边

标签位置[j][0] = (Integer.parseInt(标签位置[j][0]) + z) + ""; // 字段左边

位置参数表[j][7] = (Integer.parseInt(位置参数表[j][7]) + z1) + ""; // 标签到顶

标签位置[j][1] = (Integer.parseInt(标签位置[j][1]) + z1) + ""; // 字段到顶

y2 = Integer.parseInt(标签位置[j][1]);

z3 = j;

}

}

位置参数表[z3][4] = (文本区宽度 - Integer.parseInt(标签位置[z3][0])) + "";

起始到顶距 = y2;

if (大数据个数 > 0) {

y2 = y2 + 字符高度; // 剩下空间高度

int z2 = (窗口高 - y2 - 120) / 大数据个数; // 大数据高度

for (int i3 = 0; i3 < 列数; i3++) { // 处理大数据位置

if (大数据类型.lastIndexOf("," + 列数据类型[i3] + ",") >= 0) {

位置参数表[i3][6] = 起始左边距 + ""; // 标签左边

位置参数表[i3][7] = y2 + ""; // 标签到顶

位置参数表[i3][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度

位置参数表[i3][2] = 字符高度 + ""; // 标签高度

标签位置[i3][0] = (起始左边距 + 最大标签宽度 * 字符宽度) + ""; // 字段左边

标签位置[i3][1] = y2 + ""; // 字段到顶

y2 = y2 + z2;

位置参数表[i3][4] = (文本区宽度 - 最大标签宽度 * 字符宽度) + ""; // 字段宽度

位置参数表[i3][5] = z2 + ""; // 字段高度

位置参数表[i3][8] = "宋体";

位置参数表[i3][9] = "10"; // 字号

位置参数表[i3][10] = "5"; // 颜色

标签位置[i3][2] = "2"; // 图形代号

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[i3] + ",") >= 0)

标签位置[i3][4] = "图像字段"; // 字段类型

else

标签位置[i3][4] = "文本字段"; // 字段类型

当前列列号++;

}

}

起始到顶距 = y2 + 字符高度;

}

}

起始到顶距 = y2 + 字符高度;

}

static void 计算文本框002() { // 如果没有接口参数表，计算控件位置、大小参数

if (按钮定义标志 > 0)

return; // 如果在参数表中定义了按钮位置，则不做本项工作

String[] t5 = 要求按钮号表.split(",");

实际按钮数 = t5.length - 1;

按钮位置 = new int[按钮数][15];

for (int j = 0; j < 按钮数; j++) {

按钮位置[j][0] = 0;

按钮位置[j][1] = 0;

按钮位置[j][2] = 0;

按钮位置[j][3] = 0;

}

int 按钮行数, 按钮宽度;

按钮宽度 = (int) (字符宽度 * 6.3);

if ((实际按钮数 * 按钮宽度) % (窗口宽 - 50) == 0)

按钮行数 = (int) (实际按钮数 * 按钮宽度) % (窗口宽 - 50);

else

按钮行数 = (int) (实际按钮数 * 按钮宽度) / (窗口宽 - 50) + 1;

起始左边距 = 20;

if (大数据个数 == 0)

起始到顶距 = 起始到顶距 + 字符高度 * 2;

else

起始到顶距 = 起始到顶距 + 字符高度;

int 一行按钮数 = (窗口宽 - 30) / (int) (6.6 * 字符宽度);

if (一行按钮数 < 1)

一行按钮数 = 1; // 每行最少一个按钮

if (实际按钮数 <= 一行按钮数)

按钮宽度 = (窗口宽 - 60) / 实际按钮数;

else

按钮宽度 = (窗口宽 - 60) / 一行按钮数;

int n = 0, n1 = 0, n2 = 0, n3 = 0; // n：当行按钮数，n1：已排按钮数,n2：按钮行数,n3:一行按钮宽

n3 = 一行按钮数 * 按钮宽度;

for (int j = 0; j < 按钮数; j++) {

if (要求按钮号表.lastIndexOf("," + j + ",") >= 0) {

按钮位置[j][0] = 起始左边距;

按钮位置[j][1] = 起始到顶距;

if (按钮集[j].length() > 4) {

按钮位置[j][2] = (int) (按钮集[j].length() * (字符宽度 * 1.2));

n3 = n3 + 按钮位置[j][2] - 按钮宽度;

起始左边距 = 起始左边距 + 按钮位置[j][2];

} else {

按钮位置[j][2] = 按钮宽度;

起始左边距 = 起始左边距 + 按钮宽度;

}

按钮位置[j][3] = 字符高度;

n++;

n1++;

if (实际按钮数 - n1 == 0)

break;

if ((n >= 一行按钮数) && ((实际按钮数 - n1) - 一行按钮数 != 0)) { // 如果按钮换行

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

if ((实际按钮数 - n1) <= 一行按钮数)

按钮宽度 = (窗口宽 - 60) / (实际按钮数 - n1);

else

按钮宽度 = (窗口宽 - 60) / 一行按钮数;

n = 0;

n2++;

} else if (n >= 一行按钮数) {

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

n = 0;

n2++;

}

}

}

窗口高 = 起始到顶距 + 字符高度 + 100;

}

static void 数据表查询结构001(String 数据表名001) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

字段名字串 = 字段名字串.replaceAll(",\\*", "");

String s1 = "select " + 字段名字串 + " from " + 数据表名001;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数];

列数据类型 = new String[列数];

列数据宽度 = new int[列数];

一条空记录 = new String[列数];

大数据个数 = 0;

for (int i = 0; i < 列数; i++) {

列名[i] = rsmdt4.getColumnName(i + 1);

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

if (标签位置[i][3] == null)

标签位置[i][3] = "";

if (标签位置[i][4] == null)

标签位置[i][4] = "";

if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名[i] + "表,") >= 0) && (列名[i]

.indexOf("代码") >= 0))) {

标签位置[i][3] = 列名[i] + "表";

标签位置[i][4] = "组合框";

列数据宽度[i] = 列数据宽度[i] + 10;

} else if ((标签位置[i][3].length() < 1)

&& ((表名表.lastIndexOf("," + 列名[i] + "代码表,") >= 0) && (列名[i]

.indexOf("代码") < 0))) {

标签位置[i][3] = 列名[i] + "代码表";

标签位置[i][4] = "组合框";

列数据宽度[i] = 列数据宽度[i] + 10;

}

位置参数表[i][0] = 列名[i];

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() != 0))

for (int j = 0; j < 字典数据.length; j++) {

if (列名[i].toLowerCase().equalsIgnoreCase(

字典数据[j][0].toLowerCase()))

位置参数表[i][1] = 字典数据[j][1]; // 完成字典名（标签）改变

else if (列名[i].toLowerCase().equalsIgnoreCase(

字典数据[j][1].toLowerCase()))

位置参数表[i][1] = 字典数据[j][0]; // 完成字典名（标签）改变

}

if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() == 0))

位置参数表[i][1] = 列名[i];

if (标签位置[i][4].length() < 1)

if ((",text,ntext,i,d,t").indexOf("," + 列数据类型[i] + ",") >= 0) {

标签位置[i][4] = "文本字段";

大数据个数++;

} else if (列数据类型[i].equalsIgnoreCase("image")) {

标签位置[i][4] = "图像字段";

大数据个数++;

} else

标签位置[i][4] = "普通字段";

if (列数据类型[i].indexOf("datetime") == 0)

一条空记录[i] = "2001-01-01 00:00:00.000";

else if (列数据类型[i].indexOf("smalldatetime") == 0)

一条空记录[i] = "2001-01-01 00:00:00";

else if (列数据类型[i].indexOf("datetime2") == 0)

一条空记录[i] = "2001-01-01 00:00:00.0000000";

else if (列数据类型[i].indexOf("datetimeoffset") == 0)

一条空记录[i] = "2001-01-01 00:00:00.0000000 +08:00";

else if (列数据类型[i].indexOf("date") == 0)

一条空记录[i] = "2001-01-01";

else if (列数据类型[i].indexOf("time") == 0)

一条空记录[i] = "00:00:00";

else if (列数据类型[i].indexOf("money") >= 0)

一条空记录[i] = "0.0000";

else if (main1.小数型数据类型.lastIndexOf("," + 列数据类型[i] + ",") >= 0)

一条空记录[i] = "0.00";

else if (main1.数字数据类型.lastIndexOf("," + 列数据类型[i] + ",") >= 0)

一条空记录[i] = "0";

else

一条空记录[i] = "";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库结构出错！");

}

for (int i1 = 0; i1 < 列名.length; i1++)

for (int j1 = 0; j1 < 关键字段名.length; j1++) {

if (列名[i1].toLowerCase().trim()

.equals(关键字段名[j1].toLowerCase().trim()))

关键字序号[j1] = i1;

}

}

static void 数据表查询数据001(String 数据表名001, String 条件) { // 查数据表数据

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串 + "  from " + 数据表名001 + 条件;

rs = stat4.executeQuery(s1);

rs.last();

记录条数 = rs.getRow();

String[][] 表格数据0 = new String[记录条数][列数];

表格数据 = new String[记录条数 + 300][列数];

rsmdt4 = rs.getMetaData();

int c = 0;

int b = 0;

while (c < 记录条数) {

rs.absolute(c + 1);

while (b < 列数) {

表格数据0[c][b] = rs.getString(b + 1);

表格数据[c][b] = 表格数据0[c][b];

b++;

}

c++;

b = 0;

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

for (int i = 0; i < 记录条数; i++)

for (int j = 0; j < 列数; j++)

表格数据[i][j] = 表格数据0[i][j];

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

}

static void 数据表查询数据0011() { // 查询字典表

try {

if (字典表名.length() > 0) {

cont4 = main1.getConn();// 连接数据库

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + 字典表名;

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

rs.last();

int 记录条数5 = rs.getRow();

字典数据 = new String[记录条数5][2];

rs.absolute(1);

int numberOfColumns = rsmd.getColumnCount();

String s4 = "";

String s5 = "";

for (int i = 1; i <= 记录条数5; i++) {

rs.absolute(i);

s4 = rs.getString(1).trim();

字典数据[i - 1][0] = s4;

s5 = rs.getString(2).trim();

字典数据[i - 1][1] = s5;

}

rs.close(); // 关闭查询结果集

stat4.close();

cont4.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！");

}

}

static void 数据表查询数据0012(String 代码表名0, String 列名9, int j9) { // 查代码表数据

try {

int u = 0;

if (列名9.indexOf("代码") >= 0) {

s2 = 列名9.substring(0, 列名9.length() - 2);

s1 = "select " + 列名9 + "," + s2 + " from " + 代码表名0;

} else if (表名表.lastIndexOf("," + 列名9 + "代码表,") >= 0) {

s2 = 列名9.substring(0, 列名9.length() - 2);

s1 = "select " + 列名9 + "," + 列名9 + "代码" + " from " + 列名9

+ "代码表";

}

cont4 = main1.getConn();// 连接数据库

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

rs.last();

int numberOfColumns = rs.getRow();

rs.beforeFirst();

代码表数据[j9] = new String[numberOfColumns];

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

代码表数据[j9][i - 1] = rs.getString(1).trim();

}

rs.close();

stat4.close(); // 关闭连接

cont4.close();

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "2读取代码表数据出错！" + s1);

}

}

static void 安装文本框002() {

文本框 = new JTextField[位置参数条数];

文本域 = new JTextArea[位置参数条数];

图片数组 = new JLabel[位置参数条数];

组合框 = new JComboBox[位置参数条数];

列表框 = new List[位置参数条数];

文本数组 = new JTextComponent[位置参数条数];

文本数组号 = new int[位置参数条数];

代码表数据 = new String[位置参数条数][2];

控件个数 = 位置参数条数;

for (int j = 0; j < 线条数量; j++) {

int z1 = 0, z2 = 0;

if (线条位置[j][5] == 7) {

if (线条位置[j][0] == 线条位置[j][2]) { // 竖线

if (线条位置[j][3] > 线条位置[j][1]) {

z1 = 线条位置[j][1];

z2 = 线条位置[j][3];

} else {

z1 = 线条位置[j][3];

z2 = 线条位置[j][1];

}

for (int i1 = z1; i1 < z2; i1++) {

JLabel 标签01 = new JLabel("┃", 11);

标签01.setBounds(线条位置[j][0] - 13, i1 - 7, 20, 20);

panel1.add(标签01);

i1 = i1 + 10;

}

}

if (线条位置[j][1] == 线条位置[j][3]) { // 水平线

if (线条位置[j][2] > 线条位置[j][0]) {

z1 = 线条位置[j][0];

z2 = 线条位置[j][2];

} else {

z1 = 线条位置[j][2];

z2 = 线条位置[j][0];

}

for (int i1 = z1; i1 < z2; i1++) {

JLabel 标签00 = new JLabel("━", 11);

标签00.setBounds(i1 - 10, 线条位置[j][1] - 11, 20, 20);

panel1.add(标签00);

i1 = i1 + 10;

}

}

} else {

if (标签数据[j][0].length() > 0) { // 标签文本

JLabel 标签02 = new JLabel(标签数据[j][0]);

标签02.setBounds(线条位置[j][0], 线条位置[j][1], 线条位置[j][2],

线条位置[j][3]);

Font font = new Font(标签数据[j][2], Font.BOLD, 线条位置[j][4]); // 设置字体与文字大小

String s01 = 标签数据[j][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0)

&& (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.trim().substring(0, 1));

标签02.setFont(font);

color1(s02, 标签02);// 设置颜色

panel1.add(标签02);

} else {

JLabel l = new JLabel(new ImageIcon(标签数据[j][1]));

l.setBounds(线条位置[j][0], 线条位置[j][1], 线条位置[j][2], 线条位置[j][3]);

panel1.add(l);

}

}

}

for (int j = 0; j < 控件个数; j++) {

JLabel 标签 = new JLabel(位置参数表[j][1], 11);

标签.setBounds(Integer.parseInt(位置参数表[j][6]),

Integer.parseInt(位置参数表[j][7]),

Integer.parseInt(位置参数表[j][3]),

Integer.parseInt(位置参数表[j][2]));

panel1.add(标签);

if ((标签位置[j][4].equals("普通字段")) || (标签位置[j][4].equals("语音文件名"))) {

if (标签位置[j][4].equals("语音文件名")) {

声音字段名 = 位置参数表[j][0];

声音字段号 = j;

}

文本框[j] = new JTextField("");

文本框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

Font font1 = new Font(位置参数表[j][8], Font.BOLD,

Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小

String s011 = 位置参数表[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011.trim().substring(0, 1));

文本框[j].setFont(font1);

color2(s021, 文本框[j]);// 设置颜色

if (限只读字段号表.indexOf("," + j + ",") >= 0) {

文本框[j].setEditable(false);

}

panel1.add((Component) 文本框[j]);

文本框[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {

c = 0;

}

});

文本框[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {// 获得焦点

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

for (int i = 0; i < 控件个数; i++) {

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

int n1 = 0;

if (lbk == 1) {

list1.removeAll();

if ((表名表.lastIndexOf("," + 位置参数表[b][0] + "表,") >= 0)

|| (表名表.lastIndexOf("," + 位置参数表[b][0]

+ "代码表,") >= 0)) {

for (int i1 = 0; i1 < 代码表数据[b].length; i1++)

list1.add(代码表数据[b][i1]);

} else if (表名表.lastIndexOf("," + 位置参数表[b][0]

+ "代码表,") < 0) {

int u1 = 0;

for (int j = 0; j < 记录条数; j++) {

int u2 = 0;

for (int k = 0; k < u1; k++) {

if (表格数据[j][b] != null) {

} else

表格数据[j][b] = " ";

if (表格数据[j][b]

.toLowerCase()

.trim()

.equalsIgnoreCase(

list1.getItem(k)

.toLowerCase()

.trim())) {

u2++;

break;

}

}

if (u2 == 0) {

list1.add(表格数据[j][b]);

u1++;

}

}

}

}

}

public void focusLost(final FocusEvent arg1) {// 失去焦点

if (c > 0)

return;

if (main1.数字数据类型.indexOf("," + 列数据类型[文本数组号[b]] + ",") >= 0) {

查询条件 = 位置参数表[b][0] + "=" + 文本框[b].getText();

} else if (main1.图形数据类型.indexOf("," + 列数据类型[文本数组号[b]]

+ ",") < 0) {

查询条件 = 位置参数表[b][0] + "='" + 文本框[b].getText() + "'";

}

Object s0 = arg1.getSource();

String s1 = s0.toString().substring(10, 33);

String s2 = "";

for (int i = 0; i < 控件个数; i++) {

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

if ((c == 0) && (完整性参数条数 > 0) && (!完整性检查(c, b))) {

文本框[c].requestFocus(true); // 返回原来文本框

return;

}

}

});

文本框[j].setText(一条空记录[j]);

文本数组[j] = (JTextComponent) 文本框[j];

文本数组号[j] = j;

} else if (标签位置[j][4].equals("文本字段")) {

文本域[j] = new JTextArea("   ", Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

JScrollPane 文本域滚动条 = new JScrollPane(文本域[j]);

文本域滚动条.setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

panel1.add((Component) 文本域滚动条);

文本域[j].setText(一条空记录[j]);

文本数组[j] = (JTextComponent) 文本域[j];

文本数组号[j] = j;

} else if (标签位置[j][4].equals("图像字段")) {

JLabel 图片框 = new JLabel("   ");

图片框.setBackground(Color.BLUE);

图片框.setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

panel1.add(new JScrollPane(图片框));

panel1.add(图片框);

图片数组[j] = 图片框;

文本数组[j] = (JTextComponent) 文本域[j];

文本数组号[j] = j;

图片数组[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {// 鼠标按下事件

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

for (int i = 0; i < 控件个数; i++) {

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

控件个数0 = b;

}

});

} else if (标签位置[j][4].equals("组合框")) {

组合框[j] = new JComboBox();

文本框[j] = new JTextField();

组合框[j].setEditable(true);// 确定 JComboBox 字段是否可编辑

组合框[j].setEnabled(true); // 启用组合框以便可以选择项

panel1.add((Component) 组合框[j]);

组合框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

数据表查询数据0012(标签位置[j][3], 位置参数表[j][0], j);

for (int i = 0; i < 代码表数据[j].length; i++) {

组合框[j].addItem(代码表数据[j][i]);

}

文本数组[j] = (JTextComponent) 组合框[j].getEditor()

.getEditorComponent(); // 控件个数

文本数组[j].setText(""); // 控件个数

文本数组号[j] = j;

} else if (标签位置[j][4].equals("列表框")) {

列表框[j] = new List();

文本框[j] = new JTextField();

列表框[j].setFocusable(true);// 确定 LIst 字段是否可编辑

列表框[j].setEnabled(true); // 启用列表框以便可以选择项

panel1.add((List) 列表框[j]);

列表框[j].setBounds(Integer.parseInt(标签位置[j][0]),

Integer.parseInt(标签位置[j][1]),

Integer.parseInt(位置参数表[j][4]),

Integer.parseInt(位置参数表[j][5]));

数据表查询数据0012(标签位置[j][3], 位置参数表[j][0], j); // 查代码表

for (int i = 0; i < 代码表数据[j].length; i++) {

列表框[j].add(代码表数据[j][i]);

}

文本数组号[j] = j;

}

}

}

public static void m(int p) throws LineUnavailableException,

UnsupportedAudioFileException, IOException {

int x = 0;

AudioInputStream audioInputStream = AudioSystem

.getAudioInputStream(new File(MUSIC_FILE)); // 获取音频输入流

AudioFormat audioFormat = audioInputStream.getFormat();// 获取音频编码对象

DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class,

audioFormat, AudioSystem.NOT_SPECIFIED);// 设置数据输入

SourceDataLine sourceDataLine = (SourceDataLine) AudioSystem

.getLine(dataLineInfo);

sourceDataLine.open();

sourceDataLine.start();

int count;

byte tempBuffer[] = new byte[1024];

x = 0;

while (x <= p / 2) {

tempBuffer = new byte[1024];

count = 0;

for (int i1 = 0; i1 < 1024; i1++) {

if (x < p / 2) {

tempBuffer[i1] = v[x];

x++;

count++;

}

}

if (count > 0)

sourceDataLine.write(tempBuffer, 0, count);

count = 0;

}

sourceDataLine.drain();

sourceDataLine.close();

sourceDataLine.stop();

}

public static void deleteData(int pos) {

if (pos == 记录条数 - 1)

记录条数1--;

for (int i = pos; i < 记录条数 - 1; i++) {

for (int j = 0; j < 控件个数 - 1; j++) {

表格数据[i][j] = 表格数据[i + 1][j];

}

}

记录条数--;

}

public static void 第一条0() {

记录条数1 = 0;

记录条数2 = 记录条数1;

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(s3.substring(j + 1, j + 2),

16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0))

if (!标签位置[i][4].equals("列表框"))

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

else {

列表框[i].select(记录条数1);

}

}

}

下一条.setEnabled(true);

上一条.setEnabled(false);

t.stop();

t = new Thread(xyz); // 线程类

}

public static void 下一条0() {

if (记录条数1 < 记录条数 - 1) {

记录条数1++;

记录条数2 = 记录条数1;

if (记录条数1 == 记录条数 - 1)

下一条.setEnabled(false);

for (int i = 0; i < 控件个数; i++) {

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(s3.substring(j, j + 1),

16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0))

if (!标签位置[i][4].equals("列表框"))

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

else {

列表框[i].select(记录条数1);

}

}

}

}

上一条.setEnabled(true);

}

public static class Xyz implements Runnable { // 定义类实现Runnable接口

public void run() {

String sss = 表格数据[记录条数2][文本数组号[声音字段号]];

int mn = 记录条数2 + 1;

if (t0 == 1)

mn = 记录条数 - 1;

while (记录条数2 < mn) {

sss = 表格数据[记录条数2][文本数组号[声音字段号]];

try {

if ((sss != null) && (sss.length() > 0)) {

File file1 = new File(sss); // 建立接口参数表文件对象

if (file1.exists()) { // 如果文件存在

InputStream in = new FileInputStream(sss);

AudioInputStream audioInputStream = AudioSystem

.getAudioInputStream(new File(sss)); // 获取音频输入流

AudioFormat audioFormat = audioInputStream

.getFormat();// 获取音频编码对象

DataLine.Info dataLineInfo = new DataLine.Info(

SourceDataLine.class, audioFormat,

AudioSystem.NOT_SPECIFIED);// 设置数据输入

SourceDataLine sourceDataLine = (SourceDataLine) AudioSystem

.getLine(dataLineInfo);

sourceDataLine.open(audioFormat);

sourceDataLine.start();

int count;

byte tempBuffer[] = new byte[1024];

while ((count = audioInputStream.read(tempBuffer,

0, tempBuffer.length)) != -1) {

if (count > 0) {

sourceDataLine.write(tempBuffer, 0, count);

x11++;

}

}

sourceDataLine.drain();

sourceDataLine.close();

}

}

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e1) {

e1.printStackTrace();

} catch (LineUnavailableException e1) {

e1.printStackTrace();

} catch (UnsupportedAudioFileException e1) {

e1.printStackTrace();

}

if (t0 == 0) {

t.stop();

记录条数2 = 10000;

}

下一条0();

}

}

}

public static void 图片存盘(String s0, int k) {

for (int i = 0; i < 文本数组.length; i++)

cont4 = main1.getConn();

try {

PreparedStatement pst4 = cont4.prepareStatement(s0);

char x1 = 10, x2 = 13;

int k2 = 1;

String s5 = "";

final JFileChooser fc = new JFileChooser(".\\");

fc.showDialog(new JLabel(), "请选择图片字段" + 列名[文本数组号[k]] + "的文件名");

if (fc.getSelectedFile() != null)

s5 = fc.getSelectedFile().toString();

else {

JOptionPane.showMessageDialog(null, "未选择图片文件，原图不变！");

return;

}

FileInputStream f1 = new FileInputStream(s5); // 指定图片文件名，包括路径

pst4.setBinaryStream(k2, f1, f1.available());

k2++;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

byte[] c0 = new byte[s5.length()];

Icon icon = new ImageIcon(c0);

图片数组[k].setOpaque(true);

图片数组[k].setBackground(Color.PINK);

图片数组[k].setIcon(icon);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

public static boolean 完整性检查(int c1, int b1) {

c = c1;

b = b1;

int bz1 = 0;

String sb = "", bz = "";

String[] sb1 = null;

try {

for (int i1 = 0; i1 < 完整性参数条数; i1++) {

if (完整性参数表[i1][0].toLowerCase().trim()

.equals(位置参数表[b][0].toLowerCase().trim())) { // 当前字段,获得焦点时记录

// b

bz1 = main1.数字数据类型.indexOf("," + 列数据类型[文本数组号[b]] + ",");

if (bz1 >= 0) { // 数字数据类型

if ((完整性参数表[i1][1].trim().length() > 0)

&& (Double.parseDouble(文本框[b].getText()) > Double

.parseDouble(完整性参数表[i1][1]))) {

bz = 文本框[b].getText() + ">最大值"

+ Double.parseDouble(完整性参数表[i1][1]);

c = b;

} else if ((完整性参数表[i1][2].trim().length() > 0)

&& (Double.parseDouble(文本框[b].getText()) < Double

.parseDouble(完整性参数表[i1][2]))) {

bz = 文本框[b].getText() + "<最小值" + 完整性参数表[i1][2];

c = b;

} else if ((完整性参数表[i1][3].trim().length() > 0)) {

if (完整性参数表[i1][3].indexOf("-") > 0) {

sb1 = 完整性参数表[i1][3].split("-");

if ((Double.parseDouble(文本框[b].getText()) < Double

.parseDouble(sb1[0]))) {

bz = 文本框[b].getText() + "<范围下限" + sb1[0];

c = b;

}

if ((Double.parseDouble(文本框[b].getText()) > Double

.parseDouble(sb1[1]))) {

bz = 文本框[b].getText() + ">范围上限" + sb1[1];

c = b;

}

} else if (完整性参数表[i1][3].indexOf("[") >= 0) {

bz = 完整性参数表[i1][3].trim().substring(1,

完整性参数表[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (文本框[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (文本框[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

} else if (完整性参数表[i1][3].indexOf(",") > 0) {

if (("," + 完整性参数表[i1][3] + ",").indexOf(","

+ 文本框[b].getText() + ",") < 0) {

c = b;

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

}

}

} else if (完整性参数表[i1][4].trim().length() > 0) {

int[][] m = new int[2][控件个数];

for (int i = 0; i < 控件个数; i++) { // 按列名长度从大到小排序

m[0][i] = i;

m[1][i] = 位置参数表[i][0].length();

}

int d = 0, e = 0;

for (int i = 0; i < m[1].length; i++)

for (int j = i + 1; j < m[1].length; j++)

if (m[1][i] < m[1][j]) {

e = m[0][i];

m[0][i] = m[0][j];

m[0][j] = e;

e = m[1][i];

m[1][i] = m[1][j];

m[1][j] = e;

}

sb = 完整性参数表[i1][4];

for (int i = 0; i < m[1].length; i++)

sb = sb.replaceAll(位置参数表[m[0][b]][0],

文本框[m[0][b]].getText());

if (!tenanceEval.tenanceeval(sb)) {

bz = 文本框[b].getText() + "不满足条件："

+ 完整性参数表[i1][4];

c = b;

}

} else

c = 0;

} // 数字数据类型可有4种约束条件

else if (main1.文字数据类型.lastIndexOf("," + 列数据类型[文本数组号[b]]

+ ",") >= 0) { // 字符类型

if ((完整性参数表[i1][3].trim().length() > 0)) {

if (完整性参数表[i1][3].indexOf("[") >= 0) {

bz = 完整性参数表[i1][3].trim().substring(1,

完整性参数表[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (文本框[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (文本框[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

c = b;

}

} else if (完整性参数表[i1][3].indexOf(",") > 0) {

if (("," + 完整性参数表[i1][3] + ",").indexOf(","

+ 文本框[b].getText() + ",") < 0) {

c = b;

bz = 文本框[b].getText() + "不满足"

+ 完整性参数表[i1][3] + "范围要求！";

}

}

}

} else

c = 0;

}

if (bz.length() > 0)

break;

}

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求，请修改接口参数表！"

+ e1);

}

if (bz.length() > 0) {

if (c > 0) {

JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查！"

+ bz);

bz = "";

return false;

}

}

return true;

}

}

版本2

82.源码82，公共程序，表单设计器。可视化设置界面。为单记录数据维护部件9等程序布局。界面可以包括全局性列表框、单指某字段列表框、组合框、文本域、文本框、图形框、按钮、水平直线、竖直直线等各种控件，任意布置位置与大小。可以规定每个文本框、按钮、文本域的字体、字号、颜色。

/* 

 * 程序文件名：ControlPosition.java 

 * 作者：程学先 

 * 功能：表单设计器。可视化设置界面。为单记录数据维护部件9等程序布局。 

 * 工具程序，直接用程序名ControlPosition调用。  

 */

import java.awt.*;

import java.awt.event.*;

import java.awt.geom.Line2D;

import java.awt.image.BufferedImage;

import java.io.*;

import java.sql.*;

import java.util.ArrayList;

import javax.imageio.ImageIO;

import javax.swing.*;

import javax.swing.table.DefaultTableModel;

import javax.swing.table.JTableHeader;

import javax.swing.table.TableColumn;

import javax.swing.text.JTextComponent;

class variabl18897 {

int variabl2673;

String variabl1621;

String variabl1773;

int variabl2175;

int variabl1813;

String variabl2003;

int variabl1859;

int variabl1845;

int variabl2593;

int variabl2547;

String variabl23850;

String variabl22110;

String variabl20890;

String variabl22330;

String variabl22530;

int variabl13490;

int variabl36790;

int variabl20270;

int variabl18970;

int variabl13570;

int variabl36890;

int variabl18190;

int variabl26310;

String variabl26290;

int variabl26070;

String variabl26590;

double variabl22810;

double variabl23710;

String variabl26050;

String variabl14130;

String variabl17150;

public variabl18897(int variabl2673, String variabl1621,

String variabl1773, int variabl2175, int variabl1813,

String variabl2003, int variabl1859, int variabl1845,

int variabl2593, int variabl2547, String variabl23850,

String variabl22110, String variabl20890, String variabl22330,

String variabl22530, int variabl13490, int variabl36790,

int variabl20270, int variabl18970, int variabl13570,

int variabl36890, int variabl18190, int variabl26310,

String variabl26290, int variabl26070, String variabl26590,

double variabl22810, double variabl23710, String variabl26050,

String variabl14130, String variabl17150) {

this.variabl2673 = variabl2673;

this.variabl1621 = variabl1621;

this.variabl1773 = variabl1773;

this.variabl2175 = variabl2175;

this.variabl1813 = variabl1813;

this.variabl2003 = variabl2003;

this.variabl1859 = variabl1859;

this.variabl1845 = variabl1845;

this.variabl2593 = variabl2593;

this.variabl2547 = variabl2547;

this.variabl23850 = variabl23850;

this.variabl22110 = variabl22110;

this.variabl20890 = variabl20890;

this.variabl22330 = variabl22330;

this.variabl22530 = variabl22530;

this.variabl13490 = variabl13490;

this.variabl36790 = variabl36790;

this.variabl20270 = variabl20270;

this.variabl18970 = variabl18970;

this.variabl13570 = variabl13570;

this.variabl36890 = variabl36890;

this.variabl18190 = variabl18190;

this.variabl26310 = variabl26310;

this.variabl26290 = variabl26290;

this.variabl26070 = variabl26070;

this.variabl26590 = variabl26590;

this.variabl22810 = variabl22810;

this.variabl23710 = variabl23710;

this.variabl26050 = variabl26050;

this.variabl14130 = variabl14130;

this.variabl17150 = variabl17150;

}

}

public class ControlPosition extends JFrame {

static ControlPosition frame;

static JPanel panel;

static ControlPosition frame1, frame2;

static String[][] variabl21971;

static int variabl1853;

static int variabl21130;

static JScrollPane scrollPane1 = new JScrollPane();

static String[] variabl25172 = { "序号", "图形代码", "图形名称", "标签名", "字段名",

"更换列名", "字段类型", "代码表名", "关键字", "标签左边距", "标签到顶距", "标签宽度", "标签高度",

"字段左边距", "字段到顶距", "字段宽度", "高度", "字体", "字号", "颜色", "最大值", "最小值",

"值域", "条件表达式", "只作显示" };

static int variabl2475[] = new int[25];

static DefaultTableModel variabl1965;

static JTable variabl2655;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static JPanel panel1, panel2;

public static int variabl26730 = 0, variabl26731 = 0, variabl2203 = 0,

variabl2241 = 0, variabl22412 = 0;

public static int variabl3665 = 0, variabl2573 = 0, variabl19891x,

variabl1155, variabl19894x, variabl1121;

private static int variabl1193, variabl19893x, variabl19893y,

variabl19894y, variabl16631, variabl2223 = 0, variabl22230 = 0;

public static String variabl20031, variabl17731, variabl16211,

variabl18291, variabl17591;

private static String[] variabl2539 = { "", "", "文本框", "", "下拉组合框", "列表框",

"按钮", "线条", "图片" };

private static int variabl2483 = 1350, variabl2503 = 700;

static int mouseX1 = 0, mouseY1 = 0;

static int mouseX3 = 0, mouseY3 = 0;

static int mouseX2 = 0, mouseY2 = 0;

static int mouseX4 = 0, mouseY4 = 0;

static int mouseX5 = 0, mouseY5 = 0;

static int mouseX6 = 0, mouseY6 = 0;

static int mouseX7 = 6, mouseY7 = 0;

static int variabl1655 = 0;

static int variabl2139 = 60, variabl1931 = 50;

static char x1 = 10, x2 = 13;

static Graphics g;

static Graphics2D g2 = (Graphics2D) g;

static ArrayList<variabl18897> variabl1955 = new ArrayList<variabl18897>();

static String variabl2207, variabl1747, variabl2015, variabl1115,

variabl2235;

static String variabl1829, variabl1759, variabl2301, variabl2317,

variabl23171;

static JLabel fl0;

private static float[] arr = { 3.0f, 3.0f };

static String variabl2429 = "", variabl2603 = "";

static Connection con;

static String variabl1275 = "sql server";

static String variabl1091 = "sql1";

private static Statement sta3;

private static ResultSetMetaData rsmd3;

private static JComboBox variabl23595 = new JComboBox();

private static JTextField fa1 = new JTextField("");

private static JTextField fa2 = new JTextField("");

private static JTextField fa3 = new JTextField("");

private static JTextField fa4 = new JTextField("");

private static int variabl2651 = 0, variabl2593 = 0, variabl2547 = 0;

private static String[] variabl1501;

private static String[] variabl2517 = null;

private static List list1;

private static String kuangm = "";

private static String[] variabl2835 = { "第一条", "下一条", "末一条", "上一条", "浏览",

"存盘", "查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

private static int[][] variabl1885;

private static int variabl1637 = 0, variabl2851;

private static int variabl1133 = 0;

private static int variabl3681 = 0;

private static int variabl1459 = 0;

private static int[][] variabl1921;

private static int variabl2179;

private static int variabl1315 = 0;

private static String[] variabl1419;

private static int[][] variabl1111;

private static int variabl1319, variabl1313;

private static int variabl1925 = 0;

private static int variabl1473 = 0;

private static int variabl1293 = 0;

private static int variabl2119 = 0, variabl1745 = variabl2483,

variabl1923 = variabl2503;

private static int variabl1843 = 0;

private static int variabl1647 = 15, variabl1849 = 20;

private static int variabl1531 = 10, variabl1477 = 10;

private static int variabl2113;

private static String[] variabl1913;

private static String[] variabl1169, variabl11691;

private static int[] variabl1489;

private static int[] variabl1119;

private static String variabl2309 = "";

static String variabl23851, variabl22111, variabl20891, variabl22331,

variabl22531, variabl26291;

static String variabl26591, variabl26051, variabl14131, variabl17151;

static int variabl13491, variabl36791, variabl20271, variabl18971,

variabl13571, variabl36891, variabl18191, variabl26311,

variabl26071;

static double variabl22811, variabl23711;

private static String variabl1187 = "";

private static int variabl1371 = 0;

private static String[][] variabl1323 = null;

private static String[][] variabl1651 = null;

private static String[] variabl2405;

private static int variabl1233 = 0;

private static String variabl1325 = "";

private static String[][] variabl1837 = new String[0][0];

public static boolean find(int EdgeX, int EdgeY, int l) {

int z = 0, i = 0;

if (l == 1) {

for (i = 0; i < variabl1955.size(); i++) {

variabl16211 = variabl1955.get(i).variabl1621;

int x15 = variabl1955.get(i).variabl13490;

int x16 = variabl1955.get(i).variabl13570

+ variabl1955.get(i).variabl18190;

int x17 = variabl1955.get(i).variabl13490

+ variabl1955.get(i).variabl20270;

int y15 = variabl1955.get(i).variabl36790;

int y16 = variabl1955.get(i).variabl36890

+ variabl1955.get(i).variabl26310;

int y17 = variabl1955.get(i).variabl36790

+ variabl1955.get(i).variabl18970;

boolean b1 = ((x15 + 5 <= EdgeX) && (y15 + 5 <= EdgeY) && ((x16 - 5 >= EdgeX) && (y16 - 5 >= EdgeY)));

boolean b2 = ((x15 + 5 <= EdgeX) && (y15 + 5 <= EdgeY) && ((x17 - 5 >= EdgeX) && (y17 - 5 >= EdgeY)));

double f1 = Math.sqrt((Math.pow(0.000 + y16 - y15, 2) + Math

.pow(x16 - x15, 2)));

double f2 = Math.sqrt((Math.pow(0.000 + EdgeY - y15, 2) + Math

.pow(EdgeX - x15, 2)));

double f3 = Math.sqrt((Math.pow(0.000 + EdgeY - y16, 2) + Math

.pow(EdgeX - x16, 2)));

int n1 = Integer.parseInt(variabl1955.get(i).variabl1621);

if ((variabl16211.equals("7")) && (f1 * 1.005 >= f2 + f3)

&& (f1 * 0.995 <= f2 + f3)) {

z = 1;

variabl26731 = variabl1955.get(i).variabl2673;

variabl17731 = variabl1955.get(i).variabl1773;

variabl13491 = variabl1955.get(i).variabl13490;

variabl36791 = variabl1955.get(i).variabl36790;

variabl13571 = variabl1955.get(i).variabl13570;

variabl36891 = variabl1955.get(i).variabl36890;

variabl2241 = i;

break;

} else if (((b1) && (n1 < 6)) || ((b2) && (n1 == 6))

|| ((b2) && (n1 == 8))) {

z = 1;

variabl19891x = variabl1955.get(i).variabl2175;

variabl1121 = variabl1955.get(i).variabl1813;

variabl1155 = variabl1955.get(i).variabl1859;

variabl1193 = variabl1955.get(i).variabl1845;

variabl19893x = variabl1955.get(i).variabl2593;

variabl19893y = variabl1955.get(i).variabl2547;

variabl20031 = variabl1955.get(i).variabl2003;

variabl26731 = variabl1955.get(i).variabl2673;

variabl16211 = variabl1955.get(i).variabl1621;

variabl17731 = variabl1955.get(i).variabl1773;

variabl23851 = variabl1955.get(i).variabl23850;

variabl22111 = variabl1955.get(i).variabl22110;

variabl20891 = variabl1955.get(i).variabl20890;

variabl22331 = variabl1955.get(i).variabl22330;

variabl22531 = variabl1955.get(i).variabl22530;

variabl26291 = variabl1955.get(i).variabl26290;

variabl26591 = variabl1955.get(i).variabl26590;

variabl26051 = variabl1955.get(i).variabl26050;

variabl14131 = variabl1955.get(i).variabl14130;

variabl17151 = variabl1955.get(i).variabl17150;

variabl13491 = variabl1955.get(i).variabl13490;

variabl36791 = variabl1955.get(i).variabl36790;

variabl20271 = variabl1955.get(i).variabl20270;

variabl18971 = variabl1955.get(i).variabl18970;

variabl13571 = variabl1955.get(i).variabl13570;

variabl36891 = variabl1955.get(i).variabl36890;

variabl18191 = variabl1955.get(i).variabl18190;

variabl26311 = variabl1955.get(i).variabl26310;

variabl26071 = variabl1955.get(i).variabl26070;

variabl22811 = variabl1955.get(i).variabl22810;

variabl23711 = variabl1955.get(i).variabl23710;

variabl2593 = variabl1955.get(i).variabl2593;

variabl2547 = variabl1955.get(i).variabl2547;

variabl2241 = i;

break;

}

}

}

if (z == 1)

return true;

else {

variabl20031 = "";

variabl26731 = -1;

variabl16211 = "";

variabl17731 = "";

variabl23851 = "";

return false;

}

}

public static void variabl1603() {

if (fa2.getText().length() > 0)

variabl19891x = 100;

variabl1121 = 150;

variabl26730 = 0;

try {

FileReader f0;

File f1 = new File(fa2.getText());

if (f1.exists()) {

f0 = new FileReader(fa2.getText());

BufferedReader file = new BufferedReader(f0);

String str = "";

Double z26 = 0.0;

Double z27 = 0.0;

while ((str = file.readLine()) != null) {

String[] o1 = str.split("。");

int x21 = Integer.parseInt(o1[3]);

int y21 = Integer.parseInt(o1[4]);

int x22 = Integer.parseInt(o1[6]);

int y22 = Integer.parseInt(o1[7]);

int x23 = Integer.parseInt(o1[8]);

int y23 = Integer.parseInt(o1[9]);

int z15 = Integer.parseInt(o1[15]);

int z16 = Integer.parseInt(o1[16]);

int z17 = Integer.parseInt(o1[17]);

int z18 = Integer.parseInt(o1[18]);

int z19 = Integer.parseInt(o1[19]);

int z20 = Integer.parseInt(o1[20]);

int z21 = Integer.parseInt(o1[21]);

int z22 = Integer.parseInt(o1[22]);

int z24 = Integer.parseInt(o1[24]);

if ((o1[26] != null) && (o1[26].length() > 0))

z26 = Double.parseDouble(o1[26]);

if ((o1[27] != null) && (o1[27].length() > 0))

z27 = Double.parseDouble(o1[27]);

mouseX2 = x21;

mouseY2 = y21;

variabl16631 = o1[11].length();

variabl1955.add(new variabl18897(variabl26730, o1[1],

o1[2], x21, y21, o1[5], x22, y22, x23, y23, o1[10],

o1[11], o1[12], o1[13], o1[14], z15, z16, z17, z18,

z19, z20, z21, z22, o1[23], z24, o1[25], z26, z27,

o1[28], o1[29], o1[30]));

variabl26730++;

}

file.close();

}

} catch (IOException e1) {

JOptionPane.showMessageDialog(null, "发生异常:" + e1);

}

variabl2203 = 1;

variabl3665 = 10;

frame.repaint();

}

public static void variabl1081() {

int a1 = 0, b1 = 0, a2 = 0, b2 = 0, a3 = 0, b3 = 0, x11 = 0, y11 = 0;

x11 = 50;

y11 = 60;

variabl1955.remove(variabl2241);

variabl3665 = 10;

frame.repaint();

}

public static void variabl24791() {

Graphics2D g2 = (Graphics2D) g;

g2.setStroke(new BasicStroke(1f));

g.setColor(Color.BLACK);

int k1 = variabl1955.size();

for (int i2 = 0; i2 < k1; i2++) {

variabl19891x = variabl1955.get(i2).variabl2175;

variabl1121 = variabl1955.get(i2).variabl1813;

variabl1155 = variabl1955.get(i2).variabl1859;

variabl1193 = variabl1955.get(i2).variabl1845;

variabl19893x = variabl1955.get(i2).variabl2593;

variabl19893y = variabl1955.get(i2).variabl2547;

variabl20031 = variabl1955.get(i2).variabl2003;

variabl26731 = variabl1955.get(i2).variabl2673;

variabl16211 = variabl1955.get(i2).variabl1621;

variabl17731 = variabl1955.get(i2).variabl1773;

variabl23851 = variabl1955.get(i2).variabl23850;

variabl22111 = variabl1955.get(i2).variabl22110;

variabl20891 = variabl1955.get(i2).variabl20890;

variabl22331 = variabl1955.get(i2).variabl22330;

variabl22531 = variabl1955.get(i2).variabl22530;

variabl26291 = variabl1955.get(i2).variabl26290;

variabl26591 = variabl1955.get(i2).variabl26590;

variabl26051 = variabl1955.get(i2).variabl26050;

variabl14131 = variabl1955.get(i2).variabl14130;

variabl17151 = variabl1955.get(i2).variabl17150;

variabl13491 = variabl1955.get(i2).variabl13490;

variabl36791 = variabl1955.get(i2).variabl36790;

variabl20271 = variabl1955.get(i2).variabl20270;

variabl18971 = variabl1955.get(i2).variabl18970;

variabl13571 = variabl1955.get(i2).variabl13570;

variabl36891 = variabl1955.get(i2).variabl36890;

variabl18191 = variabl1955.get(i2).variabl18190;

variabl26311 = variabl1955.get(i2).variabl26310;

variabl26071 = variabl1955.get(i2).variabl26070;

variabl22811 = variabl1955.get(i2).variabl22810;

variabl23711 = variabl1955.get(i2).variabl23710;

if ((variabl16211.equals("6")) || (variabl16211.equals("8"))) {

g.drawLine(variabl13491, variabl36791, variabl13491

+ variabl20271, variabl36791);

g.drawLine(variabl13491, variabl36791, variabl13491,

variabl36791 + variabl18971);

g.drawLine(variabl13491 + variabl20271, variabl36791,

variabl13491 + variabl20271, variabl36791

+ variabl18971);

g.drawLine(variabl13491, variabl36791 + variabl18971,

variabl13491 + variabl20271, variabl36791

+ variabl18971);

}

if ((!variabl22111.equals("*")) && (!variabl16211.equals("8"))) {

g.drawString(variabl22111, variabl13491 + 5, variabl36791 + 15);

}

if (variabl16211.equals("4")) {

g.drawString("组合框", variabl13571 + 5, variabl36891 + 15);

g.drawString("▼", variabl13571 + variabl18191 - 15,

variabl36891 + 13);

}

if (variabl16211.equals("5")) {

g.drawString("列表框", variabl13571 + 5, variabl36891 + 15);

g.drawString("▼", variabl13571 + variabl18191 - 15,

variabl36891 + 13);

g.drawString("▲", variabl13571 + variabl18191 - 15,

variabl36891 + variabl26311 - 6);

}

g.drawLine(variabl13571, variabl36891, variabl13571 + variabl18191,

variabl36891);

g.drawLine(variabl13571, variabl36891, variabl13571, variabl36891

+ variabl26311);

g.drawLine(variabl13571 + variabl18191, variabl36891, variabl13571

+ variabl18191, variabl36891 + variabl26311);

g.drawLine(variabl13571, variabl36891 + variabl26311, variabl13571

+ variabl18191, variabl36891 + variabl26311);

if (variabl16211.equals("7"))

g.drawLine(variabl13491, variabl36791, variabl13571,

variabl36891);

if (variabl16211.equals("8")) {

String sm = "";

if (variabl22111.lastIndexOf("\\") > 0)

if (variabl22111.lastIndexOf("p1") > 0)

sm = ".."

+ variabl22111.substring(

variabl22111.lastIndexOf("p1") - 1,

variabl22111.length());

else

sm = variabl22111.substring(

variabl22111.lastIndexOf("\\") + 1,

variabl22111.length());

else

sm = variabl22111;

if (sm.trim().length() > 0) {

File file = new File(sm);

try {

BufferedImage image = ImageIO.read(file);

g.drawImage(image, variabl13491 + 1, variabl36791 + 1,

variabl20271, variabl18971, null);

} catch (Exception e) {

}

} else {

g.drawString(variabl23851, variabl13491 + 5,

variabl36791 + 10);

}

}

variabl2241 = i2;

mouseX2 = variabl19891x;

mouseY2 = variabl1121;

variabl3665 = 0;

}

variabl3665 = 0;

}

public static void variabl2189(int variabl2241, int variabl16210) {

if ((variabl16210 < 7) || (variabl16210 == 8))

variabl1955.set(variabl2241, new variabl18897(variabl26731,

variabl16211, variabl17731, variabl13491, variabl36791,

variabl20031, variabl20271, variabl18971, variabl13571,

variabl26311, variabl23851, variabl22111, variabl20891,

variabl22331, variabl22531, variabl13491 + mouseX6

- mouseX1, variabl36791 + mouseY6 - mouseY1,

variabl20271, variabl18971, variabl13571 + mouseX6

- mouseX1, variabl36891 + mouseY6 - mouseY1,

variabl18191, variabl26311, variabl26291, variabl26071,

variabl26591, variabl22811, variabl23711, variabl26051,

variabl14131, variabl17151));

else {

variabl1955.get(variabl2241).variabl13490 = variabl1955

.get(variabl2241).variabl13490 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36790 = variabl1955

.get(variabl2241).variabl36790 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl13570 = variabl1955

.get(variabl2241).variabl13570 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36890 = variabl1955

.get(variabl2241).variabl36890 + mouseY6 - mouseY1;

}

variabl3665 = 10;

frame.repaint();

}

public static void variabl1643(int variabl2241) {

switch (variabl22230) {

case 1: {

variabl1955.get(variabl2241).variabl13490 = variabl1955

.get(variabl2241).variabl13490 + mouseX6 - mouseX1;

;

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 - mouseX6 + mouseX1;

;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 2: {

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 + mouseX6 - mouseX1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 3: {

variabl1955.get(variabl2241).variabl36790 = variabl1955

.get(variabl2241).variabl36790 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 4: {

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 5: {

variabl1955.get(variabl2241).variabl13490 = variabl1955

.get(variabl2241).variabl13490 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 - mouseX6 + mouseX1;

variabl1955.get(variabl2241).variabl36790 = variabl1955

.get(variabl2241).variabl36790 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 6: {

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36790 = variabl1955

.get(variabl2241).variabl36790 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 7: {

variabl1955.get(variabl2241).variabl13490 = variabl1955

.get(variabl2241).variabl13490 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 - mouseX6 + mouseX1;

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 8: {

variabl1955.get(variabl2241).variabl20270 = variabl1955

.get(variabl2241).variabl20270 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl18970 = variabl1955

.get(variabl2241).variabl18970 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 11: {

variabl1955.get(variabl2241).variabl13570 = variabl1955

.get(variabl2241).variabl13570 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 - mouseX6 + mouseX1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 12: {

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 + mouseX6 - mouseX1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 13: {

variabl1955.get(variabl2241).variabl36890 = variabl1955

.get(variabl2241).variabl36890 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 14: {

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 15: {

variabl1955.get(variabl2241).variabl13570 = variabl1955

.get(variabl2241).variabl13570 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 - mouseX6 + mouseX1;

variabl1955.get(variabl2241).variabl36890 = variabl1955

.get(variabl2241).variabl36890 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 16: {

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36890 = variabl1955

.get(variabl2241).variabl36890 + mouseY6 - mouseY1;

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 - mouseY6 + mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 17: {

variabl1955.get(variabl2241).variabl13570 = variabl1955

.get(variabl2241).variabl13570 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 - mouseX6 + mouseX1;

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 18: {

variabl1955.get(variabl2241).variabl18190 = variabl1955

.get(variabl2241).variabl18190 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl26310 = variabl1955

.get(variabl2241).variabl26310 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 9: {

variabl1955.get(variabl2241).variabl13490 = variabl1955

.get(variabl2241).variabl13490 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36790 = variabl1955

.get(variabl2241).variabl36790 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

case 19: {

variabl1955.get(variabl2241).variabl13570 = variabl1955

.get(variabl2241).variabl13570 + mouseX6 - mouseX1;

variabl1955.get(variabl2241).variabl36890 = variabl1955

.get(variabl2241).variabl36890 + mouseY6 - mouseY1;

variabl3665 = 10;

variabl22230 = 0;

frame.repaint();

break;

}

}

}

public ControlPosition() {

addMouseListener(new MouseMonitor());

addMouseMotionListener(new MouseMonitor());

}

public static void main(String[] args) {

scrollPane1 = new JScrollPane();

variabl25172[0] = "序号";

variabl25172[1] = "图形代码";

variabl25172[2] = "图形名称";

variabl25172[3] = "标签名";

variabl25172[4] = "字段名";

variabl25172[5] = "更换列名";

variabl25172[6] = "字段类型";

variabl25172[7] = "代码表名";

variabl25172[8] = "关键字";

variabl25172[9] = "标签左边距";

variabl25172[10] = "标签到顶距";

variabl25172[11] = "标签宽度";

variabl25172[12] = "标签高度";

variabl25172[13] = "字段左边距";

variabl25172[14] = "字段到顶距";

variabl25172[15] = "字段宽度";

variabl25172[16] = "高度";

variabl25172[17] = "字体";

variabl25172[18] = "字号";

variabl25172[19] = "颜色";

variabl25172[20] = "最大值";

variabl25172[21] = "最小值";

variabl25172[22] = "值域";

variabl25172[23] = "条件表达式";

variabl25172[24] = "只作显示";

variabl2475 = new int[25];

variabl26730 = 0;

variabl26731 = 0;

variabl2203 = 0;

variabl2241 = 0;

variabl22412 = 0;

variabl3665 = 0;

variabl2573 = 0;

variabl2223 = 0;

variabl22230 = 0;

variabl2539[0] = "";

variabl2539[1] = "";

variabl2539[2] = "文本框";

variabl2539[3] = "";

variabl2539[4] = "下拉组合框";

variabl2539[5] = "列表框";

variabl2539[6] = "按钮";

variabl2539[7] = "线条";

variabl2483 = 1350;

variabl2503 = 700;

mouseX1 = 0;

mouseY1 = 0;

mouseX3 = 0;

mouseY3 = 0;

mouseX2 = 0;

mouseY2 = 0;

mouseX4 = 0;

mouseY4 = 0;

mouseX5 = 0;

mouseY5 = 0;

mouseX6 = 0;

mouseY6 = 0;

mouseX7 = 6;

mouseY7 = 0;

variabl1655 = 0;

variabl2139 = 60;

variabl1931 = 50;

x1 = 10;

x2 = 13;

g2 = (Graphics2D) g;

variabl1955 = new ArrayList<variabl18897>();

arr[0] = 3.0f;

arr[1] = 3.0f;

variabl1275 = "sql server";

variabl1091 = "sql1";

variabl23595 = new JComboBox();

fa1 = new JTextField("");

fa2 = new JTextField("");

fa3 = new JTextField("");

fa4 = new JTextField("");

variabl2651 = 0;

variabl2517 = null;

variabl2835[0] = "第一条";

variabl2835[1] = "下一条";

variabl2835[3] = "上一条";

variabl2835[2] = "末一条";

variabl2835[4] = "浏览";

variabl2835[5] = "存盘";

variabl2835[6] = "查询";

variabl2835[7] = "清屏";

variabl2835[8] = "修改";

variabl2835[9] = "批修改";

variabl2835[10] = "删除";

variabl2835[11] = "录入图形";

variabl2835[12] = "播放声音";

variabl2835[13] = "连续播放";

variabl2835[14] = "退出";

variabl1637 = 0;

int variabl1133 = 0;

variabl3681 = 0;

variabl1459 = 0;

variabl1315 = 0;

variabl1925 = 0;

variabl1473 = 0;

variabl1293 = 0;

variabl2119 = 0;

variabl1745 = variabl2483;

variabl1923 = variabl2503;

variabl1843 = 0;

variabl1647 = 15;

variabl1849 = 20;

variabl1531 = 10;

variabl1477 = 10;

variabl2309 = "";

variabl1187 = "";

variabl1371 = 0;

variabl1323 = null;

variabl1651 = null;

variabl1233 = 0;

variabl1325 = "";

variabl1837 = new String[0][0];

String[] variabl240501 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘",

"查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

variabl1187 = "0,1,2,3,4,5,6,7,8,9,10,11,12,13,14";

variabl2405 = new String[variabl240501.length];

variabl2851 = 0;

for (int i0 = 0; i0 < variabl240501.length; i0++)

variabl2405[i0] = variabl240501[i0];

frame = new ControlPosition();

frame.setTitle("表单设计程序               作者：程学先");

frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

frame.setBounds(10, 10, variabl2483, variabl2503);

frame.getContentPane().setLayout(null);

panel = new JPanel();

panel.setBounds(0, 0, variabl2483, variabl2503);

panel.setLayout(null);

try {

String[] tableType = { "TABLE" };

variabl2429 = "";

con = main1.getConn();

DatabaseMetaData databaseMetaData = con.getMetaData();

ResultSet resultSet = databaseMetaData.getTables(null, null, "%",

tableType);

while (resultSet.next()) {

variabl2429 = variabl2429 + resultSet.getString("TABLE_NAME")

+ ",";

}

con.close();

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "获取表名失败！");

}

JLabel la1 = new JLabel("表名");

la1.setBounds(10, 5, 65, 25);

la1.setForeground(Color.red);

panel.add(la1);

variabl23595.setFont(new java.awt.Font("Dialog", 0, 12));

variabl23595.setBounds(new Rectangle(80, 5, 150, 25));

panel.add(variabl23595);

String[] s8 = variabl2429.split(",");

for (int i = 0; i < s8.length; i++) {

variabl23595.addItem(s8[i]);

}

if (variabl23595.getItemCount() > 0) {

variabl23595.setSelectedIndex(-1);

}

JLabel la2 = new JLabel("存储文件名");

la2.setBounds(235, 5, 85, 25);

panel.add(la2);

fa2.setBounds(320, 5, 300, 25);

panel.add(fa2);

fa2.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl1955.clear();

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

String s7 = "";

if (fc.getSelectedFile() != null) {

s7 = fc.getSelectedFile().toString();

}

if (s7.indexOf("txt") < 0)

s7 = s7 + ".txt";

fa2.setText(s7);

variabl1603();

variabl2203 = 1;

}

});

JLabel la3 = new JLabel("字段号表");

la3.setBounds(10, 30, 65, 25);

panel.add(la3);

fa3.setBounds(80, 30, 150, 25);

panel.add(fa3);

fa3.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

final JFileChooser fc = new JFileChooser(".\\");

kuangm = "fa3";

list1.removeAll();

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

list1.add(variabl2517[i]);

frame1.setVisible(true);

}

});

JLabel la4 = new JLabel("按钮号表");

la4.setBounds(235, 30, 85, 25);

panel.add(la4);

fa4.setBounds(320, 30, 300, 25);

panel.add(fa4);

fa4.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

final JFileChooser fc = new JFileChooser(".\\");

list1.removeAll();

kuangm = "fa4";

for (int i = 0; i < variabl2835.length; i++)

list1.add(variabl2835[i]);

frame1.setVisible(true);

}

});

JToolBar toolBar = new JToolBar();

toolBar.setBounds(610, 10, 700, 50);

JButton variabl2403 = new JButton(new ImageIcon("文本框.png"));

variabl2403.setToolTipText("文本框");

toolBar.add(variabl2403);

JButton variabl1453 = new JButton(new ImageIcon("下拉组合框.png"));

variabl1453.setToolTipText("下拉组合框");

toolBar.add(variabl1453);

JButton variabl2311 = new JButton(new ImageIcon("列表框.png"));

variabl2311.setToolTipText("列表框");

toolBar.add(variabl2311);

JButton variabl2555 = new JButton(new ImageIcon("按钮.png"));

variabl2555.setToolTipText("按钮");

toolBar.add(variabl2555);

JButton variabl2515 = new JButton(new ImageIcon("线条.png"));

variabl2515.setToolTipText("线条");

toolBar.add(variabl2515);

JButton 图片 = new JButton(new ImageIcon("图片.png"));

图片.setToolTipText("图片");

toolBar.add(图片);

JButton variabl2001 = new JButton("查看数据");

toolBar.add(variabl2001);

JButton variabl2611 = new JButton(" 存  盘 ");

toolBar.add(variabl2611);

JButton variabl2071 = new JButton("自动布局");

toolBar.add(variabl2071);

JButton variabl2455 = new JButton("批 修 改");

toolBar.add(variabl2455);

variabl2455.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl21971 = new String[variabl1955.size()][variabl25172.length];

for (int i1 = 0; i1 < variabl1955.size(); i1++) {

variabl21971[i1][0] = variabl1955.get(i1).variabl2673 + "";

variabl21971[i1][1] = variabl1955.get(i1).variabl1621;

variabl21971[i1][2] = variabl1955.get(i1).variabl1773;

variabl21971[i1][3] = variabl1955.get(i1).variabl2003;

variabl21971[i1][4] = variabl1955.get(i1).variabl23850;

variabl21971[i1][5] = variabl1955.get(i1).variabl22110;

variabl21971[i1][6] = variabl1955.get(i1).variabl20890;

variabl21971[i1][7] = variabl1955.get(i1).variabl22330;

variabl21971[i1][8] = variabl1955.get(i1).variabl22530;

variabl21971[i1][9] = variabl1955.get(i1).variabl13490 + "";

variabl21971[i1][10] = variabl1955.get(i1).variabl36790

+ "";

variabl21971[i1][11] = variabl1955.get(i1).variabl20270

+ "";

variabl21971[i1][12] = variabl1955.get(i1).variabl18970

+ "";

variabl21971[i1][13] = variabl1955.get(i1).variabl13570

+ "";

variabl21971[i1][14] = variabl1955.get(i1).variabl36890

+ "";

variabl21971[i1][15] = variabl1955.get(i1).variabl18190

+ "";

variabl21971[i1][16] = variabl1955.get(i1).variabl26310

+ "";

variabl21971[i1][17] = variabl1955.get(i1).variabl26290;

variabl21971[i1][18] = variabl1955.get(i1).variabl26070

+ "";

variabl21971[i1][19] = variabl1955.get(i1).variabl26590;

variabl21971[i1][20] = variabl1955.get(i1).variabl22810

+ "";

variabl21971[i1][21] = variabl1955.get(i1).variabl23710

+ "";

variabl21971[i1][22] = variabl1955.get(i1).variabl26050;

variabl21971[i1][23] = variabl1955.get(i1).variabl14130;

variabl21971[i1][24] = variabl1955.get(i1).variabl17150;

}

variabl11691 = new String[variabl25172.length];

variabl2475 = new int[variabl25172.length];

for (int i = 0; i < variabl25172.length; i++) {

if (((i > 1) && (i < 7)) || (i == 22))

variabl2475[i] = 8;

else if ((i != 7) && (i != 23))

variabl2475[i] = 4;

else

variabl2475[i] = 14;

variabl11691[i] = "char";

}

tableTenance0.tableModel(1350, 600, variabl25172, variabl2475,

variabl21971, variabl11691);

}

});

JButton variabl2041 = new JButton("进入表单");

toolBar.add(variabl2041);

variabl2041.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String[] parameter = new String[23];

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

parameter[i] = "";

parameter[4] = fa1.getText();

for (int i1 = 0; i1 < variabl1955.size(); i1++) {

if (variabl1955.get(i1).variabl22530.equals("是"))

if (parameter[6].length() <= 0)

parameter[6] = variabl1955.get(i1).variabl23850;

else

parameter[6] = parameter[6] + ","

+ variabl1955.get(i1).variabl23850;

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

parameter[17] = variabl2483 + "";

parameter[18] = (variabl2503 + 100) + "";

parameter[4] = variabl2603;

parameter[5] = fa2.getText();

parameter[0] = variabl2429;

parameter[19] = variabl1325;

dataTenance9.means(parameter);

}

});

JButton variabl1641 = new JButton("打印表单");

toolBar.add(variabl1641);

variabl1641.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String[] parameter = new String[23];

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

parameter[i] = "";

parameter[4] = variabl2603;

parameter[15] = fa2.getText();

dataPreview2.means(parameter);

}

});

JButton variabl2599 = new JButton(" 退  出 ");

toolBar.add(variabl2599);

variabl2599.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

frame.setVisible(false);

frame.dispose();

}

});

panel.add(toolBar, BorderLayout.NORTH);

frame.setContentPane(panel);

frame.setVisible(true);

variabl2403.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl1829 = "";

variabl3665 = 2;

}

});

variabl1453.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl1829 = "";

variabl3665 = 4;

}

});

variabl2311.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl1829 = "";

variabl3665 = 5;

}

});

variabl2555.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl2301 = "";

variabl3665 = 6;

}

});

variabl2515.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl2317 = "";

variabl3665 = 7;

}

});

图片.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl23171 = "";

variabl3665 = 8;

}

});

variabl2001.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

String variabl2001 = "";

char x1 = 10, x2 = 13;

for (int i = 0; i < variabl1955.size(); i++) {

variabl2001 = variabl2001 + variabl1955.get(i).variabl2673

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl1621

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl1773

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl2175

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl1813

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl2003

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl2593

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl2547

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl23850

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl22110

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl20890

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl22330

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl22530

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl13490

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl36790

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl20270

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl18970

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl13570

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl36890

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl18190

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl26310

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl26290

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl26070

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl26590

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl22810

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl23710

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl26050

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl14130

+ "  ";

variabl2001 = variabl2001 + variabl1955.get(i).variabl17150

+ "  ";

variabl2001 = variabl2001 + x1 + x2;

}

printClass1.main3(variabl2001, 1000, 500);

variabl3665 = 0;

}

});

variabl2611.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl3665 = 0;

String sn = fa2.getText();

if (sn.trim().length() < 1) {

sn = JOptionPane.showInputDialog("请输入文件名称。");

if (sn.indexOf("txt") < 0)

sn = sn + ".txt";

fa2.setText(sn);

}

try {

File f1 = new File(sn);

f1.createNewFile();

BufferedWriter f0 = new BufferedWriter(new FileWriter(f1));

String s11 = "";

for (int i = 0; i < variabl1955.size(); i++) {

s11 = s11 + variabl1955.get(i).variabl2673 + "。";

s11 = s11 + variabl1955.get(i).variabl1621 + "。";

s11 = s11 + variabl1955.get(i).variabl1773 + "。";

s11 = s11 + variabl1955.get(i).variabl2175 + "。";

s11 = s11 + variabl1955.get(i).variabl1813 + "。";

s11 = s11 + variabl1955.get(i).variabl2003 + "。";

s11 = s11 + variabl1955.get(i).variabl1859 + "。";

s11 = s11 + variabl1955.get(i).variabl1845 + "。";

s11 = s11 + variabl1955.get(i).variabl2593 + "。";

s11 = s11 + variabl1955.get(i).variabl2547 + "。";

s11 = s11 + variabl1955.get(i).variabl23850 + "。";

s11 = s11 + variabl1955.get(i).variabl22110 + "。";

s11 = s11 + variabl1955.get(i).variabl20890 + "。";

s11 = s11 + variabl1955.get(i).variabl22330 + "。";

s11 = s11 + variabl1955.get(i).variabl22530 + "。";

s11 = s11 + variabl1955.get(i).variabl13490 + "。";

s11 = s11 + variabl1955.get(i).variabl36790 + "。";

s11 = s11 + variabl1955.get(i).variabl20270 + "。";

s11 = s11 + variabl1955.get(i).variabl18970 + "。";

s11 = s11 + variabl1955.get(i).variabl13570 + "。";

s11 = s11 + variabl1955.get(i).variabl36890 + "。";

s11 = s11 + variabl1955.get(i).variabl18190 + "。";

s11 = s11 + variabl1955.get(i).variabl26310 + "。";

s11 = s11 + variabl1955.get(i).variabl26290 + "。";

s11 = s11 + variabl1955.get(i).variabl26070 + "。";

s11 = s11 + variabl1955.get(i).variabl26590 + "。";

s11 = s11 + variabl1955.get(i).variabl22810 + "。";

s11 = s11 + variabl1955.get(i).variabl23710 + "。";

s11 = s11 + variabl1955.get(i).variabl26050 + "。";

s11 = s11 + variabl1955.get(i).variabl14130 + "。";

s11 = s11 + variabl1955.get(i).variabl17150 + "。";

f0.write(s11);

f0.newLine();

s11 = "";

}

f0.flush();

f0.close();

} catch (IOException e1) {

JOptionPane.showMessageDialog(null, "发生异常:" + e1);

}

}

});

variabl2071.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent e) {

variabl3665 = 0;

variabl1459 = 5;

variabl1005(fa1.getText());

variabl1037();

int k = 0;

variabl1955 = new ArrayList<variabl18897>();

variabl26730 = 0;

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

variabl1955.add(new variabl18897(variabl26730, "2", "文本框",

Integer.parseInt(variabl1323[j][6]), Integer

.parseInt(variabl1323[j][4]),

variabl1323[j][1], 0, 0, Integer

.parseInt(variabl1651[j][5]), Integer

.parseInt(variabl1651[j][6]),

variabl1323[j][0], variabl1323[j][1],

variabl1651[j][4], "", "否", Integer

.parseInt(variabl1323[j][6]), Integer

.parseInt(variabl1323[j][7]), Integer

.parseInt(variabl1323[j][3]), Integer

.parseInt(variabl1323[j][2]), Integer

.parseInt(variabl1651[j][0]), Integer

.parseInt(variabl1651[j][1]), Integer

.parseInt(variabl1323[j][4]), Integer

.parseInt(variabl1323[j][5]),

variabl1323[j][8], Integer

.parseInt(variabl1323[j][9]),

variabl1323[j][10], 0.0, 0.0, "", "", "可读写"));

variabl26730++;

}

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

if (variabl1885[j][0] > 0) {

variabl1955.add(new variabl18897(variabl26730, "6",

"按钮", variabl1885[j][0], variabl1885[j][1],

variabl2405[j], variabl1885[j][0],

variabl1885[j][1], variabl1885[j][2],

variabl1885[j][3], variabl2405[j],

variabl2405[j], "按钮", variabl1885[j][4] + "",

"否", variabl1885[j][0], variabl1885[j][1],

variabl1885[j][2], variabl1885[j][3], 0, 0, 0,

0, "宋体", 10, "5   black黑色", 0.0, 0.0, "", "",

"可读写"));

variabl26730++;

}

}

variabl3665 = 50;

frame.repaint();

}

});

variabl23595.addItemListener(new ItemListener() {

public void itemStateChanged(ItemEvent arg0) {

variabl2603 = variabl23595.getSelectedItem().toString();

variabl1005(variabl2603);

variabl2309 = variabl1325;

variabl2203 = 1;

}

});

frame1 = new ControlPosition();

frame1.setBounds(100, 150, 100, 400);

frame1.getContentPane().setLayout(null);

panel1 = new JPanel();

panel1.setBounds(0, 0, 100, 400);

panel1.setLayout(null);

list1 = new List(130, false);

list1.setBounds(0, 0, 140, 340);

JScrollPane listScroll = new JScrollPane(list1);

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

if (list1.getSelectedIndex() >= 0)

if (kuangm.equals("fa3")) {

if (fa3.getText().length() > 0) {

if (("," + fa3.getText() + ",").indexOf(","

+ list1.getSelectedIndex() + ",") < 0)

fa3.setText(fa3.getText() + ","

+ list1.getSelectedIndex());

} else

fa3.setText("" + list1.getSelectedIndex());

} else if (kuangm.equals("fa4")) {

if (fa4.getText().length() > 0) {

if (("," + fa4.getText() + ",").indexOf(","

+ list1.getSelectedIndex() + ",") < 0)

fa4.setText(fa4.getText() + ","

+ list1.getSelectedIndex());

} else

fa4.setText("" + list1.getSelectedIndex());

}

}

});

panel1.add(list1);

frame1.setContentPane(panel1);

final int variabl1727 = 1350, variabl1783 = 700;

frame2 = new ControlPosition();

frame2.setBounds(10, 100, variabl1727, variabl1783 - 100);

frame2.getContentPane().setLayout(null);

panel2 = new JPanel();

panel2.setBounds(0, 0, variabl1727 - 30, variabl1783 - 10);

panel2.setLayout(null);

scrollPane1.setBounds(0, 0, variabl1727 - 30, variabl1783 - 100);

panel2.add(scrollPane1);

variabl21971 = new String[variabl1955.size()][variabl25172.length];

variabl1965 = new DefaultTableModel(variabl21971, variabl25172);

variabl2655 = new JTable(variabl1965);

scrollPane1.getViewport().add(variabl2655, null);

JButton variabl2687 = new JButton("返回");

variabl2687.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

frame.setVisible(true);

frame2.setVisible(false);

frame2.dispose();

}

});

variabl2687.setBounds(10, 520, variabl1727 - 100, 20);

panel2.add(variabl2687);

frame2.add(panel2);

frame2.setLayout(null);

frame2.setVisible(false);

}

public void paint(Graphics g1) {

g = g1;

if (variabl2203 == 0) {

super.paint(g1);

g1.setColor(Color.WHITE);

g1.fillRect(0, 95, variabl1745, variabl1923);

g1.setColor(Color.black);

return;

} else if (variabl3665 == 10) {

g1.setColor(Color.WHITE);

g1.fillRect(0, 95, variabl1745, variabl1923);

g1.setColor(Color.black);

variabl24791();

variabl3665 = 0;

} else if (variabl3665 == 19) {

g1.setColor(Color.WHITE);

g1.fillRect(0, 95, variabl1745, variabl1923);

g1.setColor(Color.black);

int a2 = mouseX2 + variabl20271;

int b2 = mouseY2 + variabl26311;

int a3 = a2;

int b3 = a3;

variabl20031 = variabl23851;

if ((variabl16211.equals("4")) || (variabl16211.equals("5"))) {

variabl18191 = variabl18191 + 15;

if (variabl16211.equals("5"))

variabl26311 = variabl26311 + 40;

}

variabl1955.add(new variabl18897(variabl26730, variabl16211,

variabl17731, mouseX2, mouseY2, variabl20031, a2, b2, a3,

b3, variabl23851, variabl22111, variabl20891, variabl22331,

variabl22531, variabl13491, variabl36791, variabl20271,

variabl18971, variabl13571, variabl36891, variabl18191,

variabl26311, variabl26291, variabl26071, variabl26591,

variabl22811, variabl23711, variabl26051, variabl14131,

variabl17151));

variabl26730++;

variabl24791();

variabl3665 = 0;

} else if (variabl3665 == 18) {

g1.setColor(Color.WHITE);

g1.fillRect(0, 95, variabl1745, variabl1923);

g1.setColor(Color.black);

int a2 = mouseX2 + variabl20271;

int b2 = mouseY2 + variabl26311;

int a3 = a2;

int b3 = a3;

variabl20031 = variabl23851;

variabl1955.set(variabl26731, new variabl18897(variabl26731,

variabl16211, variabl17731, mouseX2, mouseY2, variabl20031,

a2, b2, a3, b3, variabl23851, variabl22111, variabl20891,

variabl22331, variabl22531, variabl13491, variabl36791,

variabl20271, variabl18971, variabl13571, variabl36891,

variabl18191, variabl26311, variabl26291, variabl26071,

variabl26591, variabl22811, variabl23711, variabl26051,

variabl14131, variabl17151));

variabl24791();

variabl3665 = 0;

} else if (variabl3665 == 50) {

g1.setColor(Color.WHITE);

g1.fillRect(0, 95, variabl1745, variabl1923);

g1.setColor(Color.black);

variabl24791();

variabl3665 = 0;

} else if (variabl3665 == 7) {

g.drawLine(mouseX1, mouseY1, mouseX3, mouseY3);

variabl3665 = 0;

}

}

class MouseMonitor implements MouseListener, MouseMotionListener {

public void mouseEntered(MouseEvent arg0) {

if ((variabl3665 == 20) || (variabl3665 == 33)) {

variabl3665 = 10;

frame.repaint();

} else if (variabl3665 == 15) {

variabl3665 = 19;

frame.repaint();

} else if (variabl3665 == 16) {

variabl22412 = variabl2241;

variabl3665 = 18;

frame.repaint();

}

}

public void mousePressed(MouseEvent me) {

variabl1655 = me.getModifiers();

mouseX4 = 0;

if (variabl1655 == 4) {

mouseX4 = me.getX();

mouseY4 = me.getY();

}

mouseX1 = me.getX();

mouseY1 = me.getY();

if (variabl2223 > 0) {

variabl22230 = variabl2223;

variabl2223 = 0;

} else

variabl22230 = 0;

}

public void mouseReleased(MouseEvent me) {

mouseX3 = me.getX();

mouseY3 = me.getY();

Object[] options = { "修改图形参数并重画类图", "删除图形", "退出" };

int variabl2097 = 0;

if ((variabl1655 == 4) && (variabl22230 > 0) && (variabl3665 == 0)) {

if (((mouseX1 != me.getX()) || (mouseY1 != me.getY()))) {

mouseX6 = me.getX();

mouseY6 = me.getY();

variabl1643(variabl2241);

}

} else if ((variabl3665 == 7) && (variabl1655 != 4)) {

if ((mouseX1 != me.getX()) || (mouseY1 != me.getY())) {

variabl2203 = 1;

frame.repaint();

if ((Math.abs(0.0 + mouseX1 - mouseX3)

/ Math.abs(mouseY1 - mouseY3) < 0.07))

mouseX3 = mouseX1;

if ((Math.abs(0.0 + mouseY1 - mouseY3)

/ Math.abs(mouseX1 - mouseX3) < 0.07))

mouseY3 = mouseY1;

variabl1955.add(new variabl18897(variabl26730, "7", "线条",

mouseX1, mouseY1, " ", mouseX1, mouseY1, mouseX3,

mouseY3, "线条", " ", " ", " ", " ", mouseX1,

mouseY1, 1, 1, mouseX3, mouseY3, 1, 1, "宋体", 10,

"5", 0, 0, " ", " ", " "));

variabl26730++;

variabl3665 = 10;

frame.repaint();

}

} else if ((variabl1655 == 4) && (find(mouseX1, mouseY1, 1))

&& (variabl3665 == 0) && (variabl2223 == 0)) {

int variabl16210 = Integer.parseInt(variabl16211);

if (((mouseX1 != me.getX()) || (mouseY1 != me.getY()))) {

mouseX6 = me.getX();

mouseY6 = me.getY();

variabl2189(variabl2241, variabl16210);

} else if ((variabl16210 < 7) || (variabl16210 == 8)) {

variabl2097 = (JOptionPane.showOptionDialog(null,

"请确定是修改图形参数还是删除图形。", "确定是修改图形参数还是删除图形。",

JOptionPane.YES_NO_OPTION,

JOptionPane.QUESTION_MESSAGE, null, options,

options[1]));

if (variabl2097 == 0) {

sysParametric4.main2(15, variabl16210, variabl2241,

variabl2517, variabl1489, variabl13491,

variabl36791, variabl2593, variabl2547);

} else if (variabl2097 == 1) {

variabl1081();

}

} else if (variabl16210 == 7) {

variabl1955.remove(variabl2241);

variabl3665 = 10;

frame.repaint();

}

}

}

public void mouseExited(MouseEvent arg0) {

}

public void mouseMoved(MouseEvent e) {

if (variabl3665 != 7)

for (int i = 0; i < variabl1955.size(); i++) {

int variabl16210 = Integer

.parseInt(variabl1955.get(i).variabl1621);

variabl19891x = variabl1955.get(i).variabl13490;

variabl1155 = variabl1955.get(i).variabl13490

+ variabl1955.get(i).variabl20270;

variabl19893x = variabl1955.get(i).variabl13570;

variabl19894x = variabl1955.get(i).variabl13570

+ variabl1955.get(i).variabl18190;

variabl1121 = variabl1955.get(i).variabl36790;

variabl1193 = variabl1955.get(i).variabl36790

+ variabl1955.get(i).variabl18970;

variabl19893y = variabl1955.get(i).variabl36890;

variabl19894y = variabl1955.get(i).variabl36890

+ variabl1955.get(i).variabl26310;

if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19891x - 2 <= e.getX())

&& (variabl19891x + 2 >= e.getX())

&& (variabl1121 < e.getY() - 2)

&& (variabl1193 > e.getY() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));

variabl2223 = 1;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1155 - 2 <= e.getX())

&& (variabl1155 + 2 >= e.getX())

&& (variabl1121 < e.getY() - 2)

&& (variabl1193 > e.getY() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));

variabl2223 = 2;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1121 - 2 <= e.getY())

&& (variabl1121 + 2 >= e.getY())

&& (variabl19891x < e.getX() - 2)

&& (variabl1155 > e.getX() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));

variabl2223 = 3;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1193 - 2 <= e.getY())

&& (variabl1193 + 2 >= e.getY())

&& (variabl19891x < e.getX() - 2)

&& (variabl1155 > e.getX() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));

variabl2223 = 4;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19891x - 2 <= e.getX())

&& (variabl19891x + 2 >= e.getX())

&& (variabl1121 + 2 > e.getY())

&& (variabl1121 - 2 < e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));

variabl2223 = 5;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1155 - 2 <= e.getX())

&& (variabl1155 + 2 >= e.getX())

&& (variabl1121 + 2 > e.getY())

&& (variabl1121 - 2 < e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));

variabl2223 = 6;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1193 - 2 <= e.getY())

&& (variabl1193 + 2 >= e.getY())

&& (variabl19891x + 2 > e.getX())

&& (variabl19891x - 2 < e.getX())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));

variabl2223 = 7;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl1193 - 2 <= e.getY())

&& (variabl1193 + 2 >= e.getY())

&& (variabl1155 + 2 > e.getX())

&& (variabl1155 - 2 < e.getX())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));

variabl2223 = 8;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19893x - 2 <= e.getX())

&& (variabl19893x + 2 >= e.getX())

&& (variabl19893y < e.getY() - 2)

&& (variabl19894y > e.getY() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.W_RESIZE_CURSOR));

variabl2223 = 11;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19894x - 2 <= e.getX())

&& (variabl19894x + 2 >= e.getX())

&& (variabl19893y < e.getY() - 2)

&& (variabl19894y > e.getY() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.E_RESIZE_CURSOR));

variabl2223 = 12;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19893y - 2 <= e.getY())

&& (variabl19893y + 2 >= e.getY())

&& (variabl19893x < e.getX() - 2)

&& (variabl19894x > e.getX() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.N_RESIZE_CURSOR));

variabl2223 = 13;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19894y - 2 <= e.getY())

&& (variabl19894y + 2 >= e.getY())

&& (variabl19893x < e.getX() - 2)

&& (variabl19894x > e.getX() + 2)) {

setCursor(Cursor

.getPredefinedCursor(Cursor.S_RESIZE_CURSOR));

variabl2223 = 14;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19893x - 2 <= e.getX())

&& (variabl19893x + 2 >= e.getX())

&& (variabl19893y + 2 > e.getY())

&& (variabl19893y - 2 < e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.NW_RESIZE_CURSOR));

variabl2223 = 15;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19894x - 2 <= e.getX())

&& (variabl19894x + 2 >= e.getX())

&& (variabl19893y + 2 > e.getY())

&& (variabl19893y - 2 < e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.NE_RESIZE_CURSOR));

variabl2223 = 16;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19894y - 2 <= e.getY())

&& (variabl19894y + 2 >= e.getY())

&& (variabl19893x + 2 > e.getX())

&& (variabl19893x - 2 < e.getX())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.SW_RESIZE_CURSOR));

variabl2223 = 17;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19894y - 2 <= e.getY())

&& (variabl19894y + 2 >= e.getY())

&& (variabl19894x + 2 > e.getX())

&& (variabl19894x - 2 < e.getX())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.SE_RESIZE_CURSOR));

variabl2223 = 18;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19891x - 2 <= e.getX())

&& (variabl19891x + 2 >= e.getX())

&& (variabl1121 - 2 < e.getY())

&& (variabl1193 + 2 > e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

variabl2223 = 9;

variabl2241 = i;

break;

} else if (((variabl16210 < 7) || (variabl16210 == 8))

&& (variabl19893x - 2 <= e.getX())

&& (variabl19893x + 2 >= e.getX())

&& (variabl19893y - 2 < e.getY())

&& (variabl19893y + 2 > e.getY())) {

setCursor(Cursor

.getPredefinedCursor(Cursor.CROSSHAIR_CURSOR));

variabl2223 = 19;

variabl2241 = i;

break;

} else {

variabl2223 = 0;

variabl2241 = 0;

setCursor(Cursor

.getPredefinedCursor(Cursor.DEFAULT_CURSOR));

}

}

}

public void mouseClicked(MouseEvent me) {

mouseX2 = me.getX();

mouseY2 = me.getY();

if ((variabl3665 > 0) && ((variabl3665 < 7) || (variabl3665 == 8))

&& (variabl1655 != 4)) {

if ((variabl2651 == 0) && (variabl3665 < 6)) {

JOptionPane.showMessageDialog(null, "请先选择数据表名！");

return;

}

mouseX2 = me.getX();

mouseY2 = me.getY();

variabl16211 = variabl3665 + "";

variabl17731 = variabl2539[variabl3665];

if (!(find(mouseX2, mouseY2, 1))) {

sysParametric4.main2(14, variabl3665, -1, variabl2517,

variabl1489, mouseX2, mouseY2, 0, 0);

}

}

}

public void mouseDragged(MouseEvent arg0) {

}

}

static void variabl1037() {

int variabl1637 = 0;

int variabl1133 = 0;

int variabl3681 = 10;

int variabl1385 = 1;

int variabl1327 = 1;

variabl1921 = new int[variabl2651][2];

variabl1233 = variabl2651;

int variabl1239 = 1;

variabl1315 = variabl2483 - 80;

variabl1459 = 100;

int y1 = variabl3681;

int y2 = variabl1459;

int variabl1159 = 0;

if ((variabl1473 == 0)

&& (variabl2651 * variabl1849 < variabl2503 - 120)) {

variabl1239 = variabl2651;

variabl1637 = (variabl2503 - 120 - variabl2651 * variabl1849)

/ (variabl2651 + 1);

int n1 = 1, n2 = 1;

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

if (variabl1323[j][1].length() > variabl1159)

variabl1159 = variabl1323[j][1].length();

}

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

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1159 * variabl1647 + "";

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1159 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = (variabl1315 - Integer

.parseInt(variabl1651[j][0])) + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y2 = y2 + variabl1849 + variabl1637;

variabl1459 = y2;

variabl1651[j][5] = n1 + "";

variabl1651[j][6] = n2 + "";

n1++;

}

} else {

variabl1385 = 1;

y1 = variabl3681;

y2 = variabl1459;

variabl1327 = 1;

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

variabl1925 = variabl1323[j][1].length();

if (("ntext,text,memo,image,long,lob,")

.lastIndexOf(variabl1501[j]) < 0) {

if ((y1 + (variabl1925 + variabl1489[j]) * variabl1647) > variabl1315) {

variabl1327++;

variabl1385 = 1;

y1 = variabl3681;

y2 = y2 + variabl1849;

}

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1925 * variabl1647 + "";

if ((y1 == variabl3681) && (variabl1925 > variabl1159))

variabl1159 = variabl1925;

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1925 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = variabl1489[j] * variabl1647 + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y1 = y1 + variabl1925 * variabl1647 + variabl1489[j]

* variabl1647;

variabl1651[j][5] = variabl1327 + "";

variabl1651[j][6] = variabl1385 + "";

variabl1385++;

}

}

if (variabl1473 == 0)

variabl1637 = (variabl2503 - 120) / (variabl1327 + 1)

- variabl1849;

else

variabl1637 = 0;

if (variabl1637 < 0)

variabl1637 = 0;

int z = 0;

int z1 = 0;

int z3 = 0;

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

if (main1.variabl1537.lastIndexOf(variabl1501[j]) < 0) {

if (Integer.parseInt(variabl1323[j][6]) == variabl3681) {

z = variabl1159 * variabl1647

- Integer.parseInt(variabl1323[j][3]);

z1 = z1 + variabl1637;

if (j > 0)

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

}

variabl1323[j][6] = (Integer.parseInt(variabl1323[j][6]) + z)

+ "";

variabl1651[j][0] = (Integer.parseInt(variabl1651[j][0]) + z)

+ "";

variabl1323[j][7] = (Integer.parseInt(variabl1323[j][7]) + z1)

+ "";

variabl1651[j][1] = (Integer.parseInt(variabl1651[j][1]) + z1)

+ "";

y2 = Integer.parseInt(variabl1651[j][1]) + z1;

z3 = j;

}

}

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

variabl1459 = y2;

if (variabl1473 > 0) {

y2 = y2 + variabl1849;

int z2 = (variabl2503 - y2 - 120) / variabl1473;

for (int i3 = 0; i3 < variabl2651; i3++) {

if (main1.variabl1537.lastIndexOf(variabl1501[i3]) >= 0) {

variabl1327++;

variabl1385 = 1;

variabl1323[i3][6] = variabl3681 + "";

variabl1323[i3][7] = y2 + "";

variabl1323[i3][3] = variabl1159 * variabl1647 + "";

variabl1323[i3][2] = variabl1849 + "";

variabl1651[i3][0] = (variabl3681 + variabl1159

* variabl1647)

+ "";

variabl1651[i3][1] = y2 + "";

y2 = y2 + z2;

variabl1323[i3][4] = (variabl1315 - variabl1159

* variabl1647 - 10)

+ "";

variabl1323[i3][5] = z2 + "";

variabl1323[i3][8] = "宋体";

variabl1323[i3][9] = "10";

variabl1323[i3][10] = "5";

variabl1651[i3][2] = "2";

if ((",image,long,lob,").lastIndexOf(variabl1501[i3]) >= 0)

variabl1651[i3][4] = "图像字段";

else

variabl1651[i3][4] = "文本字段";

variabl1651[i3][5] = variabl1327 + "";

variabl1651[i3][6] = variabl1385 + "";

variabl1385++;

}

}

}

}

int zzb = 1000;

String bqk = "";

for (int i3 = 0; i3 < variabl2651; i3++) {

if (Integer.parseInt(variabl1651[i3][6]) == 1)

if (zzb > Integer.parseInt(variabl1323[i3][6]))

zzb = Integer.parseInt(variabl1323[i3][6]);

bqk = variabl1323[i3][3];

}

for (int i3 = 0; i3 < variabl2651; i3++)

if (Integer.parseInt(variabl1651[i3][6]) == 1) {

variabl1323[i3][6] = zzb + "";

variabl1323[i3][3] = bqk;

}

variabl1459 = y2;

if (fa4.getText().length() > 0)

variabl1187 = fa4.getText();

variabl2851 = variabl2405.length;

variabl1885 = new int[variabl2851][15];

String[] t5 = variabl1187.split(",");

variabl1371 = t5.length;

variabl1885 = new int[variabl2851][15];

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

variabl1885[j][0] = 0;

variabl1885[j][1] = 0;

variabl1885[j][2] = 0;

variabl1885[j][3] = 0;

variabl1885[j][4] = 0;

}

int variabl2179, variabl1629;

variabl1629 = (int) (variabl1647 * 6.3);

if ((variabl1371 * variabl1629) % (variabl2483 - 50) == 0)

variabl2179 = (int) (variabl1371 * variabl1629)

% (variabl2483 - 50);

else

variabl2179 = (int) (variabl1371 * variabl1629)

/ (variabl2483 - 50) + 1;

variabl3681 = 20;

if (variabl1473 == 0)

variabl1459 = variabl1459 + variabl1849 * 2;

else

variabl1459 = variabl1459 + variabl1849;

int variabl1505 = (variabl2483 - 30) / (int) (6.6 * variabl1647);

if (variabl1505 < 1)

variabl1505 = 1;

if (variabl1371 <= variabl1505)

variabl1629 = (variabl2483 - 60) / variabl1371;

else

variabl1629 = (variabl2483 - 60) / variabl1505;

int n = 0, n1 = 0, n2 = 0, n3 = 0;

n3 = variabl1505 * variabl1629;

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

if (("," + variabl1187 + ",").lastIndexOf("," + j + ",") >= 0) {

variabl1885[j][0] = variabl3681;

variabl1885[j][1] = variabl1459;

if (variabl2405[j].length() > 4) {

variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 1.2));

n3 = n3 + variabl1885[j][2] - variabl1629;

variabl3681 = variabl3681 + variabl1885[j][2];

} else {

variabl1885[j][2] = variabl1629;

variabl3681 = variabl3681 + variabl1629;

}

variabl1885[j][3] = variabl1849;

variabl1885[j][4] = j;

n++;

n1++;

if (variabl1371 - n1 == 0)

break;

if ((n >= variabl1505)

&& ((variabl1371 - n1) - variabl1505 != 0)) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

if ((variabl1371 - n1) <= variabl1505)

variabl1629 = (variabl2483 - 60) / (variabl1371 - n1);

else

variabl1629 = (variabl2483 - 60) / variabl1505;

n = 0;

n2++;

} else if (n >= variabl1505) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

n = 0;

n2++;

}

}

}

}

static void variabl1005(String variabl1103) {

String variabl1203 = "";

if (variabl23595.getSelectedItem().toString().length() <= 0) {

JOptionPane.showMessageDialog(null, "请先选择数据表。");

return;

}

variabl1103 = variabl23595.getSelectedItem().toString();

if (fa3.getText().length() > 0) {

String[] sj = fa3.getText().split(",");

String[] sj1 = variabl2309.split(",");

for (int i = 0; i < sj.length; i++)

if (i == 0)

variabl1203 = sj1[Integer.parseInt(sj[i])];

else

variabl1203 = variabl1203 + ","

+ sj1[Integer.parseInt(sj[i])];

}

String s1 = "";

int variabl2119 = 0;

variabl1325 = "";

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

if (variabl1203.length() <= 0)

s1 = "select * from " + variabl1103;

else

s1 = "select " + variabl1203 + "  from " + variabl1103;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

variabl1651 = new String[variabl2651][8];

variabl1323 = new String[variabl2651][15];

variabl1473 = 0;

variabl1843 = 0;

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

variabl2517[i] = rsmdt4.getColumnName(i + 1);

if (variabl1325.length() < 1)

variabl1325 = variabl2517[i];

else

variabl1325 = variabl1325 + "," + variabl2517[i];

variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);

variabl1843++;

variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);

if (("ntext,text,memo,image,long,lob,")

.lastIndexOf(variabl1501[i]) < 0)

variabl2119 = variabl2119 + variabl2517[i].length() * 20

* 30 + variabl1489[i] * 20 * 30;

else

variabl2119 = variabl2119 + variabl2517[i].length() * 20

* 30 + 400 * 40;

if (variabl1651[i][3] == null)

variabl1651[i][3] = "";

if (variabl1651[i][4] == null)

variabl1651[i][4] = "";

if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl2517[i]

+ "表,") >= 0) && (variabl2517[i].indexOf("代码") >= 0))) {

variabl1651[i][3] = variabl2517[i] + "表";

variabl1651[i][4] = "组合框";

variabl1489[i] = variabl1489[i] + 10;

} else if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl2517[i]

+ "代码表,") >= 0) && (variabl2517[i]

.indexOf("代码") < 0))) {

variabl1651[i][3] = variabl2517[i] + "代码表";

variabl1651[i][4] = "组合框";

variabl1489[i] = variabl1489[i] + 10;

}

variabl1323[i][0] = variabl2517[i];

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() == 0))

for (int j = 0; j < variabl1837.length; j++) {

if (variabl2517[i].equals(variabl1837[j][0]))

variabl1323[i][1] = variabl1837[j][1];

else if (variabl2517[i].equals(variabl1837[j][1]))

variabl1323[i][1] = variabl1837[j][0];

}

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() == 0))

variabl1323[i][1] = variabl2517[i];

if (variabl1651[i][4].length() < 1)

if (main1.variabl1537.indexOf("," + variabl1501[i] + ",") >= 0) {

variabl1651[i][4] = "文本字段";

variabl1473++;

} else if (main1.variabl1539.indexOf("," + variabl1501[i]

+ ",") >= 0) {

variabl1651[i][4] = "图像字段";

variabl1473++;

} else

variabl1651[i][4] = "普通字段";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

variabl2119 = variabl2119 + 100 * 30 * 14;

variabl2503 = (int) Math.sqrt((variabl2119 * 2 * 3 / 4));

variabl2483 = variabl2503 * 4 / 3;

while ((variabl2503 > 650) && (variabl2483 < 1000)) {

variabl2503 = (int) (variabl2503 * 0.9);

variabl2483 = (int) (variabl2483 / 0.9);

}

}

}

83.源码83，部件程序，自定义表单。界面可以包括全局性列表框、单指某字段列表框、组合框、文本域、文本框、图形框、按钮、水平直线、竖直直线等各种控件，任意布置位置与大小。可以规定每个文本框、按钮、文本域的字体、字号、颜色。具有数据录入、修改、删除、图形输入、指定图形输入、指定记录播放语音、连续播放语音、批修改、查询等功能。具有变换标签、提供代码录入方便功能，具有安全性、数据实体完整性、域完整性控制功能。

/** 

 * 程序文件名：dataTenance9.java 

 * 作者：程学先  

 * 功能：自定义表单。

  */

import java.awt.Color;

import java.awt.Component;

import java.awt.Font;

import java.awt.List;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.FocusListener;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.io.InputStream;

import java.io.BufferedReader;

import java.io.BufferedWriter;

import java.io.File;

import java.io.FileInputStream;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.FileReader;

import java.io.FileWriter;

import java.io.IOException;

import java.io.OutputStreamWriter;

import java.sql.Connection;

import java.sql.PreparedStatement;

import java.sql.ResultSet;

import java.sql.ResultSetMetaData;

import java.sql.SQLException;

import java.sql.Statement;

import java.util.ArrayList;

import java.util.HashSet;

import javax.swing.Icon;

import javax.swing.ImageIcon;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JList;

import javax.swing.JOptionPane;

import javax.swing.JPanel;

import javax.swing.JScrollPane;

import javax.swing.JTextArea;

import javax.swing.JTextField;

import javax.swing.text.JTextComponent;

import javax.swing.JFileChooser;

import javax.sound.sampled.AudioFormat;

import javax.sound.sampled.AudioInputStream;

import javax.sound.sampled.AudioSystem;

import javax.sound.sampled.DataLine;

import javax.sound.sampled.LineUnavailableException;

import javax.sound.sampled.SourceDataLine;

import javax.sound.sampled.UnsupportedAudioFileException;

public class dataTenance9 extends JFrame {

static dataTenance9 frame1 = null;

static String variabl1091 = main1.variabl1091;

static JTextField[] variabl2403 = null;

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String variabl2603 = "";

private static int variabl2483 = main1.variabl2483;

private static int variabl2503 = main1.variabl2503;

private static int variabl1531 = 10, variabl1477 = 10;

private static int variabl2651 = 0, variabl1739 = 0;

private static String[] variabl2517 = null;

private static String variabl1325 = "", variabl2803 = "";

private static String[] variabl1501 = null;

private static int[] variabl1489 = null;

private static int variabl1853 = 0;

private static int variabl18531 = 0, variabl18532 = 0;

private static int variabl2547 = 0;

private static String[][] variabl2197 = null;

private static String[] variabl1419 = null;

static String[][] variabl1701 = null;

private static String variabl1187 = "";

private static int variabl1371 = 0;

private static String variabl1153 = "";

private static String[] variabl1507 = null;

private static String[] variabl1525 = null;

private static int[] variabl1287 = null;

private static String s1 = "", s2 = "", s3 = "", s4 = "";

private static int b = 0, c = 0;

private static int[][] variabl1921 = null;

private static int variabl1843 = 0;

private static int variabl18430 = 0;

private static JLabel[] variabl2165 = null;

private static int variabl1647 = 15, variabl1849 = 20;

private static String[] variabl2405 = { "第一条", "下一条", "末一条", "上一条", "浏览",

"存盘", "查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

private static JButton variabl2375, variabl2325, variabl2853, variabl2255,

variabl2531, variabl2611, variabl2637, variabl2601, variabl1697,

variabl2455, variabl2633, variabl2825, variabl2827, variabl2829,

variabl2599;

private static ArrayList<String> list = new ArrayList<String>();

private static ArrayList<String> list0 = new ArrayList<String>();

private static String[][] variabl1323 = null;

private static String[][] variabl1651 = null;

private static String[][] variabl1201 = null;

private static String[][] variabl1197 = null;

private static String[][] variabl1837 = new String[0][0];

private static int variabl1233 = 0, variabl1077 = 0, variabl1069 = 0;

private static int variabl1693 = 0, variabl1725 = 0;

private static int variabl2695 = 0, x11 = 0;

public static String username = main1.username;

public static int variabl2607 = 9, variabl2659 = 5;

private static String variabl2629 = "宋体";

private static String variabl1597 = main1.variabl1537 + main1.variabl1539;

private static int variabl3681 = 0;

private static int variabl1459 = 0, variabl14590 = 0;

private static int variabl1319 = 0, variabl1313 = 0;

private static int[] variabl1467 = null;

private static int variabl1637 = 0;

private static int[][] variabl1111 = null;

private static JPanel panel1 = new JPanel(false);

private static int variabl2119 = 0, variabl1745 = variabl2483,

variabl1923 = variabl2503;

private static int variabl1315 = 0, variabl2821 = 0;

private static int variabl1473 = 0, ann = 0;

private static int variabl1925 = 0;

private static JTextArea[] variabl2463 = null;

private static JComboBox[] variabl2359 = null;

private static JTextComponent[] variabl1733 = null;

private static String[][] variabl1431 = null;

private static String variabl2429 = "", variabl2823 = "";

private static String variabl1873 = "";

private static int[][] variabl1885 = null;

private static JButton[] variabl2185 = new JButton[15];

private static List list1;

private static List[] variabl2311;

public static String MUSIC_FILE = "notify.wav";

public static byte[] v;

public static Xyz xyz;

public static Thread t;

public static int t0 = 0;

public static String[] t5;

public static String[] variabl2831;

public static String sk, variabl2031;

public static int k3, lbk;

static int variabl2851 = 0, variabl2339 = 0;

private static int variabl2833;

static int 线条数量 = 0;

static int[][] 线条位置 = new int[20][6];

static String[][] variabl2231 = new String[20][5];

static String[][] 按钮数据 = new String[20][5];

private static HashSet set01 = new HashSet();

public static String sd0;

static void color1(int c, JLabel fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color2(int c, JTextField fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color3(int c, JTextArea fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void color4(int c, JButton fl) {

switch (c) {

case 1:

fl.setForeground(Color.red);

break;

case 2:

fl.setForeground(Color.blue);

break;

case 3:

fl.setForeground(Color.green);

break;

case 4:

fl.setForeground(Color.white);

break;

case 5:

fl.setForeground(Color.black);

break;

case 6:

fl.setForeground(Color.darkGray);

break;

case 7:

fl.setForeground(Color.cyan);

break;

case 8:

fl.setForeground(Color.yellow);

break;

case 9:

fl.setForeground(Color.gray);

break;

case 10:

fl.setForeground(Color.lightGray);

break;

case 11:

fl.setForeground(Color.magenta);

break;

case 12:

fl.setForeground(Color.orange);

break;

}

}

static void means(String parameter[]) {

variabl2651 = 0;

variabl1739 = 0;

variabl1325 = "";

variabl1853 = 0;

variabl18531 = 0;

variabl2547 = 0;

variabl1187 = "";

variabl1371 = 0;

variabl1153 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

b = 0;

c = 0;

x11 = 0;

variabl1843 = 0;

variabl18430 = 0;

variabl1647 = 18;

variabl1849 = 20;

variabl1233 = 0;

variabl1077 = 0;

variabl1069 = 0;

variabl1693 = 0;

variabl1725 = 0;

variabl2695 = 0;

variabl2607 = 9;

variabl2659 = 5;

variabl2629 = "宋体";

variabl3681 = 0;

variabl1459 = 0;

variabl2483 = main1.variabl2483;

variabl2503 = main1.variabl2503;

variabl1319 = 0;

variabl1313 = 0;

variabl1637 = 0;

variabl2119 = 0;

variabl1745 = variabl2483;

variabl1923 = variabl2503;

variabl1315 = 0;

variabl1473 = 0;

variabl1925 = 0;

variabl2429 = "";

variabl1873 = "";

ann = 0;

variabl2821 = 0;

variabl2823 = "";

variabl2833 = 0;

lbk = 0;

线条数量 = 0;

list = new ArrayList<String>();

list0 = new ArrayList<String>();

variabl1091 = main1.variabl1091;

sk = "";

k3 = 0;

variabl2339 = 0;

variabl2803 = "";

variabl1837 = new String[0][0];

username = main1.username;

xyz = new Xyz();

t = new Thread(xyz);

panel1 = new JPanel(true);

frame1 = new dataTenance9();

frame1.setTitle("自定义表单程序                           作者：程学先");

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

frame1.getContentPane().add(panel1, null);

variabl2823 = "";

list1 = new List();

list = new ArrayList<String>();

variabl1597 = main1.variabl1537 + main1.variabl1539;

variabl2185 = new JButton[20];

String[] variabl240501 = { "第一条", "下一条", "末一条", "上一条", "浏览", "存盘",

"查询", "清屏", "修改", "批修改", "删除", "录入图形", "播放声音", "连续播放", "退出" };

variabl2405 = new String[variabl240501.length];

variabl2851 = 0;

for (int i0 = 0; i0 < variabl240501.length; i0++)

variabl2405[i0] = variabl240501[i0];

if (parameter[11].length() > 0) {

variabl1187 = parameter[11];

variabl1187 = variabl1187.replaceAll("；", ";");

variabl1187 = variabl1187.replaceAll("。", ";");

variabl1187 = variabl1187.replaceAll(":", ";");

variabl1187 = variabl1187.replaceAll("：", ";");

if (variabl1187.indexOf(";") > 0) {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (s601[i01].indexOf(";") > 0) {

String s602[] = s601[i01].split(";");

if (s602[0] != null)

variabl2405[Integer.parseInt((s602[0]))] = s602[1];

variabl1187 = variabl1187 + "," + s602[0];

} else {

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

String s601[] = variabl1187.split(",");

variabl1187 = "";

for (int i01 = 0; i01 < s601.length; i01++) {

if (i01 == 0)

variabl1187 = s601[i01];

else

variabl1187 = variabl1187 + "," + s601[i01];

}

}

} else {

variabl1187 = "";

for (int i1 = 0; i1 < variabl2405.length; i1++) {

if (i1 == 0)

variabl1187 = variabl1187 + i1;

else

variabl1187 = variabl1187 + "," + i1;

}

}

variabl1187 = "," + variabl1187 + ",";

variabl1187 = variabl1187.replaceAll(",,", ",");

variabl2851 = variabl2405.length;

variabl1885 = new int[variabl2851][15];

int m1 = 0, m2 = 0;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

if (parameter[17] != null)

m1 = Integer.parseInt(parameter[17]);

if (parameter[18] != null)

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

variabl2483 = m1;

variabl1745 = m1;

variabl2503 = m2;

}

} catch (Exception e2) {

}

panel1.setLayout(null);

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

variabl2231[i][2] = "宋体";

variabl2231[i][3] = "10";

variabl2231[i][4] = "5";

按钮数据[i][2] = "宋体";

按钮数据[i][3] = "10";

按钮数据[i][4] = "5";

}

variabl2429 = "," + parameter[0] + ",";

variabl2603 = parameter[4];

String[] t1 = parameter[0].split(",");

variabl1325 = parameter[19];

String variabl1059 = parameter[5];

String[] t2 = parameter[19].split(",");

variabl1873 = "";

if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0)

for (int i = 0; i < t1.length; i++)

if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0) {

variabl1873 = t1[i];

variabl10091();

}

if (parameter[6].length() <= 0) {

JOptionPane.showMessageDialog(null, "缺少关键字，请说明关键字字段后再运行。");

return;

}

variabl1525 = parameter[6].split(",");

variabl1153 = parameter[8];

variabl2803 = "," + parameter[9] + ",";

variabl1287 = new int[variabl1525.length];

String variabl13250 = "", variabl13251 = "";

if (variabl1153.length() > 0) {

String[] t3 = variabl1153.split(",");

for (int i = 0; i < t3.length; i++) {

if (t3[i] != null)

if (i > 0)

variabl13250 = variabl13250 + ","

+ t2[Integer.parseInt(t3[i])];

else

variabl13250 = t2[Integer.parseInt(t3[i])];

}

variabl1325 = variabl13250;

for (int i = 0; i < variabl1525.length; i++)

if (("," + variabl1325 + ",").indexOf("," + variabl1525[i]

+ ",") < 0)

variabl1325 = variabl1325 + "," + variabl1525[i];

}

t2 = variabl1325.split(",");

variabl1467 = new int[t2.length];

variabl1651 = new String[t2.length][6];

variabl1323 = new String[t2.length][15];

t5 = variabl1187.split(",");

variabl2831 = new String[variabl2405.length];

if (parameter[5].length() > 1) {

File file1 = new File(parameter[5]);

try {

if (file1.exists()) {

FileReader fr = new FileReader(file1);

BufferedReader br = new BufferedReader(fr);

String tempStr = null;

variabl13251 = "";

String[] d1;

int d2 = 0;

k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1)

list0.add(tempStr);

if (d2 == 0) {

d1 = tempStr.split("。");

if (d1.length > 15)

d2 = 1;

}

}

sk = "";

for (int i = 0; i < list0.size(); i++) {

sk = list0.get(i);

if (d2 == 0) {

list.add(sk);

if (sk.substring(0, 2).equals("1,"))

variabl1233++;

if (sk.substring(0, 2).equals("2,"))

variabl1069++;

if (sk.substring(0, 2).equals("3,"))

variabl1077++;

} else if (sk.length() > 1) {

d1 = sk.split("。");

if (d1[1].equals("2") || d1[1].equals("4")

|| d1[1].equals("5")) {

list.add(sk);

if ((d1[1].equals("5")) && (d1[10].equals("*"))) {

lbk = 1;

if ((d1[19] != null) && (d1[20] != null)

&& (d1[21] != null)

&& (d1[22] != null))

list1.setBounds(

Integer.parseInt(d1[19]),

Integer.parseInt(d1[20]),

Integer.parseInt(d1[21]),

Integer.parseInt(d1[22]));

panel1.add(list1);

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

String s4 = "";

String[] s5;

for (int i = 0; i < variabl1733.length; i++)

variabl1733[b].setText(list1

.getSelectedItem());

}

});

} else

variabl1233++;

if ((d1[26].length() > 0)

|| (d1[27].length() > 0)

|| (d1[28].length() > 0)

|| (d1[29].length() > 0))

variabl1077++;

if (d1[30].length() > 0)

variabl1069++;

} else if (d1[1].equals("6")) {

String[] nl = sk.split("。");

int xl = 0;

if (nl[13] != null)

xl = Integer.parseInt(nl[13]);

variabl2831[k3] = sk;

k3++;

variabl2405[xl] = nl[11];

variabl1885[xl][0] = Integer.parseInt(nl[15]);

variabl1885[xl][1] = Integer.parseInt(nl[16]);

variabl1885[xl][2] = Integer.parseInt(nl[17]);

variabl1885[xl][3] = Integer.parseInt(nl[18]);

按钮数据[xl][0] = nl[10];

按钮数据[xl][1] = nl[11];

按钮数据[xl][2] = nl[23];

按钮数据[xl][3] = nl[24];

按钮数据[xl][4] = nl[25];

} else if (d1[1].equals("7")) {

String[] nl = sk.split("。");

线条位置[线条数量][0] = Integer.parseInt(nl[15]);

线条位置[线条数量][1] = Integer.parseInt(nl[16]);

线条位置[线条数量][2] = Integer.parseInt(nl[19]);

线条位置[线条数量][3] = Integer.parseInt(nl[20]);

线条位置[线条数量][4] = Integer.parseInt(nl[24]);

线条位置[线条数量][5] = 7;

线条数量++;

} else if (d1[1].equals("8")) {

String[] nl = sk.split("。");

线条位置[线条数量][0] = Integer.parseInt(nl[15]);

线条位置[线条数量][1] = Integer.parseInt(nl[16]);

线条位置[线条数量][2] = Integer.parseInt(nl[17]);

线条位置[线条数量][3] = Integer.parseInt(nl[18]);

线条位置[线条数量][4] = Integer.parseInt(nl[24]);

线条位置[线条数量][5] = 8;

variabl2231[线条数量][0] = nl[10];

variabl2231[线条数量][1] = nl[11];

variabl2231[线条数量][2] = nl[23];

variabl2231[线条数量][3] = nl[24];

variabl2231[线条数量][4] = nl[25];

线条数量++;

}

}

}

variabl1371 = k3;

if (k3 > 0) {

variabl2833 = 1;

}

if (variabl1233 > 0) {

if (lbk == 1) {

variabl1651 = new String[variabl1233 + 1][6];

variabl1323 = new String[variabl1233 + 1][13];

} else {

variabl1651 = new String[variabl1233][6];

variabl1323 = new String[variabl1233][13];

}

} else {

variabl1323 = new String[t2.length][13];

variabl1651 = new String[t2.length][6];

}

variabl1197 = new String[variabl1069][4];

variabl1201 = new String[variabl1077][6];

int m3 = 0;

m1 = 0;

m2 = 0;

int y = 2, n1 = 0;

String s = "";

s2 = "";

variabl1693 = 0;

variabl1725 = 0;

int variabl16931 = 0;

variabl2483 = 0;

for (int i = 0; i < list.size(); i++) {

s = list.get(i);

if (d2 == 0) {

if (s.substring(0, 2).equals("1,")) {

variabl1323[m1] = s.substring(2, s.length())

.split("。");

variabl1323[m1][1] = "";

variabl1323[m1][2] = variabl1323[m1][5];

variabl1651[m1][0] = Integer

.parseInt(variabl1323[m1][3])

+ Integer.parseInt(variabl1323[m1][6])

+ "";

variabl1651[m1][1] = variabl1323[m1][7];

if (Integer.parseInt(variabl1323[m1][5])

+ Integer.parseInt(variabl1651[m1][1]) > variabl1459)

variabl1459 = Integer

.parseInt(variabl1323[m1][5])

+ Integer

.parseInt(variabl1651[m1][1]);

if (Integer.parseInt(variabl1323[m1][4])

+ Integer.parseInt(variabl1323[m1][6])

+ 80 > variabl2483)

variabl2483 = Integer

.parseInt(variabl1323[m1][4])

+ Integer

.parseInt(variabl1323[m1][6])

+ 80;

variabl1651[m1][2] = "";

variabl1651[m1][3] = "";

variabl1651[m1][4] = "";

s2 = s2 + variabl1323[m1][0] + ",";

m1++;

variabl1233 = m1;

} else if (s.substring(0, 2).equals("2,")) {

y = 2;

n1 = 0;

int n0 = 0;

String[] sf = s.split("。");

variabl1197[m2][0] = sf[0];

variabl1197[m2][1] = sf[1];

variabl1197[m2][2] = sf[2];

sf = variabl1197[m2][0].split(",");

variabl1197[m2][0] = sf[1];

if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& ((variabl1197[m2][1].length() == 0)

|| (variabl1197[m2][1]

.equals("*")) || (variabl1197[m2][1]

.toLowerCase()

.equals(variabl2603

.toLowerCase())))) {

if (variabl1197[m2][2].indexOf("i") < 0) {

variabl1187 = variabl1187.replaceAll(

"5,", "");

n0 = 1;

}

if (variabl1197[m2][2].indexOf("u") < 0) {

variabl1187 = variabl1187.replaceAll(

"7,", "");

n0 = 1;

}

if (variabl1197[m2][2].indexOf("d") < 0) {

variabl1187 = variabl1187.replaceAll(

"8,", "");

n0 = 1;

}

n0 = 1;

} else if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& (variabl1197[m2][2].indexOf("d") < 0)) {

variabl1187 = variabl1187.replaceAll("8,",

"");

n0 = 1;

} else if ((variabl1197[m2][0]

.equalsIgnoreCase(username))

&& (variabl1197[m2][2].length() > 0)

&& (variabl1197[m2][2].indexOf("a") < 0)

&& (variabl1197[m2][2].indexOf("i") < 0)

&& (variabl1197[m2][2].indexOf("u") < 0)) {

variabl1197[m2][0] = "只读";

variabl1197[m2][2] = "q,";

}

if (n0 == 0) {

m2++;

variabl1069 = m2;

}

} else if (s.substring(0, 2).equals("3,")) {

y = 2;

n1 = 0;

for (int k = 2; k < s.length(); k++)

if (s.substring(k, k + 1).equals("。")) {

variabl1201[m3][n1] = s.substring(y, k);

y = k + 1;

n1++;

}

variabl1201[m3][n1] = s

.substring(y, s.length());

if (variabl1201[m3][3].isEmpty())

variabl1201[m3][3] = "";

m3++;

variabl1077 = m3;

}

} else {

d1 = s.split("。");

if (d1[13] == null)

d1[13] = "";

variabl1651[m1][0] = d1[19];

variabl1651[m1][1] = d1[20];

if (Integer.parseInt(d1[20])

+ Integer.parseInt(d1[22]) > variabl1459)

variabl1459 = Integer.parseInt(d1[20])

+ Integer.parseInt(d1[22]);

if (Integer.parseInt(d1[19])

+ Integer.parseInt(d1[21]) + 80 > variabl2483)

variabl2483 = Integer.parseInt(d1[19])

+ Integer.parseInt(d1[21]) + 80;

variabl1651[m1][2] = d1[1];

variabl1651[m1][3] = d1[13];

variabl1651[m1][4] = d1[12];

variabl1323[m1][0] = d1[10];

variabl1323[m1][1] = d1[11];

variabl1323[m1][2] = d1[18];

variabl1323[m1][3] = d1[17];

variabl1323[m1][4] = d1[21];

variabl1323[m1][5] = d1[22];

variabl1323[m1][6] = d1[15];

variabl1323[m1][7] = d1[16];

variabl1323[m1][8] = d1[23];

variabl1323[m1][9] = d1[24];

variabl1323[m1][10] = d1[25];

variabl1323[m1][11] = d1[0];

s2 = s2 + variabl1323[m1][0] + ",";

if (!d1[11].equals("*"))

m1++;

variabl1233 = m1;

if ((d1[26].length() > 0) || (d1[27].length() > 0)

|| (d1[28].length() > 0)

|| (d1[29].length() > 0)) {

variabl1201[m3][0] = d1[10];

variabl1201[m3][1] = d1[26];

variabl1201[m3][2] = d1[27];

variabl1201[m3][3] = d1[28];

variabl1201[m3][4] = d1[29];

m3++;

variabl1077 = m3;

}

if (d1[30].trim().equals("只读")) {

variabl1197[m2][1] = d1[10];

variabl1197[m2][0] = "只读";

variabl1197[m2][2] = "q,";

m2++;

variabl1069 = m2;

}

}

variabl1111 = new int[variabl1323.length][10];

variabl1467 = new int[variabl1323.length];

variabl1419 = new String[variabl1323.length];

}

if (variabl1233 > 0) {

variabl1325 = "";

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

if (i == 0)

variabl1325 = variabl1323[i][0];

else

variabl1325 = variabl1325 + ","

+ variabl1323[i][0];

}

}

}

} catch (IOException e2) {

JOptionPane.showMessageDialog(null, "打开文件错！");

}

} else {

variabl1323 = new String[t2.length][13];

variabl1651 = new String[t2.length][6];

variabl1197 = new String[0][4];

variabl1201 = new String[0][6];

variabl1111 = new int[t2.length][10];

variabl1467 = new int[t2.length];

variabl1419 = new String[t2.length];

}

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

t2 = variabl1325.split(",");

for (int j = 0; j < t2.length; j++) {

if (variabl1197[i][1] == null)

continue;

if (variabl1197[i][1].toLowerCase()

.indexOf(t2[j].toLowerCase()) >= 0) {

if (variabl1197[i][0].equals("只读"))

variabl2803 = variabl2803 + j + ",";

variabl1197[i][1] = j + "";

}

}

}

if (variabl2483 < variabl1745)

variabl2483 = variabl1745;

variabl1005(variabl2603);

variabl1009(variabl2603, "");

if (variabl1233 == 0)

variabl1037();

variabl2819002();

variabl2817002();

t2 = variabl1325.split(",");

for (int i = 0; i < t2.length; i++)

if (t2[i].equals("声音文件名")) {

variabl2823 = t2[i];

variabl2821 = i;

}

String sd = "";

for (int i0 = 0; i0 < variabl1853; i0++) {

sd = "";

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

sd = sd + variabl2197[i0][variabl1467[i]].trim() + ",";

break;

}

}

}

set01.add(sd);

}

variabl2375 = new JButton(variabl2405[0]);

variabl2375.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl18531 = 0;

variabl18532 = variabl18531;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",")) >= 0)

if ((variabl1733[i].getText() == null)

|| (variabl1733[i].getText().trim()

.length() < 1))

variabl1733[i].setText("0");

} else {

variabl2311[i].select(variabl18531);

}

}

}

variabl2325.setEnabled(true);

variabl2255.setEnabled(false);

t.stop();

t = new Thread(xyz);

}

});

if (variabl1885[0][0] > 0) {

variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],

variabl1885[0][2], variabl1885[0][3]);

Font font = new Font(按钮数据[0][2], Font.BOLD,

Integer.parseInt(按钮数据[0][3]));

String s01 = 按钮数据[0][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2375.setFont(font);

color4(s02, variabl2375);

panel1.add(variabl2375);

}

variabl2325 = new JButton(variabl2405[1]);

variabl2325.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 < variabl1853 - 1) {

variabl18531++;

variabl18532 = variabl18531;

if (variabl18531 == variabl1853 - 1)

variabl2325.setEnabled(false);

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

if ((main1.variabl1545

.lastIndexOf(","

+ variabl1501[variabl1467[i]]

+ ",")) >= 0)

if ((variabl1733[i].getText() == null)

|| (variabl1733[i].getText()

.trim().length() < 1))

variabl1733[i].setText("0");

} else {

variabl2311[i].select(variabl18531);

}

}

}

}

variabl2255.setEnabled(true);

t.stop();

t = new Thread(xyz);

}

});

if (variabl1885[1][0] > 0) {

variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],

variabl1885[1][2], variabl1885[1][3]);

Font font = new Font(按钮数据[1][2], Font.BOLD,

Integer.parseInt(按钮数据[1][3]));

String s01 = 按钮数据[1][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2325.setFont(font);

color4(s02, variabl2325);

panel1.add(variabl2325);

}

variabl2853 = new JButton(variabl2405[2]);

variabl2853.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl1853 > 1)

variabl18531 = variabl1853 - 1;

else

variabl18531 = 0;

variabl18532 = variabl18531;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

if ((main1.variabl1545.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",")) >= 0)

if ((variabl1733[i].getText() == null)

|| (variabl1733[i].getText().trim()

.length() < 1))

variabl1733[i].setText("0");

} else {

variabl2311[i].select(variabl18531);

}

}

}

variabl2255.setEnabled(true);

variabl2325.setEnabled(false);

t.stop();

t = new Thread(xyz);

}

});

if (variabl1885[2][0] > 0) {

variabl2853.setBounds(variabl1885[2][0], variabl1885[2][1],

variabl1885[2][2], variabl1885[2][3]);

Font font = new Font(按钮数据[2][2], Font.BOLD,

Integer.parseInt(按钮数据[2][3]));

String s01 = 按钮数据[2][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2853.setFont(font);

color4(s02, variabl2853);

panel1.add(variabl2853);

}

variabl2255 = new JButton(variabl2405[3]);

variabl2255.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 > 0) {

variabl18531--;

variabl18532 = variabl18531;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框")) {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

if ((main1.variabl1545

.lastIndexOf(","

+ variabl1501[variabl1467[i]]

+ ",")) >= 0)

if ((variabl1733[i].getText() == null)

|| (variabl1733[i].getText()

.trim().length() < 1))

variabl1733[i].setText("0");

} else {

variabl2311[i].select(variabl18531);

}

}

}

variabl2325.setEnabled(true);

} else

variabl2255.setEnabled(false);

t.stop();

t = new Thread(xyz);

}

});

if (variabl1885[3][0] > 0) {

variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],

variabl1885[3][2], variabl1885[3][3]);

Font font = new Font(按钮数据[3][2], Font.BOLD,

Integer.parseInt(按钮数据[3][3]));

String s01 = 按钮数据[3][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2255.setFont(font);

color4(s02, variabl2255);

panel1.add(variabl2255);

variabl2255.setEnabled(false);

}

variabl2531 = new JButton(variabl2405[4]);

variabl2531.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2531.getText().trim().equals("浏览")) {

variabl2531.setText("转当前行");

variabl1701 = new String[variabl1853][variabl2651];

int[] n = new int[variabl1489.length];

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

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

variabl1701[i][j] = variabl2197[i][j];

if (variabl1701[i][j] == null)

variabl1701[i][j] = "";

if (variabl1701[i][j].length() > 50)

variabl1701[i][j] = variabl1701[i][j]

.substring(0, 50);

}

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

n[j] = variabl1489[j];

if (n[j] > 50)

n[j] = 50;

}

tableTenance.tableModel(variabl2483, variabl2503,

variabl2517, n, variabl1701, variabl1501);

} else {

variabl2531.setText("浏览");

variabl18531 = main1.variabl1327;

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

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

variabl1733[i]

.setText(variabl2197[main1.variabl1327][variabl1467[i]]);

}

}

}

});

if (variabl1885[4][0] > 0) {

variabl2531.setBounds(variabl1885[4][0], variabl1885[4][1],

variabl1885[4][2], variabl1885[4][3]);

Font font = new Font(按钮数据[4][2], Font.BOLD,

Integer.parseInt(按钮数据[4][3]));

String s01 = 按钮数据[4][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2531.setFont(font);

color4(s02, variabl2531);

panel1.add(variabl2531);

}

variabl2611 = new JButton(variabl2405[5]);

variabl2611.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[variabl1843];

String s = "";

String[] s0 = new String[variabl1843];

int b = 0;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0) {

if (variabl1651[i][4].equals("组合框")) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

s = (String) variabl2359[variabl1739]

.getSelectedItem();

variabl1419[i] = s;

if (variabl1419[i] == null)

variabl1419[i] = " ";

} else {

variabl1419[i] = variabl1733[i].getText().trim();

if (variabl1419[i] == null) {

variabl1419[i] = " ";

variabl1733[i].setText(variabl1507[i]);

}

}

} else {

variabl1419[i] = "?";

}

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

if ((variabl1419[i] == null)

|| (variabl1419[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl1419[i].trim() + ",";

break;

}

}

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

set01.add(sd);

if (set01.size() == kd) {

JOptionPane.showMessageDialog(null, "关键字重复，请修改后重新生成！");

return;

}

set01.remove(sd);

sd0 = sd;

c = 0;

int a1 = 0;

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

if ((variabl1077 > 0) && (!variabl3623(c, i))) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

cont4 = main1.getConn();

try {

variabl1853++;

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "insert into " + variabl2603 + "(";

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

a1 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("i") < 0))

a1 = 1;

}

if (a1 == 0)

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[j]] + ",") < 0)

s1 = s1 + variabl2517[variabl1467[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1733.length; i++)

if (variabl1467[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[j] + ",") >= 0) {

if (variabl1419[i].length() < 1)

variabl1419[i] = "0";

s2 = s2 + variabl1525[j] + "="

+ variabl1419[i];

} else

s2 = s2 + variabl1525[j] + "='"

+ variabl1419[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

d1: for (int j = 0; j < variabl1843; j++) {

int a2 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("i") < 0)) {

a2 = 1;

continue d1;

}

}

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[variabl1467[j]] + ",") >= 0) {

s1 = s1 + variabl1419[j] + ",";

} else if (variabl1419[j].trim().equals("?")) {

s0[b] = "update " + variabl2603 + " set "

+ variabl2517[variabl1467[j]] + " = ?"

+ " where " + s2;

x0[b] = j;

b++;

} else {

s1 = s1 + "'" + variabl1419[j].trim() + "',";

}

}

s1 = s1.substring(0, s1.length() - 1) + ")";

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

variabl1853++;

set01.add(sd0);

for (int j = 0; j < variabl1733.length; j++) {

variabl2197[variabl1853][j] = "";

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

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

variabl4063(s0[i], x0[i]);

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

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

variabl1733[i].setText(variabl1507[i]);

}

});

if (variabl1885[5][0] > 0) {

variabl2611.setBounds(variabl1885[5][0], variabl1885[5][1],

variabl1885[5][2], variabl1885[5][3]);

Font font = new Font(按钮数据[5][2], Font.BOLD,

Integer.parseInt(按钮数据[5][3]));

String s01 = 按钮数据[5][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2611.setFont(font);

color4(s02, variabl2611);

panel1.add(variabl2611);

}

variabl2637 = new JButton(variabl2405[6]);

variabl2637.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2637.getText().trim().equals("查询")) {

variabl2637.setText("还原");

variabl2375.setEnabled(true);

variabl2325.setEnabled(true);

variabl2255.setEnabled(true);

variabl2853.setEnabled(true);

variabl2455.setEnabled(true);

variabl1009(variabl2603, " where " + variabl2031);

variabl23750();

} else {

variabl2637.setText("查询");

variabl18531 = 0;

variabl2375.setEnabled(true);

variabl2325.setEnabled(true);

variabl2255.setEnabled(true);

variabl2853.setEnabled(true);

variabl1009(variabl2603, "");

variabl23750();

variabl2455.setEnabled(false);

}

}

});

if (variabl1885[6][0] > 0) {

variabl2637.setBounds(variabl1885[6][0], variabl1885[6][1],

variabl1885[6][2], variabl1885[6][3]);

Font font = new Font(按钮数据[6][2], Font.BOLD,

Integer.parseInt(按钮数据[6][3]));

String s01 = 按钮数据[6][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2637.setFont(font);

color4(s02, variabl2637);

panel1.add(variabl2637);

}

variabl2601 = new JButton(variabl2405[7]);

variabl2601.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

variabl1733[i].setText(variabl1507[i]);

}

}

});

if (variabl1885[7][0] > 0) {

variabl2601.setBounds(variabl1885[7][0], variabl1885[7][1],

variabl1885[7][2], variabl1885[7][3]);

Font font = new Font(按钮数据[7][2], Font.BOLD,

Integer.parseInt(按钮数据[7][3]));

String s01 = 按钮数据[7][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2601.setFont(font);

color4(s02, variabl2601);

panel1.add(variabl2601);

}

variabl1697 = new JButton(variabl2405[8]);

variabl1697.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

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

if ((variabl1077 > 0) && (!variabl3623(c, i))) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String[] s0 = new String[variabl1843];

int b = 0;

int[] x0 = new int[variabl1843];

for (int i = 0; i < variabl1733.length; i++)

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0) {

if (variabl1651[i][4].equals("组合框")) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框")) {

variabl1419[i] = (String) variabl2359[variabl1739]

.getSelectedItem();

}

if (variabl1419[i] == null)

variabl1419[i] = " ";

} else {

variabl1419[i] = variabl1733[i].getText().trim();

if (variabl1419[i] == null) {

variabl1419[i] = " ";

variabl1733[i].setText(variabl1507[i]);

}

}

} else {

variabl1419[i] = "?";

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

if ((variabl1419[i] == null)

|| (variabl1419[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl1419[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请改为生成数据录入语句！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1733.length; i++)

if (variabl1467[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[j] + ",") >= 0) {

if (variabl1419[i].length() < 1)

variabl1419[i] = "0";

s2 = s2 + variabl1525[j] + "=" + variabl1419[i];

} else

s2 = s2 + variabl1525[j] + "='"

+ variabl1419[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "update " + variabl2603 + " set ";

d2: for (int j = 0; j < variabl1733.length; j++) {

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((("," + variabl1197[i][1] + ",")

.indexOf("," + j + ",") >= 0)

&& (variabl1197[i][2].indexOf("u") < 0))

continue d2;

}

if (!variabl1419[j].trim().equals("?")) {

s1 = s1 + variabl2517[variabl1467[j]] + "=";

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[variabl1467[j]] + ",") >= 0)

s1 = s1 + variabl1419[j];

else

s1 = s1 + "'" + variabl1419[j].trim() + "'";

s1 = s1 + ",";

} else {

s0[b] = "update " + variabl2603 + " set "

+ variabl2517[variabl1467[j]] + "=? where "

+ s2;

x0[b] = j;

b++;

}

}

s1 = s1.substring(0, s1.length() - 1) + " where " + s2;

PreparedStatement pst4 = cont4.prepareStatement(s1);

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

for (int k = 0; k < variabl1733.length; k++) {

variabl2197[variabl18531][variabl1467[k]] = variabl1419[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

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

variabl4063(s0[i], x0[i]);

}

});

if (variabl1885[8][0] > 0) {

variabl1697.setBounds(variabl1885[8][0], variabl1885[8][1],

variabl1885[8][2], variabl1885[8][3]);

Font font = new Font(按钮数据[8][2], Font.BOLD,

Integer.parseInt(按钮数据[8][3]));

String s01 = 按钮数据[8][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl1697.setFont(font);

color4(s02, variabl1697);

panel1.add(variabl1697);

}

variabl2455 = new JButton(variabl2405[9]);

variabl2455.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

}

});

if (variabl1885[9][0] > 0) {

variabl2455.setBounds(variabl1885[9][0], variabl1885[9][1],

variabl1885[9][2], variabl1885[8][3]);

Font font = new Font(按钮数据[9][2], Font.BOLD,

Integer.parseInt(按钮数据[9][3]));

String s01 = 按钮数据[9][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2455.setFont(font);

color4(s02, variabl2455);

panel1.add(variabl2455);

variabl2455.setEnabled(false);

}

variabl2633 = new JButton(variabl2405[10]);

variabl2633.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0)

variabl1419[i] = variabl1733[i].getText().trim();

}

String sd = "";

int kd = set01.size();

int kd0 = 0;

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

if ((variabl1419[i] == null)

|| (variabl1419[i].trim().length() == 0))

kd0 = 1;

sd = sd + variabl1419[i].trim() + ",";

break;

}

if (kd0 == 1) {

JOptionPane.showMessageDialog(null, "关键字不全，请修改后重新生成！");

return;

}

}

set01.add(sd);

if (set01.size() != kd) {

JOptionPane.showMessageDialog(null, "关键字不存在，请修改后重新生成！");

set01.remove(sd);

return;

}

sd0 = sd;

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[j] + ",") >= 0)

s2 = s2 + variabl1525[j] + "=" + variabl1419[i];

else

s2 = s2 + variabl1525[j] + "='"

+ variabl1419[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "delete from  " + variabl2603 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

set01.remove(sd0);

deleteData(variabl18531);

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

if (variabl18531 == variabl1853 - 1)

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0)

variabl1733[i].setText(variabl1507[i]);

else if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0) {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if (variabl1885[10][0] > 0) {

variabl2633.setBounds(variabl1885[10][0], variabl1885[10][1],

variabl1885[10][2], variabl1885[10][3]);

Font font = new Font(按钮数据[10][2], Font.BOLD,

Integer.parseInt(按钮数据[10][3]));

String s01 = 按钮数据[10][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2633.setFont(font);

color4(s02, variabl2633);

panel1.add(variabl2633);

}

variabl2825 = new JButton(variabl2405[11]);

variabl2825.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

String s;

s2 = "";

for (int j = 0; j < variabl1525.length; j++) {

for (int i = 0; i < variabl1733.length; i++)

if (variabl1467[i] == variabl1287[j]) {

variabl1419[i] = variabl1733[i].getText().trim();

if (main1.variabl1545.lastIndexOf(","

+ variabl1501[j] + ",") >= 0) {

if (variabl1419[i].length() < 1)

variabl1419[i] = "0";

s2 = s2 + variabl1525[j] + "=" + variabl1419[i];

} else

s2 = s2 + variabl1525[j] + "='"

+ variabl1419[i].trim() + "'";

break;

}

if (j < variabl1525.length - 1)

s2 = s2 + " and ";

}

if (variabl18430 > 0) {

s1 = "update " + variabl2603 + " set "

+ variabl2517[variabl18430] + "=? where " + s2;

variabl4063(s1, variabl18430);

} else

for (int i = 0; i < variabl1733.length; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

variabl1419[i] = "?";

s1 = "update " + variabl2603 + " set "

+ variabl2517[variabl1467[i]] + "=? where "

+ s2;

variabl4063(s1, i);

}

}

}

});

if (variabl1885[11][0] > 0) {

variabl2825.setBounds(variabl1885[11][0], variabl1885[11][1],

variabl1885[11][2], variabl1885[11][3]);

Font font = new Font(按钮数据[11][2], Font.BOLD,

Integer.parseInt(按钮数据[11][3]));

String s01 = 按钮数据[11][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2825.setFont(font);

color4(s02, variabl2825);

panel1.add(variabl2825);

}

variabl2827 = new JButton(variabl2405[12]);

variabl2827.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

t0 = 0;

if (variabl2823.length() > 0)

t.start();

}

});

if (variabl1885[12][0] > 0) {

variabl2827.setBounds(variabl1885[12][0], variabl1885[12][1],

variabl1885[12][2], variabl1885[12][3]);

Font font = new Font(按钮数据[12][2], Font.BOLD,

Integer.parseInt(按钮数据[12][3]));

String s01 = 按钮数据[12][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2827.setFont(font);

color4(s02, variabl2827);

panel1.add(variabl2827);

}

variabl2829 = new JButton(variabl2405[13]);

variabl2829.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

t0 = 1;

if (variabl2823.length() > 0) {

t = new Thread(xyz);

t.start();

}

}

});

if (variabl1885[13][0] > 0) {

variabl2829.setBounds(variabl1885[13][0], variabl1885[13][1],

variabl1885[13][2], variabl1885[13][3]);

Font font = new Font(按钮数据[13][2], Font.BOLD,

Integer.parseInt(按钮数据[13][3]));

String s01 = 按钮数据[13][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2829.setFont(font);

color4(s02, variabl2829);

panel1.add(variabl2829);

}

variabl2599 = new JButton(variabl2405[14]);

variabl2185[9] = variabl2599;

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if (variabl1885[14][0] > 0) {

variabl2599.setBounds(variabl1885[14][0], variabl1885[14][1],

variabl1885[14][2], variabl1885[14][3]);

Font font = new Font(按钮数据[14][2], Font.BOLD,

Integer.parseInt(按钮数据[14][3]));

String s01 = 按钮数据[14][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.substring(0, 1));

variabl2599.setFont(font);

color4(s02, variabl2599);

panel1.add(variabl2599);

}

if (variabl2503 - variabl1459 - variabl1637 - 100 < 0)

variabl2503 = variabl1459 + variabl1637 + 100;

panel1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 20);

int w1, h1;

if (1200 - variabl2483 > 0)

w1 = (1200 - variabl2483) / 2;

else

w1 = 0;

if (600 - variabl2503 > 0)

h1 = (600 - variabl2503) / 2;

else

h1 = 0;

if (variabl2503 < variabl1459 + 20)

variabl2503 = variabl1459 + 20;

frame1.setBounds(w1, h1, variabl2483, variabl2503);

frame1.setVisible(true);

}

static void variabl1037() {

if (variabl1233 > 0)

return;

int variabl1637 = 0;

int variabl1133 = 0;

int variabl3681 = 10;

variabl1921 = new int[variabl2651][2];

variabl1233 = variabl2651;

int variabl1239 = 1;

variabl1315 = variabl2483 - 80;

variabl1459 = 20;

int y1 = variabl3681;

int y2 = variabl1459;

int variabl1159 = 0;

if ((variabl1473 == 0)

&& (variabl2651 * variabl1849 < variabl2503 - 120)) {

variabl1239 = variabl2651;

variabl1637 = (variabl2503 - 150 - variabl2651 * variabl1849)

/ (variabl2651 + 1);

for (int j = 0; j < variabl2651; j++)

if (variabl1323[j][1].length() > variabl1159)

variabl1159 = variabl1323[j][1].length();

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

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1159 * variabl1647 + "";

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1159 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = (variabl1315 - Integer

.parseInt(variabl1651[j][0])) + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y2 = y2 + variabl1849 + variabl1637;

variabl1459 = y2;

}

} else {

int variabl1385 = 1;

y1 = variabl3681;

y2 = variabl1459;

int variabl1327 = 1;

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

variabl1925 = variabl1323[j][1].length();

if (variabl1597.lastIndexOf("," + variabl1501[j] + ",") < 0) {

if ((y1 + (variabl1925 + variabl1489[j]) * variabl1647) > variabl1315) {

variabl1327++;

variabl1385 = 1;

y1 = variabl3681;

y2 = y2 + variabl1849;

}

variabl1323[j][6] = y1 + "";

variabl1323[j][7] = y2 + "";

variabl1323[j][3] = variabl1925 * variabl1647 + "";

if ((y1 == variabl3681) && (variabl1925 > variabl1159))

variabl1159 = variabl1925;

variabl1323[j][2] = variabl1849 + "";

variabl1651[j][0] = (y1 + variabl1925 * variabl1647) + "";

variabl1651[j][1] = y2 + "";

variabl1323[j][4] = variabl1489[j] * variabl1647 + "";

variabl1323[j][5] = variabl1849 + "";

variabl1323[j][8] = "宋体";

variabl1323[j][9] = "10";

variabl1323[j][10] = "5";

variabl1651[j][2] = "2";

y1 = y1 + variabl1925 * variabl1647 + variabl1489[j]

* variabl1647;

variabl1385++;

}

}

if (variabl1473 == 0)

variabl1637 = (variabl2503 - 150) / (variabl1327 + 1)

- variabl1849;

else

variabl1637 = 0;

if (variabl1637 < 0)

variabl1637 = 0;

int z = 0;

int z1 = 0;

int z3 = 0;

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

if (variabl1597.lastIndexOf("," + variabl1501[j] + ",") < 0) {

if (Integer.parseInt(variabl1323[j][6]) == variabl3681) {

z = variabl1159 * variabl1647

- Integer.parseInt(variabl1323[j][3]);

z1 = z1 + variabl1637;

if (j > 0)

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

}

variabl1323[j][6] = (Integer.parseInt(variabl1323[j][6]) + z)

+ "";

variabl1651[j][0] = (Integer.parseInt(variabl1651[j][0]) + z)

+ "";

variabl1323[j][7] = (Integer.parseInt(variabl1323[j][7]) + z1)

+ "";

variabl1651[j][1] = (Integer.parseInt(variabl1651[j][1]) + z1)

+ "";

y2 = Integer.parseInt(variabl1651[j][1]);

z3 = j;

}

}

variabl1323[z3][4] = (variabl1315 - Integer

.parseInt(variabl1651[z3][0])) + "";

variabl1459 = y2;

if (variabl1473 > 0) {

y2 = y2 + variabl1849;

int z2 = (variabl2503 - y2 - 120) / variabl1473;

for (int i3 = 0; i3 < variabl2651; i3++) {

if (variabl1597.lastIndexOf("," + variabl1501[i3] + ",") >= 0) {

variabl1323[i3][6] = variabl3681 + "";

variabl1323[i3][7] = y2 + "";

variabl1323[i3][3] = variabl1159 * variabl1647 + "";

variabl1323[i3][2] = variabl1849 + "";

variabl1651[i3][0] = (variabl3681 + variabl1159

* variabl1647)

+ "";

variabl1651[i3][1] = y2 + "";

y2 = y2 + z2;

variabl1323[i3][4] = (variabl1315 - variabl1159

* variabl1647)

+ "";

variabl1323[i3][5] = z2 + "";

variabl1323[i3][8] = "宋体";

variabl1323[i3][9] = "10";

variabl1323[i3][10] = "5";

variabl1651[i3][2] = "2";

if (main1.variabl1539.lastIndexOf("," + variabl1501[i3]

+ ",") >= 0)

variabl1651[i3][4] = "图像字段";

else

variabl1651[i3][4] = "文本字段";

variabl1385++;

}

}

variabl1459 = y2 + variabl1849;

}

}

variabl1459 = y2 + variabl1849;

}

static void variabl2819002() {

if (variabl2833 > 0)

return;

String[] t5 = variabl1187.split(",");

variabl1371 = t5.length - 1;

variabl1885 = new int[variabl2851][15];

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

variabl1885[j][0] = 0;

variabl1885[j][1] = 0;

variabl1885[j][2] = 0;

variabl1885[j][3] = 0;

}

int variabl2179, variabl1629;

variabl1629 = (int) (variabl1647 * 6.3);

if ((variabl1371 * variabl1629) % (variabl2483 - 50) == 0)

variabl2179 = (int) (variabl1371 * variabl1629)

% (variabl2483 - 50);

else

variabl2179 = (int) (variabl1371 * variabl1629)

/ (variabl2483 - 50) + 1;

variabl3681 = 20;

if (variabl1473 == 0)

variabl1459 = variabl1459 + variabl1849 * 2;

else

variabl1459 = variabl1459 + variabl1849;

int variabl1505 = (variabl2483 - 30) / (int) (6.6 * variabl1647);

if (variabl1505 < 1)

variabl1505 = 1;

if (variabl1371 <= variabl1505)

variabl1629 = (variabl2483 - 60) / variabl1371;

else

variabl1629 = (variabl2483 - 60) / variabl1505;

int n = 0, n1 = 0, n2 = 0, n3 = 0;

n3 = variabl1505 * variabl1629;

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

if (variabl1187.lastIndexOf("," + j + ",") >= 0) {

variabl1885[j][0] = variabl3681;

variabl1885[j][1] = variabl1459;

if (variabl2405[j].length() > 4) {

variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 1.2));

n3 = n3 + variabl1885[j][2] - variabl1629;

variabl3681 = variabl3681 + variabl1885[j][2];

} else {

variabl1885[j][2] = variabl1629;

variabl3681 = variabl3681 + variabl1629;

}

variabl1885[j][3] = variabl1849;

n++;

n1++;

if (variabl1371 - n1 == 0)

break;

if ((n >= variabl1505)

&& ((variabl1371 - n1) - variabl1505 != 0)) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

if ((variabl1371 - n1) <= variabl1505)

variabl1629 = (variabl2483 - 60) / (variabl1371 - n1);

else

variabl1629 = (variabl2483 - 60) / variabl1505;

n = 0;

n2++;

} else if (n >= variabl1505) {

variabl3681 = 20;

variabl1459 = variabl1459 + variabl1849 + 20;

n = 0;

n2++;

}

}

}

variabl2503 = variabl1459 + variabl1849 + 100;

}

static void variabl1005(String variabl1103) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

variabl1325 = variabl1325.replaceAll(",\\*", "");

String s1 = "select " + variabl1325 + " from " + variabl1103;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

variabl1507 = new String[variabl2651];

variabl1473 = 0;

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

variabl2517[i] = rsmdt4.getColumnName(i + 1);

variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);

variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);

if (variabl1651[i][3] == null)

variabl1651[i][3] = "";

if (variabl1651[i][4] == null)

variabl1651[i][4] = "";

if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl2517[i]

+ "表,") >= 0) && (variabl2517[i].indexOf("代码") >= 0))) {

variabl1651[i][3] = variabl2517[i] + "表";

variabl1651[i][4] = "组合框";

variabl1489[i] = variabl1489[i] + 10;

} else if ((variabl1651[i][3].length() < 1)

&& ((variabl2429.lastIndexOf("," + variabl2517[i]

+ "代码表,") >= 0) && (variabl2517[i]

.indexOf("代码") < 0))) {

variabl1651[i][3] = variabl2517[i] + "代码表";

variabl1651[i][4] = "组合框";

variabl1489[i] = variabl1489[i] + 10;

}

variabl1323[i][0] = variabl2517[i];

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() != 0))

for (int j = 0; j < variabl1837.length; j++) {

if (variabl2517[i].toLowerCase().equalsIgnoreCase(

variabl1837[j][0].toLowerCase()))

variabl1323[i][1] = variabl1837[j][1];

else if (variabl2517[i].toLowerCase().equalsIgnoreCase(

variabl1837[j][1].toLowerCase()))

variabl1323[i][1] = variabl1837[j][0];

}

if ((variabl1323[i][1]) == null

|| (variabl1323[i][1].length() == 0))

variabl1323[i][1] = variabl2517[i];

if (variabl1651[i][4].length() < 1)

if ((",text,ntext,i,d,t").indexOf("," + variabl1501[i]

+ ",") >= 0) {

variabl1651[i][4] = "文本字段";

variabl1473++;

} else if (variabl1501[i].equalsIgnoreCase("image")) {

variabl1651[i][4] = "图像字段";

variabl1473++;

} else

variabl1651[i][4] = "普通字段";

if (variabl1501[i].indexOf("datetime") == 0)

variabl1507[i] = "2001-01-01 00:00:00.000";

else if (variabl1501[i].indexOf("smalldatetime") == 0)

variabl1507[i] = "2001-01-01 00:00:00";

else if (variabl1501[i].indexOf("datetime2") == 0)

variabl1507[i] = "2001-01-01 00:00:00.0000000";

else if (variabl1501[i].indexOf("datetimeoffset") == 0)

variabl1507[i] = "2001-01-01 00:00:00.0000000 +08:00";

else if (variabl1501[i].indexOf("date") == 0)

variabl1507[i] = "2001-01-01";

else if (variabl1501[i].indexOf("time") == 0)

variabl1507[i] = "00:00:00";

else if (variabl1501[i].indexOf("money") >= 0)

variabl1507[i] = "0.0000";

else if (main1.variabl1541.lastIndexOf("," + variabl1501[i]

+ ",") >= 0)

variabl1507[i] = "0.00";

else if (main1.variabl1545.lastIndexOf("," + variabl1501[i]

+ ",") >= 0)

variabl1507[i] = "0";

else

variabl1507[i] = "";

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库结构出错！");

}

for (int i1 = 0; i1 < variabl2517.length; i1++)

for (int j1 = 0; j1 < variabl1525.length; j1++) {

if (variabl2517[i1].toLowerCase().trim()

.equals(variabl1525[j1].toLowerCase().trim()))

variabl1287[j1] = i1;

}

}

static void variabl1009(String variabl1103, String variabl2669) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl1325 + "  from " + variabl1103

+ variabl2669;

rs = stat4.executeQuery(s1);

rs.last();

variabl1853 = rs.getRow();

String[][] variabl21970 = new String[variabl1853][variabl2651];

variabl2197 = new String[variabl1853 + 300][variabl2651];

rsmdt4 = rs.getMetaData();

int c = 0;

int b = 0;

while (c < variabl1853) {

rs.absolute(c + 1);

while (b < variabl2651) {

variabl21970[c][b] = rs.getString(b + 1);

variabl2197[c][b] = variabl21970[c][b];

b++;

}

c++;

b = 0;

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

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

for (int j = 0; j < variabl2651; j++)

variabl2197[i][j] = variabl21970[i][j];

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

}

static void variabl10091() {

try {

if (variabl1873.length() > 0) {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl1873;

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

rs.last();

int variabl18535 = rs.getRow();

variabl1837 = new String[variabl18535][2];

rs.absolute(1);

int numberOfColumns = rsmd.getColumnCount();

String s4 = "";

String s5 = "";

for (int i = 1; i <= variabl18535; i++) {

rs.absolute(i);

s4 = rs.getString(1).trim();

variabl1837[i - 1][0] = s4;

s5 = rs.getString(2).trim();

variabl1837[i - 1][1] = s5;

}

rs.close();

stat4.close();

cont4.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！");

}

}

static void variabl10092(String variabl22330, String variabl25179, int j9) {

try {

int u = 0;

if (variabl25179.indexOf("代码") >= 0) {

s2 = variabl25179.substring(0, variabl25179.length() - 2);

s1 = "select " + variabl25179 + "," + s2 + " from "

+ variabl22330;

} else if (variabl2429.lastIndexOf("," + variabl25179 + "代码表,") >= 0) {

s2 = variabl25179.substring(0, variabl25179.length() - 2);

s1 = "select " + variabl25179 + "," + variabl25179 + "代码"

+ " from " + variabl25179 + "代码表";

}

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

rs.last();

int numberOfColumns = rs.getRow();

rs.beforeFirst();

variabl1431[j9] = new String[numberOfColumns];

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

variabl1431[j9][i - 1] = rs.getString(1).trim();

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "2读取代码表数据出错！" + s1);

}

}

static void variabl2817002() {

variabl2403 = new JTextField[variabl1233];

variabl2463 = new JTextArea[variabl1233];

variabl2165 = new JLabel[variabl1233];

variabl2359 = new JComboBox[variabl1233];

variabl2311 = new List[variabl1233];

variabl1733 = new JTextComponent[variabl1233];

variabl1467 = new int[variabl1233];

variabl1431 = new String[variabl1233][2];

variabl1843 = variabl1233;

for (int j = 0; j < 线条数量; j++) {

int z1 = 0, z2 = 0;

if (线条位置[j][5] == 7) {

if (线条位置[j][0] == 线条位置[j][2]) {

if (线条位置[j][3] > 线条位置[j][1]) {

z1 = 线条位置[j][1];

z2 = 线条位置[j][3];

} else {

z1 = 线条位置[j][3];

z2 = 线条位置[j][1];

}

for (int i1 = z1; i1 < z2; i1++) {

JLabel variabl253301 = new JLabel("┃", 11);

variabl253301

.setBounds(线条位置[j][0] - 13, i1 - 7, 20, 20);

panel1.add(variabl253301);

i1 = i1 + 10;

}

}

if (线条位置[j][1] == 线条位置[j][3]) {

if (线条位置[j][2] > 线条位置[j][0]) {

z1 = 线条位置[j][0];

z2 = 线条位置[j][2];

} else {

z1 = 线条位置[j][2];

z2 = 线条位置[j][0];

}

for (int i1 = z1; i1 < z2; i1++) {

JLabel variabl253300 = new JLabel("━", 11);

variabl253300.setBounds(i1 - 10, 线条位置[j][1] - 11, 20,

20);

panel1.add(variabl253300);

i1 = i1 + 10;

}

}

} else {

if (variabl2231[j][0].length() > 0) {

JLabel variabl253302 = new JLabel(variabl2231[j][0]);

variabl253302.setBounds(线条位置[j][0], 线条位置[j][1], 线条位置[j][2],

线条位置[j][3]);

Font font = new Font(variabl2231[j][2], Font.BOLD,

线条位置[j][4]);

String s01 = variabl2231[j][4];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0)

&& (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01.trim().substring(0, 1));

variabl253302.setFont(font);

color1(s02, variabl253302);

panel1.add(variabl253302);

} else {

JLabel l = new JLabel(new ImageIcon(variabl2231[j][1]));

l.setBounds(线条位置[j][0], 线条位置[j][1], 线条位置[j][2], 线条位置[j][3]);

panel1.add(l);

}

}

}

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

JLabel variabl2533 = new JLabel(variabl1323[j][1], 11);

variabl2533.setBounds(Integer.parseInt(variabl1323[j][6]),

Integer.parseInt(variabl1323[j][7]),

Integer.parseInt(variabl1323[j][3]),

Integer.parseInt(variabl1323[j][2]));

panel1.add(variabl2533);

if ((variabl1651[j][4].equals("普通字段"))

|| (variabl1651[j][4].equals("语音文件名"))) {

if (variabl1651[j][4].equals("语音文件名")) {

variabl2823 = variabl1323[j][0];

variabl2821 = j;

}

variabl2403[j] = new JTextField("");

variabl2403[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

Font font1 = new Font(variabl1323[j][8], Font.BOLD,

Integer.parseInt(variabl1323[j][9]));

String s011 = variabl1323[j][10];

int s021 = 5;

if ((s011 != null) && (s011.length() > 0)

&& (s011.compareTo("0") >= 0)

&& (s011.compareTo("9") <= 0))

s021 = Integer.parseInt(s011.trim().substring(0, 1));

variabl2403[j].setFont(font1);

color2(s021, variabl2403[j]);

if (variabl2803.indexOf("," + j + ",") >= 0) {

variabl2403[j].setEditable(false);

}

panel1.add((Component) variabl2403[j]);

variabl2403[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {

c = 0;

}

});

variabl2403[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

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

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

int n1 = 0;

if (lbk == 1) {

list1.removeAll();

if ((variabl2429.lastIndexOf(","

+ variabl1323[b][0] + "表,") >= 0)

|| (variabl2429.lastIndexOf(","

+ variabl1323[b][0] + "代码表,") >= 0)) {

for (int i1 = 0; i1 < variabl1431[b].length; i1++)

list1.add(variabl1431[b][i1]);

} else if (variabl2429.lastIndexOf(","

+ variabl1323[b][0] + "代码表,") < 0) {

int u1 = 0;

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

int u2 = 0;

for (int k = 0; k < u1; k++) {

if (variabl2197[j][b] != null) {

} else

variabl2197[j][b] = " ";

if (variabl2197[j][b]

.toLowerCase()

.trim()

.equalsIgnoreCase(

list1.getItem(k)

.toLowerCase()

.trim())) {

u2++;

break;

}

}

if (u2 == 0) {

list1.add(variabl2197[j][b]);

u1++;

}

}

}

}

}

public void focusLost(final FocusEvent arg1) {

if (c > 0)

return;

if (main1.variabl1545.indexOf(","

+ variabl1501[variabl1467[b]] + ",") >= 0) {

variabl2031 = variabl1323[b][0] + "="

+ variabl2403[b].getText();

} else if (main1.variabl1539.indexOf(","

+ variabl1501[variabl1467[b]] + ",") < 0) {

variabl2031 = variabl1323[b][0] + "='"

+ variabl2403[b].getText() + "'";

}

Object s0 = arg1.getSource();

String s1 = s0.toString().substring(10, 33);

String s2 = "";

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

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

if ((c == 0) && (variabl1077 > 0)

&& (!variabl3623(c, b))) {

variabl2403[c].requestFocus(true);

return;

}

}

});

variabl2403[j].setText(variabl1507[j]);

variabl1733[j] = (JTextComponent) variabl2403[j];

variabl1467[j] = j;

} else if (variabl1651[j][4].equals("文本字段")) {

variabl2463[j] = new JTextArea("   ",

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

JScrollPane variabl1147 = new JScrollPane(variabl2463[j]);

variabl1147.setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

panel1.add((Component) variabl1147);

variabl2463[j].setText(variabl1507[j]);

variabl1733[j] = (JTextComponent) variabl2463[j];

variabl1467[j] = j;

} else if (variabl1651[j][4].equals("图像字段")) {

JLabel variabl2407 = new JLabel("   ");

variabl2407.setBackground(Color.BLUE);

variabl2407.setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

panel1.add(new JScrollPane(variabl2407));

panel1.add(variabl2407);

variabl2165[j] = variabl2407;

variabl1733[j] = (JTextComponent) variabl2463[j];

variabl1467[j] = j;

variabl2165[j].addMouseListener(new MouseAdapter() {

public void mousePressed(MouseEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

String s2 = "";

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

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

variabl18430 = b;

}

});

} else if (variabl1651[j][4].equals("组合框")) {

variabl2359[j] = new JComboBox();

variabl2403[j] = new JTextField();

variabl2359[j].setEditable(true);

variabl2359[j].setEnabled(true);

panel1.add((Component) variabl2359[j]);

variabl2359[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

variabl10092(variabl1651[j][3], variabl1323[j][0], j);

for (int i = 0; i < variabl1431[j].length; i++) {

variabl2359[j].addItem(variabl1431[j][i]);

}

variabl1733[j] = (JTextComponent) variabl2359[j].getEditor()

.getEditorComponent();

variabl1733[j].setText("");

variabl1467[j] = j;

} else if (variabl1651[j][4].equals("列表框")) {

variabl2311[j] = new List();

variabl2403[j] = new JTextField();

variabl2311[j].setFocusable(true);

variabl2311[j].setEnabled(true);

panel1.add((List) variabl2311[j]);

variabl2311[j].setBounds(Integer.parseInt(variabl1651[j][0]),

Integer.parseInt(variabl1651[j][1]),

Integer.parseInt(variabl1323[j][4]),

Integer.parseInt(variabl1323[j][5]));

variabl10092(variabl1651[j][3], variabl1323[j][0], j);

for (int i = 0; i < variabl1431[j].length; i++) {

variabl2311[j].add(variabl1431[j][i]);

}

variabl1467[j] = j;

}

}

}

public static void m(int p) throws LineUnavailableException,

UnsupportedAudioFileException, IOException {

int x = 0;

AudioInputStream audioInputStream = AudioSystem

.getAudioInputStream(new File(MUSIC_FILE));

AudioFormat audioFormat = audioInputStream.getFormat();

DataLine.Info dataLineInfo = new DataLine.Info(SourceDataLine.class,

audioFormat, AudioSystem.NOT_SPECIFIED);

SourceDataLine sourceDataLine = (SourceDataLine) AudioSystem

.getLine(dataLineInfo);

sourceDataLine.open();

sourceDataLine.start();

int count;

byte tempBuffer[] = new byte[1024];

x = 0;

while (x <= p / 2) {

tempBuffer = new byte[1024];

count = 0;

for (int i1 = 0; i1 < 1024; i1++) {

if (x < p / 2) {

tempBuffer[i1] = v[x];

x++;

count++;

}

}

if (count > 0)

sourceDataLine.write(tempBuffer, 0, count);

count = 0;

}

sourceDataLine.drain();

sourceDataLine.close();

sourceDataLine.stop();

}

public static void deleteData(int pos) {

if (pos == variabl1853 - 1)

variabl18531--;

for (int i = pos; i < variabl1853 - 1; i++) {

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

variabl2197[i][j] = variabl2197[i + 1][j];

}

}

variabl1853--;

}

public static void variabl23750() {

variabl18531 = 0;

variabl18532 = variabl18531;

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

if (main1.variabl1539.lastIndexOf("," + variabl1501[variabl1467[i]]

+ ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(s3.substring(j + 1, j + 2),

16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = { 0 };

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框"))

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

else {

variabl2311[i].select(variabl18531);

}

}

}

variabl2325.setEnabled(true);

variabl2255.setEnabled(false);

t.stop();

t = new Thread(xyz);

}

public static void variabl23250() {

if (variabl18531 < variabl1853 - 1) {

variabl18531++;

variabl18532 = variabl18531;

if (variabl18531 == variabl1853 - 1)

variabl2325.setEnabled(false);

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 0)) {

byte[] c0 = new byte[s3.length()];

for (int j = 0; j < s3.length() - 1; j++) {

int n1 = Integer.parseInt(s3.substring(j, j + 1),

16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c0[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c0 = {};

Icon icon = new ImageIcon(c0);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0))

if (!variabl1651[i][4].equals("列表框"))

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

else {

variabl2311[i].select(variabl18531);

}

}

}

}

variabl2255.setEnabled(true);

}

public static class Xyz implements Runnable {

public void run() {

String sss = variabl2197[variabl18532][variabl1467[variabl2821]];

int mn = variabl18532 + 1;

if (t0 == 1)

mn = variabl1853 - 1;

while (variabl18532 < mn) {

sss = variabl2197[variabl18532][variabl1467[variabl2821]];

try {

if ((sss != null) && (sss.length() > 0)) {

File file1 = new File(sss);

if (file1.exists()) {

InputStream in = new FileInputStream(sss);

AudioInputStream audioInputStream = AudioSystem

.getAudioInputStream(new File(sss));

AudioFormat audioFormat = audioInputStream

.getFormat();

DataLine.Info dataLineInfo = new DataLine.Info(

SourceDataLine.class, audioFormat,

AudioSystem.NOT_SPECIFIED);

SourceDataLine sourceDataLine = (SourceDataLine) AudioSystem

.getLine(dataLineInfo);

sourceDataLine.open(audioFormat);

sourceDataLine.start();

int count;

byte tempBuffer[] = new byte[1024];

while ((count = audioInputStream.read(tempBuffer,

0, tempBuffer.length)) != -1) {

if (count > 0) {

sourceDataLine.write(tempBuffer, 0, count);

x11++;

}

}

sourceDataLine.drain();

sourceDataLine.close();

}

}

} catch (FileNotFoundException e1) {

e1.printStackTrace();

} catch (IOException e1) {

e1.printStackTrace();

} catch (LineUnavailableException e1) {

e1.printStackTrace();

} catch (UnsupportedAudioFileException e1) {

e1.printStackTrace();

}

if (t0 == 0) {

t.stop();

variabl18532 = 10000;

}

variabl23250();

}

}

}

public static void variabl4063(String s0, int k) {

for (int i = 0; i < variabl1733.length; i++)

cont4 = main1.getConn();

try {

PreparedStatement pst4 = cont4.prepareStatement(s0);

char x1 = 10, x2 = 13;

int k2 = 1;

String s5 = "";

final JFileChooser fc = new JFileChooser(".\\");

fc.showDialog(new JLabel(), "请选择图片字段" + variabl2517[variabl1467[k]]

+ "的文件名");

if (fc.getSelectedFile() != null)

s5 = fc.getSelectedFile().toString();

else {

JOptionPane.showMessageDialog(null, "未选择图片文件，原图不变！");

return;

}

FileInputStream f1 = new FileInputStream(s5);

pst4.setBinaryStream(k2, f1, f1.available());

k2++;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

byte[] c0 = new byte[s5.length()];

Icon icon = new ImageIcon(c0);

variabl2165[k].setOpaque(true);

variabl2165[k].setBackground(Color.PINK);

variabl2165[k].setIcon(icon);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

public static boolean variabl3623(int c1, int b1) {

c = c1;

b = b1;

int bz1 = 0;

String sb = "", bz = "";

String[] sb1 = null;

try {

for (int i1 = 0; i1 < variabl1077; i1++) {

if (variabl1201[i1][0].toLowerCase().trim()

.equals(variabl1323[b][0].toLowerCase().trim())) {

bz1 = main1.variabl1545.indexOf(","

+ variabl1501[variabl1467[b]] + ",");

if (bz1 >= 0) {

if ((variabl1201[i1][1].trim().length() > 0)

&& (Double

.parseDouble(variabl2403[b].getText()) > Double

.parseDouble(variabl1201[i1][1]))) {

bz = variabl2403[b].getText() + ">最大值"

+ Double.parseDouble(variabl1201[i1][1]);

c = b;

} else if ((variabl1201[i1][2].trim().length() > 0)

&& (Double

.parseDouble(variabl2403[b].getText()) < Double

.parseDouble(variabl1201[i1][2]))) {

bz = variabl2403[b].getText() + "<最小值"

+ variabl1201[i1][2];

c = b;

} else if ((variabl1201[i1][3].trim().length() > 0)) {

if (variabl1201[i1][3].indexOf("-") > 0) {

sb1 = variabl1201[i1][3].split("-");

if ((Double.parseDouble(variabl2403[b]

.getText()) < Double

.parseDouble(sb1[0]))) {

bz = variabl2403[b].getText() + "<范围下限"

+ sb1[0];

c = b;

}

if ((Double.parseDouble(variabl2403[b]

.getText()) > Double

.parseDouble(sb1[1]))) {

bz = variabl2403[b].getText() + ">范围上限"

+ sb1[1];

c = b;

}

} else if (variabl1201[i1][3].indexOf("[") >= 0) {

bz = variabl1201[i1][3].trim().substring(1,

variabl1201[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (variabl2403[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (variabl2403[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

} else if (variabl1201[i1][3].indexOf(",") > 0) {

if (("," + variabl1201[i1][3] + ",")

.indexOf("," + variabl2403[b].getText()

+ ",") < 0) {

c = b;

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

}

}

} else if (variabl1201[i1][4].trim().length() > 0) {

int[][] m = new int[2][variabl1843];

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

m[0][i] = i;

m[1][i] = variabl1323[i][0].length();

}

int d = 0, e = 0;

for (int i = 0; i < m[1].length; i++)

for (int j = i + 1; j < m[1].length; j++)

if (m[1][i] < m[1][j]) {

e = m[0][i];

m[0][i] = m[0][j];

m[0][j] = e;

e = m[1][i];

m[1][i] = m[1][j];

m[1][j] = e;

}

sb = variabl1201[i1][4];

for (int i = 0; i < m[1].length; i++)

sb = sb.replaceAll(variabl1323[m[0][b]][0],

variabl2403[m[0][b]].getText());

if (!tenanceEval.tenanceeval(sb)) {

bz = variabl2403[b].getText() + "不满足条件："

+ variabl1201[i1][4];

c = b;

}

} else

c = 0;

} else if (main1.variabl1543.lastIndexOf(","

+ variabl1501[variabl1467[b]] + ",") >= 0) {

if ((variabl1201[i1][3].trim().length() > 0)) {

if (variabl1201[i1][3].indexOf("[") >= 0) {

bz = variabl1201[i1][3].trim().substring(1,

variabl1201[i1][3].length() - 1);

sb1 = bz.split(",");

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (sb1[i].indexOf("^") >= 0) {

if (variabl2403[b].getText().indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = -1;

break;

}

}

}

if (bz1 == -1) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

bz1 = 0;

for (int i = 0; i < sb1.length; i++) {

if (variabl2403[b].getText()

.indexOf(

sb1[i].substring(1,

sb1[i].length())) >= 0) {

bz1 = 1;

break;

}

}

if (bz1 == 0) {

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

c = b;

}

} else if (variabl1201[i1][3].indexOf(",") > 0) {

if (("," + variabl1201[i1][3] + ",")

.indexOf("," + variabl2403[b].getText()

+ ",") < 0) {

c = b;

bz = variabl2403[b].getText() + "不满足"

+ variabl1201[i1][3] + "范围要求！";

}

}

}

} else

c = 0;

}

if (bz.length() > 0)

break;

}

} catch (Exception e1) {

JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求，请修改接口参数表！"

+ e1);

}

if (bz.length() > 0) {

if (c > 0) {

JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查！"

+ bz);

bz = "";

return false;

}

}

return true;

}

}

转载本文请联系原作者获取授权，同时请注明本文来自程学先科学网博客。
链接地址：https://blog.sciencenet.cn/blog-2551-1121578.html

上一篇：管理信息系统软件生产线源码80-81
下一篇：管理信息系统软件生产线源码84-86