GUI/src/windows/MainWindow.cpp

#include "MainWindow.h"
#include "ui_MainWindow.h"

#include <fstream>
#include <QHBoxLayout>
#include <QScrollBar>
#include <QDateTime>
#include <QGestureEvent>
#include <QDockWidget>

#include "InitializeWidget.h"
#include "ShutdownWidget.h"
#include "event/EventCenter.h"
#include "forms/TabFormWidget.h"
#include "forms/recon/ReconFormWidget.h"
#include "forms/select/SelectFormWidget.h"
#include "forms/scan/ScanFormWidget.h"
#include "forms/settings/SettingFormWidget.h"
#include "forms/TopBarWidget.h"
#include "dialogs/DialogManager.h"
#include "device/DeviceManager.h"
#include "errorhandle/GUIErrorHandle.h"
#include "LoginDialog.h"
#include "models/User.h"
#include "appvals/AppGlobalValues.h"
#include "components/UTextEdit.h"
#include "components/WarningMessageWidget.h"
#include "json/jsonobject.h"
#include "db/SQLHelper.h"


MainWindow::MainWindow(QWidget* aParent)
    : QMainWindow(aParent)
    , mUI(new Ui::MainWindow)
    , mDebugConsoleWidget(nullptr)
    , mTabWidget(new QTabWidget(this))
    , mInitializWidget(new InitializeWidget(this))
    , mShutdownWidget(new ShutdownWidget(nullptr))
    , mTabInited(false)
{
    mUI->setupUi(this);
    this->setWindowFlags(Qt::Window);

    
    initializeLayout();

    connect(EventCenter::Default(), &EventCenter::PatientSelected, this,&MainWindow::switchToScanTab);
    connect(EventCenter::Default(), &EventCenter::RequestLogin, this,&MainWindow::requestLogin, Qt::QueuedConnection);
    connect(EventCenter::Default(), &EventCenter::LoginRoleChanged, this,&MainWindow::resetRoleLayout);
    connect(DeviceManager::Default(), &DeviceManager::raiseGlobalError, this, &MainWindow::triggerError);
    connect(DeviceManager::Default(), &DeviceManager::raiseGlobalInfo, this, &MainWindow::triggerInfo);
    connect(EventCenter::Default(), &EventCenter::ReloadLanguage, this, &MainWindow::reloadLanguage);
    connect(EventCenter::Default(), &EventCenter::RequestScreenSaver, this, &MainWindow::requestScreenSaver);
    connect(DeviceManager::Default(), &DeviceManager::initializeFinished, this, &MainWindow::requestLogin);
    connect(DeviceManager::Default(), &DeviceManager::initializeProgress, mInitializWidget, &InitializeWidget::setMessage);
    connect(DeviceManager::Default(), &DeviceManager::shutdownDmsSended, this, &MainWindow::showShutdownWidget);
    connect(DeviceManager::Default(), &DeviceManager::shutdownDmsFailed, this, &MainWindow::processShutdownDmsFailed);

    connect(EventCenter::Default(), &EventCenter::LoginSuccess, this, [this]()
    {
        mInitializWidget->setVisible(false);
    });
    
    connect(EventCenter::Default(), &EventCenter::UserVerificationSuccess, this, [this]()
    {
       if(!mTabInited){
            mTabInited = true;
            initializeTabWidget();
            mTabWidget->setCurrentIndex(0); 
        }
        mTabWidget->setVisible(true);
        this->update();
        QApplication::processEvents();
    });

    connect(EventCenter::Default(), &EventCenter::LoginSuccess, this,&MainWindow::checkEmptyScanValidity);
    connect(EventCenter::Default(), &EventCenter::EmptyScanFinished, this,&MainWindow::enableAllTabWidget);
    connect(EventCenter::Default(), &EventCenter::EmptyScanDataCorrupted, this, &MainWindow::handleEmptyScanDataCorrupted);

    connect(mTabWidget, &QTabWidget::currentChanged, this, [this](int aIndex)
    {
       if(aIndex == 0)
       {
           mTabWidget->widget(0)->setFocus();
       }
    });

    connect(DeviceManager::Default(), &DeviceManager::startAutoLocateResult, [this](bool aIsSucceed)
    {
        if(aIsSucceed)
        {
            for(int i=0; i<mTabWidget->count(); ++i)
            {
                if(i != mTabWidget->currentIndex())
                {
                    mTabWidget->setTabEnabled(i, false);
                }
            }
        }
    });

    connect(EventCenter::Default(), &EventCenter::StopScanProcess, this, [this]()
    {
        for(int i=0; i<mTabWidget->count(); ++i)
        {
            if(i != mTabWidget->currentIndex())
            {
                mTabWidget->setTabEnabled(i, true);
            }
        }
    });
            
    GUIErrorHandle::Default()->init();
    QApplication::setActiveWindow(centralWidget());
}

MainWindow::~MainWindow()
{
    delete mUI;
    delete mShutdownWidget;
}

//------Layout-----------------------------------------------------------------

void MainWindow::loadStyleSheet(const QString& aSheetName)
{
//    QFile file(":/stylesheet/" + aSheetName + ".css");
//    file.open(QFile::ReadOnly);
//    if (file.isOpen())
//    {
//        QString styleSheet = this->styleSheet();
//        styleSheet += QLatin1String(file.readAll());
//        this->setStyleSheet(styleSheet);
//    }
}

void MainWindow::initializeLayout()
{
    auto layout = new QVBoxLayout(mUI->mCentralWidget);
    layout->setMargin(0);
    layout->setSpacing(0);
    TopBarWidget* topBarWidget = new TopBarWidget(this);
    auto popNotifications = new WarningMessageWidget(this);
    popNotifications->hide();
    connect(topBarWidget,&TopBarWidget::warnBtnClicked,[=](){
        auto pos = topBarWidget->mapToGlobal(QPoint(topBarWidget->width(),topBarWidget->height()));
        popNotifications->setPopupArgs(height(),pos.x(),pos.y());
        popNotifications->show();
    });
    layout->addWidget(topBarWidget);
    layout->addWidget(mTabWidget);
    layout->addWidget(mInitializWidget);

    mTabWidget->setVisible(false);
    mShutdownWidget->setVisible(false);
}

void MainWindow::checkEmptyScanValidity()
{
     QDate lastScanDate = SQLHelper::queryValue("SELECT ScanDateTime FROM EScan ORDER BY ScanDateTime DESC LIMIT 1").toDate();
     QDate expirationScanDate = lastScanDate.addMonths(1);
     QDate currentDate = QDate::currentDate();

     if(currentDate.daysTo(expirationScanDate) < 0)
     {
         mTabWidget->setTabEnabled(0, false);
         mTabWidget->setTabEnabled(1, false);
         mTabWidget->setTabEnabled(2, false);
         mTabWidget->setCurrentIndex(3);

         DialogManager::Default()->requestAlertMessage(tr("Please execute the empty scan, assist with system calibration, when empty scan is completed, the system should operate normally."), OkOnly, tr("Warning"));
         return;
     }

     if(currentDate.daysTo(expirationScanDate) < 3)
     {
         DialogManager::Default()->requestAlertMessage(tr("There are %1 days left until the next empty scan. Please remind users to conduct the empty scan in time.").arg(currentDate.daysTo(expirationScanDate) + 1), OkOnly, tr("Warning"));
         return;
     }
}

void MainWindow::initializeTabWidget()
{
    mTabWidget->setTabPosition(QTabWidget::South);
    mTabWidget->setContentsMargins(0, 0, 0, 0);
    auto* systemForm = new SettingFormWidget(this);
    mTabWidget->insertTab(0 ,systemForm, tr("Settings"));
    auto verifyForm = new ReconFormWidget(this);
    mTabWidget->insertTab(0,verifyForm, tr("Recon"));
    auto selectForm = new SelectFormWidget(this);
    mTabWidget->insertTab(0,selectForm, tr("Select"));
    auto scanForm = new ScanFormWidget(this);
    mTabWidget->insertTab(0,scanForm, tr("Scan"));

    mTabWidget->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);


}

void MainWindow::reloadLanguage() {
    mTabWidget->setTabText(0, tr("Scan"));
    mTabWidget->setTabText(1, tr("Select"));
    mTabWidget->setTabText(2, tr("Recon"));
    mTabWidget->setTabText(3, tr("Settings"));
}

void MainWindow::showShutdownWidget()
{
    mShutdownWidget->setVisible(true);
}

void MainWindow::processShutdownDmsFailed()
{
    mShutdownWidget->setVisible(false);
    triggerError(tr("Shut down failed, please push emergency button to shutdown."));
}

void MainWindow::switchToScanTab(QObject* sender, QObject* data) { 
    if (data)mTabWidget->setCurrentIndex(0);
}

void MainWindow::centerWidgetHide()
{
    mUI->mCentralWidget->setVisible(false);
}

void MainWindow::centerWidgetShow()
{
    mUI->mCentralWidget->setVisible(true);
}

void MainWindow::triggerError(const QString& aMessage)
{
    QString message(aMessage);
    EventCenter::Default()->triggerEvent(GUIErrorRaise, nullptr, (QObject*)&message);
}

void MainWindow::triggerInfo(const QPair<QString, unsigned int>& aInfoData)
{
    QPair<QString, unsigned int> infoData = aInfoData;
    EventCenter::Default()->triggerEvent(DeviceInfoRaise, nullptr, (QObject*)&infoData);
}

//------events-----------------------------------------------------------------

//! [event handler]
bool MainWindow::event(QEvent* aEvent)
{
    if (aEvent->type() == QEvent::Gesture)
    {
        return gestureEvent(static_cast<QGestureEvent*>(aEvent));
    }
    return QMainWindow::event(aEvent);
}

void MainWindow::changeEvent(QEvent* aEvent)
{
    if (aEvent->type() == QEvent::LanguageChange)
    {
        mUI->retranslateUi(this);
    }

    QWidget::changeEvent(aEvent);
}


void MainWindow::keyPressEvent(QKeyEvent *event) {
    if (event->modifiers()==Qt::ControlModifier &&event->key()==Qt::Key_R){
        QFile file("D:\\workdir\\GUI\\src\\stylesheet\\Dark2.css");
        file.open(QFile::ReadOnly);
        if (file.isOpen())
        {
            QString styleSheet = this->styleSheet();
            styleSheet += QLatin1String(file.readAll());
            this->setStyleSheet(styleSheet);
        }
        this->update();
    }

    QWidget::keyPressEvent(event);
}

bool MainWindow::gestureEvent(QGestureEvent* aGestureEvent)
{
    if (QGesture* swipe = aGestureEvent->gesture(Qt::SwipeGesture))
    {
        swipeTriggered(static_cast<QSwipeGesture*>(swipe));
    }
    if (QGesture* pan = aGestureEvent->gesture(Qt::PanGesture))
    {
        panTriggered(static_cast<QPanGesture*>(pan));
    }
    return true;
}

void MainWindow::grabGestures(const QList<Qt::GestureType>& aGestures)
{
    //! [enable gestures]
            foreach(Qt::GestureType gesture, aGestures)
        {
            grabGesture(gesture);
        }
    //! [enable gestures]
}

void MainWindow::panTriggered(QPanGesture* aPanGesture)
{
    if (aPanGesture->state() == Qt::GestureFinished)
    {
        QPointF delta = aPanGesture->offset();
        int index = mTabWidget->currentIndex();
        if (delta.x() > 50)
        {

            index--;
            if (index >= 0)
            {
                mTabWidget->setCurrentIndex(index);
            }
        }
        if (delta.x() < -50)
        {
            index++;
            if (index < mTabWidget->count())
            {
                mTabWidget->setCurrentIndex(index);
            }
        }
    }
}

void MainWindow::swipeTriggered(QSwipeGesture* aSwipeGesture)
{
    if (aSwipeGesture->state() == Qt::GestureFinished)
    {
    }
}

//------actions & slots--------------------------------------------------------

void MainWindow::requestLogin()
{
    DialogManager::Default()->requestLogin(this);
    QApplication::setActiveWindow(centralWidget());
}

void MainWindow::requestScreenSaver()
{
    DialogManager::Default()->requestScreenSaverPlay();
}

void MainWindow::resetRoleLayout() {
    SettingFormWidget* settingWidget = dynamic_cast<SettingFormWidget*>(mTabWidget->widget(3));
    if(settingWidget == nullptr)
    {
        return;
    }
    if (User::Current()->isAdmin())
    {
        settingWidget->showAdminArea();
    }
    else
    {
        settingWidget->hideAdminArea();
    }
}

void MainWindow::enableAllTabWidget()
{
    for(int i=0; i<mTabWidget->count(); ++i)
    {
        mTabWidget->setTabEnabled(i, true);
    }
}

void MainWindow::handleEmptyScanDataCorrupted()
{
    mTabWidget->setTabEnabled(0, false);
    mTabWidget->setTabEnabled(1, false);
    mTabWidget->setTabEnabled(2, false);
    mTabWidget->setCurrentIndex(3);

    DialogManager::Default()->requestAlertMessage(tr("Due to empty scan data corruption on the server, needs to be execute the empty scan. No other operations can be conducted until the scan is complete."), OkOnly, tr("Warning"));
}