版本1

71.源码71，部件程序，表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签。

/**

 * 程序文件名：dataTenance2.java

 * 作者：程学先

 * 功能：表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

 * 本部件不涉及包含有image等二进制数据类型的数据的维护

 * 用途：以文本框、按钮等构成单记录数据维护界面作数据录入、修改、删除等使用。 

 * 完成日期：2013年12月20日

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

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

 * 可选择输入的参数：“窗口宽”、“窗口高” 、“字段序号”、 “要求按钮号表”

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

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

 * 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；

 * 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。

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

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

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

 * 在序号后可加分号之后跟变换名，可改变按钮名称。 

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

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

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

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

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

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

 * 如果要根据条件选择的结果将满足条件的记录某一字段数据全部改为某数据，

 * 需要先进行查询，再在某字段文本框中输入改后数据，之后点击“批处理”按钮。

 * 查询只限等值查询，要求先在某字段文本框中输入欲查询的数据值，再点击查询按钮，实现该字段等于该值的查询。

 * 注意本程序适用数据类型包括各类整型、各浮点类型、各char数据类型、各text数据类型。

 * 本程序提供各字段共用列表框,可以利用鼠标选择代码表中数据或历史数据录入。

 * 如果某字段有代码表，列表框中列入内容为代码表中值，否则为历史数据，供鼠标点击录入。

 * 代码表名字为字段名加“代码表”，其中，统一为二个字段，一个字段名与数据表中字段名相同，

 * 另一个为数据表中字段名再加“代码”或字段名中去掉“代码”二字。

 * 例如，关于性别，设计用0表示男，1表示女，

 * 其代码表的名字必须为：“性别代码表”，当数据表中字段名为“性别”时，代码表中设计“性别”、“性别代码”二个字段

 * 如果，数据表中字段名为“性别代码”，代码表中仍然是“性别”、“性别代码”二个字段，都是二条记录：男  0；女  1。

 * 在数据表中字段名如果为“性别代码”，在列表框中显示0  1；录入保存的是0或1。

 * 如果数据表中字段名为性别，那么，列表框中显示男   女，录入保存的是男或女。

 * 如果使用字典表，要求在当前数据库中有表的表名带“字典表”3字，该表第一列为字段名，第2列为标签名。

 */

import java.awt.*;

import java.awt.List;

import java.awt.event.*;

import java.io.UnsupportedEncodingException;

import javax.swing.*;

import javax.swing.table.*;

import javax.swing.text.JTextComponent;

import java.sql.*;

import java.util.*;

public class dataTenance2 {

static JFrame frame1 = new JFrame();

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

private static JPanel panel1 = new JPanel(false);

static JTextField[] 文本框;

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

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

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

private static String 表名; // 数据表名

private static String 表名表;

private static String 字典表名;

private static int 窗口宽 = main1.窗口宽;

private static int 窗口高 = main1.窗口高;// 窗口高

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

private static int 列数; // 数据表列数

private static int 表格列数;

private static String[][] 列名; // 数据表列名

private static String[][] 表格列名;

private static String[] 原始表格列名;

private static String[] 列数据类型; // 存放当前记录各字段数据类型的数组

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

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

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

private static int 记录条数 = 0;

private static int 记录条数1 = 0;

private static String[][] 表格数据;

private static String[][] 代码表数据;

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

private static JButton[] 按钮数组 = new JButton[10];

static String[][] 备份数据;

private static String 要求按钮号表;

private static int 实际按钮数 = 0;

private static String 要求字段号表 = "", 限只读字段号表 = "";

private static String[] 一条空记录; // 准备添加到表格的一行记录

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

private static String[] 关键字段名;

private static int[] 关键字序号;

private static String s1 = "", s2 = "";

private static int b = 0, c = 0;

private static int 当前列号 = 0;

private static int 控件个数 = 0;

private static int list框宽度 = 100;

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

private static String[] 按钮集 = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘",

"清屏", "修改存盘", "删除", "退出" };

private static JButton 第一条, 下一条, 最后一条, 上一条, 浏览, 存盘, 清屏, 修改存盘, 删除, 退出;

private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;

private static int list调整值 = 0;

private static JTextComponent[] 文本数组;

private static int[] 文本数组号;

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

private static int 行间距离 = 0;

private static int 起始左边距 = 0;

private static int 起始到顶距 = 0;

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

private static int 按钮行数;

private static int 文本区宽度 = 0;

private static String[] 文本数组值;

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

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

private static JTextArea[] 文本域;

private static int 列名长度 = 0;

private static int 大数据个数 = 0;

private static int 原窗口宽 = 窗口宽, 原窗口高 = 窗口高;

public static String[] sw = new String[11];

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

private static int 按钮定义标志;

private static HashSet set01 = new HashSet();

private static String sd0;

static void means(String parameter[]) {

frame1 = new JFrame();

panel1 = new JPanel(false);

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

窗口左边距 = 10;

窗口到顶距 = 10;

记录条数 = 0;

记录条数1 = 0;

列名长度 = 0;

大数据个数 = 0;

原窗口宽 = 窗口宽;

原窗口高 = 窗口高;

s1 = "";

s2 = "";

b = 0;

c = 0;

字符宽度 = 15;

字符高度 = 20;

按钮数组 = new JButton[10];

行间距离 = 0;

起始左边距 = 0;

起始到顶距 = 0;

按钮集 = new String[10];

控件个数 = 0;

list框宽度 = 100;

按钮定义标志 = 0;

大数据类型 = main1.文本数据类型 + main1.图形数据类型;

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

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];// 只留号，原无更名

}

}

} // 如果没有按钮更名要求，要求按钮号长度又大于0，保持原有摸样

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

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

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;

窗口高 = m2;

}

} catch (Exception e2) {

}

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

表名表 = "," + parameter[0] + ",";

String[] t1 = parameter[0].split(",");

字典表名 = "";

if (表名表.lastIndexOf(表名 + "字典表") >= 0) {

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

if (t1[i].lastIndexOf(表名 + "字典表") >= 0) {

字典表名 = t1[i];

break;

}

}

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

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

return;

}

String 字段名字串 = parameter[19];

关键字段名 = parameter[6].split(",");

if (sw[5].length() > 0) { // 如果从原安全性要求到可视化安全性要求要加5

if (要求按钮号表.length() > 0) {

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

要求按钮号表 = "";

for (int j = 0; j < ss.length; j++) {

if (要求按钮号表.length() == 0)

要求按钮号表 = (Integer.parseInt(ss[j]) + 5) + "";

else

要求按钮号表 = 要求按钮号表 + "," + (Integer.parseInt(ss[j]) + 5)

+ "";

}

} else

要求按钮号表 = "5,6,7,8,9";

}

要求字段号表 = parameter[8]; // 需要显示的字段的顺序号

if (要求字段号表.trim().length()==0){

String [] s0=字段名字串.split(",");

for (int i1=0;i1<s0.length;i1++)

          if (要求字段号表.length()==0)

          要求字段号表=i1+"";

          else 要求字段号表=要求字段号表+","+i1;

}

限只读字段号表 = parameter[9];

关键字序号 = new int[关键字段名.length];

数据表查询结构001(表名); // 得到数据表结构，产生全部字段名字符串

数据表查询数据0011();

表格列数 = 列数;

表格列名 = new String[2][表格列数];

原始表格列名 = new String[表格列数];

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

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

表格数据 = new String[记录条数 + 300][表格列数];

代码表数据 = new String[表格列数][];

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

列名长度 = 0;

大数据个数 = 0;

b = 0;

int 最大字段宽 = 0;

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

while (b < 表格列数) {

表格列名[0][b] = 列名[0][b];// b原列名列序号[b]

表格列名[1][b] = 列名[1][b];// 字典变换后列名列序号[b]

表列数据类型[b] = 列数据类型[b]; // 列序号[b]

表列数据宽度[b] = 列数据宽度[b]; // 列序号[b]

if (表格列名[1][b].length() > 列名长度)

列名长度 = 表格列名[1][b].length();

if ((大数据类型.indexOf("," + 表列数据类型[b] + ",") < 0)

&& (最大字段宽 < (表格列名[1][b].length() + 表列数据宽度[b]) * 字符宽度)) {

最大字段宽 = (表格列名[1][b].length() + 表列数据宽度[b]) * 字符宽度;

}

if (大数据类型.indexOf("," + 表列数据类型[b] + ",") >= 0)

大数据个数++; 

b++;

}

if (大数据个数 == 0) {

// 如果需求面积加list框面积加按钮面积小于原定窗口面积，

if (需求面积 + list框宽度 * (窗口高 - 120) + 窗口宽 * 80 < 窗口高 * 窗口宽) {

if (最大字段宽 < list框宽度 * 1.5)

最大字段宽 = (int) (list框宽度 * 1.5);

窗口高 = (int) (需求面积 * 1.5) / 最大字段宽 + 120;

if (原窗口高 < 窗口高)

窗口高 = 原窗口高;

if (窗口高 * 4 > 窗口宽 * 3)

窗口宽 = 窗口高 * 4 / 3;// 黄金分割点

if (原窗口宽 < 窗口宽)

窗口宽 = 原窗口宽;

}

if (窗口宽 < 500)

窗口宽 = 500;

if (窗口高 < 300) {

窗口高 = 300;

}

if (原窗口高 > 窗口高 + 大数据个数 * 40)

窗口高 = 窗口高 + 大数据个数 * 40;

else

窗口高 = 原窗口高;

}

int 文本区宽度 = (窗口宽 - list框宽度 - 50) / 字符宽度; // 以字符个数为单位文本区宽度

b = 0;

while (b < 表格列数) {

if ((列名长度 + 表列数据宽度[b]) > (文本区宽度)) {

表列数据宽度[b] = 文本区宽度 - 列名长度;

}

if (表列数据类型[b].indexOf("datetime") == 0)

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

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

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

else if (表列数据类型[b].indexOf("datetime2") == 0)

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

else if (表列数据类型[b].indexOf("datetimeoffset") == 0)

一条空记录[b] = "2001-01-01 00:00:00.0000000 +08:00";

else if (表列数据类型[b].indexOf("date") == 0)

一条空记录[b] = "2001-01-01";

else if (表列数据类型[b].indexOf("time") == 0)

一条空记录[b] = "00:00:00";

else if (表列数据类型[b].indexOf("money") >= 0)

一条空记录[b] = "0.0000";

else if (main1.小数型数据类型.lastIndexOf(表列数据类型[b]) > 0)

一条空记录[b] = "0.00";

else if (main1.数字数据类型.lastIndexOf(表列数据类型[b]) > 0)

一条空记录[b] = "0";

else

一条空记录[b] = "";

b++;

}

数据表查询数据001(表名); // 读取数据

数据表查询数据0012();   // 读代码表

final JPanel panel1 = new JPanel(false);

panel1.setLayout(null);

panel1.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 50);

JLabel jl = new JLabel("字段可选内容  :");

jl.setBounds(10, 10, list框宽度, 字符高度);

list1 = new List();

list1.setBounds(10, 40, list框宽度, 窗口高 - 230 + list调整值);

panel1.add(jl);

panel1.add(list1);

int 行间距离 = 0;

int 本行当前宽度 = 0;

int 起始左边距 = list框宽度 + 2;

位置参数 = new int[表格列数][2];

int 文本控件行数 = 1;

if ((大数据个数 == 0) && (表格列数 * 字符高度 + 按钮行数 * 字符高度 + 40 < 窗口高)) {

文本控件行数 = 表格列数;

for (int j = 0; j < 表格列数; j++) {

位置参数[j][0] = 1 + j;

位置参数[j][1] = 1;

表列数据宽度[j] = 文本区宽度 - 列名长度;

}

行间距离 = (窗口高 - 120 - (按钮行数 + 表格列数) * 字符高度) / (按钮行数 + 表格列数 + 1);

} else {

int 当前列列号 = 1;

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

if (大数据类型.lastIndexOf("," + 表列数据类型[i] + ",") < 0) {

if ((本行当前宽度 + 列名长度 + 表列数据宽度[i]) <= 文本区宽度) {

本行当前宽度 = 本行当前宽度 + 列名长度 + 表列数据宽度[i];

位置参数[i][0] = 文本控件行数;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[i];

位置参数[i][1] = 当前列列号;

当前列列号++;

} else {

表列数据宽度[i - 1] = 表列数据宽度[i - 1] + 文本区宽度 - 本行当前宽度;

文本控件行数++;

当前列列号 = 1;

位置参数[i][0] = 文本控件行数;

位置参数[i][1] = 当前列列号;

当前列列号++;

本行当前宽度 = 列名长度 + 表列数据宽度[i];

起始左边距 = list框宽度 / 字符宽度 + 2 + 列名长度 + 表列数据宽度[i];

}

b = i;

}

}

表列数据宽度[b] = 表列数据宽度[b] + 文本区宽度 - 本行当前宽度;

if (大数据个数 > 0)

行间距离 = 0;

else

行间距离 = (窗口高 - 120 - 按钮行数 * 字符高度 - 文本控件行数 * 字符高度)

/ (文本控件行数 + 按钮行数 + 1);

}

文本数组 = new JTextComponent[表格列数];

文本数组值 = new String[文本数组.length];

文本数组号 = new int[文本数组.length];

int 当前列 = 1, 当前行 = 1;

控件个数 = 0;

起始左边距 = list框宽度 / 字符宽度 + 2;

起始到顶距 = 窗口到顶距 + 行间距离;

文本框 = new JTextField[表格列名[0].length];

for (int j = 0; j < 表格列名[0].length; j++) {

JLabel 标签 = new JLabel(表格列名[1][j], 11);

文本框[j] = new JTextField("");

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

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

}

if ((大数据类型.lastIndexOf("," + 表列数据类型[j] + ",")) < 0) {

panel1.add(标签);

panel1.add((Component) 文本框[j]);

if ((位置参数[j][0] == 当前行) && (位置参数[j][1] == 当前列)) {

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

当前列++;

} else if (位置参数[j][0] == 当前行) {

当前列++;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

} else {

起始到顶距 = 起始到顶距 + 行间距离 + 字符高度;

当前行++;

起始左边距 = list框宽度 / 字符宽度 + 2;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

当前列 = 2;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

}

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

文本框[j].setFont(new Font("宋体", 1, 14));

文本框[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

int n1 = 0;

for (int i = 0; i < 表格列名[0].length; i++) {

if (s1.lastIndexOf("," + 位置参数[i][0] + ","

+ 位置参数[i][1] + ",") > 0) {

当前列号 = i;

break;

}

}

list1.removeAll();

if ((表名表.lastIndexOf("," + 表格列名[0][当前列号] + "表,") >= 0)

|| (表名表.lastIndexOf("," + 表格列名[0][当前列号]

+ "代码表,") >= 0)) {

for (int i = 0; i < 代码表数据[当前列号].length; i++)

list1.add(代码表数据[当前列号][i]);

} else if (表名表

.lastIndexOf("," + 表格列名[0][当前列号] + "代码表,") < 0) {

int u1 = 0;

for (int j = 0; j < 记录条数; j++) {

int u2 = 0;

for (int k = 0; k < u1; k++) {

if (表格数据[j][当前列号] != null) {

} else

表格数据[j][当前列号] = " ";

if (表格数据[j][当前列号].toLowerCase().trim().equals(

list1.getItem(k).toLowerCase().trim())) {

u2++;

break;

}

}

if (u2 == 0) {

list1.add(表格数据[j][当前列号]);

u1++;

}

}

}

}

});

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

文本数组号[控件个数] = j;

}

控件个数++;

}

if (大数据个数 > 0) {

起始到顶距 = 起始到顶距 + 字符高度;

文本域高度 = (窗口高 - 起始到顶距 - 150) / 大数据个数;

窗口高 = 窗口高 + 20;

起始左边距 = list框宽度 + 10;

int 文本域宽度 = (文本区宽度 - 列名长度 + 1) * 字符宽度;

for (int j = 0; j < 表格列名[0].length; j++) {

if ((大数据类型.lastIndexOf("," + 表列数据类型[j] + ",")) >= 0) {

JLabel 标签 = new JLabel(表格列名[1][j], 11);

JTextArea 文本域 = new JTextArea(null, "", 文本域宽度, 文本域高度);

JScrollPane 文本域滚动条 = new JScrollPane(文本域);

文本域滚动条.setBounds(起始左边距 + 列名长度 * 字符宽度, 起始到顶距, 文本域宽度, 文本域高度);

panel1.add(标签);

panel1.add((Component) 文本域滚动条);

标签.setBounds(起始左边距, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

起始到顶距 = 起始到顶距 + 文本域高度;

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

文本数组号[j] = j;

}

}

}

起始左边距 = 20;

if (大数据个数 == 0)

起始到顶距 = 起始到顶距 + 30 + 行间距离;

else

起始到顶距 = 起始到顶距 + 20;

字符宽度 = 25;

if (窗口高 - 230 + list调整值 > 起始到顶距) { 

list调整值 = 起始到顶距 - 窗口高 + 180;

list1.setBounds(10, 40, list框宽度, 窗口高 - 230 + list调整值);

}

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

String s4 = "";

String[] s5;

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

if (文本数组号[i] == 当前列号) {

s4 = list1.getSelectedItem();

if (s4 != null) {

} else

s4 = "";

if (s4.lastIndexOf(",") > 0) {

s5 = s4.split(",");

文本数组[i].setText(s5[0]);

} else

文本数组[i].setText(list1.getSelectedItem());

}

}

});

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

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

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

记录条数1 = 0;

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

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

if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]] + ",")) > 0)

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

|| (文本数组[i].getText().trim().length() < 1))

文本数组[i].setText("0");

}

下一条.setEnabled(true);

上一条.setEnabled(false);

}

});

if (要求按钮号表.lastIndexOf(",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++) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]]

+ ",")) > 0)

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

|| (文本数组[i].getText().trim().length() < 1))

文本数组[i].setText("0");

}

}

上一条.setEnabled(true);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 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; // 记录指针-1

else

记录条数1 = 0;

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

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]] + ",")) > 0)

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

|| (文本数组[i].getText().trim().length() < 1))

文本数组[i].setText("0");

}

下一条.setEnabled(false);

上一条.setEnabled(true);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 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++) {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[i]]

+ ",")) > 0)

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

|| (文本数组[i].getText().trim().length() < 1))

文本数组[i].setText("0");

}

下一条.setEnabled(true);

} else

上一条.setEnabled(false);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 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(窗口宽, 窗口高, 表格列名[1], n , 备份数据,

表列数据类型);

} else {

浏览.setText("浏览");

记录条数1 = main1.当前行行号; // 记录指针

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

文本数组[i].setText(表格数据[main1.当前行行号][文本数组号[i]]);

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {

浏览.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);

panel1.add(浏览);

}

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

存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

文本数组值[i] = 文本数组[i].getText();

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

文本数组值[i] = " ";

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

cont4 = main1.getConn(); // 连接数据库

try {

记录条数++;

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "insert into " + 表名 + "(";

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

if (!表列数据类型[文本数组号[j]].equals("image"))

s1 = s1 + 列名[0][文本数组号[j]] + ",";

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

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

表格数据[记录条数 - 1][j] = 文本数组值[j];

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]

+ ",") >= 0) {

s1 = s1 + 文本数组值[j] + ",";

} else {

if (!表列数据类型[文本数组号[j]].equals("image"))

s1 = s1 + "'" + 文本数组值[j].trim() + "',";

}

}

s1 = s1.substring(0, s1.length() - 1) + ")";

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

set01.add(sd0); // 添加新记录成功后将关键字加入set

} catch (SQLException e2) {

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

表格数据[记录条数][j] = "";

}

记录条数--;

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 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++) {

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

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",6,") >= 0)) {

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

panel1.add(清屏);

}

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

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

public void actionPerformed(ActionEvent e) {

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

文本数组值[i] = 文本数组[i].getText();

String sd = "";

int kd = set01.size();      //备份已有的关键字个数

int kd0 = 0;

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

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

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 if (!表列数据类型[文本数组号[j]].equals("image"))

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

String s3 = "";

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

if (!表列数据类型[文本数组号[j]].equals("image"))

if (s3.length() > 0)

s3 = s3 + "," + 列名[0][文本数组号[j]] + "=";

else

s3 = s3 + 列名[0][文本数组号[j]] + "=";

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]

+ ",") >= 0) {

if ((文本数组值[j] == null) || (文本数组值[j].length() == 0))

文本数组值[j] = "0";

s3 = s3 + 文本数组值[j];

} else {

if (!表列数据类型[文本数组号[j]].equals("image"))

s3 = s3 + "'" + 文本数组值[j].trim() + "'";

}

}

s1 = s1 + s3 + " where " + s2;

stat4.executeUpdate(s1);

stat4.close();

cont4.close();

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

表格数据[记录条数1][j] = 文本数组值[j];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",7,") >= 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++)

文本数组值[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)

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

else

文本数组[i].setText(表格数据[记录条数1][i]);

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "SQL语句错！" + s1);

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",8,") >= 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 ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",9,") >= 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]]); // 表格数据[0][文本数组号[i]]

}

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

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;

frame1.setBounds(w1, h1, 窗口宽, 窗口高); // 主程序窗口位置大小

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

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

frame1.getContentPane().add(panel1, null); // 安装面板

frame1.setVisible(true); // 安装窗口

}

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[2][列数];

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

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

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

列名[0][i] = rsmdt4.getColumnName(i + 1);

列名[1][i] = 列名[0][i];

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

if (要求字段号表.trim().length() > 0) {

int N0 = 1;

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

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

if (关键字段名[j].toLowerCase().trim().equals(列名[0][i].toLowerCase().trim())) {

关键字序号[j] = i;

if (("," + 要求字段号表 + ",").lastIndexOf("," + i + ",") < 0)

要求字段号表 = i + "," + 要求字段号表; // 关键字号加前面

break;

}

}

列名表 = "";

b = 0;

String[] t2 = 要求字段号表.split(",");

while (b < t2.length) {

列名表 = 列名表 + 列名[0][Integer.parseInt(t2[b])] + ",";

b++;

}

列名表 = 列名表.substring(0, 列名表.length() - 1);

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

} else {

b = 0;

列名表 = "";

while (b < 列数) {

列名表 = 列名表 + 列名[0][b] + ",";

b++;

}

列名表 = 列名表.substring(0, 列名表.length() - 1);

}

}

static void 数据表查询结构0011(String 列名表0, String 数据表名001) {

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_READ_ONLY); // CONCUR_UPDATABLE

String s1 = "select " + 列名表0 + " from " + 数据表名001;

rs = stat4.executeQuery(s1);

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[2][列数];

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

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

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

列名[0][i] = rsmdt4.getColumnName(i + 1);

列名[1][i] = 列名[0][i];

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

}

rs.absolute(1);

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

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

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

if (关键字段名[j].toLowerCase().equals(列名[0][i].toLowerCase()))

关键字序号[j] = i;

}

}

}

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); // .response.setCharacterEncoding("utf-8");

if ((main1.数字数据类型.lastIndexOf("," + 表列数据类型[b] + ",")) > 0)

if ((表格数据0[c][b] == null)

|| (表格数据0[c][b].trim().length() == 0))

表格数据0[c][b] = "0";

表格数据[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]; // 列序号[j]

} catch (SQLException e1) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！");

}

String sd = "";

for (int i0 = 0; i0 < 记录条数; i0++) {

sd = "";

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

sd=sd+表格数据[i0][关键字序号[j]]+",";

}

set01.add(sd);  //保存已在库中所有记录的关键字值

}

}

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

记录条数 = rs.getRow();

rs.absolute(1);

int numberOfColumns = rsmd.getColumnCount();

String s4 = "";

String s5 = "";

for (int i = 1; i <= 记录条数; i++) { 

rs.absolute(i);

s4 = rs.getString(1);

s5 = rs.getString(2);

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

if (列名[0][j].toLowerCase().trim().equals(s4.trim().toLowerCase())) {

列名[1][j] = s5;

break;

}

}

}

rs.close(); // 关闭查询结果集

stat4.close();

cont4.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！");

}

}

static void 数据表查询数据0012() {

try {

for (int j = 0; j < 表格列数; j++) {

int u = 0;

// 查代码表

if ((表名表.lastIndexOf("," + 表格列名[0][j] + "表,") >= 0)

&& (表格列名[0][j].indexOf("代码") >= 0)) {

s2 = 表格列名[0][j].substring(0, 表格列名[0][j].length() - 2);

s1 = "select " + 表格列名[0][j] + "," + s2 + " from "

+ 表格列名[0][j] + "表";

u = 1;

} else if (表名表.lastIndexOf("," + 表格列名[0][j] + "代码表,") >= 0) {

s2 = 表格列名[0][j].substring(0, 表格列名[0][j].length() - 2);

s1 = "select " + 表格列名[0][j] + "," + 表格列名[0][j] + "代码"

+ " from " + 表格列名[0][j] + "代码表";

u = 1;

}

if (u == 1) {

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

代码表数据[j] = new String[numberOfColumns];

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

代码表数据[j][i - 1] = rs.getString(1) + ","

+ rs.getString(2);

}

rs.close();

stat4.close(); // 关闭连接

cont4.close();

}

}

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

}

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 计算文本框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 >= 一行按钮数) { // 按钮数-n1)-一行按钮数==0

起始左边距 = 20;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

n = 0;

n2++;

}

}

}

窗口高 = 起始到顶距 + 字符高度 + 100;

}

}

72.源码72，部件程序，表单程序（单记录数据维护程序），应用组合框提供代码辅助录入、可变换标签、可显示与录入图片。

/**

 * 程序文件名：dataTenance3.java

 * 作者：程学先

 * 功能：表单程序（单记录数据维护程序），应用组合框提供代码辅助录入、可变换标签、可显示与录入图片。

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

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

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

 * 可选择输入的参数：“窗口宽”、“窗口高” 、“字段序号”、 “要求按钮号表”

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

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

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

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

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

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

 * 如果存在image字段，在点击“存盘”按钮或“修改存盘”按钮后，需要再点击“存入图片”专用于录入图片。

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

 */

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

import java.sql.*;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Set;

import java.util.Vector;

import java.io.*;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JTextField;

import javax.swing.WindowConstants;

import javax.swing.text.JTextComponent;

import javax.swing.text.html.HTMLDocument.Iterator;

import javax.swing.event.DocumentListener;

import javax.swing.event.DocumentEvent;

public class dataTenance3 {

private static JFrame frame1;

static JTextField[] 文本框;

private static JComboBox[] 组合框 = null;

private static JTextComponent[] 文本数组;

private static JLabel[] 图片数组;

private static int[] 文本数组号;

private static JButton[] 按钮数组 = new JButton[13];

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String 表名;

private static String 表名表;

private static String 字典表名;

private static int 窗口宽 = main1.窗口宽;

private static int 窗口高 = main1.窗口高;

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

private static int 列数;

private static int 表格列数 = 0;

private static String[][] 列名 = null;

private static String[][] 表格列名 = null;

private static String[] 列数据类型 = null;

private static String[] 表列数据类型 = null;

private static int[] 列数据宽度 = null;

private static int[] 表列数据宽度 = null;

private static int 记录条数 = 0;

private static int 记录条数1 = 0;

private static String[][] 表格数据 = null;

private static String[][] 代码表数据 = null;

private static String[] 文本数组值 = null;

static String[][] 备份数据;

private static String 要求按钮号表;

private static int 实际按钮数 = 0;

private static String 要求字段号表;

private static String[] 一条空记录 = null;

private static String 列名表 = "";

private static String[] 关键字段名 = null;

private static String[] 关键字段值 = null;

private static int[] 关键字序号 = null;

private static String s1 = "", s2 = "", s3 = "", s4 = "", s5 = "";

private static String 查询条件 = "", 查询值 = "";

private static int b = 0, c = 0;

private static String[] 当前字段值;

private static int[] 列序号;

private static int 当前行号 = 0, 当前列号 = 0;

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

private static int 控件个数 = 0;

private static String 键盘输入字串 = "";

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

private static String[] 按钮集 = { "第一条", "下一条", "最后一条", "上一条", "查询", "浏览",

"存盘", "清屏", "修改存盘", "删除", "批处理", "图片存盘", "退出" };

private static JButton b1;

private static JButton 第一条, 下一条, 最后一条, 上一条, 查询, 浏览, 存盘, 清屏, 修改存盘, 删除, 批处理,

图片存盘, 退出;

private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;

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

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

private static int 行间距离 = 0;

private static int 最大宽度 = 0;

private static int 起始左边距, 文本域高度;

private static int 末列行号 = 0;

private static int 按钮行数;

private static int 文本控件行数 = 1;

private static int 起始到顶距 = 0;

private static int 大数据个数 = 0;

private static int 按钮定义标志;

static void means(String parameter[]) {

frame1 = new JFrame();

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

窗口左边距 = main1.窗口左边距;

窗口到顶距 = main1.窗口到顶距;

表格列数 = 0;

表格列名 = new String[2][];

记录条数 = 0;

记录条数1 = 0;

实际按钮数 = 0;

文本域高度 = 0;

列名表 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

s5 = "";

查询条件 = "";

查询值 = "";

b = 0;

c = 0;

当前行号 = 0;

当前列号 = 0;

按钮定义标志 = 0;

控件个数 = 0;

键盘输入字串 = "";

字符宽度 = 15;

字符高度 = 20;

大数据类型 = main1.文本数据类型 + main1.图形数据类型;

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

窗口宽 = main1.窗口宽;

窗口高 = main1.窗口高;

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;

窗口高 = m2;

}

} catch (Exception e2) {

}

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

表名表 = "," + parameter[0] + ",";

String[] t1 = parameter[0].split(",");

字典表名 = "";

if (表名表.lastIndexOf(表名 + "字典表") >= 0)

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

if (t1[i].lastIndexOf(表名 + "字典表") >= 0)

字典表名 = t1[i];

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

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

return;

}

final int 部件序号 = Integer.parseInt(parameter[21]);

关键字段名 = parameter[6].split(",");

关键字段值 = new String[关键字段名.length];

;

要求字段号表 = parameter[8];

关键字序号 = new int[关键字段名.length];

按钮数组 = new JButton[13];

按钮数组 = new JButton[13];

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + 表名; // 查取全表数据

rs = stat4.executeQuery(s1);

rs.last();

记录条数 = rs.getRow();

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[2][列数];

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

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

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

列名[0][i] = rsmdt4.getColumnName(i + 1);

列名[1][i] = 列名[0][i];

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

if (字符宽度 * (列数据宽度[i] + 列名[1][i].length()) > 窗口宽)

列数据类型[i] = "text";

}

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

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

if (关键字段名[j].toLowerCase().trim()

.equals(列名[0][i].toLowerCase().trim())) {

关键字序号[j] = i;

if ((要求字段号表.length() > 0)

&& (("," + 要求字段号表 + ",").lastIndexOf("," + i

+ ",") < 0))

要求字段号表 = 要求字段号表 + "," + i;

break;

}

}

rs.close();

if (字典表名.length() > 0) {

s1 = "select * from " + 字典表名;

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

rs.last(); // 移动指针到最后一行

int numberOfColumns = rs.getRow();

rs.first();// 移动指针到第一行

String s4 = "";

String s5 = "";

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

s4 = rs.getString(1);

s5 = rs.getString(2);

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

if (列名[0][j].toLowerCase().trim()

.equals(s4.trim().toLowerCase())) {

列名[1][j] = s5;

break;

}

}

}

rs.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

要求字段号表 = "," + 要求字段号表 + ",";

列序号 = new int[列数];

int b0 = 0, b = -1;

while (b0 < 列数) {

if ((要求字段号表.length() < 3)

|| (要求字段号表.lastIndexOf("," + b0 + ",") >= 0)) {

b = b + 1;

列序号[b] = b0;

}

b0++;

}

表格列数 = b + 1;

表格列名 = new String[2][表格列数];

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

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

表格数据 = new String[记录条数 + 300][表格列数];

代码表数据 = new String[表格列数][];

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

int 列名长度 = 0;

大数据个数 = 0;

int 最大字段宽 = 0;

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

b = 0;

while (b < 表格列数) {

表格列名[0][b] = 列名[0][列序号[b]];

表格列名[1][b] = 列名[1][列序号[b]];

列名表 = 列名表 + 表格列名[0][b];

表列数据类型[b] = 列数据类型[列序号[b]];

表列数据宽度[b] = 列数据宽度[列序号[b]];

if (表格列名[1][b].length() > 列名长度)

列名长度 = 表格列名[1][b].length();

if ((大数据类型.indexOf("," + 表列数据类型[b] + ",") < 0)

&& (最大字段宽 < (表格列名[1][b].length() + 表列数据宽度[b]) * 字符宽度)) {

最大字段宽 = (表格列名[1][b].length() + 表列数据宽度[b]) * 字符宽度;

}

if (大数据类型.indexOf("," + 表列数据类型[b] + ",") >= 0)

大数据个数++;

b++;

}

if (大数据个数 == 0) {

if (需求面积 + 窗口宽 * 80 < 窗口高 * 窗口宽) {

窗口高 = (int) (需求面积 * 1.5) / 最大字段宽 + 120;

if (原窗口高 < 窗口高)

窗口高 = 原窗口高;

if (窗口高 * 4 > 窗口宽 * 3)

窗口宽 = 窗口高 * 4 / 3;// 黄金分割点

if (原窗口宽 < 窗口宽)

窗口宽 = 原窗口宽;

}

if (窗口宽 < 500)

窗口宽 = 500;

if (窗口高 < 300) {

窗口高 = 300;

}

if (原窗口高 > 窗口高 + 大数据个数 * 40)

窗口高 = 窗口高 + 大数据个数 * 40;

else

窗口高 = 原窗口高;

}

int 文本区宽度 = 窗口宽 / 字符宽度;

b = 0;

while (b < 表格列数) {

if (大数据类型.lastIndexOf("," + 表列数据类型[b] + ",") >= 0)

大数据个数++;

if ((列名长度 + 表列数据宽度[b]) > (文本区宽度)) {

表列数据宽度[b] = 文本区宽度 - 列名长度;

}

if (表列数据类型[b].indexOf("datetime") == 0)

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

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

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

else if (表列数据类型[b].indexOf("datetime2") == 0)

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

else if (表列数据类型[b].indexOf("datetimeoffset") == 0)

一条空记录[b] = "2001-01-01 00:00:00.0000000 +08:00";

else if (表列数据类型[b].indexOf("date") == 0)

一条空记录[b] = "2001-01-01";

else if (表列数据类型[b].indexOf("time") == 0)

一条空记录[b] = "00:00:00";

else if (表列数据类型[b].indexOf("money") >= 0)

一条空记录[b] = "0.0000";

else if (main1.小数型数据类型.lastIndexOf("," + 表列数据类型[b] + ",") >= 0)

一条空记录[b] = "0.00";

else if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[b] + ",") >= 0)

一条空记录[b] = "0";

else

一条空记录[b] = "";

b++;

}

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

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

if (关键字序号[j] == i)

关键字序号[j] = 列序号[i];

}

}

try {

s1 = "select * from " + 表名;

rs = stat4.executeQuery(s1);

rs.absolute(1);

c = 0;

b = 0;

while (c < 记录条数) {

rs.absolute(c + 1);

while (b < 表格列数) {

表格数据[c][b] = rs.getString(列序号[b] + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

try {

for (int j = 0; j < 表格列数; j++) {

int u = 0;

if ((表名表.lastIndexOf("," + 表格列名[0][j] + "表,") >= 0)

&& (表格列名[0][j].indexOf("代码") >= 0)) {

s2 = 表格列名[0][j].substring(0, 表格列名[0][j].length() - 2);

s1 = "select " + 表格列名[0][j] + "," + s2 + " from "

+ 表格列名[0][j] + "表";

u = 1;

} else if (表名表.lastIndexOf("," + 表格列名[0][j] + "代码表,") >= 0) {

s2 = 表格列名[0][j].substring(0, 表格列名[0][j].length() - 2);

s1 = "select " + 表格列名[0][j] + "," + 表格列名[0][j] + "代码"

+ " from " + 表格列名[0][j] + "代码表";

u = 1;

}

if (u == 1) {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd1 = rs.getMetaData();

rs.last(); // 移动指针到最后一行

int numberOfColumns = rs.getRow();

rs.first();// 移动指针到第一行

代码表数据[j] = new String[numberOfColumns];

表列数据宽度[j] = 表列数据宽度[j] + 5; // 组合框预留下拉框宽度

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

代码表数据[j][i - 1] = rs.getString(1) + ","

+ rs.getString(2);

}

rs.close();

stat4.close();

cont4.close();

} else {

代码表数据[j] = new String[1];

代码表数据[j][0] = "";

}

}

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

final JPanel panel1 = new JPanel(false);

panel1.setLayout(null);

panel1.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 50);

JLabel jl = new JLabel("字段可选内容  :");

jl.setBounds(10, 10, 10, 字符高度);

panel1.add(jl);

行间距离 = 0;

最大宽度 = 0;

起始左边距 = 0;

位置参数 = new int[表格列数][2];

末列行号 = 0;

文本控件行数 = 1;

if ((实际按钮数 * 字符宽度 * 6.3) % (窗口宽 - 50) == 0)

按钮行数 = (int) (实际按钮数 * 字符宽度 * 6.3) % (窗口宽 - 50);

else

按钮行数 = (实际按钮数 * 字符宽度 * 6) / (窗口宽 - 50) + 1;

if ((大数据个数 == 0) && (表格列数 * 字符高度 + 按钮行数 * 字符高度 + 40 < 窗口高)) {

文本控件行数 = 表格列数; // 没有大数据，且在窗口可以按每控件一排安排全部控件

for (int j = 0; j < 表格列数; j++) {

位置参数[j][0] = 1 + j;

位置参数[j][1] = 1;

表列数据宽度[j] = 文本区宽度 - 列名长度;

}

行间距离 = (窗口高 - 120 - (按钮行数 + 表格列数) * 字符高度) / (按钮行数 + 表格列数 + 1);

}// 没有大数据，且在窗口可以按每控件一排安排全部控件

else { // 有大数据或空间较小，需要紧凑安排

int 当前列列号 = 1;

int 最大宽度0 = 0;

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

if (大数据类型.lastIndexOf("," + 表列数据类型[i] + ",") < 0) {

if ((最大宽度 + 列名长度 + 表列数据宽度[i]) <= 文本区宽度) {

最大宽度 = 最大宽度 + 列名长度 + 表列数据宽度[i];

位置参数[i][0] = 文本控件行数;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[i];

位置参数[i][1] = 当前列列号;

if (最大宽度0 < 最大宽度)

最大宽度0 = 最大宽度;

末列行号 = i;

当前列列号++;

} // 在当前行紧凑安排

else { // 换行

if (最大宽度0 < 最大宽度)

最大宽度0 = 最大宽度;

文本控件行数++;

当前列列号 = 1;

位置参数[i][0] = 文本控件行数;

位置参数[i][1] = 当前列列号;

当前列列号++;

最大宽度 = 列名长度 + 表列数据宽度[i];

起始左边距 = 列名长度 + 表列数据宽度[i];

if (最大宽度 > 文本区宽度) {

表列数据宽度[i] = 表列数据宽度[i] - (最大宽度 - 文本区宽度);

文本控件行数++;

当前列列号 = 1;

}

}

b = i;

}

}

最大宽度0 = 0;

int n = 0, n1 = 0;

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

if (大数据类型.lastIndexOf("," + 表列数据类型[i] + ",") < 0) {

if ((i > 0) && (位置参数[i][0] > n)) { // 换行

if (最大宽度0 < 文本区宽度) {

表列数据宽度[i - 1] = 表列数据宽度[i - 1] + (文本区宽度 - 最大宽度0);

} else {

表列数据宽度[i - 1] = 表列数据宽度[i - 1] - (文本区宽度 - 最大宽度0);

}

最大宽度0 = 0;

}

n = 位置参数[i][0];

最大宽度0 = 最大宽度0 + 列名长度 + 表列数据宽度[i];

n1 = i;

}

}

if (最大宽度0 < 文本区宽度)

表列数据宽度[n1] = 表列数据宽度[n1] + (文本区宽度 - 最大宽度0);

if (大数据个数 > 0)

行间距离 = 0;

else

行间距离 = (窗口高 - 120 - 按钮行数 * 字符高度 - 文本控件行数 * 字符高度)

/ (文本控件行数 + 按钮行数 + 1);

}

文本数组 = new JTextComponent[表格列数];

图片数组 = new JLabel[表格列数];

文本数组值 = new String[文本数组.length];

文本数组号 = new int[文本数组.length];

文本框 = new JTextField[表格列名[0].length];

组合框 = new JComboBox[表格列名[0].length];

int 当前列 = 1, 当前行 = 1;

控件个数 = 0;

起始左边距 = 0;

起始到顶距 = 窗口到顶距 + 行间距离 + 部件序号;

for (int j = 0; j < 表格列名[1].length; j++) {

JLabel 标签 = new JLabel(表格列名[1][j], 11);

文本框[j] = new JTextField(" ");

if ((大数据类型.lastIndexOf("," + 表列数据类型[j] + ",")) < 0) {

panel1.add(标签);

if ((代码表数据[j][0] != null) && (代码表数据[j][0].length() == 0)) {

panel1.add((Component) 文本框[j]);

if ((位置参数[j][0] == 当前行) && (位置参数[j][1] == 当前列)) {

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

当前列++;

} else if (位置参数[j][0] == 当前行) {

当前列++;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

} else {

起始到顶距 = 起始到顶距 + 行间距离 + 字符高度;

当前行++;

起始左边距 = 0;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

文本框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

当前列 = 2;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

}

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

文本框[j].setFont(new Font("宋体", 1, 14));

文本框[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

int n1 = 0;

for (int i = 0; i < 表格列名[0].length; i++)

if (s1.lastIndexOf("," + 位置参数[i][0] + ","

+ 位置参数[i][1] + ",") > 0) {

当前列号 = i;

break;

}

}

});

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

文本数组[控件个数].setText(""); // 控件个数

文本数组号[控件个数] = j;

控件个数++;

} else {

组合框[j] = new JComboBox();

文本框[j] = new JTextField();

组合框[j].setEditable(true);// 确定 JComboBox 字段是否可编辑

组合框[j].setEnabled(true); // 启用组合框以便可以选择项

panel1.add((Component) 组合框[j]);

if ((位置参数[j][0] == 当前行) && (位置参数[j][1] == 当前列)) {

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

组合框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

当前列++;

} else if (位置参数[j][0] == 当前行) {

当前列++;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

组合框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

} else {

起始到顶距 = 起始到顶距 + 行间距离 + 字符高度;

当前行++;

起始左边距 = 0;

标签.setBounds(起始左边距 * 字符宽度, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

组合框[j].setBounds(起始左边距 * 字符宽度 + 列名长度 * 字符宽度, 起始到顶距,

表列数据宽度[j] * 字符宽度, 字符高度);

位置参数[j][0] = 起始左边距 * 字符宽度 + 列名长度 * 字符宽度;

位置参数[j][1] = 起始到顶距;

当前列 = 2;

起始左边距 = 起始左边距 + 列名长度 + 表列数据宽度[j];

}

for (int i = 0; i < 代码表数据[j].length; i++) {

String[] s0 = 代码表数据[j][i].split(",");

组合框[j].addItem(s0[0]);

}

文本数组[控件个数] = (JTextComponent) 组合框[j].getEditor()

.getEditorComponent();

文本数组[控件个数].setText("");

文本数组号[控件个数] = j;

控件个数++;

}

}

}

if (大数据个数 > 0) {

起始到顶距 = 起始到顶距 + 字符高度;

文本域高度 = (窗口高 - 起始到顶距 - 150) / 大数据个数;

起始左边距 = 0;

int 文本域宽度 = (文本区宽度 - 列名长度) * 字符宽度;

for (int j = 0; j < 表格列名[0].length; j++) {

if ((大数据类型.lastIndexOf("," + 表列数据类型[j] + ",")) >= 0) {

JLabel 标签 = new JLabel(表格列名[1][j], 11);

标签.setBounds(起始左边距, 起始到顶距, 列名长度 * 字符宽度, 字符高度);

if (main1.图形数据类型.lastIndexOf(表列数据类型[j]) >= 0) {

JLabel 图片框 = new JLabel("   ");

图片框.setBounds(起始左边距 + 列名长度 * 字符宽度, 起始到顶距, 文本域宽度, 文本域高度);

panel1.add(标签);

panel1.add(图片框);

图片数组[控件个数] = 图片框;

} else {

JTextArea 文本域 = new JTextArea("   ", 文本域宽度, 文本域高度);

JScrollPane 文本域滚动条 = new JScrollPane(文本域);

文本域滚动条.setBounds(起始左边距 + 列名长度 * 字符宽度, 起始到顶距, 文本域宽度,

文本域高度);

panel1.add(标签);

panel1.add((Component) 文本域滚动条);

文本数组[控件个数] = (JTextComponent) 文本域;

}

起始到顶距 = 起始到顶距 + 文本域高度;

文本数组号[控件个数] = j;

控件个数++;

}

}

}

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

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

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

}

}

if (大数据个数 == 0)

起始到顶距 = 起始到顶距 + 30 + 行间距离;

else

起始到顶距 = 起始到顶距 + 20;

计算文本框002();

int hl0 = 起始到顶距;

if (窗口高 != main1.窗口高)

hl0 = 窗口高 - 按钮行数 * (字符高度 + 30) - 150;

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

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

记录条数1 = 0;

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

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

String s3 = 表格数据[0][文本数组号[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

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

}

}

下一条.setEnabled(true);

上一条.setEnabled(false);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",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 (查询.getText().equals("查询")) {

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

记录条数1++;

else {

下一条.setEnabled(false);

}

上一条.setEnabled(true);

} else {

for (int j = 记录条数1 + 1; j <= 记录条数; j++) {

if (查询值.toLowerCase().trim()

.equals(表格数据[j][当前列号].toLowerCase().trim())) {

记录条数1 = j;

break;

} else if (j == 记录条数) {

下一条.setEnabled(false);

}

}

}

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

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

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else {

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",1,") >= 0)) {

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

panel1.add(下一条);

}

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

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

public void actionPerformed(ActionEvent e) {

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

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

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

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

}

下一条.setEnabled(false);

上一条.setEnabled(true);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",2,") >= 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 < 文本数组.length; i++) {

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

+ ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

}

下一条.setEnabled(true);

} else

上一条.setEnabled(false);

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",3,") >= 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("还原");

第一条.setEnabled(false);

下一条.setEnabled(true);

上一条.setEnabled(false);

最后一条.setEnabled(false);

} else {

查询.setText("查询");

记录条数1 = 0;

第一条.setEnabled(true);

下一条.setEnabled(true);

上一条.setEnabled(true);

最后一条.setEnabled(true);

}

if (查询.getText().trim().equals("还原")) {

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

if (当前列号 == 文本数组号[i]) {

查询值 = 文本数组[i].getText();

break;

}

for (int j = 0; j < 记录条数; j++)

if (查询值.toLowerCase().trim()

.equals(表格数据[j][当前列号].toLowerCase().trim())) {

记录条数1 = j;

break;

}

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

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

+ ",") >= 0) {

String s3 = 表格数据[记录条数1][文本数组号[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

图片数组[i].setOpaque(true);

图片数组[i].setBackground(Color.PINK);

图片数组[i].setIcon(icon);

}

} else

文本数组[i].setText(表格数据[记录条数1][文本数组号[i]]);

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[当前列号] + ",") >= 0)

查询条件 = 表格列名[0][当前列号] + "=" + 查询值;

else

查询条件 = 表格列名[0][当前列号] + "='" + 查询值 + "'";

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",4,") >= 0)) {

查询.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);

panel1.add(查询);

}

浏览 = new JButton(按钮集[5]);

浏览.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(窗口宽, 窗口高, 表格列名[1], n, 备份数据, 表列数据类型);

} else {

浏览.setText("浏览");

记录条数1 = main1.当前行行号;

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

文本数组[i].setText(表格数据[main1.当前行行号][文本数组号[i]]);

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",5,") >= 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 < 文本数组.length; i++) {

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

文本数组值[i] = 文本数组[i].getText().trim();

if (文本数组值[i].trim().equals("null"))

文本数组值[i] = " ";

} else {

文本数组值[i] = "?";

}

}

cont4 = main1.getConn();

try {

s1 = "insert into " + 表名 + "(";

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[文本数组号[j]]) < 0)

s1 = s1 + 表格列名[0][文本数组号[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

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

if (main1.图形数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]

+ ",") >= 0)

s1 = s1; // 图形字段不在本程序录入

else if (main1.数字数据类型.lastIndexOf(","

+ 表列数据类型[文本数组号[j]] + ",") >= 0)

s1 = s1 + 文本数组值[j] + ",";

else if (文本数组值[j].trim().equals("?")) // 本句将不改变s1

s1 = s1;

else

s1 = s1 + "'" + 文本数组值[j].trim() + "',";

}

s1 = s1.substring(0, s1.length() - 1) + ")";

s3 = "";

boolean bool = true;

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

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

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

s3 = s3 + 文本数组值[i];

break;

}

}

for (int i = 0; i < 记录条数; i++) {

s4 = "";

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

s4 = s4 + 表格数据[i][关键字序号[j]].trim();

}

if (s3.toLowerCase().trim()

.equals(s4.toLowerCase().trim())) {

bool = false;

JOptionPane.showMessageDialog(null,

"关键字重复，请修改后再录入！");

break;

}

}

if (bool) {

PreparedStatement pst4 = cont4.prepareStatement(s1); // 完成录入

char x1 = 10, x2 = 13;

int k2 = 1;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

记录条数++;

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

表格数据[记录条数 - 1][文本数组号[k]] = 文本数组值[k];

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "存盘语句错！" + s1);

}

int t = 0;

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

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

t = 0;

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

if (i == 关键字序号[j])

t = 1;

if (t == 0)

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

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",6,") >= 0)) {

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

panel1.add(存盘);

}

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

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

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

}

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",7,") >= 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 < 文本数组.length; i++)

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

文本数组值[i] = 文本数组[i].getText().trim();

if (文本数组值[i].equals("null")) {

文本数组值[i] = " ";

}

} else {

文本数组值[i] = "?";

}

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 {

s1 = "update " + 表名 + " set ";

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[文本数组号[j]]) < 0) {

s1 = s1 + 表格列名[0][文本数组号[j]] + "=";

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[文本数组号[j]]

+ ",") >= 0)

s1 = s1 + 文本数组值[j];

else if (文本数组值[j].trim().equals("?"))

s1 = s1 + 文本数组值[j];

else

s1 = s1 + "'" + 文本数组值[j].trim() + "'";

s1 = s1 + ",";

}

}

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 = 表格列名[0][文本数组号[i]];

}

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

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

表格数据[记录条数1][文本数组号[k]] = 文本数组值[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",8,") >= 0)) {

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

panel1.add(修改存盘);

}

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

删除.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

文本数组值[i] = 文本数组[i].getText().trim();

}

s2 = "";

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

for (int i = 0; i < 文本数组.length; 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();

for (int i = 记录条数1; i < 记录条数 - 1; i++)

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

表格数据[i][文本数组号[k]] = 表格数据[i + 1][文本数组号[k]];

} // 删除后清除表格数据中的数据

记录条数--;

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[k]) < 0)

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

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "删除语句错！" + s1);

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",9,") >= 0)) {

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

panel1.add(删除);

}

批处理 = new JButton(按钮集[10]);

批处理.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

s2 = "";

if (查询.getText().trim().equals("还原")) {

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

if (当前列号 == 文本数组号[i]) {

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[当前列号]

+ ",") >= 0)

s2 = "update " + 表名 + " set " + 表格列名[0][当前列号]

+ "=" + 文本数组[i].getText() + " where "

+ 查询条件;

else

s2 = "update " + 表名 + " set " + 表格列名[0][当前列号]

+ "='" + 文本数组[i].getText().trim()

+ "' where " + 查询条件;

break;

}

} else {

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

if (当前列号 == 文本数组号[i]) {

if (main1.数字数据类型.lastIndexOf("," + 表列数据类型[当前列号]

+ ",") >= 0)

s2 = "update " + 表名 + " set " + 表格列名[0][当前列号]

+ "=" + 文本数组[i].getText();

else

s2 = "update " + 表名 + " set " + 表格列名[0][当前列号]

+ "='" + 文本数组[i].getText().trim() + "'";

break;

}

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

stat4.executeUpdate(s2);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "批删除语句错！");

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",10,") >= 0)) {

批处理.setBounds(按钮位置[10][0], 按钮位置[10][1], 按钮位置[10][2], 按钮位置[10][3]);

panel1.add(批处理);

}

图片存盘 = new JButton(按钮集[11]);

按钮数组[11] = 图片存盘;

图片存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

文本数组值[i] = 文本数组[i].getText().trim();

if (文本数组值[i].equals("null")) {

文本数组值[i] = " ";

}

} else {

文本数组值[i] = "?";

}

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 {

s1 = "update " + 表名 + " set ";

int n = s1.length();

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

if (文本数组值[j].trim().equals("?"))

if (s1.length() == n)

s1 = s1 + 表格列名[0][文本数组号[j]] + "=" + 文本数组值[j];

else

s1 = s1 + "," + 表格列名[0][文本数组号[j]] + "="

+ 文本数组值[j];

}

s1 = s1 + " where " + s2;

PreparedStatement pst4 = cont4.prepareStatement(s1);

char x1 = 10, x2 = 13;

int k2 = 1;

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

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

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

+ ",") >= 0) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

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

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

表格数据[记录条数1][文本数组号[k]] = 文本数组值[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",11,") >= 0)) {

图片存盘.setBounds(按钮位置[11][0], 按钮位置[11][1], 按钮位置[11][2], 按钮位置[11][3]);

panel1.add(图片存盘);

}

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

按钮数组[12] = 退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if ((要求按钮号表.length() < 3) || (要求按钮号表.lastIndexOf(",12,") >= 0)) {

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

panel1.add(退出);

}

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

panel1.setBounds(10, 10, 窗口宽 + 50, 窗口高 - 20);

int w1, h1;

if (1200 - 窗口宽 > 0)

w1 = (1200 - 窗口宽) / 2;

else

w1 = 0;

if (600 - 窗口高 > 0)

h1 = (600 - 窗口高) / 2;

else

h1 = 0;

frame1.setBounds(w1, h1, 窗口宽 + 50, 窗口高); // 主程序窗口位置大小

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

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

frame1.setVisible(true);

}

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;

起始左边距 = 0;

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)) { // 如果按钮换行

起始左边距 = 0;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

if ((实际按钮数 - n1) <= 一行按钮数)

按钮宽度 = (窗口宽 - 60) / (实际按钮数 - n1);

else

按钮宽度 = (窗口宽 - 60) / 一行按钮数;

n = 0;

n2++; // 按钮行数

} else if (n >= 一行按钮数) {

起始左边距 = 0;

起始到顶距 = 起始到顶距 + 字符高度 + 20;

n = 0;

n2++;

}

}

}

窗口高 = 起始到顶距 + 字符高度 + 100;

}

}

73.源码73，部件程序，表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签、可显示与录入图片。

/**

 * 程序文件名：dataTenance4.java

 * 作者：程学先 

 * 功能：表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签、可显示与录入图片。

 * 本程序设计在每次调用时使用不同类名，更能防止多次同时并发调用时可能出现的不稳定。

 * 对image类型未做特殊排版，如有image字段，在录入和修改操作后需要再点击“图片存盘”按钮，

 * 将提问图像文件名，回答之后完成图片录入。

 * 根据main1.java程序中数据设置窗口宽度与高度。

 * 当无其他大数据类型时，在窗口中按每字段一行安排控件，各字段统一长度。

 * 如果有包括图片类型的大数据类型字段，或字段数量多且设置窗口大小后导致按每行一排安排不下，

 * 也会按各字段实际大小，用比较紧凑的方式布局。。

 * 如果有大数据类型，一般字段按各字段实际大小紧凑布局之后，余下空间均匀分配给大数据类型。

 * 用途：以文本框、按钮等构成单记录数据维护界面作数据录入、修改数据库中数据、删除数据库中数据等使用。 

 * 完成日期：2013年10月11日

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

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

 * 可选择提供的参数：“窗口宽”、“窗口高”、“要求字段号表”、“要求按钮号表”。

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

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

 * 要求字段号表：所操作数据可以是表的全部字段，也可以只涉及部分字段。如果选择全部字段，初始值设为""；

 * 否则写入所有将涉及的字段在表中的顺序后，号与号之间以英文逗号分隔。

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

 * “修改存盘”、“图片存盘”、“删除”、“批处理”、“退出”共 13 个。

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

 * 在序号后可加分号之后跟变换名，可改变按钮名称。 

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

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

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

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

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

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

 * 如果要根据条件选择的结果将满足条件的记录某一字段数据全部改为某数据，

 * 需要先进行查询，再在某字段文本框中输入改后数据，之后点击“批处理”按钮。

 * 查询只限等值查询，要求先在某字段文本框中输入欲查询的数据值，再点击查询按钮，实现该字段等于该值的查询。

 * 注意本程序适用于由基本数据类型构成的数据表，适用数据类型包括各类整型、各浮点类型、各char数据类型、各text数据类型。

 * 本程序提供各字段共用列表框,可以利用鼠标选择代码表中数据或历史数据录入。

 * 代码表名字为字段名加“代码表”，其中，统一为二个字段，一个字段名与数据表中字段名相同，

 * 另一个为数据表中字段名再加“代码”或字段名中去掉“代码”二字。

 * 例如，关于性别，设计用0表示男，1表示女，

 * 其代码表的名字必须为：“性别代码表”，当数据表中字段名为“性别”时，代码表中设计“性别”、“性别代码”二个字段

 * 如果，数据表中字段名为“性别代码”，代码表中仍然是“性别”、“性别代码”二个字段，都是二条记录：男  0；女  1。

 * 在数据表中字段名如果为“性别代码”，在列表框中显示0  1；录入保存的是0或1。

 * 如果数据表中字段名为性别，那么，列表框中显示男   女，录入保存的是男或女。

 * 如果使用字典表，要求在当前数据库中有表的表名带“字典表”3字，该表第一列为字段名，第2列为标签名。

 */

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

import java.sql.*;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Set;

import java.util.Vector;

import java.io.*;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JTextField;

import javax.swing.WindowConstants;

import javax.swing.text.JTextComponent;

import javax.swing.text.html.HTMLDocument.Iterator;

import javax.swing.event.DocumentListener;

import javax.swing.event.DocumentEvent;

public class dataTenance4 

{

private static JFrame framet1;

private static List list1;

private static JTextComponent[] 文本数组;

private static JLabel [] 图片数组;

private static int [] 文本数组号;

private static JButton[] 按钮数组=new JButton[13];

private static Connection cont4; 

private static Statement stat4;   

private static ResultSetMetaData rsmdt4;

private static ResultSet rs; 

private static String 表名 ;

private static String 表名表 ; 

private static String 字典表名;

private static int 窗口宽 =main1.窗口宽;

private static int 窗口高 = main1.窗口高;

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

private static int 列数; 

private static int 表格列数[]=new int[10]; 

private static String[][] 列名; 

private static String[][][] 表格列名=new String[10][2][];

private static String[] 列数据类型; 

private static String[][] 表列数据类型=new String[10][]; 

private static int[] 列数据宽度;

private static int[] 表列数据宽度; 

private static int [] 记录条数=new int[10];

private static int [] 记录条数1=new int[10];

private static String[][][] 表格数据=new String[10][][];

private static String[][][] 代码表数据=new String[10][][];

private static String  [][] 文本数组值=new String[10][];

static String[][] 备份数据; 

private static String 要求按钮号表 ;

private static int 实际按钮数=0;

private static String 要求字段号表 ;

private static String[][] 一条空记录=new String[10][];

private static String 列名表=""; 

private static String[][] 关键字段名=new String[10][];

private static String[][] 关键字段值=new String[10][];

private static int[] 关键字序号;

private static String s1 = "", s2 = "",s3="",s4="",s5=""; 

private static String 查询条件 = "",查询值="";

private static int b = 0, c = 0;

private static String[] 当前字段值;

private static int[] 列序号;

private static int 当前行号=0,当前列号=0; 

private static int [][][] 位置参数=new int[10][][]; 

private static int 控件个数=0;

private static String 键盘输入字串="";

private static int list框宽度=100;

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

private static String[] 按钮集={"第一条","下一条","最后一条","上一条","查询","浏览","存盘"

,"清屏","修改存盘","删除","批处理","图片存盘","退出"};

private static JButton b1;                    

private static  JButton 第一条,下一条,最后一条,上一条,查询,浏览,存盘,清屏,修改存盘,删除,批处理,图片存盘,退出;

private static String 大数据类型=main1.文本数据类型 + main1.图形数据类型;

private static int list调整值=0; 

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

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

private static int 行间距离=0; 

private static int 最大宽度=0;   

private static int 起始左边距,文本域高度; 

private static int 末列行号=0;

private static int 按钮行数;

private static int 文本控件行数=1;

private static int 起始到顶距=0;

private static int 大数据个数=0;

private static int 按钮定义标志;

static void means(String parameter[],JFrame frame1) {

窗口左边距 =main1.窗口左边距;窗口到顶距= main1.窗口到顶距;

表格列数=new int[10]; 

表格列名=new String[10][2][];

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

记录条数=new int[10];

记录条数1=new int[10];

表格数据=new String[10][][];

代码表数据=new String[10][][];

文本数组值=new String[10][];

实际按钮数=0;文本域高度=0;

一条空记录=new String[10][];

列名表="";关键字段名=new String[10][];

关键字段值=new String[10][]; s1 = ""; s2 = "";s3="";s4="";s5=""; 

查询条件 = "";查询值=""; b = 0; c = 0;

当前行号=0;当前列号=0; 按钮定义标志=0;

位置参数=new int[10][][]; 

控件个数=0;键盘输入字串=""; list框宽度=100;

字符宽度=15;字符高度=20;  

大数据类型=main1.文本数据类型 + main1.图形数据类型;

list调整值=0; 

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

窗口宽=main1.窗口宽;  窗口高=main1.窗口高;

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 ;

   窗口高=m2 ;

}

}catch(Exception e2){}

表名=parameter[4] ;

        表名表=","+parameter[0]+","; 

        String [] t1=parameter[0].split(",");

        字典表名="";

        if (表名表.lastIndexOf(表名+"字典表")>=0) 

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

       if (t1[i].lastIndexOf(表名+"字典表")>=0) 字典表名=t1[i];

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

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

       return;

    }

final int 部件序号=Integer.parseInt(parameter[21]);  

关键字段名[部件序号]=parameter[6].split(",");

关键字段值[部件序号]=new String[关键字段名[部件序号].length];;

要求字段号表=parameter[8] ; 

关键字序号=new int[关键字段名[部件序号].length];

framet1=frame1;

按钮数组=new JButton[13];

framet1=frame1;

按钮数组=new JButton[13];

try

{ 

cont4=main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + 表名; // 查取全表数据

rs = stat4.executeQuery(s1);

rs.last();

记录条数[部件序号] = rs.getRow(); 

rsmdt4 = rs.getMetaData();

列数 = rsmdt4.getColumnCount();

列名 = new String[2][列数]; 

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

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

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

    列名[0][i] = rsmdt4.getColumnName(i + 1); 

    列名[1][i] = 列名[0][i];

列数据类型[i] = rsmdt4.getColumnTypeName(i + 1); 

列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);

if (字符宽度*(列数据宽度[i]+列名[1][i].length())+list框宽度>窗口宽) 列数据类型[i]="text";

}

for (int j = 0; j< 关键字段名[部件序号].length; j++)

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

           if (关键字段名[部件序号][j].toLowerCase().trim().equals(列名[0][i].toLowerCase().trim())) {

              关键字序号[j] = i;

               if ((要求字段号表.length() >0)&&((","+要求字段号表+",").lastIndexOf(","+i+",")<0))

                        要求字段号表=要求字段号表+","+i;

             break;

           }

           }

      rs.close();   

      if (字典表名.length()>0){  

      s1 = "select * from " + 字典表名; 

      rs = stat4.executeQuery(s1);

                  ResultSetMetaData rsmd = rs.getMetaData();

         rs.last();  //移动指针到最后一行

                    int numberOfColumns=rs.getRow();  

                    rs.first();//移动指针到第一行

                   String s4="";

                   String s5="";

                for (int i=1;i<=numberOfColumns;i++){

                  rs.absolute(i);

                       s4=rs.getString(1);

                       s5=rs.getString(2);

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

                         if (列名[0][j].toLowerCase().trim().equals(s4.trim().toLowerCase())){

                      列名[1][j]=s5;

                      break;

                      }

                       }

                    }

                 rs.close();  

      }

  } catch (SQLException e)

{

JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1);

}

要求字段号表 = "," + 要求字段号表 + ",";

列序号 = new int[列数]; 

int b0 = 0, b = -1;

while (b0 < 列数) {

if ((要求字段号表.length() < 3)

|| (要求字段号表.lastIndexOf(","+b0+",") >= 0))

{

b = b + 1;

列序号[b] = b0; 

}

b0++;

}

表格列数[部件序号] = b + 1; 

表格列名[部件序号] = new String[2][表格列数[部件序号]]; 

表列数据类型[部件序号] = new String[表格列数[部件序号]]; 

表列数据宽度 = new int[表格列数[部件序号]];

表格数据[部件序号] = new String[记录条数[部件序号]+300][表格列数[部件序号]]; 

代码表数据[部件序号] = new String [表格列数[部件序号]][]; 

        一条空记录[部件序号] = new String[表格列数[部件序号]];

        int 列名长度=0; 

  大数据个数=0; 

int 最大字段宽=0; 

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

      b=0;

while (b < 表格列数[部件序号]){

表格列名[部件序号][0][b] = 列名[0][列序号[b]]; 

表格列名[部件序号][1][b] = 列名[1][列序号[b]];  

列名表=列名表+表格列名[部件序号][0][b];

表列数据类型[部件序号][b] = 列数据类型[列序号[b]];

表列数据宽度[b] = 列数据宽度[列序号[b]];  

    if (表格列名[部件序号][1][b].length()>列名长度) 列名长度=表格列名[部件序号][1][b].length();

    if ((大数据类型.indexOf(","+表列数据类型[部件序号][b]+",")<0)&&(最大字段宽<(表格列名[部件序号][1][b].length()+表列数据宽度[b])*字符宽度)){

    最大字段宽=(表格列名[部件序号][1][b].length()+表列数据宽度[b])*字符宽度;

    }

    if (大数据类型.indexOf(","+表列数据类型[部件序号][b]+",")>=0)

    大数据个数++;  

    b++;

}

if (大数据个数==0){

  if (需求面积+list框宽度*(窗口高-120)+窗口宽*80<窗口高*窗口宽){

  if (最大字段宽<list框宽度*1.5) 

  最大字段宽=(int)(list框宽度*1.5);

  if (原窗口高<窗口高) 窗口高=原窗口高;

  if (窗口高*4>窗口宽*3) 窗口宽=窗口高*4/3;//黄金分割点

  if (原窗口宽<窗口宽) 窗口宽=原窗口宽;

  }

  if (窗口宽<500) 窗口宽=500;

  if (窗口高<300) {

  窗口高=300;

  }

 if (原窗口高>窗口高+大数据个数*40)  窗口高=窗口高+大数据个数*40;

 else 窗口高=原窗口高;

}

             int 文本区宽度=(窗口宽-list框宽度-30)/16;

b = 0;

while (b < 表格列数[部件序号])

{

            if (大数据类型.lastIndexOf(","+表列数据类型[部件序号][b]+",") >= 0)

            大数据个数++;

if ((列名长度+表列数据宽度[b])>(文本区宽度))  {   

      表列数据宽度[b]=文本区宽度-列名长度;  

   }

if (表列数据类型[部件序号][b].indexOf("datetime") == 0)

一条空记录[部件序号][b] = "2001-01-01 00:00:00.000";

else if (表列数据类型[部件序号][b].indexOf("smalldatetime") == 0)

一条空记录[部件序号][b] = "2001-01-01 00:00:00";

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

else if (表列数据类型[部件序号][b].indexOf("datetime2") == 0)

一条空记录[部件序号][b] = "2001-01-01 00:00:00.0000000";

else if (表列数据类型[部件序号][b].indexOf("datetimeoffset") == 0)

一条空记录[部件序号][b] = "2001-01-01 00:00:00.0000000 +08:00";

else if (表列数据类型[部件序号][b].indexOf("date") == 0)

一条空记录[部件序号][b] = "2001-01-01";

else if (表列数据类型[部件序号][b].indexOf("time") == 0)

一条空记录[部件序号][b] = "00:00:00";

else if (表列数据类型[部件序号][b].indexOf("money") >= 0)

一条空记录[部件序号][b] = "0.0000";

else if (main1.小数型数据类型.lastIndexOf(","+表列数据类型[部件序号][b]+",") >= 0)

一条空记录[部件序号][b] = "0.00";

else if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][b]+",") >= 0)

                一条空记录[部件序号][b]  = "0";

else

                   一条空记录[部件序号][b]  = "";

    b++;

}

for (int j = 0; j< 关键字段名[部件序号].length; j++){

for (int i = 0; i< 表格列数[部件序号]; i++){

if (关键字序号[j]==i) 关键字序号[j]=列序号[i];  

}

}

   try{

s1 = "select * from " + 表名; 

rs = stat4.executeQuery(s1);

        rs.absolute(1); 

c = 0; 

b = 0; 

while (c < 记录条数[部件序号])

{

rs.absolute(c + 1); 

while (b < 表格列数[部件序号])

{

表格数据[部件序号][c][b] = rs.getString(列序号[b] + 1); 

b++;

}

c++;

b = 0;

}

      rs.close();    

      stat4.close();  

      cont4.close();

} catch(SQLException e2){

JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1);

}

    try

{            

for (int j=0;j<表格列数[部件序号];j++){

        int u=0;    

        if ((表名表.lastIndexOf(","+表格列名[部件序号][0][j]+"表,")>=0)&&(表格列名[部件序号][0][j].indexOf("代码")>=0)) {

        s2=表格列名[部件序号][0][j].substring(0,表格列名[部件序号][0][j].length()-2);

      s1 = "select "+表格列名[部件序号][0][j]+","+s2+" from " + 表格列名[部件序号][0][j]+"表";

      u=1;

        } else if(表名表.lastIndexOf(","+表格列名[部件序号][0][j]+"代码表,")>=0){

        s2=表格列名[部件序号][0][j].substring(0,表格列名[部件序号][0][j].length()-2);

        s1 = "select "+表格列名[部件序号][0][j]+","+表格列名[部件序号][0][j]+"代码"+" from " + 表格列名[部件序号][0][j]+"代码表";

        u=1;

        }

           if (u==1){

                     cont4=main1.getConn();

                     stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

                      ResultSet.CONCUR_UPDATABLE); 

                     rs = stat4.executeQuery(s1);

                   ResultSetMetaData rsmd1 = rs.getMetaData();

         rs.last();  //移动指针到最后一行

                    int numberOfColumns=rs.getRow();  

                    rs.first();//移动指针到第一行

            代码表数据[部件序号][j] = new String [numberOfColumns]; 

                   for (int i=1;i<=numberOfColumns;i++){

                  rs.absolute(i);

                  代码表数据[部件序号][j][i-1]=rs.getString(1)+","+rs.getString(2);

                    }

                   rs.close();

                   stat4.close();   

                   cont4.close();

           }

     }

} catch(SQLException e3){

JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1);

}

    final JPanel panel1 = new JPanel(false); 

panel1.setLayout(null);  

panel1.setBounds(10, 10,窗口宽-10,窗口高-50);

JLabel jl = new JLabel("字段可选内容  :");

jl.setBounds(10, 10,list框宽度, 字符高度); 

list1 = new List();

panel1.add(jl);

行间距离=0; 

最大宽度=0;   

起始左边距=list框宽度/字符宽度+1; 

位置参数[部件序号]=new int[表格列数[部件序号]][2];

末列行号=0;

文本控件行数=1;

if ((实际按钮数*字符宽度*6.3)%(窗口宽-50)==0) 按钮行数=(int)(实际按钮数*字符宽度*6.3)%(窗口宽-50);

else 按钮行数=(实际按钮数*字符宽度*6)/(窗口宽-50)+1;

if ((大数据个数==0)&&(表格列数[部件序号]*字符高度+按钮行数*字符高度+40<窗口高)){

文本控件行数=表格列数[部件序号]; //没有大数据，且在窗口可以按每控件一排安排全部控件

for (int j=0;j<表格列数[部件序号];j++){

位置参数[部件序号][j][0]=1+j; 

位置参数[部件序号][j][1]=1;  

表列数据宽度[j]=文本区宽度-列名长度;

}

行间距离=(窗口高-120-(按钮行数+表格列数[部件序号])*字符高度)/(按钮行数+表格列数[部件序号]+1);

}

else 

{    //有大数据或空间较小，需要紧凑安排

  int 当前列列号=1;

      int 最大宽度0=0;

  for (int i=0;i<表格列数[部件序号];i++)  {

   if (大数据类型.lastIndexOf(","+表列数据类型[部件序号][i]+",")<0) {

        if  ((最大宽度+列名长度+表列数据宽度[i])<=文本区宽度) { 

             最大宽度=最大宽度+列名长度+表列数据宽度[i]; 

             位置参数[部件序号][i][0]=文本控件行数;   

              起始左边距=起始左边距+列名长度+表列数据宽度[i];

             位置参数[部件序号][i][1]=当前列列号;

                      if (最大宽度0<最大宽度) 最大宽度0=最大宽度;

             末列行号=i;

                                    当前列列号++;

        }   

        else   {   //换行

if (最大宽度0<最大宽度) 最大宽度0=最大宽度;

                   文本控件行数++;

                                         当前列列号=1;

                    位置参数[部件序号][i][0]=文本控件行数;

                   位置参数[部件序号][i][1]=当前列列号;

                                  当前列列号++;

                    最大宽度=列名长度+表列数据宽度[i];  

                    起始左边距=list框宽度/字符宽度+1+列名长度+表列数据宽度[i];

        }

        b=i;

   }    //非大数据

 }

最大宽度0=0;

int n=0,n1=0;

for (int i = 0; i < 表格列数[部件序号]; i++) {

if (大数据类型.lastIndexOf("," + 表列数据类型[部件序号][i] + ",") < 0) {

if ((i>0)&&(位置参数[部件序号][i][0]>n)) { //换行

if (最大宽度0<文本区宽度) {

表列数据宽度[i-1]=表列数据宽度[i-1]+(文本区宽度-最大宽度0);

}

else {

表列数据宽度[i-1]=表列数据宽度[i-1]-(文本区宽度-最大宽度0);

}

最大宽度0=0;

}

n=位置参数[部件序号][i][0];

最大宽度0=最大宽度0 + 列名长度 + 表列数据宽度[i];

n1=i;

}

}

if (最大宽度0<文本区宽度) 

表列数据宽度[n1]=表列数据宽度[n1]+(文本区宽度-最大宽度0);

if (大数据个数>0) 行间距离=0; 

 else

        行间距离=(窗口高-120-按钮行数*字符高度-文本控件行数*字符高度)/(文本控件行数+按钮行数+1);

}

          文本数组 = new JTextComponent[表格列数[部件序号]];

           图片数组=new JLabel[表格列数[部件序号]];

           文本数组值[部件序号] = new String[文本数组.length];

           文本数组号= new int[文本数组.length];

            int 当前列=1,当前行=1;

            控件个数=0;

            起始左边距=list框宽度/字符宽度+部件序号; 

            起始到顶距=窗口到顶距+行间距离+部件序号; 

     for (int j = 0; j < 表格列名[部件序号][1].length; j++) {

JLabel 标签 = new JLabel(表格列名[部件序号][1][j], 11); 

JTextField 文本框 = new JTextField(" ");

            if ((大数据类型.lastIndexOf(","+表列数据类型[部件序号][j]+","))<0) {

            panel1.add(标签);

            panel1.add((Component)文本框);

if ((位置参数[部件序号][j][0]==当前行)&&(位置参数[部件序号][j][1]==当前列)){

   标签.setBounds(起始左边距*字符宽度,起始到顶距,列名长度*字符宽度,字符高度);  

文本框.setBounds(起始左边距*字符宽度+列名长度*字符宽度,起始到顶距,表列数据宽度[j]*字符宽度,字符高度);  

位置参数[部件序号][j][0]=起始左边距*字符宽度+列名长度*字符宽度;

位置参数[部件序号][j][1]=起始到顶距;

起始左边距=起始左边距+列名长度+表列数据宽度[j];

当前列++;

  }

 else if (位置参数[部件序号][j][0]==当前行){   

当前列++;

标签.setBounds(起始左边距*字符宽度,起始到顶距,列名长度*字符宽度,字符高度);

文本框.setBounds(起始左边距*字符宽度+列名长度*字符宽度,起始到顶距,表列数据宽度[j]*字符宽度,字符高度); 

位置参数[部件序号][j][0]=起始左边距*字符宽度+列名长度*字符宽度;

位置参数[部件序号][j][1]=起始到顶距;

起始左边距=起始左边距+列名长度+表列数据宽度[j];

 }

else { 

起始到顶距=起始到顶距+行间距离+字符高度;

当前行++;

起始左边距=list框宽度/字符宽度+部件序号;

标签.setBounds(起始左边距*字符宽度,起始到顶距,列名长度*字符宽度,字符高度); 

文本框.setBounds(起始左边距*字符宽度+列名长度*字符宽度,起始到顶距,表列数据宽度[j]*字符宽度,字符高度);

位置参数[部件序号][j][0]=起始左边距*字符宽度+列名长度*字符宽度;

位置参数[部件序号][j][1]=起始到顶距;

当前列=2; 

起始左边距=起始左边距+列名长度+表列数据宽度[j];

}

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

文本框.addFocusListener(new FocusAdapter() {      

public void focusGained(final FocusEvent arg0) {

        Object s0=arg0.getSource();

String s1 = s0.toString();

int n1=0;

for (int i = 0; i < 表格列名[部件序号][0].length; i++) 

   if (s1.lastIndexOf(","+位置参数[部件序号][i][0]+","+位置参数[部件序号][i][1]+",")>0){

当前列号=i;

break;

  }

list1.removeAll(); 

if((表名表.lastIndexOf(","+表格列名[部件序号][0][当前列号]+"代码表,")>=0)||

((表格列名[部件序号][0][当前列号].indexOf("代码")>=0)&&(表名表.lastIndexOf(","+表格列名[部件序号][0][当前列号]+"表,")>=0)))

for (int i=0;i<代码表数据[部件序号][当前列号].length;i++){//如果有代码表

     list1.add(代码表数据[部件序号][当前列号][i]);

}

else {//如果没有代码表

   int u1=0; 

for (int j = 0; j < 记录条数[部件序号]; j++) {

   int u2=0;  

   for (int k=0;k<u1;k++){ 

      if (表格数据[部件序号][j][当前列号]==null)

                                          表格数据[部件序号][j][当前列号]=" ";

      if (表格数据[部件序号][j][当前列号].toLowerCase().trim().equals(list1.getItem(k).trim().toLowerCase())){

      u2++;

      break ;

      }

    }

     if (u2==0) {   

      list1.add(表格数据[部件序号][j][当前列号]);

      u1++;

      }

   }

 }

}

});

文本数组[控件个数] = (JTextComponent)文本框;

        文本数组号[控件个数] = j;

控件个数++;

}

     }

     if (大数据个数>0){

起始到顶距=起始到顶距+字符高度;

文本域高度=(窗口高-起始到顶距-150)/大数据个数;

起始左边距=list框宽度+部件序号;

int 文本域宽度=(文本区宽度-列名长度)*字符宽度;

for (int j = 0; j < 表格列名[部件序号][0].length; j++){ 

  if ((大数据类型.lastIndexOf(","+表列数据类型[部件序号][j]+","))>=0) {

JLabel 标签 = new JLabel(表格列名[部件序号][1][j], 11); 

标签.setBounds(起始左边距,起始到顶距,列名长度*字符宽度,字符高度); 

if (main1.图形数据类型.lastIndexOf(表列数据类型[部件序号][j])>=0){

JLabel 图片框=new JLabel("   ");

图片框.setBounds(起始左边距+列名长度*字符宽度,起始到顶距,文本域宽度,文本域高度);

panel1.add(标签);

panel1.add(图片框);

图片数组[控件个数] = 图片框;

}

else {

JTextArea 文本域=new JTextArea("   ",文本域宽度,文本域高度);

JScrollPane 文本域滚动条 = new JScrollPane(文本域);

文本域滚动条.setBounds(起始左边距+列名长度*字符宽度,起始到顶距,文本域宽度,文本域高度);

      panel1.add(标签);

      panel1.add((Component)文本域滚动条);

               文本数组[控件个数] = (JTextComponent)文本域;

}

起始到顶距=起始到顶距+文本域高度;

文本数组号[控件个数] = j;

控件个数++;

}

      }

   }

起始左边距=20+部件序号;

if (大数据个数==0)

      起始到顶距=起始到顶距+30+行间距离;

else 起始到顶距=起始到顶距+20;

list1.addMouseListener(new MouseAdapter() {

public void mouseClicked(MouseEvent evt) {

 String s4="";

 String [] s5;

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

    if (文本数组号[i]==当前列号){

    s4=list1.getSelectedItem();

              if (s4 != null){}  else s4=""; 

      if (s4.lastIndexOf(",")>0){  

       s5=s4.split(",");

    文本数组[i].setText(s5[0]);

    }

    else

    文本数组[i].setText(list1.getSelectedItem());

    }

   }

});

计算文本框002();

  int hl0=起始到顶距;  

  if (窗口高!=main1.窗口高) hl0=窗口高- 按钮行数*(字符高度+30)-150;

list1.setBounds(10, 40,list框宽度, hl0);  

panel1.add(list1);

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

第一条.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

 记录条数1[部件序号]=0;  

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

if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

String s3=表格数据[部件序号][0][文本数组号[i]];

if ((s3!=null)&&(s3.length()>10)){                 

byte []c=new byte[s3.length()];

for (int j=0;j<s3.length();j++){

int n1=Integer.parseInt(s3.substring(j,j+1),16);

int n2=Integer.parseInt(s3.substring(j+1,j+2),16);

c[j/2]=(byte)(n1*16+n2);

j++;

}

            Icon icon = new ImageIcon(c);

            图片数组[i].setOpaque(true);

            图片数组[i].setBackground(Color.PINK);

            图片数组[i].setIcon(icon);

}

else {

byte []c={0};

          Icon icon = new ImageIcon(c);

                   图片数组[i].setOpaque(true);

                   图片数组[i].setBackground(Color.PINK);

                   图片数组[i].setIcon(icon);

}

}

else  {

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

}

   }

下一条.setEnabled(true);

上一条.setEnabled(false);

 }

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",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 (查询.getText().equals("查询")){ 

           if (记录条数1[部件序号]<记录条数[部件序号]-1)  

             记录条数1[部件序号]++;   

           else {

          下一条.setEnabled(false);

            }

        上一条.setEnabled(true);

          }

   else{

            for (int j=记录条数1[部件序号]+1;j<=记录条数[部件序号];j++){

            if (查询值.toLowerCase().trim().equals(表格数据[部件序号][j][当前列号].toLowerCase().trim())){

          记录条数1[部件序号]=j;

          break;

          }

          else if (j==记录条数[部件序号]){

              下一条.setEnabled(false);

          }

            }

   }

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

if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

String s3=表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]];

if ((s3!=null)&&(s3.length()>10)){                 

byte []c=new byte[s3.length()];

for (int j=0;j<s3.length();j++){

int n1=Integer.parseInt(s3.substring(j,j+1),16);

int n2=Integer.parseInt(s3.substring(j+1,j+2),16);

c[j/2]=(byte)(n1*16+n2);

j++;

}

            Icon icon = new ImageIcon(c);

            图片数组[i].setOpaque(true);

            图片数组[i].setBackground(Color.PINK);

            图片数组[i].setIcon(icon);

}

else {          

byte []c={0};

          Icon icon = new ImageIcon(c);

                   图片数组[i].setOpaque(true);

                   图片数组[i].setBackground(Color.PINK);

                   图片数组[i].setIcon(icon);

}

}

else{   

  文本数组[i].setText(表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]]);

}

}

    }

     });

    if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",1,")>=0)){

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

panel1.add(下一条);

    }

 

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

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

public void actionPerformed(ActionEvent e) {

记录条数1[部件序号]=记录条数[部件序号]-1;     //记录指针

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

if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

String s3=表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]];

if ((s3!=null)&&(s3.length()>10)){                 

byte []c=new byte[s3.length()];

for (int j=0;j<s3.length();j++){

int n1=Integer.parseInt(s3.substring(j,j+1),16);

int n2=Integer.parseInt(s3.substring(j+1,j+2),16);

c[j/2]=(byte)(n1*16+n2);

j++;

}

            Icon icon = new ImageIcon(c);

            图片数组[i].setOpaque(true);

            图片数组[i].setBackground(Color.PINK);

            图片数组[i].setIcon(icon);

}

else {

byte []c={0};

          Icon icon = new ImageIcon(c);

                   图片数组[i].setOpaque(true);

                   图片数组[i].setBackground(Color.PINK);

                   图片数组[i].setIcon(icon);

}

}

else

   文本数组[i].setText(表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]]);

  }

下一条.setEnabled(false);

上一条.setEnabled(true);

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",2,")>=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 < 文本数组.length; i++) {

if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

String s3=表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]];

if ((s3!=null)&&(s3.length()>10)){                 

byte []c=new byte[s3.length()];

for (int j=0;j<s3.length();j++){

int n1=Integer.parseInt(s3.substring(j,j+1),16);

int n2=Integer.parseInt(s3.substring(j+1,j+2),16);

c[j/2]=(byte)(n1*16+n2);

j++;

}

            Icon icon = new ImageIcon(c);

            图片数组[i].setOpaque(true);

            图片数组[i].setBackground(Color.PINK);

            图片数组[i].setIcon(icon);

}

else {

byte []c={0};

          Icon icon = new ImageIcon(c);

                   图片数组[i].setOpaque(true);

                   图片数组[i].setBackground(Color.PINK);

                   图片数组[i].setIcon(icon);

}

}

else

文本数组[i].setText(表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]]);

  }

下一条.setEnabled(true);

    }

    else 上一条.setEnabled(false);

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",3,")>=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("还原");

        第一条.setEnabled(false);

       下一条.setEnabled(true);

        上一条.setEnabled(false);

            最后一条.setEnabled(false);

       }

        else{ 

        查询.setText("查询");

        记录条数1[部件序号]=0;

            第一条.setEnabled(true);

       下一条.setEnabled(true);

        上一条.setEnabled(true);

            最后一条.setEnabled(true);

        }

        if (查询.getText().trim().equals("还原")){

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

                  if (当前列号==文本数组号[i]){

                 查询值=文本数组[i].getText(); 

                   break;

                  }

            for (int j=0;j<记录条数[部件序号];j++)

            if (查询值.toLowerCase().trim().equals(表格数据[部件序号][j][当前列号].toLowerCase().trim())) {

            记录条数1[部件序号]=j;

               break;

            }

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

        if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

        String s3=表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]];

        if ((s3!=null)&&(s3.length()>10)){                 

        byte []c=new byte[s3.length()];

        for (int j=0;j<s3.length();j++){

        int n1=Integer.parseInt(s3.substring(j,j+1),16);

        int n2=Integer.parseInt(s3.substring(j+1,j+2),16);

        c[j/2]=(byte)(n1*16+n2);

        j++;

        }

                    Icon icon = new ImageIcon(c);

                    图片数组[i].setOpaque(true);

                    图片数组[i].setBackground(Color.PINK);

                    图片数组[i].setIcon(icon);

        }

        else {

        byte []c={0};

                  Icon icon = new ImageIcon(c);

                           图片数组[i].setOpaque(true);

                           图片数组[i].setBackground(Color.PINK);

                           图片数组[i].setIcon(icon);

        }

        }

        else

        文本数组[i].setText(表格数据[部件序号][记录条数1[部件序号]][文本数组号[i]]);

      if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][当前列号]+",")>=0)

                   查询条件=表格列名[部件序号][0][当前列号]+"="+查询值;

   else

               查询条件=表格列名[部件序号][0][当前列号]+"='"+查询值+"'";

           }

        }

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",4,")>=0)){

查询.setBounds(按钮位置[4][0],按钮位置[4][1],按钮位置[4][2],按钮位置[4][3]);          

     panel1.add(查询);

}

 

浏览= new JButton(按钮集[5]);

浏览.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(窗口宽,窗口高,表格列名[部件序号][1],n,备份数据,表列数据类型[部件序号]);

        }

        else{

        浏览.setText("浏览");

        记录条数1[部件序号]=main1.当前行行号;  

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

        文本数组[i].setText(表格数据[部件序号][main1.当前行行号][文本数组号[i]]);

          }

       }

        }

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",5,")>=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 < 文本数组.length; i++) {  

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

      文本数组值[部件序号][i] = 文本数组[i].getText().trim();

    if (文本数组值[部件序号][i].trim().equals("null"))  文本数组值[部件序号][i] =" ";

       }

    else{   文本数组值[部件序号][i]="?";         }  

      }

cont4 = main1.getConn(); 

try

{

s1 = "insert into " + 表名 +"("; 

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[部件序号][文本数组号[j]])<0)

                           s1=s1+表格列名[部件序号][0][文本数组号[j]]+",";

}

s1=s1.substring(0,s1.length()-1)+") VALUES (";

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

if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[j]]+",")>=0)

s1=s1;  //图形字段不在本程序录入

   else if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[j]]+",") >= 0)

s1=s1+文本数组值[部件序号][j]+",";

else if(文本数组值[部件序号][j].trim().equals("?"))   //本句将不改变s1

                     s1=s1; 

else

s1=s1+"'"+文本数组值[部件序号][j].trim()+"',";

}

s1=s1.substring(0,s1.length()-1)+")";

s3="";

boolean bool=true;

   for (int j = 0; j< 关键字段名[部件序号].length; j++){ 

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

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

    s3= s3+文本数组值[部件序号][i];   //新存入关键字

       break;

    }

   }

  for (int i=0;i<记录条数[部件序号];i++){

s4 = ""; // 已有关键字

    for (int j = 0; j< 关键字段名[部件序号].length; j++){

s4=s4+表格数据[部件序号][i][关键字序号[j]].trim();

}

    if (s3.toLowerCase().trim().equals(s4.trim().toLowerCase())){

    bool=false;

    JOptionPane.showMessageDialog( null, "关键字重复，请修改后再录入！");

    break;

   }

   }

  if (bool){

                 PreparedStatement pst4 = cont4.prepareStatement(s1);   //完成录入

                 char x1=10,x2=13;

                 int k2=1;   

                      pst4.execute();

                     pst4.close();

stat4.close();

cont4.close();

记录条数[部件序号]++;

        int t=0;

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

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

        t=0;

        for (int j = 0; j< 关键字段名[部件序号].length; j++)

        if (i==关键字序号[j]) t=1;

        if (t==0)

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

     }

}

  }    

} catch (SQLException e2)

{

JOptionPane.showMessageDialog( null, "存盘语句错！"+s1);

}

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",6,")>=0)){

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

     panel1.add(存盘);

}

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

清屏.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

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

      }

  }

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",7,")>=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 < 文本数组.length; i++) 

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

文本数组值[部件序号][i] = 文本数组[i].getText().trim();

if (文本数组值[部件序号][i].equals("null")){

                      文本数组值[部件序号][i] =" ";

}

}else{  

                    文本数组值[部件序号][i]="?";         }    

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

{

s1 = "update " + 表名 +" set "; 

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[部件序号][文本数组号[j]])<0){

                       s1=s1+表格列名[部件序号][0][文本数组号[j]]+"=";

    if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[j]]+",") >= 0)

                  s1=s1+文本数组值[部件序号][j];

    else if(文本数组值[部件序号][j].trim().equals("?"))

                       s1=s1+文本数组值[部件序号][j];

    else s1=s1+"'"+文本数组值[部件序号][j].trim()+"'";

    s1=s1+",";

}

   }

                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=表格列名[部件序号][0][文本数组号[i]];

                     }

                     pst4.execute();

                     pst4.close();

stat4.close();

cont4.close();

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

  表格数据[部件序号][记录条数1[部件序号]][文本数组号[k]]=文本数组值[部件序号][k];

}

} catch (SQLException e2)

{

JOptionPane.showMessageDialog( null, "修改语句错！"+s1);

}

         }

       });

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",8,")>=0)){

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

panel1.add(修改存盘);

}

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

删除.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.图形数据类型.lastIndexOf(表列数据类型[部件序号][文本数组号[i]])<0)

文本数组值[部件序号][i] = 文本数组[i].getText().trim();

}

s2="";

   for (int j = 0; j< 关键字段名[部件序号].length; j++){

    for (int i = 0; i < 文本数组.length; 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();

   for (int i=记录条数1[部件序号];i<记录条数[部件序号]-1;i++)

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

    表格数据[部件序号][i][文本数组号[k]]=表格数据[部件序号][i+1][文本数组号[k]];

}    //删除后清除表格数据中的数据

   记录条数[部件序号]--;

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

  if (main1.图形数据类型.lastIndexOf(表列数据类型[部件序号][k])<0)

    文本数组[k].setText(一条空记录[部件序号][文本数组号[k]]);

} catch (SQLException e2)

{

JOptionPane.showMessageDialog( null, "删除语句错！"+s1);

}

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",9,")>=0)){

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

    panel1.add(删除);

}

    

批处理 = new JButton(按钮集[10]);

批处理.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

s2="";

        if (查询.getText().trim().equals("还原")){ 

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

                if (当前列号==文本数组号[i]){

  if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][当前列号]+",")>=0)

    s2="update " + 表名 +" set "+表格列名[部件序号][0][当前列号]+"="+文本数组[i].getText()+" where "+查询条件;

  else

s2="update " + 表名 +" set "+表格列名[部件序号][0][当前列号]+"='"+文本数组[i].getText().trim()+"' where "+查询条件;

                   break;

                }

         }

        else { 

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

                if (当前列号==文本数组号[i]){

if (main1.数字数据类型.lastIndexOf(","+表列数据类型[部件序号][当前列号]+",")>=0)

s2="update " + 表名 +" set "+表格列名[部件序号][0][当前列号]+"="+文本数组[i].getText();

else

s2="update " + 表名 +" set "+表格列名[部件序号][0][当前列号]+"='"+文本数组[i].getText().trim()+"'";

                   break;

                }

         }

cont4 = main1.getConn(); 

try

{

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE); 

            stat4.executeUpdate(s2);

}catch(SQLException e2)

{

JOptionPane.showMessageDialog( null, "批删除语句错！");

}

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",10,")>=0)){

     批处理.setBounds(按钮位置[10][0],按钮位置[10][1],按钮位置[10][2],按钮位置[10][3]);

     panel1.add(批处理);

}

图片存盘 = new JButton(按钮集[11]);

按钮数组[11]=图片存盘;

图片存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

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

文本数组值[部件序号][i] = 文本数组[i].getText().trim();

if (文本数组值[部件序号][i].equals("null")){

                     文本数组值[部件序号][i] =" ";

}

}else{  

                   文本数组值[部件序号][i]="?"; 

        }    

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

{

s1 = "update " + 表名 +" set "; 

int n=s1.length();

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

if(文本数组值[部件序号][j].trim().equals("?")) {

if (s1.length()==n)

                       s1=s1+表格列名[部件序号][0][文本数组号[j]]+"="+文本数组值[部件序号][j];

else

                       s1=s1+","+表格列名[部件序号][0][文本数组号[j]]+"="+文本数组值[部件序号][j];

}

       }  

               s1=s1+" where "+s2;

               PreparedStatement pst4 = cont4.prepareStatement(s1);

               char x1=10,x2=13;

               int k2=1; 

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

          String fieldname=表格列名[部件序号][0][文本数组号[i]];

          if (main1.图形数据类型.lastIndexOf(","+表列数据类型[部件序号][文本数组号[i]]+",")>=0){

          final JFileChooser fc = new JFileChooser(".\\"); 

          fc.showOpenDialog(null); 

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

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

  表格数据[部件序号][记录条数1[部件序号]][文本数组号[k]]=文本数组值[部件序号][k];

}

} catch (SQLException e2)

{

JOptionPane.showMessageDialog( null, "修改语句错！"+s1);

}catch (IOException e3)

{

JOptionPane.showMessageDialog( null, "文件读取出错！");

}

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",11,")>=0)){

图片存盘.setBounds(按钮位置[11][0],按钮位置[11][1],按钮位置[11][2],按钮位置[11][3]);

panel1.add(图片存盘);

}  

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

按钮数组[12]=退出;

退出.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

    panel1.setVisible(false); 

framet1.setVisible(false); 

    framet1.dispose();

}

});

if ((要求按钮号表.length()<3) || (要求按钮号表.lastIndexOf(",12,")>=0)){

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

       panel1.add(退出);

}

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

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;

frame1.setBounds(w1,h1,窗口宽, 窗口高);    //主程序窗口位置大小

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null); 

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

frame1.setVisible(true); 

}

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;

}

}

class frame1{

static JFrame framet1=new JFrame();

static JFrame framet2=new JFrame();

static JFrame framet3=new JFrame();

static JFrame framet4=new JFrame();

static JFrame framet5=new JFrame();

static JFrame framet6=new JFrame();

static JFrame framet7=new JFrame();

static JFrame framet8=new JFrame();

static JFrame framet9=new JFrame();

static JFrame framet10=new JFrame();

}

版本2

71.源码71，部件程序，表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签。

     /** 

      * 程序文件名：dataTenance2.java 

      * 作者：程学先 

      * 功能：表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签。 

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

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

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

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

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

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

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

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

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

      * 在每次调用时通过选择数据表、选择布局、选择字段与按钮使其用作某种某块或构件， 

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

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

      * 需要说明的是，软件复用有利于提高编码效率，有利于实现自动化，但它是以降低软件运行效率为代价的， 

      * 因此需要根据应用需要恰当地选取软件复用度，不要一味最求高复用，对于对时间要求高的软件，只能用复用度低的软件， 

      * 例如使用用C语言甚至汇编语言编写的程序。 

      * 本部件不涉及包含有image等二进制数据类型的数据的维护 

      * 用途：以文本框、按钮等构成单记录数据维护界面作数据录入、修改、删除等使用。  

      * 完成日期：2013年12月20日 

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

      */ 

     import java.awt.*; 

     import java.awt.List; 

     import java.awt.event.*; 

     import java.io.UnsupportedEncodingException; 

     import javax.swing.*; 

     import javax.swing.table.*; 

     import javax.swing.text.JTextComponent; 

     import java.sql.*; 

     import java.util.*; 

      

     public class dataTenance2 { 

      static JFrame frame1 = new JFrame(); 

      static String variabl1091 = main1.variabl1091; 

      private static JPanel panel1 = new JPanel(false); 

      static JTextField[] variabl2403; 

      private static Connection cont4; 

      private static Statement stat4; 

      private static ResultSetMetaData rsmdt4; 

      private static ResultSet rs; 

      private static String variabl2603; 

      private static String variabl2429; 

      private static String variabl1873; 

      private static int variabl2483 = main1.variabl2483; 

      private static int variabl2503 = main1.variabl2503;

      private static int variabl1531 = 10, variabl1477 = 10; 

      private static int variabl2651; 

      private static int variabl2113; 

      private static String[][] variabl2517; 

      private static String[][] variabl1913; 

      private static String[] variabl1231; 

      private static String[] variabl1501; 

      private static String[] variabl1169; 

      private static int[] variabl1489; 

      private static int[] variabl1119; 

      private static int variabl1853 = 0; 

      private static int variabl18531 = 0; 

      private static String[][] variabl2197; 

      private static String[][] variabl1431; 

      private static List list1;

      private static JButton[] variabl2185 = new JButton[10]; 

      static String[][] variabl1701; 

      private static String variabl1187; 

      private static int variabl1371 = 0; 

      private static String variabl1153 = "", variabl2803 = ""; 

      private static String[] variabl1507; 

      private static String variabl2309 = ""; 

      private static String[] variabl1525; 

      private static int[] variabl1287; 

      private static String s1 = "", s2 = ""; 

      private static int b = 0, c = 0; 

      private static int variabl1739 = 0; 

      private static int variabl1843 = 0; 

      private static int variabl1057 = 100; 

      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 String variabl1597 = main1.variabl1537 + main1.variabl1539; 

      private static int variabl1097 = 0; 

      private static JTextComponent[] variabl1733; 

      private static int[] variabl1467; 

      private static int[][] variabl1885; 

      private static int variabl1637 = 0; 

      private static int variabl1577 = 0; 

      private static int variabl1459 = 0; 

      private static int[][] variabl1921; 

      private static int variabl2179; 

      private static int variabl1315 = 0; 

      private static String[] variabl1419; 

      private static int[][] variabl1111; 

      private static int variabl1319, variabl1313; 

      private static JTextArea[] variabl2463; 

      private static int variabl1925 = 0; 

      private static int variabl1473 = 0; 

      private static int variabl1745 = variabl2483, variabl1923 = variabl2503; 

      public static String[] sw = new String[11]; 

      static int variabl2851 = 0, variabl2339 = 0; 

      private static int variabl2833; 

      private static HashSet set01 = new HashSet(); 

      private static String sd0; 

      

      static void means(String parameter[]) { 

      frame1 = new JFrame(); 

      panel1 = new JPanel(false); 

      variabl2483 = main1.variabl2483; 

      variabl2503 = main1.variabl2503; 

      variabl1531 = 10; 

      variabl1477 = 10; 

      variabl1853 = 0; 

      variabl18531 = 0; 

      variabl1925 = 0; 

      variabl1473 = 0; 

      variabl1745 = variabl2483; 

      variabl1923 = variabl2503; 

      s1 = ""; 

      s2 = ""; 

      b = 0; 

      c = 0; 

      variabl1647 = 15; 

      variabl1849 = 20; 

      variabl2185 = new JButton[10]; 

      variabl1637 = 0; 

      variabl1577 = 0; 

      variabl1459 = 0; 

      variabl2405 = new String[10]; 

      variabl1843 = 0; 

      variabl1057 = 100; 

      variabl2833 = 0; 

      variabl1597 = main1.variabl1537 + main1.variabl1539; 

      variabl1091 = main1.variabl1091; 

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

      variabl2483 = main1.variabl2483; 

      variabl2503 = main1.variabl2503; 

      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; 

      variabl2503 = m2; 

      } 

      } catch (Exception e2) { 

      } 

      variabl2603 = parameter[4]; 

      variabl2429 = "," + parameter[0] + ","; 

      String[] t1 = parameter[0].split(","); 

      variabl1873 = ""; 

      if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0) { 

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

      if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0) { 

      variabl1873 = t1[i]; 

      break; 

      } 

      } 

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

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

      return; 

      } 

      String variabl1325 = parameter[19]; 

      variabl1525 = parameter[6].split(","); 

      if (sw[5].length() > 0) { 

      if (variabl1187.length() > 0) { 

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

      variabl1187 = ""; 

      for (int j = 0; j < ss.length; j++) { 

      if (variabl1187.length() == 0) 

      variabl1187 = (Integer.parseInt(ss[j]) + 5) + ""; 

      else 

      variabl1187 = variabl1187 + "," + (Integer.parseInt(ss[j]) + 5) 

      + ""; 

      } 

      } else 

      variabl1187 = "5,6,7,8,9"; 

      } 

      variabl1153 = parameter[8]; 

      if (variabl1153.trim().length()==0){ 

      String [] s0=variabl1325.split(","); 

      for (int i1=0;i1<s0.length;i1++) 

                if (variabl1153.length()==0) 

                variabl1153=i1+""; 

                else variabl1153=variabl1153+","+i1; 

      } 

      variabl2803 = parameter[9]; 

      variabl1287 = new int[variabl1525.length]; 

      variabl1005(variabl2603); 

      variabl10091(); 

      variabl2113 = variabl2651; 

      variabl1913 = new String[2][variabl2113]; 

      variabl1231 = new String[variabl2113]; 

      variabl1169 = new String[variabl2113]; 

      variabl1119 = new int[variabl2113]; 

      variabl2197 = new String[variabl1853 + 300][variabl2113]; 

      variabl1431 = new String[variabl2113][]; 

      variabl1507 = new String[variabl2113]; 

      variabl1925 = 0; 

      variabl1473 = 0; 

      b = 0; 

      int variabl1293 = 0; 

      int variabl2119 = 0, variabl1745 = variabl2483, variabl1923 = variabl2503; 

      while (b < variabl2113) { 

      variabl1913[0][b] = variabl2517[0][b];

      variabl1913[1][b] = variabl2517[1][b];

      variabl1169[b] = variabl1501[b]; 

      variabl1119[b] = variabl1489[b]; 

      if (variabl1913[1][b].length() > variabl1925) 

      variabl1925 = variabl1913[1][b].length(); 

      if ((variabl1597.indexOf("," + variabl1169[b] + ",") < 0) 

      && (variabl1293 < (variabl1913[1][b].length() + variabl1119[b]) * variabl1647)) { 

      variabl1293 = (variabl1913[1][b].length() + variabl1119[b]) * variabl1647; 

      } 

      if (variabl1597.indexOf("," + variabl1169[b] + ",") >= 0) 

      variabl1473++;  

      b++; 

      } 

      if (variabl1473 == 0) { 

     

      if (variabl2119 + variabl1057 * (variabl2503 - 120) + variabl2483 * 80 < variabl2503 * variabl2483) { 

      if (variabl1293 < variabl1057 * 1.5) 

      variabl1293 = (int) (variabl1057 * 1.5); 

      variabl2503 = (int) (variabl2119 * 1.5) / variabl1293 + 120; 

      if (variabl1923 < variabl2503) 

      variabl2503 = variabl1923; 

      if (variabl2503 * 4 > variabl2483 * 3) 

      variabl2483 = variabl2503 * 4 / 3;

      if (variabl1745 < variabl2483) 

      variabl2483 = variabl1745; 

      } 

      if (variabl2483 < 500) 

      variabl2483 = 500; 

      if (variabl2503 < 300) { 

      variabl2503 = 300; 

      } 

      if (variabl1923 > variabl2503 + variabl1473 * 40) 

      variabl2503 = variabl2503 + variabl1473 * 40; 

      else 

      variabl2503 = variabl1923; 

      } 

      int variabl1315 = (variabl2483 - variabl1057 - 50) / variabl1647; 

      b = 0; 

      while (b < variabl2113) { 

      if ((variabl1925 + variabl1119[b]) > (variabl1315)) { 

      variabl1119[b] = variabl1315 - variabl1925; 

      } 

      if (variabl1169[b].indexOf("datetime") == 0) 

      variabl1507[b] = "2001-01-01 00:00:00.000"; 

      else if (variabl1169[b].indexOf("smalldatetime") == 0) 

      variabl1507[b] = "2001-01-01 00:00:00"; 

      else if (variabl1169[b].indexOf("datetime2") == 0) 

      variabl1507[b] = "2001-01-01 00:00:00.0000000"; 

      else if (variabl1169[b].indexOf("datetimeoffset") == 0) 

      variabl1507[b] = "2001-01-01 00:00:00.0000000 +08:00"; 

      else if (variabl1169[b].indexOf("date") == 0) 

      variabl1507[b] = "2001-01-01"; 

      else if (variabl1169[b].indexOf("time") == 0) 

      variabl1507[b] = "00:00:00"; 

      else if (variabl1169[b].indexOf("money") >= 0) 

      variabl1507[b] = "0.0000"; 

      else if (main1.variabl1541.lastIndexOf(variabl1169[b]) > 0) 

      variabl1507[b] = "0.00"; 

      else if (main1.variabl1545.lastIndexOf(variabl1169[b]) > 0) 

      variabl1507[b] = "0"; 

      else 

      variabl1507[b] = ""; 

      b++; 

      } 

      variabl1009(variabl2603); 

      variabl10092();   

      final JPanel panel1 = new JPanel(false); 

      panel1.setLayout(null); 

      panel1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 50); 

      JLabel jl = new JLabel("字段可选内容  :"); 

      jl.setBounds(10, 10, variabl1057, variabl1849); 

      list1 = new List(); 

      list1.setBounds(10, 40, variabl1057, variabl2503 - 230 + variabl1097); 

      panel1.add(jl); 

      panel1.add(list1); 

      int variabl1637 = 0; 

      int variabl1133 = 0; 

      int variabl1577 = variabl1057 + 2; 

      variabl1921 = new int[variabl2113][2]; 

      int variabl1239 = 1; 

      if ((variabl1473 == 0) && (variabl2113 * variabl1849 + variabl2179 * variabl1849 + 40 < variabl2503)) { 

      variabl1239 = variabl2113; 

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

      variabl1921[j][0] = 1 + j; 

      variabl1921[j][1] = 1; 

      variabl1119[j] = variabl1315 - variabl1925; 

      } 

      variabl1637 = (variabl2503 - 120 - (variabl2179 + variabl2113) * variabl1849) / (variabl2179 + variabl2113 + 1); 

      } else { 

      int variabl1385 = 1; 

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

      if (variabl1597.lastIndexOf("," + variabl1169[i] + ",") < 0) { 

      if ((variabl1133 + variabl1925 + variabl1119[i]) <= variabl1315) { 

      variabl1133 = variabl1133 + variabl1925 + variabl1119[i]; 

      variabl1921[i][0] = variabl1239; 

      variabl1577 = variabl1577 + variabl1925 + variabl1119[i]; 

      variabl1921[i][1] = variabl1385; 

      variabl1385++; 

      } else { 

      variabl1119[i - 1] = variabl1119[i - 1] + variabl1315 - variabl1133; 

      variabl1239++; 

      variabl1385 = 1; 

      variabl1921[i][0] = variabl1239; 

      variabl1921[i][1] = variabl1385; 

      variabl1385++; 

      variabl1133 = variabl1925 + variabl1119[i]; 

      variabl1577 = variabl1057 / variabl1647 + 2 + variabl1925 + variabl1119[i]; 

      } 

      b = i; 

      } 

      } 

      variabl1119[b] = variabl1119[b] + variabl1315 - variabl1133; 

      if (variabl1473 > 0) 

      variabl1637 = 0; 

      else 

      variabl1637 = (variabl2503 - 120 - variabl2179 * variabl1849 - variabl1239 * variabl1849) 

      / (variabl1239 + variabl2179 + 1); 

      } 

      variabl1733 = new JTextComponent[variabl2113]; 

      variabl1419 = new String[variabl1733.length]; 

      variabl1467 = new int[variabl1733.length]; 

      int variabl2247 = 1, variabl2331 = 1; 

      variabl1843 = 0; 

      variabl1577 = variabl1057 / variabl1647 + 2; 

      variabl1459 = variabl1477 + variabl1637; 

      variabl2403 = new JTextField[variabl1913[0].length]; 

      for (int j = 0; j < variabl1913[0].length; j++) { 

      JLabel variabl2533 = new JLabel(variabl1913[1][j], 11); 

      variabl2403[j] = new JTextField(""); 

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

      variabl2403[j].setEditable(false); 

      } 

      if ((variabl1597.lastIndexOf("," + variabl1169[j] + ",")) < 0) { 

      panel1.add(variabl2533); 

      panel1.add((Component) variabl2403[j]); 

      if ((variabl1921[j][0] == variabl2331) && (variabl1921[j][1] == variabl2247)) { 

      variabl2533.setBounds(variabl1577 * variabl1647, variabl1459, variabl1925 * variabl1647, variabl1849); 

      variabl2403[j].setBounds(variabl1577 * variabl1647 + variabl1925 * variabl1647, variabl1459, 

      variabl1119[j] * variabl1647, variabl1849); 

      variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925 * variabl1647; 

      variabl1921[j][1] = variabl1459; 

      variabl1577 = variabl1577 + variabl1925 + variabl1119[j]; 

      variabl2247++; 

      } else if (variabl1921[j][0] == variabl2331) { 

      variabl2247++; 

      variabl2533.setBounds(variabl1577 * variabl1647, variabl1459, variabl1925 * variabl1647, variabl1849); 

      variabl2403[j].setBounds(variabl1577 * variabl1647 + variabl1925 * variabl1647, variabl1459, 

      variabl1119[j] * variabl1647, variabl1849); 

      variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925 * variabl1647; 

      variabl1921[j][1] = variabl1459; 

      variabl1577 = variabl1577 + variabl1925 + variabl1119[j]; 

      } else { 

      variabl1459 = variabl1459 + variabl1637 + variabl1849; 

      variabl2331++; 

      variabl1577 = variabl1057 / variabl1647 + 2; 

      variabl2533.setBounds(variabl1577 * variabl1647, variabl1459, variabl1925 * variabl1647, variabl1849); 

      variabl2403[j].setBounds(variabl1577 * variabl1647 + variabl1925 * variabl1647, variabl1459, 

      variabl1119[j] * variabl1647, variabl1849); 

      variabl1921[j][0] = variabl1577 * variabl1647 + variabl1925 * variabl1647; 

      variabl1921[j][1] = variabl1459; 

      variabl2247 = 2; 

      variabl1577 = variabl1577 + variabl1925 + variabl1119[j]; 

      } 

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

      variabl2403[j].setFont(new Font("宋体", 1, 14)); 

      variabl2403[j].addFocusListener(new FocusAdapter() { 

      public void focusGained(final FocusEvent arg0) { 

      Object s0 = arg0.getSource(); 

      String s1 = s0.toString(); 

      int n1 = 0; 

      for (int i = 0; i < variabl1913[0].length; i++) { 

      if (s1.lastIndexOf("," + variabl1921[i][0] + "," 

      + variabl1921[i][1] + ",") > 0) { 

      variabl1739 = i; 

      break; 

      } 

      } 

      list1.removeAll(); 

      if ((variabl2429.lastIndexOf("," + variabl1913[0][variabl1739] + "表,") >= 0) 

      || (variabl2429.lastIndexOf("," + variabl1913[0][variabl1739] 

      + "代码表,") >= 0)) { 

      for (int i = 0; i < variabl1431[variabl1739].length; i++) 

      list1.add(variabl1431[variabl1739][i]); 

      } else if (variabl2429 

      .lastIndexOf("," + variabl1913[0][variabl1739] + "代码表,") < 0) { 

      int u1 = 0; 

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

      int u2 = 0; 

      for (int k = 0; k < u1; k++) { 

      if (variabl2197[j][variabl1739] != null) { 

      } else 

      variabl2197[j][variabl1739] = " "; 

      if (variabl2197[j][variabl1739].toLowerCase().trim().equals( 

      list1.getItem(k).toLowerCase().trim())) { 

      u2++; 

      break; 

      } 

      } 

      if (u2 == 0) { 

      list1.add(variabl2197[j][variabl1739]); 

      u1++; 

      } 

      } 

      } 

      } 

      }); 

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

      variabl1467[variabl1843] = j; 

      } 

      variabl1843++; 

      } 

      if (variabl1473 > 0) { 

      variabl1459 = variabl1459 + variabl1849; 

      variabl1313 = (variabl2503 - variabl1459 - 150) / variabl1473; 

      variabl2503 = variabl2503 + 20; 

      variabl1577 = variabl1057 + 10; 

      int variabl1319 = (variabl1315 - variabl1925 + 1) * variabl1647; 

      for (int j = 0; j < variabl1913[0].length; j++) { 

      if ((variabl1597.lastIndexOf("," + variabl1169[j] + ",")) >= 0) { 

      JLabel variabl2533 = new JLabel(variabl1913[1][j], 11); 

      JTextArea variabl2463 = new JTextArea(null, "", variabl1319, variabl1313); 

      JScrollPane variabl1147 = new JScrollPane(variabl2463); 

      variabl1147.setBounds(variabl1577 + variabl1925 * variabl1647, variabl1459, variabl1319, variabl1313); 

      panel1.add(variabl2533); 

      panel1.add((Component) variabl1147); 

      variabl2533.setBounds(variabl1577, variabl1459, variabl1925 * variabl1647, variabl1849); 

      variabl1459 = variabl1459 + variabl1313; 

      variabl1733[j] = (JTextComponent) variabl2463; 

      variabl1467[j] = j; 

      } 

      } 

      } 

      variabl1577 = 20; 

      if (variabl1473 == 0) 

      variabl1459 = variabl1459 + 30 + variabl1637; 

      else 

      variabl1459 = variabl1459 + 20; 

      variabl1647 = 25; 

      if (variabl2503 - 230 + variabl1097 > variabl1459) {  

      variabl1097 = variabl1459 - variabl2503 + 180; 

      list1.setBounds(10, 40, variabl1057, variabl2503 - 230 + variabl1097); 

      } 

      list1.addMouseListener(new MouseAdapter() { 

      public void mouseClicked(MouseEvent evt) { 

      String s4 = ""; 

      String[] s5; 

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

      if (variabl1467[i] == variabl1739) { 

      s4 = list1.getSelectedItem(); 

      if (s4 != null) { 

      } else 

      s4 = ""; 

      if (s4.lastIndexOf(",") > 0) { 

      s5 = s4.split(","); 

      variabl1733[i].setText(s5[0]); 

      } else 

      variabl1733[i].setText(list1.getSelectedItem()); 

      } 

      } 

      }); 

      variabl2819002(); 

      

      variabl2375 = new JButton(variabl2405[0]); 

      variabl2375.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      variabl18531 = 0; 

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

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

      if ((main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[i]] + ",")) > 0) 

      if ((variabl1733[i].getText() == null) 

      || (variabl1733[i].getText().trim().length() < 1)) 

      variabl1733[i].setText("0"); 

      } 

      variabl2325.setEnabled(true); 

      variabl2255.setEnabled(false); 

      } 

      }); 

      if (variabl1187.lastIndexOf(",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++) { 

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

      if ((main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[i]] 

      + ",")) > 0) 

      if ((variabl1733[i].getText() == null) 

      || (variabl1733[i].getText().trim().length() < 1)) 

      variabl1733[i].setText("0"); 

      } 

      } 

      variabl2255.setEnabled(true); 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 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++) { 

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

      if ((main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[i]] + ",")) > 0) 

      if ((variabl1733[i].getText() == null) 

      || (variabl1733[i].getText().trim().length() < 1)) 

      variabl1733[i].setText("0"); 

      } 

      variabl2325.setEnabled(false); 

      variabl2255.setEnabled(true); 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 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++) { 

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

      if ((main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[i]] 

      + ",")) > 0) 

      if ((variabl1733[i].getText() == null) 

      || (variabl1733[i].getText().trim().length() < 1)) 

      variabl1733[i].setText("0"); 

      } 

      variabl2325.setEnabled(true); 

      } else 

      variabl2255.setEnabled(false); 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 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][variabl2113]; 

      int [] n=new int [variabl1119.length]; 

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

      for (int j = 0; j < variabl2113; 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 < variabl2113; j++){ 

         n[j]=variabl1119[j]; 

         if (n[j]>50) n[j]=50;  

      } 

      tableTenance.tableModel(variabl2483, variabl2503, variabl1913[1], n , variabl1701, 

      variabl1169); 

      } else { 

      variabl2531.setText("浏览"); 

      variabl18531 = main1.variabl1327; 

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

      variabl1733[i].setText(variabl2197[main1.variabl1327][variabl1467[i]]); 

      } 

      } 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 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) { 

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

      variabl1419[i] = variabl1733[i].getText(); 

      if (variabl1419[i] == null) 

      variabl1419[i] = " "; 

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

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

      if (!variabl1169[variabl1467[j]].equals("image")) 

      s1 = s1 + variabl2517[0][variabl1467[j]] + ","; 

      s1 = s1.substring(0, s1.length() - 1) + ") VALUES ("; 

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

      variabl2197[variabl1853 - 1][j] = variabl1419[j]; 

      if (main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[j]] 

      + ",") >= 0) { 

      s1 = s1 + variabl1419[j] + ","; 

      } else { 

      if (!variabl1169[variabl1467[j]].equals("image")) 

      s1 = s1 + "'" + variabl1419[j].trim() + "',"; 

      } 

      } 

      s1 = s1.substring(0, s1.length() - 1) + ")"; 

      stat4.executeUpdate(s1); 

      stat4.close(); 

      cont4.close(); 

      set01.add(sd0); 

      } catch (SQLException e2) { 

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

      variabl2197[variabl1853][j] = ""; 

      } 

      variabl1853--; 

      JOptionPane.showMessageDialog(null, "SQL语句错！" + s1); 

      } 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 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++) { 

      variabl1733[i].setText(variabl1507[i]); 

      } 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",6,") >= 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) { 

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

      variabl1419[i] = variabl1733[i].getText(); 

      String sd = ""; 

      int kd = set01.size();      

      int kd0 = 0; 

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

      for (int j = 0; j < variabl1525.length; j++) { 

      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("," + variabl1169[j] + ",") >= 0) 

      s2 = s2 + variabl1525[j] + "=" + variabl1419[i]; 

      else if (!variabl1169[variabl1467[j]].equals("image")) 

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

      String s3 = ""; 

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

      if (!variabl1169[variabl1467[j]].equals("image")) 

      if (s3.length() > 0) 

      s3 = s3 + "," + variabl2517[0][variabl1467[j]] + "="; 

      else 

      s3 = s3 + variabl2517[0][variabl1467[j]] + "="; 

      if (main1.variabl1545.lastIndexOf("," + variabl1169[variabl1467[j]] 

      + ",") >= 0) { 

      if ((variabl1419[j] == null) || (variabl1419[j].length() == 0)) 

      variabl1419[j] = "0"; 

      s3 = s3 + variabl1419[j]; 

      } else { 

      if (!variabl1169[variabl1467[j]].equals("image")) 

      s3 = s3 + "'" + variabl1419[j].trim() + "'"; 

      } 

      } 

      s1 = s1 + s3 + " where " + s2; 

      stat4.executeUpdate(s1); 

      stat4.close(); 

      cont4.close(); 

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

      variabl2197[variabl18531][j] = variabl1419[j]; 

      } 

      } catch (SQLException e2) { 

      JOptionPane.showMessageDialog(null, "SQL语句错！" + s1); 

      } 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",7,") >= 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++) 

      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("," + variabl1169[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) 

      variabl1733[i].setText(variabl1507[i]); 

      else 

      variabl1733[i].setText(variabl2197[variabl18531][i]); 

      } 

      } catch (SQLException e2) { 

      JOptionPane.showMessageDialog(null, "SQL语句错！" + s1); 

      } 

      } 

      }); 

      if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",8,") >= 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 ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",9,") >= 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]]); 

      } 

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

      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; 

      frame1.setBounds(w1, h1, variabl2483, variabl2503); 

      frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

      frame1.getContentPane().setLayout(null); 

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

      frame1.setVisible(true); 

      } 

      

      static void variabl1005(String variabl1103) { 

      try { 

      cont4 = main1.getConn(); 

      stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE); 

      String s1 = "select * from " + variabl1103; 

      rs = stat4.executeQuery(s1); 

      rsmdt4 = rs.getMetaData(); 

      variabl2651 = rsmdt4.getColumnCount(); 

      variabl2517 = new String[2][variabl2651]; 

      variabl1501 = new String[variabl2651]; 

      variabl1489 = new int[variabl2651]; 

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

      variabl2517[0][i] = rsmdt4.getColumnName(i + 1); 

      variabl2517[1][i] = variabl2517[0][i]; 

      variabl1501[i] = rsmdt4.getColumnTypeName(i + 1); 

      variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1); 

      } 

      rs.absolute(1); 

      rs.close(); 

      stat4.close(); 

      cont4.close(); 

      } catch (SQLException e1) { 

      JOptionPane.showMessageDialog(null, "读取数据库数据出错！"); 

      } 

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

      int N0 = 1; 

      for (int j = 0; j < variabl1525.length; j++) 

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

      if (variabl1525[j].toLowerCase().trim().equals(variabl2517[0][i].toLowerCase().trim())) { 

      variabl1287[j] = i; 

      if (("," + variabl1153 + ",").lastIndexOf("," + i + ",") < 0) 

      variabl1153 = i + "," + variabl1153; 

      break; 

      } 

      } 

      variabl2309 = ""; 

      b = 0; 

      String[] t2 = variabl1153.split(","); 

      while (b < t2.length) { 

      variabl2309 = variabl2309 + variabl2517[0][Integer.parseInt(t2[b])] + ","; 

      b++; 

      } 

      variabl2309 = variabl2309.substring(0, variabl2309.length() - 1); 

      variabl10051(variabl2309, variabl1103); 

      } else { 

      b = 0; 

      variabl2309 = ""; 

      while (b < variabl2651) { 

      variabl2309 = variabl2309 + variabl2517[0][b] + ","; 

      b++; 

      } 

      variabl2309 = variabl2309.substring(0, variabl2309.length() - 1); 

      } 

      } 

      

      static void variabl10051(String variabl23090, String variabl1103) { 

      try { 

      cont4 = main1.getConn(); 

      stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_READ_ONLY); 

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

      rs = stat4.executeQuery(s1); 

      rsmdt4 = rs.getMetaData(); 

      variabl2651 = rsmdt4.getColumnCount(); 

      variabl2517 = new String[2][variabl2651]; 

      variabl1501 = new String[variabl2651]; 

      variabl1489 = new int[variabl2651]; 

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

      variabl2517[0][i] = rsmdt4.getColumnName(i + 1); 

      variabl2517[1][i] = variabl2517[0][i]; 

      variabl1501[i] = rsmdt4.getColumnTypeName(i + 1); 

      variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1); 

      } 

      rs.absolute(1); 

      rs.close(); 

      stat4.close(); 

      cont4.close(); 

      } catch (SQLException e1) { 

      JOptionPane.showMessageDialog(null, "读取数据库数据出错！"); 

      } 

      for (int j = 0; j < variabl1525.length; j++) { 

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

      if (variabl1525[j].toLowerCase().equals(variabl2517[0][i].toLowerCase())) 

      variabl1287[j] = i; 

      } 

      } 

      } 

      

      static void variabl1009(String variabl1103) { 

      try { 

      cont4 = main1.getConn(); 

      stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE); 

      String s1 = "select " + variabl2309 + "  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); 

      if ((main1.variabl1545.lastIndexOf("," + variabl1169[b] + ",")) > 0) 

      if ((variabl21970[c][b] == null) 

      || (variabl21970[c][b].trim().length() == 0)) 

      variabl21970[c][b] = "0"; 

      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 < variabl2113; j++) 

      variabl2197[i][j] = variabl21970[i][j]; 

      } catch (SQLException e1) { 

      JOptionPane.showMessageDialog(null, "读取数据库数据出错！"); 

      } 

      String sd = ""; 

      for (int i0 = 0; i0 < variabl1853; i0++) { 

      sd = ""; 

      for (int j = 0; j < variabl1525.length; j++) { 

      sd=sd+variabl2197[i0][variabl1287[j]]+","; 

      } 

      set01.add(sd);  

      } 

      } 

      

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

      variabl1853 = rs.getRow(); 

      rs.absolute(1); 

      int numberOfColumns = rsmd.getColumnCount(); 

      String s4 = ""; 

      String s5 = ""; 

      for (int i = 1; i <= variabl1853; i++) {  

      rs.absolute(i); 

      s4 = rs.getString(1); 

      s5 = rs.getString(2); 

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

      if (variabl2517[0][j].toLowerCase().trim().equals(s4.trim().toLowerCase())) { 

      variabl2517[1][j] = s5; 

      break; 

      } 

      } 

      } 

      rs.close(); 

      stat4.close(); 

      cont4.close(); 

      } 

      } catch (SQLException e) { 

      JOptionPane.showMessageDialog(null, "连接数据库出错！"); 

      } 

      } 

      

      static void variabl10092() { 

      try { 

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

      int u = 0; 

     

      if ((variabl2429.lastIndexOf("," + variabl1913[0][j] + "表,") >= 0) 

      && (variabl1913[0][j].indexOf("代码") >= 0)) { 

      s2 = variabl1913[0][j].substring(0, variabl1913[0][j].length() - 2); 

      s1 = "select " + variabl1913[0][j] + "," + s2 + " from " 

      + variabl1913[0][j] + "表"; 

      u = 1; 

      } else if (variabl2429.lastIndexOf("," + variabl1913[0][j] + "代码表,") >= 0) { 

      s2 = variabl1913[0][j].substring(0, variabl1913[0][j].length() - 2); 

      s1 = "select " + variabl1913[0][j] + "," + variabl1913[0][j] + "代码" 

      + " from " + variabl1913[0][j] + "代码表"; 

      u = 1; 

      } 

      if (u == 1) { 

      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[j] = new String[numberOfColumns]; 

      for (int i = 1; i <= numberOfColumns; i++) { 

      rs.absolute(i); 

      variabl1431[j][i - 1] = rs.getString(1) + "," 

      + rs.getString(2); 

      } 

      rs.close(); 

      stat4.close(); 

      cont4.close(); 

      } 

      } 

      } catch (SQLException e3) { 

      JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1); 

      } 

      } 

      

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

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

      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; 

      variabl1577 = variabl1577 + variabl1885[j][2]; 

      } else { 

      variabl1885[j][2] = variabl1629; 

      variabl1577 = variabl1577 + variabl1629; 

      } 

      variabl1885[j][3] = variabl1849; 

      n++; 

      n1++; 

      if (variabl1371 - n1 == 0) 

      break; 

      if ((n >= variabl1505) && ((variabl1371 - n1) - variabl1505 != 0)) { 

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

      variabl1577 = 20; 

      variabl1459 = variabl1459 + variabl1849 + 20; 

      n = 0; 

      n2++; 

      } 

      } 

      } 

      variabl2503 = variabl1459 + variabl1849 + 100; 

      } 

    }

72.源码72，部件程序，表单程序（单记录数据维护程序），应用组合框提供代码辅助录入、可变换标签、可显示与录入图片。

/** 

 * 程序文件名：dataTenance3.java 

 * 作者：程学先 

 * 功能：表单程序（单记录数据维护程序），应用组合框提供代码辅助录入、可变换标签、可显示与录入图片。 

 */

import java.awt.*;

import java.awt.event.*;

import javax.swing.*;

import javax.swing.table.*;

import java.sql.*;

import java.util.ArrayList;

import java.util.HashSet;

import java.util.Set;

import java.util.Vector;

import java.io.*;

import java.awt.Component;

import java.awt.event.ActionEvent;

import java.awt.event.ActionListener;

import java.awt.event.FocusAdapter;

import java.awt.event.FocusEvent;

import java.awt.event.MouseAdapter;

import java.awt.event.MouseEvent;

import java.util.Vector;

import javax.swing.JButton;

import javax.swing.JComboBox;

import javax.swing.JComponent;

import javax.swing.JFileChooser;

import javax.swing.JFrame;

import javax.swing.JLabel;

import javax.swing.JTextField;

import javax.swing.WindowConstants;

import javax.swing.text.JTextComponent;

import javax.swing.text.html.HTMLDocument.Iterator;

import javax.swing.event.DocumentListener;

import javax.swing.event.DocumentEvent;

public class dataTenance3 {

private static JFrame frame1;

static JTextField[] variabl2403;

private static JComboBox[] variabl2359 = null;

private static JTextComponent[] variabl1733;

private static JLabel[] variabl2165;

private static int[] variabl1467;

private static JButton[] variabl2185 = new JButton[13];

private static Connection cont4;

private static Statement stat4;

private static ResultSetMetaData rsmdt4;

private static ResultSet rs;

private static String variabl2603;

private static String variabl2429;

private static String variabl1873;

private static int variabl2483 = main1.variabl2483;

private static int variabl2503 = main1.variabl2503;

private static int variabl1531 = main1.variabl1531,

variabl1477 = main1.variabl1477;

private static int variabl2651;

private static int variabl2113 = 0;

private static String[][] variabl2517 = null;

private static String[][] variabl1913 = null;

private static String[] variabl1501 = null;

private static String[] variabl1169 = null;

private static int[] variabl1489 = null;

private static int[] variabl1119 = null;

private static int variabl1853 = 0;

private static int variabl18531 = 0;

private static String[][] variabl2197 = null;

private static String[][] variabl1431 = null;

private static String[] variabl1419 = null;

static String[][] variabl1701;

private static String variabl1187;

private static int variabl1371 = 0;

private static String variabl1153;

private static String[] variabl1507 = null;

private static String variabl2309 = "";

private static String[] variabl1525 = null;

private static String[] variabl1377 = null;

private static int[] variabl1287 = null;

private static String s1 = "", s2 = "", s3 = "", s4 = "", s5 = "";

private static String variabl2031 = "", variabl2499 = "";

private static int b = 0, c = 0;

private static String[] variabl1425;

private static int[] variabl2345;

private static int variabl1947 = 0, variabl1739 = 0;

private static int[][] variabl1921 = null;

private static int variabl1843 = 0;

private static String variabl1175 = "";

private static int variabl1647 = 15, variabl1849 = 20;

private static String[] variabl2405 = { "第一条", "下一条", "最后一条", "上一条", "查询",

"浏览", "存盘", "清屏", "修改存盘", "删除", "批处理", "图片存盘", "退出" };

private static JButton b1;

private static JButton variabl2375, variabl2325, variabl1971, variabl2255,

variabl2637, variabl2531, variabl2611, variabl2601, variabl1697,

variabl2633, variabl2315, 图片存盘, variabl2599;

private static String variabl1597 = main1.variabl1537 + main1.variabl1539;

static int variabl2851 = 0, variabl2339 = 0;

private static int[][] variabl1885 = null;

private static int variabl1637 = 0;

private static int variabl1693 = 0;

private static int variabl1577, variabl1313;

private static int variabl2129 = 0;

private static int variabl2179;

private static int variabl1239 = 1;

private static int variabl1459 = 0;

private static int variabl1473 = 0;

private static int variabl2833;

static void means(String parameter[]) {

frame1 = new JFrame();

variabl2483 = main1.variabl2483;

variabl2503 = main1.variabl2503;

variabl1531 = main1.variabl1531;

variabl1477 = main1.variabl1477;

variabl2113 = 0;

variabl1913 = new String[2][];

variabl1853 = 0;

variabl18531 = 0;

variabl1371 = 0;

variabl1313 = 0;

variabl2309 = "";

s1 = "";

s2 = "";

s3 = "";

s4 = "";

s5 = "";

variabl2031 = "";

variabl2499 = "";

b = 0;

c = 0;

variabl1947 = 0;

variabl1739 = 0;

variabl2833 = 0;

variabl1843 = 0;

variabl1175 = "";

variabl1647 = 15;

variabl1849 = 20;

variabl1597 = main1.variabl1537 + main1.variabl1539;

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

variabl2483 = main1.variabl2483;

variabl2503 = main1.variabl2503;

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;

variabl2503 = m2;

}

} catch (Exception e2) {

}

variabl2603 = parameter[4];

variabl2429 = "," + parameter[0] + ",";

String[] t1 = parameter[0].split(",");

variabl1873 = "";

if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0)

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

if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0)

variabl1873 = t1[i];

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

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

return;

}

final int variabl1805 = Integer.parseInt(parameter[21]);

variabl1525 = parameter[6].split(",");

variabl1377 = new String[variabl1525.length];

;

variabl1153 = parameter[8];

variabl1287 = new int[variabl1525.length];

variabl2185 = new JButton[13];

variabl2185 = new JButton[13];

try {

cont4 = main1.getConn();

stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

s1 = "select * from " + variabl2603;

rs = stat4.executeQuery(s1);

rs.last();

variabl1853 = rs.getRow();

rsmdt4 = rs.getMetaData();

variabl2651 = rsmdt4.getColumnCount();

variabl2517 = new String[2][variabl2651];

variabl1501 = new String[variabl2651];

variabl1489 = new int[variabl2651];

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

variabl2517[0][i] = rsmdt4.getColumnName(i + 1);

variabl2517[1][i] = variabl2517[0][i];

variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);

variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);

if (variabl1647 * (variabl1489[i] + variabl2517[1][i].length()) > variabl2483)

variabl1501[i] = "text";

}

for (int j = 0; j < variabl1525.length; j++)

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

if (variabl1525[j].toLowerCase().trim()

.equals(variabl2517[0][i].toLowerCase().trim())) {

variabl1287[j] = i;

if ((variabl1153.length() > 0)

&& (("," + variabl1153 + ",").lastIndexOf(","

+ i + ",") < 0))

variabl1153 = variabl1153 + "," + i;

break;

}

}

rs.close();

if (variabl1873.length() > 0) {

s1 = "select * from " + variabl1873;

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd = rs.getMetaData();

rs.last();

int numberOfColumns = rs.getRow();

rs.first();

String s4 = "";

String s5 = "";

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

s4 = rs.getString(1);

s5 = rs.getString(2);

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

if (variabl2517[0][j].toLowerCase().trim()

.equals(s4.trim().toLowerCase())) {

variabl2517[1][j] = s5;

break;

}

}

}

rs.close();

}

} catch (SQLException e) {

JOptionPane.showMessageDialog(null, "连接数据库出错！" + s1);

}

variabl1153 = "," + variabl1153 + ",";

variabl2345 = new int[variabl2651];

int b0 = 0, b = -1;

while (b0 < variabl2651) {

if ((variabl1153.length() < 3)

|| (variabl1153.lastIndexOf("," + b0 + ",") >= 0)) {

b = b + 1;

variabl2345[b] = b0;

}

b0++;

}

variabl2113 = b + 1;

variabl1913 = new String[2][variabl2113];

variabl1169 = new String[variabl2113];

variabl1119 = new int[variabl2113];

variabl2197 = new String[variabl1853 + 300][variabl2113];

variabl1431 = new String[variabl2113][];

variabl1507 = new String[variabl2113];

int variabl1925 = 0;

variabl1473 = 0;

int variabl1293 = 0;

int variabl2119 = 0, variabl1745 = variabl2483, variabl1923 = variabl2503;

b = 0;

while (b < variabl2113) {

variabl1913[0][b] = variabl2517[0][variabl2345[b]];

variabl1913[1][b] = variabl2517[1][variabl2345[b]];

variabl2309 = variabl2309 + variabl1913[0][b];

variabl1169[b] = variabl1501[variabl2345[b]];

variabl1119[b] = variabl1489[variabl2345[b]];

if (variabl1913[1][b].length() > variabl1925)

variabl1925 = variabl1913[1][b].length();

if ((variabl1597.indexOf("," + variabl1169[b] + ",") < 0)

&& (variabl1293 < (variabl1913[1][b].length() + variabl1119[b])

* variabl1647)) {

variabl1293 = (variabl1913[1][b].length() + variabl1119[b])

* variabl1647;

}

if (variabl1597.indexOf("," + variabl1169[b] + ",") >= 0)

variabl1473++;

b++;

}

if (variabl1473 == 0) {

if (variabl2119 + variabl2483 * 80 < variabl2503 * variabl2483) {

variabl2503 = (int) (variabl2119 * 1.5) / variabl1293 + 120;

if (variabl1923 < variabl2503)

variabl2503 = variabl1923;

if (variabl2503 * 4 > variabl2483 * 3)

variabl2483 = variabl2503 * 4 / 3;

if (variabl1745 < variabl2483)

variabl2483 = variabl1745;

}

if (variabl2483 < 500)

variabl2483 = 500;

if (variabl2503 < 300) {

variabl2503 = 300;

}

if (variabl1923 > variabl2503 + variabl1473 * 40)

variabl2503 = variabl2503 + variabl1473 * 40;

else

variabl2503 = variabl1923;

}

int variabl1315 = variabl2483 / variabl1647;

b = 0;

while (b < variabl2113) {

if (variabl1597.lastIndexOf("," + variabl1169[b] + ",") >= 0)

variabl1473++;

if ((variabl1925 + variabl1119[b]) > (variabl1315)) {

variabl1119[b] = variabl1315 - variabl1925;

}

if (variabl1169[b].indexOf("datetime") == 0)

variabl1507[b] = "2001-01-01 00:00:00.000";

else if (variabl1169[b].indexOf("smalldatetime") == 0)

variabl1507[b] = "2001-01-01 00:00:00";

else if (variabl1169[b].indexOf("datetime2") == 0)

variabl1507[b] = "2001-01-01 00:00:00.0000000";

else if (variabl1169[b].indexOf("datetimeoffset") == 0)

variabl1507[b] = "2001-01-01 00:00:00.0000000 +08:00";

else if (variabl1169[b].indexOf("date") == 0)

variabl1507[b] = "2001-01-01";

else if (variabl1169[b].indexOf("time") == 0)

variabl1507[b] = "00:00:00";

else if (variabl1169[b].indexOf("money") >= 0)

variabl1507[b] = "0.0000";

else if (main1.variabl1541.lastIndexOf("," + variabl1169[b] + ",") >= 0)

variabl1507[b] = "0.00";

else if (main1.variabl1545.lastIndexOf("," + variabl1169[b] + ",") >= 0)

variabl1507[b] = "0";

else

variabl1507[b] = "";

b++;

}

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1287[j] == i)

variabl1287[j] = variabl2345[i];

}

}

try {

s1 = "select * from " + variabl2603;

rs = stat4.executeQuery(s1);

rs.absolute(1);

c = 0;

b = 0;

while (c < variabl1853) {

rs.absolute(c + 1);

while (b < variabl2113) {

variabl2197[c][b] = rs.getString(variabl2345[b] + 1);

b++;

}

c++;

b = 0;

}

rs.close();

stat4.close();

cont4.close();

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

try {

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

int u = 0;

if ((variabl2429.lastIndexOf("," + variabl1913[0][j] + "表,") >= 0)

&& (variabl1913[0][j].indexOf("代码") >= 0)) {

s2 = variabl1913[0][j].substring(0,

variabl1913[0][j].length() - 2);

s1 = "select " + variabl1913[0][j] + "," + s2 + " from "

+ variabl1913[0][j] + "表";

u = 1;

} else if (variabl2429.lastIndexOf("," + variabl1913[0][j]

+ "代码表,") >= 0) {

s2 = variabl1913[0][j].substring(0,

variabl1913[0][j].length() - 2);

s1 = "select " + variabl1913[0][j] + ","

+ variabl1913[0][j] + "代码" + " from "

+ variabl1913[0][j] + "代码表";

u = 1;

}

if (u == 1) {

cont4 = main1.getConn();

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

rs = stat4.executeQuery(s1);

ResultSetMetaData rsmd1 = rs.getMetaData();

rs.last();

int numberOfColumns = rs.getRow();

rs.first();

variabl1431[j] = new String[numberOfColumns];

variabl1119[j] = variabl1119[j] + 5;

for (int i = 1; i <= numberOfColumns; i++) {

rs.absolute(i);

variabl1431[j][i - 1] = rs.getString(1) + ","

+ rs.getString(2);

}

rs.close();

stat4.close();

cont4.close();

} else {

variabl1431[j] = new String[1];

variabl1431[j][0] = "";

}

}

} catch (SQLException e3) {

JOptionPane.showMessageDialog(null, "读取数据库数据出错！" + s1);

}

final JPanel panel1 = new JPanel(false);

panel1.setLayout(null);

panel1.setBounds(10, 10, variabl2483 - 10, variabl2503 - 50);

JLabel jl = new JLabel("字段可选内容  :");

jl.setBounds(10, 10, 10, variabl1849);

panel1.add(jl);

variabl1637 = 0;

variabl1693 = 0;

variabl1577 = 0;

variabl1921 = new int[variabl2113][2];

variabl2129 = 0;

variabl1239 = 1;

if ((variabl1371 * variabl1647 * 6.3) % (variabl2483 - 50) == 0)

variabl2179 = (int) (variabl1371 * variabl1647 * 6.3)

% (variabl2483 - 50);

else

variabl2179 = (variabl1371 * variabl1647 * 6) / (variabl2483 - 50)

+ 1;

if ((variabl1473 == 0)

&& (variabl2113 * variabl1849 + variabl2179 * variabl1849 + 40 < variabl2503)) {

variabl1239 = variabl2113;

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

variabl1921[j][0] = 1 + j;

variabl1921[j][1] = 1;

variabl1119[j] = variabl1315 - variabl1925;

}

variabl1637 = (variabl2503 - 120 - (variabl2179 + variabl2113)

* variabl1849)

/ (variabl2179 + variabl2113 + 1);

} else {

int variabl1385 = 1;

int variabl16930 = 0;

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

if (variabl1597.lastIndexOf("," + variabl1169[i] + ",") < 0) {

if ((variabl1693 + variabl1925 + variabl1119[i]) <= variabl1315) {

variabl1693 = variabl1693 + variabl1925

+ variabl1119[i];

variabl1921[i][0] = variabl1239;

variabl1577 = variabl1577 + variabl1925

+ variabl1119[i];

variabl1921[i][1] = variabl1385;

if (variabl16930 < variabl1693)

variabl16930 = variabl1693;

variabl2129 = i;

variabl1385++;

} else {

if (variabl16930 < variabl1693)

variabl16930 = variabl1693;

variabl1239++;

variabl1385 = 1;

variabl1921[i][0] = variabl1239;

variabl1921[i][1] = variabl1385;

variabl1385++;

variabl1693 = variabl1925 + variabl1119[i];

variabl1577 = variabl1925 + variabl1119[i];

if (variabl1693 > variabl1315) {

variabl1119[i] = variabl1119[i]

- (variabl1693 - variabl1315);

variabl1239++;

variabl1385 = 1;

}

}

b = i;

}

}

variabl16930 = 0;

int n = 0, n1 = 0;

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

if (variabl1597.lastIndexOf("," + variabl1169[i] + ",") < 0) {

if ((i > 0) && (variabl1921[i][0] > n)) {

if (variabl16930 < variabl1315) {

variabl1119[i - 1] = variabl1119[i - 1]

+ (variabl1315 - variabl16930);

} else {

variabl1119[i - 1] = variabl1119[i - 1]

- (variabl1315 - variabl16930);

}

variabl16930 = 0;

}

n = variabl1921[i][0];

variabl16930 = variabl16930 + variabl1925 + variabl1119[i];

n1 = i;

}

}

if (variabl16930 < variabl1315)

variabl1119[n1] = variabl1119[n1]

+ (variabl1315 - variabl16930);

if (variabl1473 > 0)

variabl1637 = 0;

else

variabl1637 = (variabl2503 - 120 - variabl2179 * variabl1849 - variabl1239

* variabl1849)

/ (variabl1239 + variabl2179 + 1);

}

variabl1733 = new JTextComponent[variabl2113];

variabl2165 = new JLabel[variabl2113];

variabl1419 = new String[variabl1733.length];

variabl1467 = new int[variabl1733.length];

variabl2403 = new JTextField[variabl1913[0].length];

variabl2359 = new JComboBox[variabl1913[0].length];

int variabl2247 = 1, variabl2331 = 1;

variabl1843 = 0;

variabl1577 = 0;

variabl1459 = variabl1477 + variabl1637 + variabl1805;

for (int j = 0; j < variabl1913[1].length; j++) {

JLabel variabl2533 = new JLabel(variabl1913[1][j], 11);

variabl2403[j] = new JTextField(" ");

if ((variabl1597.lastIndexOf("," + variabl1169[j] + ",")) < 0) {

panel1.add(variabl2533);

if ((variabl1431[j][0] != null)

&& (variabl1431[j][0].length() == 0)) {

panel1.add((Component) variabl2403[j]);

if ((variabl1921[j][0] == variabl2331)

&& (variabl1921[j][1] == variabl2247)) {

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2403[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

variabl2247++;

} else if (variabl1921[j][0] == variabl2331) {

variabl2247++;

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2403[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

} else {

variabl1459 = variabl1459 + variabl1637 + variabl1849;

variabl2331++;

variabl1577 = 0;

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2403[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl2247 = 2;

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

}

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

variabl2403[j].setFont(new Font("宋体", 1, 14));

variabl2403[j].addFocusListener(new FocusAdapter() {

public void focusGained(final FocusEvent arg0) {

Object s0 = arg0.getSource();

String s1 = s0.toString();

int n1 = 0;

for (int i = 0; i < variabl1913[0].length; i++)

if (s1.lastIndexOf("," + variabl1921[i][0]

+ "," + variabl1921[i][1] + ",") > 0) {

variabl1739 = i;

break;

}

}

});

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

variabl1733[variabl1843].setText("");

variabl1467[variabl1843] = j;

variabl1843++;

} else {

variabl2359[j] = new JComboBox();

variabl2403[j] = new JTextField();

variabl2359[j].setEditable(true);

variabl2359[j].setEnabled(true);

panel1.add((Component) variabl2359[j]);

if ((variabl1921[j][0] == variabl2331)

&& (variabl1921[j][1] == variabl2247)) {

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2359[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl1921[j][0] = variabl1577 * variabl1647

+ variabl1925 * variabl1647;

variabl1921[j][1] = variabl1459;

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

variabl2247++;

} else if (variabl1921[j][0] == variabl2331) {

variabl2247++;

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2359[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl1921[j][0] = variabl1577 * variabl1647

+ variabl1925 * variabl1647;

variabl1921[j][1] = variabl1459;

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

} else {

variabl1459 = variabl1459 + variabl1637 + variabl1849;

variabl2331++;

variabl1577 = 0;

variabl2533.setBounds(variabl1577 * variabl1647,

variabl1459, variabl1925 * variabl1647,

variabl1849);

variabl2359[j].setBounds(variabl1577 * variabl1647

+ variabl1925 * variabl1647, variabl1459,

variabl1119[j] * variabl1647, variabl1849);

variabl1921[j][0] = variabl1577 * variabl1647

+ variabl1925 * variabl1647;

variabl1921[j][1] = variabl1459;

variabl2247 = 2;

variabl1577 = variabl1577 + variabl1925

+ variabl1119[j];

}

for (int i = 0; i < variabl1431[j].length; i++) {

String[] s0 = variabl1431[j][i].split(",");

variabl2359[j].addItem(s0[0]);

}

variabl1733[variabl1843] = (JTextComponent) variabl2359[j]

.getEditor().getEditorComponent();

variabl1733[variabl1843].setText("");

variabl1467[variabl1843] = j;

variabl1843++;

}

}

}

if (variabl1473 > 0) {

variabl1459 = variabl1459 + variabl1849;

variabl1313 = (variabl2503 - variabl1459 - 150) / variabl1473;

variabl1577 = 0;

int variabl1319 = (variabl1315 - variabl1925) * variabl1647;

for (int j = 0; j < variabl1913[0].length; j++) {

if ((variabl1597.lastIndexOf("," + variabl1169[j] + ",")) >= 0) {

JLabel variabl2533 = new JLabel(variabl1913[1][j], 11);

variabl2533.setBounds(variabl1577, variabl1459, variabl1925

* variabl1647, variabl1849);

if (main1.variabl1539.lastIndexOf(variabl1169[j]) >= 0) {

JLabel variabl2407 = new JLabel("   ");

variabl2407.setBounds(variabl1577 + variabl1925

* variabl1647, variabl1459, variabl1319,

variabl1313);

panel1.add(variabl2533);

panel1.add(variabl2407);

variabl2165[variabl1843] = variabl2407;

} else {

JTextArea variabl2463 = new JTextArea("   ",

variabl1319, variabl1313);

JScrollPane variabl1147 = new JScrollPane(variabl2463);

variabl1147.setBounds(variabl1577 + variabl1925

* variabl1647, variabl1459, variabl1319,

variabl1313);

panel1.add(variabl2533);

panel1.add((Component) variabl1147);

variabl1733[variabl1843] = (JTextComponent) variabl2463;

}

variabl1459 = variabl1459 + variabl1313;

variabl1467[variabl1843] = j;

variabl1843++;

}

}

}

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

if (main1.variabl1539.lastIndexOf("," + variabl1169[variabl1467[i]]

+ ",") < 0) {

variabl1733[i].setText(variabl1507[variabl1467[i]]);

}

}

if (variabl1473 == 0)

variabl1459 = variabl1459 + 30 + variabl1637;

else

variabl1459 = variabl1459 + 20;

variabl2819002();

int hl0 = variabl1459;

if (variabl2503 != main1.variabl2503)

hl0 = variabl2503 - variabl2179 * (variabl1849 + 30) - 150;

variabl2375 = new JButton(variabl2405[0]);

variabl2375.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

variabl18531 = 0;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[0][variabl1467[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

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

}

}

variabl2325.setEnabled(true);

variabl2255.setEnabled(false);

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",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 (variabl2637.getText().equals("查询")) {

if (variabl18531 < variabl1853 - 1)

variabl18531++;

else {

variabl2325.setEnabled(false);

}

variabl2255.setEnabled(true);

} else {

for (int j = variabl18531 + 1; j <= variabl1853; j++) {

if (variabl2499

.toLowerCase()

.trim()

.equals(variabl2197[j][variabl1739]

.toLowerCase().trim())) {

variabl18531 = j;

break;

} else if (j == variabl1853) {

variabl2325.setEnabled(false);

}

}

}

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else {

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",1,") >= 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) {

variabl18531 = variabl1853 - 1;

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

}

variabl2325.setEnabled(false);

variabl2255.setEnabled(true);

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",2,") >= 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 < variabl1733.length; i++) {

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

}

variabl2325.setEnabled(true);

} else

variabl2255.setEnabled(false);

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",3,") >= 0)) {

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

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

panel1.add(variabl2255);

variabl2255.setEnabled(false);

}

variabl2637 = new JButton(variabl2405[4]);

variabl2637.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2637.getText().trim().equals("查询")) {

variabl2637.setText("还原");

variabl2375.setEnabled(false);

variabl2325.setEnabled(true);

variabl2255.setEnabled(false);

variabl1971.setEnabled(false);

} else {

variabl2637.setText("查询");

variabl18531 = 0;

variabl2375.setEnabled(true);

variabl2325.setEnabled(true);

variabl2255.setEnabled(true);

variabl1971.setEnabled(true);

}

if (variabl2637.getText().trim().equals("还原")) {

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

if (variabl1739 == variabl1467[i]) {

variabl2499 = variabl1733[i].getText();

break;

}

for (int j = 0; j < variabl1853; j++)

if (variabl2499

.toLowerCase()

.trim()

.equals(variabl2197[j][variabl1739]

.toLowerCase().trim())) {

variabl18531 = j;

break;

}

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

String s3 = variabl2197[variabl18531][variabl1467[i]];

if ((s3 != null) && (s3.length() > 10)) {

byte[] c = new byte[s3.length()];

for (int j = 0; j < s3.length(); j++) {

int n1 = Integer.parseInt(

s3.substring(j, j + 1), 16);

int n2 = Integer.parseInt(

s3.substring(j + 1, j + 2), 16);

c[j / 2] = (byte) (n1 * 16 + n2);

j++;

}

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

} else {

byte[] c = { 0 };

Icon icon = new ImageIcon(c);

variabl2165[i].setOpaque(true);

variabl2165[i].setBackground(Color.PINK);

variabl2165[i].setIcon(icon);

}

} else

variabl1733[i]

.setText(variabl2197[variabl18531][variabl1467[i]]);

if (main1.variabl1545.lastIndexOf(","

+ variabl1169[variabl1739] + ",") >= 0)

variabl2031 = variabl1913[0][variabl1739] + "="

+ variabl2499;

else

variabl2031 = variabl1913[0][variabl1739] + "='"

+ variabl2499 + "'";

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",4,") >= 0)) {

variabl2637.setBounds(variabl1885[4][0], variabl1885[4][1],

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

panel1.add(variabl2637);

}

variabl2531 = new JButton(variabl2405[5]);

variabl2531.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

if (variabl2531.getText().trim().equals("浏览")) {

variabl2531.setText("转当前行");

variabl1701 = new String[variabl1853][variabl2113];

int[] n = new int[variabl1119.length];

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

for (int j = 0; j < variabl2113; 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 < variabl2113; j++) {

n[j] = variabl1119[j];

if (n[j] > 50)

n[j] = 50;

}

tableTenance.tableModel(variabl2483, variabl2503,

variabl1913[1], n, variabl1701, variabl1169);

} else {

variabl2531.setText("浏览");

variabl18531 = main1.variabl1327;

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

variabl1733[i]

.setText(variabl2197[main1.variabl1327][variabl1467[i]]);

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",5,") >= 0)) {

variabl2531.setBounds(variabl1885[5][0], variabl1885[5][1],

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

panel1.add(variabl2531);

}

variabl2611 = new JButton(variabl2405[6]);

variabl2611.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539.lastIndexOf(","

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

variabl1419[i] = variabl1733[i].getText().trim();

if (variabl1419[i].trim().equals("null"))

variabl1419[i] = " ";

} else {

variabl1419[i] = "?";

}

}

cont4 = main1.getConn();

try {

s1 = "insert into " + variabl2603 + "(";

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

if (main1.variabl1539

.lastIndexOf(variabl1169[variabl1467[j]]) < 0)

s1 = s1 + variabl1913[0][variabl1467[j]] + ",";

}

s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";

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

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[j]] + ",") >= 0)

s1 = s1;

else if (main1.variabl1545.lastIndexOf(","

+ variabl1169[variabl1467[j]] + ",") >= 0)

s1 = s1 + variabl1419[j] + ",";

else if (variabl1419[j].trim().equals("?"))

s1 = s1;

else

s1 = s1 + "'" + variabl1419[j].trim() + "',";

}

s1 = s1.substring(0, s1.length() - 1) + ")";

s3 = "";

boolean bool = true;

for (int j = 0; j < variabl1525.length; j++) {

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

if (variabl1467[i] == variabl1287[j]) {

s3 = s3 + variabl1419[i];

break;

}

}

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

s4 = "";

for (int j = 0; j < variabl1525.length; j++) {

s4 = s4 + variabl2197[i][variabl1287[j]].trim();

}

if (s3.toLowerCase().trim()

.equals(s4.toLowerCase().trim())) {

bool = false;

JOptionPane.showMessageDialog(null,

"关键字重复，请修改后再录入！");

break;

}

}

if (bool) {

PreparedStatement pst4 = cont4.prepareStatement(s1);

char x1 = 10, x2 = 13;

int k2 = 1;

pst4.execute();

pst4.close();

stat4.close();

cont4.close();

variabl1853++;

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

variabl2197[variabl1853 - 1][variabl1467[k]] = variabl1419[k];

}

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "存盘语句错！" + s1);

}

int t = 0;

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

if (main1.variabl1539.lastIndexOf(","

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

t = 0;

for (int j = 0; j < variabl1525.length; j++)

if (i == variabl1287[j])

t = 1;

if (t == 0)

variabl1733[i].setText(variabl1507[variabl1467[i]]);

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",6,") >= 0)) {

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

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

panel1.add(variabl2611);

}

variabl2601 = new JButton(variabl2405[7]);

variabl2601.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539.lastIndexOf(","

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

variabl1733[i].setText(variabl1507[variabl1467[i]]);

}

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",7,") >= 0)) {

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

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

panel1.add(variabl2601);

}

variabl1697 = new JButton(variabl2405[8]);

variabl1697.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539.lastIndexOf(","

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

variabl1419[i] = variabl1733[i].getText().trim();

if (variabl1419[i].equals("null")) {

variabl1419[i] = " ";

}

} else {

variabl1419[i] = "?";

}

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(","

+ variabl1169[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 {

s1 = "update " + variabl2603 + " set ";

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

if (main1.variabl1539

.lastIndexOf(variabl1169[variabl1467[j]]) < 0) {

s1 = s1 + variabl1913[0][variabl1467[j]] + "=";

if (main1.variabl1545.lastIndexOf(","

+ variabl1169[variabl1467[j]] + ",") >= 0)

s1 = s1 + variabl1419[j];

else if (variabl1419[j].trim().equals("?"))

s1 = s1 + variabl1419[j];

else

s1 = s1 + "'" + variabl1419[j].trim() + "'";

s1 = s1 + ",";

}

}

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 = variabl1913[0][variabl1467[i]];

}

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, "修改语句错！" + s1);

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",8,") >= 0)) {

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

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

panel1.add(variabl1697);

}

variabl2633 = new JButton(variabl2405[9]);

variabl2633.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539

.lastIndexOf(variabl1169[variabl1467[i]]) < 0)

variabl1419[i] = variabl1733[i].getText().trim();

}

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(","

+ variabl1169[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();

for (int i = variabl18531; i < variabl1853 - 1; i++)

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

variabl2197[i][variabl1467[k]] = variabl2197[i + 1][variabl1467[k]];

}

variabl1853--;

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

if (main1.variabl1539.lastIndexOf(variabl1169[k]) < 0)

variabl1733[k].setText(variabl1507[variabl1467[k]]);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "删除语句错！" + s1);

}

}

});

if ((variabl1187.length() < 3) || (variabl1187.lastIndexOf(",9,") >= 0)) {

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

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

panel1.add(variabl2633);

}

variabl2315 = new JButton(variabl2405[10]);

variabl2315.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

s2 = "";

if (variabl2637.getText().trim().equals("还原")) {

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

if (variabl1739 == variabl1467[i]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1169[variabl1739] + ",") >= 0)

s2 = "update " + variabl2603 + " set "

+ variabl1913[0][variabl1739] + "="

+ variabl1733[i].getText() + " where "

+ variabl2031;

else

s2 = "update " + variabl2603 + " set "

+ variabl1913[0][variabl1739] + "='"

+ variabl1733[i].getText().trim()

+ "' where " + variabl2031;

break;

}

} else {

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

if (variabl1739 == variabl1467[i]) {

if (main1.variabl1545.lastIndexOf(","

+ variabl1169[variabl1739] + ",") >= 0)

s2 = "update " + variabl2603 + " set "

+ variabl1913[0][variabl1739] + "="

+ variabl1733[i].getText();

else

s2 = "update " + variabl2603 + " set "

+ variabl1913[0][variabl1739] + "='"

+ variabl1733[i].getText().trim() + "'";

break;

}

}

cont4 = main1.getConn();

try {

stat4 = cont4.createStatement(

ResultSet.TYPE_SCROLL_INSENSITIVE,

ResultSet.CONCUR_UPDATABLE);

stat4.executeUpdate(s2);

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "批删除语句错！");

}

}

});

if ((variabl1187.length() < 3)

|| (variabl1187.lastIndexOf(",10,") >= 0)) {

variabl2315.setBounds(variabl1885[10][0], variabl1885[10][1],

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

panel1.add(variabl2315);

}

图片存盘 = new JButton(variabl2405[11]);

variabl2185[11] = 图片存盘;

图片存盘.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

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

if (main1.variabl1539.lastIndexOf(","

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

variabl1419[i] = variabl1733[i].getText().trim();

if (variabl1419[i].equals("null")) {

variabl1419[i] = " ";

}

} else {

variabl1419[i] = "?";

}

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(","

+ variabl1169[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 {

s1 = "update " + variabl2603 + " set ";

int n = s1.length();

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

if (variabl1419[j].trim().equals("?"))

if (s1.length() == n)

s1 = s1 + variabl1913[0][variabl1467[j]] + "="

+ variabl1419[j];

else

s1 = s1 + "," + variabl1913[0][variabl1467[j]]

+ "=" + variabl1419[j];

}

s1 = s1 + " 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 = variabl1913[0][variabl1467[i]];

if (main1.variabl1539.lastIndexOf(","

+ variabl1169[variabl1467[i]] + ",") >= 0) {

final JFileChooser fc = new JFileChooser(".\\");

fc.showOpenDialog(null);

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

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

variabl2197[variabl18531][variabl1467[k]] = variabl1419[k];

}

} catch (SQLException e2) {

JOptionPane.showMessageDialog(null, "修改语句错！" + s1);

} catch (IOException e3) {

JOptionPane.showMessageDialog(null, "文件读取出错！");

}

}

});

if ((variabl1187.length() < 3)

|| (variabl1187.lastIndexOf(",11,") >= 0)) {

图片存盘.setBounds(variabl1885[11][0], variabl1885[11][1],

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

panel1.add(图片存盘);

}

variabl2599 = new JButton(variabl2405[12]);

variabl2185[12] = variabl2599;

variabl2599.addActionListener(new ActionListener() {

public void actionPerformed(ActionEvent e) {

panel1.setVisible(false);

frame1.setVisible(false);

frame1.dispose();

}

});

if ((variabl1187.length() < 3)

|| (variabl1187.lastIndexOf(",12,") >= 0)) {

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

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

panel1.add(variabl2599);

}

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

panel1.setBounds(10, 10, variabl2483 + 50, 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;

frame1.setBounds(w1, h1, variabl2483 + 50, variabl2503);

frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);

frame1.getContentPane().setLayout(null);

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

frame1.setVisible(true);

}

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

variabl1577 = 0;

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

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;

variabl1577 = variabl1577 + variabl1885[j][2];

} else {

variabl1885[j][2] = variabl1629;

variabl1577 = variabl1577 + variabl1629;

}

variabl1885[j][3] = variabl1849;

n++;

n1++;

if (variabl1371 - n1 == 0)

break;

if ((n >= variabl1505)

&& ((variabl1371 - n1) - variabl1505 != 0)) {

variabl1577 = 0;

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

variabl1577 = 0;

variabl1459 = variabl1459 + variabl1849 + 20;

n = 0;

n2++;

}

}

}

variabl2503 = variabl1459 + variabl1849 + 100;

}

}

73.源码73，部件程序，表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签、可显示与录入图片。

/** 

 * 程序文件名：dataTenance4.java 

 * 作者：程学先  

 * 功能：表单程序（单记录数据维护程序），应用列表框提供代码或历史数据辅助录入、可变换标签、可显示与录入图片。 

 * 本程序设计在每次调用时使用不同类名，更能防止多次同时并发调用时可能出现的不稳定。 

  */

    import java.awt.*; 

     import java.awt.event.*; 

     import javax.swing.*; 

     import javax.swing.table.*; 

     import java.sql.*; 

     import java.util.ArrayList; 

     import java.util.HashSet; 

     import java.util.Set; 

     import java.util.Vector; 

     import java.io.*; 

     import java.awt.Component; 

     import java.awt.event.ActionEvent; 

     import java.awt.event.ActionListener; 

     import java.awt.event.FocusAdapter; 

     import java.awt.event.FocusEvent; 

     import java.awt.event.MouseAdapter; 

     import java.awt.event.MouseEvent; 

     import java.util.Vector; 

     import javax.swing.JButton; 

     import javax.swing.JComboBox; 

     import javax.swing.JComponent; 

     import javax.swing.JFileChooser; 

     import javax.swing.JFrame; 

     import javax.swing.JLabel; 

     import javax.swing.JTextField; 

     import javax.swing.WindowConstants; 

     import javax.swing.text.JTextComponent; 

     import javax.swing.text.html.HTMLDocument.Iterator; 

     import javax.swing.event.DocumentListener; 

     import javax.swing.event.DocumentEvent; 

      

     public class dataTenance4  

     { 

      private static JFrame framet1; 

      private static List list1; 

      private static JTextComponent[] variabl1733; 

      private static JLabel [] variabl2165; 

      private static int [] variabl1467; 

      private static JButton[] variabl2185=new JButton[13]; 

      private static Connection cont4;  

      private static Statement stat4;    

      private static ResultSetMetaData rsmdt4; 

      private static ResultSet rs;  

      private static String variabl2603 ; 

      private static String variabl2429 ;  

      private static String variabl1873; 

      private static int variabl2483 =main1.variabl2483; 

      private static int variabl2503 = main1.variabl2503; 

      private static int variabl1531 =main1.variabl1531,variabl1477= main1.variabl1477; 

      private static int variabl2651;  

      private static int variabl2113[]=new int[10];  

      private static String[][] variabl2517;  

      private static String[][][] variabl1913=new String[10][2][]; 

      private static String[] variabl1501;  

      private static String[][] variabl1169=new String[10][];  

      private static int[] variabl1489; 

      private static int[] variabl1119;  

      private static int [] variabl1853=new int[10]; 

      private static int [] variabl18531=new int[10]; 

      private static String[][][] variabl2197=new String[10][][]; 

      private static String[][][] variabl1431=new String[10][][]; 

      private static String  [][] variabl1419=new String[10][]; 

      static String[][] variabl1701;  

      private static String variabl1187 ; 

      private static int variabl1371=0; 

      private static String variabl1153 ; 

      private static String[][] variabl1507=new String[10][]; 

      private static String variabl2309="";  

      private static String[][] variabl1525=new String[10][]; 

      private static String[][] variabl1377=new String[10][]; 

      private static int[] variabl1287; 

      private static String s1 = "", s2 = "",s3="",s4="",s5="";  

      private static String variabl2031 = "",variabl2499=""; 

      private static int b = 0, c = 0; 

      private static String[] variabl1425; 

      private static int[] variabl2345; 

      private static int variabl1947=0,variabl1739=0;  

      private static int [][][] variabl1921=new int[10][][];  

      private static int variabl1843=0; 

      private static String variabl1175=""; 

      private static int variabl1057=100; 

      private static int variabl1647=15,variabl1849=20;   

      private static String[] variabl2405={"第一条","下一条","最后一条","上一条","查询","浏览","存盘" 

      ,"清屏","修改存盘","删除","批处理","图片存盘","退出"}; 

      private static JButton b1;                     

      private static  JButton variabl2375,variabl2325,variabl1971,variabl2255,variabl2637,variabl2531,variabl2611,variabl2601,variabl1697,variabl2633,variabl2315,图片存盘,variabl2599; 

      private static String variabl1597=main1.variabl1537 + main1.variabl1539; 

      private static int variabl1097=0;  

      static int variabl2851=0,variabl2339=0; 

      private static int [][] variabl1885=null; 

      private static int variabl1637=0;  

      private static int variabl1693=0;    

      private static int variabl1577,variabl1313;  

      private static int variabl2129=0; 

      private static int variabl2179; 

      private static int variabl1239=1; 

      private static int variabl1459=0; 

      private static int variabl1473=0; 

      private static int variabl2833; 

       

     static void means(String parameter[],JFrame frame1) { 

      variabl1531 =main1.variabl1531;variabl1477= main1.variabl1477; 

      variabl2113=new int[10];  

      variabl1913=new String[10][2][]; 

      variabl1169=new String[10][];  

      variabl1853=new int[10]; 

      variabl18531=new int[10]; 

      variabl2197=new String[10][][]; 

      variabl1431=new String[10][][]; 

      variabl1419=new String[10][]; 

      variabl1371=0;variabl1313=0; 

      variabl1507=new String[10][]; 

      variabl2309="";variabl1525=new String[10][]; 

      variabl1377=new String[10][]; s1 = ""; s2 = "";s3="";s4="";s5="";  

      variabl2031 = "";variabl2499=""; b = 0; c = 0; 

      variabl1947=0;variabl1739=0; variabl2833=0; 

      variabl1921=new int[10][][];  

      variabl1843=0;variabl1175=""; variabl1057=100; 

      variabl1647=15;variabl1849=20;   

      variabl1597=main1.variabl1537 + main1.variabl1539; 

      variabl1097=0;  

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

      variabl2483=main1.variabl2483;  variabl2503=main1.variabl2503; 

      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 ; 

         variabl2503=m2 ; 

      } 

      }catch(Exception e2){} 

      variabl2603=parameter[4] ; 

             variabl2429=","+parameter[0]+",";  

             String [] t1=parameter[0].split(","); 

             variabl1873=""; 

             if (variabl2429.lastIndexOf(variabl2603+"字典表")>=0)  

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

             if (t1[i].lastIndexOf(variabl2603+"字典表")>=0) variabl1873=t1[i]; 

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

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

             return; 

          } 

      final int variabl1805=Integer.parseInt(parameter[21]);   

      variabl1525[variabl1805]=parameter[6].split(","); 

      variabl1377[variabl1805]=new String[variabl1525[variabl1805].length];; 

      variabl1153=parameter[8] ;  

      variabl1287=new int[variabl1525[variabl1805].length]; 

      framet1=frame1; 

      variabl2185=new JButton[13]; 

      framet1=frame1; 

      variabl2185=new JButton[13]; 

      try 

      {  

      cont4=main1.getConn(); 

      stat4 = cont4.createStatement( 

      ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE); 

      s1 = "select * from " + variabl2603; 

      rs = stat4.executeQuery(s1); 

      rs.last(); 

      variabl1853[variabl1805] = rs.getRow();  

      rsmdt4 = rs.getMetaData(); 

      variabl2651 = rsmdt4.getColumnCount(); 

      variabl2517 = new String[2][variabl2651];  

      variabl1501 = new String[variabl2651]; 

      variabl1489 = new int[variabl2651]; 

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

          variabl2517[0][i] = rsmdt4.getColumnName(i + 1);  

          variabl2517[1][i] = variabl2517[0][i]; 

      variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);  

      variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1); 

      if (variabl1647*(variabl1489[i]+variabl2517[1][i].length())+variabl1057>variabl2483) variabl1501[i]="text"; 

      } 

      for (int j = 0; j< variabl1525[variabl1805].length; j++) 

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

                 if (variabl1525[variabl1805][j].toLowerCase().trim().equals(variabl2517[0][i].toLowerCase().trim())) { 

                    variabl1287[j] = i; 

                     if ((variabl1153.length() >0)&&((","+variabl1153+",").lastIndexOf(","+i+",")<0)) 

                             variabl1153=variabl1153+","+i; 

                 break; 

                 } 

                } 

            rs.close();    

            if (variabl1873.length()>0){   

            s1 = "select * from " + variabl1873;  

            rs = stat4.executeQuery(s1); 

                       ResultSetMetaData rsmd = rs.getMetaData(); 

               rs.last();  

                         int numberOfColumns=rs.getRow();   

                         rs.first();

                        String s4=""; 

                        String s5=""; 

                     for (int i=1;i<=numberOfColumns;i++){ 

                        rs.absolute(i); 

                            s4=rs.getString(1); 

                            s5=rs.getString(2); 

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

                              if (variabl2517[0][j].toLowerCase().trim().equals(s4.trim().toLowerCase())){ 

                            variabl2517[1][j]=s5; 

                          break; 

                            } 

                            } 

                         } 

                      rs.close();   

            } 

      } catch (SQLException e) 

      { 

      JOptionPane.showMessageDialog( null, "连接数据库出错！"+s1); 

      } 

      variabl1153 = "," + variabl1153 + ","; 

      variabl2345 = new int[variabl2651];  

      int b0 = 0, b = -1; 

      while (b0 < variabl2651) { 

      if ((variabl1153.length() < 3) 

      || (variabl1153.lastIndexOf(","+b0+",") >= 0)) 

      { 

      b = b + 1; 

      variabl2345[b] = b0;  

      } 

      b0++; 

      } 

      variabl2113[variabl1805] = b + 1;  

      variabl1913[variabl1805] = new String[2][variabl2113[variabl1805]];  

      variabl1169[variabl1805] = new String[variabl2113[variabl1805]];  

      variabl1119 = new int[variabl2113[variabl1805]]; 

      variabl2197[variabl1805] = new String[variabl1853[variabl1805]+300][variabl2113[variabl1805]];  

      variabl1431[variabl1805] = new String [variabl2113[variabl1805]][];  

             variabl1507[variabl1805] = new String[variabl2113[variabl1805]]; 

             int variabl1925=0;  

      variabl1473=0;  

      int variabl1293=0;  

        int variabl2119=0,variabl1745=variabl2483,variabl1923=variabl2503; 

            b=0; 

      while (b < variabl2113[variabl1805]){ 

      variabl1913[variabl1805][0][b] = variabl2517[0][variabl2345[b]];  

      variabl1913[variabl1805][1][b] = variabl2517[1][variabl2345[b]];   

      variabl2309=variabl2309+variabl1913[variabl1805][0][b]; 

      variabl1169[variabl1805][b] = variabl1501[variabl2345[b]]; 

      variabl1119[b] = variabl1489[variabl2345[b]];   

          if (variabl1913[variabl1805][1][b].length()>variabl1925) variabl1925=variabl1913[variabl1805][1][b].length(); 

          if ((variabl1597.indexOf(","+variabl1169[variabl1805][b]+",")<0)&&(variabl1293<(variabl1913[variabl1805][1][b].length()+variabl1119[b])*variabl1647)){ 

          variabl1293=(variabl1913[variabl1805][1][b].length()+variabl1119[b])*variabl1647; 

          } 

          if (variabl1597.indexOf(","+variabl1169[variabl1805][b]+",")>=0) 

          variabl1473++;   

          b++; 

      } 

      if (variabl1473==0){ 

        if (variabl2119+variabl1057*(variabl2503-120)+variabl2483*80<variabl2503*variabl2483){ 

        if (variabl1293<variabl1057*1.5)  

        variabl1293=(int)(variabl1057*1.5); 

        if (variabl1923<variabl2503) variabl2503=variabl1923; 

        if (variabl2503*4>variabl2483*3) variabl2483=variabl2503*4/3;

        if (variabl1745<variabl2483) variabl2483=variabl1745; 

        } 

        if (variabl2483<500) variabl2483=500; 

        if (variabl2503<300) { 

        variabl2503=300; 

        } 

       if (variabl1923>variabl2503+variabl1473*40)  variabl2503=variabl2503+variabl1473*40; 

       else variabl2503=variabl1923; 

      } 

                  int variabl1315=(variabl2483-variabl1057-30)/16; 

      b = 0; 

      while (b < variabl2113[variabl1805]) 

      { 

                 if (variabl1597.lastIndexOf(","+variabl1169[variabl1805][b]+",") >= 0) 

                  variabl1473++; 

      if ((variabl1925+variabl1119[b])>(variabl1315))  {    

          variabl1119[b]=variabl1315-variabl1925;   

         } 

      if (variabl1169[variabl1805][b].indexOf("datetime") == 0) 

      variabl1507[variabl1805][b] = "2001-01-01 00:00:00.000"; 

      else if (variabl1169[variabl1805][b].indexOf("smalldatetime") == 0) 

      variabl1507[variabl1805][b] = "2001-01-01 00:00:00"; 

     

      else if (variabl1169[variabl1805][b].indexOf("datetime2") == 0) 

      variabl1507[variabl1805][b] = "2001-01-01 00:00:00.0000000"; 

      else if (variabl1169[variabl1805][b].indexOf("datetimeoffset") == 0) 

      variabl1507[variabl1805][b] = "2001-01-01 00:00:00.0000000 +08:00"; 

      else if (variabl1169[variabl1805][b].indexOf("date") == 0) 

      variabl1507[variabl1805][b] = "2001-01-01"; 

      else if (variabl1169[variabl1805][b].indexOf("time") == 0) 

      variabl1507[variabl1805][b] = "00:00:00"; 

      else if (variabl1169[variabl1805][b].indexOf("money") >= 0) 

      variabl1507[variabl1805][b] = "0.0000"; 

      else if (main1.variabl1541.lastIndexOf(","+variabl1169[variabl1805][b]+",") >= 0) 

      variabl1507[variabl1805][b] = "0.00"; 

      else if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][b]+",") >= 0) 

                     variabl1507[variabl1805][b]  = "0"; 

      else 

                        variabl1507[variabl1805][b]  = ""; 

          b++; 

      } 

      for (int j = 0; j< variabl1525[variabl1805].length; j++){ 

      for (int i = 0; i< variabl2113[variabl1805]; i++){ 

      if (variabl1287[j]==i) variabl1287[j]=variabl2345[i];   

      } 

      } 

        try{ 

      s1 = "select * from " + variabl2603;  

      rs = stat4.executeQuery(s1); 

             rs.absolute(1);  

      c = 0;  

      b = 0;  

      while (c < variabl1853[variabl1805]) 

      { 

      rs.absolute(c + 1);  

      while (b < variabl2113[variabl1805]) 

      { 

      variabl2197[variabl1805][c][b] = rs.getString(variabl2345[b] + 1);  

      b++; 

      } 

      c++; 

      b = 0; 

      } 

            rs.close();     

           stat4.close();   

           cont4.close(); 

     } catch(SQLException e2){ 

      JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1); 

     } 

         try 

      {             

      for (int j=0;j<variabl2113[variabl1805];j++){ 

            int u=0;     

            if ((variabl2429.lastIndexOf(","+variabl1913[variabl1805][0][j]+"表,")>=0)&&(variabl1913[variabl1805][0][j].indexOf("代码")>=0)) { 

            s2=variabl1913[variabl1805][0][j].substring(0,variabl1913[variabl1805][0][j].length()-2); 

            s1 = "select "+variabl1913[variabl1805][0][j]+","+s2+" from " + variabl1913[variabl1805][0][j]+"表"; 

            u=1; 

            } else if(variabl2429.lastIndexOf(","+variabl1913[variabl1805][0][j]+"代码表,")>=0){ 

            s2=variabl1913[variabl1805][0][j].substring(0,variabl1913[variabl1805][0][j].length()-2); 

            s1 = "select "+variabl1913[variabl1805][0][j]+","+variabl1913[variabl1805][0][j]+"代码"+" from " + variabl1913[variabl1805][0][j]+"代码表"; 

            u=1; 

            } 

               if (u==1){ 

                          cont4=main1.getConn(); 

                          stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, 

                            ResultSet.CONCUR_UPDATABLE);  

                          rs = stat4.executeQuery(s1); 

                        ResultSetMetaData rsmd1 = rs.getMetaData(); 

             rs.last();  

                         int numberOfColumns=rs.getRow();   

                         rs.first();

                variabl1431[variabl1805][j] = new String [numberOfColumns];  

                        for (int i=1;i<=numberOfColumns;i++){ 

                        rs.absolute(i); 

                        variabl1431[variabl1805][j][i-1]=rs.getString(1)+","+rs.getString(2); 

                         } 

                        rs.close(); 

                        stat4.close();    

                        cont4.close(); 

               } 

         } 

     } catch(SQLException e3){ 

      JOptionPane.showMessageDialog( null, "读取数据库数据出错！"+s1); 

     } 

         final JPanel panel1 = new JPanel(false);  

      panel1.setLayout(null);   

      panel1.setBounds(10, 10,variabl2483-10,variabl2503-50); 

      JLabel jl = new JLabel("字段可选内容  :"); 

      jl.setBounds(10, 10,variabl1057, variabl1849);  

      list1 = new List(); 

      panel1.add(jl); 

      variabl1637=0;  

      variabl1693=0;    

      variabl1577=variabl1057/variabl1647+1;  

      variabl1921[variabl1805]=new int[variabl2113[variabl1805]][2]; 

      variabl2129=0; 

      variabl1239=1; 

      if ((variabl1371*variabl1647*6.3)%(variabl2483-50)==0) variabl2179=(int)(variabl1371*variabl1647*6.3)%(variabl2483-50); 

      else variabl2179=(variabl1371*variabl1647*6)/(variabl2483-50)+1; 

      if ((variabl1473==0)&&(variabl2113[variabl1805]*variabl1849+variabl2179*variabl1849+40<variabl2503)){ 

      variabl1239=variabl2113[variabl1805]; 

      for (int j=0;j<variabl2113[variabl1805];j++){ 

      variabl1921[variabl1805][j][0]=1+j;  

      variabl1921[variabl1805][j][1]=1;   

      variabl1119[j]=variabl1315-variabl1925; 

      } 

      variabl1637=(variabl2503-120-(variabl2179+variabl2113[variabl1805])*variabl1849)/(variabl2179+variabl2113[variabl1805]+1); 

      } 

      else  

      {    

        int variabl1385=1; 

            int variabl16930=0; 

        for (int i=0;i<variabl2113[variabl1805];i++)  { 

         if (variabl1597.lastIndexOf(","+variabl1169[variabl1805][i]+",")<0) { 

              if  ((variabl1693+variabl1925+variabl1119[i])<=variabl1315) {  

                   variabl1693=variabl1693+variabl1925+variabl1119[i];  

                   variabl1921[variabl1805][i][0]=variabl1239;    

                    variabl1577=variabl1577+variabl1925+variabl1119[i]; 

                   variabl1921[variabl1805][i][1]=variabl1385; 

                           if (variabl16930<variabl1693) variabl16930=variabl1693; 

                   variabl2129=i; 

                                          variabl1385++; 

              }    

              else   {   

      if (variabl16930<variabl1693) variabl16930=variabl1693; 

                         variabl1239++; 

                                               variabl1385=1; 

                          variabl1921[variabl1805][i][0]=variabl1239; 

                         variabl1921[variabl1805][i][1]=variabl1385; 

                                        variabl1385++; 

                         variabl1693=variabl1925+variabl1119[i];   

                         variabl1577=variabl1057/variabl1647+1+variabl1925+variabl1119[i]; 

              } 

              b=i; 

         }    

       } 

      variabl16930=0; 

      int n=0,n1=0; 

      for (int i = 0; i < variabl2113[variabl1805]; i++) { 

      if (variabl1597.lastIndexOf("," + variabl1169[variabl1805][i] + ",") < 0) { 

      if ((i>0)&&(variabl1921[variabl1805][i][0]>n)) { 

      if (variabl16930<variabl1315) { 

      variabl1119[i-1]=variabl1119[i-1]+(variabl1315-variabl16930); 

      } 

      else { 

      variabl1119[i-1]=variabl1119[i-1]-(variabl1315-variabl16930); 

      } 

      variabl16930=0; 

      } 

      n=variabl1921[variabl1805][i][0]; 

      variabl16930=variabl16930 + variabl1925 + variabl1119[i]; 

      n1=i; 

      } 

      } 

      if (variabl16930<variabl1315)  

      variabl1119[n1]=variabl1119[n1]+(variabl1315-variabl16930); 

      if (variabl1473>0) variabl1637=0;  

       else 

             variabl1637=(variabl2503-120-variabl2179*variabl1849-variabl1239*variabl1849)/(variabl1239+variabl2179+1); 

      } 

               variabl1733 = new JTextComponent[variabl2113[variabl1805]]; 

                variabl2165=new JLabel[variabl2113[variabl1805]]; 

                variabl1419[variabl1805] = new String[variabl1733.length]; 

                variabl1467= new int[variabl1733.length]; 

                 int variabl2247=1,variabl2331=1; 

                 variabl1843=0; 

                 variabl1577=variabl1057/variabl1647+variabl1805;  

                 variabl1459=variabl1477+variabl1637+variabl1805;  

         for (int j = 0; j < variabl1913[variabl1805][1].length; j++) { 

      JLabel variabl2533 = new JLabel(variabl1913[variabl1805][1][j], 11);  

      JTextField variabl2403 = new JTextField(" "); 

                 if ((variabl1597.lastIndexOf(","+variabl1169[variabl1805][j]+","))<0) { 

                panel1.add(variabl2533); 

                panel1.add((Component)variabl2403); 

      if ((variabl1921[variabl1805][j][0]==variabl2331)&&(variabl1921[variabl1805][j][1]==variabl2247)){ 

         variabl2533.setBounds(variabl1577*variabl1647,variabl1459,variabl1925*variabl1647,variabl1849);   

      variabl2403.setBounds(variabl1577*variabl1647+variabl1925*variabl1647,variabl1459,variabl1119[j]*variabl1647,variabl1849);   

      variabl1921[variabl1805][j][0]=variabl1577*variabl1647+variabl1925*variabl1647; 

      variabl1921[variabl1805][j][1]=variabl1459; 

      variabl1577=variabl1577+variabl1925+variabl1119[j]; 

      variabl2247++; 

        } 

       else if (variabl1921[variabl1805][j][0]==variabl2331){    

      variabl2247++; 

      variabl2533.setBounds(variabl1577*variabl1647,variabl1459,variabl1925*variabl1647,variabl1849); 

      variabl2403.setBounds(variabl1577*variabl1647+variabl1925*variabl1647,variabl1459,variabl1119[j]*variabl1647,variabl1849);  

      variabl1921[variabl1805][j][0]=variabl1577*variabl1647+variabl1925*variabl1647; 

      variabl1921[variabl1805][j][1]=variabl1459; 

      variabl1577=variabl1577+variabl1925+variabl1119[j]; 

       } 

      else {  

      variabl1459=variabl1459+variabl1637+variabl1849; 

      variabl2331++; 

      variabl1577=variabl1057/variabl1647+variabl1805; 

      variabl2533.setBounds(variabl1577*variabl1647,variabl1459,variabl1925*variabl1647,variabl1849);  

      variabl2403.setBounds(variabl1577*variabl1647+variabl1925*variabl1647,variabl1459,variabl1119[j]*variabl1647,variabl1849); 

      variabl1921[variabl1805][j][0]=variabl1577*variabl1647+variabl1925*variabl1647; 

      variabl1921[variabl1805][j][1]=variabl1459; 

      variabl2247=2;  

      variabl1577=variabl1577+variabl1925+variabl1119[j]; 

      } 

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

      variabl2403.addFocusListener(new FocusAdapter() {       

      public void focusGained(final FocusEvent arg0) { 

             Object s0=arg0.getSource(); 

      String s1 = s0.toString(); 

      int n1=0; 

      for (int i = 0; i < variabl1913[variabl1805][0].length; i++)  

         if (s1.lastIndexOf(","+variabl1921[variabl1805][i][0]+","+variabl1921[variabl1805][i][1]+",")>0){ 

      variabl1739=i; 

      break; 

        } 

      list1.removeAll();  

      if((variabl2429.lastIndexOf(","+variabl1913[variabl1805][0][variabl1739]+"代码表,")>=0)|| 

      ((variabl1913[variabl1805][0][variabl1739].indexOf("代码")>=0)&&(variabl2429.lastIndexOf(","+variabl1913[variabl1805][0][variabl1739]+"表,")>=0))) 

      

      for (int i=0;i<variabl1431[variabl1805][variabl1739].length;i++){

           list1.add(variabl1431[variabl1805][variabl1739][i]); 

      } 

      else {

         int u1=0;  

      for (int j = 0; j < variabl1853[variabl1805]; j++) { 

         int u2=0;   

         for (int k=0;k<u1;k++){  

            if (variabl2197[variabl1805][j][variabl1739]==null) 

                                               variabl2197[variabl1805][j][variabl1739]=" "; 

            if (variabl2197[variabl1805][j][variabl1739].toLowerCase().trim().equals(list1.getItem(k).trim().toLowerCase())){ 

            u2++; 

            break ; 

            } 

          } 

           if (u2==0) {    

            list1.add(variabl2197[variabl1805][j][variabl1739]); 

            u1++; 

            } 

         } 

       } 

      } 

      }); 

      variabl1733[variabl1843] = (JTextComponent)variabl2403; 

             variabl1467[variabl1843] = j; 

      variabl1843++; 

      } 

          } 

          if (variabl1473>0){ 

      variabl1459=variabl1459+variabl1849; 

      variabl1313=(variabl2503-variabl1459-150)/variabl1473; 

      variabl1577=variabl1057+variabl1805; 

      int variabl1319=(variabl1315-variabl1925)*variabl1647; 

      for (int j = 0; j < variabl1913[variabl1805][0].length; j++){  

        if ((variabl1597.lastIndexOf(","+variabl1169[variabl1805][j]+","))>=0) { 

      JLabel variabl2533 = new JLabel(variabl1913[variabl1805][1][j], 11);  

      variabl2533.setBounds(variabl1577,variabl1459,variabl1925*variabl1647,variabl1849);  

      if (main1.variabl1539.lastIndexOf(variabl1169[variabl1805][j])>=0){ 

      JLabel variabl2407=new JLabel("   "); 

      variabl2407.setBounds(variabl1577+variabl1925*variabl1647,variabl1459,variabl1319,variabl1313); 

      panel1.add(variabl2533); 

      panel1.add(variabl2407); 

      variabl2165[variabl1843] = variabl2407; 

      } 

      else { 

      JTextArea variabl2463=new JTextArea("   ",variabl1319,variabl1313); 

      JScrollPane variabl1147 = new JScrollPane(variabl2463); 

      variabl1147.setBounds(variabl1577+variabl1925*variabl1647,variabl1459,variabl1319,variabl1313); 

            panel1.add(variabl2533); 

            panel1.add((Component)variabl1147); 

                    variabl1733[variabl1843] = (JTextComponent)variabl2463; 

      } 

      variabl1459=variabl1459+variabl1313; 

      variabl1467[variabl1843] = j; 

      variabl1843++; 

      } 

           } 

        } 

      variabl1577=20+variabl1805; 

      if (variabl1473==0) 

            variabl1459=variabl1459+30+variabl1637; 

      else variabl1459=variabl1459+20; 

      list1.addMouseListener(new MouseAdapter() { 

      public void mouseClicked(MouseEvent evt) { 

       String s4=""; 

       String [] s5; 

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

          if (variabl1467[i]==variabl1739){ 

          s4=list1.getSelectedItem(); 

                   if (s4 != null){}  else s4="";  

          if (s4.lastIndexOf(",")>0){   

             s5=s4.split(","); 

          variabl1733[i].setText(s5[0]); 

          } 

          else 

          variabl1733[i].setText(list1.getSelectedItem()); 

          } 

      

         } 

      }); 

      variabl2819002(); 

        int hl0=variabl1459;   

        if (variabl2503!=main1.variabl2503) hl0=variabl2503- variabl2179*(variabl1849+30)-150; 

      list1.setBounds(10, 40,variabl1057, hl0);   

      panel1.add(list1); 

     variabl2375 = new JButton(variabl2405[0]); 

     variabl2375.addActionListener(new ActionListener() { 

     public void actionPerformed(ActionEvent e) { 

       variabl18531[variabl1805]=0;   

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

      if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

      String s3=variabl2197[variabl1805][0][variabl1467[i]]; 

      if ((s3!=null)&&(s3.length()>10)){                  

      byte []c=new byte[s3.length()]; 

      for (int j=0;j<s3.length();j++){ 

      int n1=Integer.parseInt(s3.substring(j,j+1),16); 

      int n2=Integer.parseInt(s3.substring(j+1,j+2),16); 

      c[j/2]=(byte)(n1*16+n2); 

      j++; 

      } 

                 Icon icon = new ImageIcon(c);  

                 variabl2165[i].setOpaque(true); 

                 variabl2165[i].setBackground(Color.PINK); 

                 variabl2165[i].setIcon(icon); 

      } 

      else { 

      byte []c={0}; 

                Icon icon = new ImageIcon(c); 

                        variabl2165[i].setOpaque(true); 

                        variabl2165[i].setBackground(Color.PINK); 

                        variabl2165[i].setIcon(icon); 

      } 

      } 

      else  { 

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

      } 

       } 

      variabl2325.setEnabled(true); 

      variabl2255.setEnabled(false); 

       } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",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 (variabl2637.getText().equals("查询")){  

                if (variabl18531[variabl1805]<variabl1853[variabl1805]-1)   

                   variabl18531[variabl1805]++;    

                else { 

                variabl2325.setEnabled(false); 

                 } 

              variabl2255.setEnabled(true); 

               } 

         else{ 

                 for (int j=variabl18531[variabl1805]+1;j<=variabl1853[variabl1805];j++){ 

                if (variabl2499.toLowerCase().trim().equals(variabl2197[variabl1805][j][variabl1739].toLowerCase().trim())){ 

                variabl18531[variabl1805]=j; 

                break; 

                } 

                else if (j==variabl1853[variabl1805]){ 

                    variabl2325.setEnabled(false); 

                } 

                 } 

         } 

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

      if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

      String s3=variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]; 

      if ((s3!=null)&&(s3.length()>10)){                  

      byte []c=new byte[s3.length()]; 

      for (int j=0;j<s3.length();j++){ 

      int n1=Integer.parseInt(s3.substring(j,j+1),16); 

      int n2=Integer.parseInt(s3.substring(j+1,j+2),16); 

      c[j/2]=(byte)(n1*16+n2); 

      j++; 

      } 

                 Icon icon = new ImageIcon(c); 

                 variabl2165[i].setOpaque(true); 

                 variabl2165[i].setBackground(Color.PINK); 

                 variabl2165[i].setIcon(icon); 

      } 

      else {           

      byte []c={0}; 

                Icon icon = new ImageIcon(c);  

                        variabl2165[i].setOpaque(true); 

                        variabl2165[i].setBackground(Color.PINK); 

                        variabl2165[i].setIcon(icon); 

      } 

      } 

      else{    

        variabl1733[i].setText(variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]); 

      } 

      } 

         } 

          }); 

         if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",1,")>=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) { 

      variabl18531[variabl1805]=variabl1853[variabl1805]-1;     

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

      if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

      String s3=variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]; 

      if ((s3!=null)&&(s3.length()>10)){                  

      byte []c=new byte[s3.length()]; 

      for (int j=0;j<s3.length();j++){ 

      int n1=Integer.parseInt(s3.substring(j,j+1),16); 

      int n2=Integer.parseInt(s3.substring(j+1,j+2),16); 

      c[j/2]=(byte)(n1*16+n2); 

      j++; 

      } 

                 Icon icon = new ImageIcon(c); 

                 variabl2165[i].setOpaque(true); 

                 variabl2165[i].setBackground(Color.PINK); 

                 variabl2165[i].setIcon(icon); 

      } 

      else { 

      byte []c={0}; 

                Icon icon = new ImageIcon(c); 

                        variabl2165[i].setOpaque(true); 

                        variabl2165[i].setBackground(Color.PINK); 

                        variabl2165[i].setIcon(icon); 

      } 

      } 

      else 

         variabl1733[i].setText(variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]); 

      } 

      variabl2325.setEnabled(false); 

      variabl2255.setEnabled(true); 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",2,")>=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[variabl1805]>0){ 

      variabl18531[variabl1805]--;    

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

      if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

      String s3=variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]; 

      if ((s3!=null)&&(s3.length()>10)){                  

      byte []c=new byte[s3.length()]; 

      for (int j=0;j<s3.length();j++){ 

      int n1=Integer.parseInt(s3.substring(j,j+1),16); 

      int n2=Integer.parseInt(s3.substring(j+1,j+2),16); 

      c[j/2]=(byte)(n1*16+n2); 

      j++; 

      } 

                 Icon icon = new ImageIcon(c); 

                 variabl2165[i].setOpaque(true); 

                 variabl2165[i].setBackground(Color.PINK); 

                 variabl2165[i].setIcon(icon); 

      } 

      else { 

      byte []c={0}; 

                Icon icon = new ImageIcon(c); 

                        variabl2165[i].setOpaque(true); 

                        variabl2165[i].setBackground(Color.PINK); 

                        variabl2165[i].setIcon(icon); 

      } 

      } 

      else 

      variabl1733[i].setText(variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]); 

      } 

      variabl2325.setEnabled(true); 

         } 

         else variabl2255.setEnabled(false); 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",3,")>=0)){ 

      variabl2255.setBounds(variabl1885[3][0],variabl1885[3][1],variabl1885[3][2],variabl1885[3][3]);           

          panel1.add(variabl2255); 

          variabl2255.setEnabled(false);  

     } 

        

     variabl2637 = new JButton(variabl2405[4]); 

     variabl2637.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

             if (variabl2637.getText().trim().equals("查询")){  

              variabl2637.setText("还原"); 

              variabl2375.setEnabled(false); 

             variabl2325.setEnabled(true); 

              variabl2255.setEnabled(false); 

                variabl1971.setEnabled(false); 

            } 

             else{  

              variabl2637.setText("查询"); 

              variabl18531[variabl1805]=0; 

                variabl2375.setEnabled(true); 

             variabl2325.setEnabled(true); 

              variabl2255.setEnabled(true); 

                variabl1971.setEnabled(true); 

             } 

             if (variabl2637.getText().trim().equals("还原")){ 

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

                       if (variabl1739==variabl1467[i]){ 

                       variabl2499=variabl1733[i].getText();  

                         break; 

                       } 

                 for (int j=0;j<variabl1853[variabl1805];j++) 

                if (variabl2499.toLowerCase().trim().equals(variabl2197[variabl1805][j][variabl1739].toLowerCase().trim())) { 

                variabl18531[variabl1805]=j; 

                   break; 

                 } 

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

              if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

              String s3=variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]; 

              if ((s3!=null)&&(s3.length()>10)){                  

              byte []c=new byte[s3.length()]; 

              for (int j=0;j<s3.length();j++){ 

              int n1=Integer.parseInt(s3.substring(j,j+1),16); 

              int n2=Integer.parseInt(s3.substring(j+1,j+2),16); 

              c[j/2]=(byte)(n1*16+n2); 

              j++; 

              } 

                         Icon icon = new ImageIcon(c); 

                         variabl2165[i].setOpaque(true); 

                         variabl2165[i].setBackground(Color.PINK); 

                         variabl2165[i].setIcon(icon); 

              } 

              else { 

              byte []c={0}; 

                        Icon icon = new ImageIcon(c); 

                                variabl2165[i].setOpaque(true); 

                                variabl2165[i].setBackground(Color.PINK); 

                                variabl2165[i].setIcon(icon); 

              } 

              } 

              else 

              variabl1733[i].setText(variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[i]]); 

          if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][variabl1739]+",")>=0) 

                       variabl2031=variabl1913[variabl1805][0][variabl1739]+"="+variabl2499; 

         else 

                     variabl2031=variabl1913[variabl1805][0][variabl1739]+"='"+variabl2499+"'"; 

                } 

             } 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",4,")>=0)){ 

      variabl2637.setBounds(variabl1885[4][0],variabl1885[4][1],variabl1885[4][2],variabl1885[4][3]);           

          panel1.add(variabl2637); 

     } 

        

     variabl2531= new JButton(variabl2405[5]); 

     variabl2531.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

             if (variabl2531.getText().trim().equals("浏览")) { 

              variabl2531.setText("转当前行"); 

                 variabl1701=new String[variabl1853[variabl1805]][variabl2113[variabl1805]]; 

      int [] n=new int [variabl1119.length]; 

            for (int i=0;i<variabl1853[variabl1805];i++) 

              for (int j=0;j<variabl2113[variabl1805];j++){ 

              variabl1701[i][j]=variabl2197[variabl1805][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 < variabl2113[variabl1805]; j++){ 

         n[j]=variabl1119[j]; 

         if (n[j]>50) n[j]=50; 

      } 

             tableTenance.tableModel(variabl2483,variabl2503,variabl1913[variabl1805][1],n,variabl1701,variabl1169[variabl1805]); 

             } 

             else{ 

              variabl2531.setText("浏览"); 

              variabl18531[variabl1805]=main1.variabl1327;   

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

              variabl1733[i].setText(variabl2197[variabl1805][main1.variabl1327][variabl1467[i]]); 

              } 

            } 

             } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",5,")>=0)){ 

      variabl2531.setBounds(variabl1885[5][0],variabl1885[5][1],variabl1885[5][2],variabl1885[5][3]);           

          panel1.add(variabl2531); 

     } 

        

     variabl2611 = new JButton(variabl2405[6]); 

     variabl2611.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

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

          if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")<0){ 

          variabl1419[variabl1805][i] = variabl1733[i].getText().trim(); 

          if (variabl1419[variabl1805][i].trim().equals("null"))  variabl1419[variabl1805][i] =" "; 

           } 

          else{   variabl1419[variabl1805][i]="?";         }   

            } 

      cont4 = main1.getConn();  

      try 

      { 

      s1 = "insert into " + variabl2603 +"(";  

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

      if (main1.variabl1539.lastIndexOf(variabl1169[variabl1805][variabl1467[j]])<0) 

                                s1=s1+variabl1913[variabl1805][0][variabl1467[j]]+","; 

      } 

      s1=s1.substring(0,s1.length()-1)+") VALUES ("; 

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

      if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[j]]+",")>=0) 

      s1=s1;  

         else if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][variabl1467[j]]+",") >= 0) 

      s1=s1+variabl1419[variabl1805][j]+","; 

      else if(variabl1419[variabl1805][j].trim().equals("?"))   

                          s1=s1;  

      else 

      s1=s1+"'"+variabl1419[variabl1805][j].trim()+"',"; 

      } 

      s1=s1.substring(0,s1.length()-1)+")"; 

      s3=""; 

      boolean bool=true; 

         for (int j = 0; j< variabl1525[variabl1805].length; j++){  

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

          if (variabl1467[i]==variabl1287[j]){ 

          s3= s3+variabl1419[variabl1805][i];   

             break; 

          } 

         } 

      for (int i=0;i<variabl1853[variabl1805];i++){ 

      s4 = ""; 

          for (int j = 0; j< variabl1525[variabl1805].length; j++){ 

      s4=s4+variabl2197[variabl1805][i][variabl1287[j]].trim(); 

      } 

          if (s3.toLowerCase().trim().equals(s4.trim().toLowerCase())){ 

          bool=false; 

          JOptionPane.showMessageDialog( null, "关键字重复，请修改后再录入！"); 

          break; 

         } 

         } 

      if (bool){ 

                      PreparedStatement pst4 = cont4.prepareStatement(s1);   

                      char x1=10,x2=13; 

                      int k2=1;    

                           pst4.execute(); 

                          pst4.close(); 

      stat4.close(); 

      cont4.close(); 

      variabl1853[variabl1805]++; 

              int t=0; 

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

             if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")<0){ 

              t=0; 

              for (int j = 0; j< variabl1525[variabl1805].length; j++) 

              if (i==variabl1287[j]) t=1; 

              if (t==0) 

                  variabl1733[i].setText(variabl1507[variabl1805][variabl1467[i]]); 

           } 

      } 

      }     

      } catch (SQLException e2) 

      { 

      JOptionPane.showMessageDialog( null, "存盘语句错！"+s1); 

      } 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",6,")>=0)){ 

      variabl2611.setBounds(variabl1885[6][0],variabl1885[6][1],variabl1885[6][2],variabl1885[6][3]);           

          panel1.add(variabl2611); 

     } 

      

     variabl2601 = new JButton(variabl2405[7]); 

     variabl2601.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

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

             if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")<0){ 

                  variabl1733[i].setText(variabl1507[variabl1805][variabl1467[i]]); 

           } 

      } 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",7,")>=0)){ 

      variabl2601.setBounds(variabl1885[7][0],variabl1885[7][1],variabl1885[7][2],variabl1885[7][3]);           

          panel1.add(variabl2601); 

     } 

      

     variabl1697 = new JButton(variabl2405[8]); 

     variabl1697.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

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

         if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")<0){ 

      variabl1419[variabl1805][i] = variabl1733[i].getText().trim(); 

      if (variabl1419[variabl1805][i].equals("null")){ 

                           variabl1419[variabl1805][i] =" "; 

      } 

      }else{   

                         variabl1419[variabl1805][i]="?";         }     

      s2="";      

         for (int j = 0; j< variabl1525[variabl1805].length; j++){ 

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

          if (variabl1467[i]==variabl1287[j]){ 

      if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][j]+",")>=0) 

      { 

      if (variabl1419[variabl1805][i].length()<1) variabl1419[variabl1805][i]="0"; 

                       s2=s2+variabl1525[variabl1805][j]+"="+variabl1419[variabl1805][i]; 

      } 

      else s2=s2+variabl1525[variabl1805][j]+"='"+variabl1419[variabl1805][i].trim()+"'"; 

             break; 

          } 

             if (j<variabl1525[variabl1805].length-1) s2=s2+" and "; 

         } 

      cont4 = main1.getConn();  

      try 

      { 

      s1 = "update " + variabl2603 +" set ";  

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

      if (main1.variabl1539.lastIndexOf(variabl1169[variabl1805][variabl1467[j]])<0){ 

                            s1=s1+variabl1913[variabl1805][0][variabl1467[j]]+"="; 

          if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][variabl1467[j]]+",") >= 0) 

                      s1=s1+variabl1419[variabl1805][j]; 

          else if(variabl1419[variabl1805][j].trim().equals("?")) 

                            s1=s1+variabl1419[variabl1805][j]; 

        else s1=s1+"'"+variabl1419[variabl1805][j].trim()+"'"; 

        s1=s1+","; 

      } 

         } 

                     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=variabl1913[variabl1805][0][variabl1467[i]]; 

                          } 

                          pst4.execute(); 

                          pst4.close(); 

      stat4.close(); 

      cont4.close(); 

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

        variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[k]]=variabl1419[variabl1805][k]; 

      } 

      } catch (SQLException e2) 

      { 

      JOptionPane.showMessageDialog( null, "修改语句错！"+s1); 

      } 

              } 

            }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",8,")>=0)){ 

      variabl1697.setBounds(variabl1885[8][0],variabl1885[8][1],variabl1885[8][2],variabl1885[8][3]); 

      panel1.add(variabl1697); 

     } 

      

     variabl2633 = new JButton(variabl2405[9]); 

     variabl2633.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

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

      if (main1.variabl1539.lastIndexOf(variabl1169[variabl1805][variabl1467[i]])<0) 

      variabl1419[variabl1805][i] = variabl1733[i].getText().trim(); 

      } 

      s2=""; 

         for (int j = 0; j< variabl1525[variabl1805].length; j++){ 

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

          if (variabl1467[i]==variabl1287[j]){ 

            if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][j]+",")>=0) 

      s2=s2+variabl1525[variabl1805][j]+"="+variabl1419[variabl1805][i]; 

      else s2=s2+variabl1525[variabl1805][j]+"='"+variabl1419[variabl1805][i].trim()+"'"; 

             break; 

          } 

             if (j<variabl1525[variabl1805].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(); 

         for (int i=variabl18531[variabl1805];i<variabl1853[variabl1805]-1;i++) 

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

          variabl2197[variabl1805][i][variabl1467[k]]=variabl2197[variabl1805][i+1][variabl1467[k]]; 

      }    

         variabl1853[variabl1805]--; 

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

        if (main1.variabl1539.lastIndexOf(variabl1169[variabl1805][k])<0) 

          variabl1733[k].setText(variabl1507[variabl1805][variabl1467[k]]); 

      } catch (SQLException e2) 

      { 

      JOptionPane.showMessageDialog( null, "删除语句错！"+s1); 

      } 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",9,")>=0)){ 

      variabl2633.setBounds(variabl1885[9][0],variabl1885[9][1],variabl1885[9][2],variabl1885[9][3]);           

         panel1.add(variabl2633); 

     } 

          

     variabl2315 = new JButton(variabl2405[10]); 

     variabl2315.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

      s2=""; 

             if (variabl2637.getText().trim().equals("还原")){  

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

                     if (variabl1739==variabl1467[i]){ 

        if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][variabl1739]+",")>=0) 

          s2="update " + variabl2603 +" set "+variabl1913[variabl1805][0][variabl1739]+"="+variabl1733[i].getText()+" where "+variabl2031; 

        else 

      s2="update " + variabl2603 +" set "+variabl1913[variabl1805][0][variabl1739]+"='"+variabl1733[i].getText().trim()+"' where "+variabl2031; 

                        break; 

                     } 

              } 

             else {  

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

                     if (variabl1739==variabl1467[i]){ 

      if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][variabl1739]+",")>=0) 

      s2="update " + variabl2603 +" set "+variabl1913[variabl1805][0][variabl1739]+"="+variabl1733[i].getText(); 

      else 

      s2="update " + variabl2603 +" set "+variabl1913[variabl1805][0][variabl1739]+"='"+variabl1733[i].getText().trim()+"'"; 

                        break; 

                     } 

              } 

      cont4 = main1.getConn();  

      try 

      { 

      stat4 = cont4.createStatement( 

      ResultSet.TYPE_SCROLL_INSENSITIVE, 

      ResultSet.CONCUR_UPDATABLE);  

                 stat4.executeUpdate(s2); 

      }catch(SQLException e2) 

      { 

      JOptionPane.showMessageDialog( null, "批删除语句错！"); 

      } 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",10,")>=0)){ 

          variabl2315.setBounds(variabl1885[10][0],variabl1885[10][1],variabl1885[10][2],variabl1885[10][3]); 

          panel1.add(variabl2315); 

     } 

     图片存盘 = new JButton(variabl2405[11]); 

     variabl2185[11]=图片存盘; 

     图片存盘.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

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

         if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")<0){ 

      variabl1419[variabl1805][i] = variabl1733[i].getText().trim(); 

      if (variabl1419[variabl1805][i].equals("null")){ 

                           variabl1419[variabl1805][i] =" "; 

      } 

      }else{   

                         variabl1419[variabl1805][i]="?";  

              }     

      s2="";      

         for (int j = 0; j< variabl1525[variabl1805].length; j++){ 

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

          if (variabl1467[i]==variabl1287[j]){ 

      if (main1.variabl1545.lastIndexOf(","+variabl1169[variabl1805][j]+",")>=0) 

      { 

      if (variabl1419[variabl1805][i].length()<1) variabl1419[variabl1805][i]="0"; 

                       s2=s2+variabl1525[variabl1805][j]+"="+variabl1419[variabl1805][i]; 

      } 

      else s2=s2+variabl1525[variabl1805][j]+"='"+variabl1419[variabl1805][i].trim()+"'"; 

             break; 

          } 

             if (j<variabl1525[variabl1805].length-1) s2=s2+" and "; 

         } 

      cont4 = main1.getConn();  

      try 

      { 

      s1 = "update " + variabl2603 +" set ";  

      int n=s1.length(); 

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

      if(variabl1419[variabl1805][j].trim().equals("?")) { 

      if (s1.length()==n) 

                             s1=s1+variabl1913[variabl1805][0][variabl1467[j]]+"="+variabl1419[variabl1805][j]; 

      else 

                             s1=s1+","+variabl1913[variabl1805][0][variabl1467[j]]+"="+variabl1419[variabl1805][j]; 

      } 

             }   

                     s1=s1+" 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=variabl1913[variabl1805][0][variabl1467[i]]; 

                if (main1.variabl1539.lastIndexOf(","+variabl1169[variabl1805][variabl1467[i]]+",")>=0){ 

                final JFileChooser fc = new JFileChooser(".\\");  

                fc.showOpenDialog(null);  

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

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

        variabl2197[variabl1805][variabl18531[variabl1805]][variabl1467[k]]=variabl1419[variabl1805][k]; 

      } 

      } catch (SQLException e2) 

      { 

      JOptionPane.showMessageDialog( null, "修改语句错！"+s1); 

      }catch (IOException e3) 

      { 

      JOptionPane.showMessageDialog( null, "文件读取出错！"); 

      } 

      } 

      }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",11,")>=0)){ 

      图片存盘.setBounds(variabl1885[11][0],variabl1885[11][1],variabl1885[11][2],variabl1885[11][3]); 

      panel1.add(图片存盘); 

     }   

      

     variabl2599 = new JButton(variabl2405[12]); 

     variabl2185[12]=variabl2599; 

     variabl2599.addActionListener(new ActionListener() { 

      public void actionPerformed(ActionEvent e) { 

          panel1.setVisible(false);  

      framet1.setVisible(false);  

          framet1.dispose(); 

     } 

     }); 

     if ((variabl1187.length()<3) || (variabl1187.lastIndexOf(",12,")>=0)){ 

            variabl2599.setBounds(variabl1885[12][0],variabl1885[12][1],variabl1885[12][2],variabl1885[12][3]); 

            panel1.add(variabl2599); 

     } 

      

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

     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; 

     frame1.setBounds(w1,h1,variabl2483, variabl2503);    

     frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE); 

     frame1.getContentPane().setLayout(null);  

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

     frame1.setVisible(true);  

     } 

      

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

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

      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; 

      variabl1577=variabl1577+variabl1885[j][2]; 

      } 

      else { 

      variabl1885[j][2]=variabl1629;    

      variabl1577=variabl1577+variabl1629; 

      } 

      variabl1885[j][3]=variabl1849; 

      n++; 

      n1++; 

             if (variabl1371-n1==0) break; 

         if ((n>=variabl1505)&&((variabl1371-n1)-variabl1505!=0)) {  

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

          variabl1577=20; 

          variabl1459=variabl1459+variabl1849+20; 

          n=0; 

          n2++; 

         } 

      } 

      } 

      variabl2503=variabl1459+variabl1849+100; 

     } 

      

     } 

     class frame1{ 

      static JFrame framet1=new JFrame(); 

      static JFrame framet2=new JFrame(); 

      static JFrame framet3=new JFrame(); 

      static JFrame framet4=new JFrame(); 

      static JFrame framet5=new JFrame(); 

      static JFrame framet6=new JFrame(); 

      static JFrame framet7=new JFrame(); 

      static JFrame framet8=new JFrame(); 

      static JFrame framet9=new JFrame(); 

      static JFrame framet10=new JFrame(); 

     }   

     

转载本文请联系原作者获取授权，同时请注明本文来自程学先科学网博客。
链接地址：https://blog.sciencenet.cn/blog-2551-1120306.html

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