mesclient-op170-dy/src/com/mes/ui/MesClient.java

package com.mes.ui;

import com.alibaba.fastjson2.JSONObject;
import com.fazecast.jSerialComm.SerialPort;
import com.fazecast.jSerialComm.SerialPortEvent;
import com.mes.component.MesRadio;
import com.mes.component.MesWebView;
import com.mes.laser.LaserFlowManager;
import com.mes.netty.NettyClient;
import com.mes.util.DateLocalUtils;
import com.mes.util.JdbcUtils;
import javafx.embed.swing.JFXPanel;

import javax.swing.*;
import javax.swing.border.EmptyBorder;
import javax.swing.event.ChangeEvent;
import javax.swing.event.ChangeListener;
import javax.swing.event.DocumentEvent;
import javax.swing.event.DocumentListener;
import java.awt.*;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.ComponentAdapter;
import java.awt.event.ComponentEvent;
import java.awt.event.MouseAdapter;
import java.awt.event.MouseEvent;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.time.LocalDateTime;
import java.util.List;
import java.util.Properties;
import java.util.Timer;
import java.util.TimerTask;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

public class MesClient extends JFrame {

    private static String Drivde = "org.sqlite.JDBC";

    public static int mes_auth = 0; // 权限级别 0=无权限 1=操作工人 2=管理员
    public static String mes_gw = ""; // 工位号
    public static String mes_gw_des = ""; // 工位名称
    public static String mes_server_ip = ""; // 服务器IP地址
    public static int mes_tcp_port = 3000; // TCP服务端口
    public static int mes_heart_beat_cycle = 10; // 心跳周期
    public static int mes_heart_icon_cycle = 1;
    public static String mes_line_sn = ""; // 产线编号
    public static String ui_design_password = "mes123"; // UI面板密码

    //TCP连接
    public static NettyClient nettyClient;
    //TCP连接状态
    public static boolean tcp_connect_flag = false;
    //TCP连接请求
    public static boolean connect_request_flag = false;

    //session
    public static String sessionid = "";

    public static JPanel contentPane;
    public static MesClient mesClientFrame;
    public static JTabbedPane tabbedPane;
    public static JScrollPane indexScrollPaneA;
    public static JScrollPane searchScrollPane;
    public static JScrollPane searchScrollPaneDj;


    public static Boolean check_quality_result = false;
    public static Integer work_status = 0;

    public static JButton heart_beat_menu;
    public static JButton status_menu;
    public static JButton user_menu;

    public static int scan_type = 0;
    public static JButton finish_ok_bt;
    public static JButton finish_ng_bt;
    public static JTextField product_sn;
    public static JButton f_scan_data_bt_1;

    public static JTextField batch_sn; // 物料批次码
    public static JButton batch_sn_btn;

    public static String user20 = "";

    public static JFrame welcomeWin;

    public static JPanel indexPanelB;
    public static MesWebView jfxPanel = null;
    public static JPanel indexPanelC;
    public static MesWebView jfxPanel2 = null;
    public static MesRadio mesRadioHj;

    public static JTable table;
    public static Object[] columnNames = { "物料名称", "绑定批次", "剩余次数", "操作" };
    public static Object[][] rowData = null;
    public static Boolean checkState = false; // 点检状态 false=未点检 true=已点检

    public static SerialPort serialPort; // 串口对象

    // 镭雕相关
    public static JButton laser_get_code_bt; // 获取镭雕码按钮
    public static JButton laser_reset_bt; // 人工复位按钮
    public static LaserFlowManager laserFlowManager;
    public static JTextField manualSteelSnInput;
    public static JButton manualGetCodeBt;
    public static JButton manualFinishOkBt;
    public static JButton manualUnbindBt;
    private static boolean manualWaitingComplete = false;
    private static boolean manualCompleting = false;
    private static final ExecutorService laserActionExecutor = Executors.newSingleThreadExecutor();

    public static void main(String[] args) {
        if (LockUtil.getInstance().isAppActive() == true){
//            JOptionPane.showMessageDialog(null, "已有一个程序在运行,程序退出");
            return;
        }else{
        // 设置支持高DPI
        System.setProperty("sun.java2d.uiScale", "1.0");
        System.setProperty("sun.java2d.dpiaware", "true");
        
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try{
                    //读文件配置
                    readProperty();

                    // 显示界面
                    mesClientFrame = new MesClient();
                    mesClientFrame.setVisible(false);

                    JdbcUtils.getConn();

                    welcomeWin = new LoginFarme();
                    welcomeWin.setVisible(true);

                    getMaterailData();

                    serialPort = ModbusRtu.connect();

                    // checkTimer()已移除：原用于每3秒驱动继电器开关(formatDeviceState)，
                    // 继电器功能已不再使用，保留会导致无意义的轮询打印

                    // 启动镭雕流程管理器（含本地HTTP服务，接收镭雕软件完成上报）
                    initLaserFlow();

                }catch (Exception e){
                    e.printStackTrace();
                }
            }
        });
        }
    }

    public static java.util.Timer checkTimer;
    public static void checkTimer() {
        if(checkTimer!=null) {
            checkTimer.cancel();
        }
        checkTimer = new java.util.Timer();
        checkTimer.schedule(new TimerTask() {
            public void run() {
                if(!MesClient.sessionid.isEmpty()){
                    getCheckResult();
                }
            }
        }, 100,3*1000);
    }

    //读配置文件
    private static void readProperty() throws IOException{
        String enconding = "UTF-8";
        InputStream is = ClassLoader.getSystemResourceAsStream("config/config.properties");
        Properties pro = new Properties();
        BufferedReader br = new BufferedReader(new InputStreamReader(is, enconding));
        pro.load(br);
        mes_gw =  pro.getProperty("mes.gw");

//        mes_gw_des = pro.getProperty("mes.gw_des");
        mes_server_ip = pro.getProperty("mes.server_ip");
        mes_tcp_port = Integer.parseInt(pro.getProperty("mes.tcp_port"));
        mes_heart_beat_cycle = Integer.parseInt(pro.getProperty("mes.heart_beat_cycle"));
        mes_line_sn = pro.getProperty("mes.line_sn");
        ui_design_password = pro.getProperty("mes.ui.design.password", "123456").trim();

        mes_gw_des = OprnoUtil.getGwDes(mes_line_sn,mes_gw);

        System.out.println(mes_gw + ";" + mes_gw_des + ";" + mes_server_ip + ";" + mes_tcp_port + ";" + mes_heart_beat_cycle);
    }

    // 初始化TCP
    public static void initTcpConnection() {
        try {
            if(nettyClient==null) {
                //初始化TCP连接
                nettyClient = new NettyClient();
                //TCP连接状态
                tcp_connect_flag = false;
                //设置TCP请求状态
                connect_request_flag = true;

                DataUtil.synrTcp(nettyClient,mes_gw);
            }
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

    //启动心跳包程序
    public static java.util.Timer heartBeatTimer;
    public static java.util.Timer heartBeatIconTimer;
    public static boolean iconREDFlag = true;
    public static void startHeartBeatTimer() {
        if(heartBeatTimer!=null) {
            heartBeatTimer.cancel();
        }
        heartBeatTimer = new java.util.Timer();
        heartBeatTimer.schedule(new TimerTask() {
            public void run() {
                if(nettyClient!=null&&tcp_connect_flag) {
                    //System.out.println("发送心跳报文");
                    DataUtil.heartBeat(nettyClient,mes_gw);

                    heart_beat_menu.setText(DateLocalUtils.getCurrentTime());
                }
            }
        }, 100,mes_heart_beat_cycle*1000);

        //心跳显示图标
        if(heartBeatIconTimer!=null) {
            heartBeatIconTimer.cancel();
        }
        heartBeatIconTimer = new Timer();
        heartBeatIconTimer.schedule(new TimerTask() {
            public void run() {
                if(tcp_connect_flag) {
                    if(iconREDFlag) {
                        heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
                        iconREDFlag = false;
                    }else {
                        heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/green_dot.png")));
                        iconREDFlag = true;
                    }
                    heart_beat_menu.setText(DateLocalUtils.getCurrentTime());
                    heart_beat_menu.repaint();
                }else {
                    heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
                    heart_beat_menu.setText(DateLocalUtils.getCurrentTime());
                    heart_beat_menu.repaint();

                    //若未连接则尝试连接
                    if(nettyClient!=null&&!tcp_connect_flag){
                        System.out.println("TCP已断开");
                        //TCP重新同步连接
                        if(!connect_request_flag) {
                            //System.out.println("TCP重新同步连接");
                            //设置TCP请求状态,只重新同步连接一次
                            connect_request_flag = true;

                            DataUtil.synrTcp(nettyClient,mes_gw);
                        }

                    }
                }
            }
        }, 100,mes_heart_icon_cycle*1000);
    }

    //设置tcp连接状态显示
    public static void setTcpStatus() {
        if(tcp_connect_flag) {
            status_menu.setText("已连接MES服务器");
            heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
            heart_beat_menu.repaint();
        }else {
            status_menu.setText("未连接MES服务器");
            heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/grey_dot.png")));
            heart_beat_menu.repaint();
        }
    }

    public static void initWarehouseData(){
        resetScanA();
    }

    public static void resetScanA() {
        work_status = 0;
        check_quality_result = false;
        MesClient.finish_ok_bt.setEnabled(false);
        MesClient.finish_ng_bt.setEnabled(false);
        product_sn.setText("");

        batch_sn.setText("");

//        MesClient.f_scan_data_bt_1.setEnabled(true);
        MesClient.setMenuStatus("请扫工件码",0);

        updateMaterailData();
        // getCheckResult()调用已移除：原用于驱动继电器(formatDeviceState)，继电器功能已不再使用
        // 注释掉换班检查，避免自动退出
        // shiftUserCheck();
    }

    public static int userLoginHours;//用户登录所处小时
    //换班用户信息检查（已注释，避免早上8点自动关闭）
    /*
    private static  void  shiftUserCheck() {
        LocalDateTime now = LocalDateTime.now();
        // 判断时间范围
        if (userLoginHours >= 8 && userLoginHours < 20) {

            int hour = now.getHour();
            if (hour >= 20 || hour < 8) {
                logoff();
            }
        } else {
            int hour = now.getHour();
            if (hour >= 8 && hour < 20) {
                logoff();
            }
        }
    }
    */

    public static void resetScanB() {

    }

    //获取用户20位
    public static void getUser() {
        user20 = user_menu.getText().toString();
        String space_tmp1 = "";
        if(user20.length()<20) {
            for(int i=0;i<20-user20.length();i++) {
                space_tmp1 = space_tmp1 + " ";
            }
        }
        user20 = user20 + space_tmp1;
    }

    //获取barcode内容36位
    public static String getBarcode(String barcodeTmp) {
        String barcodeRet = barcodeTmp;
        if(barcodeTmp.equalsIgnoreCase("")) {
            return "";
        }else {
            if(barcodeTmp.length()<36) {
                String space = "";
                for(int i=0;i<36-barcodeTmp.length();i++) {
                    space = space + " ";
                }
                barcodeRet = barcodeTmp + space;
            }
        }
        return barcodeRet;
    }

    public static void setMenuStatus(String msg,int error){
        if(error == 0){
            MesClient.status_menu.setForeground(Color.GREEN);
        }else{
            MesClient.status_menu.setForeground(Color.RED);
        }
        MesClient.status_menu.setText(msg);
    }


    private static boolean isManualSteelSnReady() {
        return manualSteelSnInput != null && manualSteelSnInput.getText().trim().length() == 11;
    }

    private static void updateManualSubmitButtons() {
        boolean ready = isManualSteelSnReady();
        if (manualGetCodeBt != null) {
            manualGetCodeBt.setEnabled(!manualWaitingComplete && ready);
        }
        if (manualFinishOkBt != null) {
            manualFinishOkBt.setEnabled(manualWaitingComplete && !manualCompleting);
        }
        if (manualUnbindBt != null) {
            manualUnbindBt.setEnabled(!manualWaitingComplete && !manualCompleting && ready);
        }
    }

    private static void resetManualSubmitPanel(boolean clearInput) {
        manualWaitingComplete = false;
        manualCompleting = false;
        if (clearInput && manualSteelSnInput != null) {
            manualSteelSnInput.setText("");
        }
        updateManualSubmitButtons();
    }
    private static void requestUnbindSteelSn(String steelSn) {
        requestUnbindSteelSn(steelSn, manualSteelSnInput);
    }

    private static void requestUnbindSteelSn(String steelSn, final JTextField steelSnInputToClear) {
        if (steelSn == null || steelSn.trim().length() != 11) {
            setMenuStatus("请输入11位钢印码", 1);
            updateManualSubmitButtons();
            return;
        }
        if (laserFlowManager != null && laserFlowManager.isWaitingComplete()) {
            setMenuStatus("镭雕进行中，不能解绑", 1);
            return;
        }
        manualCompleting = true;
        updateManualSubmitButtons();
        final String steelSnTrim = steelSn.trim();
        laserActionExecutor.submit(new Runnable() {
            @Override
            public void run() {
                JSONObject retObj = DataUtil.unbindSteelSn(steelSnTrim);
                SwingUtilities.invokeLater(new Runnable() {
                    @Override
                    public void run() {
                        manualCompleting = false;
                        if (retObj != null && retObj.get("result") != null
                                && "true".equalsIgnoreCase(retObj.get("result").toString())) {
                            setMenuStatus(retObj.getString("message"), 0);
                            if (steelSnInputToClear != null) {
                                steelSnInputToClear.setText("");
                            }
                            product_sn.setText("");
                        } else {
                            String msg = retObj != null && retObj.get("message") != null
                                    ? retObj.get("message").toString() : "解绑失败，请重试";
                            setMenuStatus(msg, 1);
                        }
                        updateManualSubmitButtons();
                    }
                });
            }
        });
    }
    public static void scanBarcode() {
        String scanBarcodeTitle = "";
        switch(scan_type) {
            case 1:
                product_sn.setText("");
                scanBarcodeTitle = "请扫工件码";
                break;
            case 2:
                batch_sn.setText("");
                scanBarcodeTitle = "请扫物料批次码";
                break;
        }

        //弹窗扫工件码
        String scanBarcode = JOptionPane.showInputDialog(null, scanBarcodeTitle);
        if(scanBarcode!=null&&!scanBarcode.equalsIgnoreCase("")) {
            //获取用户
            getUser();
            //获取扫码内容36位
            String barcode36 = getBarcode(scanBarcode);//处理36为码
            //工位号
            String gw = "";
            switch(scan_type) {
                case 1:
                    product_sn.setText(scanBarcode);
                    break;
                case 2:
                    batch_sn.setText(scanBarcode);
                    break;
            }
            //刷新界面
            mesClientFrame.repaint();

            if(!tcp_connect_flag) {
                MesClient.setMenuStatus("设备未连接Mes服务器",1);
//                JOptionPane.showMessageDialog(mesClientFrame,"设备未连接Mes服务器","提示窗口", JOptionPane.INFORMATION_MESSAGE);
                return;
            }

//            if(!product_sn.getText().isEmpty() && !batch_sn.getText().isEmpty()){
//                finish_ok_bt.setEnabled(true);
//                finish_ng_bt.setEnabled(true);
//            }

            if(!product_sn.getText().isEmpty()){
                // 扫码后自动提交OK
                String sn = getBarcode(product_sn.getText());
                if(!sn.isEmpty()){
                    String qret = "OK";
                    Boolean sendret = DataUtil.sendCreate(nettyClient,sn,qret,user20);
                    if(!sendret){
                        MesClient.setMenuStatus("消息发送失败，请重试",1);
                        return;
                    }
                    // 提交成功后，弹出新的扫码框
                    SwingUtilities.invokeLater(new Runnable() {
                        @Override
                        public void run() {
                            scan_type = 1;
                            scanBarcode();
                        }
                    });
                }
            }

            // 查询工件质量
//            Boolean sendret = DataUtil.checkQuality(nettyClient,barcode36,user20);
//            if(!sendret){
//                JOptionPane.showMessageDialog(mesClientFrame,"消息发送失败，请重试","提示窗口", JOptionPane.INFORMATION_MESSAGE);
//                return;
//            }
        }else {
            JOptionPane.showMessageDialog(mesClientFrame,"请扫工件码","提示窗口", JOptionPane.INFORMATION_MESSAGE);
            return;
        }
    }

    // 复用op040既有建档提交逻辑（原finish_ok_bt/finish_ng_bt里的sendCreate调用抽出来）
    // sn: 用于提交的编码（客户编码），qret: OK/NG
    public static boolean submitLaserResult(String sn, String qret){
        if(sn == null || sn.isEmpty()){
            setMenuStatus("客户编码为空，无法提交",1);
            return false;
        }
        getUser();
        String snPad = getBarcode(sn);
        Boolean sendret = DataUtil.sendCreate(nettyClient, snPad, qret, user20);
        if(!sendret){
            setMenuStatus("结果提交MES失败，请重试",1);
            return false;
        }
        return true;
    }

    // 初始化镭雕流程管理器
    public static void initLaserFlow(){
        laserFlowManager = new LaserFlowManager(new LaserFlowManager.UiCallback() {
            @Override
            public void onStatus(String msg, boolean error) {
                SwingUtilities.invokeLater(() -> setMenuStatus(msg, error ? 1 : 0));
            }

            @Override
            public void onLockButton(boolean lock) {
                SwingUtilities.invokeLater(() -> {
                    if(laser_get_code_bt != null){
                        laser_get_code_bt.setEnabled(!lock);
                    }
                    if (!lock && manualWaitingComplete) {
                        resetManualSubmitPanel(true);
                    }
                });
            }

            @Override
            public void onCodeReceived(String code) {
                SwingUtilities.invokeLater(() -> product_sn.setText(code));
            }

            @Override
            public boolean onSubmitResult(String customerSn, String qret) {
                return submitLaserResult(customerSn, qret);
            }
        });
        laserFlowManager.startCompleteServer();
    }

    public static void logoff() {
//        welcomeWin.setVisible(true);
        mesClientFrame.setVisible(false);

        if(laserFlowManager != null){
            laserFlowManager.stopCompleteServer();
        }

        nettyClient = null;
//        if(heartBeatTimer!=null) {
//            heartBeatTimer.cancel();
//        }
//        if(heartBeatIconTimer!=null) {
//            heartBeatIconTimer.cancel();
//        }
        tcp_connect_flag = false;
        connect_request_flag = false;
    }

    public static boolean confirmClose(Component parent) {
        return JOptionPane.showConfirmDialog(parent, "确定要关闭MES系统客户端吗？", "确认关闭",
                JOptionPane.YES_NO_OPTION, JOptionPane.QUESTION_MESSAGE) == JOptionPane.YES_OPTION;
    }

    public MesClient() {
        setIconImage(Toolkit.getDefaultToolkit().getImage(MesClient.class.getResource("/bg/logo.png")));
        setTitle("MES系统客户端："+mes_gw + "- " + mes_gw_des);
        setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                if (confirmClose(MesClient.this)) {
                    System.exit(0);
                }
            }
        });
        setBounds(0, 0, 1024, 768);
        
        // 确保标题栏正确显示
        validate();
        
        JMenuBar menuBar = new JMenuBar();
        menuBar.setFont(new Font("Microsoft YaHei UI", Font.PLAIN, 26));
        setJMenuBar(menuBar);
        JMenu fileMenu = new JMenu("用户");
        fileMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/user.png")));
        fileMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        menuBar.add(fileMenu);

        JMenuItem exitMenuItem = new JMenuItem("退出");
        exitMenuItem.setIcon(new ImageIcon(MesClient.class.getResource("/bg/logoff.png")));
        exitMenuItem.setFont(new Font("微软雅黑", Font.PLAIN, 22));
        fileMenu.add(exitMenuItem);
        exitMenuItem.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {//只能检测到mousePressed事件
                super.mouseClicked(e);
                //dispose();
                logoff();
            }
        });

        JMenu settingMenu = new JMenu("设置");
        //settingMenu.setVisible(false);
        settingMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/menu_setting.png")));
        settingMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        menuBar.add(settingMenu);

        JMenuItem resetTcpMenu = new JMenuItem("\u91CD\u8FDEMES");
        resetTcpMenu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
        resetTcpMenu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        resetTcpMenu.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                super.mouseClicked(e);
                //重连mes
                nettyClient.future.channel().close();
            }
        });
        settingMenu.add(resetTcpMenu);

        JMenuItem resetTcpMenu_1 = new JMenuItem("刷新工件");
        resetTcpMenu_1.setIcon(new ImageIcon(MesClient.class.getResource("/bg/reset_logo.png")));
        resetTcpMenu_1.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        resetTcpMenu_1.addMouseListener(new MouseAdapter() {
            @Override
            public void mousePressed(MouseEvent e) {
                super.mouseClicked(e);
                resetScanA();
            }
        });
        settingMenu.add(resetTcpMenu_1);

        contentPane = new JPanel();
        contentPane.setBorder(new EmptyBorder(5, 5, 5, 5));
        setContentPane(contentPane);
        contentPane.setLayout(new BorderLayout(0, 0));

        JToolBar toolBar = new JToolBar();
        contentPane.add(toolBar, BorderLayout.NORTH);

        JLabel equipment_statu_label = new JLabel("状态：");
        equipment_statu_label.setHorizontalAlignment(SwingConstants.CENTER);
        equipment_statu_label.setForeground(Color.BLACK);
        equipment_statu_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        equipment_statu_label.setBackground(Color.LIGHT_GRAY);
        toolBar.add(equipment_statu_label);

        status_menu = new JButton("设备未连接MES服务器");
        if(tcp_connect_flag) {
            status_menu.setText("已连接MES服务器");
            status_menu.setForeground(Color.GREEN);
        }else {
            status_menu.setText("未连接MES服务器");
            status_menu.setForeground(Color.DARK_GRAY);
        }
        status_menu.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
            }
        });
        status_menu.setForeground(Color.GREEN);
        status_menu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        status_menu.setBackground(Color.BLACK);
        toolBar.add(status_menu);

        JLabel space_1 = new JLabel("    ");
        toolBar.add(space_1);

        JLabel heart_beat_status_label = new JLabel("心跳：");
        heart_beat_status_label.setHorizontalAlignment(SwingConstants.CENTER);
        heart_beat_status_label.setForeground(Color.BLACK);
        heart_beat_status_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        heart_beat_status_label.setBackground(Color.LIGHT_GRAY);
        toolBar.add(heart_beat_status_label);

        heart_beat_menu = new JButton("2024-02-20 23:20:10");
        heart_beat_menu.setIcon(new ImageIcon(MesClient.class.getResource("/bg/green_dot.png")));
        heart_beat_menu.setForeground(Color.GREEN);
        heart_beat_menu.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        heart_beat_menu.setBackground(Color.BLACK);
        toolBar.add(heart_beat_menu);

        JLabel space_2 = new JLabel("    ");
        toolBar.add(space_2);

        JLabel user_status_label = new JLabel("登录用户：");
        user_status_label.setHorizontalAlignment(SwingConstants.CENTER);
        user_status_label.setForeground(Color.BLACK);
        user_status_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        user_status_label.setBackground(Color.LIGHT_GRAY);
        toolBar.add(user_status_label);

        user_menu = new JButton("JinJuShi");
        user_menu.setForeground(Color.GREEN);
        user_menu.setFont(new Font("微软雅黑", Font.PLAIN, 22));
        user_menu.setBackground(Color.BLACK);
        toolBar.add(user_menu);

        JLabel space_3 = new JLabel("    ");
        toolBar.add(space_3);

        JLabel space_4 = new JLabel("    ");
        toolBar.add(space_4);

        tabbedPane = new JTabbedPane(JTabbedPane.TOP);
        tabbedPane.setMinimumSize(new Dimension(400, 50));
        tabbedPane.setFont(new Font("宋体", Font.BOLD, 22));
        contentPane.add(tabbedPane);

        //首页
        JPanel indexPanelA = new JPanel();
        indexScrollPaneA = new JScrollPane(indexPanelA);
        indexPanelA.setLayout(null);

        // 镭雕：获取镭雕码 / 复位按钮，放在扫码框（回显框）上方
        laser_get_code_bt = new JButton("获取镭雕码");
        laser_get_code_bt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                laserFlowManager.startLaserFlow(mes_gw, mes_line_sn);
            }
        });
        laser_get_code_bt.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        laser_get_code_bt.setBounds(81, 40, 300, 50);
        indexPanelA.add(laser_get_code_bt);

        // 镭雕：人工复位按钮（完成信号超时或异常时使用，强制解锁并作废当前请求）
        laser_reset_bt = new JButton("复位");
        laser_reset_bt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                int result = JOptionPane.showConfirmDialog(MesClient.this,
                        "复位会取消当前镭雕流程，确定要继续吗？", "确认复位",
                        JOptionPane.YES_NO_OPTION, JOptionPane.WARNING_MESSAGE);
                if (result == JOptionPane.YES_OPTION) {
                    laserFlowManager.manualReset();
                    resetManualSubmitPanel(true);
                }
            }
        });
        laser_reset_bt.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        laser_reset_bt.setBounds(400, 40, 150, 50);
        indexPanelA.add(laser_reset_bt);

        product_sn = new JTextField();
        product_sn.setHorizontalAlignment(SwingConstants.CENTER);
        product_sn.setEditable(false);
        product_sn.setFont(new Font("微软雅黑", Font.PLAIN, 28));
        product_sn.setBounds(81, 100, 602, 70);
        indexPanelA.add(product_sn);
        product_sn.setColumns(10);

        // 原扫码按钮不再需要，隐藏但保留逻辑（scanBarcode等方法仍被其他流程复用）
        f_scan_data_bt_1 = new JButton("扫码");
        f_scan_data_bt_1.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                scan_type = 1;
                scanBarcode();
            }
        });
        f_scan_data_bt_1.setIcon(new ImageIcon(MesClient.class.getResource("/bg/scan_barcode.png")));
        f_scan_data_bt_1.setFont(new Font("微软雅黑", Font.PLAIN, 32));
        f_scan_data_bt_1.setBounds(693, 100, 198, 70);
        f_scan_data_bt_1.setVisible(false);
        indexPanelA.add(f_scan_data_bt_1);


        JLabel batch_label = new JLabel("绑定物料批次码");
        batch_label.setHorizontalAlignment(SwingConstants.CENTER);
        batch_label.setForeground(Color.BLACK);
        batch_label.setFont(new Font("微软雅黑", Font.PLAIN, 20));
        batch_label.setBackground(Color.LIGHT_GRAY);
        batch_label.setBounds(81, 140, 602, 70);
//        indexPanelA.add(batch_label);

        batch_sn = new JTextField();
        batch_sn.setHorizontalAlignment(SwingConstants.CENTER);
        batch_sn.setEditable(false);
        batch_sn.setFont(new Font("微软雅黑", Font.PLAIN, 28));
        batch_sn.setBounds(81, 210, 602, 70);
//        indexPanelA.add(batch_sn);
        batch_sn.setColumns(10);

        batch_sn_btn = new JButton("扫码");
        batch_sn_btn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                scan_type = 2;
                scanBarcode();
            }
        });
        batch_sn_btn.setIcon(new ImageIcon(MesClient.class.getResource("/bg/scan_barcode.png")));
        batch_sn_btn.setFont(new Font("微软雅黑", Font.PLAIN, 32));
        batch_sn_btn.setBounds(693, 210, 198, 70);
//        indexPanelA.add(batch_sn_btn);

//        String[] hjtitles = new String[]{"焊机1","焊机2","焊机3"};
//        String[] hjvals = new String[]{"HJ001","HJ002","HJ003"};
//        mesRadioHj = new MesRadio(hjtitles,hjvals);
//        mesRadioHj.setSize(500,50);
//        mesRadioHj.setBounds(190,170,500,50);
//        indexPanelA.add(mesRadioHj);

        finish_ok_bt = new JButton("OK");
        finish_ok_bt.setEnabled(false);
        finish_ok_bt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String sn = getBarcode(product_sn.getText());
                //                String batchsn = getBarcode(batch_sn.getText());
                if(sn.isEmpty()){
                    MesClient.setMenuStatus("请扫工件码",1);
                    return;
                }
//                if(batchsn.isEmpty()){
//                    MesClient.setMenuStatus("请扫物料批次码",1);
//                    return;
//                }
                getUser();

                String qret = "OK";
                Boolean sendret = DataUtil.sendCreate(nettyClient,sn,qret,user20);
                if(!sendret){
                    MesClient.setMenuStatus("消息发送失败，请重试",1);
//                        JOptionPane.showMessageDialog(mesClientFrame,"消息发送失败，请重试","提示窗口", JOptionPane.INFORMATION_MESSAGE);
                    return;
                }
            }
        });
        finish_ok_bt.setIcon(new ImageIcon(MesClient.class.getResource("/bg/ok_bg.png")));
        finish_ok_bt.setFont(new Font("微软雅黑", Font.PLAIN, 32));
        finish_ok_bt.setBounds(185, 341, 240, 80);
        finish_ok_bt.setEnabled(false);
        // 镭雕工位不需要手动点OK，完成信号收到后自动提交，隐藏但保留逻辑复用
        finish_ok_bt.setVisible(false);
        indexPanelA.add(finish_ok_bt);

        finish_ng_bt = new JButton("NG");
        finish_ng_bt.setEnabled(false);
        finish_ng_bt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                String sn = getBarcode(product_sn.getText());
//                String batchsn = getBarcode(batch_sn.getText());
                if(sn.isEmpty()){
                    MesClient.setMenuStatus("请扫工件码",1);
                    return;
                }
//                if(batchsn.isEmpty()){
//                    MesClient.setMenuStatus("请扫物料批次码",1);
//                    return;
//                }
                getUser();

                String qret = "NG";
                Boolean sendret = DataUtil.sendCreate(nettyClient,sn,qret,user20);
                if(!sendret){
                    MesClient.setMenuStatus("消息发送失败，请重试",1);
//                        JOptionPane.showMessageDialog(mesClientFrame,"消息发送失败，请重试","提示窗口", JOptionPane.INFORMATION_MESSAGE);
                    return;
                }
            }
        });
        finish_ng_bt.setIcon(new ImageIcon(MesClient.class.getResource("/bg/ng_bg.png")));
        finish_ng_bt.setFont(new Font("微软雅黑", Font.PLAIN, 32));
        finish_ng_bt.setBounds(508, 341, 240, 80);
        finish_ng_bt.setEnabled(false);
        // 镭雕工位不需要手动点NG，隐藏但保留逻辑复用
        finish_ng_bt.setVisible(false);
        indexPanelA.add(finish_ng_bt);

        // ===== 手动模式面板 =====
        JLabel debugTitle = new JLabel("手动模式");
        debugTitle.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        debugTitle.setForeground(Color.GRAY);
        debugTitle.setHorizontalAlignment(SwingConstants.CENTER);
        debugTitle.setVisible(true);
        debugTitle.setBounds(760, 40, 220, 30);
        indexPanelA.add(debugTitle);

        manualSteelSnInput = new JTextField();
        manualSteelSnInput.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        manualSteelSnInput.setBounds(760, 80, 220, 40);
        manualSteelSnInput.setToolTipText("输入11位钢印码");
        manualSteelSnInput.getDocument().addDocumentListener(new DocumentListener() {
            public void insertUpdate(DocumentEvent e) {
                updateManualSubmitButtons();
            }

            public void removeUpdate(DocumentEvent e) {
                updateManualSubmitButtons();
            }

            public void changedUpdate(DocumentEvent e) {
                updateManualSubmitButtons();
            }
        });
        indexPanelA.add(manualSteelSnInput);

        manualGetCodeBt = new JButton("模拟获取镭雕码");
        manualGetCodeBt.setEnabled(false);
        manualGetCodeBt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                if (!isManualSteelSnReady()) {
                    MesClient.setMenuStatus("请输入11位钢印码", 1);
                    updateManualSubmitButtons();
                    return;
                }
                if (laserFlowManager.isWaitingComplete()) {
                    MesClient.setMenuStatus("镭雕进行中，请先完成或复位", 1);
                    return;
                }
                manualWaitingComplete = true;
                manualCompleting = false;
                laserFlowManager.simulateGetCode(manualSteelSnInput.getText());
                updateManualSubmitButtons();
            }
        });
        manualGetCodeBt.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        manualGetCodeBt.setBounds(760, 130, 220, 50);
        indexPanelA.add(manualGetCodeBt);

        manualFinishOkBt = new JButton("模拟完成信号(OK)");
        manualFinishOkBt.setEnabled(false);
        manualFinishOkBt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                manualCompleting = true;
                updateManualSubmitButtons();
                laserFlowManager.simulateComplete("OK", "");
            }
        });
        manualFinishOkBt.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        manualFinishOkBt.setBounds(760, 190, 220, 50);
        indexPanelA.add(manualFinishOkBt);

        manualUnbindBt = new JButton("解绑钢印码");
        manualUnbindBt.setEnabled(false);
        manualUnbindBt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                requestUnbindSteelSn(manualSteelSnInput.getText());
            }
        });
        manualUnbindBt.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        manualUnbindBt.setBounds(760, 250, 220, 50);
        indexPanelA.add(manualUnbindBt);
        JButton debugSimNgBtn = new JButton("模拟完成信号(NG)");
        debugSimNgBtn.setVisible(false);
        debugSimNgBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                laserFlowManager.simulateComplete("NG", "模拟打码失败");
            }
        });
        indexPanelA.add(debugSimNgBtn);

        JButton debugGenSnBtn = new JButton("测试生成客户编码");
        debugGenSnBtn.setVisible(false);
        debugGenSnBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                laserFlowManager.manualGenCustomerSn(manualSteelSnInput.getText());
            }
        });
        indexPanelA.add(debugGenSnBtn);
        // ===== 手动模式面板结束 =====

        JButton modbusBtn = new JButton("关");
        modbusBtn.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ModbusRtu.closeDevice(serialPort);
            }
        });
        modbusBtn.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        modbusBtn.setBounds(208, 241, 160, 60);
//        indexPanelA.add(modbusBtn);

        JButton modbusBtn2 = new JButton("开");
        modbusBtn2.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ModbusRtu.openDevice(serialPort);
            }
        });
        modbusBtn2.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        modbusBtn2.setBounds(388, 241, 160, 60);
//        indexPanelA.add(modbusBtn2);

        JButton modbusBtn3 = new JButton("查询");
        modbusBtn3.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                ModbusRtu.readCoil(serialPort,0);
            }
        });
        modbusBtn3.setFont(new Font("微软雅黑", Font.PLAIN, 16));
        modbusBtn3.setBounds(568, 241, 160, 60);
//        indexPanelA.add(modbusBtn3);

        VisualUiEditorPanel.applySavedDesign(indexPanelA);

        tabbedPane.addTab("工作面板", new ImageIcon(MesClient.class.getResource("/bg/a_side.png")), indexScrollPaneA, null);
        tabbedPane.setEnabledAt(0, true);

        JPanel unbindPanel = new JPanel();
        JScrollPane unbindScrollPane = new JScrollPane(unbindPanel);
        unbindPanel.setLayout(null);

        JLabel unbindTitle = new JLabel("钢印码解绑");
        unbindTitle.setHorizontalAlignment(SwingConstants.CENTER);
        unbindTitle.setForeground(Color.BLACK);
        unbindTitle.setFont(new Font("微软雅黑", Font.PLAIN, 28));
        unbindTitle.setBounds(260, 80, 420, 50);
        unbindPanel.add(unbindTitle);

        JLabel unbindInputLabel = new JLabel("钢印码");
        unbindInputLabel.setHorizontalAlignment(SwingConstants.RIGHT);
        unbindInputLabel.setForeground(Color.BLACK);
        unbindInputLabel.setFont(new Font("微软雅黑", Font.PLAIN, 22));
        unbindInputLabel.setBounds(170, 170, 120, 50);
        unbindPanel.add(unbindInputLabel);

        final JTextField unbindSteelSnInput = new JTextField();
        unbindSteelSnInput.setHorizontalAlignment(SwingConstants.CENTER);
        unbindSteelSnInput.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        unbindSteelSnInput.setToolTipText("输入11位钢印码");
        unbindSteelSnInput.setBounds(320, 170, 340, 50);
        unbindPanel.add(unbindSteelSnInput);

        final JButton unbindSteelSnBt = new JButton("解绑钢印码");
        unbindSteelSnBt.setEnabled(false);
        unbindSteelSnBt.setFont(new Font("微软雅黑", Font.PLAIN, 24));
        unbindSteelSnBt.setBounds(320, 250, 220, 60);
        unbindSteelSnBt.addActionListener(new ActionListener() {
            public void actionPerformed(ActionEvent e) {
                requestUnbindSteelSn(unbindSteelSnInput.getText(), unbindSteelSnInput);
            }
        });
        unbindPanel.add(unbindSteelSnBt);

        unbindSteelSnInput.getDocument().addDocumentListener(new DocumentListener() {
            private void update() {
                boolean ready = unbindSteelSnInput.getText().trim().length() == 11;
                boolean laserBusy = laserFlowManager != null && laserFlowManager.isWaitingComplete();
                unbindSteelSnBt.setEnabled(ready && !laserBusy);
            }

            public void insertUpdate(DocumentEvent e) {
                update();
            }

            public void removeUpdate(DocumentEvent e) {
                update();
            }

            public void changedUpdate(DocumentEvent e) {
                update();
            }
        });

        tabbedPane.addTab("钢印解绑", new ImageIcon(MesClient.class.getResource("/bg/delete.png")), unbindScrollPane, null);

//		searchScrollPane = new JScrollPane((Component) null);

        indexPanelC = new JPanel();
        searchScrollPaneDj = new JScrollPane(indexPanelC);
        indexPanelC.setLayout(null);

        tabbedPane.addTab("开班点检", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), searchScrollPaneDj, null);


        indexPanelB = new JPanel();
        searchScrollPane = new JScrollPane(indexPanelB);
        indexPanelB.setLayout(null);

		tabbedPane.addTab("工作记录", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), searchScrollPane, null);

        VisualUiEditorPanel visualEditorPanel = new VisualUiEditorPanel(indexPanelA);
        final JDialog visualEditorToolWindow = new JDialog(this, false);
        visualEditorToolWindow.setTitle("UI");
        visualEditorToolWindow.setContentPane(visualEditorPanel.createExternalToolPanel());
        visualEditorToolWindow.pack();
        addComponentListener(new ComponentAdapter() {
            public void componentMoved(ComponentEvent e) {
                if (visualEditorToolWindow.isVisible()) {
                    positionVisualEditorToolWindow(visualEditorToolWindow);
                }
            }

            public void componentResized(ComponentEvent e) {
                if (visualEditorToolWindow.isVisible()) {
                    positionVisualEditorToolWindow(visualEditorToolWindow);
                }
            }
        });
        // UI面板默认隐藏，三击时间状态栏并输入密码后再显示。
        heart_beat_menu.addMouseListener(new MouseAdapter() {
            @Override
            public void mouseClicked(MouseEvent e) {
                if (e.getClickCount() != 3) {
                    return;
                }
                JPasswordField passwordField = new JPasswordField();
                int ret = JOptionPane.showConfirmDialog(
                        MesClient.this,
                        passwordField,
                        "请输入UI密码",
                        JOptionPane.OK_CANCEL_OPTION,
                        JOptionPane.PLAIN_MESSAGE);
                if (ret != JOptionPane.OK_OPTION) {
                    return;
                }
                String password = new String(passwordField.getPassword());
                if (!ui_design_password.equals(password)) {
                    setMenuStatus("UI密码错误", 1);
                    return;
                }
                int index = tabbedPane.indexOfComponent(visualEditorPanel);
                if (index < 0) {
                    tabbedPane.addTab("UI", null, visualEditorPanel, null);
                    index = tabbedPane.indexOfComponent(visualEditorPanel);
                }
                tabbedPane.setSelectedIndex(index);
                positionVisualEditorToolWindow(visualEditorToolWindow);
                visualEditorToolWindow.setVisible(true);
            }
        });


		tabbedPane.addChangeListener(new ChangeListener() {
            @Override
            public void stateChanged(ChangeEvent e) {
                JTabbedPane tabbedPane = (JTabbedPane) e.getSource();
                int selectedIndex = tabbedPane.getSelectedIndex();
                System.out.println("selectedIndex:"+selectedIndex);
                boolean visualEditorSelected = selectedIndex >= 0 && tabbedPane.getComponentAt(selectedIndex) == visualEditorPanel;
                if (visualEditorSelected) {
                    positionVisualEditorToolWindow(visualEditorToolWindow);
                    visualEditorToolWindow.setVisible(true);
                } else {
                    visualEditorToolWindow.setVisible(false);
                }

                // getCheckResult()调用已移除：原用于驱动继电器(formatDeviceState)，
                // 继电器功能已不再使用
            }
        });
        
        // 确保窗口布局正确
        pack();
        setSize(1024, 768);
        validate();
        repaint();
    }

    private void positionVisualEditorToolWindow(JDialog toolWindow) {
        Point location = getLocationOnScreen();
        int x = location.x + getWidth() - 1;
        int y = location.y + 110;
        toolWindow.pack();
        toolWindow.setLocation(x, y);
    }

    // 获取开班点检状态
    public static void getCheckResult(){
        try{
            JSONObject retObj = DataUtil.getCheckResult();
            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) { // 已点检
                MesClient.checkState = true;
            }else{ // 未点检
                MesClient.checkState = false;
            }
        }catch (Exception e){
            e.printStackTrace();
            MesClient.checkState = false;
        }
        MesClient.formatDeviceState();
    }

    // 格式化设备启动状态
    public static void formatDeviceState(){
        try{
            if(MesClient.checkState){ // 检查物料是否已绑定
                if(rowData == null){
                    ModbusRtu.openDevice(serialPort);
                }else{
                    // 判断物料是否可启动
                    int flag = 0;
                    int i = 0;
                    for (Object object:rowData){
                        Integer times = Integer.valueOf(String.valueOf(rowData[i][2]));
                        if(times < 1){
                            flag = 1;
                        }
                        i++;
                    }
                    if(flag == 1){ // 不能启动
                        ModbusRtu.closeDevice(serialPort);
                    }else{
                        // 可启动
                        ModbusRtu.openDevice(serialPort);
                    }
                }
            }else{
                //不能启动
                ModbusRtu.closeDevice(serialPort);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
    }

    public static void getMaterailData(){
        JSONObject retObj = DataUtil.getBindMaterail();
        if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
            java.util.List<BindMaterialResp> arrs = retObj.getList("data",BindMaterialResp.class);
            int i = 0;
            rowData = new Object[arrs.size()][7];
            for (BindMaterialResp bindMaterialResp:arrs){
                rowData[i][0] = bindMaterialResp.getMaterialTitle();
                rowData[i][1] = bindMaterialResp.getBatchSn();
                rowData[i][2] = bindMaterialResp.getLastTimes();
                rowData[i][3] = "";
                rowData[i][4] = bindMaterialResp.getCraft();
                rowData[i][5] = bindMaterialResp.getMaterialId();
                rowData[i][6] = bindMaterialResp.getType();
                i++;
            }
            bindBatchPanel();
        }
    }

    public static void updateMaterailData(){
        JSONObject retObj = DataUtil.getBindMaterail();
        if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
            List<BindMaterialResp> arrs = retObj.getList("data",BindMaterialResp.class);

            int i = 0;
            for (BindMaterialResp bindMaterialResp:arrs){
                rowData[i][0] = bindMaterialResp.getMaterialTitle();
                rowData[i][1] = bindMaterialResp.getBatchSn();
                rowData[i][2] = bindMaterialResp.getLastTimes();
                rowData[i][3] = "";
                rowData[i][4] = bindMaterialResp.getCraft();
                rowData[i][5] = bindMaterialResp.getMaterialId();
                rowData[i][6] = bindMaterialResp.getType();
                i++;
            }

            MesClient.table.repaint();
        }
    }

    // 绑定物料批次码
    public static void scanBatchSn(BindMaterialResp bindMaterialResp) {
        //弹窗扫工件码
        String scanBarcodeTitle = "请扫物料:"+bindMaterialResp.getMaterialTitle();
        String scanBarcode = JOptionPane.showInputDialog(null, scanBarcodeTitle);
        if(scanBarcode!=null&&!scanBarcode.equalsIgnoreCase("")) {

            JSONObject retObj = DataUtil.saveBindMaterail(scanBarcode,bindMaterialResp.getCraft(),bindMaterialResp.getMaterialId(),bindMaterialResp.getType());
            if(retObj.get("result")!=null&&retObj.get("result").toString().equalsIgnoreCase("true")) {
                MesClient.setMenuStatus("扫物料:"+bindMaterialResp.getMaterialTitle()+"成功",0);
                updateMaterailData();
            }else{
                if(retObj.get("result")==null){
                    MesClient.setMenuStatus("请求失败，请重试",-1);
                }else{
                    if(retObj.get("result").toString().equalsIgnoreCase("false")){
                        MesClient.setMenuStatus(retObj.getString("message"),-1);
                    }
                }
            }
        }
    }

    public static void bindBatchPanel(){
        JPanel indexPanelBB = new JPanel();
        JPanel panel = new JPanel();
        panel.setBounds(0, 0, 990, 550);
//        panel.setBounds(81, 50, 810, 479);
        indexPanelBB.add(panel);

        panel.setLayout(new GridLayout(0, 1, 0, 0));
        table = new JTable(rowData, columnNames){
            public boolean isCellEditable(int row, int column) {
                if(column == 3){
                    return true;
                }
                return false;
            }
        };
        table.setRowHeight(40);
        table.setEnabled(true);
        table.setFont(new Font("微软雅黑", Font.PLAIN, 14));

        table.getColumnModel().getColumn(3).setCellRenderer(new TableCellRendererButton());
        table.getColumnModel().getColumn(3).setCellEditor(new TableCellEditorButton());


        JScrollPane scrollPane = new JScrollPane(table);
        panel.add(scrollPane);

        JScrollPane indexScrollPaneB = new JScrollPane(indexPanelBB);
        indexPanelBB.setLayout(null);
        tabbedPane.addTab("绑定物料", new ImageIcon(MesClient.class.getResource("/bg/menu_data_preprocess.png")), indexScrollPaneB, null);
    }

}