版本1

78.源码78，部件程序，表单程序（单记录数据维护程序），包括图形字段数据维护程序，可变换标签，用组合框显示代码，可实现数据完整性、数据安全性保护。

/**

 * 程序文件名：dataTenance5.java

 * 作者：程学先 

 * 功能：表单程序（单记录数据维护程序），包括图形字段数据维护程序，

 * 可变换标签，用组合框显示代码，可实现数据完整性、数据安全性保护。

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

 * 面向对象的秘诀或创新是多工作“集成”或"冗余"，"冗余"指在设计时不只是根据当前的需求

 * 设计一对一的代码，而是再加上类似界面、类似功能的其他代码，封装在一起，

 * 在每次应用时选择部分方法与数据为当前任务服务，不一定用到其全部的方法和数据。

 * 其他的方法与数据将在其他类似界面、类似任务重调用。

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

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

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

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

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

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

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

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

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

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

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

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

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

 * 用途：以文本框、组合框、按钮等构成单记录数据维护界面作数据录入、

 * 修改数据库中数据、删除数据库中数据等使用。 

 * 完成日期：2014年1月20日

 * 被调用语句：dataTenance5.means(parameter);

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

 * 可选择参数：“窗口宽”、“窗口高” 、“要求按钮号表”、“字段号表”、“接口参数表名称”。

 * 本程序允许借用表单设计器或者工具程序completeTool.java定义数据完整性条件、

 * secureTool.java定义数据安全要求。

 * 所有数据存放在一个文件中，文件名通过参数带入。

 * secureTool.java定义安全性要求，数据以2,打头，在文件中占一行。

 * 如果文件中缺少安全性要求数据，则不做安全性检查。只要有一个安全性要求，就要全面控制。

 * 其数据依次为用户名、字段名、权限：i录入、u改、d删、a全部、q查

 * 注意一个字段可以有多个权限，之间用逗号分隔，例如i,u,表示有录入和修改权，

 * 一个字段全部权限必须写在一行内。

 * completeTool.java定义完整性要求，数据以2,打头，在文件中占一行

 * 如果文件中缺少完整性要求数据，则不做完整性检查。

 * 所定义数据依次为：字段名、最大值、最小值、值域、条件表达式。

 * 操作方法与注意事项：以上所有参数均为字符串数据类型的全局变量。

 * 最大值、最小值、条件表达式只对数字数据各类型检查并控制。

 * 值域可对数字数据类型，也可对各字符数据类型。本程序允许有三种格式

 * 1）最小值-最大值，只对数字数据类型。

 * 2）值1,值2,……,值n,    表示只能是其中之一

 * 3）[值1,值2,……,值n,]   表示只要包含其中之一。在值前可以加^，表示该值不得包含在内。

 * 关键字段名为识别与区分记录的主要标志，不允许重复，不允许为空，可以是单一字段，

 * 也可以是多个字段，如果是多字段，以英文逗号分隔。

 * 本部件预设的按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、

 * “修改存盘”、“删除”、“退出”共 10 个。

 * 通过“要求按钮号表”提供所需要显示的按钮在该部件原设计的界面 中的顺序号，各按钮号用逗号分隔。 

 * 做数据录入程序模块使用时一般选择“存盘”、“清屏”、“退出”等按钮，选择按钮号为：“5,6,9”。

 * 做数据修改程序模块使用时，一般选择“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“查询”、

 * “修改存盘”、“退出”等按钮，选择按钮号为：“0,1,2,3,4,7,8,9”。

 * 每录入一条记录后必须点击“存盘”按钮。

 * 如果存在image字段，在点击“存盘”按钮或“修改存盘”按钮后，将提问图片文件名，

 * 之后将文件名找到并填入。修改操作时，如果点击“取消”，不提供图片文件名或文件无效，

 * 原来的图片将保留不变。

 * 本程序可适应一表多图形字段的数据维护。

 * 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。

 * 每删除一条记录，必须点击“删除”按钮。

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

public class dataTenance5 extends JFrame {

static dataTenance5 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;

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 控件个数 = 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;

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;

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;

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[] sw = new String[11];

static int 按钮数 = 0, 按钮宽 = 0;

private static int 按钮定义标志;

private static HashSet set01 = new HashSet();

public static String sd0;

static void means(String parameter[]) {

列数 = 0;

当前列号 = 0;

字段名字串 = "";

记录条数 = 0;

记录条数1 = 0;

要求按钮号表 = "";

实际按钮数 = 0;

要求字段号表 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

b = 0;

c = 0;

控件个数 = 0;

字符宽度 = 18;

字符高度 = 20;

位置参数条数 = 0;

完整性参数条数 = 0;

安全性参数条数 = 0;

字号 = 9;

颜色 = 5;

字体 = "宋体";

起始左边距 = 0;

起始到顶距 = 0;

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

文本域宽度 = 0;

文本域高度 = 0;

行间距离 = 0;

需求面积 = 0;

原窗口宽 = 窗口宽;

原窗口高 = 窗口高;

文本区宽度 = 0;

大数据个数 = 0;

列名长度 = 0;

表名表 = "";

字典表名 = "";

ann = 0;

按钮定义标志 = 0;

ODBC数据源 = main1.ODBC数据源;

list0 = new ArrayList<String>();

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

username = main1.username;

按钮宽 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3;

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

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(";");

按钮集[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, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);// 宽度参数

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

窗口宽 = m1;

原窗口宽 = m1;

窗口高 = m2;

}

} catch (Exception e2) {

}

panel1 = new JPanel(true);

frame1 = new dataTenance5();

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];

panel1.setLayout(null); // 空面板

表名表 = "," + 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 (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];

String[] t5 = 要求按钮号表.split(",");

String[] 临时按钮参数 = new String[按钮集.length]; // 最多留30个按钮空位

按钮位置 = new int[按钮数][15];

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;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1) // 参数由completeTool等二个程序产生

list0.add(tempStr); // 将文件内容全部读到集合中，先统计参数中不同类型数据条数

}

String 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("2,"))

安全性参数条数++;

if (sk.substring(0, 2).equals("3,"))

完整性参数条数++;

}

} // 以上完成对参数表数据分类统计条数

实际按钮数 = k3;

if (k3 > 0) {

按钮定义标志 = 1;

}

if (位置参数条数 > 0) {

位置参数表 = new String[位置参数条数][13];

标签位置 = new String[位置参数条数][6];// 0、1字段左边距到顶距，2字段类型

} else { // 无接口参数表

位置参数表 = new String[t2.length][13];

标签位置 = new String[t2.length][6];

}

安全性参数表 = new String[安全性参数条数][4];

完整性参数表 = new String[完整性参数条数][6];

int m3 = 0;

m1 = 0;

m2 = 0;

int y = 2, n1 = 0;

String s = "";

s2 = ",";

int 最大宽度1 = 0;

窗口宽 = 0;

for (int i = 0; i < list.size(); i++) {

s = list.get(i); // 再取出接口参数

if (d2 == 0) {

if (s.substring(0, 2).equals("2,")) { // 安全参数

y = 2;

n1 = 0;

int n0 = 0;

while (s.indexOf("。。") > 0)

s = s.replaceAll("。。", "。 。"); // 如果某项为空值，变成空格

String[] sf = s.split("。");

安全性参数表[m2][0] = sf[0].substring(2,

sf[0].length());

安全性参数表[m2][1] = sf[1]; // 表名或字段名

安全性参数表[m2][2] = sf[2]; // 权限

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()

.equalsIgnoreCase(表名

.toLowerCase())))) { // 字段名为空、为星号、为表名表示是全表单权限，决定按钮显示否

if (安全性参数表[m2][2].indexOf("i") < 0) { // 不包含i录入权

要求按钮号表 = 要求按钮号表.replaceAll("5,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("u") < 0) { // 不包含u修改权

要求按钮号表 = 要求按钮号表.replaceAll("7,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("d") < 0) { // 不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("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,")) { // 完整性参数

while (s.indexOf("。。") > 0)

s = s.replaceAll("。。", "。 。"); // 如果某项为空值，变成空格

完整性参数表[m3] = s.split("。");

完整性参数表[m3][0] = 完整性参数表[m3][0].substring(2,

完整性参数表[m3][0].length());

m3++;

}

}

位置数据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 (t2[j].toLowerCase().equalsIgnoreCase(

安全性参数表[i][1].toLowerCase())) { // 字段名相同

if (安全性参数表[i][0].equals("只读"))

限只读字段号表 = 限只读字段号表 + j + ",";

安全性参数表[i][1] = j + ""; // 字段号

}

}

}

if (窗口宽 == 0)

窗口宽 = 原窗口宽;

数据表查询结构001(表名); // 得到数据表结构，产生全部字段名、数据类型、宽度

数据表查询数据001(表名); // 求当前表中所有数据

if (位置参数条数 == 0)

计算文本框001();

计算文本框002(); // 定义按钮位置

安装文本框002();

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

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0)) {

文本数组[i].setText(一条空记录[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;

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);

}

});

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

第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);

panel1.add(第一条);

}

下一条 = new JButton(按钮集[1]);

下一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 < 记录条数 - 1) {

记录条数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);

}

});

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

下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);

panel1.add(下一条);

}

最后一条 = new JButton(按钮集[2]);

最后一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数 > 1)

记录条数1 = 记录条数 - 1; // 记录指针

else

记录条数1 = 0;

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(false);

上一条.setEnabled(true);

}

});

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

最后一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);

panel1.add(最后一条);

}

上一条 = new JButton(按钮集[3]);

上一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 > 0) {

记录条数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);

}

});

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

上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);

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]);

panel1.add(浏览);

}

存盘 = new JButton(按钮集[5]);

存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[控件个数];

String[] s0 = new String[控件个数];

String s = "";

int b = 0;

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

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0) {

if ((标签位置[i][4].equals("组合框"))

|| (标签位置[i][4].equals("列表框"))) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

s = (String) 组合框[当前列号].getSelectedItem();

else {

s = 列表框[i].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;

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

if (!完整性检查(c, i, 1)) { // 1表示为存盘时的检查

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++) {

int a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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 (";

sd = "";

for (int j = 0; j < 关键字段名.length; j++) {

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

if (文本数组号[i] == 关键字序号[j]) {

if ((文本数组值[i] == null)

|| (文本数组值[i].trim().length() == 0)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + 文本数组值[i].trim() + ",";

break;

}

}

}

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 ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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) + ")";

stat4.executeUpdate(s1);

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]);

panel1.add(存盘);

}

清屏 = new JButton(按钮集[6]);

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0)) {

文本数组[i].setText(一条空记录[i]);

}

}

}

});

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

清屏.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);

panel1.add(清屏);

}

修改存盘 = new JButton(按钮集[7]);

修改存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

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

if (!完整性检查(c, i, 1)) { // 1表示为存盘时的检查

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

int[] x0 = new int[控件个数];

String[] s0 = new String[控件个数];

String s = "";

for (int i = 0; i < 文本数组.length; i++)

if (main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0) {

if ((标签位置[i][4].equals("组合框"))

|| (标签位置[i][4].equals("列表框"))) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

s = (String) 组合框[当前列号].getSelectedItem();

else {

s = 列表框[i].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, "关键字不存在，请改为生成数据录入语句！");

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 ";

b = 0;

d2: for (int j = 0; j < 文本数组.length; j++) {

int a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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);

char x1 = 10, x2 = 13;

int k2 = 1;

for (int i = 0; i < 文本数组.length; i++) {

String fieldname = 列名[文本数组号[i]];

String s6 = "";

/*

* if

* (main1.图形数据类型.lastIndexOf(","+列数据类型[文本数组号[i]]+",")>=

* 0){ final JFileChooser fc = new JFileChooser(".\\");

* fc.showOpenDialog(null); if

* (fc.getSelectedFile()!=null)

* s6=fc.getSelectedFile().toString(); else {

* JOptionPane.showMessageDialog( null,

* "未选择图片文件，不能录入！"); continue; } FileInputStream f1 =

* new FileInputStream(s6);

* pst4.setBinaryStream(k2,f1,f1.available()); k2++; }

*/

}

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 (按钮位置[7][0] > 0) {

修改存盘.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);

panel1.add(修改存盘);

}

删除 = new JButton(按钮集[8]);

删除.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();

deleteData(记录条数1);

set01.remove(sd0);

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 (按钮位置[8][0] > 0) {

删除.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);

panel1.add(删除);

}

退出 = new JButton(按钮集[9]);

按钮数组[9] = 退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

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

退出.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[9][3]);

panel1.add(退出);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

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

文本数组[i].setText(表格数据[0][文本数组号[i]]);

}

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;

位置参数条数 = 列数;

int 文本控件行数 = 1;

文本区宽度 = 窗口宽 - 80;

起始到顶距 = 20;

int y1 = 起始左边距;

int y2 = 起始到顶距;

int 最大标签宽度 = 0;

if ((大数据个数 == 0) && (列数 * 字符高度 < 窗口高 - 120)) {

文本控件行数 = 列数;

行间距离 = (窗口高 - 150 - 列数 * 字符高度) / (列数 + 1);

for (int j = 0; j < 列数; j++) { // 求最大标签宽度,位置参数表[j][1]:字段名

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);

String s1 = "select " + 字段名字串 + " from " + 数据表名001;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[列数];

列数据类型 = new String[列数];

列数据宽度 = new int[列数];

一条空记录 = new String[列数];

标签位置 = new String[列数][6];

位置参数表 = new String[列数][15];

大数据个数 = 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];

位置参数表[i][1] = 列名[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 (main1.文本数据类型.indexOf("," + 列数据类型[i] + ",") >= 0) {

标签位置[i][4] = "文本字段";

大数据个数++;

} else if (列数据类型[i].equalsIgnoreCase("image")) {

标签位置[i][4] = "图像字段";

大数据个数++;

} else

标签位置[i][4] = "普通字段";

if (列数据类型[i].indexOf("smalldatetime") == 0)

一条空记录[i] = "2001-01-01 00:00:00";

// 以下二类型在JAVA中不被识别，本处考虑今后的扩展，暂时保留

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 e2) {

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) { // 查数据表数据

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串 + "  from " + 数据表名001;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

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, "读取数据库数据出错！" + 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++) {

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] = new JTextField("");

文本框[j].setBounds(Integer.parseInt(标签位置[j][0]),

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

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

Integer.parseInt(位置参数表[j][5]));

if (限只读字段号表.indexOf("," + j + ",") >= 0) {

文本框[j].setEditable(false);

}

文本框[j].setText(一条空记录[j]);

文本数组[j] = (JTextComponent) 文本框[j];

文本数组号[j] = j;

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().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;

}

}

}

public void focusLost(final FocusEvent arg1) {// 失去焦点

if (c > 0)

return;

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) && (!完整性检查(c, b, 0))) { // 0表示为输入时的检查

文本框[c].requestFocus(true); // 返回原来文本框

return;

}

}

});

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

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

}

}

}

public static boolean 完整性检查(int c1, int b1, int k) {

c = c1;

b = b1; // k=1表示为存盘时的检查,k=0表示输入数据时的检查

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;

}

}

} // 数字数据类型可有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] + "范围要求！";

}

}

}

}

}

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;

}

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 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];

}

}

记录条数--;

}

}

79.源码79，部件程序，表单程序（单记录数据维护程序），可应用deviseTool自定义界面，包括多图形字段数据维护，可变换标签，可用组合框显示代码，可实现数据完整性、数据安全性保护。

/**

 * 程序文件名：dataTenance6.java

 * 作者：程学先 

 * 功能：表单程序（单记录数据维护程序），可应用deviseTool自定义界面，

 * 包括多图形字段数据维护，可变换标签，可用组合框显示代码，可实现数据完整性、数据安全性保护。

 * 完成日期：2014年1月20日

 * 被调用语句：dataTenance6.means(parameter);

 * 数据完整性、数据安全性要求由completeTool.java、secureTool.java等程序定义。

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

 * 可选择参数：“窗口宽”、“窗口高” 、“要求按钮号表”、“字段号表”、“接口参数表名称”。

 * 本部件预设的按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、

 * “修改存盘”、“删除”、“退出”共 10 个。

 * 如果存在image字段，在点击“存盘”按钮或“修改存盘”按钮后，将提问图片文件名，

 * 之后将文件名找到并填入图片数据。如果不提供图片文件名或文件无效，原有图片不变。

 * 如果表中且字段号表中规定的字段中有多个图形字段，将逐一提问图形文件名并请逐一回答，

 * 注意提问中图形文件相关字段名的提示。

 * 每修改一条记录，必须点击“修改存盘”按钮，将改后记录填入表内。

 * 每删除一条记录，必须点击“删除”按钮。

 * secureTool.java定义安全性要求，数据以2,打头，在文件中占一行。

 * 如果文件中缺少安全性要求数据，则不做安全性检查。只要有一个安全性要求，就要全面控制。

 * 其数据依次为用户名、字段名、权限：i录入、u改、d删、a全部、q查

 * 注意一个字段可以有多个权限，之间用逗号分隔，例如i,u,表示有录入和修改权，

 * 一个字段全部权限必须写在一行内。

 * completeTool.java定义完整性要求，数据以2,打头，在文件中占一行

 * 如果文件中缺少完整性要求数据，则不做完整性检查。

 * 所定义数据依次为：字段名、最大值、最小值、值域、条件表达式。

 * 操作方法与注意事项：以上所有参数均为字符串数据类型的全局变量。

 * 最大值、最小值、条件表达式只对数字数据各类型检查并控制。

 * 值域可对数字数据类型，也可对各字符数据类型。本程序允许有三种格式

 * 1）最小值-最大值，只对数字数据类型。

 * 2）值1,值2,……,值n,    表示只能是其中之一

 * 3）[值1,值2,……,值n,]   表示只要包含其中之一。在值前可以加^，表示该值不得包含在内。

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

import javax.sound.sampled.*;

public class dataTenance6 extends JFrame {

static dataTenance6 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;

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;

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;

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[] sw = new String[11];

static int 按钮数 = 0, 按钮宽 = 0;

private static int 按钮定义标志;

private static HashSet set01 = new HashSet();

public static String sd0;

static void means(String parameter[]) {

列数 = 0;

当前列号 = 0;

字段名字串 = "";

记录条数 = 0;

记录条数1 = 0;

列号 = 0;

要求按钮号表 = "";

实际按钮数 = 0;

要求字段号表 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

b = 0;

c = 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;

ODBC数据源 = main1.ODBC数据源;

list0 = new ArrayList<String>();

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

username = main1.username;

按钮宽 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3; 

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

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(";");

按钮集[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, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);// 宽度参数

m2 = Integer.parseInt(parameter[18]);

}

if (m1 > 0) {

if (m2 < 80) {

m1 = m1 * 10;

m2 = m2 * 10;

}

窗口宽 = m1;

原窗口宽 = m1;

窗口高 = m2;

}

} catch (Exception e2) {

}

panel1 = new JPanel(true);

frame1 = new dataTenance6();

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];

panel1.setLayout(null); // 空面板

表名表 = "," + 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 (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];

String[] t5 = 要求按钮号表.split(",");

String[] 临时按钮参数 = new String[按钮集.length];

按钮位置 = new int[按钮数][15];

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;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1) // 参数由completeTool等三个程序产生

list0.add(tempStr); // 将文件内容全部读到集合中，先统计参数中不同类型数据条数

}

String 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,"))

完整性参数条数++;

}

} // 以上完成对参数表数据分类统计条数

实际按钮数 = k3;

if (k3 > 0) {

按钮定义标志 = 1;

}

if (位置参数条数 > 0) {

位置参数表 = new String[位置参数条数][13];

标签位置 = new String[位置参数条数][6];// 0、1字段左边距到顶距，2字段类型

} else {

位置参数表 = 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) {

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];

安全性参数表[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)

&& ((安全性参数表[m2][1].length() == 0) 

|| (安全性参数表[m2][1].equals("*")) || (安全性参数表[m2][1]

.toLowerCase().equalsIgnoreCase(表名.toLowerCase())))) { // 字段名为空、为星号、为表名表示是全表单权限，决定按钮显示否

if (安全性参数表[m2][2].indexOf("i") < 0) { // 不包含i录入权

要求按钮号表 = 要求按钮号表.replaceAll("5,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("u") < 0) { // 不包含u修改权

要求按钮号表 = 要求按钮号表.replaceAll("7,", "");

n0 = 1;

}

if (安全性参数表[m2][2].indexOf("d") < 0) { // 不包含d删除权

要求按钮号表 = 要求按钮号表.replaceAll("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,", ""); // 去掉删除按钮

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; // 重定义完整性参数条数

}

}

位置数据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 (t2[j].toLowerCase().equalsIgnoreCase(

安全性参数表[i][1].toLowerCase())) { // 字段名相同

if (安全性参数表[i][0].equals("只读"))

限只读字段号表 = 限只读字段号表 + j + ",";

安全性参数表[i][1] = j + ""; 

}

}

}

if (窗口宽 == 0)

窗口宽 = 原窗口宽;

数据表查询结构001(表名); // 得到数据表结构，产生全部字段名、数据类型、宽度

数据表查询数据001(表名); // 求当前表中所有数据

if (位置参数条数 == 0)

计算文本框001();

计算文本框002(); // 是否已经定义了按钮位置

安装文本框002();

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]) {

if (表格数据[i0][文本数组号[i]] == null) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + 表格数据[i0][文本数组号[i]].trim() + ",";

break;

}

}

}

set01.add(sd);

}

第一条 = new JButton(按钮集[0]);

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

记录条数1 = 0;

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);

}

});

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

第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);

panel1.add(第一条);

}

下一条 = new JButton(按钮集[1]);

下一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 < 记录条数 - 1) {

记录条数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);

}

});

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

下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);

panel1.add(下一条);

}

最后一条 = new JButton(按钮集[2]);

最后一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数 > 1)

记录条数1 = 记录条数 - 1; 

else

记录条数1 = 0;

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(false);

上一条.setEnabled(true);

}

});

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

最后一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);

panel1.add(最后一条);

}

上一条 = new JButton(按钮集[3]);

上一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (记录条数1 > 0) {

记录条数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);

}

});

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

上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);

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]);

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][4].equals("列表框"))) {

当前列号 = i; 

if (标签位置[i][4].equals("组合框"))

s = (String) 组合框[当前列号].getSelectedItem();

else {

s = 列表框[i].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;

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

if (!完整性检查(c, i, 1)) { // 1表示为存盘时的检查

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++) {

int a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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 (";

sd = "";

for (int j = 0; j < 关键字段名.length; j++) {

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

if (文本数组号[i] == 关键字序号[j]) {

if ((文本数组值[i] == null)

|| (文本数组值[i].trim().length() == 0)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + 文本数组值[i].trim() + ",";

break;

}

}

}

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 ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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]);

panel1.add(存盘);

}

清屏 = new JButton(按钮集[6]);

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if ((main1.图形数据类型.lastIndexOf("," + 列数据类型[文本数组号[i]] + ",") < 0))

文本数组[i].setText(一条空记录[i]);

}

}

});

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

清屏.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);

panel1.add(清屏);

}

修改存盘 = new JButton(按钮集[7]);

修改存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

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

if (!完整性检查(c, i, 1)) { // 1表示为存盘时的检查

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String s;

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][4].equals("列表框"))) {

当前列号 = i;

if (标签位置[i][4].equals("组合框"))

s = (String) 组合框[当前列号].getSelectedItem();

else {

s = 列表框[i].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, "关键字不存在，请改为生成数据录入语句！");

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++) {

int a1 = 0;

for (int i = 0; i < 安全性参数条数; i++) {

if ((安全性参数表[i][1] != null)

&& (安全性参数表[i][2] != null))

if ((Integer.parseInt(安全性参数表[i][1]) == j)

&& (安全性参数表[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);

char x1 = 10, x2 = 13;

int k2 = 1;

for (int i = 0; i < 文本数组.length; i++) {

String fieldname = 列名[文本数组号[i]];

String s6 = "";

}

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 (按钮位置[7][0] > 0) {

修改存盘.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);

panel1.add(修改存盘);

}

删除 = new JButton(按钮集[8]);

删除.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();

deleteData(记录条数1);

set01.remove(sd0);

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 (按钮位置[8][0] > 0) {

删除.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);

panel1.add(删除);

}

退出 = new JButton(按钮集[9]);

按钮数组[9] = 退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

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

退出.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[9][3]);

panel1.add(退出);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

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

文本数组[i].setText(表格数据[0][文本数组号[i]]);

}

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);

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 (main1.文本数据类型.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 e2) {

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) { // 查数据表数据

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + 字段名字串 + "  from " + 数据表名001;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

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, "读取数据库数据出错！" + 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++) {

JLabel 标签 = new JLabel(位置参数表[j][1], 11);

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

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

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

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

Font font = new Font(位置参数表[j][8], Font.BOLD,

Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小

String s01 = 位置参数表[j][10];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01);

标签.setFont(font);

color1(s02, 标签);// 设置颜色

panel1.add(标签);

if (标签位置[j][4].equals("普通字段")) {

文本框[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);

文本框[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 = "";

int n1 = 0;

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

s2 = "[," + 标签位置[i][0].trim() + ","

+ 标签位置[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

}

public void focusLost(final FocusEvent arg1) {// 失去焦点

if (c > 0)

return;

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) && (!完整性检查(c, b, 0))) { // 0表示为输入时的检查

文本框[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]));

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);

文本域[j].setFont(font1);

color3(s021, 文本域[j]);// 设置颜色

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;

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

}

}

}

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];

}

}

记录条数--;

}

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;

}

}

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, int k) {

c = c1;

b = b1; // k=1表示为存盘时的检查,k=0表示输入数据时的检查

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())) { // 当前字段,获得焦点时记录

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

78.源码78，部件程序，表单程序（单记录数据维护程序），包括图形字段数据维护程序，可变换标签，用组合框显示代码，可实现数据完整性、数据安全性保护。

/** 

 * 程序文件名：dataTenance5.java 

 * 作者：程学先  

 * 功能：包括图形字段数据维护程序，可变换标签，用组合框显示代码，可实现数据完整性、数据安全性保护。 

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

public class dataTenance5 extends JFrame {

static dataTenance5 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;

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 variabl1843 = 0;

private static JLabel[] variabl2165 = null;

private static int variabl1647 = 15, variabl1849 = 20;

private static String[] variabl2405;

private static JButton variabl2375, variabl2325, variabl1971, variabl2255,

variabl2531, variabl2611, variabl2601, variabl1697, variabl2633,

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;

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;

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;

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 = "";

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[] sw = new String[11];

static int variabl2851 = 0, variabl2339 = 0;

private static int variabl2833;

private static HashSet set01 = new HashSet();

public static String sd0;

static void means(String parameter[]) {

variabl2651 = 0;

variabl1739 = 0;

variabl1325 = "";

variabl1853 = 0;

variabl18531 = 0;

variabl1187 = "";

variabl1371 = 0;

variabl1153 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

b = 0;

c = 0;

variabl1843 = 0;

variabl1647 = 18;

variabl1849 = 20;

variabl1233 = 0;

variabl1077 = 0;

variabl1069 = 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;

variabl2833 = 0;

variabl1091 = main1.variabl1091;

list0 = new ArrayList<String>();

variabl1837 = new String[0][0];

username = main1.username;

variabl2339 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3;

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

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(";");

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, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);

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 = new JPanel(true);

frame1 = new dataTenance5();

frame1.setTitle("单记录数据维护程序                           作者：程学先");

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

frame1.getContentPane().add(panel1, null);

list1 = new List();

list = new ArrayList<String>();

variabl1597 = main1.variabl1537 + main1.variabl1539;

variabl2185 = new JButton[20];

panel1.setLayout(null);

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 (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];

String[] t5 = variabl1187.split(",");

String[] variabl2831 = new String[variabl2405.length];

variabl1885 = new int[variabl2851][15];

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;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1)

list0.add(tempStr);

}

String 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("2,"))

variabl1069++;

if (sk.substring(0, 2).equals("3,"))

variabl1077++;

}

}

variabl1371 = k3;

if (k3 > 0) {

variabl2833 = 1;

}

if (variabl1233 > 0) {

variabl1323 = new String[variabl1233][13];

variabl1651 = new String[variabl1233][6];

} 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 = ",";

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("2,")) {

y = 2;

n1 = 0;

int n0 = 0;

while (s.indexOf("。。") > 0)

s = s.replaceAll("。。", "。 。");

String[] sf = s.split("。");

variabl1197[m2][0] = sf[0].substring(2,

sf[0].length());

variabl1197[m2][1] = sf[1];

variabl1197[m2][2] = sf[2];

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()

.equalsIgnoreCase(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,")) {

while (s.indexOf("。。") > 0)

s = s.replaceAll("。。", "。 。");

variabl1201[m3] = s.split("。");

variabl1201[m3][0] = variabl1201[m3][0]

.substring(2,

variabl1201[m3][0].length());

m3++;

}

}

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 (t2[j].toLowerCase().equalsIgnoreCase(

variabl1197[i][1].toLowerCase())) {

if (variabl1197[i][0].equals("只读"))

variabl2803 = variabl2803 + j + ",";

variabl1197[i][1] = j + "";

}

}

}

if (variabl2483 == 0)

variabl2483 = variabl1745;

variabl1005(variabl2603);

variabl1009(variabl2603);

if (variabl1233 == 0)

variabl1037();

variabl2819002();

variabl2817002();

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

if ((main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0)) {

variabl1733[i].setText(variabl1507[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;

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);

}

});

if (variabl1885[0][0] > 0) {

variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],

variabl1885[0][2], variabl1885[0][3]);

panel1.add(variabl2375);

}

variabl2325 = new JButton(variabl2405[1]);

variabl2325.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 < variabl1853 - 1) {

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);

}

});

if (variabl1885[1][0] > 0) {

variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],

variabl1885[1][2], variabl1885[1][3]);

panel1.add(variabl2325);

}

variabl1971 = new JButton(variabl2405[2]);

variabl1971.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl1853 > 1)

variabl18531 = variabl1853 - 1;

else

variabl18531 = 0;

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(false);

variabl2255.setEnabled(true);

}

});

if (variabl1885[2][0] > 0) {

variabl1971.setBounds(variabl1885[2][0], variabl1885[2][1],

variabl1885[2][2], variabl1885[2][3]);

panel1.add(variabl1971);

}

variabl2255 = new JButton(variabl2405[3]);

variabl2255.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 > 0) {

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);

}

});

if (variabl1885[3][0] > 0) {

variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],

variabl1885[3][2], variabl1885[3][3]);

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]);

panel1.add(variabl2531);

}

variabl2611 = new JButton(variabl2405[5]);

variabl2611.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

int[] x0 = new int[variabl1843];

String[] s0 = new String[variabl1843];

String s = "";

int b = 0;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0) {

if ((variabl1651[i][4].equals("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

s = (String) variabl2359[variabl1739]

.getSelectedItem();

else {

s = variabl2311[i].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;

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

if (!variabl3623(c, i, 1)) {

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++) {

int a1 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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 (";

sd = "";

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)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + variabl1419[i].trim() + ",";

break;

}

}

}

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 ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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) + ")";

stat4.executeUpdate(s1);

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]);

panel1.add(variabl2611);

}

variabl2601 = new JButton(variabl2405[6]);

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[6][0] > 0) {

variabl2601.setBounds(variabl1885[6][0], variabl1885[6][1],

variabl1885[6][2], variabl1885[6][3]);

panel1.add(variabl2601);

}

variabl1697 = new JButton(variabl2405[7]);

variabl1697.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

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

if (!variabl3623(c, i, 1)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

int[] x0 = new int[variabl1843];

String[] s0 = new String[variabl1843];

String s = "";

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1501[variabl1467[i]] + ",") < 0) {

if ((variabl1651[i][4].equals("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

s = (String) variabl2359[variabl1739]

.getSelectedItem();

else {

s = variabl2311[i].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, "关键字不存在，请改为生成数据录入语句！");

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 ";

b = 0;

d2: for (int j = 0; j < variabl1733.length; j++) {

int a1 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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);

char x1 = 10, x2 = 13;

int k2 = 1;

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

String fieldname = variabl2517[variabl1467[i]];

String s6 = "";

/*

* if (main1.variabl1539.lastIndexOf(","+variabl1501[

* variabl1467[i]]+",")>= 0){ final JFileChooser fc =

* new JFileChooser(".\\"); fc.showOpenDialog(null); if

* (fc.getSelectedFile()!=null)

* s6=fc.getSelectedFile().toString(); else {

* JOptionPane.showMessageDialog( null,

* "未选择图片文件，不能录入！"); continue; } FileInputStream f1 =

* new FileInputStream(s6);

* pst4.setBinaryStream(k2,f1,f1.available()); k2++; }

*/

}

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[7][0] > 0) {

variabl1697.setBounds(variabl1885[7][0], variabl1885[7][1],

variabl1885[7][2], variabl1885[7][3]);

panel1.add(variabl1697);

}

variabl2633 = new JButton(variabl2405[8]);

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();

deleteData(variabl18531);

set01.remove(sd0);

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[8][0] > 0) {

variabl2633.setBounds(variabl1885[8][0], variabl1885[8][1],

variabl1885[8][2], variabl1885[8][3]);

panel1.add(variabl2633);

}

variabl2599 = new JButton(variabl2405[9]);

variabl2185[9] = variabl2599;

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if (variabl1885[9][0] > 0) {

variabl2599.setBounds(variabl1885[9][0], variabl1885[9][1],

variabl1885[9][2], variabl1885[9][3]);

panel1.add(variabl2599);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

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

variabl1733[i].setText(variabl2197[0][variabl1467[i]]);

}

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;

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);

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];

variabl1651 = new String[variabl2651][6];

variabl1323 = new String[variabl2651][15];

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];

variabl1323[i][1] = 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 (main1.variabl1537.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("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 e2) {

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) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl1325 + "  from " + variabl1103;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

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, "读取数据库数据出错！" + 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 < 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("普通字段")) {

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]));

if (variabl2803.indexOf("," + j + ",") >= 0) {

variabl2403[j].setEditable(false);

}

variabl2403[j].setText(variabl1507[j]);

variabl1733[j] = (JTextComponent) variabl2403[j];

variabl1467[j] = j;

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().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;

}

}

}

public void focusLost(final FocusEvent arg1) {

if (c > 0)

return;

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) && (!variabl3623(c, b, 0))) {

variabl2403[c].requestFocus(true);

return;

}

}

});

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

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

}

}

}

public static boolean variabl3623(int c1, int b1, int k) {

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 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] + "范围要求！";

}

}

}

}

}

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;

}

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 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--;

}

}

79.源码79，部件程序，表单程序（单记录数据维护程序），可应用deviseTool自定义界面，包括多图形字段数据维护，可变换标签，可用组合框显示代码，可实现数据完整性、数据安全性保护。

/** 

 * 程序文件名：dataTenance6.java 

 * 作者：程学先  

 * 功能：表单程序（单记录数据维护程序），可应用deviseTool自定义界面， 

 * 包括多图形字段数据维护，可变换标签，可用组合框显示代码，可实现数据完整性、数据安全性保护。 

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.*;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

import javax.sound.sampled.*;

public class dataTenance6 extends JFrame {

static dataTenance6 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;

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, variabl1971, variabl2255,

variabl2531, variabl2611, variabl2601, variabl1697, variabl2633,

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;

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;

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 = "";

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[] sw = new String[11];

static int variabl2851 = 0, variabl2339 = 0;

private static int variabl2833;

private static HashSet set01 = new HashSet();

public static String sd0;

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;

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;

variabl2833 = 0;

variabl1091 = main1.variabl1091;

list0 = new ArrayList<String>();

variabl1837 = new String[0][0];

username = main1.username;

variabl2339 = 0;

sw = new String[11];

sw[1] = main1.sw1 + "";

sw[2] = main1.sw2;

sw[3] = main1.sw3;

sw[4] = main1.sw4;

sw[5] = main1.sw5;

sw[6] = main1.sw6;

sw[7] = main1.sw7;

sw[8] = main1.sw8;

sw[10] = main1.sw10;

main1.sw1 = 0;

main1.sw2 = "";

main1.sw3 = "";

main1.sw4 = "";

main1.sw5 = "";

main1.sw6 = "";

main1.sw7 = "";

main1.sw8 = "";

main1.sw9 = "";

main1.sw10 = "";

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(";");

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, m2;

try {

if (parameter[17].length() == 0) {

m1 = 0;

m2 = 0;

} else {

m1 = Integer.parseInt(parameter[17]);

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 = new JPanel(true);

frame1 = new dataTenance6();

frame1.setTitle("单记录数据维护程序                           作者：程学先");

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

frame1.getContentPane().add(panel1, null);

list1 = new List();

list = new ArrayList<String>();

variabl1597 = main1.variabl1537 + main1.variabl1539;

variabl2185 = new JButton[20];

panel1.setLayout(null);

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 (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];

String[] t5 = variabl1187.split(",");

String[] variabl2831 = new String[variabl2405.length];

variabl1885 = new int[variabl2851][15];

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;

int k3 = 0;

for (int i = 0; (tempStr = br.readLine()) != null; i++) {

if (tempStr.length() > 1)

list0.add(tempStr);

}

String 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++;

}

}

variabl1371 = k3;

if (k3 > 0) {

variabl2833 = 1;

}

if (variabl1233 > 0) {

variabl1323 = new String[variabl1233][13];

variabl1651 = new String[variabl1233][6];

} 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()

.equalsIgnoreCase(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;

}

}

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 (t2[j].toLowerCase().equalsIgnoreCase(

variabl1197[i][1].toLowerCase())) {

if (variabl1197[i][0].equals("只读"))

variabl2803 = variabl2803 + j + ",";

variabl1197[i][1] = j + "";

}

}

}

if (variabl2483 == 0)

variabl2483 = variabl1745;

variabl1005(variabl2603);

variabl1009(variabl2603);

if (variabl1233 == 0)

variabl1037();

variabl2819002();

variabl2817002();

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]) {

if (variabl2197[i0][variabl1467[i]] == null) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

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;

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);

}

});

if (variabl1885[0][0] > 0) {

variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],

variabl1885[0][2], variabl1885[0][3]);

panel1.add(variabl2375);

}

variabl2325 = new JButton(variabl2405[1]);

variabl2325.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 < variabl1853 - 1) {

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);

}

});

if (variabl1885[1][0] > 0) {

variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],

variabl1885[1][2], variabl1885[1][3]);

panel1.add(variabl2325);

}

variabl1971 = new JButton(variabl2405[2]);

variabl1971.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl1853 > 1)

variabl18531 = variabl1853 - 1;

else

variabl18531 = 0;

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(false);

variabl2255.setEnabled(true);

}

});

if (variabl1885[2][0] > 0) {

variabl1971.setBounds(variabl1885[2][0], variabl1885[2][1],

variabl1885[2][2], variabl1885[2][3]);

panel1.add(variabl1971);

}

variabl2255 = new JButton(variabl2405[3]);

variabl2255.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl18531 > 0) {

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);

}

});

if (variabl1885[3][0] > 0) {

variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],

variabl1885[3][2], variabl1885[3][3]);

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]);

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("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

s = (String) variabl2359[variabl1739]

.getSelectedItem();

else {

s = variabl2311[i].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;

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

if (!variabl3623(c, i, 1)) {

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++) {

int a1 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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 (";

sd = "";

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)) {

JOptionPane.showMessageDialog(null,

"存在关键字为空值的记录，请检查数据库中数据情况。");

return;

}

sd = sd + variabl1419[i].trim() + ",";

break;

}

}

}

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 ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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]);

panel1.add(variabl2611);

}

variabl2601 = new JButton(variabl2405[6]);

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[6][0] > 0) {

variabl2601.setBounds(variabl1885[6][0], variabl1885[6][1],

variabl1885[6][2], variabl1885[6][3]);

panel1.add(variabl2601);

}

variabl1697 = new JButton(variabl2405[7]);

variabl1697.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

c = 0;

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

if (!variabl3623(c, i, 1)) {

JOptionPane.showMessageDialog(null, i

+ "数据完整性检测出错，请检查！");

return;

}

String s;

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("组合框"))

|| (variabl1651[i][4].equals("列表框"))) {

variabl1739 = i;

if (variabl1651[i][4].equals("组合框"))

s = (String) variabl2359[variabl1739]

.getSelectedItem();

else {

s = variabl2311[i].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, "关键字不存在，请改为生成数据录入语句！");

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++) {

int a1 = 0;

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

if ((variabl1197[i][1] != null)

&& (variabl1197[i][2] != null))

if ((Integer.parseInt(variabl1197[i][1]) == j)

&& (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);

char x1 = 10, x2 = 13;

int k2 = 1;

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

String fieldname = variabl2517[variabl1467[i]];

String s6 = "";

}

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[7][0] > 0) {

variabl1697.setBounds(variabl1885[7][0], variabl1885[7][1],

variabl1885[7][2], variabl1885[7][3]);

panel1.add(variabl1697);

}

variabl2633 = new JButton(variabl2405[8]);

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();

deleteData(variabl18531);

set01.remove(sd0);

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[8][0] > 0) {

variabl2633.setBounds(variabl1885[8][0], variabl1885[8][1],

variabl1885[8][2], variabl1885[8][3]);

panel1.add(variabl2633);

}

variabl2599 = new JButton(variabl2405[9]);

variabl2185[9] = variabl2599;

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if ((sw[2].length() > 0) && (sw[3].length() > 0)

&& (sw[4].length() > 0))

WorkflowDrivek1.means(sw);

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if (variabl1885[9][0] > 0) {

variabl2599.setBounds(variabl1885[9][0], variabl1885[9][1],

variabl1885[9][2], variabl1885[9][3]);

panel1.add(variabl2599);

}

if ((sw[3].length() > 0) && (sw[4].length() > 0))

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

variabl1733[i].setText(variabl2197[0][variabl1467[i]]);

}

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);

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 (main1.variabl1537.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 e2) {

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) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

String s1 = "select " + variabl1325 + "  from " + variabl1103;

if ((sw[3].length() > 0) && (sw[4].length() > 0))

s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";

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, "读取数据库数据出错！" + 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 < 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]));

Font font = new Font(variabl1323[j][8], Font.BOLD,

Integer.parseInt(variabl1323[j][9]));

String s01 = variabl1323[j][10];

int s02 = 5;

if ((s01 != null) && (s01.length() > 0)

&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))

s02 = Integer.parseInt(s01);

variabl2533.setFont(font);

color1(s02, variabl2533);

panel1.add(variabl2533);

if (variabl1651[j][4].equals("普通字段")) {

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);

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 = "";

int n1 = 0;

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

s2 = "[," + variabl1651[i][0].trim() + ","

+ variabl1651[i][1].trim() + ",";

if (s1.indexOf(s2) > 0) {

b = i;

break;

}

}

}

public void focusLost(final FocusEvent arg1) {

if (c > 0)

return;

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) && (!variabl3623(c, b, 0))) {

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]));

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);

variabl2463[j].setFont(font1);

color3(s021, variabl2463[j]);

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;

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

}

}

}

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--;

}

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;

}

}

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, int k) {

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-1121170.html

上一篇：管理信息系统软件生产线源码74-77
下一篇：管理信息系统软件生产线源码80-81