|||
版本1
80.源码80,部件程序,表单程序,一对多表多方子表数据维护部件,运行时同时显示主表与子表,对子表提供录入、修改、删除操作功能。提供安全性、域完整性、实体完整性及参照完整性保护。对主表只提供删除操作功能。
/**
* 程序文件名:dataTenance7.java
* 作者:程学先
* 功能:一对多表多方子表数据维护部件,运行时同时显示主表与子表,对子表提供录入、修改、删除操作功能。
* 对主表只提供删除操作功能,提供安全性、域完整性、实体完整性及参照完整性保护。
* 在主表中删除一条记录时会提问是否同时删除子表中相匹配的记录,在肯定后删除子表中相关记录。
* 关键字段名为子表的关键字,是识别与区分子表记录的主要标志,不允许重复,不允许为空,
* 可以是单一字段,也可以是多个字段,如果是多字段,以英文逗号分隔。
* 外键指主表与子表中同名字段,可以是单个字段,也可以是多字段。如果是多字段,以英文逗号分隔。
* 在子表窗口中用组合框表示外键数据,组合框中数据全部来自主表,不能添加,
* 保证在子表中录入数据时不出现破坏参照完整性的情况。
* 当用鼠标点击主表某一条记录时,子表中组合框内显示相关外键数据,
* 此时只需要修改子表非外键数据就可进行数据录入。
* 输入子表非外键数据后再输入其他数据可修改子表中记录。
* 子表允许借用工具程序deviseTool.java、completeTool.java、
* secureTool.java等定义界面中的控件及其位置大小参数、定义数据完整性条件、定义数据安全要求。
* 所有数据存放在一个文件中,文件名在参数中带入。
* 完成日期:2014年1月20日
* 被调用语句:dataTenance7.means(parameter);
* 必须提供的参数:主表名,子表名,子表关键字(可多个),子表外键(即主表主键,可多个字段名)
* 可选择提供的参数:“窗口宽”、“窗口高” 、“要求按钮号表”等均指子表窗口中参数。
* 当子表字段数较少时,建议一定要改变窗口的宽度与高度。主表可停留在窗口任何位置。
* 本部件预设的子表按钮控件“第一条”、“下一条”、“最后一条”、“上一条”、“浏览”、“存盘”、“清屏”、
* “修改存盘”、“删除”、“退出”共 10 个。
* 通过“要求按钮号表”提供子表所需要显示的按钮在该部件原设计的界面 中的顺序号,各按钮号用逗号分隔。
* 每录入一条记录后必须点击“存盘”按钮。
* 如果存在image字段,在点击“存盘”按钮后,将提问图片文件名,之后将新记录填入表内。
* 每修改一条记录,必须点击“修改存盘”按钮,将改后记录填入表内。
* 如果存在image字段,在点击“存盘”按钮后,将提问图片文件名,之后将新记录填入表内。
* 每删除一条记录,必须点击“删除”按钮,将改后记录填入表内。
*/
import java.awt.*;
import java.awt.List;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.text.JTextComponent;
import java.sql.*;
import java.util.*;
public class dataTenance7 extends JFrame {
static dataTenance7 frame1 = null;
static dataTenance7 frame2 = null;
static JTextField[] 文本框 = null;
private static Connection cont4; // 连接数据库
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs;
private static String 主表名;
private static String 表名 = ""; // 数据表名
private static int 窗口宽 = main1.窗口宽;
private static int 窗口宽1 = 300;
private static int 窗口高 = main1.窗口高 - 100;
private static int 列数 = 0;
private static int 列数2 = 0, 当前列号 = 0; // 数据表列数
private static String[] 列名 = null; // 主表列名
private static String[] 列名0 = null; // 中文列名
private static String[] 列名2 = null; // 子表列名
private static String 字段名字串 = "";
private static String 字段名字串2 = "", 限只读字段号表 = "";
private static String[] 列数据类型 = null; // 存放当前记录各字段数据类型的数组
private static String[] 列数据类型2 = null; // 存放当前记录各字段数据类型的数组
private static int[] 列数据宽度 = null; // 存放当前记录各字段数据宽度的数组
private static int[] 列数据宽度2 = null; // 存放当前记录各字段数据宽度的数组
private static int 记录条数 = 0;
private static int 记录条数1 = 0;
private static int 记录条数2 = 0;
private static JTable 表格;
static DefaultTableModel 表格模型;
private static String[][] 表格数据 = null;
private static String[][] 表格数据2 = null;
private static String[] 文本数组值2 = null;
static String[][] 备份数据 = null;
private static String 要求按钮号表 = "";
private static int 实际按钮数 = 0;
private static String 要求字段号表 = "";
private static String 要求字段号表2 = "";
// private static String[] 一条空记录 = null;
private static String[] 一条空记录2 = null;
private static String[] 关键字段名 = null;// 存放关键字字段名的数组
private static int[] 关键字序号 = null;
private static String[] 外键名 = null;// 存放外键字段名的数组
private static String 外键序号集2 = "";
private static int[] 外键序号 = null; // 子表中外键在子表中序号
private static int[] 外键序号0 = null; // 主表中外键在子表中序号
private static int[] 外键序号1 = null; // 子表中外键在主表中序号
private static String s1 = "", s2 = "";
private static int b = 0, c = 0;
private static int 控件个数 = 0;
private static JLabel[] 图片数组 = null;
private static int 字符宽度 = 15, 字符高度 = 20;
private static String[] 按钮集;
private static JButton 第一条, 下一条, 最后一条, 上一条, 浏览, 存盘, 清屏, 修改存盘, 删除, 退出;
private static ArrayList<String> list = new ArrayList<String>();
private static ArrayList<String> list0 = new ArrayList<String>();
private static String[][] 位置参数表 = null;
private static String[][] 标签位置 = null;
private static String[][] 完整性参数表 = null;
private static String[][] 安全性参数表 = null;
private static String[][] 字典数据 = new String[0][0];
private static int 位置参数条数 = 0, 完整性参数条数 = 0, 安全性参数条数 = 0;
public static String username = main1.username;
public static int 字号 = 9, 颜色 = 5;
private static String 大数据类型 = main1.文本数据类型 + main1.图形数据类型;
private static int 起始左边距 = 0;
private static int 起始到顶距 = 0;
private static int[] 文本数组号2 = null;
private static int 行间距离 = 0;
private static JPanel panel2 = new JPanel(false); // 定义面板
private static int 原窗口宽 = 窗口宽;
private static int 文本区宽度 = 0;
private static int 大数据个数 = 0;// 是否已经定义了按钮位置标志
private static int 列名长度 = 0;
private static JTextArea[] 文本域 = null;
private static JComboBox[] 组合框 = null;
private static JTextComponent[] 文本数组2 = null;
private static String[][] 代码表数据 = null;
private static String 表名表 = "";
private static String 字典表名 = "";
private static int[][] 按钮位置 = null;
private static JButton[] 按钮数组 = new JButton[15];
public static String[] sw = new String[11];
static int 按钮数 = 0, 按钮宽 = 0;
private static int 按钮定义标志;
private static HashSet set01 = new HashSet();
public static String sd0;
static void means(String parameter[]) {
列数2 = 0;
当前列号 = 0;
字段名字串 = "";
字段名字串2 = "";
记录条数2 = 0;
记录条数1 = 0;
要求按钮号表 = "";
实际按钮数 = 0;
要求字段号表 = "";
要求字段号表2 = "";
s1 = "";
s2 = "";
b = 0;
c = 0;
控件个数 = 0;
字符宽度 = 18;
字符高度 = 20;
位置参数条数 = 0;
完整性参数条数 = 0;
安全性参数条数 = 0;
字号 = 9;
颜色 = 5;
起始左边距 = 0;
起始到顶距 = 0;
窗口宽 = main1.窗口宽;
窗口宽1 = 300;
窗口高 = main1.窗口高 - 100;
行间距离 = 0;
原窗口宽 = 窗口宽;
文本区宽度 = 0;
大数据个数 = 0;
列名长度 = 0;
表名表 = "";
字典表名 = "";
按钮定义标志 = 0;
list0 = new ArrayList<String>();
字典数据 = new String[0][0];
username = main1.username;
按钮宽 = 0;
sw = new String[11];
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3;
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw9 = "";
main1.sw10 = "";
String 按钮集01[] = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘", "清屏",
"修改存盘", "删除", "退出" };
按钮集 = new String[按钮集01.length];
按钮数 = 0;
for (int i0 = 0; i0 < 按钮集01.length; i0++)
按钮集[i0] = 按钮集01[i0];
if (parameter[11].length() > 0) {
要求按钮号表 = parameter[11];// 需要显示的按钮的顺序号
要求按钮号表 = 要求按钮号表.replaceAll(";", ";");
要求按钮号表 = 要求按钮号表.replaceAll("。", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
要求按钮号表 = 要求按钮号表.replaceAll(":", ";");
if (要求按钮号表.indexOf(";") > 0) { // 如果有按钮更名要求
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
按钮集[Integer.parseInt((s602[0]))] = s602[1];
要求按钮号表 = 要求按钮号表 + "," + s602[0];
} else {
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
}
}
} else {
String s601[] = 要求按钮号表.split(",");
要求按钮号表 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
要求按钮号表 = s601[i01];
else
要求按钮号表 = 要求按钮号表 + "," + s601[i01];
}
}
} else {
要求按钮号表 = ""; // 没输入要求按钮号,定全部按钮号
for (int i1 = 0; i1 < 按钮集.length; i1++) {
if (i1 == 0)
要求按钮号表 = 要求按钮号表 + i1;
else
要求按钮号表 = 要求按钮号表 + "," + i1;
}
}
要求按钮号表 = "," + 要求按钮号表 + ",";
要求按钮号表 = 要求按钮号表.replaceAll(",,", ",");
按钮数 = 按钮集.length; // 可以供选择的按钮数
按钮位置 = new int[按钮数][15];
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);// 宽度参数
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
窗口宽 = m1;
原窗口宽 = m1;
窗口高 = m2;
}
} catch (Exception e2) {
}
frame1 = new dataTenance7();
frame1.setTitle("主表数据记录");
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null); // 关闭布局管理器
panel2 = new JPanel(true);
frame2 = new dataTenance7();
frame2.setTitle("子表数据维护窗口 作者:程学先");
frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame2.getContentPane().setLayout(null); // 关闭布局管理器
frame2.getContentPane().add(panel2, null); // 安装面板
list = new ArrayList<String>();
大数据类型 = main1.文本数据类型 + main1.图形数据类型;
按钮数组 = new JButton[20];
panel2.setLayout(null);
主表名 = parameter[2]; // 数据表名
表名表 = "," + parameter[0] + ",";
表名 = parameter[4]; // 数据表名
String[] t1 = parameter[0].split(","); // 表名数组
字段名字串2 = parameter[19];
String[] t2 = parameter[19].split(","); // 字段名数组
字典表名 = "";
if (表名表.lastIndexOf(表名 + "字典表") >= 0)
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(表名 + "字典表") >= 0) {
字典表名 = t1[i];
数据表查询数据0011(); // 查询字典表
}
if (parameter[6].length() <= 0) {
JOptionPane.showMessageDialog(null, "缺少关键字,请说明关键字字段后再运行。");
return;
}
关键字段名 = parameter[6].split(",");
外键名 = parameter[7].split(",");
要求字段号表 = parameter[8];
要求字段号表2 = parameter[9];
限只读字段号表 = "," + parameter[9] + ",";
关键字序号 = new int[关键字段名.length];
外键序号 = new int[外键名.length];
外键序号0 = new int[外键名.length];
String 字段名字串0 = "";
if (要求字段号表2.length() > 0) {
String[] t3 = 要求字段号表2.split(","); // 字段号数组
for (int i = 0; i < t3.length; i++) {
if (i > 0)
字段名字串0 = 字段名字串0 + "," + t2[Integer.parseInt(t3[i])];
else
字段名字串0 = t2[Integer.parseInt(t3[i])];
}
字段名字串2 = 字段名字串0;
for (int i = 0; i < 关键字段名.length; i++)
if (("," + 字段名字串2 + ",").indexOf("," + 关键字段名[i] + ",") < 0)
字段名字串2 = 字段名字串2 + "," + 关键字段名[i];
}
t2 = 字段名字串2.split(",");
文本数组号2 = new int[t2.length];
标签位置 = new String[t2.length][6];
位置参数表 = new String[t2.length][15];
按钮位置 = new int[按钮数][15];
if (parameter[5].length() > 1) { // 接口参数表文件
File file1 = new File(parameter[5]);
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
int d2 = 0;
int k3 = 0;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (tempStr.length() > 1) // 参数由completeTool等三个程序产生
list0.add(tempStr); // 将文件内容全部读到集合中,先统计参数中不同类型数据条数
}
String sk = "";
for (int i = 0; i < list0.size(); i++) {
sk = list0.get(i);
if (d2 == 0) { // 参数由completeTool等三个程序产生
list.add(sk);// 将文件内容读到集合中,先统计参数中不同类型数据条数
if (sk.substring(0, 2).equals("1,"))
位置参数条数++;
if (sk.substring(0, 2).equals("2,"))
安全性参数条数++;
if (sk.substring(0, 2).equals("3,"))
完整性参数条数++;
}
} // 以上完成对参数表数据分类统计条数
实际按钮数 = k3;
if (k3 > 0) {
按钮定义标志 = 1;
}
if (位置参数条数 > 0) {
位置参数表 = new String[位置参数条数][13];
标签位置 = new String[位置参数条数][6];// 0、1字段左边距到顶距,2字段类型
} else {
位置参数表 = new String[t2.length][13];
标签位置 = new String[t2.length][6];
} // 0、1字段左边距到顶距,2字段类型
安全性参数表 = new String[安全性参数条数][4];
完整性参数表 = new String[完整性参数条数][6];
int m3 = 0;
m1 = 0;
m2 = 0;
int y = 2, n1 = 0;
String s = "";
s2 = ",";
窗口宽 = 0;
for (int i = 0; i < list.size(); i++) {
s = list.get(i); // 再取出接口参数
if (d2 == 0) {
if (s.substring(0, 2).equals("1,")) { // 位置参数
位置参数表[m1] = s.substring(2, s.length()).split(
"。");
位置参数表[m1][1] = "";
位置参数表[m1][2] = 位置参数表[m1][5];
标签位置[m1][0] = Integer.parseInt(位置参数表[m1][3])
+ Integer.parseInt(位置参数表[m1][6]) + "";// 字段左边距
标签位置[m1][1] = 位置参数表[m1][7]; // 字段到顶距
if (Integer.parseInt(位置参数表[m1][5])
+ Integer.parseInt(标签位置[m1][1]) > 起始到顶距)
起始到顶距 = Integer.parseInt(位置参数表[m1][5])
+ Integer.parseInt(标签位置[m1][1]);
if (Integer.parseInt(位置参数表[m1][4])
+ Integer.parseInt(位置参数表[m1][6]) + 80 > 窗口宽)
窗口宽 = Integer.parseInt(位置参数表[m1][4])
+ Integer.parseInt(位置参数表[m1][6])
+ 80;
标签位置[m1][2] = ""; // 图形代码
标签位置[m1][3] = ""; // 代码表名
标签位置[m1][4] = ""; // 字段类型(普通字段、文本、图形)
s2 = s2 + 位置参数表[m1][0] + ","; // 字段名表
m1++;
位置参数条数 = m1; // 重定义位置参数条数
} else if (s.substring(0, 2).equals("2,")) {// 安全参数
y = 2;
n1 = 0;
int n0 = 0;
String[] sf = s.split("。");
安全性参数表[m2][0] = sf[0];
安全性参数表[m2][1] = sf[1]; // 表名或字段名
安全性参数表[m2][2] = sf[2]; // 权限
sf = 安全性参数表[m2][0].split(",");
安全性参数表[m2][0] = sf[1]; // 用户名
if ((安全性参数表[m2][0].equalsIgnoreCase(username))
&& (安全性参数表[m2][2].length() > 0)
&& (安全性参数表[m2][2].indexOf("a") < 0)
&& ((安全性参数表[m2][1].length() == 0)
|| (安全性参数表[m2][1].equals("*")) || (安全性参数表[m2][1]
.toLowerCase()
.equalsIgnoreCase(表名
.toLowerCase())))) { // 字段名为空、为星号、为表名表示是全表单权限,决定按钮显示否
if (安全性参数表[m2][2].indexOf("i") < 0) { // 不包含i录入权
要求按钮号表 = 要求按钮号表.replaceAll("5,", "");
n0 = 1;
}
if (安全性参数表[m2][2].indexOf("u") < 0) { // 不包含u修改权
要求按钮号表 = 要求按钮号表.replaceAll("7,", "");
n0 = 1;
}
if (安全性参数表[m2][2].indexOf("d") < 0) { // 不包含d删除权
要求按钮号表 = 要求按钮号表.replaceAll("8,", "");
n0 = 1;
}
n0 = 1;
} // 以下对字段安全要求进行处理
else if ((安全性参数表[m2][0]
.equalsIgnoreCase(username))
&& (安全性参数表[m2][2].length() > 0)
&& (安全性参数表[m2][2].indexOf("a") < 0) && // 权限内容不空,无a
(安全性参数表[m2][2].indexOf("d") < 0)) { // 如果任何一个字段不包含d删除权
要求按钮号表 = 要求按钮号表.replaceAll("8,", ""); // 去掉删除按钮
n0 = 1;
} else if ((安全性参数表[m2][0]
.equalsIgnoreCase(username))
&& (安全性参数表[m2][2].length() > 0)
&& (安全性参数表[m2][2].indexOf("a") < 0)
&& // 权限内容不空,无a
(安全性参数表[m2][2].indexOf("i") < 0)
&& (安全性参数表[m2][2].indexOf("u") < 0)) { // 如果任何一个字段不包含iu权
安全性参数表[m2][0] = "只读";
安全性参数表[m2][2] = "q,";
}
if (n0 == 0) {
m2++;
安全性参数条数 = m2; // 重定义安全性参数条数
}
} else if (s.substring(0, 2).equals("3,")) { // 完整性参数
y = 2;
n1 = 0;
for (int k = 2; k < s.length(); k++)
if (s.substring(k, k + 1).equals("。")) {
完整性参数表[m3][n1] = s.substring(y, k);
y = k + 1;
n1++;
}
完整性参数表[m3][n1] = s.substring(y, s.length());
if (完整性参数表[m3][3].isEmpty())
完整性参数表[m3][3] = "";
m3++;
完整性参数条数 = m3; // 重定义完整性参数条数
}
}
文本数组号2 = new int[位置参数表.length];
文本数组值2 = new String[位置参数表.length];
}
if (位置参数条数 > 0) {
字段名字串2 = "";
for (int i = 0; i < 位置参数条数; i++) {
if (i == 0)
字段名字串2 = 位置参数表[i][0];
else
字段名字串2 = 字段名字串2 + "," + 位置参数表[i][0];
}
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错!");
}
} else { // 无接口参数表文件,根据选定的字段情况处理
位置参数表 = new String[t2.length][13];
标签位置 = new String[t2.length][6];// 0、1字段左边距到顶距,2字段类型
安全性参数表 = new String[0][4];
完整性参数表 = new String[0][6];
文本数组号2 = new int[t2.length];
文本数组值2 = new String[t2.length];
}
for (int i = 0; i < 安全性参数条数; i++) {
t2 = 字段名字串2.split(",");
for (int j = 0; j < t2.length; j++) {
if (安全性参数表[i][1].toLowerCase().indexOf(t2[j].toLowerCase()) >= 0) { // 字段名相同
if (安全性参数表[i][0].equals("只读"))
限只读字段号表 = 限只读字段号表 + j + ",";
安全性参数表[i][1] = j + "";
}
}
}
if (窗口宽 == 0)
窗口宽 = 原窗口宽;
数据表查询结构001(表名); // 得到数据表结构,产生全部字段名、数据类型、宽度
数据表查询数据001(表名); // 求当前表中所有数据
if (位置参数条数 == 0)
计算文本框001();
计算文本框002(); // 是否已经定义了按钮位置
安装文本框002();
String sd = "";
for (int i0 = 0; i0 < 记录条数2; i0++) {
sd = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++) {
if (文本数组号2[i] == 关键字序号[j]) {
if (表格数据2[i0][文本数组号2[i]] == null) {
JOptionPane.showMessageDialog(null,
"存在关键字为空值的记录,请检查数据库中数据情况。");
return;
}
sd = sd + 表格数据2[i0][文本数组号2[i]].trim() + ",";
break;
}
}
}
set01.add(sd);
}
第一条 = new JButton(按钮集[0]);
第一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
记录条数1 = 0;
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") >= 0) {
String s3 = 表格数据2[记录条数1][文本数组号2[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
}
} else {
if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]
+ ",") < 0))
if (! 标签位置[i][4].equals("列表框")) {
文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);
if ((main1.数字数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)
if ((文本数组2[i].getText() == null)
|| (文本数组2[i].getText().trim()
.length() < 1))
文本数组2[i].setText("0");
}
}
}
下一条.setEnabled(true);
上一条.setEnabled(false);
}
});
if (按钮位置[0][0] > 0) {
第一条.setBounds(按钮位置[0][0], 按钮位置[0][1], 按钮位置[0][2], 按钮位置[0][3]);
panel2.add(第一条);
}
下一条 = new JButton(按钮集[1]);
下一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数1 < 记录条数2 - 1) {
记录条数1++;
if (记录条数1 == 记录条数2 - 1)
下一条.setEnabled(false);
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]
+ ",") >= 0) {
String s3 = 表格数据2[记录条数1][文本数组号2[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
} else {
byte[] c0 = {};
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
}
} else {
if ((main1.图形数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",") < 0))
if (! 标签位置[i][4].equals("列表框")) {
文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);
if ((main1.数字数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)
if ((文本数组2[i].getText() == null)
|| (文本数组2[i].getText().trim()
.length() < 1))
文本数组2[i].setText("0");
}
}
}
}
上一条.setEnabled(true);
}
});
if (按钮位置[1][0] > 0) {
下一条.setBounds(按钮位置[1][0], 按钮位置[1][1], 按钮位置[1][2], 按钮位置[1][3]);
panel2.add(下一条);
}
最后一条 = new JButton(按钮集[2]);
最后一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数2 > 1)
记录条数1 = 记录条数2 - 1;
else
记录条数1 = 0;
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") >= 0) {
String s3 = 表格数据2[记录条数1][文本数组号2[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
}
} else {
if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]
+ ",") < 0))
if (! 标签位置[i][4].equals("列表框")) {
文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);
if ((main1.数字数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)
if ((文本数组2[i].getText() == null)
|| (文本数组2[i].getText().trim()
.length() < 1))
文本数组2[i].setText("0");
}
}
}
下一条.setEnabled(false);
上一条.setEnabled(true);
}
});
if (按钮位置[2][0] > 0) {
最后一条.setBounds(按钮位置[2][0], 按钮位置[2][1], 按钮位置[2][2], 按钮位置[2][3]);
panel2.add(最后一条);
}
上一条 = new JButton(按钮集[3]);
上一条.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (记录条数1 > 0) {
记录条数1--;
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]
+ ",") >= 0) {
String s3 = 表格数据2[记录条数1][文本数组号2[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
图片数组[i].setOpaque(true);
图片数组[i].setBackground(Color.PINK);
图片数组[i].setIcon(icon);
}
} else {
if ((main1.图形数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",") < 0))
if (! 标签位置[i][4].equals("列表框")) {
文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);
if ((main1.数字数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",")) >= 0)
if ((文本数组2[i].getText() == null)
|| (文本数组2[i].getText().trim()
.length() < 1))
文本数组2[i].setText("0");
}
}
}
下一条.setEnabled(true);
} else
上一条.setEnabled(false);
}
});
if (按钮位置[3][0] > 0) {
上一条.setBounds(按钮位置[3][0], 按钮位置[3][1], 按钮位置[3][2], 按钮位置[3][3]);
panel2.add(上一条);
上一条.setEnabled(false);
}
浏览 = new JButton(按钮集[4]);
浏览.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (浏览.getText().trim().equals("浏览")) {
浏览.setText("转当前行");
备份数据 = new String[记录条数2][列数2];
int[] n = new int[列数据宽度2.length];
for (int i = 0; i < 记录条数2; i++)
for (int j = 0; j < 列数2; j++) {
备份数据[i][j] = 表格数据2[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 < 列数2; j++) {
n[j] = 列数据宽度2[j];
if (n[j] > 50)
n[j] = 50;
}
tableTenance.tableModel(窗口宽, 窗口高, 列名2, n, 备份数据, 列数据类型2);
} else {
浏览.setText("浏览");
记录条数1 = main1.当前行行号; // 记录指针
for (int i = 0; i < 控件个数; i++) {
if ((main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]]
+ ",") < 0))
文本数组2[i].setText(表格数据2[main1.当前行行号][文本数组号2[i]]);
}
}
}
});
if (按钮位置[4][0] > 0) {
浏览.setBounds(按钮位置[4][0], 按钮位置[4][1], 按钮位置[4][2], 按钮位置[4][3]);
panel2.add(浏览);
}
存盘 = new JButton(按钮集[5]);
存盘.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int[] x0 = new int[控件个数];
String[] s0 = new String[控件个数];
int b = 0;
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0) {
if ((标签位置[i][4].equals("组合框"))
|| (标签位置[i][4].equals("列表框"))) {
当前列号 = i;
if (标签位置[i][4].equals("组合框"))
文本数组值2[i] = (String) 组合框[当前列号]
.getSelectedItem();
if (文本数组值2[i] == null)
文本数组值2[i] = " ";
} else {
文本数组值2[i] = 文本数组2[i].getText().trim();
if (文本数组值2[i] == null) {
文本数组值2[i] = " ";
文本数组2[i].setText(一条空记录2[i]);
}
}
} else {
文本数组值2[i] = "?";
}
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++) {
if (文本数组号2[i] == 关键字序号[j]) {
if ((文本数组值2[i] == null)
|| (文本数组值2[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值2[i].trim() + ",";
break;
}
}
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
set01.add(sd);
if (set01.size() == kd) {
JOptionPane.showMessageDialog(null, "关键字重复,请修改后重新生成!");
return;
}
set01.remove(sd); // 本句是准备生成SQL语句,在执行成功后再加到set中
sd0 = sd;
c = 0;
for (int i = 0; i < 控件个数; i++)
if (! 完整性检查(c, i)) {
JOptionPane.showMessageDialog(null, i
+ "数据完整性检测出错,请检查!");
return;
}
cont4 = main1.getConn();
try {
记录条数2++;
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + 表名 + "(";
for (int j = 0; j < 控件个数; j++) {
int a1 = 0;
for (int i = 0; i < 安全性参数条数; i++) {
if ((安全性参数表[i][1] != null)
&& (安全性参数表[i][2] != null))
if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j
+ ",") >= 0)
&& (安全性参数表[i][2].indexOf("i") < 0))
a1 = 1;
}
if (a1 == 0)
if (main1.图形数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[j]] + ",") < 0)
s1 = s1 + 列名2[文本数组号2[j]] + ",";
}
s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";
sd = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++) {
if (文本数组号2[i] == 关键字序号[j]) {
if ((文本数组值2[i] == null)
|| (文本数组值2[i].trim().length() == 0)) {
JOptionPane.showMessageDialog(null,
"存在关键字为空值的记录,请检查数据库中数据情况。");
return;
}
sd = sd + 文本数组值2[i].trim() + ",";
break;
}
}
}
s2 = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 文本数组2.length; i++)
if (文本数组号2[i] == 关键字序号[j]) {
if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j]
+ ",") >= 0) {
if (文本数组值2[i].length() < 1)
文本数组值2[i] = "0";
s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];
} else
s2 = s2 + 关键字段名[j] + "='"
+ 文本数组值2[i].trim() + "'";
break;
}
if (j < 关键字段名.length - 1)
s2 = s2 + " and ";
}
d1: for (int j = 0; j < 控件个数; j++) {
int a2 = 0;
for (int i = 0; i < 安全性参数条数; i++) {
if ((安全性参数表[i][1] != null)
&& (安全性参数表[i][2] != null))
if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j
+ ",") >= 0)
&& (安全性参数表[i][2].indexOf("i") < 0)) {
a2 = 1;
continue d1;
}
}
if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[j]]
+ ",") >= 0) {
s1 = s1 + 文本数组值2[j] + ",";
} else if (文本数组值2[j].trim().equals("?")) {
s0[b] = "update " + 表名 + " set " + 列名2[文本数组号2[j]]
+ " = ?" + " where " + s2;
x0[b] = j;
b++;
} else {
s1 = s1 + "'" + 文本数组值2[j].trim() + "',";
}
}
s1 = s1.substring(0, s1.length() - 1) + ")";
PreparedStatement pst4 = cont4.prepareStatement(s1);
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
记录条数2++;
set01.add(sd0); // 添加新记录成功后将关键字加入set
for (int j = 0; j < 文本数组2.length; j++) {
表格数据2[记录条数2][j] = "";
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
for (int i = 0; i < b; i++)
图片存盘(s0[i], x0[i]);
for (int i = 0; i < 控件个数; i++)
if ((main1.图形数据类型
.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0))
文本数组2[i].setText(一条空记录2[i]);
}
});
if (按钮位置[5][0] > 0) {
存盘.setBounds(按钮位置[5][0], 按钮位置[5][1], 按钮位置[5][2], 按钮位置[5][3]);
panel2.add(存盘);
}
清屏 = new JButton(按钮集[6]);
清屏.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++) {
if ((main1.图形数据类型
.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0))
文本数组2[i].setText(一条空记录2[i]);
}
}
});
if (按钮位置[6][0] > 0) {
清屏.setBounds(按钮位置[6][0], 按钮位置[6][1], 按钮位置[6][2], 按钮位置[6][3]);
panel2.add(清屏);
}
修改存盘 = new JButton(按钮集[7]);
修改存盘.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
c = 0;
for (int i = 0; i < 控件个数; i++)
if (! 完整性检查(c, i)) {
JOptionPane.showMessageDialog(null, i
+ "数据完整性检测出错,请检查!");
return;
}
String[] s0 = new String[控件个数];
int b = 0;
int[] x0 = new int[控件个数];
for (int i = 0; i < 文本数组2.length; i++)
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0) {
if ((标签位置[i][4].equals("组合框"))
|| (标签位置[i][4].equals("列表框"))) {
当前列号 = i;
if (标签位置[i][4].equals("组合框"))
文本数组值2[i] = (String) 组合框[当前列号]
.getSelectedItem();
if (文本数组值2[i] == null)
文本数组值2[i] = " ";
} else {
文本数组值2[i] = 文本数组2[i].getText().trim();
if (文本数组值2[i] == null) {
文本数组值2[i] = " ";
文本数组2[i].setText(一条空记录2[i]);
}
}
} else {
文本数组值2[i] = "?";
}
String sd = "";
int kd = set01.size();
int kd0 = 0;
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号2[i] == 关键字序号[j]) {
if ((文本数组值2[i] == null)
|| (文本数组值2[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值2[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
}
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null, "关键字不存在,请改为生成数据录入语句!");
set01.remove(sd);
return;
}
sd0 = sd;
s2 = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 文本数组2.length; i++)
if (文本数组号2[i] == 关键字序号[j]) {
if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j] + ",") >= 0) {
if (文本数组值2[i].length() < 1)
文本数组值2[i] = "0";
s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];
} else
s2 = s2 + 关键字段名[j] + "='" + 文本数组值2[i].trim()
+ "'";
break;
}
if (j < 关键字段名.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + 表名 + " set ";
d2: for (int j = 0; j < 文本数组2.length; j++) {
for (int i = 0; i < 安全性参数条数; i++) {
if ((安全性参数表[i][1] != null)
&& (安全性参数表[i][2] != null))
if ((("," + 安全性参数表[i][1] + ",").indexOf("," + j
+ ",") >= 0)
&& (安全性参数表[i][2].indexOf("u") < 0))
continue d2;
}
if (! 文本数组值2[j].trim().equals("?")) {
s1 = s1 + 列名2[文本数组号2[j]] + "=";
if (main1.数字数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[j]] + ",") >= 0)
s1 = s1 + 文本数组值2[j];
else
s1 = s1 + "'" + 文本数组值2[j].trim() + "'";
s1 = s1 + ",";
} else {
s0[b] = "update " + 表名 + " set " + 列名2[文本数组号2[j]]
+ "=? where " + s2;
x0[b] = j;
b++;
}
}
s1 = s1.substring(0, s1.length() - 1) + " where " + s2;
PreparedStatement pst4 = cont4.prepareStatement(s1);
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
for (int k = 0; k < 文本数组2.length; k++) {
表格数据2[记录条数1][文本数组号2[k]] = 文本数组值2[k];
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
for (int i = 0; i < b; i++)
图片存盘(s0[i], x0[i]);
}
});
if (按钮位置[7][0] > 0) {
修改存盘.setBounds(按钮位置[7][0], 按钮位置[7][1], 按钮位置[7][2], 按钮位置[7][3]);
panel2.add(修改存盘);
}
删除 = new JButton(按钮集[8]);
删除.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < 控件个数; i++) {
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[i]] + ",") < 0)
文本数组值2[i] = 文本数组2[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 (文本数组号2[i] == 关键字序号[j]) {
if ((文本数组值2[i] == null)
|| (文本数组值2[i].trim().length() == 0))
kd0 = 1;
sd = sd + 文本数组值2[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
}
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null, "关键字不存在,请修改后重新生成!");
set01.remove(sd);
return;
}
sd0 = sd;
s2 = "";
for (int j = 0; j < 关键字段名.length; j++) {
for (int i = 0; i < 控件个数; i++)
if (文本数组号2[i] == 关键字序号[j]) {
if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[j] + ",") >= 0)
s2 = s2 + 关键字段名[j] + "=" + 文本数组值2[i];
else
s2 = s2 + 关键字段名[j] + "='" + 文本数组值2[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 == 记录条数2 - 1)
if (main1.图形数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",") < 0)
文本数组2[i].setText(一条空记录2[i]);
else if (main1.图形数据类型.lastIndexOf(","
+ 列数据类型2[文本数组号2[i]] + ",") < 0) {
文本数组2[i].setText(表格数据2[记录条数1][文本数组号2[i]]);
}
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
});
if (按钮位置[8][0] > 0) {
删除.setBounds(按钮位置[8][0], 按钮位置[8][1], 按钮位置[8][2], 按钮位置[8][3]);
panel2.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);
panel2.setVisible(false);
frame2.setVisible(false);
frame2.dispose();
}
});
if (按钮位置[9][0] > 0) {
退出.setBounds(按钮位置[9][0], 按钮位置[9][1], 按钮位置[9][2], 按钮位置[9][3]);
panel2.add(退出);
}
if ((sw[3].length() > 0) && (sw[4].length() > 0))
for (int i = 0; i < 控件个数; i++) {
文本数组2[i].setText(表格数据2[0][文本数组号2[i]]);
}
if (窗口高 - 起始到顶距 - 行间距离 - 100 < 0)
窗口高 = 起始到顶距 + 行间距离 + 100;
int w1, h1;
if (1200 - 窗口宽 > 0)
w1 = (1000 - 窗口宽) / 2;
else
w1 = 0;
if (600 - 窗口高 > 0)
h1 = (600 - 窗口高) / 2;
else
h1 = 0;
if (窗口高 < 起始到顶距 + 20)
窗口高 = 起始到顶距 + 20;
panel2.setBounds(10, 10, 窗口宽 - 10, 窗口高 - 20);
frame2.setBounds(w1 + 300, h1 + 100, 窗口宽, 窗口高); // 主程序窗口位置大小
frame2.setVisible(true); // 安装窗口
表格模型 = new DefaultTableModel(表格数据, 列名0);
表格 = new JTable(表格模型);
表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
表格.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
int w0 = 0;
for (int i = 0; i < 列数; i++) {
TableColumn tc = 表格.getColumn(列名0[i]);
JTableHeader header = 表格.getTableHeader();
tc.setPreferredWidth(列数据宽度[i] * 10);
tc.setMaxWidth(列数据宽度[i] * 10);
tc.sizeWidthToFit();
w0 = w0 + 列数据宽度[i] * 10;
if (w0 > 窗口宽1)
break;
}
表格.addMouseListener(new MouseAdapter() { // 为表格添加鼠标事件监听器
public void mouseClicked(MouseEvent e) { // 发生了点击事件
int 选中行号 = 表格.getSelectedRow(); // 获得被选中行的索引
for (int i = 0; i < 外键序号.length; i++) {
组合框[外键序号[i]].setSelectedItem(表格数据[选中行号][外键序号0[i]]);
}
}
});
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 10, 300, 窗口高 - 260);
scrollPane.setViewportView(表格);
frame1.add(scrollPane, BorderLayout.CENTER);
frame1.setBounds(10, 10, 350, 窗口高 - 100); // 主程序窗口位置大小
frame1.setVisible(true); // 安装窗口
JButton 删除0 = new JButton("删除当前记录");
删除0.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int 选中行号 = 表格.getSelectedRow();
s2 = "";
for (int j = 0; j < 外键名.length; j++) {
for (int i = 0; i < 列名.length; i++)
if (i == 外键序号0[j]) {
if (main1.数字数据类型.lastIndexOf("," + 列数据类型[i] + ",") >= 0)
s2 = s2 + 外键名[j] + "="
+ 表格模型.getValueAt(选中行号, i).toString();
else
s2 = s2 + 外键名[j] + "='"
+ 表格模型.getValueAt(选中行号, i).toString()
+ "'";
break;
}
if (j < 外键名.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
if (JOptionPane.showConfirmDialog(null, "是否删除子表中相关记录?") == 0) {
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + 表名 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + 主表名 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
deleteData(记录条数1);
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
});
删除0.setBounds(10, 窗口高 - 200, 150, 20);
frame1.add(删除0);
JButton 退出0 = new JButton("退出");
退出0.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
frame1.setVisible(false);
frame1.dispose();
frame2.dispose();
frame2.setVisible(false);
frame2.dispose();
}
});
退出0.setBounds(160, 窗口高 - 200, 150, 20);
frame1.add(退出0);
}
static void 计算文本框001() { // 如果没有接口参数表,计算控件位置、大小参数
if (位置参数条数 > 0)
return;
int 行间距离 = 0;
int 起始左边距 = 10;
位置参数条数 = 列数2;
文本区宽度 = 窗口宽 - 80;
起始到顶距 = 20;
int y1 = 起始左边距;
int y2 = 起始到顶距;
int 最大标签宽度 = 0;
if ((大数据个数 == 0) && (列数2 * 字符高度 < 窗口高 - 120)) {
行间距离 = (窗口高 - 150 - 列数2 * 字符高度) / (列数2 + 1);
for (int j = 0; j < 列数2; j++)
if (位置参数表[j][1].length() > 最大标签宽度)
最大标签宽度 = 位置参数表[j][1].length();
for (int j = 0; j < 列数2; j++) {
位置参数表[j][6] = y1 + ""; // 标签左边
位置参数表[j][7] = y2 + ""; // 标签到顶
位置参数表[j][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度
位置参数表[j][2] = 字符高度 + ""; // 标签高度
标签位置[j][0] = (y1 + 最大标签宽度 * 字符宽度) + ""; // 字段左边
标签位置[j][1] = y2 + ""; // 字段到顶
位置参数表[j][4] = (文本区宽度 - Integer.parseInt(标签位置[j][0])) + ""; // 字段宽度
位置参数表[j][5] = 字符高度 + ""; // 字段高度
位置参数表[j][8] = "宋体";
位置参数表[j][9] = "10"; // 字号
位置参数表[j][10] = "5"; // 颜色
标签位置[j][2] = "2"; // 图形代号
y2 = y2 + 字符高度 + 行间距离;
起始到顶距 = y2;
}
} else // 字段比较多,或者有大数据
{
y1 = 起始左边距; // 当前位置
y2 = 起始到顶距;
int 当前行行号 = 1;
for (int j = 0; j < 列数2; j++) { // 先处理非大数据
列名长度 = 位置参数表[j][1].length(); // 翻译后字段名宽度
if (大数据类型.lastIndexOf("," + 列数据类型2[j] + ",") < 0) {
if ((y1 + (列名长度 + 列数据宽度2[j]) * 字符宽度) > 文本区宽度) { // 如果放不下,换行
当前行行号++;
y1 = 起始左边距;
y2 = y2 + 字符高度;
}
位置参数表[j][6] = y1 + ""; // 标签左边
位置参数表[j][7] = y2 + ""; // 标签到顶
位置参数表[j][3] = 列名长度 * 字符宽度 + ""; // 标签宽度
if ((y1 == 起始左边距) && (列名长度 > 最大标签宽度))
最大标签宽度 = 列名长度;
位置参数表[j][2] = 字符高度 + ""; // 标签高度
标签位置[j][0] = (y1 + 列名长度 * 字符宽度) + ""; // 字段左边
标签位置[j][1] = y2 + ""; // 字段到顶
位置参数表[j][4] = 列数据宽度2[j] * 字符宽度 + ""; // 字段宽度
位置参数表[j][5] = 字符高度 + ""; // 字段高度
位置参数表[j][8] = "宋体";
位置参数表[j][9] = "10"; // 字号
位置参数表[j][10] = "5"; // 颜色
标签位置[j][2] = "2"; // 图形代号
y1 = y1 + 列名长度 * 字符宽度 + 列数据宽度2[j] * 字符宽度;
}
}
if (大数据个数 == 0)
行间距离 = (窗口高 - 150) / (当前行行号 + 1) - 字符高度;
else
行间距离 = 0;
if (行间距离 < 0)
行间距离 = 0;
int z = 0; // 每行左移数值
int z1 = 0; // 每行下移数值
int z3 = 0; // 最后一个非大数据字段号
for (int j = 0; j < 列数2; j++) { // 先处理非大数据位置调整
if (大数据类型.lastIndexOf("," + 列数据类型2[j] + ",") < 0) {
if (Integer.parseInt(位置参数表[j][6]) == 起始左边距) { // 每行第一列
z = 最大标签宽度 * 字符宽度 - Integer.parseInt(位置参数表[j][3]); // 修正标签宽度
z1 = z1 + 行间距离;
if (j > 0)
位置参数表[z3][4] = (文本区宽度 - Integer
.parseInt(标签位置[z3][0])) + "";
}
位置参数表[j][6] = (Integer.parseInt(位置参数表[j][6]) + z) + ""; // 标签左边
标签位置[j][0] = (Integer.parseInt(标签位置[j][0]) + z) + ""; // 字段左边
位置参数表[j][7] = (Integer.parseInt(位置参数表[j][7]) + z1) + ""; // 标签到顶
标签位置[j][1] = (Integer.parseInt(标签位置[j][1]) + z1) + ""; // 字段到顶
y2 = Integer.parseInt(标签位置[j][1]);
z3 = j;
}
}
位置参数表[z3][4] = (文本区宽度 - Integer.parseInt(标签位置[z3][0])) + "";
起始到顶距 = y2;
if (大数据个数 > 0) {
y2 = y2 + 字符高度; // 剩下空间高度
int z2 = (窗口高 - y2 - 120) / 大数据个数; // 大数据高度
for (int i3 = 0; i3 < 列数2; i3++) { // 处理大数据位置
if (大数据类型.lastIndexOf("," + 列数据类型2[i3] + ",") >= 0) {
位置参数表[i3][6] = 起始左边距 + ""; // 标签左边
位置参数表[i3][7] = y2 + ""; // 标签到顶
位置参数表[i3][3] = 最大标签宽度 * 字符宽度 + ""; // 标签宽度
位置参数表[i3][2] = 字符高度 + ""; // 标签高度
标签位置[i3][0] = (起始左边距 + 最大标签宽度 * 字符宽度) + ""; // 字段左边
标签位置[i3][1] = y2 + ""; // 字段到顶
y2 = y2 + z2;
位置参数表[i3][4] = (文本区宽度 - 最大标签宽度 * 字符宽度) + ""; // 字段宽度
位置参数表[i3][5] = z2 + ""; // 字段高度
位置参数表[i3][8] = "宋体";
位置参数表[i3][9] = "10"; // 字号
位置参数表[i3][10] = "5"; // 颜色
标签位置[i3][2] = "2"; // 图形代号
if (main1.图形数据类型.lastIndexOf("," + 列数据类型2[i3] + ",") >= 0)
标签位置[i3][4] = "图像字段"; // 字段类型
else
标签位置[i3][4] = "文本字段"; // 字段类型
// 当前列列号++;
}
}
起始到顶距 = y2 + 字符高度;
}
}
起始到顶距 = y2 + 字符高度;
}
static void 计算文本框002() { // 如果没有接口参数表,计算控件位置、大小参数
if (按钮定义标志 > 0)
return;
String[] t5 = 要求按钮号表.split(",");
实际按钮数 = t5.length - 1;
按钮位置 = new int[按钮数][15];
for (int j = 0; j < 按钮数; j++) {
按钮位置[j][0] = 0;
按钮位置[j][1] = 0;
按钮位置[j][2] = 0;
按钮位置[j][3] = 0;
}
int 按钮宽度;// ,按钮行数;
按钮宽度 = (int) (字符宽度 * 6.3);
起始左边距 = 20;
if (大数据个数 == 0)
起始到顶距 = 起始到顶距 + 字符高度 * 2;
else
起始到顶距 = 起始到顶距 + 字符高度;
int 一行按钮数 = (窗口宽 - 100) / (int) (6.6 * 字符宽度);
if (一行按钮数 < 1)
一行按钮数 = 1; // 每行最少一个按钮
if (实际按钮数 <= 一行按钮数)
按钮宽度 = (窗口宽 - 100) / 实际按钮数;
else
按钮宽度 = (窗口宽 - 100) / 一行按钮数;
int n = 0, n1 = 0, n3 = 0; // n:当行按钮数,n1:已排按钮数,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) <= 一行按钮数)
按钮宽度 = (窗口宽 - 100) / (实际按钮数 - n1);
else
按钮宽度 = (窗口宽 - 100) / 一行按钮数;
n = 0;
} else if (n >= 一行按钮数) {
起始左边距 = 20;
起始到顶距 = 起始到顶距 + 字符高度 + 20;
n = 0;
}
}
}
窗口高 = 起始到顶距 + 字符高度 + 100;
}
static void 数据表查询结构001(String 数据表名001) {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + 字段名字串2 + " from " + 数据表名001;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
列数2 = rsmdt4.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
一条空记录2 = new String[列数2];
大数据个数 = 0;
for (int i = 0; i < 列数2; i++) {
列名2[i] = rsmdt4.getColumnName(i + 1);
列数据宽度2[i] = rsmdt4.getColumnDisplaySize(i + 1);
列数据类型2[i] = rsmdt4.getColumnTypeName(i + 1);
if (标签位置[i][3] == null)
标签位置[i][3] = "";
if (标签位置[i][4] == null)
标签位置[i][4] = "";
if ((标签位置[i][3].length() < 1)
&& ((表名表.lastIndexOf("," + 列名2[i] + "表,") >= 0) && (列名2[i]
.indexOf("代码") >= 0))) {
标签位置[i][3] = 列名2[i] + "表";
标签位置[i][4] = "组合框";
列数据宽度2[i] = 列数据宽度2[i] + 10;
} else if ((标签位置[i][3].length() < 1)
&& ((表名表.lastIndexOf("," + 列名2[i] + "代码表,") >= 0) && (列名2[i]
.indexOf("代码") < 0))) {
标签位置[i][3] = 列名2[i] + "代码表";
标签位置[i][4] = "组合框";
列数据宽度2[i] = 列数据宽度2[i] + 10;
}
位置参数表[i][0] = 列名2[i];
if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() != 0))
for (int j = 0; j < 字典数据.length; j++) {
if (列名2[i].toLowerCase().equalsIgnoreCase(
字典数据[j][0].toLowerCase()))
位置参数表[i][1] = 字典数据[j][1]; // 完成字典名(标签)改变
else if (列名2[i].toLowerCase().equalsIgnoreCase(
字典数据[j][1].toLowerCase()))
位置参数表[i][1] = 字典数据[j][0]; // 完成字典名(标签)改变
}
if ((位置参数表[i][1]) == null || (位置参数表[i][1].length() == 0))
位置参数表[i][1] = 列名2[i];
if (标签位置[i][4].length() < 1)
if (main1.文本数据类型.indexOf("," + 列数据类型2[i] + ",") >= 0) {
标签位置[i][4] = "文本字段";
大数据个数++;
} else if (列数据类型2[i].equalsIgnoreCase("image")) {
标签位置[i][4] = "图像字段";
大数据个数++;
} else
标签位置[i][4] = "普通字段";
if (列数据类型2[i].indexOf("datetime") == 0)
一条空记录2[i] = "2001-01-01 00:00:00.000";
else if (列数据类型2[i].indexOf("smalldatetime") == 0)
一条空记录2[i] = "2001-01-01 00:00:00";
else if (列数据类型2[i].indexOf("datetime2") == 0)
一条空记录2[i] = "2001-01-01 00:00:00.0000000";
else if (列数据类型2[i].indexOf("datetimeoffset") == 0)
一条空记录2[i] = "2001-01-01 00:00:00.0000000 +08:00";
else if (列数据类型2[i].indexOf("date") == 0)
一条空记录2[i] = "2001-01-01";
else if (列数据类型2[i].indexOf("time") == 0)
一条空记录2[i] = "00:00:00";
else if (列数据类型2[i].indexOf("money") >= 0)
一条空记录2[i] = "0.0000";
else if (main1.小数型数据类型.lastIndexOf("," + 列数据类型2[i] + ",") >= 0)
一条空记录2[i] = "0.00";
else if (main1.数字数据类型.lastIndexOf("," + 列数据类型2[i] + ",") >= 0)
一条空记录2[i] = "0";
else
一条空记录2[i] = "";
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
外键序号集2 = ",";
字段名字串 = "";
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select * from " + 主表名;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
列数 = rsmdt4.getColumnCount();
列名 = new String[列数];
for (int i = 0; i < 列数; i++) {
列名[i] = rsmdt4.getColumnName(i + 1);
if ((要求字段号表.trim().length() > 0)
&& (("," + 要求字段号表 + ",").indexOf("," + i + ",") >= 0))
字段名字串 = 字段名字串 + 列名[i] + ",";
else if (要求字段号表.trim().length() == 0)
字段名字串 = 字段名字串 + 列名[i] + ",";
}
字段名字串 = 字段名字串.substring(0, 字段名字串.length() - 1);
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + 字段名字串 + " from " + 主表名;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
列数 = rsmdt4.getColumnCount();
列名 = new String[列数];
列名0 = new String[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
for (int i = 0; i < 列数; i++) {
列名[i] = rsmdt4.getColumnName(i + 1);
列名0[i] = 列名[i];
列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);
列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
for (int i = 0; i < 字典数据.length; i++) {
for (int j = 0; j < 列名.length; j++) {
if (列名[j].equals(字典数据[i][0]))
列名0[j] = 字典数据[i][1];
else if (列名[j].equals(字典数据[i][1]))
列名0[j] = 字典数据[i][0];
}
}
for (int j = 0; j < 列名.length; j++) {
for (int i = 0; i < 字典数据.length; i++) {
if (列名[j].equals(字典数据[i][0]))
列名0[j] = 字典数据[i][1];
else if (列名[j].equals(字典数据[i][1]))
列名0[j] = 字典数据[i][0];
}
}
for (int i1 = 0; i1 < 列名.length; i1++) {// 主表中外键在主表中序号
for (int j1 = 0; j1 < 外键名.length; j1++)
if (列名[i1].toLowerCase().trim()
.equals(外键名[j1].toLowerCase().trim()))
外键序号0[j1] = i1;
}
外键序号1 = new int[列名2.length];
for (int i1 = 0; i1 < 列名2.length; i1++) {
for (int j1 = 0; j1 < 关键字段名.length; j1++) {
if (列名2[i1].toLowerCase().trim()
.equals(关键字段名[j1].toLowerCase().trim()))
关键字序号[j1] = i1;
}
for (int j1 = 0; j1 < 外键名.length; j1++) { // 子表中外键在子表中序号
if (列名2[i1].toLowerCase().trim()
.equals(外键名[j1].toLowerCase().trim())) {
外键序号[j1] = i1; // 外键在子表中序号
外键序号集2 = 外键序号集2 + i1 + ",";
}
}
}
for (int i1 = 0; i1 < 列名2.length; i1++) {
for (int j1 = 0; j1 < 外键名.length; j1++) { // 子表中外键在子表中序号
if (列名2[i1].toLowerCase().trim()
.equals(外键名[j1].toLowerCase().trim()))
for (int i2 = 0; i2 < 列名.length; i2++) {
if (列名[i2].toLowerCase().trim()
.equals(外键名[j1].toLowerCase().trim()))
外键序号1[i1] = i2; // 子表中外键在主表中序号
}
}
}
}
static void 数据表查询数据001(String 数据表名001) { // 查数据表数据
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + 字段名字串2 + " from " + 数据表名001;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
rs = stat4.executeQuery(s1);
rs.last();
记录条数2 = rs.getRow();
String[][] 表格数据0 = new String[记录条数2][列数2];
表格数据2 = new String[记录条数2 + 300][列数2];
rsmdt4 = rs.getMetaData();
int c = 0;
int b = 0;
while (c < 记录条数2) {
rs.absolute(c + 1);
while (b < 列数2) {
表格数据0[c][b] = rs.getString(b + 1);
表格数据2[c][b] = 表格数据0[c][b];
b++;
}
c++;
b = 0;
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
for (int i = 0; i < 记录条数2; i++)
for (int j = 0; j < 列数2; j++)
表格数据2[i][j] = 表格数据0[i][j];
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + 字段名字串 + " from " + 主表名;
ResultSet rs = stat4.executeQuery(s1);
rs.last();
记录条数 = rs.getRow();
表格数据 = new String[记录条数][列数];
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();
} catch (Exception e) {
e.printStackTrace();
}
}
static void 数据表查询数据0011() { // 查询字典表
int 记录条数5 = 0;
try {
if (字典表名.length() > 0) {
cont4 = main1.getConn();// 连接数据库
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 字典表名;
rs = stat4.executeQuery(s1);
rs.last();
记录条数5 = rs.getRow();
字典数据 = new String[记录条数5][2];
rs.absolute(1);
String s4 = "";
String s5 = "";
for (int i = 1; i <= 记录条数5; i++) {
rs.absolute(i);
s4 = rs.getString(1).trim();
字典数据[i - 1][0] = s4;
s5 = rs.getString(2).trim();
字典数据[i - 1][1] = s5;
}
rs.close(); // 关闭查询结果集
stat4.close();
cont4.close();
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
static void 数据表查询数据0012(String 代码表名0, String 列名9, int j9) { // 查代码表数据
try {
if (列名9.indexOf("代码") >= 0) {
s2 = 列名9.substring(0, 列名9.length() - 2);
s1 = "select " + 列名9 + "," + s2 + " from " + 代码表名0;
} else if (表名表.lastIndexOf("," + 列名9 + "代码表,") >= 0) {
s2 = 列名9.substring(0, 列名9.length() - 2);
s1 = "select " + 列名9 + "," + 列名9 + "代码" + " from " + 列名9
+ "代码表";
}
cont4 = main1.getConn();// 连接数据库
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = stat4.executeQuery(s1);
rs.last();
int numberOfColumns = rs.getRow();
rs.beforeFirst();
代码表数据[j9] = new String[numberOfColumns];
for (int i = 1; i <= numberOfColumns; i++) {
rs.absolute(i);
代码表数据[j9][i - 1] = rs.getString(1).trim();
}
rs.close();
stat4.close(); // 关闭连接
cont4.close();
} catch (SQLException e3) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!" + s1);
}
}
static void 安装文本框002() {
文本框 = new JTextField[位置参数条数];
文本域 = new JTextArea[位置参数条数];
图片数组 = new JLabel[位置参数条数];
组合框 = new JComboBox[位置参数条数];
文本数组2 = new JTextComponent[位置参数条数];
文本数组号2 = new int[位置参数条数];
代码表数据 = new String[位置参数条数][2];
控件个数 = 位置参数条数;
for (int j = 0; j < 控件个数; j++) {
JLabel 标签 = new JLabel(位置参数表[j][1], 11);
标签.setBounds(Integer.parseInt(位置参数表[j][6]),
Integer.parseInt(位置参数表[j][7]),
Integer.parseInt(位置参数表[j][3]),
Integer.parseInt(位置参数表[j][2]));
Font font = new Font(位置参数表[j][8], Font.BOLD,
Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小
String s01 = 位置参数表[j][10];
int s02 = 5;
if ((s01 != null) && (s01.length() > 0)
&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))
s02 = Integer.parseInt(s01);
标签.setFont(font);
color1(s02, 标签);// 设置颜色
panel2.add(标签);
if ((标签位置[j][4].equals("普通字段"))
&& ((外键序号集2.indexOf("," + j + ",") < 0))) {
文本框[j] = new JTextField("");
文本框[j].setBounds(Integer.parseInt(标签位置[j][0]),
Integer.parseInt(标签位置[j][1]),
Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
Font font1 = new Font(位置参数表[j][8], Font.BOLD,
Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小
String s011 = 位置参数表[j][10];
int s021 = 5;
if ((s011 != null) && (s011.length() > 0)
&& (s011.compareTo("0") >= 0)
&& (s011.compareTo("9") <= 0))
s021 = Integer.parseInt(s011);
文本框[j].setFont(font1);
color2(s021, 文本框[j]);// 设置颜色
if (限只读字段号表.indexOf("," + j + ",") >= 0) {
文本框[j].setEditable(false);
}
panel2.add((Component) 文本框[j]);
文本框[j].addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent arg0) {// 鼠标按下事件
c = 0;
}
});
文本框[j].addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {// 获得焦点
Object s0 = arg0.getSource();
String s1 = s0.toString();
String s2 = "";
for (int i = 0; i < 控件个数; i++) {
s2 = "[," + 标签位置[i][0].trim() + ","
+ 标签位置[i][1].trim() + ",";
if (s1.indexOf(s2) > 0) {
b = i;
break;
}
}
}
public void focusLost(final FocusEvent arg1) {// 失去焦点
if (c > 0)
return;
Object s0 = arg1.getSource();
String s1 = s0.toString().substring(10, 33);
String s2 = "";
for (int i = 0; i < 控件个数; i++) {
s2 = "[," + 标签位置[i][0].trim() + ","
+ 标签位置[i][1].trim() + ",";
if (s1.indexOf(s2) > 0) {
b = i;
break;
}
}
if ((c == 0) && (! 完整性检查(c, b))) {
文本框[c].requestFocus(true); // 返回原来文本框
return;
}
}
});
文本框[j].setText(一条空记录2[j]);
文本数组2[j] = (JTextComponent) 文本框[j];
文本数组号2[j] = j;
} // 普通字段
else if (标签位置[j][4].equals("文本字段")) {
文本域[j] = new JTextArea(" ", Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
JScrollPane 文本域滚动条 = new JScrollPane(文本域[j]);
文本域滚动条.setBounds(Integer.parseInt(标签位置[j][0]),
Integer.parseInt(标签位置[j][1]),
Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
Font font1 = new Font(位置参数表[j][8], Font.BOLD,
Integer.parseInt(位置参数表[j][9])); // 设置字体与文字大小
String s011 = 位置参数表[j][10];
int s021 = 5;
if ((s011 != null) && (s011.length() > 0)
&& (s011.compareTo("0") >= 0)
&& (s011.compareTo("9") <= 0))
s021 = Integer.parseInt(s011);
文本域[j].setFont(font1);
color3(s021, 文本域[j]);// 设置颜色
panel2.add((Component) 文本域滚动条);
文本域[j].setText(一条空记录2[j]);
文本数组2[j] = (JTextComponent) 文本域[j];
文本数组号2[j] = j;
} else if (标签位置[j][4].equals("图像字段")) {
JLabel 图片框 = new JLabel(" ");
图片框.setBackground(Color.BLUE);
图片框.setBounds(Integer.parseInt(标签位置[j][0]),
Integer.parseInt(标签位置[j][1]),
Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
panel2.add(new JScrollPane(图片框));
panel2.add(图片框);
图片数组[j] = 图片框;
文本数组2[j] = (JTextComponent) 文本域[j];
文本数组号2[j] = j;
} else if (标签位置[j][4].equals("组合框")) {
组合框[j] = new JComboBox();
文本框[j] = new JTextField();
组合框[j].setEditable(true);// 确定 JComboBox 字段是否可编辑
组合框[j].setEnabled(true); // 启用组合框以便可以选择项
panel2.add((Component) 组合框[j]);
组合框[j].setBounds(Integer.parseInt(标签位置[j][0]),
Integer.parseInt(标签位置[j][1]),
Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
数据表查询数据0012(标签位置[j][3], 位置参数表[j][0], j);
for (int i = 0; i < 代码表数据[j].length; i++) {
组合框[j].addItem(代码表数据[j][i]);
}
文本数组2[j] = (JTextComponent) 组合框[j].getEditor()
.getEditorComponent(); // 控件个数
文本数组2[j].setText(""); // 控件个数
文本数组号2[j] = j;
} else if (外键序号集2.indexOf("," + j + ",") >= 0) {
组合框[j] = new JComboBox();
文本框[j] = new JTextField();
组合框[j].setEditable(false);// 确定 JComboBox 字段是否可编辑
组合框[j].setEnabled(true); // 启用组合框以便可以选择项
panel2.add((Component) 组合框[j]);
组合框[j].setBounds(Integer.parseInt(标签位置[j][0]),
Integer.parseInt(标签位置[j][1]),
Integer.parseInt(位置参数表[j][4]),
Integer.parseInt(位置参数表[j][5]));
for (int i = 0; i < 表格数据.length; i++) {
组合框[j].addItem(表格数据[i][外键序号1[j]]);
}
文本数组2[j] = (JTextComponent) 组合框[j].getEditor()
.getEditorComponent(); // 控件个数
文本数组2[j].setText(""); // 控件个数
文本数组号2[j] = j;
组合框[j].addActionListener(new ActionListener() {// 组合框响应事件
public void actionPerformed(ActionEvent event) {
int b0 = 0;
String s0 = "";
String s10 = event.toString();
for (int i = 0; i < 控件个数; i++) {
s0 = "[," + 标签位置[i][0].trim() + ","
+ 标签位置[i][1].trim() + ",";
if (s10.indexOf(s0) > 0) {
b0 = i;
break;
}
}
for (int i = 0; i < 外键序号.length; i++) {
if (外键序号[i] != b0)
组合框[外键序号[i]].setSelectedIndex(组合框[b0]
.getSelectedIndex());
表格.editCellAt(组合框[b0].getSelectedIndex(), 外键序号1[b0]);
}
}
});
}
}
}
public static void deleteData(int pos) {
if (pos == 记录条数2 - 1)
记录条数1--;
for (int i = pos; i < 记录条数2 - 1; i++) {
for (int j = 0; j < 控件个数 - 1; j++) {
表格数据2[i][j] = 表格数据2[i + 1][j];
}
}
记录条数2--;
}
static void color1(int c, JLabel fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
static void color2(int c, JTextField fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
static void color3(int c, JTextArea fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
public static void 图片存盘(String s0, int k) {
for (int i = 0; i < 文本数组2.length; i++)
cont4 = main1.getConn();
try {
PreparedStatement pst4 = cont4.prepareStatement(s0);
int k2 = 1;
String s5 = "";
final JFileChooser fc = new JFileChooser(".\\");
fc.showDialog(new JLabel(), "请选择图片字段" + 列名2[文本数组号2[k]] + "的文件名");
if (fc.getSelectedFile() != null)
s5 = fc.getSelectedFile().toString();
else {
JOptionPane.showMessageDialog(null, "未选择图片文件,原图不变!");
return;
}
FileInputStream f1 = new FileInputStream(s5); // 指定图片文件名,包括路径
pst4.setBinaryStream(k2, f1, f1.available());
k2++;
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
byte[] c0 = new byte[s5.length()];
Icon icon = new ImageIcon(c0);
图片数组[k].setOpaque(true);
图片数组[k].setBackground(Color.PINK);
图片数组[k].setIcon(icon);
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "修改语句错!" + s1);
} catch (IOException e3) {
JOptionPane.showMessageDialog(null, "文件读取出错!");
}
}
public static boolean 完整性检查(int c1, int b1) {
c = c1;
b = b1;
int bz1 = 0;
String sb = "", bz = "";
String[] sb1 = null;
try {
for (int i1 = 0; i1 < 完整性参数条数; i1++) {
if (完整性参数表[i1][0].toLowerCase().trim()
.equals(位置参数表[b][0].toLowerCase().trim())) { // 当前字段,获得焦点时记录
bz1 = main1.数字数据类型.indexOf("," + 列数据类型2[文本数组号2[b]] + ",");
if (bz1 >= 0) { // 数字数据类型
if ((完整性参数表[i1][1].trim().length() > 0)
&& (Double.parseDouble(文本框[b].getText()) > Double
.parseDouble(完整性参数表[i1][1]))) {
bz = 文本框[b].getText() + ">最大值"
+ Double.parseDouble(完整性参数表[i1][1]);
c = b;
} else if ((完整性参数表[i1][2].trim().length() > 0)
&& (Double.parseDouble(文本框[b].getText()) < Double
.parseDouble(完整性参数表[i1][2]))) {
bz = 文本框[b].getText() + "<最小值" + 完整性参数表[i1][2];
c = b;
} else if ((完整性参数表[i1][3].trim().length() > 0)) {
if (完整性参数表[i1][3].indexOf("-") > 0) {
sb1 = 完整性参数表[i1][3].split("-");
if ((Double.parseDouble(文本框[b].getText()) < Double
.parseDouble(sb1[0]))) {
bz = 文本框[b].getText() + "<范围下限" + sb1[0];
c = b;
}
if ((Double.parseDouble(文本框[b].getText()) > Double
.parseDouble(sb1[1]))) {
bz = 文本框[b].getText() + ">范围上限" + sb1[1];
c = b;
}
} else if (完整性参数表[i1][3].indexOf("[") >= 0) {
bz = 完整性参数表[i1][3].trim().substring(1,
完整性参数表[i1][3].length() - 1);
sb1 = bz.split(",");
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (sb1[i].indexOf("^") >= 0) {
if (文本框[b].getText().indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = -1;
break;
}
}
}
if (bz1 == -1) {
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
c = b;
}
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (文本框[b].getText()
.indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = 1;
break;
}
}
if (bz1 == 0) {
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
c = b;
}
} else if (完整性参数表[i1][3].indexOf(",") > 0) {
if (("," + 完整性参数表[i1][3] + ",").indexOf(","
+ 文本框[b].getText() + ",") < 0) {
c = b;
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
}
}
} else if (完整性参数表[i1][4].trim().length() > 0) {
int[][] m = new int[2][控件个数];
for (int i = 0; i < 控件个数; i++) { // 按列名长度从大到小排序
m[0][i] = i;
m[1][i] = 位置参数表[i][0].length();
}
int d = 0, e = 0;
for (int i = 0; i < m[1].length; i++)
for (int j = i + 1; j < m[1].length; j++)
if (m[1][i] < m[1][j]) {
e = m[0][i];
m[0][i] = m[0][j];
m[0][j] = e;
e = m[1][i];
m[1][i] = m[1][j];
m[1][j] = e;
}
sb = 完整性参数表[i1][4];
for (int i = 0; i < m[1].length; i++)
sb = sb.replaceAll(位置参数表[m[0][b]][0],
文本框[m[0][b]].getText());
if (! tenanceEval.tenanceeval(sb)) {
bz = 文本框[b].getText() + "不满足条件:"
+ 完整性参数表[i1][4];
c = b;
}
} else
c = 0;
}
else if (main1.文字数据类型.lastIndexOf("," + 列数据类型2[文本数组号2[b]]
+ ",") >= 0) { // 字符类型
if ((完整性参数表[i1][3].trim().length() > 0)) {
if (完整性参数表[i1][3].indexOf("[") >= 0) {
bz = 完整性参数表[i1][3].trim().substring(1,
完整性参数表[i1][3].length() - 1);
sb1 = bz.split(",");
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (sb1[i].indexOf("^") >= 0) {
if (文本框[b].getText().indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = -1;
break;
}
}
}
if (bz1 == -1) {
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
c = b;
}
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (文本框[b].getText()
.indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = 1;
break;
}
}
if (bz1 == 0) {
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
c = b;
}
} else if (完整性参数表[i1][3].indexOf(",") > 0) {
if (("," + 完整性参数表[i1][3] + ",").indexOf(","
+ 文本框[b].getText() + ",") < 0) {
c = b;
bz = 文本框[b].getText() + "不满足"
+ 完整性参数表[i1][3] + "范围要求!";
}
}
} else
c = 0;
}
}
if (bz.length() > 0)
break;
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求,请修改接口参数表!"
+ e1);
}
if (bz.length() > 0) {
if (c > 0) {
JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查!"
+ bz);
bz = "";
return false;
}
}
return true;
}
}
81.源码81,部件程序,表单程序,用于多对多表之间联系表的数据维护。
/**
* 程序文件名:dataTenance8.java
* 作者:程学先
* 程序功能:多对多表之间联系表的数据维护。
* 多对多表称为主表1和主表2,本程序只适应每表主键均为单字段情况。
* 多对多关系之间应当存在一个联系表,其主键为二个多方关系的主键,分别为多方表外键。
* 向联系表录入数据时外键数据来自多方表,应当率先自动填入,
* 操作者只录入联系自身属性值,这样既减少工作量且有效减少出错可能,是实现参照完整性保护常见手段。
* 本程序要求首先确定从多方表取主键数据到联系表的条件,例如在学生表中设定:专业='计算机技术'
* 在课程表中确定:课号='2'。注意均采用单引号。
* 之后,自动查找联系表中与之同名的字段,从多方表满足条件的记录中取出关键字数据填到表格中,
* 将原联系表中非关键字字段数据填入表格,显示在窗口中。
* 再由操作者填写其他新的数据,完成后将表格数据区分添加方式或修改方式录入到数据表中。
* 完成日期:2014年1月20日
* 被调用语句:dataTenance8.means(parameter);
* 必须提供的参数:“主表1表名”、“主表2表名”、联系“表名”、联系表“关键字段名”。
* 可选择输入的参数:多方表名1相关的"条件表达式1"、多方表2相关的"条件表达式2"、“窗口宽”、“窗口高” 等。
* 联系表主键必须分别是二个多方表的主键,且同名。
* 本部件预设的按钮控件“从表格删除”、“存入数据库”、“表格更新”、“退出”共 4个。
* 从表格删除指从显示的临时表格中删除,当时不删除数据表中数据。
* 全部录入、修改、删除完成后必须点击“存入数据库”按钮完成数据录入操作。
* 如果重新设置条件表达式,需要点击“表格更新”按钮重建表格,表格中原有数据将删除。
*/
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
public class dataTenance8 extends JFrame
{
static dataTenance8 frame1=new dataTenance8();
static JTextField 文本框1;
static JTextField 文本框2;
private static JLabel fl1,fl2;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs;
private static String 主表名1;
private static String 主表名2;
private static String 表名 ;
private static int 窗口宽 =main1.窗口宽;
private static int 窗口高 = main1.窗口高;
private static int 列数;
private static int 列数1;
private static int 列数2;
private static String[] 列名;
private static String[] 列名1;
private static String[] 列名2;
private static String[] 列数据类型;
private static String[] 列数据类型1;
private static String[] 列数据类型2;
private static int[] 列数据宽度;
private static int[] 列数据宽度1;
private static int[] 列数据宽度2;
private static int 记录条数=0;
private static int 记录条数1=0;
private static int 记录条数2=0;
private static String[][] 表格数据;
private static String[][] 表格数据1;
private static String[][] 表格数据2;
private static String[][] 表格数据3;
private static String 键盘输入字串="";
private static JTable 表格;
static DefaultTableModel 表格模型;
private static String[] 关键字段名;
private static String[] 关键字段值;
private static int[] 关键字序号;
private static int 关键字序号1;
private static int 关键字序号2;
private static String 条件表达式1="",条件表达式2="";
private static String s1="",s2="",s3="";//,s4="";
private static int b = 0, c = 0,行号=0,列号3=0;
private static String[] 按钮集={"从表格删除","存入数据库","更新表格","退出"};
private static JButton 从表格删除,存入数据库,退出;
static int 按钮数=0,按钮宽=0;
private static String 要求按钮号表;
private static int 字符宽度=15,字符高度=20;
static int 起始左边距;
static int 文本域高度;
private static int 按钮位置[][];
static int 大数据个数;
private static int 按钮定义标志,实际按钮数;
static void means(String parameter[]) {
frame1=new dataTenance8();
窗口宽 =main1.窗口宽;
窗口高 = main1.窗口高;
记录条数=0;记录条数1=0;记录条数2=0;
键盘输入字串="";文本域高度=0;
s1="";s2="";s3=""; b = 0; c = 0;行号=0;列号3=0;
字符宽度=15;字符高度=20; 按钮定义标志=0;实际按钮数=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];//只留号,原无更名
}
}
} //如果没有按钮更名要求,要求按钮号长度又大于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; //可以供选择的按钮数
窗口宽=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){}
主表名1=parameter[2] ; // 数据表名
主表名2=parameter[3] ;
表名=parameter[4] ;
if (parameter[6].length()<=0){
JOptionPane.showMessageDialog( null, "缺少关键字,请说明关键字字段后再运行。");
return;
}
关键字段名=parameter[6].split(",");
条件表达式1=parameter[13] ;
条件表达式2=parameter[14] ;
关键字序号=new int[关键字段名.length];
frame1.setTitle("多对多表数据维护程序 作者:程学先");
frame1.setBounds(0, 0,窗口宽, 窗口高);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null);
fl1=new JLabel(主表名1+"条件表达式");
fl1.setBounds(30,20,120, 20);
frame1.add(fl1); //定义文本框的标签
文本框1 = new JTextField(条件表达式1,20);
文本框1.setBounds(150,20,200, 20);
frame1.add(文本框1); //加入文本框
fl2=new JLabel(主表名2+"条件表达式");
fl2.setBounds(350,20,120, 20);
frame1.add(fl2);
文本框2 = new JTextField(条件表达式2,20);
文本框2.setBounds(470,20,200, 20);
frame1.add(文本框2); //加入文本框
计算文本框002();
if ((条件表达式1.trim().length()>0)&&(条件表达式2.trim().length()>0))
refresh();
从表格删除 = new JButton(按钮集[0]);
从表格删除.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int 选中行号 = 表格.getSelectedRow();
if (选中行号 != -1)
表格模型.removeRow(选中行号);
}
});
if (要求按钮号表.lastIndexOf(",0,")>=0){
从表格删除.setBounds(按钮位置[0][0],按钮位置[0][1],按钮位置[0][2],按钮位置[0][3]);
frame1.add(从表格删除);
}
存入数据库 = new JButton(按钮集[1]);
存入数据库.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String 类型=main1.数字数据类型;
try{
cont4=main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
记录条数1=表格模型.getRowCount();
int f0=0;
for (int i=0;i<记录条数1;i++) {
f0=0;
s3="";
for (int j=0;j<关键字序号.length;j++){
s3=s3+表格模型.getValueAt(i,关键字序号[j]).toString().trim();
}
for (int i1=0;i1<记录条数;i1++){
if (关键字段值[i1].toLowerCase().trim().equals(s3.toLowerCase().trim())){
f0=1;
break;
}
}
if (f0==0){
s1="insert into "+表名+" (";
for (int k1=0;k1<列名.length;k1++)
s1=s1+列名[k1]+",";
s1=s1.substring(0,s1.length()-1)+" ) values (";
// System.out.println("0s1="+s1);
for (int j=0;j<列名.length;j++){
if (类型.lastIndexOf(","+列数据类型[j]+",")>=0){
if ((表格模型.getValueAt(i,j)==null)||
(表格模型.getValueAt(i,j).toString().trim().length()<1))
s1=s1+"0";
else s1=s1+表格模型.getValueAt(i,j).toString().trim();
}
else{
if (表格模型.getValueAt(i,j)==null)
s1=s1+"' '";
else s1=s1+"'"+表格模型.getValueAt(i,j).toString().trim()+"'";
}
if (j!=列名.length-1) s1=s1+",";
}
s1=s1+")";
stat4.executeUpdate(s1);
}
else {
s1="update "+表名+" set ";
for (int k1=0;k1<列名.length;k1++){
s1=s1+列名[k1]+"=";
if (类型.lastIndexOf(","+列数据类型[k1]+",")>=0){
if ((表格模型.getValueAt(i,k1)==null) ||
(表格模型.getValueAt(i,k1).toString().trim().length()<1))
s1=s1+"0";
else s1=s1+表格模型.getValueAt(i,k1).toString().trim();
}
else{
if (表格模型.getValueAt(i,k1)==null) s1=s1+"' '";
else s1=s1+"'"+表格模型.getValueAt(i,k1).toString().trim()+"'";
}
if (k1!=列名.length-1) s1=s1+",";
}
s2=" where ";
for (int k=0;k<关键字序号.length;k++){
s2=s2+关键字段名[k]+"='"+表格数据[i][关键字序号[k]]+"'";
if (k<关键字段名.length-1) s2=s2+" and ";
}
s1=s1+s2;
stat4.executeUpdate(s1);
}
}
stat4.close(); //关闭连接
cont4.close();
}
catch(SQLException e1)
{
JOptionPane.showMessageDialog( null, "操作出错,请检查数据表名是否重复,录入语句是否正确!"+s1);
}
}
});
if (要求按钮号表.lastIndexOf(",1,")>=0){
存入数据库.setBounds(按钮位置[1][0],按钮位置[1][1],按钮位置[1][2],按钮位置[1][3]);
frame1.add(存入数据库);
}
JButton 更新表格 = new JButton(按钮集[2]);
更新表格.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
条件表达式1=文本框1.getText();
条件表达式2=文本框2.getText();
refresh();
}
});
if (要求按钮号表.lastIndexOf(",2,")>=0){
更新表格.setBounds(按钮位置[2][0],按钮位置[2][1],按钮位置[2][2],按钮位置[2][3]);
frame1.add(更新表格);
}
退出 = new JButton(按钮集[3]);
退出.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
}
});
if (要求按钮号表.lastIndexOf(",3,")>=0){
退出.setBounds(按钮位置[3][0],按钮位置[3][1],按钮位置[3][2],按钮位置[3][3]);
frame1.add(退出);
}
frame1.setVisible(true);
}
static void 计算文本框002(){ //如果没有接口参数表,计算控件位置、大小参数
int 起始到顶距=0;
//计算按钮位置
if (按钮定义标志>0) return;
要求按钮号表=",0,1,2,3,";
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)(字符宽度*12);
起始左边距=20;
if (大数据个数==0)
起始到顶距=起始到顶距+字符高度*2;
else 起始到顶距=起始到顶距+字符高度;
int 一行按钮数=(窗口宽-30)/(int)(6.6*字符宽度);
if (一行按钮数<1) 一行按钮数=1; //每行最少一个按钮
if (实际按钮数<=一行按钮数) 按钮宽度=(窗口宽-60)/实际按钮数;
else 按钮宽度=(窗口宽-60)/一行按钮数;
int n=0,n1=0,n3=0; //n:当行按钮数,n1:已排按钮数,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()*(字符宽度*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;
}
else if (n>=一行按钮数){
起始左边距=20;
起始到顶距=起始到顶距+字符高度+20;
n=0;
}
}
}
窗口高=起始到顶距+字符高度+100;
}
public static void refresh(){
try
{
cont4=main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 主表名1;
if (条件表达式1.length()>0)
s1=s1+" where "+条件表达式1;
rs = stat4.executeQuery(s1);
rs.last();
记录条数1 = rs.getRow();
rsmdt4 = rs.getMetaData();
列数1 = rsmdt4.getColumnCount();
列名1 = new String[列数1];
列数据类型1 = new String[列数1];
列数据宽度1 = new int[列数1];
表格数据1= new String[记录条数1][列数1];
for (int i=0;i<列数1;i++) {
列名1[i] = rsmdt4.getColumnName(i + 1);
列数据类型1[i] = rsmdt4.getColumnTypeName(i + 1);
列数据宽度1[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j< 关键字段名.length; j++)
for (int i=0;i<列数1;i++){
if (关键字段名[j].toLowerCase().trim().equals(列名1[i].toLowerCase().trim())) {
关键字序号1 = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < 记录条数1)
{
rs.absolute(c + 1);
while (b < 列数1)
{
表格数据1[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!"+s1);
}
if (主表名2.length()>0){
try
{
cont4=main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + 主表名2;
if (条件表达式2.length()>0)
s1=s1+" where "+条件表达式2;
rs = stat4.executeQuery(s1);
rs.last();
记录条数2 = rs.getRow();
rsmdt4 = rs.getMetaData();
列数2 = rsmdt4.getColumnCount();
列名2 = new String[列数2];
列数据类型2 = new String[列数2];
列数据宽度2 = new int[列数2];
表格数据2= new String[记录条数2][列数2];
for (int i=0;i<列数2;i++) {
列名2[i] = rsmdt4.getColumnName(i + 1);
列数据类型2[i] = rsmdt4.getColumnTypeName(i + 1);
列数据宽度2[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j< 关键字段名.length; j++)
for (int i=0;i<列数2;i++){
if (关键字段名[j].toLowerCase().trim().equals(列名2[i].toLowerCase().trim())) {
关键字序号2 = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < 记录条数2)
{
rs.absolute(c + 1);
while (b < 列数2)
{
表格数据2[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!"+s1);
}
}
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[列数];
列数据类型 = new String[列数];
列数据宽度 = new int[列数];
表格数据3=new String[记录条数][列数];
for (int i=0;i<列数;i++) {
列名[i] = rsmdt4.getColumnName(i + 1);
列数据类型[i] = rsmdt4.getColumnTypeName(i + 1);
列数据宽度[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j< 关键字段名.length; j++)
for (int i=0;i<列数;i++){
if (关键字段名[j].toLowerCase().trim().equals(列名[i].toLowerCase().trim())) {
关键字序号[j] = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < 记录条数){
rs.absolute(c + 1);
while (b < 列数) {
表格数据3[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
关键字段值=new String[记录条数];
for (int j=0;j<记录条数;j++){
关键字段值[j]="";
for (int i=0;i<关键字段名.length;i++){
关键字段值[j]=关键字段值[j]+表格数据3[j][关键字序号[i]].trim();
}
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e)
{
JOptionPane.showMessageDialog( null, "连接数据库出错!"+s1);
}
if (记录条数2==0)
表格数据=new String[记录条数1][列数];
else 表格数据=new String[记录条数1*记录条数2][列数];
for (int i=0;i<记录条数1;i++)
for (int j=0;j<列数;j++)
表格数据[i][j]="";
if (记录条数2>0)
for (int i=0;i<记录条数1;i++)
for (int j=0;j<记录条数2;j++){
表格数据[i][关键字序号[0]]=表格数据1[i][关键字序号1];
表格数据[i][关键字序号[1]]=表格数据2[j][关键字序号2];
}
else
for (int i=0;i<记录条数1;i++){
表格数据[i][关键字序号[0]]=表格数据1[i][关键字序号1];
}
for (int i=0;i<表格数据.length;i++)
for (int j=0;j<表格数据3.length;j++)
if ((表格数据[i][关键字序号[0]].trim()+表格数据[i][关键字序号[1]].trim())
.equals(表格数据3[j][关键字序号[0]]+表格数据3[j][关键字序号[1]])){
for (int k=0;k<列数;k++){
if ((k!=关键字序号[0])&&(k!=关键字序号[1]))
表格数据[i][k]=表格数据3[j][k];
}
}
表格模型 = new DefaultTableModel(表格数据,列名);
表格 = new JTable(表格模型);
表格.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
表格.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for(int i=0;i<列数;i++) {
TableColumn tc = 表格.getColumn(列名[i]);
if (列名[i].length()>列数据宽度[i]) 列数据宽度[i]=列名[i].length();
tc.setPreferredWidth(列数据宽度[i]*11);
tc.setMaxWidth(列数据宽度[i]*11);
tc.sizeWidthToFit();
}
窗口高=650;
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(30,80,窗口宽-100,窗口高-150);
frame1.setBounds(10,10,窗口宽,窗口高);
scrollPane.setViewportView(表格);
frame1.add(scrollPane, BorderLayout.CENTER);
表格.addKeyListener(new KeyAdapter()
{
public void keyPressed(KeyEvent evt) {
键盘输入字串=键盘输入字串+evt.getKeyChar();
}
});
表格.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
键盘输入字串="";
}
});
表格.addFocusListener(new FocusAdapter() {
public void focusLost(final FocusEvent arg0) {
行号 = 表格.getSelectedRow();
列号3 = 表格.getSelectedColumn();
表格模型.setValueAt(键盘输入字串, 行号,列号3);
}
});
}
}
版本2
80.源码80,部件程序,表单程序,一对多表多方子表数据维护部件,运行时同时显示主表与子表,对子表提供录入、修改、删除操作功能。提供安全性、域完整性、实体完整性及参照完整性保护。对主表只提供删除操作功能。
/**
* 程序文件名:dataTenance7.java
* 作者:程学先
* 功能:一对多表多方子表数据维护部件,运行时同时显示主表与子表,对子表提供录入、修改、删除操作功能。
* 对主表只提供删除操作功能,提供安全性、域完整性、实体完整性及参照完整性保护。
* 在主表中删除一条记录时会提问是否同时删除子表中相匹配的记录,在肯定后删除子表中相关记录。
* 关键字段名为子表的关键字,是识别与区分子表记录的主要标志,不允许重复,不允许为空,
* 可以是单一字段,也可以是多个字段,如果是多字段,以英文逗号分隔。
* 外键指主表与子表中同名字段,可以是单个字段,也可以是多字段。如果是多字段,以英文逗号分隔。
*/
import java.awt.*;
import java.awt.List;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;
import javax.swing.table.*;
import javax.swing.text.JTextComponent;
import java.sql.*;
import java.util.*;
public class dataTenance7 extends JFrame {
static dataTenance7 frame1 = null;
static dataTenance7 frame2 = null;
static JTextField[] variabl2403 = null;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs;
private static String variabl2277;
private static String variabl2603 = "";
private static int variabl2483 = main1.variabl2483;
private static int variabl24831 = 300;
private static int variabl2503 = main1.variabl2503 - 100;
private static int variabl2651 = 0;
private static int variabl26512 = 0, variabl1739 = 0;
private static String[] variabl2517 = null;
private static String[] variabl25170 = null;
private static String[] variabl25172 = null;
private static String variabl1325 = "";
private static String variabl13252 = "", variabl2803 = "";
private static String[] variabl1501 = null;
private static String[] variabl15012 = null;
private static int[] variabl1489 = null;
private static int[] variabl14892 = null;
private static int variabl1853 = 0;
private static int variabl18531 = 0;
private static int variabl18532 = 0;
private static JTable variabl2655;
static DefaultTableModel variabl1965;
private static String[][] variabl2197 = null;
private static String[][] variabl21972 = null;
private static String[] variabl14192 = null;
static String[][] variabl1701 = null;
private static String variabl1187 = "";
private static int variabl1371 = 0;
private static String variabl1153 = "";
private static String variabl11532 = "";
private static String[] variabl15072 = null;
private static String[] variabl1525 = null;
private static int[] variabl1287 = null;
private static String[] variabl2379 = null;
private static String variabl15932 = "";
private static int[] variabl2105 = null;
private static int[] variabl21050 = null;
private static int[] variabl21051 = null;
private static String s1 = "", s2 = "";
private static int b = 0, c = 0;
private static int variabl1843 = 0;
private static JLabel[] variabl2165 = null;
private static int variabl1647 = 15, variabl1849 = 20;
private static String[] variabl2405;
private static JButton variabl2375, variabl2325, variabl1971, variabl2255,
variabl2531, variabl2611, variabl2601, variabl1697, variabl2633,
variabl2599;
private static ArrayList<String> list = new ArrayList<String>();
private static ArrayList<String> list0 = new ArrayList<String>();
private static String[][] variabl1323 = null;
private static String[][] variabl1651 = null;
private static String[][] variabl1201 = null;
private static String[][] variabl1197 = null;
private static String[][] variabl1837 = new String[0][0];
private static int variabl1233 = 0, variabl1077 = 0, variabl1069 = 0;
public static String username = main1.username;
public static int variabl2607 = 9, variabl2659 = 5;
private static String variabl1597 = main1.variabl1537 + main1.variabl1539;
private static int variabl3681 = 0;
private static int variabl1459 = 0;
private static int[] variabl14672 = null;
private static int variabl1637 = 0;
private static JPanel panel2 = new JPanel(false);
private static int variabl1745 = variabl2483;
private static int variabl1315 = 0;
private static int variabl1473 = 0;
private static int variabl1925 = 0;
private static JTextArea[] variabl2463 = null;
private static JComboBox[] variabl2359 = null;
private static JTextComponent[] variabl17332 = null;
private static String[][] variabl1431 = null;
private static String variabl2429 = "";
private static String variabl1873 = "";
private static int[][] variabl1885 = null;
private static JButton[] variabl2185 = new JButton[15];
public static String[] sw = new String[11];
static int variabl2851 = 0, variabl2339 = 0;
private static int variabl2833;
private static HashSet set01 = new HashSet();
public static String sd0;
static void means(String parameter[]) {
variabl26512 = 0;
variabl1739 = 0;
variabl1325 = "";
variabl13252 = "";
variabl18532 = 0;
variabl18531 = 0;
variabl1187 = "";
variabl1371 = 0;
variabl1153 = "";
variabl11532 = "";
s1 = "";
s2 = "";
b = 0;
c = 0;
variabl1843 = 0;
variabl1647 = 18;
variabl1849 = 20;
variabl1233 = 0;
variabl1077 = 0;
variabl1069 = 0;
variabl2607 = 9;
variabl2659 = 5;
variabl3681 = 0;
variabl1459 = 0;
variabl2483 = main1.variabl2483;
variabl24831 = 300;
variabl2503 = main1.variabl2503 - 100;
variabl1637 = 0;
variabl1745 = variabl2483;
variabl1315 = 0;
variabl1473 = 0;
variabl1925 = 0;
variabl2429 = "";
variabl1873 = "";
variabl2833 = 0;
list0 = new ArrayList<String>();
variabl1837 = new String[0][0];
username = main1.username;
variabl2339 = 0;
sw = new String[11];
sw[1] = main1.sw1 + "";
sw[2] = main1.sw2;
sw[3] = main1.sw3;
sw[4] = main1.sw4;
sw[5] = main1.sw5;
sw[6] = main1.sw6;
sw[7] = main1.sw7;
sw[8] = main1.sw8;
sw[10] = main1.sw10;
main1.sw1 = 0;
main1.sw2 = "";
main1.sw3 = "";
main1.sw4 = "";
main1.sw5 = "";
main1.sw6 = "";
main1.sw7 = "";
main1.sw8 = "";
main1.sw9 = "";
main1.sw10 = "";
String variabl240501[] = { "第一条", "下一条", "最后一条", "上一条", "浏览", "存盘",
"清屏", "修改存盘", "删除", "退出" };
variabl2405 = new String[variabl240501.length];
variabl2851 = 0;
for (int i0 = 0; i0 < variabl240501.length; i0++)
variabl2405[i0] = variabl240501[i0];
if (parameter[11].length() > 0) {
variabl1187 = parameter[11];
variabl1187 = variabl1187.replaceAll(";", ";");
variabl1187 = variabl1187.replaceAll("。", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
variabl1187 = variabl1187.replaceAll(":", ";");
if (variabl1187.indexOf(";") > 0) {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (s601[i01].indexOf(";") > 0) {
String s602[] = s601[i01].split(";");
variabl2405[Integer.parseInt((s602[0]))] = s602[1];
variabl1187 = variabl1187 + "," + s602[0];
} else {
variabl1187 = variabl1187 + "," + s601[i01];
}
}
} else {
String s601[] = variabl1187.split(",");
variabl1187 = "";
for (int i01 = 0; i01 < s601.length; i01++) {
if (i01 == 0)
variabl1187 = s601[i01];
else
variabl1187 = variabl1187 + "," + s601[i01];
}
}
} else {
variabl1187 = "";
for (int i1 = 0; i1 < variabl2405.length; i1++) {
if (i1 == 0)
variabl1187 = variabl1187 + i1;
else
variabl1187 = variabl1187 + "," + i1;
}
}
variabl1187 = "," + variabl1187 + ",";
variabl1187 = variabl1187.replaceAll(",,", ",");
variabl2851 = variabl2405.length;
variabl1885 = new int[variabl2851][15];
int m1, m2;
try {
if (parameter[17].length() == 0) {
m1 = 0;
m2 = 0;
} else {
m1 = Integer.parseInt(parameter[17]);
m2 = Integer.parseInt(parameter[18]);
}
if (m1 > 0) {
if (m2 < 80) {
m1 = m1 * 10;
m2 = m2 * 10;
}
variabl2483 = m1;
variabl1745 = m1;
variabl2503 = m2;
}
} catch (Exception e2) {
}
frame1 = new dataTenance7();
frame1.setTitle("主表数据记录");
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null);
panel2 = new JPanel(true);
frame2 = new dataTenance7();
frame2.setTitle("子表数据维护窗口 作者:程学先");
frame2.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame2.getContentPane().setLayout(null);
frame2.getContentPane().add(panel2, null);
list = new ArrayList<String>();
variabl1597 = main1.variabl1537 + main1.variabl1539;
variabl2185 = new JButton[20];
panel2.setLayout(null);
variabl2277 = parameter[2];
variabl2429 = "," + parameter[0] + ",";
variabl2603 = parameter[4];
String[] t1 = parameter[0].split(",");
variabl13252 = parameter[19];
String[] t2 = parameter[19].split(",");
variabl1873 = "";
if (variabl2429.lastIndexOf(variabl2603 + "字典表") >= 0)
for (int i = 0; i < t1.length; i++)
if (t1[i].lastIndexOf(variabl2603 + "字典表") >= 0) {
variabl1873 = t1[i];
variabl10091();
}
if (parameter[6].length() <= 0) {
JOptionPane.showMessageDialog(null, "缺少关键字,请说明关键字字段后再运行。");
return;
}
variabl1525 = parameter[6].split(",");
variabl2379 = parameter[7].split(",");
variabl1153 = parameter[8];
variabl11532 = parameter[9];
variabl2803 = "," + parameter[9] + ",";
variabl1287 = new int[variabl1525.length];
variabl2105 = new int[variabl2379.length];
variabl21050 = new int[variabl2379.length];
String variabl13250 = "";
if (variabl11532.length() > 0) {
String[] t3 = variabl11532.split(",");
for (int i = 0; i < t3.length; i++) {
if (i > 0)
variabl13250 = variabl13250 + ","
+ t2[Integer.parseInt(t3[i])];
else
variabl13250 = t2[Integer.parseInt(t3[i])];
}
variabl13252 = variabl13250;
for (int i = 0; i < variabl1525.length; i++)
if (("," + variabl13252 + ",").indexOf("," + variabl1525[i]
+ ",") < 0)
variabl13252 = variabl13252 + "," + variabl1525[i];
}
t2 = variabl13252.split(",");
variabl14672 = new int[t2.length];
variabl1651 = new String[t2.length][6];
variabl1323 = new String[t2.length][15];
variabl1885 = new int[variabl2851][15];
if (parameter[5].length() > 1) {
File file1 = new File(parameter[5]);
try {
if (file1.exists()) {
FileReader fr = new FileReader(file1);
BufferedReader br = new BufferedReader(fr);
String tempStr = null;
int d2 = 0;
int k3 = 0;
for (int i = 0; (tempStr = br.readLine()) != null; i++) {
if (tempStr.length() > 1)
list0.add(tempStr);
}
String sk = "";
for (int i = 0; i < list0.size(); i++) {
sk = list0.get(i);
if (d2 == 0) {
list.add(sk);
if (sk.substring(0, 2).equals("1,"))
variabl1233++;
if (sk.substring(0, 2).equals("2,"))
variabl1069++;
if (sk.substring(0, 2).equals("3,"))
variabl1077++;
}
}
variabl1371 = k3;
if (k3 > 0) {
variabl2833 = 1;
}
if (variabl1233 > 0) {
variabl1323 = new String[variabl1233][13];
variabl1651 = new String[variabl1233][6];
} else {
variabl1323 = new String[t2.length][13];
variabl1651 = new String[t2.length][6];
}
variabl1197 = new String[variabl1069][4];
variabl1201 = new String[variabl1077][6];
int m3 = 0;
m1 = 0;
m2 = 0;
int y = 2, n1 = 0;
String s = "";
s2 = ",";
variabl2483 = 0;
for (int i = 0; i < list.size(); i++) {
s = list.get(i);
if (d2 == 0) {
if (s.substring(0, 2).equals("1,")) {
variabl1323[m1] = s.substring(2, s.length())
.split("。");
variabl1323[m1][1] = "";
variabl1323[m1][2] = variabl1323[m1][5];
variabl1651[m1][0] = Integer
.parseInt(variabl1323[m1][3])
+ Integer.parseInt(variabl1323[m1][6])
+ "";
variabl1651[m1][1] = variabl1323[m1][7];
if (Integer.parseInt(variabl1323[m1][5])
+ Integer.parseInt(variabl1651[m1][1]) > variabl1459)
variabl1459 = Integer
.parseInt(variabl1323[m1][5])
+ Integer
.parseInt(variabl1651[m1][1]);
if (Integer.parseInt(variabl1323[m1][4])
+ Integer.parseInt(variabl1323[m1][6])
+ 80 > variabl2483)
variabl2483 = Integer
.parseInt(variabl1323[m1][4])
+ Integer
.parseInt(variabl1323[m1][6])
+ 80;
variabl1651[m1][2] = "";
variabl1651[m1][3] = "";
variabl1651[m1][4] = "";
s2 = s2 + variabl1323[m1][0] + ",";
m1++;
variabl1233 = m1;
} else if (s.substring(0, 2).equals("2,")) {
y = 2;
n1 = 0;
int n0 = 0;
String[] sf = s.split("。");
variabl1197[m2][0] = sf[0];
variabl1197[m2][1] = sf[1];
variabl1197[m2][2] = sf[2];
sf = variabl1197[m2][0].split(",");
variabl1197[m2][0] = sf[1];
if ((variabl1197[m2][0]
.equalsIgnoreCase(username))
&& (variabl1197[m2][2].length() > 0)
&& (variabl1197[m2][2].indexOf("a") < 0)
&& ((variabl1197[m2][1].length() == 0)
|| (variabl1197[m2][1]
.equals("*")) || (variabl1197[m2][1]
.toLowerCase()
.equalsIgnoreCase(variabl2603
.toLowerCase())))) {
if (variabl1197[m2][2].indexOf("i") < 0) {
variabl1187 = variabl1187.replaceAll(
"5,", "");
n0 = 1;
}
if (variabl1197[m2][2].indexOf("u") < 0) {
variabl1187 = variabl1187.replaceAll(
"7,", "");
n0 = 1;
}
if (variabl1197[m2][2].indexOf("d") < 0) {
variabl1187 = variabl1187.replaceAll(
"8,", "");
n0 = 1;
}
n0 = 1;
} else if ((variabl1197[m2][0]
.equalsIgnoreCase(username))
&& (variabl1197[m2][2].length() > 0)
&& (variabl1197[m2][2].indexOf("a") < 0)
&& (variabl1197[m2][2].indexOf("d") < 0)) {
variabl1187 = variabl1187.replaceAll("8,",
"");
n0 = 1;
} else if ((variabl1197[m2][0]
.equalsIgnoreCase(username))
&& (variabl1197[m2][2].length() > 0)
&& (variabl1197[m2][2].indexOf("a") < 0)
&& (variabl1197[m2][2].indexOf("i") < 0)
&& (variabl1197[m2][2].indexOf("u") < 0)) {
variabl1197[m2][0] = "只读";
variabl1197[m2][2] = "q,";
}
if (n0 == 0) {
m2++;
variabl1069 = m2;
}
} else if (s.substring(0, 2).equals("3,")) {
y = 2;
n1 = 0;
for (int k = 2; k < s.length(); k++)
if (s.substring(k, k + 1).equals("。")) {
variabl1201[m3][n1] = s.substring(y, k);
y = k + 1;
n1++;
}
variabl1201[m3][n1] = s
.substring(y, s.length());
if (variabl1201[m3][3].isEmpty())
variabl1201[m3][3] = "";
m3++;
variabl1077 = m3;
}
}
variabl14672 = new int[variabl1323.length];
variabl14192 = new String[variabl1323.length];
}
if (variabl1233 > 0) {
variabl13252 = "";
for (int i = 0; i < variabl1233; i++) {
if (i == 0)
variabl13252 = variabl1323[i][0];
else
variabl13252 = variabl13252 + ","
+ variabl1323[i][0];
}
}
}
} catch (IOException e2) {
JOptionPane.showMessageDialog(null, "打开文件错!");
}
} else {
variabl1323 = new String[t2.length][13];
variabl1651 = new String[t2.length][6];
variabl1197 = new String[0][4];
variabl1201 = new String[0][6];
variabl14672 = new int[t2.length];
variabl14192 = new String[t2.length];
}
for (int i = 0; i < variabl1069; i++) {
t2 = variabl13252.split(",");
for (int j = 0; j < t2.length; j++) {
if (variabl1197[i][1].toLowerCase()
.indexOf(t2[j].toLowerCase()) >= 0) {
if (variabl1197[i][0].equals("只读"))
variabl2803 = variabl2803 + j + ",";
variabl1197[i][1] = j + "";
}
}
}
if (variabl2483 == 0)
variabl2483 = variabl1745;
variabl1005(variabl2603);
variabl1009(variabl2603);
if (variabl1233 == 0)
variabl1037();
variabl2819002();
variabl2817002();
String sd = "";
for (int i0 = 0; i0 < variabl18532; i0++) {
sd = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++) {
if (variabl14672[i] == variabl1287[j]) {
if (variabl21972[i0][variabl14672[i]] == null) {
JOptionPane.showMessageDialog(null,
"存在关键字为空值的记录,请检查数据库中数据情况。");
return;
}
sd = sd + variabl21972[i0][variabl14672[i]].trim()
+ ",";
break;
}
}
}
set01.add(sd);
}
variabl2375 = new JButton(variabl2405[0]);
variabl2375.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl18531 = 0;
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") >= 0) {
String s3 = variabl21972[variabl18531][variabl14672[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
}
} else {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
if (!variabl1651[i][4].equals("列表框")) {
variabl17332[i]
.setText(variabl21972[variabl18531][variabl14672[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",")) >= 0)
if ((variabl17332[i].getText() == null)
|| (variabl17332[i].getText()
.trim().length() < 1))
variabl17332[i].setText("0");
}
}
}
variabl2325.setEnabled(true);
variabl2255.setEnabled(false);
}
});
if (variabl1885[0][0] > 0) {
variabl2375.setBounds(variabl1885[0][0], variabl1885[0][1],
variabl1885[0][2], variabl1885[0][3]);
panel2.add(variabl2375);
}
variabl2325 = new JButton(variabl2405[1]);
variabl2325.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl18531 < variabl18532 - 1) {
variabl18531++;
if (variabl18531 == variabl18532 - 1)
variabl2325.setEnabled(false);
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") >= 0) {
String s3 = variabl21972[variabl18531][variabl14672[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
} else {
byte[] c0 = {};
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
}
} else {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
if (!variabl1651[i][4].equals("列表框")) {
variabl17332[i]
.setText(variabl21972[variabl18531][variabl14672[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[i]]
+ ",")) >= 0)
if ((variabl17332[i].getText() == null)
|| (variabl17332[i].getText()
.trim().length() < 1))
variabl17332[i].setText("0");
}
}
}
}
variabl2255.setEnabled(true);
}
});
if (variabl1885[1][0] > 0) {
variabl2325.setBounds(variabl1885[1][0], variabl1885[1][1],
variabl1885[1][2], variabl1885[1][3]);
panel2.add(variabl2325);
}
variabl1971 = new JButton(variabl2405[2]);
variabl1971.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl18532 > 1)
variabl18531 = variabl18532 - 1;
else
variabl18531 = 0;
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") >= 0) {
String s3 = variabl21972[variabl18531][variabl14672[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
}
} else {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
if (!variabl1651[i][4].equals("列表框")) {
variabl17332[i]
.setText(variabl21972[variabl18531][variabl14672[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",")) >= 0)
if ((variabl17332[i].getText() == null)
|| (variabl17332[i].getText()
.trim().length() < 1))
variabl17332[i].setText("0");
}
}
}
variabl2325.setEnabled(false);
variabl2255.setEnabled(true);
}
});
if (variabl1885[2][0] > 0) {
variabl1971.setBounds(variabl1885[2][0], variabl1885[2][1],
variabl1885[2][2], variabl1885[2][3]);
panel2.add(variabl1971);
}
variabl2255 = new JButton(variabl2405[3]);
variabl2255.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
if (variabl18531 > 0) {
variabl18531--;
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") >= 0) {
String s3 = variabl21972[variabl18531][variabl14672[i]];
if ((s3 != null) && (s3.length() > 0)) {
byte[] c0 = new byte[s3.length()];
for (int j = 0; j < s3.length() - 1; j++) {
int n1 = Integer.parseInt(
s3.substring(j, j + 1), 16);
int n2 = Integer.parseInt(
s3.substring(j + 1, j + 2), 16);
c0[j / 2] = (byte) (n1 * 16 + n2);
j++;
}
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
} else {
byte[] c0 = { 0 };
Icon icon = new ImageIcon(c0);
variabl2165[i].setOpaque(true);
variabl2165[i].setBackground(Color.PINK);
variabl2165[i].setIcon(icon);
}
} else {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
if (!variabl1651[i][4].equals("列表框")) {
variabl17332[i]
.setText(variabl21972[variabl18531][variabl14672[i]]);
if ((main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[i]]
+ ",")) >= 0)
if ((variabl17332[i].getText() == null)
|| (variabl17332[i].getText()
.trim().length() < 1))
variabl17332[i].setText("0");
}
}
}
variabl2325.setEnabled(true);
} else
variabl2255.setEnabled(false);
}
});
if (variabl1885[3][0] > 0) {
variabl2255.setBounds(variabl1885[3][0], variabl1885[3][1],
variabl1885[3][2], variabl1885[3][3]);
panel2.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[variabl18532][variabl26512];
int[] n = new int[variabl14892.length];
for (int i = 0; i < variabl18532; i++)
for (int j = 0; j < variabl26512; j++) {
variabl1701[i][j] = variabl21972[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 < variabl26512; j++) {
n[j] = variabl14892[j];
if (n[j] > 50)
n[j] = 50;
}
tableTenance.tableModel(variabl2483, variabl2503,
variabl25172, n, variabl1701, variabl15012);
} else {
variabl2531.setText("浏览");
variabl18531 = main1.variabl1327;
for (int i = 0; i < variabl1843; i++) {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
variabl17332[i]
.setText(variabl21972[main1.variabl1327][variabl14672[i]]);
}
}
}
});
if (variabl1885[4][0] > 0) {
variabl2531.setBounds(variabl1885[4][0], variabl1885[4][1],
variabl1885[4][2], variabl1885[4][3]);
panel2.add(variabl2531);
}
variabl2611 = new JButton(variabl2405[5]);
variabl2611.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int[] x0 = new int[variabl1843];
String[] s0 = new String[variabl1843];
int b = 0;
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0) {
if ((variabl1651[i][4].equals("组合框"))
|| (variabl1651[i][4].equals("列表框"))) {
variabl1739 = i;
if (variabl1651[i][4].equals("组合框"))
variabl14192[i] = (String) variabl2359[variabl1739]
.getSelectedItem();
if (variabl14192[i] == null)
variabl14192[i] = " ";
} else {
variabl14192[i] = variabl17332[i].getText().trim();
if (variabl14192[i] == null) {
variabl14192[i] = " ";
variabl17332[i].setText(variabl15072[i]);
}
}
} else {
variabl14192[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 (variabl14672[i] == variabl1287[j]) {
if ((variabl14192[i] == null)
|| (variabl14192[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl14192[i].trim() + ",";
break;
}
}
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
set01.add(sd);
if (set01.size() == kd) {
JOptionPane.showMessageDialog(null, "关键字重复,请修改后重新生成!");
return;
}
set01.remove(sd);
sd0 = sd;
c = 0;
for (int i = 0; i < variabl1843; i++)
if (!variabl3623(c, i)) {
JOptionPane.showMessageDialog(null, i
+ "数据完整性检测出错,请检查!");
return;
}
cont4 = main1.getConn();
try {
variabl18532++;
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "insert into " + variabl2603 + "(";
for (int j = 0; j < variabl1843; j++) {
int a1 = 0;
for (int i = 0; i < variabl1069; i++) {
if ((variabl1197[i][1] != null)
&& (variabl1197[i][2] != null))
if ((("," + variabl1197[i][1] + ",")
.indexOf("," + j + ",") >= 0)
&& (variabl1197[i][2].indexOf("i") < 0))
a1 = 1;
}
if (a1 == 0)
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[j]] + ",") < 0)
s1 = s1 + variabl25172[variabl14672[j]] + ",";
}
s1 = s1.substring(0, s1.length() - 1) + ") VALUES (";
sd = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++) {
if (variabl14672[i] == variabl1287[j]) {
if ((variabl14192[i] == null)
|| (variabl14192[i].trim().length() == 0)) {
JOptionPane.showMessageDialog(null,
"存在关键字为空值的记录,请检查数据库中数据情况。");
return;
}
sd = sd + variabl14192[i].trim() + ",";
break;
}
}
}
s2 = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl17332.length; i++)
if (variabl14672[i] == variabl1287[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl15012[j] + ",") >= 0) {
if (variabl14192[i].length() < 1)
variabl14192[i] = "0";
s2 = s2 + variabl1525[j] + "="
+ variabl14192[i];
} else
s2 = s2 + variabl1525[j] + "='"
+ variabl14192[i].trim() + "'";
break;
}
if (j < variabl1525.length - 1)
s2 = s2 + " and ";
}
d1: for (int j = 0; j < variabl1843; j++) {
int a2 = 0;
for (int i = 0; i < variabl1069; i++) {
if ((variabl1197[i][1] != null)
&& (variabl1197[i][2] != null))
if ((("," + variabl1197[i][1] + ",")
.indexOf("," + j + ",") >= 0)
&& (variabl1197[i][2].indexOf("i") < 0)) {
a2 = 1;
continue d1;
}
}
if (main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[j]] + ",") >= 0) {
s1 = s1 + variabl14192[j] + ",";
} else if (variabl14192[j].trim().equals("?")) {
s0[b] = "update " + variabl2603 + " set "
+ variabl25172[variabl14672[j]] + " = ?"
+ " where " + s2;
x0[b] = j;
b++;
} else {
s1 = s1 + "'" + variabl14192[j].trim() + "',";
}
}
s1 = s1.substring(0, s1.length() - 1) + ")";
PreparedStatement pst4 = cont4.prepareStatement(s1);
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
variabl18532++;
set01.add(sd0);
for (int j = 0; j < variabl17332.length; j++) {
variabl21972[variabl18532][j] = "";
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
for (int i = 0; i < b; i++)
variabl4063(s0[i], x0[i]);
for (int i = 0; i < variabl1843; i++)
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
variabl17332[i].setText(variabl15072[i]);
}
});
if (variabl1885[5][0] > 0) {
variabl2611.setBounds(variabl1885[5][0], variabl1885[5][1],
variabl1885[5][2], variabl1885[5][3]);
panel2.add(variabl2611);
}
variabl2601 = new JButton(variabl2405[6]);
variabl2601.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++) {
if ((main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0))
variabl17332[i].setText(variabl15072[i]);
}
}
});
if (variabl1885[6][0] > 0) {
variabl2601.setBounds(variabl1885[6][0], variabl1885[6][1],
variabl1885[6][2], variabl1885[6][3]);
panel2.add(variabl2601);
}
variabl1697 = new JButton(variabl2405[7]);
variabl1697.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
c = 0;
for (int i = 0; i < variabl1843; i++)
if (!variabl3623(c, i)) {
JOptionPane.showMessageDialog(null, i
+ "数据完整性检测出错,请检查!");
return;
}
String[] s0 = new String[variabl1843];
int b = 0;
int[] x0 = new int[variabl1843];
for (int i = 0; i < variabl17332.length; i++)
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0) {
if ((variabl1651[i][4].equals("组合框"))
|| (variabl1651[i][4].equals("列表框"))) {
variabl1739 = i;
if (variabl1651[i][4].equals("组合框"))
variabl14192[i] = (String) variabl2359[variabl1739]
.getSelectedItem();
if (variabl14192[i] == null)
variabl14192[i] = " ";
} else {
variabl14192[i] = variabl17332[i].getText().trim();
if (variabl14192[i] == null) {
variabl14192[i] = " ";
variabl17332[i].setText(variabl15072[i]);
}
}
} else {
variabl14192[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 (variabl14672[i] == variabl1287[j]) {
if ((variabl14192[i] == null)
|| (variabl14192[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl14192[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
}
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null, "关键字不存在,请改为生成数据录入语句!");
set01.remove(sd);
return;
}
sd0 = sd;
s2 = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl17332.length; i++)
if (variabl14672[i] == variabl1287[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl15012[j] + ",") >= 0) {
if (variabl14192[i].length() < 1)
variabl14192[i] = "0";
s2 = s2 + variabl1525[j] + "="
+ variabl14192[i];
} else
s2 = s2 + variabl1525[j] + "='"
+ variabl14192[i].trim() + "'";
break;
}
if (j < variabl1525.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "update " + variabl2603 + " set ";
d2: for (int j = 0; j < variabl17332.length; j++) {
for (int i = 0; i < variabl1069; i++) {
if ((variabl1197[i][1] != null)
&& (variabl1197[i][2] != null))
if ((("," + variabl1197[i][1] + ",")
.indexOf("," + j + ",") >= 0)
&& (variabl1197[i][2].indexOf("u") < 0))
continue d2;
}
if (!variabl14192[j].trim().equals("?")) {
s1 = s1 + variabl25172[variabl14672[j]] + "=";
if (main1.variabl1545.lastIndexOf(","
+ variabl15012[variabl14672[j]] + ",") >= 0)
s1 = s1 + variabl14192[j];
else
s1 = s1 + "'" + variabl14192[j].trim() + "'";
s1 = s1 + ",";
} else {
s0[b] = "update " + variabl2603 + " set "
+ variabl25172[variabl14672[j]]
+ "=? where " + s2;
x0[b] = j;
b++;
}
}
s1 = s1.substring(0, s1.length() - 1) + " where " + s2;
PreparedStatement pst4 = cont4.prepareStatement(s1);
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
for (int k = 0; k < variabl17332.length; k++) {
variabl21972[variabl18531][variabl14672[k]] = variabl14192[k];
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
for (int i = 0; i < b; i++)
variabl4063(s0[i], x0[i]);
}
});
if (variabl1885[7][0] > 0) {
variabl1697.setBounds(variabl1885[7][0], variabl1885[7][1],
variabl1885[7][2], variabl1885[7][3]);
panel2.add(variabl1697);
}
variabl2633 = new JButton(variabl2405[8]);
variabl2633.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
for (int i = 0; i < variabl1843; i++) {
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0)
variabl14192[i] = variabl17332[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 (variabl14672[i] == variabl1287[j]) {
if ((variabl14192[i] == null)
|| (variabl14192[i].trim().length() == 0))
kd0 = 1;
sd = sd + variabl14192[i].trim() + ",";
break;
}
if (kd0 == 1) {
JOptionPane.showMessageDialog(null, "关键字不全,请修改后重新生成!");
return;
}
}
if (set01.size() != kd) {
JOptionPane.showMessageDialog(null, "关键字不存在,请修改后重新生成!");
set01.remove(sd);
return;
}
sd0 = sd;
s2 = "";
for (int j = 0; j < variabl1525.length; j++) {
for (int i = 0; i < variabl1843; i++)
if (variabl14672[i] == variabl1287[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl15012[j] + ",") >= 0)
s2 = s2 + variabl1525[j] + "="
+ variabl14192[i];
else
s2 = s2 + variabl1525[j] + "='"
+ variabl14192[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 == variabl18532 - 1)
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0)
variabl17332[i].setText(variabl15072[i]);
else if (main1.variabl1539.lastIndexOf(","
+ variabl15012[variabl14672[i]] + ",") < 0) {
variabl17332[i]
.setText(variabl21972[variabl18531][variabl14672[i]]);
}
}
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
});
if (variabl1885[8][0] > 0) {
variabl2633.setBounds(variabl1885[8][0], variabl1885[8][1],
variabl1885[8][2], variabl1885[8][3]);
panel2.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);
panel2.setVisible(false);
frame2.setVisible(false);
frame2.dispose();
}
});
if (variabl1885[9][0] > 0) {
variabl2599.setBounds(variabl1885[9][0], variabl1885[9][1],
variabl1885[9][2], variabl1885[9][3]);
panel2.add(variabl2599);
}
if ((sw[3].length() > 0) && (sw[4].length() > 0))
for (int i = 0; i < variabl1843; i++) {
variabl17332[i].setText(variabl21972[0][variabl14672[i]]);
}
if (variabl2503 - variabl1459 - variabl1637 - 100 < 0)
variabl2503 = variabl1459 + variabl1637 + 100;
int w1, h1;
if (1200 - variabl2483 > 0)
w1 = (1000 - variabl2483) / 2;
else
w1 = 0;
if (600 - variabl2503 > 0)
h1 = (600 - variabl2503) / 2;
else
h1 = 0;
if (variabl2503 < variabl1459 + 20)
variabl2503 = variabl1459 + 20;
panel2.setBounds(10, 10, variabl2483 - 10, variabl2503 - 20);
frame2.setBounds(w1 + 300, h1 + 100, variabl2483, variabl2503);
frame2.setVisible(true);
variabl1965 = new DefaultTableModel(variabl2197, variabl25170);
variabl2655 = new JTable(variabl1965);
variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
variabl2655
.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
int w0 = 0;
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = variabl2655.getColumn(variabl25170[i]);
JTableHeader header = variabl2655.getTableHeader();
tc.setPreferredWidth(variabl1489[i] * 10);
tc.setMaxWidth(variabl1489[i] * 10);
tc.sizeWidthToFit();
w0 = w0 + variabl1489[i] * 10;
if (w0 > variabl24831)
break;
}
variabl2655.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
int variabl1823 = variabl2655.getSelectedRow();
for (int i = 0; i < variabl2105.length; i++) {
variabl2359[variabl2105[i]]
.setSelectedItem(variabl2197[variabl1823][variabl21050[i]]);
}
}
});
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(10, 10, 300, variabl2503 - 260);
scrollPane.setViewportView(variabl2655);
frame1.add(scrollPane, BorderLayout.CENTER);
frame1.setBounds(10, 10, 350, variabl2503 - 100);
frame1.setVisible(true);
JButton variabl26330 = new JButton("删除当前记录");
variabl26330.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int variabl1823 = variabl2655.getSelectedRow();
s2 = "";
for (int j = 0; j < variabl2379.length; j++) {
for (int i = 0; i < variabl2517.length; i++)
if (i == variabl21050[j]) {
if (main1.variabl1545.lastIndexOf(","
+ variabl1501[i] + ",") >= 0)
s2 = s2
+ variabl2379[j]
+ "="
+ variabl1965
.getValueAt(variabl1823, i)
.toString();
else
s2 = s2
+ variabl2379[j]
+ "='"
+ variabl1965
.getValueAt(variabl1823, i)
.toString() + "'";
break;
}
if (j < variabl2379.length - 1)
s2 = s2 + " and ";
}
cont4 = main1.getConn();
if (JOptionPane.showConfirmDialog(null, "是否删除子表中相关记录?") == 0) {
try {
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2603 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "delete from " + variabl2277 + " where " + s2;
stat4.executeUpdate(s1);
stat4.close();
cont4.close();
deleteData(variabl18531);
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "SQL语句错!" + s1);
}
}
});
variabl26330.setBounds(10, variabl2503 - 200, 150, 20);
frame1.add(variabl26330);
JButton variabl25990 = new JButton("退出");
variabl25990.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
frame1.setVisible(false);
frame1.dispose();
frame2.dispose();
frame2.setVisible(false);
frame2.dispose();
}
});
variabl25990.setBounds(160, variabl2503 - 200, 150, 20);
frame1.add(variabl25990);
}
static void variabl1037() {
if (variabl1233 > 0)
return;
int variabl1637 = 0;
int variabl3681 = 10;
variabl1233 = variabl26512;
variabl1315 = variabl2483 - 80;
variabl1459 = 20;
int y1 = variabl3681;
int y2 = variabl1459;
int variabl1159 = 0;
if ((variabl1473 == 0)
&& (variabl26512 * variabl1849 < variabl2503 - 120)) {
variabl1637 = (variabl2503 - 150 - variabl26512 * variabl1849)
/ (variabl26512 + 1);
for (int j = 0; j < variabl26512; j++)
if (variabl1323[j][1].length() > variabl1159)
variabl1159 = variabl1323[j][1].length();
for (int j = 0; j < variabl26512; j++) {
variabl1323[j][6] = y1 + "";
variabl1323[j][7] = y2 + "";
variabl1323[j][3] = variabl1159 * variabl1647 + "";
variabl1323[j][2] = variabl1849 + "";
variabl1651[j][0] = (y1 + variabl1159 * variabl1647) + "";
variabl1651[j][1] = y2 + "";
variabl1323[j][4] = (variabl1315 - Integer
.parseInt(variabl1651[j][0])) + "";
variabl1323[j][5] = variabl1849 + "";
variabl1323[j][8] = "宋体";
variabl1323[j][9] = "10";
variabl1323[j][10] = "5";
variabl1651[j][2] = "2";
y2 = y2 + variabl1849 + variabl1637;
variabl1459 = y2;
}
} else {
y1 = variabl3681;
y2 = variabl1459;
int variabl1327 = 1;
for (int j = 0; j < variabl26512; j++) {
variabl1925 = variabl1323[j][1].length();
if (variabl1597.lastIndexOf("," + variabl15012[j] + ",") < 0) {
if ((y1 + (variabl1925 + variabl14892[j]) * variabl1647) > variabl1315) {
variabl1327++;
y1 = variabl3681;
y2 = y2 + variabl1849;
}
variabl1323[j][6] = y1 + "";
variabl1323[j][7] = y2 + "";
variabl1323[j][3] = variabl1925 * variabl1647 + "";
if ((y1 == variabl3681) && (variabl1925 > variabl1159))
variabl1159 = variabl1925;
variabl1323[j][2] = variabl1849 + "";
variabl1651[j][0] = (y1 + variabl1925 * variabl1647) + "";
variabl1651[j][1] = y2 + "";
variabl1323[j][4] = variabl14892[j] * variabl1647 + "";
variabl1323[j][5] = variabl1849 + "";
variabl1323[j][8] = "宋体";
variabl1323[j][9] = "10";
variabl1323[j][10] = "5";
variabl1651[j][2] = "2";
y1 = y1 + variabl1925 * variabl1647 + variabl14892[j]
* variabl1647;
}
}
if (variabl1473 == 0)
variabl1637 = (variabl2503 - 150) / (variabl1327 + 1)
- variabl1849;
else
variabl1637 = 0;
if (variabl1637 < 0)
variabl1637 = 0;
int z = 0;
int z1 = 0;
int z3 = 0;
for (int j = 0; j < variabl26512; j++) {
if (variabl1597.lastIndexOf("," + variabl15012[j] + ",") < 0) {
if (Integer.parseInt(variabl1323[j][6]) == variabl3681) {
z = variabl1159 * variabl1647
- Integer.parseInt(variabl1323[j][3]);
z1 = z1 + variabl1637;
if (j > 0)
variabl1323[z3][4] = (variabl1315 - Integer
.parseInt(variabl1651[z3][0])) + "";
}
variabl1323[j][6] = (Integer.parseInt(variabl1323[j][6]) + z)
+ "";
variabl1651[j][0] = (Integer.parseInt(variabl1651[j][0]) + z)
+ "";
variabl1323[j][7] = (Integer.parseInt(variabl1323[j][7]) + z1)
+ "";
variabl1651[j][1] = (Integer.parseInt(variabl1651[j][1]) + z1)
+ "";
y2 = Integer.parseInt(variabl1651[j][1]);
z3 = j;
}
}
variabl1323[z3][4] = (variabl1315 - Integer
.parseInt(variabl1651[z3][0])) + "";
variabl1459 = y2;
if (variabl1473 > 0) {
y2 = y2 + variabl1849;
int z2 = (variabl2503 - y2 - 120) / variabl1473;
for (int i3 = 0; i3 < variabl26512; i3++) {
if (variabl1597.lastIndexOf("," + variabl15012[i3] + ",") >= 0) {
variabl1323[i3][6] = variabl3681 + "";
variabl1323[i3][7] = y2 + "";
variabl1323[i3][3] = variabl1159 * variabl1647 + "";
variabl1323[i3][2] = variabl1849 + "";
variabl1651[i3][0] = (variabl3681 + variabl1159
* variabl1647)
+ "";
variabl1651[i3][1] = y2 + "";
y2 = y2 + z2;
variabl1323[i3][4] = (variabl1315 - variabl1159
* variabl1647)
+ "";
variabl1323[i3][5] = z2 + "";
variabl1323[i3][8] = "宋体";
variabl1323[i3][9] = "10";
variabl1323[i3][10] = "5";
variabl1651[i3][2] = "2";
if (main1.variabl1539.lastIndexOf(","
+ variabl15012[i3] + ",") >= 0)
variabl1651[i3][4] = "图像字段";
else
variabl1651[i3][4] = "文本字段";
}
}
variabl1459 = y2 + variabl1849;
}
}
variabl1459 = y2 + variabl1849;
}
static void variabl2819002() {
if (variabl2833 > 0)
return;
String[] t5 = variabl1187.split(",");
variabl1371 = t5.length - 1;
variabl1885 = new int[variabl2851][15];
for (int j = 0; j < variabl2851; j++) {
variabl1885[j][0] = 0;
variabl1885[j][1] = 0;
variabl1885[j][2] = 0;
variabl1885[j][3] = 0;
}
int variabl1629;
variabl1629 = (int) (variabl1647 * 6.3);
variabl3681 = 20;
if (variabl1473 == 0)
variabl1459 = variabl1459 + variabl1849 * 2;
else
variabl1459 = variabl1459 + variabl1849;
int variabl1505 = (variabl2483 - 100) / (int) (6.6 * variabl1647);
if (variabl1505 < 1)
variabl1505 = 1;
if (variabl1371 <= variabl1505)
variabl1629 = (variabl2483 - 100) / variabl1371;
else
variabl1629 = (variabl2483 - 100) / variabl1505;
int n = 0, n1 = 0, n3 = 0;
n3 = variabl1505 * variabl1629;
for (int j = 0; j < variabl2851; j++) {
if (variabl1187.lastIndexOf("," + j + ",") >= 0) {
variabl1885[j][0] = variabl3681;
variabl1885[j][1] = variabl1459;
if (variabl2405[j].length() > 4) {
variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 1.2));
n3 = n3 + variabl1885[j][2] - variabl1629;
variabl3681 = variabl3681 + variabl1885[j][2];
} else {
variabl1885[j][2] = variabl1629;
variabl3681 = variabl3681 + variabl1629;
}
variabl1885[j][3] = variabl1849;
n++;
n1++;
if (variabl1371 - n1 == 0)
break;
if ((n >= variabl1505)
&& ((variabl1371 - n1) - variabl1505 != 0)) {
variabl3681 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
if ((variabl1371 - n1) <= variabl1505)
variabl1629 = (variabl2483 - 100) / (variabl1371 - n1);
else
variabl1629 = (variabl2483 - 100) / variabl1505;
n = 0;
} else if (n >= variabl1505) {
variabl3681 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
n = 0;
}
}
}
variabl2503 = variabl1459 + variabl1849 + 100;
}
static void variabl1005(String variabl1103) {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + variabl13252 + " from " + variabl1103;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
variabl26512 = rsmdt4.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
variabl15072 = new String[variabl26512];
variabl1473 = 0;
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmdt4.getColumnName(i + 1);
variabl14892[i] = rsmdt4.getColumnDisplaySize(i + 1);
variabl15012[i] = rsmdt4.getColumnTypeName(i + 1);
if (variabl1651[i][3] == null)
variabl1651[i][3] = "";
if (variabl1651[i][4] == null)
variabl1651[i][4] = "";
if ((variabl1651[i][3].length() < 1)
&& ((variabl2429.lastIndexOf("," + variabl25172[i]
+ "表,") >= 0) && (variabl25172[i].indexOf("代码") >= 0))) {
variabl1651[i][3] = variabl25172[i] + "表";
variabl1651[i][4] = "组合框";
variabl14892[i] = variabl14892[i] + 10;
} else if ((variabl1651[i][3].length() < 1)
&& ((variabl2429.lastIndexOf("," + variabl25172[i]
+ "代码表,") >= 0) && (variabl25172[i]
.indexOf("代码") < 0))) {
variabl1651[i][3] = variabl25172[i] + "代码表";
variabl1651[i][4] = "组合框";
variabl14892[i] = variabl14892[i] + 10;
}
variabl1323[i][0] = variabl25172[i];
if ((variabl1323[i][1]) == null
|| (variabl1323[i][1].length() != 0))
for (int j = 0; j < variabl1837.length; j++) {
if (variabl25172[i].toLowerCase().equalsIgnoreCase(
variabl1837[j][0].toLowerCase()))
variabl1323[i][1] = variabl1837[j][1];
else if (variabl25172[i].toLowerCase()
.equalsIgnoreCase(
variabl1837[j][1].toLowerCase()))
variabl1323[i][1] = variabl1837[j][0];
}
if ((variabl1323[i][1]) == null
|| (variabl1323[i][1].length() == 0))
variabl1323[i][1] = variabl25172[i];
if (variabl1651[i][4].length() < 1)
if (main1.variabl1537.indexOf("," + variabl15012[i] + ",") >= 0) {
variabl1651[i][4] = "文本字段";
variabl1473++;
} else if (variabl15012[i].equalsIgnoreCase("image")) {
variabl1651[i][4] = "图像字段";
variabl1473++;
} else
variabl1651[i][4] = "普通字段";
if (variabl15012[i].indexOf("datetime") == 0)
variabl15072[i] = "2001-01-01 00:00:00.000";
else if (variabl15012[i].indexOf("smalldatetime") == 0)
variabl15072[i] = "2001-01-01 00:00:00";
else if (variabl15012[i].indexOf("datetime2") == 0)
variabl15072[i] = "2001-01-01 00:00:00.0000000";
else if (variabl15012[i].indexOf("datetimeoffset") == 0)
variabl15072[i] = "2001-01-01 00:00:00.0000000 +08:00";
else if (variabl15012[i].indexOf("date") == 0)
variabl15072[i] = "2001-01-01";
else if (variabl15012[i].indexOf("time") == 0)
variabl15072[i] = "00:00:00";
else if (variabl15012[i].indexOf("money") >= 0)
variabl15072[i] = "0.0000";
else if (main1.variabl1541.lastIndexOf("," + variabl15012[i]
+ ",") >= 0)
variabl15072[i] = "0.00";
else if (main1.variabl1545.lastIndexOf("," + variabl15012[i]
+ ",") >= 0)
variabl15072[i] = "0";
else
variabl15072[i] = "";
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
variabl15932 = ",";
variabl1325 = "";
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select * from " + variabl2277;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
variabl2651 = rsmdt4.getColumnCount();
variabl2517 = new String[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmdt4.getColumnName(i + 1);
if ((variabl1153.trim().length() > 0)
&& (("," + variabl1153 + ",").indexOf("," + i + ",") >= 0))
variabl1325 = variabl1325 + variabl2517[i] + ",";
else if (variabl1153.trim().length() == 0)
variabl1325 = variabl1325 + variabl2517[i] + ",";
}
variabl1325 = variabl1325.substring(0, variabl1325.length() - 1);
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + variabl1325 + " from " + variabl2277;
rs = stat4.executeQuery(s1);
rsmdt4 = rs.getMetaData();
variabl2651 = rsmdt4.getColumnCount();
variabl2517 = new String[variabl2651];
variabl25170 = new String[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmdt4.getColumnName(i + 1);
variabl25170[i] = variabl2517[i];
variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);
variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
for (int i = 0; i < variabl1837.length; i++) {
for (int j = 0; j < variabl2517.length; j++) {
if (variabl2517[j].equals(variabl1837[i][0]))
variabl25170[j] = variabl1837[i][1];
else if (variabl2517[j].equals(variabl1837[i][1]))
variabl25170[j] = variabl1837[i][0];
}
}
for (int j = 0; j < variabl2517.length; j++) {
for (int i = 0; i < variabl1837.length; i++) {
if (variabl2517[j].equals(variabl1837[i][0]))
variabl25170[j] = variabl1837[i][1];
else if (variabl2517[j].equals(variabl1837[i][1]))
variabl25170[j] = variabl1837[i][0];
}
}
for (int i1 = 0; i1 < variabl2517.length; i1++) {
for (int j1 = 0; j1 < variabl2379.length; j1++)
if (variabl2517[i1].toLowerCase().trim()
.equals(variabl2379[j1].toLowerCase().trim()))
variabl21050[j1] = i1;
}
variabl21051 = new int[variabl25172.length];
for (int i1 = 0; i1 < variabl25172.length; i1++) {
for (int j1 = 0; j1 < variabl1525.length; j1++) {
if (variabl25172[i1].toLowerCase().trim()
.equals(variabl1525[j1].toLowerCase().trim()))
variabl1287[j1] = i1;
}
for (int j1 = 0; j1 < variabl2379.length; j1++) {
if (variabl25172[i1].toLowerCase().trim()
.equals(variabl2379[j1].toLowerCase().trim())) {
variabl2105[j1] = i1;
variabl15932 = variabl15932 + i1 + ",";
}
}
}
for (int i1 = 0; i1 < variabl25172.length; i1++) {
for (int j1 = 0; j1 < variabl2379.length; j1++) {
if (variabl25172[i1].toLowerCase().trim()
.equals(variabl2379[j1].toLowerCase().trim()))
for (int i2 = 0; i2 < variabl2517.length; i2++) {
if (variabl2517[i2].toLowerCase().trim()
.equals(variabl2379[j1].toLowerCase().trim()))
variabl21051[i1] = i2;
}
}
}
}
static void variabl1009(String variabl1103) {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
String s1 = "select " + variabl13252 + " from " + variabl1103;
if ((sw[3].length() > 0) && (sw[4].length() > 0))
s1 = s1 + " where " + sw[4] + " = '" + sw[5] + "'";
rs = stat4.executeQuery(s1);
rs.last();
variabl18532 = rs.getRow();
String[][] variabl21970 = new String[variabl18532][variabl26512];
variabl21972 = new String[variabl18532 + 300][variabl26512];
rsmdt4 = rs.getMetaData();
int c = 0;
int b = 0;
while (c < variabl18532) {
rs.absolute(c + 1);
while (b < variabl26512) {
variabl21970[c][b] = rs.getString(b + 1);
variabl21972[c][b] = variabl21970[c][b];
b++;
}
c++;
b = 0;
}
rs.absolute(1);
rs.close();
stat4.close();
cont4.close();
for (int i = 0; i < variabl18532; i++)
for (int j = 0; j < variabl26512; j++)
variabl21972[i][j] = variabl21970[i][j];
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!");
}
cont4 = main1.getConn();
try {
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select " + variabl1325 + " from " + variabl2277;
ResultSet rs = stat4.executeQuery(s1);
rs.last();
variabl1853 = rs.getRow();
variabl2197 = new String[variabl1853][variabl2651];
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl2197[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
} catch (Exception e) {
e.printStackTrace();
}
}
static void variabl10091() {
int variabl18535 = 0;
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);
rs.last();
variabl18535 = rs.getRow();
variabl1837 = new String[variabl18535][2];
rs.absolute(1);
String s4 = "";
String s5 = "";
for (int i = 1; i <= variabl18535; i++) {
rs.absolute(i);
s4 = rs.getString(1).trim();
variabl1837[i - 1][0] = s4;
s5 = rs.getString(2).trim();
variabl1837[i - 1][1] = s5;
}
rs.close();
stat4.close();
cont4.close();
}
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!");
}
}
static void variabl10092(String variabl22330, String variabl25179, int j9) {
try {
if (variabl25179.indexOf("代码") >= 0) {
s2 = variabl25179.substring(0, variabl25179.length() - 2);
s1 = "select " + variabl25179 + "," + s2 + " from "
+ variabl22330;
} else if (variabl2429.lastIndexOf("," + variabl25179 + "代码表,") >= 0) {
s2 = variabl25179.substring(0, variabl25179.length() - 2);
s1 = "select " + variabl25179 + "," + variabl25179 + "代码"
+ " from " + variabl25179 + "代码表";
}
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
rs = stat4.executeQuery(s1);
rs.last();
int numberOfColumns = rs.getRow();
rs.beforeFirst();
variabl1431[j9] = new String[numberOfColumns];
for (int i = 1; i <= numberOfColumns; i++) {
rs.absolute(i);
variabl1431[j9][i - 1] = rs.getString(1).trim();
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e3) {
JOptionPane.showMessageDialog(null, "读取数据库数据出错!" + s1);
}
}
static void variabl2817002() {
variabl2403 = new JTextField[variabl1233];
variabl2463 = new JTextArea[variabl1233];
variabl2165 = new JLabel[variabl1233];
variabl2359 = new JComboBox[variabl1233];
variabl17332 = new JTextComponent[variabl1233];
variabl14672 = new int[variabl1233];
variabl1431 = new String[variabl1233][2];
variabl1843 = variabl1233;
for (int j = 0; j < variabl1843; j++) {
JLabel variabl2533 = new JLabel(variabl1323[j][1], 11);
variabl2533.setBounds(Integer.parseInt(variabl1323[j][6]),
Integer.parseInt(variabl1323[j][7]),
Integer.parseInt(variabl1323[j][3]),
Integer.parseInt(variabl1323[j][2]));
Font font = new Font(variabl1323[j][8], Font.BOLD,
Integer.parseInt(variabl1323[j][9]));
String s01 = variabl1323[j][10];
int s02 = 5;
if ((s01 != null) && (s01.length() > 0)
&& (s01.compareTo("0") >= 0) && (s01.compareTo("9") <= 0))
s02 = Integer.parseInt(s01);
variabl2533.setFont(font);
color1(s02, variabl2533);
panel2.add(variabl2533);
if ((variabl1651[j][4].equals("普通字段"))
&& ((variabl15932.indexOf("," + j + ",") < 0))) {
variabl2403[j] = new JTextField("");
variabl2403[j].setBounds(Integer.parseInt(variabl1651[j][0]),
Integer.parseInt(variabl1651[j][1]),
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
Font font1 = new Font(variabl1323[j][8], Font.BOLD,
Integer.parseInt(variabl1323[j][9]));
String s011 = variabl1323[j][10];
int s021 = 5;
if ((s011 != null) && (s011.length() > 0)
&& (s011.compareTo("0") >= 0)
&& (s011.compareTo("9") <= 0))
s021 = Integer.parseInt(s011);
variabl2403[j].setFont(font1);
color2(s021, variabl2403[j]);
if (variabl2803.indexOf("," + j + ",") >= 0) {
variabl2403[j].setEditable(false);
}
panel2.add((Component) variabl2403[j]);
variabl2403[j].addMouseListener(new MouseAdapter() {
public void mousePressed(MouseEvent arg0) {
c = 0;
}
});
variabl2403[j].addFocusListener(new FocusAdapter() {
public void focusGained(final FocusEvent arg0) {
Object s0 = arg0.getSource();
String s1 = s0.toString();
String s2 = "";
for (int i = 0; i < variabl1843; i++) {
s2 = "[," + variabl1651[i][0].trim() + ","
+ variabl1651[i][1].trim() + ",";
if (s1.indexOf(s2) > 0) {
b = i;
break;
}
}
}
public void focusLost(final FocusEvent arg1) {
if (c > 0)
return;
Object s0 = arg1.getSource();
String s1 = s0.toString().substring(10, 33);
String s2 = "";
for (int i = 0; i < variabl1843; i++) {
s2 = "[," + variabl1651[i][0].trim() + ","
+ variabl1651[i][1].trim() + ",";
if (s1.indexOf(s2) > 0) {
b = i;
break;
}
}
if ((c == 0) && (!variabl3623(c, b))) {
variabl2403[c].requestFocus(true);
return;
}
}
});
variabl2403[j].setText(variabl15072[j]);
variabl17332[j] = (JTextComponent) variabl2403[j];
variabl14672[j] = j;
} else if (variabl1651[j][4].equals("文本字段")) {
variabl2463[j] = new JTextArea(" ",
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
JScrollPane variabl1147 = new JScrollPane(variabl2463[j]);
variabl1147.setBounds(Integer.parseInt(variabl1651[j][0]),
Integer.parseInt(variabl1651[j][1]),
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
Font font1 = new Font(variabl1323[j][8], Font.BOLD,
Integer.parseInt(variabl1323[j][9]));
String s011 = variabl1323[j][10];
int s021 = 5;
if ((s011 != null) && (s011.length() > 0)
&& (s011.compareTo("0") >= 0)
&& (s011.compareTo("9") <= 0))
s021 = Integer.parseInt(s011);
variabl2463[j].setFont(font1);
color3(s021, variabl2463[j]);
panel2.add((Component) variabl1147);
variabl2463[j].setText(variabl15072[j]);
variabl17332[j] = (JTextComponent) variabl2463[j];
variabl14672[j] = j;
} else if (variabl1651[j][4].equals("图像字段")) {
JLabel variabl2407 = new JLabel(" ");
variabl2407.setBackground(Color.BLUE);
variabl2407.setBounds(Integer.parseInt(variabl1651[j][0]),
Integer.parseInt(variabl1651[j][1]),
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
panel2.add(new JScrollPane(variabl2407));
panel2.add(variabl2407);
variabl2165[j] = variabl2407;
variabl17332[j] = (JTextComponent) variabl2463[j];
variabl14672[j] = j;
} else if (variabl1651[j][4].equals("组合框")) {
variabl2359[j] = new JComboBox();
variabl2403[j] = new JTextField();
variabl2359[j].setEditable(true);
variabl2359[j].setEnabled(true);
panel2.add((Component) variabl2359[j]);
variabl2359[j].setBounds(Integer.parseInt(variabl1651[j][0]),
Integer.parseInt(variabl1651[j][1]),
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
variabl10092(variabl1651[j][3], variabl1323[j][0], j);
for (int i = 0; i < variabl1431[j].length; i++) {
variabl2359[j].addItem(variabl1431[j][i]);
}
variabl17332[j] = (JTextComponent) variabl2359[j].getEditor()
.getEditorComponent();
variabl17332[j].setText("");
variabl14672[j] = j;
} else if (variabl15932.indexOf("," + j + ",") >= 0) {
variabl2359[j] = new JComboBox();
variabl2403[j] = new JTextField();
variabl2359[j].setEditable(false);
variabl2359[j].setEnabled(true);
panel2.add((Component) variabl2359[j]);
variabl2359[j].setBounds(Integer.parseInt(variabl1651[j][0]),
Integer.parseInt(variabl1651[j][1]),
Integer.parseInt(variabl1323[j][4]),
Integer.parseInt(variabl1323[j][5]));
for (int i = 0; i < variabl2197.length; i++) {
variabl2359[j].addItem(variabl2197[i][variabl21051[j]]);
}
variabl17332[j] = (JTextComponent) variabl2359[j].getEditor()
.getEditorComponent();
variabl17332[j].setText("");
variabl14672[j] = j;
variabl2359[j].addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent event) {
int b0 = 0;
String s0 = "";
String s10 = event.toString();
for (int i = 0; i < variabl1843; i++) {
s0 = "[," + variabl1651[i][0].trim() + ","
+ variabl1651[i][1].trim() + ",";
if (s10.indexOf(s0) > 0) {
b0 = i;
break;
}
}
for (int i = 0; i < variabl2105.length; i++) {
if (variabl2105[i] != b0)
variabl2359[variabl2105[i]]
.setSelectedIndex(variabl2359[b0]
.getSelectedIndex());
variabl2655.editCellAt(
variabl2359[b0].getSelectedIndex(),
variabl21051[b0]);
}
}
});
}
}
}
public static void deleteData(int pos) {
if (pos == variabl18532 - 1)
variabl18531--;
for (int i = pos; i < variabl18532 - 1; i++) {
for (int j = 0; j < variabl1843 - 1; j++) {
variabl21972[i][j] = variabl21972[i + 1][j];
}
}
variabl18532--;
}
static void color1(int c, JLabel fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
static void color2(int c, JTextField fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
static void color3(int c, JTextArea fl) {
switch (c) {
case 1:
fl.setForeground(Color.red);
break;
case 2:
fl.setForeground(Color.blue);
break;
case 3:
fl.setForeground(Color.green);
break;
case 4:
fl.setForeground(Color.white);
break;
case 5:
fl.setForeground(Color.black);
break;
case 6:
fl.setForeground(Color.darkGray);
break;
case 7:
fl.setForeground(Color.cyan);
break;
case 8:
fl.setForeground(Color.yellow);
break;
case 9:
fl.setForeground(Color.gray);
break;
case 10:
fl.setForeground(Color.lightGray);
break;
case 11:
fl.setForeground(Color.magenta);
break;
case 12:
fl.setForeground(Color.orange);
break;
}
}
public static void variabl4063(String s0, int k) {
for (int i = 0; i < variabl17332.length; i++)
cont4 = main1.getConn();
try {
PreparedStatement pst4 = cont4.prepareStatement(s0);
int k2 = 1;
String s5 = "";
final JFileChooser fc = new JFileChooser(".\\");
fc.showDialog(new JLabel(), "请选择图片字段"
+ variabl25172[variabl14672[k]] + "的文件名");
if (fc.getSelectedFile() != null)
s5 = fc.getSelectedFile().toString();
else {
JOptionPane.showMessageDialog(null, "未选择图片文件,原图不变!");
return;
}
FileInputStream f1 = new FileInputStream(s5);
pst4.setBinaryStream(k2, f1, f1.available());
k2++;
pst4.execute();
pst4.close();
stat4.close();
cont4.close();
byte[] c0 = new byte[s5.length()];
Icon icon = new ImageIcon(c0);
variabl2165[k].setOpaque(true);
variabl2165[k].setBackground(Color.PINK);
variabl2165[k].setIcon(icon);
} catch (SQLException e2) {
JOptionPane.showMessageDialog(null, "修改语句错!" + s1);
} catch (IOException e3) {
JOptionPane.showMessageDialog(null, "文件读取出错!");
}
}
public static boolean variabl3623(int c1, int b1) {
c = c1;
b = b1;
int bz1 = 0;
String sb = "", bz = "";
String[] sb1 = null;
try {
for (int i1 = 0; i1 < variabl1077; i1++) {
if (variabl1201[i1][0].toLowerCase().trim()
.equals(variabl1323[b][0].toLowerCase().trim())) {
bz1 = main1.variabl1545.indexOf(","
+ variabl15012[variabl14672[b]] + ",");
if (bz1 >= 0) {
if ((variabl1201[i1][1].trim().length() > 0)
&& (Double
.parseDouble(variabl2403[b].getText()) > Double
.parseDouble(variabl1201[i1][1]))) {
bz = variabl2403[b].getText() + ">最大值"
+ Double.parseDouble(variabl1201[i1][1]);
c = b;
} else if ((variabl1201[i1][2].trim().length() > 0)
&& (Double
.parseDouble(variabl2403[b].getText()) < Double
.parseDouble(variabl1201[i1][2]))) {
bz = variabl2403[b].getText() + "<最小值"
+ variabl1201[i1][2];
c = b;
} else if ((variabl1201[i1][3].trim().length() > 0)) {
if (variabl1201[i1][3].indexOf("-") > 0) {
sb1 = variabl1201[i1][3].split("-");
if ((Double.parseDouble(variabl2403[b]
.getText()) < Double
.parseDouble(sb1[0]))) {
bz = variabl2403[b].getText() + "<范围下限"
+ sb1[0];
c = b;
}
if ((Double.parseDouble(variabl2403[b]
.getText()) > Double
.parseDouble(sb1[1]))) {
bz = variabl2403[b].getText() + ">范围上限"
+ sb1[1];
c = b;
}
} else if (variabl1201[i1][3].indexOf("[") >= 0) {
bz = variabl1201[i1][3].trim().substring(1,
variabl1201[i1][3].length() - 1);
sb1 = bz.split(",");
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (sb1[i].indexOf("^") >= 0) {
if (variabl2403[b].getText().indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = -1;
break;
}
}
}
if (bz1 == -1) {
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
c = b;
}
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (variabl2403[b].getText()
.indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = 1;
break;
}
}
if (bz1 == 0) {
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
c = b;
}
} else if (variabl1201[i1][3].indexOf(",") > 0) {
if (("," + variabl1201[i1][3] + ",")
.indexOf("," + variabl2403[b].getText()
+ ",") < 0) {
c = b;
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
}
}
} else if (variabl1201[i1][4].trim().length() > 0) {
int[][] m = new int[2][variabl1843];
for (int i = 0; i < variabl1843; i++) {
m[0][i] = i;
m[1][i] = variabl1323[i][0].length();
}
int d = 0, e = 0;
for (int i = 0; i < m[1].length; i++)
for (int j = i + 1; j < m[1].length; j++)
if (m[1][i] < m[1][j]) {
e = m[0][i];
m[0][i] = m[0][j];
m[0][j] = e;
e = m[1][i];
m[1][i] = m[1][j];
m[1][j] = e;
}
sb = variabl1201[i1][4];
for (int i = 0; i < m[1].length; i++)
sb = sb.replaceAll(variabl1323[m[0][b]][0],
variabl2403[m[0][b]].getText());
if (!tenanceEval.tenanceeval(sb)) {
bz = variabl2403[b].getText() + "不满足条件:"
+ variabl1201[i1][4];
c = b;
}
} else
c = 0;
} else if (main1.variabl1543.lastIndexOf(","
+ variabl15012[variabl14672[b]] + ",") >= 0) {
if ((variabl1201[i1][3].trim().length() > 0)) {
if (variabl1201[i1][3].indexOf("[") >= 0) {
bz = variabl1201[i1][3].trim().substring(1,
variabl1201[i1][3].length() - 1);
sb1 = bz.split(",");
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (sb1[i].indexOf("^") >= 0) {
if (variabl2403[b].getText().indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = -1;
break;
}
}
}
if (bz1 == -1) {
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
c = b;
}
bz1 = 0;
for (int i = 0; i < sb1.length; i++) {
if (variabl2403[b].getText()
.indexOf(
sb1[i].substring(1,
sb1[i].length())) >= 0) {
bz1 = 1;
break;
}
}
if (bz1 == 0) {
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
c = b;
}
} else if (variabl1201[i1][3].indexOf(",") > 0) {
if (("," + variabl1201[i1][3] + ",")
.indexOf("," + variabl2403[b].getText()
+ ",") < 0) {
c = b;
bz = variabl2403[b].getText() + "不满足"
+ variabl1201[i1][3] + "范围要求!";
}
}
} else
c = 0;
}
}
if (bz.length() > 0)
break;
}
} catch (Exception e1) {
JOptionPane.showMessageDialog(null, "数据完整性约束条件设置不满足格式要求,请修改接口参数表!"
+ e1);
}
if (bz.length() > 0) {
if (c > 0) {
JOptionPane.showMessageDialog(null, "填入的数据违反数据完整性约束条件。请检查!"
+ bz);
bz = "";
return false;
}
}
return true;
}
}
81.源码81,部件程序,表单程序,用于多对多表之间联系表的数据维护。
/**
* 程序文件名:dataTenance8.java
* 作者:程学先
* 程序功能:实现多对多表之间联系表的数据维护。
*/
import java.awt.BorderLayout;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.FocusAdapter;
import java.awt.event.FocusEvent;
import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import javax.swing.JButton;
import javax.swing.JFrame;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JScrollPane;
import javax.swing.JTable;
import javax.swing.JTextField;
import javax.swing.ListSelectionModel;
import javax.swing.table.DefaultTableModel;
import javax.swing.table.JTableHeader;
import javax.swing.table.TableColumn;
public class dataTenance8 extends JFrame {
static dataTenance8 frame1 = new dataTenance8();
static JTextField variabl24031;
static JTextField variabl24032;
private static JLabel fl1, fl2;
private static Connection cont4;
private static Statement stat4;
private static ResultSetMetaData rsmdt4;
private static ResultSet rs;
private static String variabl22771;
private static String variabl22772;
private static String variabl2603;
private static int variabl2483 = main1.variabl2483;
private static int variabl2503 = main1.variabl2503;
private static int variabl2651;
private static int variabl26511;
private static int variabl26512;
private static String[] variabl2517;
private static String[] variabl25171;
private static String[] variabl25172;
private static String[] variabl1501;
private static String[] variabl15011;
private static String[] variabl15012;
private static int[] variabl1489;
private static int[] variabl14891;
private static int[] variabl14892;
private static int variabl1853 = 0;
private static int variabl18531 = 0;
private static int variabl18532 = 0;
private static String[][] variabl2197;
private static String[][] variabl21971;
private static String[][] variabl21972;
private static String[][] variabl21973;
private static String variabl1175 = "";
private static JTable variabl2655;
static DefaultTableModel variabl1965;
private static String[] variabl1525;
private static String[] variabl1377;
private static int[] variabl1287;
private static int variabl12871;
private static int variabl12872;
private static String variabl14131 = "", variabl14132 = "";
private static String s1 = "", s2 = "", s3 = "";
private static int b = 0, c = 0, variabl2593 = 0, variabl25473 = 0;
private static String[] variabl2405 = { "从表格删除", "存入数据库", "更新表格", "退出" };
private static JButton variabl1479, variabl1337, variabl2599;
static int variabl2851 = 0, variabl2339 = 0;
private static String variabl1187;
private static int variabl1647 = 15, variabl1849 = 20;
static int variabl3681;
static int variabl1313;
private static int variabl1885[][];
static int variabl1473;
private static int variabl2833, variabl1371;
static void means(String parameter[]) {
frame1 = new dataTenance8();
variabl2483 = main1.variabl2483;
variabl2503 = main1.variabl2503;
variabl1853 = 0;
variabl18531 = 0;
variabl18532 = 0;
variabl1175 = "";
variabl1313 = 0;
s1 = "";
s2 = "";
s3 = "";
b = 0;
c = 0;
variabl2593 = 0;
variabl25473 = 0;
variabl1647 = 15;
variabl1849 = 20;
variabl2833 = 0;
variabl1371 = 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;
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) {
}
variabl22771 = parameter[2];
variabl22772 = parameter[3];
variabl2603 = parameter[4];
if (parameter[6].length() <= 0) {
JOptionPane.showMessageDialog(null, "缺少关键字,请说明关键字字段后再运行。");
return;
}
variabl1525 = parameter[6].split(",");
variabl14131 = parameter[13];
variabl14132 = parameter[14];
variabl1287 = new int[variabl1525.length];
frame1.setTitle("多对多表数据维护程序 作者:程学先");
frame1.setBounds(0, 0, variabl2483, variabl2503);
frame1.setDefaultCloseOperation(JFrame.DISPOSE_ON_CLOSE);
frame1.getContentPane().setLayout(null);
fl1 = new JLabel(variabl22771 + "条件表达式");
fl1.setBounds(30, 20, 120, 20);
frame1.add(fl1);
variabl24031 = new JTextField(variabl14131, 20);
variabl24031.setBounds(150, 20, 200, 20);
frame1.add(variabl24031);
fl2 = new JLabel(variabl22772 + "条件表达式");
fl2.setBounds(350, 20, 120, 20);
frame1.add(fl2);
variabl24032 = new JTextField(variabl14132, 20);
variabl24032.setBounds(470, 20, 200, 20);
frame1.add(variabl24032);
variabl2819002();
if ((variabl14131.trim().length() > 0)
&& (variabl14132.trim().length() > 0))
refresh();
variabl1479 = new JButton(variabl2405[0]);
variabl1479.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
int variabl1823 = variabl2655.getSelectedRow();
if (variabl1823 != -1)
variabl1965.removeRow(variabl1823);
}
});
if (variabl1187.lastIndexOf(",0,") >= 0) {
variabl1479.setBounds(variabl1885[0][0], variabl1885[0][1],
variabl1885[0][2], variabl1885[0][3]);
frame1.add(variabl1479);
}
variabl1337 = new JButton(variabl2405[1]);
variabl1337.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
String variabl2511 = main1.variabl1545;
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
variabl18531 = variabl1965.getRowCount();
int f0 = 0;
for (int i = 0; i < variabl18531; i++) {
f0 = 0;
s3 = "";
for (int j = 0; j < variabl1287.length; j++) {
s3 = s3
+ variabl1965.getValueAt(i, variabl1287[j])
.toString().trim();
}
for (int i1 = 0; i1 < variabl1853; i1++) {
if (variabl1377[i1].toLowerCase().trim()
.equals(s3.toLowerCase().trim())) {
f0 = 1;
break;
}
}
if (f0 == 0) {
s1 = "insert into " + variabl2603 + " (";
for (int k1 = 0; k1 < variabl2517.length; k1++)
s1 = s1 + variabl2517[k1] + ",";
s1 = s1.substring(0, s1.length() - 1)
+ " ) values (";
for (int j = 0; j < variabl2517.length; j++) {
if (variabl2511.lastIndexOf(","
+ variabl1501[j] + ",") >= 0) {
if ((variabl1965.getValueAt(i, j) == null)
|| (variabl1965.getValueAt(i, j)
.toString().trim().length() < 1))
s1 = s1 + "0";
else
s1 = s1
+ variabl1965.getValueAt(i, j)
.toString().trim();
} else {
if (variabl1965.getValueAt(i, j) == null)
s1 = s1 + "' '";
else
s1 = s1
+ "'"
+ variabl1965.getValueAt(i, j)
.toString().trim()
+ "'";
}
if (j != variabl2517.length - 1)
s1 = s1 + ",";
}
s1 = s1 + ")";
stat4.executeUpdate(s1);
} else {
s1 = "update " + variabl2603 + " set ";
for (int k1 = 0; k1 < variabl2517.length; k1++) {
s1 = s1 + variabl2517[k1] + "=";
if (variabl2511.lastIndexOf(","
+ variabl1501[k1] + ",") >= 0) {
if ((variabl1965.getValueAt(i, k1) == null)
|| (variabl1965.getValueAt(i, k1)
.toString().trim().length() < 1))
s1 = s1 + "0";
else
s1 = s1
+ variabl1965.getValueAt(i, k1)
.toString().trim();
} else {
if (variabl1965.getValueAt(i, k1) == null)
s1 = s1 + "' '";
else
s1 = s1
+ "'"
+ variabl1965.getValueAt(i, k1)
.toString().trim()
+ "'";
}
if (k1 != variabl2517.length - 1)
s1 = s1 + ",";
}
s2 = " where ";
for (int k = 0; k < variabl1287.length; k++) {
s2 = s2 + variabl1525[k] + "='"
+ variabl2197[i][variabl1287[k]] + "'";
if (k < variabl1525.length - 1)
s2 = s2 + " and ";
}
s1 = s1 + s2;
stat4.executeUpdate(s1);
}
}
stat4.close();
cont4.close();
} catch (SQLException e1) {
JOptionPane.showMessageDialog(null,
"操作出错,请检查数据表名是否重复,录入语句是否正确!" + s1);
}
}
});
if (variabl1187.lastIndexOf(",1,") >= 0) {
variabl1337.setBounds(variabl1885[1][0], variabl1885[1][1],
variabl1885[1][2], variabl1885[1][3]);
frame1.add(variabl1337);
}
JButton variabl1689 = new JButton(variabl2405[2]);
variabl1689.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
variabl14131 = variabl24031.getText();
variabl14132 = variabl24032.getText();
refresh();
}
});
if (variabl1187.lastIndexOf(",2,") >= 0) {
variabl1689.setBounds(variabl1885[2][0], variabl1885[2][1],
variabl1885[2][2], variabl1885[2][3]);
frame1.add(variabl1689);
}
variabl2599 = new JButton(variabl2405[3]);
variabl2599.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
frame1.setVisible(false);
frame1.dispose();
}
});
if (variabl1187.lastIndexOf(",3,") >= 0) {
variabl2599.setBounds(variabl1885[3][0], variabl1885[3][1],
variabl1885[3][2], variabl1885[3][3]);
frame1.add(variabl2599);
}
frame1.setVisible(true);
}
static void variabl2819002() {
int variabl1459 = 0;
if (variabl2833 > 0)
return;
variabl1187 = ",0,1,2,3,";
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 * 12);
variabl3681 = 20;
if (variabl1473 == 0)
variabl1459 = variabl1459 + variabl1849 * 2;
else
variabl1459 = variabl1459 + variabl1849;
int variabl1505 = (variabl2483 - 30) / (int) (6.6 * variabl1647);
if (variabl1505 < 1)
variabl1505 = 1;
if (variabl1371 <= variabl1505)
variabl1629 = (variabl2483 - 60) / variabl1371;
else
variabl1629 = (variabl2483 - 60) / variabl1505;
int n = 0, n1 = 0, n3 = 0;
n3 = variabl1505 * variabl1629;
for (int j = 0; j < variabl2851; j++) {
if (variabl1187.lastIndexOf("," + j + ",") >= 0) {
variabl1885[j][0] = variabl3681;
variabl1885[j][1] = variabl1459;
if (variabl2405[j].length() > 4) {
variabl1885[j][2] = (int) (variabl2405[j].length() * (variabl1647 * 2));
n3 = n3 + variabl1885[j][2] - variabl1629;
variabl3681 = variabl3681 + variabl1885[j][2];
} else {
variabl1885[j][2] = variabl1629;
variabl3681 = variabl3681 + variabl1629;
}
variabl1885[j][3] = variabl1849;
n++;
n1++;
if (variabl1371 - n1 == 0)
break;
if ((n >= variabl1505)
&& ((variabl1371 - n1) - variabl1505 != 0)) {
variabl3681 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
if ((variabl1371 - n1) <= variabl1505)
variabl1629 = (variabl2483 - 60) / (variabl1371 - n1);
else
variabl1629 = (variabl2483 - 60) / variabl1505;
n = 0;
} else if (n >= variabl1505) {
variabl3681 = 20;
variabl1459 = variabl1459 + variabl1849 + 20;
n = 0;
}
}
}
variabl2503 = variabl1459 + variabl1849 + 100;
}
public static void refresh() {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl22771;
if (variabl14131.length() > 0)
s1 = s1 + " where " + variabl14131;
rs = stat4.executeQuery(s1);
rs.last();
variabl18531 = rs.getRow();
rsmdt4 = rs.getMetaData();
variabl26511 = rsmdt4.getColumnCount();
variabl25171 = new String[variabl26511];
variabl15011 = new String[variabl26511];
variabl14891 = new int[variabl26511];
variabl21971 = new String[variabl18531][variabl26511];
for (int i = 0; i < variabl26511; i++) {
variabl25171[i] = rsmdt4.getColumnName(i + 1);
variabl15011[i] = rsmdt4.getColumnTypeName(i + 1);
variabl14891[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j < variabl1525.length; j++)
for (int i = 0; i < variabl26511; i++) {
if (variabl1525[j].toLowerCase().trim()
.equals(variabl25171[i].toLowerCase().trim())) {
variabl12871 = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl18531) {
rs.absolute(c + 1);
while (b < variabl26511) {
variabl21971[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!" + s1);
}
if (variabl22772.length() > 0) {
try {
cont4 = main1.getConn();
stat4 = cont4.createStatement(
ResultSet.TYPE_SCROLL_INSENSITIVE,
ResultSet.CONCUR_UPDATABLE);
s1 = "select * from " + variabl22772;
if (variabl14132.length() > 0)
s1 = s1 + " where " + variabl14132;
rs = stat4.executeQuery(s1);
rs.last();
variabl18532 = rs.getRow();
rsmdt4 = rs.getMetaData();
variabl26512 = rsmdt4.getColumnCount();
variabl25172 = new String[variabl26512];
variabl15012 = new String[variabl26512];
variabl14892 = new int[variabl26512];
variabl21972 = new String[variabl18532][variabl26512];
for (int i = 0; i < variabl26512; i++) {
variabl25172[i] = rsmdt4.getColumnName(i + 1);
variabl15012[i] = rsmdt4.getColumnTypeName(i + 1);
variabl14892[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j < variabl1525.length; j++)
for (int i = 0; i < variabl26512; i++) {
if (variabl1525[j].toLowerCase().trim()
.equals(variabl25172[i].toLowerCase().trim())) {
variabl12872 = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl18532) {
rs.absolute(c + 1);
while (b < variabl26512) {
variabl21972[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!" + s1);
}
}
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[variabl2651];
variabl1501 = new String[variabl2651];
variabl1489 = new int[variabl2651];
variabl21973 = new String[variabl1853][variabl2651];
for (int i = 0; i < variabl2651; i++) {
variabl2517[i] = rsmdt4.getColumnName(i + 1);
variabl1501[i] = rsmdt4.getColumnTypeName(i + 1);
variabl1489[i] = rsmdt4.getColumnDisplaySize(i + 1);
}
for (int j = 0; j < variabl1525.length; j++)
for (int i = 0; i < variabl2651; i++) {
if (variabl1525[j].toLowerCase().trim()
.equals(variabl2517[i].toLowerCase().trim())) {
variabl1287[j] = i;
break;
}
}
rs.absolute(1);
c = 0;
b = 0;
while (c < variabl1853) {
rs.absolute(c + 1);
while (b < variabl2651) {
variabl21973[c][b] = rs.getString(b + 1);
b++;
}
c++;
b = 0;
}
variabl1377 = new String[variabl1853];
for (int j = 0; j < variabl1853; j++) {
variabl1377[j] = "";
for (int i = 0; i < variabl1525.length; i++) {
variabl1377[j] = variabl1377[j]
+ variabl21973[j][variabl1287[i]].trim();
}
}
rs.close();
stat4.close();
cont4.close();
} catch (SQLException e) {
JOptionPane.showMessageDialog(null, "连接数据库出错!" + s1);
}
if (variabl18532 == 0)
variabl2197 = new String[variabl18531][variabl2651];
else
variabl2197 = new String[variabl18531 * variabl18532][variabl2651];
for (int i = 0; i < variabl18531; i++)
for (int j = 0; j < variabl2651; j++)
variabl2197[i][j] = "";
if (variabl18532 > 0)
for (int i = 0; i < variabl18531; i++)
for (int j = 0; j < variabl18532; j++) {
variabl2197[i][variabl1287[0]] = variabl21971[i][variabl12871];
variabl2197[i][variabl1287[1]] = variabl21972[j][variabl12872];
}
else
for (int i = 0; i < variabl18531; i++) {
variabl2197[i][variabl1287[0]] = variabl21971[i][variabl12871];
}
for (int i = 0; i < variabl2197.length; i++)
for (int j = 0; j < variabl21973.length; j++)
if ((variabl2197[i][variabl1287[0]].trim() + variabl2197[i][variabl1287[1]]
.trim()).equals(variabl21973[j][variabl1287[0]]
+ variabl21973[j][variabl1287[1]])) {
for (int k = 0; k < variabl2651; k++) {
if ((k != variabl1287[0]) && (k != variabl1287[1]))
variabl2197[i][k] = variabl21973[j][k];
}
}
variabl1965 = new DefaultTableModel(variabl2197, variabl2517);
variabl2655 = new JTable(variabl1965);
variabl2655.setAutoResizeMode(JTable.AUTO_RESIZE_OFF);
variabl2655
.setSelectionMode(ListSelectionModel.SINGLE_INTERVAL_SELECTION);
for (int i = 0; i < variabl2651; i++) {
TableColumn tc = variabl2655.getColumn(variabl2517[i]);
if (variabl2517[i].length() > variabl1489[i])
variabl1489[i] = variabl2517[i].length();
tc.setPreferredWidth(variabl1489[i] * 11);
tc.setMaxWidth(variabl1489[i] * 11);
tc.sizeWidthToFit();
}
variabl2503 = 650;
final JScrollPane scrollPane = new JScrollPane();
scrollPane.setBounds(30, 80, variabl2483 - 100, variabl2503 - 150);
frame1.setBounds(10, 10, variabl2483, variabl2503);
scrollPane.setViewportView(variabl2655);
frame1.add(scrollPane, BorderLayout.CENTER);
variabl2655.addKeyListener(new KeyAdapter() {
public void keyPressed(KeyEvent evt) {
variabl1175 = variabl1175 + evt.getKeyChar();
}
});
variabl2655.addMouseListener(new MouseAdapter() {
public void mouseClicked(MouseEvent e) {
variabl1175 = "";
}
});
variabl2655.addFocusListener(new FocusAdapter() {
public void focusLost(final FocusEvent arg0) {
variabl2593 = variabl2655.getSelectedRow();
variabl25473 = variabl2655.getSelectedColumn();
variabl1965.setValueAt(variabl1175, variabl2593, variabl25473);
}
});
}
}
Archiver|手机版|科学网 ( 京ICP备07017567号-12 )
GMT+8, 2024-9-27 12:08
Powered by ScienceNet.cn
Copyright © 2007- 中国科学报社