EnergySpectrumAnalyer/src/MainWindow.cpp

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

#include <QAction>
#include <QDateTime>
#include <QDir>
#include <QHBoxLayout>
#include <QLabel>
#include <QMenu>
#include <QPlainTextEdit>
#include <QScrollBar>

#include "DockAreaWidget.h"
#include "DockComponentsFactory.h"
#include "DockManager.h"
#include "DockWidget.h"
#include "FloatingDockContainer.h"

#include "AboutDlg.h"
#include "DataProcessWorkPool.h"
#include "EneryScaleForm.h"
#include "MeasureAnalysisHistoryForm.h"
#include "MeasureAnalysisProjectModel.h"
#include "MeasureAnalysisTree.h"
#include "MeasureDeviceParamsCfgForm.h"
#include "NewMeasureAnalysisDlg.h"
#include "MeasureAnalysisView.h"
#include "MeasureAnalysisActions.h"

using namespace ads;

QMutex MainWindow::_s_mutex_info_output;
QPlainTextEdit* MainWindow::_s_plain_edit_info_output = nullptr;
QStatusBar* MainWindow::_s_status_bar = nullptr;

void MainWindow::OutputInfo(OutputInfoType out_type, const QString& ouput_info)
{
    if (!ouput_info.isEmpty()) {
        QStringList list_str_out_type = {
            QStringLiteral(u"信息"),
            QStringLiteral(u"警告"),
            QStringLiteral(u"错误"),
            QStringLiteral(u"调试")
        };
        QList<QColor> list_color_out_type = {
            Qt::black,
            Qt::darkYellow,
            Qt::red,
            Qt::darkBlue
        };
        const QString& ouput_text = QString("%1 [%2] : %3")
                                        .arg(QDateTime::currentDateTime().toString("yyyy-MM-dd hh:mm:ss"))
                                        .arg(list_str_out_type.at(int(out_type)))
                                        .arg(ouput_info);
        QTextCharFormat cur_fmt, fmt;
        fmt.setForeground(QBrush(list_color_out_type.at(out_type)));
        _s_mutex_info_output.lock();
        cur_fmt = _s_plain_edit_info_output->currentCharFormat();
        _s_plain_edit_info_output->mergeCurrentCharFormat(fmt);
        _s_plain_edit_info_output->appendPlainText(ouput_text);
        _s_plain_edit_info_output->setCurrentCharFormat(cur_fmt);
        QScrollBar* scrollbar = _s_plain_edit_info_output->verticalScrollBar();
        if (scrollbar) {
            scrollbar->setSliderPosition(scrollbar->maximum());
        }
        _s_plain_edit_info_output->update();
        _s_mutex_info_output.unlock();
    }
}

void MainWindow::ShowStatusBarMsg(const QString& msg)
{
    _s_status_bar->showMessage(msg);
}

MainWindow::MainWindow(QWidget* parent)
    : QMainWindow(parent)
    , ui(new Ui::MainWindow)
{
    ui->setupUi(this);
    _s_status_bar = ui->statusbar;

    initMainWindow();
    initAction();

    this->applyStyleSheet();
}

MainWindow::~MainWindow()
{
    delete ui;
}

void MainWindow::initMainWindow()
{
    ads::CDockManager::setConfigFlag(CDockManager::FocusHighlighting, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::DockAreaHasCloseButton, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::AllTabsHaveCloseButton, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::DockAreaHasUndockButton, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::DockAreaDynamicTabsMenuButtonVisibility, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::DisableTabTextEliding, true);
    ads::CDockManager::setConfigFlag(ads::CDockManager::DoubleClickUndocksWidget, false);
    ads::CDockManager::setAutoHideConfigFlags({ CDockManager::DefaultAutoHideConfig });

    _dock_manager = new CDockManager(this);
    _dock_manager->setFrameStyle(QFrame::StyledPanel | QFrame::Plain);
    _dock_manager->setLineWidth(1);

    // Set central widget
    MeasureAnalysisHistoryForm* measure_analysis_history_form = new MeasureAnalysisHistoryForm;
    CDockWidget* central_dock_widget = _dock_manager->createDockWidget(QStringLiteral(u"测量分析记录"));
    central_dock_widget->setWidget(measure_analysis_history_form);
    central_dock_widget->setFeature(ads::CDockWidget::AllDockWidgetFeatures, true);
    _central_dock_area = _dock_manager->setCentralWidget(central_dock_widget);
    _action_central_dock_widget = central_dock_widget->toggleViewAction();
    _action_central_dock_widget->setCheckable(false);
    ui->menu_view->addAction(_action_central_dock_widget);

    // 构建测量分析工程树视图
    _tree_measure_analysis = new MeasureAnalysisTree::TreeWidget;
    _dockw_measure_analysis_tree = new ads::CDockWidget(QStringLiteral(u"测量分析工作空间"));
    _dockw_measure_analysis_tree->setWidget(_tree_measure_analysis);
    _dockw_measure_analysis_tree->setMinimumSizeHintMode(ads::CDockWidget::MinimumSizeHintFromContentMinimumSize);
    _dock_manager->addDockWidget(ads::DockWidgetArea::LeftDockWidgetArea, _dockw_measure_analysis_tree);
    ui->menu_view->addAction(_dockw_measure_analysis_tree->toggleViewAction());

    _tree_actions = new MeasureAnalysisTree::MeasureAnalysisActions(_tree_measure_analysis);
    _tree_measure_analysis->SetConnectActions(_tree_actions);

    _menu_view_data_table_list = ui->menu_view->addMenu(QStringLiteral(u"查看数据列表"));
    _menu_view_analysis_view_list = ui->menu_view->addMenu(QStringLiteral(u"分析视图列表"));

    // 构建日志输出视图
    _s_plain_edit_info_output = new QPlainTextEdit;
    _s_plain_edit_info_output->setReadOnly(true);
    ads::CDockWidget* dockw_info_output = new ads::CDockWidget(QStringLiteral(u"信息输出"));
    dockw_info_output->setWidget(_s_plain_edit_info_output);
    dockw_info_output->setMinimumSizeHintMode(ads::CDockWidget::MinimumSizeHintFromContentMinimumSize);
    _dock_manager->addDockWidget(ads::DockWidgetArea::BottomDockWidgetArea, dockw_info_output);
    ui->menu_view->addAction(dockw_info_output->toggleViewAction());
}

void MainWindow::initAction()
{
    connect(ui->action_new_measurement_analysis, &QAction::triggered, this, [this]() {
        NewMeasureAnalysisDlg new_measure_analysis_dlg;
        if (QDialog::Accepted == new_measure_analysis_dlg.exec()) {
            auto project_model = MeasureAnalysisProjectModelList::GetCurrentProjectModel();
            this->_tree_measure_analysis->AddProjectModel(project_model);
            if (project_model->GetIsMeasureComplete()) {
                const QString& project_name = project_model->GetProjectName();

                /*
                const QString& result_data_dir = QDir(project_model->GetProjectDir()).filePath("EveryChannelParticleData");
                auto separate_task = new DataProcessWorkPool::EveryChannelParticleDataSeparateTask;
                separate_task->SetAllChannelParticleDataFilename(project_model->GetAllChannelParticleDataFilename());
                separate_task->SetResultDataDir(result_data_dir);
                separate_task->SetFinishedNotifier(this->_tree_measure_analysis, "onFinishedSeparateEveryChannelParticleData", project_name);
                separate_task->StartTask();
                */

                auto separate_task = new DataProcessWorkPool::ParticleDataSortTask;
                separate_task->SetAllChannelParticleDataFilename(project_model->GetAllChannelParticleDataFilename());
                separate_task->SetSortedResultDir(project_model->GetProjectDir());
                separate_task->StartTask();

                const QString& all_ch_count_dir = project_model->GetProjectDir();
                const QString& every_ch_count_dir = QDir(project_model->GetProjectDir()).filePath("EveryChannelParticleCountData");
                auto count_task = new DataProcessWorkPool::EveryChannelParticleCountDataTask;
                count_task->SetAllChannelParticleDataFilename(project_model->GetAllChannelParticleDataFilename());
                count_task->SetAllChannelCountResultDir(all_ch_count_dir);
                count_task->SetEveryChannelCountResultDir(every_ch_count_dir);
                count_task->SetFinishedNotifier(this->_tree_measure_analysis, "onFinishedParticleCountData", project_name);
                count_task->StartTask();
            }
        }
    });
    connect(ui->action_manage_measurement_analysis, &QAction::triggered, this->_action_central_dock_widget, &QAction::triggered);
    connect(ui->action_device_config_mrg, &QAction::triggered, this, []() {
        QDialog device_cfg_mrg_dlg;
        device_cfg_mrg_dlg.setObjectName("MeasureDeviceParamsCfgFormDlg");
        device_cfg_mrg_dlg.setWindowTitle(QStringLiteral(u"测量设备参数配置管理"));
        device_cfg_mrg_dlg.setWindowFlags(device_cfg_mrg_dlg.windowFlags() | Qt::WindowMaximizeButtonHint);
        MeasureDeviceParamsCfgForm* measure_dev_params_cfg_form = new MeasureDeviceParamsCfgForm(&device_cfg_mrg_dlg);
        QHBoxLayout* hlayout = new QHBoxLayout;
        hlayout->addWidget(measure_dev_params_cfg_form);
        device_cfg_mrg_dlg.setLayout(hlayout);
        device_cfg_mrg_dlg.exec();
    });
    connect(ui->action_enery_scale_mrg, &QAction::triggered, this, []() {
        QDialog enery_scale_mrg_dlg;
        enery_scale_mrg_dlg.setObjectName("EneryScaleFormDlg");
        enery_scale_mrg_dlg.setWindowTitle(QStringLiteral(u"能量刻度管理"));
        enery_scale_mrg_dlg.setWindowFlags(enery_scale_mrg_dlg.windowFlags() | Qt::WindowMaximizeButtonHint);
        EneryScaleForm* enery_scale_mrg_form = new EneryScaleForm(&enery_scale_mrg_dlg);
        QHBoxLayout* hlayout = new QHBoxLayout;
        hlayout->addWidget(enery_scale_mrg_form);
        enery_scale_mrg_dlg.setLayout(hlayout);
        enery_scale_mrg_dlg.exec();
    });
    connect(ui->action_about_info, &QAction::triggered, this, []() {
        AboutDlg about_dlg;
        about_dlg.exec();
    });

    connect(_tree_measure_analysis, &MeasureAnalysisTree::TreeWidget::currentItemViewWidget, [this](MeasureAnalysisView* view) {
        if (view && this->_dock_manager) {
            bool view_exist = false;
            QList<CDockWidget*> dock_widget_list = this->_dock_manager->dockWidgetsMap().values();
            for (auto it = dock_widget_list.constBegin(); it != dock_widget_list.constEnd(); ++it) {
                CDockWidget* dock_widget = *it;
                if (dock_widget) {
                    if ( dock_widget->widget() == view ) {
                        dock_widget->toggleView();
                        dock_widget->raise();
                        view_exist = true;
                    }
                }
            }
            if ( !view_exist ) {
                ads::CDockWidget* dock_widget = new ads::CDockWidget(view->GetViewName());
                dock_widget->setWidget(view);
                dock_widget->setFeatures(dock_widget->features() | ads::CDockWidget::CustomCloseHandling);
                dock_widget->setMinimumSizeHintMode(ads::CDockWidget::MinimumSizeHintFromContentMinimumSize);
                dock_widget->setProperty("TakeWidget", true);

                connect(dock_widget, &CDockWidget::closeRequested, [dock_widget](){
                    dock_widget->takeWidget();
                    dock_widget->deleteDockWidget();
                });

                auto central_area = _dock_manager->centralWidget()->dockAreaWidget();
                _dock_manager->addDockWidget(ads::DockWidgetArea::CenterDockWidgetArea, dock_widget, central_area);

                MeasureAnalysisView::ViewType view_type = view->GetAnalyzeViewType();
                switch (view_type) {
                case MeasureAnalysisView::ViewType::DataTable: {
                    dock_widget->setFeatures(dock_widget->features() | ads::CDockWidget::DockWidgetDeleteOnClose);
                    _menu_view_data_table_list->addAction(dock_widget->toggleViewAction());
                } break;
                default:
                    break;
                }
            }
        }
    });

    connect(_tree_measure_analysis, &MeasureAnalysisTree::TreeWidget::removeItemViewFromStack, [this](MeasureAnalysisView* view) {
        if (this->_dock_manager) {
            QList<CDockWidget*> dock_widget_list = this->_dock_manager->dockWidgetsMap().values();
            for (auto it = dock_widget_list.constBegin(); it != dock_widget_list.constEnd(); ++it) {
                CDockWidget* dock_widget = *it;
                if (dock_widget) {
                    if ( dock_widget->widget() == view ) {
                        QWidget* content = dock_widget->takeWidget();
                        dock_widget->deleteDockWidget();
                    }
                }
            }
        }
    });
}

void MainWindow::applyStyleSheet()
{
#ifdef ENABLE_DEBUG
    QString style_file_path = "D:/Workspace/EnergySpectrumAnalyerProject/EnergySpectrumAnalyer/style/stylesheet/";
#else
    QString style_file_path = ":/stylesheet/";
#endif
    QFile file_stylesheet_default(style_file_path + "default.qss");
    if (file_stylesheet_default.open(QFile::ReadOnly)) {
        const QString& str_stylesheet_default = file_stylesheet_default.readAll();
        qApp->setStyleSheet(str_stylesheet_default);
    }
    QFile file_stylesheet_dock(style_file_path + "dock.qss");
    if (file_stylesheet_dock.open(QFile::ReadOnly)) {
        const QString& str_stylesheet_dock = file_stylesheet_dock.readAll();
        _dock_manager->setStyleSheet(_dock_manager->styleSheet() + str_stylesheet_dock);
    }
}

void MainWindow::closeEvent(QCloseEvent* event)
{
    // Delete dock manager here to delete all floating widgets. This ensures
    // that all top level windows of the dock manager are properly closed
    if (this->_dock_manager) {
        QList<CDockWidget*> dock_widget_list = this->_dock_manager->dockWidgetsMap().values();
        for (auto it = dock_widget_list.constBegin(); it != dock_widget_list.constEnd(); ++it) {
            CDockWidget* dock_widget = *it;
            if (dock_widget) {
                bool need_take_widget = dock_widget->property("TakeWidget").toBool();
                if (need_take_widget) {
                    dock_widget->takeWidget();
                }
            }
        }
    }
    _dock_manager->deleteLater();
    _dock_manager = nullptr;
    QMainWindow::closeEvent(event);
}