ISCS_Cabinet_WIN/main.qml

import QtQuick
import QtQuick.VirtualKeyboard
import QtQuick.Layouts
import "./content"
import QtQuick.Controls

import com.lock 1.0  // 导入 C++ 类
import com.rfid 1.0
import com.pro 1.0
import com.httpclient 1.0
import com.finger 1.0
import com.timeout 1.0

// import com.InteractiveCore 1.0
import com.InteractiveTask 1.0
// import com.InteractiveFace 1.0

ApplicationWindow {
    id: window
    visible: true
    width: 1920
    height: 1080
    title: "Cabinet"

    property bool lockWorkStat: false
    property bool windowIsQuit: false

    signal lockThreadExit
    signal rfidThreadExit
    signal httpThreadExit
    signal proThreadExit
    signal fingerThreadExit

    visibility: Window.FullScreen       // 设置窗口为全屏
    flags: Qt.FramelessWindowHint       // 设置窗口无边框
    // flags: Qt.WindowStaysOnTopHint | Qt.FramelessWindowHint  // 设置窗口无边框且强制置顶

    Image {
        id: image
        x: 0
        y: 0
        width: 1920
        height: 1080
        // width: parent.width
        // height: parent.height
        source: "qrc:/png/backspace.png"
        fillMode: Image.PreserveAspectFit
    }

    // 捕获关闭事件
    onClosing: {
        // close.accepted = false; // 阻止默认关闭行为
        // confirmExitDialog.open(); // 打开确认对话框
        exitWork();

        Qt.quit(); // 用户选择“是”，退出应用程序
    }

    WaitPromptBox {
        id: waitPromptBox
        visible: false
    }

    InfoPromptBox {
        id: infoPromptBox
        visible: false
    }

    HangPromptBox {
        id: hangPromptBox
        visible: false
    }

    Component.onCompleted:{
        waitPromptBox.hide();
        infoPromptBox.hide();
        hangPromptBox.hide();
        loginScreen.visible = true;
    }

    Dialog {
        id: confirmExitDialog
        title: "Confirm Exit"
        standardButtons: Dialog.Yes | Dialog.No

        contentItem: Text {
            text: "是否确认退出程序?"
            font.pixelSize: 16
        }

        onAccepted: {

            exitWork();

        }

        onRejected: {
            confirmExitDialog.close(); // 用户选择“否”，关闭对话框
        }
    }

    function exitWork() {
        console.log("Work exit!");
        httpThreadExit();
        lockThreadExit();
        rfidThreadExit();
        proThreadExit();
        fingerThreadExit();
        quit_timer.start();
    }

    Timer {
        id: quit_timer
        interval: 2000 // 1秒后触发一次（1000毫秒）
        running: false // 默认不运行，通过程序控制启动和停止
        repeat: false // 不重复触发
        onTriggered: {
            Qt.quit(); // 用户选择“是”，退出应用程序
        }
    }

    // InteractiveCore {
    //     id: interactiveCore
    // }

    // InteractiveFace{
    //     id: interactiveFace
    // }

    Timeout {
        id: timeout

        Component.onCompleted: {
            // signal_timeoutRun.connect();
        }

        onSignal_timeoutRun: function(epoch)
        {
            materialDialog.timeout_refresh(epoch);
        }

        onSignal_timeoutStart:
        {
            materialDialog.show();
        }
        onSignal_timeoutEnd:
        {
            materialDialog.hide();
        }
    }

    Lock {
        id: lockThread
        onSignal_lock_run:(value)=>{ console.log("lockWorkStat:", value); } // 连接信号到槽（这里是JavaScript函数）
        Component.onCompleted: {
            lockThreadExit.connect(lockThread.slot_set_thread_stop);


            // 锁状态改变
            signal_lockStat.connect(proThread.slot_lockStat);
            signal_lockStat.connect(mainScreen.lockStat_callback);

            // 物资取还调用开柜
            materialTakeBack.signal_openLock.connect(lockThread.slot_openLock);
            // 物资更换调用开柜
            materialReplace.signal_openLock.connect(lockThread.slot_openLock);
            // 物资手动更换调用开柜
            materialManualReplace.signal_openLock.connect(lockThread.slot_openLock);
            // 异常处理调用开柜
            materialException.signal_openLock.connect(lockThread.slot_openLock);
            // 物资检查计划调用开柜
            materialCheckPlan.signal_openLock.connect(lockThread.slot_openLock);


            // 物资取还锁状态改变
            proThread.signal_lockStatTakeBack.connect(materialTakeBack.lockStat_callback);
            // 物资手动更换锁状态改变
            proThread.signal_lockStatReplaceHand.connect(materialManualReplace.lockStat_callback);
            // 物资自动更换锁状态改变
            proThread.signal_lockStatReplaceAuto.connect(materialReplace.lockStat_callback);
            // 异常处理锁状态改变
            proThread.signal_lockStatException.connect(materialException.lockStat_callback);
            // 物资检查计划锁状态改变
            proThread.signal_lockStatCheckPlan.connect(materialCheckPlan.lockStat_callback);

            start();
        } // 开始线程执行
    }

    Rfid {
        id: rfidThread
        Component.onCompleted: {
            rfidThreadExit.connect(rfidThread.slot_set_thread_stop);

            // 开始读rfid
            materialTakeBack.startReader.connect(rfidThread.slot_start_read_tid);
            materialReplace.startReader.connect(rfidThread.slot_start_read_tid);
            materialManualReplace.startReader.connect(rfidThread.slot_start_read_tid);
            materialException.startReader.connect(rfidThread.slot_start_read_tid);
            materialCheckPlan.startReader.connect(rfidThread.slot_start_read_tid);

            // 读rfid返回
            signal_tid_update.connect(proThread.slot_tid_update);




            start();

        } // 开始线程执行
    }

    Pro {
        id: proThread
        Component.onCompleted: {
            proThreadExit.connect(proThread.slot_set_thread_stop);
            loginScreen.signal_login.connect(proThread.slot_login);
            mainScreen.signal_logout.connect(proThread.slot_logout);
            signal_login_return_stat.connect(loginScreen.login_return_stat);
            signal_login_return_param.connect(mainScreen.login_return_param);
            signal_updateMaterial.connect(materialSelmodel.slot_updateMaterial);
            signal_updateMaterial.connect(materialTakeBack.slot_updateMaterial);

            signal_updateMaterialHand.connect(materialManualReplace.slot_updateMaterialHand);

            // signal_updatetakebackMaterial.connect(materialStatistics.slot_updatetakebackMaterial);
            signal_fingerWork.connect(fingerThread.slot_fingerWork);
            signal_post_request_data.connect(httpThread.slot_post_request_data);
            signal_get_request_data.connect(httpThread.slot_get_request_data);
            signal_addFinger_act.connect(setView.slot_addFinger_act);
            materialTakeBack.signal_takebackstat.connect(proThread.slot_takebackstat);
            setView.signal_saveConfig.connect(proThread.slot_saveConfig);
            setView.signal_addfinger.connect(proThread.slot_addfinger);
            loginScreen.signal_fingerWork.connect(proThread.slot_fingerWork);

            // 物资更换锁状态改变
            materialReplace.signal_takebackstat.connect(proThread.slot_takebackstat);
            materialManualReplace.signal_takebackstat.connect(proThread.slot_takebackstat);
            // 异常处理锁状态改变
            materialException.signal_takebackstat.connect(proThread.slot_takebackstat);

            // 物资检查计划
            materialCheckPlan.signal_takebackstat.connect(proThread.slot_takebackstat);


            // // 手动更换
            // signal_updatetakebackMaterialHand.connect(materialReplaceHand.slot_updatetakebackMaterial);
            // // 自动更换
            // signal_updatetakebackMaterialAuto.connect(materialReplaceAuto.slot_updatetakebackMaterial);
            // // 物资检查计划
            // signal_updatematerialCheckPlan.connect(materialCheckUpdate.slot_updatetakebackMaterial);

            signal_updatetakebackMaterial.connect(materialStocktaking.slot_updatetakebackMaterial);
            signal_updatetakebackMaterialHand.connect(materialStocktaking.slot_updatetakebackMaterial);
            signal_updatetakebackMaterialAuto.connect(materialStocktaking.slot_updatetakebackMaterial);
            signal_updateExceptionHandle.connect(materialStocktaking.slot_updatetakebackMaterial);
            signal_updatematerialCheckPlan.connect(materialStocktaking.slot_updatetakebackMaterial);




            // 2025-06-23 wxh
            // 获取使用说明
            materialInstructions.signal_get.connect(proThread.slot_instructionsGet);

            // 使用说明数据返回
            proThread.signal_materialTypeGet.connect(materialInstructions.slot_materialTypeGet);
            proThread.signal_instructionsGet.connect(materialInstructions.slot_instructionsGet);

            // pdf实时下载
            materialInstructions.signal_pdf_click.connect(proThread.slot_pdf_click);
            proThread.signal_pdf_relay.connect(materialInstructions.slot_pdf_relay);

            // 获取物资检查计划
            materialCheckPlan.signal_getMaterialCheckPlan.connect(proThread.slot_getMaterialCheckPlan);
            // 获取物资检查计划数据返回
            proThread.signal_getMaterialCheckPlan.connect(materialCheckPlan.slot_getMaterialCheckPlan);

            // 获取物资检查列表
            materialCheckForm.signal_getMaterialCheckForm.connect(proThread.slot_getMaterialCheckForm);
            // 获取物资键槽列表返回
            proThread.signal_getMaterialCheckForm.connect(materialCheckForm.slot_getMaterialCheckForm);

            // 保存
            materialCheckForm.signal_postSaveForm.connect(proThread.slot_postSaveForm);
            proThread.signal_postSaveForm.connect(materialCheckForm.slot_postSaveForm);

            // 检查签名
            materialCheckSign.signal_postCheckSign.connect(proThread.slot_postCheckSign);
            proThread.signal_postCheckSign.connect(materialCheckSign.slot_postCheckSign);

            // 最终提交物资检查记录
            materialCheckPlan.signal_postSubmit.connect(proThread.slot_postSubmit);
            proThread.signal_postSubmit.connect(materialCheckPlan.slot_postSubmit);

            // 获取物资列表信息
            // materialReplace.signal_getMaterialInfoList.connect(proThread.slot_getMaterialInfoList);
            // proThread.signal_getMaterialInfoList.connect(materialReplace.slot_getMaterialInfoList);



            signal_backRefresh.connect(materialDialogBack.slot_backRefresh);
            signal_takeRefresh.connect(materialDialogTake.slot_takeRefresh);

            // 全局鼠标点击事件，退出定时器
            signal_global_mouse_clicked.connect(mainScreen.resetLogin_timeout);

            start();
        } // 开始线程执行
    }

    Httpclient{
        id: httpThread
        Component.onCompleted: {
            httpThreadExit.connect(httpThread.slot_set_thread_stop);
            signal_response_data.connect(proThread.slot_response_data);
            start();
        }
    }

    Finger{
        id: fingerThread
        Component.onCompleted: {
            fingerThreadExit.connect(fingerThread.slot_set_thread_stop);
            signal_fingerStat.connect(proThread.slot_fingerStat);
            // start();
        }
    }

    Login {
        id: loginScreen
        visible: false
    }

    MainScreen{
        id:mainScreen
        visible: false
    }

    MaterialSelModel{
        id:materialSelmodel
        visible: false
    }

    MaterialTakeBack{
        id: materialTakeBack
        visible: false
    }

    MaterialStatistics {
        id: materialStatistics
        visible: false
    }

    MaterialInstructions {
        id: materialInstructions
        visible: false
    }

    MaterialCheckPlan {
        id: materialCheckPlan
        visible: false
    }

    MaterialCheckUpdate {
        id: materialCheckUpdate
        visible: false
    }


    MaterialCheckForm {
        id: materialCheckForm
        visible: false
    }

    MaterialCheckSign {
        id: materialCheckSign
        visible: false
    }

    MaterialReplace {
        id: materialReplace
        visible: false
    }

    MaterialManualReplace {
        id: materialManualReplace
        visible: false
    }

    MaterialReplaceHand
    {
        id: materialReplaceHand
        visible: false
    }

    MaterialReplaceAuto
    {
        id: materialReplaceAuto
        visible: false
    }

    SetView {
        id: setView
        visible: false
    }

    // 异常处理
    MaterialException {
        id: materialException
        visible: false
    }
    MaterialExceptionReport {
        id: materialExceptionReport
        visible: false
    }



    // MaterialExceptionFinish {
    //     id: materialExceptionFinish
    //     visible: false
    // }

    MaterialDialog {
        id: materialDialog
        visible: false
    }

    MaterialDialogTake {
        id: materialDialogTake
        visible: false
    }

    MaterialDialogBack {
        id: materialDialogBack
        visible: false
    }

    FacialRecognition
    {
        id: facialRecognition
        visible: false
    }

    MaterialStocktaking {
        id: materialStocktaking
        visible: false
    }


    // 更新电磁锁板子工作状态
    function lock_run_stat_callback(value) {
        lockWorkStat = value;
    }

}