#include "mainwindowcurve.h"
#include "ui_mainwindowcurve.h"
#include <QFile>
#include <QTextStream>
#include "CallManage.h"
#include <QAbstractItemView>
#include "qtcommonclass.h"
#include <QFuture>
#include <QtConcurrent/QtConcurrent>
#include "newheaddialog.h"
#include "formhead.h"
//#include "qmytablewidget.h"
#include "PropertyWidget.h"
#include "LogModuleParamers.h"
#include "LogModuleConsole.h"
#include "DepPairs.h"

extern int g_iOneWidth;  //道宽
extern QString g_prjname;
//
//extern int m_iY1;
//extern int m_iY2;
extern double g_dPixelPerCm;//每厘米像素数
extern int g_iShow;  //显示刻度

extern int g_iRows;
extern int g_iCols;
extern int g_iColsWidth;
extern int g_iRowsHight;

MainWindowCurve::MainWindowCurve(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindowCurve)
{
    ui->setupUi(this);

    QtCommonClass *qtCommon = new QtCommonClass(this);
    m_strUuid =  qtCommon->getUUid();

    // 设置工具栏的位置，此处设置为在左侧
    addToolBar(Qt::LeftToolBarArea, ui->toolBar);
    addToolBar(Qt::RightToolBarArea, ui->toolBar_2);

    //初始化工具栏
    initMainToolBar();
    initToolBar();
    //校深
    initToolBar_2();
    ui->toolBar_2->hide();

    //加载样式
    loadStyle(":/qrc/qss/flatgray.css");

    //-------------------------------------
    ui->tableWidget->hide();
//    //隐藏网格线
//    ui->tableWidget->setShowGrid(false);
//    //设置样式表，不显示竖直边框
//    ui->tableWidget->setStyleSheet( "QTableView::item {border-left: 0px solid black;} \
//                                       QTableView::item:selected {border-left: 0px solid black;}\
//                                       QTableView::item {border-right: 0px solid black;} \
//                                       QTableView::item:selected {border-right: 0px solid black;}");
//    //
//    ui->tableWidget->verticalHeader()->hide();        //行
//    ui->tableWidget->horizontalHeader()->hide();      //列
//    //ui->tableWidget->verticalHeader()->setFixedWidth(3);//标题栏宽度
//    //ui->tableWidget->horizontalHeader()->setFixedHeight(3);//标题栏高度
//    ui->tableWidget->setColumnCount(1); //动态设置列数
//    ui->tableWidget->horizontalHeader()->setStretchLastSection(true);//最后一列铺满最后
//    //标题
//    QTableWidgetItem *headerItem = new QTableWidgetItem("");
//    ui->tableWidget->setHorizontalHeaderItem(0, headerItem);
//    //我们让一列也可以滑动
//    ui->tableWidget->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
//    ui->tableWidget->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);
//    // 设置右键菜单策略
//    ui->tableWidget->setContextMenuPolicy(Qt::CustomContextMenu);
//    connect(ui->tableWidget, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slotContextMenu(QPoint)));
//    // 在窗口构造函数中
//    //ui->tableWidget->installEventFilter(this);

    //-------------------------------------
    //ui->tableWidget_2->setFrameShape(QFrame::NoFrame); //设置无边框
    //隐藏网格线
    ui->tableWidget_2->setShowGrid(false);
    //设置样式表，只显示竖直边框
    ui->tableWidget_2->setStyleSheet( "QTableView::item {border-left: 1px solid black;} \
                                       QTableView::item:selected {border-left: 1px solid black;}\
                                       QTableView::item {border-right: 1px solid black;} \
                                       QTableView::item:selected {border-right: 1px solid black;}");


    ui->tableWidget_2->verticalHeader()->hide();    //行
    //ui->tableWidget_2->horizontalHeader()->hide();//列
    int rowcount = 2;  //总行数
    ui->tableWidget_2->setRowCount(rowcount); //动态设置行数
    //ui->tableWidget_2->verticalHeader()->setFixedWidth(3);//标题栏宽度
    ui->tableWidget_2->horizontalHeader()->setFixedHeight(3);//标题栏高度
    //我们让一列也可以滑动
    ui->tableWidget_2->setHorizontalScrollMode(QAbstractItemView::ScrollPerPixel);
    ui->tableWidget_2->setVerticalScrollMode(QAbstractItemView::ScrollPerPixel);

    connect(ui->tableWidget_2, SIGNAL(itemClicked(QTableWidgetItem*)), this, SLOT(onItemClicked(QTableWidgetItem*)));

    //-------------------------------------
    ui->tableWidget_3->hide();
    ui->tableWidget_3->verticalHeader()->hide();
    ui->tableWidget_3->horizontalHeader()->hide();

    connect(this, SIGNAL(sig_NewTrackChangeWidth(QString, int)), this, SLOT(s_NewTrackChangeWidth(QString, int)));
    //connect(this, SIGNAL(sig_NewWell(QString, QString)), this, SLOT(s_NewWell(QString, QString)));

    connect(CallManage::getInstance(), SIGNAL(sig_mouseWheel(QWheelEvent*)), this, SLOT(s_mouseWheel(QWheelEvent*)));
    connect(CallManage::getInstance(), SIGNAL(sig_changeScale(QString, int)), this, SLOT(s_changeScale(QString, int)));
    connect(CallManage::getInstance(), SIGNAL(sig_changeDepth(QString, QString, QString, int, int)), this, SLOT(s_changeDepth(QString, QString, QString, int, int)));
    connect(CallManage::getInstance(), SIGNAL(sig_changeWidth(QString, QString, QString, QString, int, int)), this, SLOT(s_changeWidth(QString, QString, QString, QString, int, int)));
    //曲线选中，置顶
    connect(CallManage::getInstance(), SIGNAL(sig_Raise(QString, QString, QString, QString, QString, int, QString)), this, SLOT(s_Raise(QString, QString, QString, QString, QString, int, QString)));

    //图头
    m_dock1=new QDockWidget(tr(""),this);
    m_dock1->setFeatures(QDockWidget::NoDockWidgetFeatures);//QDockWidget::DockWidgetMovable
    //dock1->setAllowedAreas(Qt::TopDockWidgetArea);
    //
    m_formMultiHeads = new FormMultiHeads(this);
    m_dock1->setWidget(m_formMultiHeads);
    addDockWidget(Qt::TopDockWidgetArea,m_dock1);
    //移除标题栏
    QWidget* lTitleBar = m_dock1->titleBarWidget();
    QWidget* lEmptyWidget = new QWidget();
    m_dock1->setTitleBarWidget(lEmptyWidget);
    delete lTitleBar;
    //隐藏
    m_dock1->hide();

    //属性编辑器
//    m_propertyWidget = PropertyService();
//    m_propertyWidget->setWindowTitle("属性编辑器");
//    m_propertyWidget->setParent(this);
//    addDockWidget( Qt::TopDockWidgetArea, m_propertyWidget);
}

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

//鼠标滚动，通知可视解释窗口
void MainWindowCurve::s_mouseWheel(QWheelEvent *event)
{
    if (event->angleDelta().y() > 0) {
        ui->tableWidget_2->verticalScrollBar()->triggerAction(QAbstractSlider::SliderSingleStepSub); // 向下滚动
    } else {
        ui->tableWidget_2->verticalScrollBar()->triggerAction(QAbstractSlider::SliderSingleStepAdd); // 向上滚动
    }

    //verticalScrollBar() horizontalScrollBar()
    //event->accept(); // 确保事件被处理
}

//初始化工具栏
void MainWindowCurve::initMainToolBar()
{
    QSize toolIconSize(18, 18);
    ui->mainToolBar->setIconSize(toolIconSize);   //设置工具栏图标大小

    QIcon fixwellsectionHeaderIcon(::GetImagePath()+"icon/fixwellsectionHeader.png");
    QIcon currtempliteIcon(::GetImagePath()+"icon/currtemplite.png");
    QIcon saveastemplateIcon(::GetImagePath()+"icon/saveastemplate.png");
    QIcon executeDepthShiftIcon(::GetImagePath()+"icon/ExecuteDepthShift.png");
    QIcon ModuleOpenIcon(::GetImagePath()+"icon/ModuleOne.png");
    QIcon openFileIcon(":/image/open.png");
    QIcon runIcon(":/image/capacity.png");
    QIcon debugIcon(":/image/anaysis.png");
    QIcon loadIcon(":/image/export.png");

    //Main工具栏
    QAction* m_fixwellsectionHeaderAc = nullptr;	//锁头
    QAction* m_currtempliteAc = nullptr;            //加载图文件
    QAction* m_saveastemplateAc = nullptr;          //另存为图文件
    QAction* m_executeDepthShiftAc = nullptr;       //校深
    QAction* m_ModuleOpenAc = nullptr;              //处理方法
    //QAction* m_openAc = nullptr;	//打开
//    QAction* m_runAc = nullptr;//
//    QAction* m_debugAc = nullptr;	//
//    QAction* m_loadAc = nullptr;	//加载

    m_fixwellsectionHeaderAc = new QAction(fixwellsectionHeaderIcon, "锁头", this);
    m_currtempliteAc = new QAction(currtempliteIcon, "加载图文件", this);
    m_saveastemplateAc = new QAction(saveastemplateIcon, "另存为图文件", this);
    m_executeDepthShiftAc = new QAction(executeDepthShiftIcon, "校深", this);
    m_ModuleOpenAc = new QAction(ModuleOpenIcon, "处理方法", this);
//    m_runAc = new QAction(runIcon, "设置井", this);
//    m_debugAc = new QAction(debugIcon, "撤销", this);
//    m_loadAc = new QAction(loadIcon, "重做", this);
    //m_openAc = new QAction(openFileIcon, "打开", this);

    ui->mainToolBar->setToolButtonStyle(Qt::ToolButtonTextBesideIcon); //此种方式为文字显示在图标右侧

    //add QAction to Widget.
    ui->mainToolBar->addAction(m_fixwellsectionHeaderAc);
    ui->mainToolBar->addAction(m_currtempliteAc);
    ui->mainToolBar->addAction(m_saveastemplateAc);
    ui->mainToolBar->addAction(m_executeDepthShiftAc);
    ui->mainToolBar->addAction(m_ModuleOpenAc);
//    ui->mainToolBar->addAction(m_runAc);
//    ui->mainToolBar->addAction(m_debugAc);
//    ui->mainToolBar->addAction(m_loadAc);
    //ui->mainToolBar->addAction(m_openAc);

    connect(m_fixwellsectionHeaderAc, &QAction::triggered, this, &MainWindowCurve::s_showHeadTable);
    connect(m_currtempliteAc, &QAction::triggered, this, &MainWindowCurve::s_currtemplite);
    connect(m_saveastemplateAc, &QAction::triggered, this, &MainWindowCurve::s_Save);
    connect(m_executeDepthShiftAc, &QAction::triggered, this, &MainWindowCurve::s_ExecuteDepthShift);

    connect(m_ModuleOpenAc, &QAction::triggered, this, &MainWindowCurve::s_ModuleOpen);

//    connect(m_grepAc, &QAction::triggered, this, &MainWindow::s_Risize);
//    connect(m_compileAc, &QAction::triggered, this, &MainWindow::s_AddOne);
//    connect(m_runAc, &QAction::triggered, this, &MainWindow::s_SaveImage);
//    connect(m_debugAc, &QAction::triggered, this, &MainWindow::s_DrawImg);
//    connect(m_loadAc, &QAction::triggered, this, &MainWindow::s_DrawLine);
    //connect(m_openAc, &QAction::triggered, this, &MainWindowCurve::s_Open);
}
//初始化工具栏
void MainWindowCurve::initToolBar()
{
    QSize toolIconSize(18, 18);
    ui->toolBar->setIconSize(toolIconSize);   //设置工具栏图标大小

    QIcon blankTrackIcon(::GetImagePath()+"icon/BlankTrack.png");
    QIcon depthIcon(::GetImagePath()+"icon/depth.png");
    QIcon logsIcon(::GetImagePath()+"icon/logs.png");
    QIcon waveIcon(::GetImagePath()+"icon/wave.png");
    QIcon OGResultIcon(::GetImagePath()+"icon/OGResult.png");
    QIcon gujingIcon(::GetImagePath()+"icon/gujing.png");
    QIcon sidecoreIcon(::GetImagePath()+"icon/sidecore.png");
    //
    QIcon coreIcon(::GetImagePath()+"icon/Core.png");
    QIcon mudloggingIcon(::GetImagePath()+"icon/mudlogging.png");
    QIcon txtIcon(::GetImagePath()+"icon/txt.png");
    QIcon coreimageIcon(::GetImagePath()+"icon/coreimage.png");
    QIcon santuyibiaoIcon(::GetImagePath()+"icon/santuyibiao.png");
    QIcon crackIcon(::GetImagePath()+"icon/crack.png");
    QIcon showdipIcon(::GetImagePath()+"icon/showdip.png");
    QIcon pinlvIcon(::GetImagePath()+"icon/pinlv.png");
    QIcon ganzhuangtuIcon(::GetImagePath()+"icon/ganzhuangtu.png");
    QIcon roseIcon(::GetImagePath()+"icon/rose.png");
    QIcon collapseIcon(::GetImagePath()+"icon/collapse.png");
    QIcon deviIcon(::GetImagePath()+"icon/devi.png");
    QIcon electric_imagingIcon(::GetImagePath()+"icon/electric_imaging.png");
    QIcon DCAIcon(::GetImagePath()+"icon/DCA.png");
    QIcon GeoSectionIcon(::GetImagePath()+"icon/GeoSection.png");
    QIcon jiegutextIcon(::GetImagePath()+"icon/jiegutext.png");
    QIcon mcalsIcon(::GetImagePath()+"icon/mcals.png");
    QIcon logfaceIcon(::GetImagePath()+"icon/logface.png");
    QIcon TubingstringIcon(::GetImagePath()+"icon/Tubingstring.png");
    QIcon TDTIcon(::GetImagePath()+"icon/TDT.png");
    QIcon LogMudIcon(::GetImagePath()+"icon/LogMud.png");

    //工具栏
    QAction* m_blankTrackAc = nullptr;
    QAction* m_depthAc = nullptr;
    QAction* m_logsAc = nullptr;
    QAction* m_waveAc = nullptr;
    QAction* m_OGResultAc = nullptr;
    QAction* m_gujingAc = nullptr;
    QAction* m_sidecoreAc = nullptr;
    //
    QAction* m_coreAc = nullptr;
    QAction* m_mudloggingAc = nullptr;
    QAction* m_txtAc = nullptr;
    QAction* m_coreimageAc = nullptr;
    QAction* m_santuyibiaoAc = nullptr;
    QAction* m_crackAc = nullptr;
    QAction* m_showdipAc = nullptr;
    QAction* m_pinlvAc = nullptr;
    QAction* m_ganzhuangtuAc = nullptr;
    QAction* m_roseAc = nullptr;
    QAction* m_collapseAc = nullptr;
    QAction* m_deviAc = nullptr;
    QAction* m_electric_imagingAc = nullptr;
    QAction* m_DCAAc = nullptr;
    QAction* m_GeoSectionAc = nullptr;
    QAction* m_jiegutextAc = nullptr;
    QAction* m_mcalsAc = nullptr;
    QAction* m_logfaceAc = nullptr;
    QAction* m_TubingstringAc = nullptr;
    QAction* m_TDTAc = nullptr;
    QAction* m_LogMudAc = nullptr;

    m_blankTrackAc = new QAction(blankTrackIcon, "", this);
    m_depthAc = new QAction(depthIcon, "", this);
    m_logsAc = new QAction(logsIcon, "", this);
    m_waveAc = new QAction(waveIcon, "", this);
    m_OGResultAc = new QAction(OGResultIcon, "", this);
    m_gujingAc = new QAction(gujingIcon, "", this);
    m_sidecoreAc = new QAction(sidecoreIcon, "", this);
    //
    m_coreAc = new QAction(coreIcon, "", this);
    m_mudloggingAc = new QAction(mudloggingIcon, "", this);
    m_txtAc = new QAction(txtIcon, "", this);
    m_coreimageAc = new QAction(coreimageIcon, "", this);
    m_santuyibiaoAc = new QAction(santuyibiaoIcon, "", this);
    m_crackAc = new QAction(crackIcon, "", this);
    m_showdipAc = new QAction(showdipIcon, "", this);
    m_pinlvAc = new QAction(pinlvIcon, "", this);
    m_ganzhuangtuAc = new QAction(ganzhuangtuIcon, "", this);
    m_roseAc = new QAction(roseIcon, "", this);
    m_collapseAc = new QAction(collapseIcon, "", this);
    m_deviAc = new QAction(deviIcon, "", this);
    m_electric_imagingAc = new QAction(electric_imagingIcon, "", this);
    m_DCAAc = new QAction(DCAIcon, "", this);
    m_GeoSectionAc = new QAction(GeoSectionIcon, "", this);
    m_jiegutextAc = new QAction(jiegutextIcon, "", this);
    m_mcalsAc = new QAction(mcalsIcon, "", this);
    m_logfaceAc = new QAction(logfaceIcon, "", this);
    m_TubingstringAc = new QAction(TubingstringIcon, "", this);
    m_TDTAc = new QAction(TDTIcon, "", this);
    m_LogMudAc = new QAction(LogMudIcon, "", this);


    m_blankTrackAc->setToolTip("道");
    m_depthAc->setToolTip("深度");
    m_logsAc->setToolTip("曲线");
    m_waveAc->setToolTip("波列");
    m_OGResultAc->setToolTip("解释结论道");
    m_gujingAc->setToolTip("固井结论道");
    m_sidecoreAc->setToolTip("井壁取心");
    //
    m_coreAc->setToolTip("岩心分析");
    m_mudloggingAc->setToolTip("录井剖面");
    m_txtAc->setToolTip("岩性描述");
    m_coreimageAc->setToolTip("岩心照片");
    m_santuyibiaoAc->setToolTip("斜井三图一表");
    m_crackAc->setToolTip("裂缝");
    m_showdipAc->setToolTip("蝌蚪图");
    m_pinlvAc->setToolTip("频率统计图");
    m_ganzhuangtuAc->setToolTip("杆状图");
    m_roseAc->setToolTip("玫瑰图");
    m_collapseAc->setToolTip("井眼垮塌矢量图");
    m_deviAc->setToolTip("井斜方位图");
    m_electric_imagingAc->setToolTip("图像");
    m_DCAAc->setToolTip("裂缝DCA分析");
    m_GeoSectionAc->setToolTip("地质层位道");
    m_jiegutextAc->setToolTip("气测/管柱/文本/FMT/射孔");
    m_mcalsAc->setToolTip("多臂井径");
    m_logfaceAc->setToolTip("沉积相");
    m_TubingstringAc->setToolTip("套管组件");
    m_TDTAc->setToolTip("TDT");
    m_LogMudAc->setToolTip("LogMud");

    //此种方式为文字显示在图标右侧
    ui->toolBar->setToolButtonStyle(Qt::ToolButtonIconOnly);

    //add QAction to Widget.
    ui->toolBar->addAction(m_blankTrackAc);
    ui->toolBar->addAction(m_depthAc);
    ui->toolBar->addAction(m_logsAc);
    ui->toolBar->addAction(m_waveAc);
    ui->toolBar->addAction(m_OGResultAc);
    ui->toolBar->addAction(m_gujingAc);
    ui->toolBar->addAction(m_sidecoreAc);
    //
    ui->toolBar->addAction(m_coreAc);
    ui->toolBar->addAction(m_mudloggingAc);
    ui->toolBar->addAction(m_txtAc);
    ui->toolBar->addAction(m_coreimageAc);
    ui->toolBar->addAction(m_santuyibiaoAc);
    ui->toolBar->addAction(m_crackAc);
    ui->toolBar->addAction(m_showdipAc);
    ui->toolBar->addAction(m_pinlvAc);
    ui->toolBar->addAction(m_ganzhuangtuAc);
    ui->toolBar->addAction(m_roseAc);
    ui->toolBar->addAction(m_collapseAc);
    ui->toolBar->addAction(m_deviAc);
    ui->toolBar->addAction(m_electric_imagingAc);
    ui->toolBar->addAction(m_DCAAc);
    ui->toolBar->addAction(m_GeoSectionAc);
    ui->toolBar->addAction(m_jiegutextAc);
    ui->toolBar->addAction(m_mcalsAc);
    ui->toolBar->addAction(m_logfaceAc);
    ui->toolBar->addAction(m_TubingstringAc);
    ui->toolBar->addAction(m_TDTAc);
    ui->toolBar->addAction(m_LogMudAc);

    connect(m_blankTrackAc, &QAction::triggered, this, &MainWindowCurve::s_NewTrack);
    connect(m_depthAc, &QAction::triggered, this, &MainWindowCurve::s_NewDepth);//深度
    connect(m_logsAc, &QAction::triggered, this, &MainWindowCurve::s_NewLogs);//曲线
    connect(m_waveAc, &QAction::triggered, this, &MainWindowCurve::s_NewWave);//波列
    connect(m_OGResultAc, &QAction::triggered, this, &MainWindowCurve::s_NewOGResult);//解释结论道
    connect(m_gujingAc, &QAction::triggered, this, &MainWindowCurve::s_NewGujing);//固井结论道
    connect(m_sidecoreAc, &QAction::triggered, this, &MainWindowCurve::s_NewSideCore);//井壁取心
    connect(m_coreAc, &QAction::triggered, this, &MainWindowCurve::s_NewCore);//岩心分析
    connect(m_mudloggingAc, &QAction::triggered, this, &MainWindowCurve::s_NewMudlogging);//录井剖面
    connect(m_txtAc, &QAction::triggered, this, &MainWindowCurve::s_NewTxt);//岩性描述
    connect(m_coreimageAc, &QAction::triggered, this, &MainWindowCurve::s_NewCoreImage);//岩心照片
	connect(m_santuyibiaoAc, &QAction::triggered, this, &MainWindowCurve::s_NewSantuyibiao);//斜井三图一表
    connect(m_crackAc, &QAction::triggered, this, &MainWindowCurve::s_NewCrack);//裂缝
    connect(m_showdipAc, &QAction::triggered, this, &MainWindowCurve::s_NewShowDip);//蝌蚪图
    connect(m_pinlvAc, &QAction::triggered, this, &MainWindowCurve::s_pinLvAc);//频率统计图
    connect(m_ganzhuangtuAc, &QAction::triggered, this, &MainWindowCurve::s_NewGanZhuangTu);//杆状图
    connect(m_roseAc, &QAction::triggered, this, &MainWindowCurve::s_roseAc);//玫瑰图
    connect(m_DCAAc, &QAction::triggered, this, &MainWindowCurve::s_dcaAc);
   connect(m_collapseAc, &QAction::triggered, this, &MainWindowCurve::s_Jykt);//井眼垮塌矢量图
   connect(m_deviAc, &QAction::triggered, this, &MainWindowCurve::s_Denv);//井斜方位图
   connect(m_electric_imagingAc, &QAction::triggered, this, &MainWindowCurve::s_DrawImage);//图像
   connect(m_GeoSectionAc, &QAction::triggered, this, &MainWindowCurve::s_NewGeoSection);//地质层位道
   connect(m_jiegutextAc, &QAction::triggered, this, &MainWindowCurve::s_NewJiegutext);//气测/FMT/射孔/文本
   connect(m_mcalsAc, &QAction::triggered, this, &MainWindowCurve::s_NewMCals);//多臂井径
   connect(m_logfaceAc, &QAction::triggered, this, &MainWindowCurve::s_NewLogface);//沉积相
   connect(m_TubingstringAc, &QAction::triggered, this, &MainWindowCurve::s_NewTubingstring);//套管组件
   connect(m_TDTAc, &QAction::triggered, this, &MainWindowCurve::s_NewTDT);//TDT

}

//初始化工具栏
void MainWindowCurve::initToolBar_2()
{
    QSize toolIconSize(18, 18);
    ui->toolBar_2->setIconSize(toolIconSize);   //设置工具栏图标大小

    QIcon ShiftIcon(::GetImagePath()+"icon/Shift.png");
    QIcon MoveShiftIcon(::GetImagePath()+"icon/MoveShift.png");
    QIcon DepthShiftIcon(::GetImagePath()+"icon/DepthShift.png");
    QIcon StandardIcon(::GetImagePath()+"icon/Standard.png");
    QIcon CorrectionIcon(::GetImagePath()+"icon/Correction.png");
    QIcon ShiftotherIcon(::GetImagePath()+"icon/Shiftother.png");
    QIcon autocorIcon(::GetImagePath()+"icon/autocor.png");
    QIcon runcorIcon(::GetImagePath()+"icon/runcor.png");
    QIcon ClearAllSetCurveIcon(::GetImagePath()+"icon/ClearAllSetCurve.png");
    QIcon ClearSetCurveIcon(::GetImagePath()+"icon/ClearSetCurve.png");

    //工具栏
    QAction* m_ShiftAc = nullptr;
    QAction* m_MoveShiftAc = nullptr;
    QAction* m_DepthShiftAc = nullptr;
    QAction* m_StandardAc = nullptr;
    QAction* m_CorrectionAc = nullptr;
    QAction* m_ShiftotherAc = nullptr;
    QAction* m_autocorAc = nullptr;
    QAction* m_runcorAc = nullptr;
    QAction* m_ClearAllSetCurveAc = nullptr;
    QAction* m_ClearSetCurveAc = nullptr;

    m_ShiftAc = new QAction(ShiftIcon, "", this);
    m_MoveShiftAc = new QAction(MoveShiftIcon, "", this);
    m_DepthShiftAc = new QAction(DepthShiftIcon, "", this);
    m_StandardAc = new QAction(StandardIcon, "", this);
    m_CorrectionAc = new QAction(CorrectionIcon, "", this);
    m_ShiftotherAc = new QAction(ShiftotherIcon, "", this);
    m_autocorAc = new QAction(autocorIcon, "", this);
    m_runcorAc = new QAction(runcorIcon, "", this);
    m_ClearAllSetCurveAc = new QAction(ClearAllSetCurveIcon, "", this);
    m_ClearSetCurveAc = new QAction(ClearSetCurveIcon, "", this);

    m_ShiftAc->setToolTip("整体深度平移校正");
    m_MoveShiftAc->setToolTip("深度分段平移校正");
    m_DepthShiftAc->setToolTip("参数卡深度平移校正");
    m_StandardAc->setToolTip("设置/取消标准曲线");
    m_CorrectionAc->setToolTip("设置/取消校正曲线");
    m_ShiftotherAc->setToolTip("批量设置从校正曲线");
    m_autocorAc->setToolTip("自动对比");
    m_runcorAc->setToolTip("执行校正");
    m_ClearAllSetCurveAc->setToolTip("清除全部曲线设置");
    m_ClearSetCurveAc->setToolTip("清除全部从曲线设置");

    //此种方式为文字显示在图标右侧
    ui->toolBar_2->setToolButtonStyle(Qt::ToolButtonIconOnly);

    //add QAction to Widget.
    ui->toolBar_2->addAction(m_ShiftAc);
    ui->toolBar_2->addAction(m_MoveShiftAc);
    ui->toolBar_2->addAction(m_DepthShiftAc);
    ui->toolBar_2->addSeparator();
    ui->toolBar_2->addAction(m_StandardAc);
    ui->toolBar_2->addAction(m_CorrectionAc);
    ui->toolBar_2->addAction(m_ShiftotherAc);
    ui->toolBar_2->addSeparator();
    ui->toolBar_2->addAction(m_autocorAc);
    ui->toolBar_2->addAction(m_runcorAc);
    ui->toolBar_2->addSeparator();
    ui->toolBar_2->addAction(m_ClearAllSetCurveAc);
    ui->toolBar_2->addAction(m_ClearSetCurveAc);

    connect(m_ShiftAc, &QAction::triggered, this, &MainWindowCurve::s_Shift);
    connect(m_MoveShiftAc, &QAction::triggered, this, &MainWindowCurve::s_MoveShift);
//    connect(m_DepthShiftAc, &QAction::triggered, this, &MainWindowCurve::s_DepthShift);
    connect(m_StandardAc, &QAction::triggered, this, &MainWindowCurve::s_Standard);
    connect(m_CorrectionAc, &QAction::triggered, this, &MainWindowCurve::s_Correction);
//    connect(m_ShiftotherAc, &QAction::triggered, this, &MainWindowCurve::s_Shiftother);
    connect(m_autocorAc, &QAction::triggered, this, &MainWindowCurve::s_autocor);
//    connect(m_runcorAc, &QAction::triggered, this, &MainWindowCurve::s_runcor);
    connect(m_ClearAllSetCurveAc, &QAction::triggered, this, &MainWindowCurve::s_ClearAllSetCurve);
    connect(m_ClearSetCurveAc, &QAction::triggered, this, &MainWindowCurve::s_ClearSetCurve);

}

QStringList MainWindowCurve::getLineList(QString strWellName, QString strTrackName)
{
    // 创建根对象
    QStringList listLine;

    //
    int columnCount = ui->tableWidget_2->columnCount();//总列数
    for(int i=0; i<columnCount; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }

        if( ui->tableWidget_2->cellWidget(1, i) != nullptr )
        {
             auto myWidget = ui->tableWidget_2->cellWidget(1, i);
             //
             FormWell *widgetWell = (FormWell*)myWidget;//获得widget
             if(widgetWell)
             {
                 QStringList listTemp = widgetWell->getLineList(strWellName, strTrackName);
                 if(listTemp.size()>0)
                 {
                    listLine.append(listTemp);
                 }
             }
        }
    }
    return listLine;
}

void MainWindowCurve::ApplyShiftDepth(QString strSlfName, QString strLineName, double DepthOffset)
{
    //1.修改内存数据
    if(strSlfName=="") return ;
    CMemRdWt * logio=new CMemRdWt();
    if(!logio->Open(strSlfName.toStdString().c_str(),CSlfIO::modeReadWrite))
    {
        delete logio;
        //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！");
        return ;
    };
    bool isok=0;
    //TODO 目前对于表格类，参数卡类不支持,会崩溃
    int curveindex=logio->FindObjectName((char *)strLineName.toStdString().c_str());
    if(curveindex>=0) {
        CString szBuffer="";
        szBuffer=QString::number(DepthOffset,'f',3)+"\r\n";
        WriteShiftMessage(*logio,szBuffer,strLineName);
        logio->CorrectObjectDepth(curveindex, DepthOffset);
        isok=1;
    }
//    Slf_CURVE acurveinfo;
//    logio->GetCurveInfo(curveindex,&acurveinfo);
    delete logio;

    //DepthOffset = 0;
//    if(isRun&&isok) {
//        isLoad=false;
//        LoadFromSLF();
//    }
}

void MainWindowCurve::s_Shift()
{
    if(m_SelectTableItem.m_iTableType==0) {
        QMessageBox::warning(this, "提示", "请选择要校正的对象!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==1) {
        QMessageBox::warning(this, "提示", "该功能不支持对井次校正，如果需要井次校正请到数据树上进行!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==2 || m_SelectTableItem.m_iTableType==3)
    {
        //道，曲线
        bool ok=0;
        double depthshift=QInputDialog::getDouble(NULL,"深度移动","请输入移动的深度量(上移-,下移+)",0.0,-2147483647, 2147483647,4,&ok);
        if(!ok) return;
        if(depthshift==0) return;
        if(depthshift>10)
        {
            int flag = QMessageBox::warning(this->parentWidget(),"提示",QString("深度移动量 =")+QString::number(depthshift)+"m\n"+"\n您确定执行校正?",
                QMessageBox::Yes,QMessageBox::No);
            if(flag==QMessageBox::No)
            {
                return;
            }
        }

        if(m_SelectTableItem.m_iTableType==2)
        {
            //道
            QStringList listLine = getLineList(m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName);
            if(listLine.size()>0)
            {
                for(int i=0; i<listLine.size(); i++)
                {
                    //单条曲线校深
                    ApplyShiftDepth(m_SelectTableItem.m_strSlfName, listLine[i], depthshift);
                }
            }
            else
            {
                QMessageBox::warning(this, "提示", "道内曲线对象为空，无对象可校正！");
                return;
            }
        }
        else if(m_SelectTableItem.m_iTableType==3)
        {
            //单条曲线校深
            ApplyShiftDepth(m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strLineName, depthshift);
        }
    }
}

void MainWindowCurve::MoveShift(QString strSlfName, QString strLineName, float sdep,float edep,float delta)
{
    if(sdep>=edep&&delta==0) return;
    if(strSlfName=="") return;
    CMemRdWt * logio=new CMemRdWt();
    if(!logio->Open(strSlfName.toStdString().c_str(),CSlfIO::modeReadWrite))
    {
        delete logio;
        //AppendConsole(pai::log::PAI_ERROR,"SLF文件打开失败，请检查！");
        return;
    }

    int curveindex=logio->FindObjectName((char*)strLineName.toStdString().c_str());
    if(curveindex<0)
    {
        delete logio;
        return;
    }
    CString szBuffer="";

    if(sdep==edep&&sdep==-9999.0) {
        szBuffer=QString::number(delta,'f',3)+"\r\n";
        WriteShiftMessage(*logio,szBuffer,strLineName);
        logio->CorrectObjectDepth(curveindex,delta);
        delete logio;
//		if(isRun) {
//			isLoad=false;
//			LoadFromSLF();
//		}
        return;
    }
    curveindex=logio->OpenChannel(strLineName.toStdString().c_str());
    if(curveindex>-1) {
        szBuffer.Format("%10.3f %10.3f %10.3f\r\n",sdep,edep,delta);
        WriteShiftMessage(*logio,szBuffer,strLineName);
        logio->MoveDepth(curveindex,sdep,edep,delta);
    }
    else {
        int ObjectType=logio->GetObjectType(strLineName.toStdString().c_str());
        float sdeps[2],edeps[2];
        sdeps[0]=sdep;
        edeps[0]=sdep+delta;
        sdeps[1]=edep;
        edeps[1]=edep+delta;
        szBuffer.Format("%10.3f %10.3f\r\n%10.3f %10.3f\r\n",sdeps[0],edeps[0],sdeps[1],edeps[1]);
        WriteShiftMessage(*logio,szBuffer,strLineName);
        if(ObjectType >CARD_OBJECT||ObjectType==0)
        {
            int index=logio->OpenTable(strLineName.toStdString().c_str());
            if(index>-1)
            {
                logio->EShiftTableDepth((char*)strLineName.toStdString().c_str(),2,sdeps,edeps);
            }
        }
        else if(ObjectType==CARD_OBJECT) {
            logio->EshiftStreamDepth((char *)strLineName.toStdString().c_str(),2,sdeps,edeps);
        }
    }
    delete logio;
//	if(isRun) {
//		isLoad=false;
//		LoadFromSLF();
//	}
}

void MainWindowCurve::slotRun()
{
    double depthshift=spinbox3->text().toFloat();
    if(depthshift==0) return;

    float sdep=spinbox1->text().toFloat();
    float edep=spinbox2->text().toFloat();
    if(sdep>edep) {
        float depp=sdep;
        sdep=edep;
        edep=sdep;
    }

    if(m_SelectTableItem.m_iTableType==2)
    {
        //道
        QStringList listLine = getLineList(m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName);
        if(listLine.size()>0)
        {
            for(int i=0; i<listLine.size(); i++)
            {
                //单条曲线校深
                MoveShift(m_SelectTableItem.m_strSlfName, listLine[i], sdep, edep, depthshift);
            }
        }
        else
        {
            QMessageBox::warning(this, "提示", "道内曲线对象为空，无对象可校正！");
            return;
        }
    }
    else if(m_SelectTableItem.m_iTableType==3)
    {
        //单条曲线校深
        MoveShift(m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strLineName, sdep, edep, depthshift);
    }
}

void MainWindowCurve::s_MoveShift()
{
    if(m_SelectTableItem.m_iTableType==0) {
        QMessageBox::warning(this, "提示", "请选择要校正的对象!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==1) {
        QMessageBox::warning(this, "提示", "该功能不支持对井次校正，如果需要井次校正请到数据树上进行!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==2 || m_SelectTableItem.m_iTableType==3)
    {
        //道，曲线
        QDialog dialog(NULL);
        dialog.setModal(false);
        Qt::WindowFlags flags = dialog.windowFlags();
        flags |= Qt::WindowStaysOnTopHint;
        flags &= ~Qt::WindowContextHelpButtonHint;
        dialog.setWindowFlags(flags);
        dialog.setWindowTitle("深度分段平移");
        QFormLayout form(&dialog);
        form.addWidget(new QLabel("输入深度参数:"));
        // Value1
        QString value1 = QString("起始深度: ");
        spinbox1 = new QLineEdit(&dialog);
        if(1) {
            float yGeoNormal =-m_iY2;
            spinbox1->setText(toString(((int)(yGeoNormal*10+0.5))/10.0));
        }
        else spinbox1->setText("-9999.0");
        form.addRow(value1, spinbox1);
        value1 = QString("终止深度: ");
        spinbox2 = new QLineEdit(&dialog);
        form.addRow(value1, spinbox2);
        if(1)
        {
            spinbox2->setText(toString(-m_iY1));
        }
        else spinbox2->setText("-9999.0");
        value1 = QString("移动量(上移-,下移+): ");
        spinbox3 = new QLineEdit(&dialog);
        form.addRow(value1, spinbox3);
        spinbox3->setText("0");
        QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
            Qt::Horizontal, &dialog);
        //m_ButtonBox=&buttonBox;
        form.addWidget(&buttonBox);

        //m_LOGS=logs;
        //QObject::connect(spinbox1, SIGNAL(returnPressed()), this, SLOT(slotSetDep()));
        //QObject::connect(spinbox2, SIGNAL(returnPressed()), this, SLOT(slotSetDep()));
        QObject::connect(buttonBox.button(QDialogButtonBox::Ok), SIGNAL(clicked()), this, SLOT(slotRun()));
        QObject::connect(&buttonBox, SIGNAL(rejected()), &dialog, SLOT(reject()));
        buttonBox.button(QDialogButtonBox::Ok)->setAutoDefault(false);
        //slotSetDep();
        dialog.show();
        if (dialog.exec() == QDialog::Accepted) {
            // Do something here
        }
    }
}

//设置/取消标准曲线
void MainWindowCurve::s_Standard()
{
    if(m_SelectTableItem.m_iTableType==0) {
        QMessageBox::warning(this, "提示", "请选择要校正的对象!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==1) {
        QMessageBox::warning(this, "提示", "该功能不支持对井次校正，如果需要井次校正请到数据树上进行!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==3 && m_SelectTableItem.m_strFormInfoType=="curveObject")
    {
        //曲线
    }
    else
    {
        QMessageBox::warning(this, "提示", "该功能只支持曲线! 请选择要校正的曲线!");
        return;
    }

    //主校曲线中，去掉本条曲线
    if(m_RightCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
        m_RightCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
        m_RightCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
        m_RightCurve.m_strLineName == m_SelectTableItem.m_strLineName)
    {
        //主校曲线中，切换为不选择
        m_RightCurve.m_iTableType=0;
        m_RightCurve.m_strUuid = "";
        m_RightCurve.m_strWellName = "";
        m_RightCurve.m_strSlfName="";
        m_RightCurve.m_strTrackName="";
        m_RightCurve.m_strLineName="";
        m_RightCurve.m_strFormInfoType="";
    }

    //从校曲线中，去掉本条曲线
    for(int i=0; i<m_ShiftCurves.size(); i++)
    {
        SelectTableItem m_TempCurve = m_ShiftCurves[i];
        //当前已经选中为从校曲线
        if(m_TempCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
            m_TempCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
            m_TempCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
            m_TempCurve.m_strLineName == m_SelectTableItem.m_strLineName)
        {
            //删除从校曲线
            m_ShiftCurves.removeAt(i);
            break;
        }
    }

    //iSelect=0未知，1标准曲线，2主校曲线，3从校曲线
    //当前有标准曲线
    if(m_LeftCurve.m_iTableType==3 && m_LeftCurve.m_strFormInfoType=="curveObject")
    {
        //当前已经选中为标准曲线
        if(m_LeftCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
                m_LeftCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
                m_LeftCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
                m_LeftCurve.m_strLineName == m_SelectTableItem.m_strLineName)
        {
            //修改当前曲线选择状态 iSelect=0未知
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 0);

            //标准曲线中，切换为不选择
            m_LeftCurve.m_iTableType=0;
            m_LeftCurve.m_strUuid = "";
            m_LeftCurve.m_strWellName = "";
            m_LeftCurve.m_strSlfName="";
            m_LeftCurve.m_strTrackName="";
            m_LeftCurve.m_strLineName="";
            m_LeftCurve.m_strFormInfoType="";
        }
        else
        {
            //修改原来的标准曲线选择状态 iSelect=0未知
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_LeftCurve.m_strSlfName, m_LeftCurve.m_strWellName, m_LeftCurve.m_strTrackName, m_LeftCurve.m_strLineName, 0);

            //修改当前曲线选择状态 iSelect=1标准曲线
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 1);

            //设置标准曲线
            m_LeftCurve = m_SelectTableItem;
        }
    }
    else
    {
        //当前没有标准曲线
        //修改当前曲线选择状态 iSelect=1标准曲线
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 1);

        //设置标准曲线
        m_LeftCurve = m_SelectTableItem;
    }
}

//设置/取消校正曲线
void MainWindowCurve::s_Correction()
{
    if(m_SelectTableItem.m_iTableType==0) {
        QMessageBox::warning(this, "提示", "请选择要校正的对象!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==1) {
        QMessageBox::warning(this, "提示", "该功能不支持对井次校正，如果需要井次校正请到数据树上进行!");
        return;
    }

    if(m_SelectTableItem.m_iTableType==3 && m_SelectTableItem.m_strFormInfoType=="curveObject")
    {
        //曲线
    }
    else
    {
        QMessageBox::warning(this, "提示", "该功能只支持曲线! 请选择要校正的曲线!");
        return;
    }

    //标准曲线中，去掉本条曲线
    //当前有标准曲线
    if(m_LeftCurve.m_iTableType==3 && m_LeftCurve.m_strFormInfoType=="curveObject")
    {
        //当前已经选中为标准曲线
        if(m_LeftCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
                m_LeftCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
                m_LeftCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
                m_LeftCurve.m_strLineName == m_SelectTableItem.m_strLineName)
        {
            //标准曲线中，切换为不选择
            m_LeftCurve.m_iTableType=0;
            m_LeftCurve.m_strUuid = "";
            m_LeftCurve.m_strWellName = "";
            m_LeftCurve.m_strSlfName="";
            m_LeftCurve.m_strTrackName="";
            m_LeftCurve.m_strLineName="";
            m_LeftCurve.m_strFormInfoType="";
        }
   }

    //从校曲线中，去掉本条曲线
    for(int i=0; i<m_ShiftCurves.size(); i++)
    {
        SelectTableItem m_TempCurve = m_ShiftCurves[i];
        //当前已经选中为从校曲线
        if(m_TempCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
            m_TempCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
            m_TempCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
            m_TempCurve.m_strLineName == m_SelectTableItem.m_strLineName)
        {
            //修改当前曲线选择状态 iSelect=0未知
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 0);

            //删除从校曲线
            m_ShiftCurves.removeAt(i);
            return;
        }
    }

    //iSelect=0未知，1标准曲线，2主校曲线，3从校曲线
    //当前有主校曲线
    if(m_RightCurve.m_iTableType==3 && m_RightCurve.m_strFormInfoType=="curveObject")
    {
        //当前已经选中为主校曲线
        if(m_RightCurve.m_strSlfName == m_SelectTableItem.m_strSlfName &&
            m_RightCurve.m_strWellName == m_SelectTableItem.m_strWellName &&
            m_RightCurve.m_strTrackName == m_SelectTableItem.m_strTrackName &&
            m_RightCurve.m_strLineName == m_SelectTableItem.m_strLineName)
        {
            //修改当前曲线选择状态 iSelect=0未知
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 0);

            //主校曲线中，切换为不选择
            m_RightCurve.m_iTableType=0;
            m_RightCurve.m_strUuid = "";
            m_RightCurve.m_strWellName = "";
            m_RightCurve.m_strSlfName="";
            m_RightCurve.m_strTrackName="";
            m_RightCurve.m_strLineName="";
            m_RightCurve.m_strFormInfoType="";
        }
        else
        {
            //修改当前曲线选择状态 iSelect=3从校曲线
            emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 3);

            //设置从校曲线
            m_ShiftCurves.append(m_SelectTableItem);
        }
    }
    else
    {
        //当前没有主校曲线
        //修改当前曲线选择状态 iSelect=2主校曲线
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_SelectTableItem.m_strSlfName, m_SelectTableItem.m_strWellName, m_SelectTableItem.m_strTrackName, m_SelectTableItem.m_strLineName, 2);

        //设置主校曲线
        m_RightCurve = m_SelectTableItem;
    }
}

// quick sort
void qsort(QVector<CurveLine *>&datx,int left,int right,int idx)
{
    if(right<left+1) return;

    int i,j;
    float x,y;

    i=left;
    j=right;
    x=datx[(left+right)/2]->GetLeftDepth();

    do
    {
        if(idx==0)
        {
            while(datx[i]->GetLeftDepth()<x && i<right) i++;
            while(datx[j]->GetLeftDepth()>x && j>left ) j--;
        }
        else
        {
            while(datx[i]->GetLeftDepth()>x && i<right) i++;
            while(datx[j]->GetLeftDepth()<x && j>left ) j--;
        }
        if(i<=j)
        {
            CurveLine *yy=datx[i];
            datx[i]=datx[j];
            datx[j]=yy;
            i++;j--;
        }
    } while(i<=j);
    if(left<j)  qsort(datx,left,j,idx);
    if(i<right) qsort(datx,i,right,idx);
}

//自动对比
void MainWindowCurve::s_autocor()
{
    //当前有标准曲线
    if(m_LeftCurve.m_iTableType==3 && m_LeftCurve.m_strFormInfoType=="curveObject")
    {
    }
    else
    {
        QMessageBox::warning(this, "提示", "请先选择标准曲线!");
        return;
    }

    //当前有主校曲线
    if(m_RightCurve.m_iTableType==3 && m_RightCurve.m_strFormInfoType=="curveObject")
    {
    }
    else
    {
        QMessageBox::warning(this, "提示", "请先选择校正曲线!");
        return;
    }

    //
    static float cmins=0.9;
    static float winLength=4;
    static float stepLength=2;
    static float searchLength=4;

    static float stdep=-9999;
    static float endep=-9999;
    //
    QDialog dialog(NULL);
    dialog.setModal(false);
    Qt::WindowFlags flags = dialog.windowFlags();
    flags |= Qt::WindowStaysOnTopHint;
    flags &= ~Qt::WindowContextHelpButtonHint;
    dialog.setWindowFlags(flags);
    dialog.setWindowTitle("自动对比参数");
    QFormLayout form(&dialog);
    form.addRow(new QLabel("输入窗长:"));
    // Value1
    QString value1 = QString("窗长: ");
    QLineEdit *spinbox1 = new QLineEdit(&dialog);
    spinbox1->setText(toString(winLength));
    form.addRow(value1, spinbox1);
    value1 = QString("步长: ");
    QLineEdit *spinbox2 = new QLineEdit(&dialog);
    form.addRow(value1, spinbox2);
    spinbox2->setText(toString(stepLength));
    value1 = QString("搜索长度: ");
    QLineEdit *spinbox3 = new QLineEdit(&dialog);
    form.addRow(value1, spinbox3);
    spinbox3->setText(toString(searchLength));
    value1 = QString("最小相关系数: ");
    QLineEdit *spinbox4 = new QLineEdit(&dialog);
    form.addRow(value1, spinbox4);
    spinbox4->setText(toString(cmins));

    value1 = QString("起始深度: ");
    QLineEdit *spinbox5 = new QLineEdit(&dialog);
    form.addRow(value1, spinbox5);
    spinbox5->setText(toString(stdep));

    value1 = QString("终止深度: ");
    QLineEdit *spinbox6 = new QLineEdit(&dialog);
    form.addRow(value1, spinbox6);
    spinbox6->setText(toString(endep));
    QDialogButtonBox buttonBox(QDialogButtonBox::Ok | QDialogButtonBox::Cancel,
        Qt::Horizontal, &dialog);
    form.addWidget(&buttonBox);

    QObject::connect(&buttonBox, SIGNAL(accepted()), &dialog, SLOT(accept()));
    QObject::connect(&buttonBox, SIGNAL(rejected()), &dialog, SLOT(reject()));

    dialog.show();
    if (dialog.exec() == QDialog::Accepted) {
        // Do something here
    }
    else return;
    winLength=spinbox1->text().toFloat();
    stepLength=spinbox2->text().toFloat();
    searchLength=spinbox3->text().toFloat();
    cmins=spinbox4->text().toFloat();
    stdep=spinbox5->text().toFloat();
    endep=spinbox6->text().toFloat();

    //
    float* FirstDep=new float[5000];
    float* SecondDep=new float[5000];
    float* corc=new float[5000];

    *FirstDep=stdep;
    *SecondDep=endep;

    int num=AutoComp((char *)m_LeftCurve.m_strSlfName.toStdString().c_str(),
                        (char *)m_RightCurve.m_strSlfName.toStdString().c_str(),
                        (char *)m_LeftCurve.m_strLineName.toStdString().c_str(),
                        (char *)m_RightCurve.m_strLineName.toStdString().c_str(),
                        cmins,
                        winLength,
                        stepLength,
                        searchLength,
                        FirstDep,
                        SecondDep,
                        corc
                        );

    for(int i=0;i<num;i++)
    {
        CurveLine * pLine = new CurveLine();
        pLine->SetLeftDepth(FirstDep[i]);
        pLine->SetRightDepth(SecondDep[i]);
        m_mergeLineList.append(pLine);
    }
    delete FirstDep;
    delete SecondDep;
    delete corc;

    qsort(m_mergeLineList,0,m_mergeLineList.size()-1,0);
    if(num>0) {
        CString szBuffer="";
        CString szBuffer1="";
        for(int i=0;i<num;i++)
        {
            float sdep=m_mergeLineList[i]->GetLeftDepth();
            float edep=m_mergeLineList[i]->GetRightDepth();
            szBuffer1.Format("%g %g\r\n",sdep,edep);
            szBuffer+=szBuffer1;
        }
        CMemRdWt mem;
        if(mem.Open(m_RightCurve.m_strSlfName.toStdString().c_str()))
        {
            WriteShiftMessage(mem,szBuffer,"Create depths Pairs:","depth_inp");
        }
    }
}

//清除全部曲线设置
void MainWindowCurve::s_ClearAllSetCurve()
{
    //标准曲线中，去掉本条曲线
    //当前有标准曲线
    if(m_LeftCurve.m_iTableType==3 && m_LeftCurve.m_strFormInfoType=="curveObject")
    {
        //修改当前曲线选择状态 iSelect=0未知
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_LeftCurve.m_strSlfName, m_LeftCurve.m_strWellName, m_LeftCurve.m_strTrackName, m_LeftCurve.m_strLineName, 0);

        //标准曲线中，切换为不选择
        m_LeftCurve.m_iTableType=0;
        m_LeftCurve.m_strUuid = "";
        m_LeftCurve.m_strWellName = "";
        m_LeftCurve.m_strSlfName="";
        m_LeftCurve.m_strTrackName="";
        m_LeftCurve.m_strLineName="";
        m_LeftCurve.m_strFormInfoType="";
   }

    //主校曲线中，去掉本条曲线
    //当前有主校曲线
    if(m_RightCurve.m_iTableType==3 && m_RightCurve.m_strFormInfoType=="curveObject")
    {
        //修改当前曲线选择状态 iSelect=0未知
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_RightCurve.m_strSlfName, m_RightCurve.m_strWellName, m_RightCurve.m_strTrackName, m_RightCurve.m_strLineName, 0);

        //主校曲线中，切换为不选择
        m_RightCurve.m_iTableType=0;
        m_RightCurve.m_strUuid = "";
        m_RightCurve.m_strWellName = "";
        m_RightCurve.m_strSlfName="";
        m_RightCurve.m_strTrackName="";
        m_RightCurve.m_strLineName="";
        m_RightCurve.m_strFormInfoType="";
    }

    //从校曲线中，去掉本条曲线
    for(int i=m_ShiftCurves.size()-1; i>-1; i--)
    {
        SelectTableItem m_TempCurve = m_ShiftCurves[i];
        //修改当前曲线选择状态 iSelect=0未知
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_TempCurve.m_strSlfName, m_TempCurve.m_strWellName, m_TempCurve.m_strTrackName, m_TempCurve.m_strLineName, 0);

        //删除从校曲线
        m_ShiftCurves.removeAt(i);
    }
}

//清除全部从曲线设置
void MainWindowCurve::s_ClearSetCurve()
{
    //从校曲线中，去掉本条曲线
    for(int i=m_ShiftCurves.size()-1; i>-1; i--)
    {
        SelectTableItem m_TempCurve = m_ShiftCurves[i];
        //修改当前曲线选择状态 iSelect=0未知
        emit CallManage::getInstance()->sig_ChangeLineStatus(m_strUuid, m_TempCurve.m_strSlfName, m_TempCurve.m_strWellName, m_TempCurve.m_strTrackName, m_TempCurve.m_strLineName, 0);

        //删除从校曲线
        m_ShiftCurves.removeAt(i);
    }
}

QStringList MainWindowCurve::insertCol(int nW)
{
    QStringList sret;
    int column = -1;
    QString strSlfName = "";
    QString strLeft = m_leftWidgets->getLeftTreeString();
    if(strLeft.length() > 0)
    {
        QStringList list = strLeft.split("#@@#");//QString字符串分割函数
        if (list.size() > 3)
        {
            strSlfName = list[0];
            QString strWellName = list[1];
            // QString strLineName = list[2];
            // QString strType = list[3];

            if(!m_listWell.contains(strWellName))
            {
                //井没创建，创建井+道+曲线
                //新建井
                s_NewWell(strWellName, strSlfName);
                m_listWell.push_back(strWellName);

                column= 0;
            }
        }
    }

    if(ui->tableWidget_2->columnCount()==0)
    {
        return sret;
    }

    int iWidth = 0;
    if(column < 0)
    {
        column = ui->tableWidget_2->currentColumn();//列编号从0开始
        iWidth = ui->tableWidget_2->columnWidth(column);
    }

    if(column<0)
    {
        //当前没有选中井
        return sret;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        return sret;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();

    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    sret << strWellName << strSlfName;

    return sret;
}

QStringList MainWindowCurve::getSelectWell()
{
    QStringList sret;
    if(ui->tableWidget_2->columnCount()==0)
    {
        return sret;
    }

    int column = ui->tableWidget_2->currentColumn();//列编号从0开始
    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return sret;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return sret;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    sret << strWellName << strSlfName;

    return sret;
}

void MainWindowCurve::loadStyle(const QString &qssFile)
{
    //加载样式表
    QString qss;
    QFile file(qssFile);
    if (file.open(QFile::ReadOnly)) {
        //用QTextStream读取样式文件不用区分文件编码 带bom也行
        QStringList list;
        QTextStream in(&file);
        //in.setCodec("utf-8");
        while (!in.atEnd()) {
            QString line;
            in >> line;
            list << line;
        }

        file.close();
        qss = list.join("\n");
        QString paletteColor = qss.mid(20, 7);
        this->setPalette(QPalette(paletteColor));
        //用时主要在下面这句
        this->setStyleSheet(qss);
    }
}

void MainWindowCurve::s_currtemplite()
{

}

void MainWindowCurve::s_Save()
{
    //Logdata
    QString folderPath;
    folderPath = GetLogdataPath();
    folderPath = folderPath + g_prjname;
    //folderPath = folderPath + "/multiwell.json";

    QString exPortPath = QFileDialog::getSaveFileName(this, "另存为", folderPath, "多井图文件(*.json)");
    if (exPortPath.isEmpty() == false)
    {
        QJsonObject rootObj = makeJson();
        // 生成JSON文档
        QJsonDocument doc(rootObj);
        // 写入文件
        QFile file(exPortPath);
        if(file.open(QIODevice::WriteOnly)){
            file.write(doc.toJson(QJsonDocument::Indented));
            file.close();
            qDebug() << "JSON文件写入成功！";
        } else {
            qWarning() << "文件打开失败：" << file.errorString();
            return;
        }
    }
}

//校深
void MainWindowCurve::s_ExecuteDepthShift()
{
    if(ui->toolBar_2->isHidden())
    {
        ui->toolBar_2->show();
    }
    else
    {
        ui->toolBar_2->hide();
    }
}

void MainWindowCurve::s_ModuleOpen()
{
    QString strSlfName = "";
    QString strLeft = m_leftWidgets->getLeftTreeString();
    if(strLeft.length() > 0)
    {
        QStringList list = strLeft.split("#@@#");//QString字符串分割函数
        if (list.size() > 3)
        {
            strSlfName = list[0];
            QString strWellName = list[1];
        }
    }
    if (strSlfName.isEmpty())
    {
        QMessageBox::information(nullptr, "提示", "请先选中待处理井次");
        return;
    }

    CModuleConsole* pModuleConsole = new pai::graphics::CModuleConsole();
    CModuleParamers* pDialog = new CModuleParamers(pModuleConsole);//::CreatParamControlWidget();
    SetWorkflowConsole(pModuleConsole);
    pModuleConsole->g_mModuleParamers = pDialog;
    pModuleConsole->m_pWorkflowDataModel = new CWellLogWorkflowDataModel();
    pDialog->m_CurrentSLFFileName = strSlfName;
    pDialog->CreatParamControlWidget();
    pDialog->show();
    return;
}

//void MainWindowCurve::s_Open(QString fileFull)
//{

//}

//显示/隐藏图头
void MainWindowCurve::s_showHeadTable()
{
    if(m_dock1->isVisible())
    {
        m_dock1->hide();
    }
    else {
        m_dock1->show();
    }

//    if(ui->tableWidget->isVisible())
//    {
//        ui->tableWidget->hide();
//    }
//    else {
//        ui->tableWidget->show();
//    }

//    QTableWidget *tableWidget = new QTableWidget();

//    tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::Stretch);
//    tableWidget->verticalHeader()->setSectionResizeMode(QHeaderView::Stretch);

//    tableWidget->setRowCount(5);
//    tableWidget->setColumnCount(5);
//    for(int i=0; i<5; i++)
//    {
//        //tableWidget->setColumnWidth(i, 100);
//        for(int j=0; j<5; j++)
//        {
//            QTableWidgetItem* item = new QTableWidgetItem("");
//            tableWidget->setItem(i, j, item);
//        }
//    }

////    QSizePolicy sizePolicy(QSizePolicy::Preferred, QSizePolicy::Preferred); // 首选大小策略
////    sizePolicy.setHorizontalStretch(0); // 水平拉伸因子
////    sizePolicy.setVerticalStretch(0); // 垂直拉伸因子
////    tableWidget->setSizePolicy(sizePolicy);

//    ui->verticalLayout_head->addWidget(tableWidget, 0, Qt::AlignCenter); // 通过布局添加表格
}

QJsonObject MainWindowCurve::makeJson()
{
    // 创建根对象
    QJsonObject rootObj;
    //
    rootObj["prjname"] = g_prjname;
    rootObj["iScale"] = m_iScale;
    rootObj["iY1"] = m_iY1;
    rootObj["iY2"] = m_iY2;

    // 创建JSON数组并填充数据
    QJsonArray subcaseArray;
    //
    int columnCount = ui->tableWidget_2->columnCount();//总列数
    for(int i=0; i<columnCount; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }

        if( ui->tableWidget_2->cellWidget(1, i) != nullptr )
        {
             auto myWidget = ui->tableWidget_2->cellWidget(1, i);
             //
             FormWell *widgetWell = (FormWell*)myWidget;//获得widget
             if(widgetWell)
             {
                 //options
                 QJsonObject wellObj;
                 wellObj["id"] = i;
                 wellObj["info"] = widgetWell->makeJson();
                 subcaseArray.append(wellObj);
             }
        }
    }
    rootObj["wells"]=subcaseArray;

    return rootObj;
}

void MainWindowCurve::s_NewWell(QString strWellName, QString strSlfName)
{
    //因为tableWidget需要提前规定好行数与列数
    int rowcount = 2;  //总行数
    int columnCount = ui->tableWidget_2->columnCount();//总列数

    if(columnCount==0)
    {
        //增加1列
        ui->tableWidget_2->setColumnCount(columnCount+1);
    }
    else {
        //增加1列(空白)
        ui->tableWidget_2->setColumnCount(columnCount+1);
        //设置列宽
        ui->tableWidget_2->setColumnWidth(columnCount, g_iOneWidth);

        //
        columnCount = ui->tableWidget_2->columnCount();//总列数
        //增加1列
        ui->tableWidget_2->setColumnCount(columnCount+1);
    }
    //设置列宽
    ui->tableWidget_2->setColumnWidth(columnCount, g_iOneWidth);

    //标题
    QTableWidgetItem *headerItem = new QTableWidgetItem("");
    ui->tableWidget_2->setHorizontalHeaderItem(columnCount, headerItem);

    for(int i=0; i<rowcount; i++)
    {
        if(i==0)
        {
            //设置高度
            ui->tableWidget_2->setRowHeight(i, 100);
            //
            QTableWidgetItem* item = new QTableWidgetItem(strWellName);
            item->setData(Qt::UserRole + 1, strSlfName);
            item->setFlags(item->flags() & (~Qt::ItemIsEditable));
            item->setTextAlignment(Qt::AlignCenter); //设置文本居中
            ui->tableWidget_2->setItem(i, columnCount, item);
        }
        else
        {            
            double dHight = 0;
            dHight = (m_iY2-m_iY1)*100.0/(double)m_iScale * g_dPixelPerCm;
            if(g_iShow==1)
            {
                //显示刻度
                dHight = dHight+30;
            }
            if(dHight>32767)
            {
                dHight = 32767;
            }

            dHight = dHight+300+100+10;
            //设置高度
            ui->tableWidget_2->setRowHeight(i, (int)dHight);//8020
            //
            FormWell *widgetWell = new FormWell(this, strWellName);
            widgetWell->m_iY1 = m_iY1;
            widgetWell->m_iY2 = m_iY2;
            widgetWell->m_strUuid = m_strUuid;
            widgetWell->m_strSlfName = strSlfName;
            ui->tableWidget_2->setCellWidget(i, columnCount, widgetWell);

            //
            m_listWell.push_back(strWellName);
        }
    }

    //ui->tableWidget_2->resizeColumnsToContents(); // 调整列宽以适应内容

    // 设置右键菜单策略
//    ui->tableWidget_2->setContextMenuPolicy(Qt::CustomContextMenu);
//    connect(ui->tableWidget_2, SIGNAL(customContextMenuRequested(QPoint)), this, SLOT(slotContextMenu(QPoint)));
}

void MainWindowCurve::mousePressEvent(QMouseEvent *event)
{
    QMainWindow::mousePressEvent(event); // 将事件操作权返回给父类
    // 在事件处理中添加一个打印输出，用于显示鼠标在界面上的位置
    qDebug()<< "mouse clicked at" << event->pos();


    PropertyService()->initWidgetProperty(m_strUuid, m_iScale);
    //取消所有选中单元格
    emit CallManage::getInstance()->sig_Raise(m_strUuid, "", "", "", "", 1, "");
}

void MainWindowCurve::s_Raise(QString strUuid, QString strSlfName, QString strWellName, QString strTrackName, QString strLineName, int iTableType, QString strFormInfoType)
{
    if(m_strUuid == strUuid)
    {
        //选中井次
        m_SelectTableItem.m_iTableType=iTableType;
        m_SelectTableItem.m_strUuid = strUuid;
        m_SelectTableItem.m_strWellName = strWellName;
        m_SelectTableItem.m_strSlfName=strSlfName;
        m_SelectTableItem.m_strTrackName=strTrackName;
        m_SelectTableItem.m_strLineName=strLineName;
        m_SelectTableItem.m_strFormInfoType=strFormInfoType; //类型：curveObject / waveObject / JiegutextObject
    }
    else
    {
        m_SelectTableItem.m_iTableType=0;
        m_SelectTableItem.m_strUuid = "";
        m_SelectTableItem.m_strWellName = "";
        m_SelectTableItem.m_strSlfName="";
        m_SelectTableItem.m_strTrackName="";
        m_SelectTableItem.m_strLineName="";
        m_SelectTableItem.m_strFormInfoType="";
    }


    if(m_strUuid == strUuid &&
       iTableType==1)
    {
        //
    }
    else {
        //选中了曲线置顶
        //取消表格选中状态
        ui->tableWidget_2->clearSelection();
    }
}

void MainWindowCurve::onItemClicked(QTableWidgetItem* item)
{
    qDebug() << "MainWindowCurve onItemClicked";

    //曲线
    QString strWellName = item->text();
    QString strSlfName = item->data(Qt::UserRole+1).toString();

    PropertyService()->initWellProperty(m_strUuid, strSlfName, strWellName, m_iY1, m_iY2);
    //取消所有选中单元格
    emit CallManage::getInstance()->sig_Raise(m_strUuid, "", "", "", "", 1, "");

}

void MainWindowCurve::s_NewTrack()
{
    int column = -1;
    QString strSlfName = "";

    //如果视图为空，则根据左侧选中的井来创建空白道
    if(ui->tableWidget_2->columnCount()==0)
    {
        QString strLeft = m_leftWidgets->getLeftTreeString();
        if(strLeft.length() > 0)
        {
            QStringList list = strLeft.split("#@@#");//QString字符串分割函数
            if (list.size() > 3)
            {
                strSlfName = list[0];
                QString strWellName = list[1];
                // QString strLineName = list[2];
                // QString strType = list[3];

                if(!m_listWell.contains(strWellName))
                {
                    //井没创建，创建井+道+曲线
                    //新建井
                    s_NewWell(strWellName, strSlfName);
                    m_listWell.push_back(strWellName);

                    column= 0;
                }
            }
        }
        //return;
    }

    int iWidth = 0;
    if(column < 0)
    {
        column = ui->tableWidget_2->currentColumn();//列编号从0开始
        iWidth = ui->tableWidget_2->columnWidth(column);
    }

    if(column<0)
    {
        //当前没有选中井
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();

    //新建道
    emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, "", "", "");

    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+g_iOneWidth);
}

void MainWindowCurve::s_NewDepth()
{
    int column = -1;
    int nW = 100;
    QString strSlfName = "";

    //如果视图为空，则根据左侧选中的井来创建深度道
    if(ui->tableWidget_2->columnCount()==0)
    {
        QString strLeft = m_leftWidgets->getLeftTreeString();
        if(strLeft.length() > 0)
        {
            QStringList list = strLeft.split("#@@#");//QString字符串分割函数
            if (list.size() > 3)
            {
                strSlfName = list[0];
                QString strWellName = list[1];
                // QString strLineName = list[2];
                // QString strType = list[3];

                if(!m_listWell.contains(strWellName))
                {
                    //井没创建，创建井+道+曲线
                    //新建井
                    s_NewWell(strWellName, strSlfName);
                    m_listWell.push_back(strWellName);

                    column= 0;
                }
            }
        }
        //return;
    }

    int iWidth = 0;
    if(column < 0)
    {
        column = ui->tableWidget_2->currentColumn();//列编号从0开始
        iWidth = ui->tableWidget_2->columnWidth(column);
    }

    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    if(strSlfName=="")
    {
        strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();
    }

    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    QStringList dt;
    dt << m_strUuid;
    dt << strWellName;
    dt << strSlfName;
    dt << "深度";
    dt << "depthObject";
    dt << QString::number(nW);
    //新建道
    emit CallManage::getInstance()->sig_NewCol(dt);
}

//曲线
void MainWindowCurve::s_NewLogs()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "AC", "curveObject");
}

//波列
void MainWindowCurve::s_NewWave()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "STAIMAGE", "waveObject");
}

//解释结论
void MainWindowCurve::s_NewOGResult()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "RESULT", "tableObject");
}

//固井结论道
void MainWindowCurve::s_NewGujing()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "GUJING1_RESULT", "tableObject");
}

//井壁取心
void MainWindowCurve::s_NewSideCore()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "SWALL_CORE", "tableObject");
}

//岩心分析
void MainWindowCurve::s_NewCore()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "CORE_PHYSICS", "tableObject");
}

//录井剖面
void MainWindowCurve::s_NewMudlogging()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "GEO_LITH", "tableObject");
}

//岩性描述
void MainWindowCurve::s_NewTxt()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "WORDS_RELUST", "tableObject");
}

//岩心照片
void MainWindowCurve::s_NewCoreImage()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "IMAGE_DATA", "tableObject");
}

//斜井三图一表
void MainWindowCurve::s_NewSantuyibiao()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "Santuyibiao", "SantuyibiaoObject");
}

//裂缝
void MainWindowCurve::s_NewCrack()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "FRAC_HOLE.TABLE", "CrackObject");
}

//蝌蚪图
void MainWindowCurve::s_NewShowDip()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "FRAC_HOLE.TABLE", "tableObject");
}

void MainWindowCurve::s_pinLvAc()
{
    int column = -1;
    int nW = 160;

    if(ui->tableWidget_2->columnCount()==0)
    {
        return;
    }

    int iWidth = 0;
    if(column < 0)
    {
        column = ui->tableWidget_2->currentColumn();//列编号从0开始
        iWidth = ui->tableWidget_2->columnWidth(column);
    }

    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    QStringList dt;
    dt << m_strUuid;
    dt << strWellName;
    dt << strSlfName;
    dt << "";
    dt << "plObject";
    dt << QString::number(nW);
    //新建道
    emit CallManage::getInstance()->sig_NewCol(dt);
}

void MainWindowCurve::s_NewGanZhuangTu()
{
    if(ui->tableWidget_2->columnCount()==0)
    {
        return;
    }

    int column = ui->tableWidget_2->currentColumn();//列编号从0开始
    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    int iWidth = ui->tableWidget_2->columnWidth(column);

    int nW = 320;
    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    //新建道
    emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, "杆状图", "ganzhuangtuObject", nW);
}

void MainWindowCurve::s_roseAc()
{
    int nW = 160;
    QStringList sret = this->insertCol(nW);
    if(sret.length() <= 0)
        return;

    QStringList dt;
    dt << m_strUuid;
    dt << sret.at(0);
    dt << sret.at(1);
    dt << "";
    dt << "roseObject";
    dt << QString::number(nW);
    //新建道
    emit CallManage::getInstance()->sig_NewCol(dt);
}

void MainWindowCurve::s_dcaAc()
{
    int nW = 180;
    QStringList sret = this->insertCol(nW);
    if(sret.length() <= 0)
        return;

    QStringList dt;
    dt << m_strUuid;
    dt << sret.at(0);
    dt << sret.at(1);
    dt << "";
    dt << "dcaObject";
    dt << QString::number(nW);
    //新建道
    emit CallManage::getInstance()->sig_NewCol(dt);
}

//井眼垮塌矢量图
void MainWindowCurve::s_Jykt()
{
    if(ui->tableWidget_2->columnCount()==0)
    {
        return;
    }

    int column = ui->tableWidget_2->currentColumn();//列编号从0开始
    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    int iWidth = ui->tableWidget_2->columnWidth(column);

    int nW = 320;
    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    //新建道
    emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, "井眼垮塌矢量图", "JyktObject", nW);
}

//井斜方位图
void MainWindowCurve::s_Denv()
{
//    QString strSlfName = "";
//    QString strLeft = m_leftWidgets->getLeftTreeString();
//    if(strLeft.length() > 0)
//    {
//        QStringList list = strLeft.split("#@@#");//QString字符串分割函数
//        if (list.size() > 3)
//        {
//            strSlfName = list[0];
//        }
//    }

    if(ui->tableWidget_2->columnCount()==0)
    {
        return;
    }

    int column = ui->tableWidget_2->currentColumn();//列编号从0开始
    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    int iWidth = ui->tableWidget_2->columnWidth(column);

    int nW = 320;
    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    //新建道
    emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, "井斜方位图", "DenvObject", nW);
}

//图像 成图
void MainWindowCurve::s_DrawImage()
{
//    QString strSlfName = "";
//    QString strLeft = m_leftWidgets->getLeftTreeString();
//    if(strLeft.length() > 0)
//    {
//        QStringList list = strLeft.split("#@@#");//QString字符串分割函数
//        if (list.size() > 3)
//        {
//            strSlfName = list[0];
//        }
//    }

    if(ui->tableWidget_2->columnCount()==0)
    {
        return;
    }

    int column = ui->tableWidget_2->currentColumn();//列编号从0开始
    if(column<0)
    {
        //当前没有选中井
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    if(column%2==0)
    {
    }
    else
    {
        //空白列
        QMessageBox::warning(this, "提示", "当前没有选中井", "确定");
        return;
    }

    QString strWellName = ui->tableWidget_2->item(0, column)->text();
    //直接从选中的井获取，data记录slf路径
    QString strSlfName = ui->tableWidget_2->item(0, column)->data(Qt::UserRole+1).toString();

    int iWidth = ui->tableWidget_2->columnWidth(column);

    int nW = 320;
    //设置列宽
    ui->tableWidget_2->setColumnWidth(column, iWidth+nW+8);

    //新建道
    emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, "成像", "DrawImageObject", nW);
}

//地质层位道
void MainWindowCurve::s_NewGeoSection()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "LAYER_DATA", "GeoSectionObject");
}

//气测/FMT/射孔/文本
void MainWindowCurve::s_NewJiegutext()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "GASLOG", "JiegutextObject");
}

//沉积相
void MainWindowCurve::s_NewLogface()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "LITHA", "LogfaceObject");
}

//多臂井径
void MainWindowCurve::s_NewMCals()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "FCA2", "MCalsObject");
}

//套管组件
void MainWindowCurve::s_NewTubingstring()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "TUBTOOLS", "TubingstringObject");
}

//TDT
void MainWindowCurve::s_NewTDT()
{
    QStringList sret = this->getSelectWell();
    if(sret.length() <= 0)
        return;

    //新建井+道+曲线(首条)
    NewWellAndTrack(sret.at(0), sret.at(1), "", "TDTObject");
}

void MainWindowCurve::s_NewTrackChangeWidth(QString strWellName, int nW)
{
    qDebug() << "MainWindowCurve s_NewTrackChangeWidth";

    int column = ui->tableWidget_2->columnCount();
    for(int i=0; i<column; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }
        //
        QString strWellNameTemp = ui->tableWidget_2->item(0, i)->text();
        if(strWellNameTemp==strWellName)
        {
            int iWidth = ui->tableWidget_2->columnWidth(i);//设置列宽
            if(nW<=0)
            {
                ui->tableWidget_2->setColumnWidth(i, iWidth+g_iOneWidth+6);
            }
            else
            {
                ui->tableWidget_2->setColumnWidth(i, iWidth+nW+6);
            }
        }
    }
}

//新建空白道，没有曲线
void MainWindowCurve::s_NewTrack_No_Line(QString strWellName, QString strTrackName)
{
    emit CallManage::getInstance()->sig_NewTrack_No_Line(m_strUuid, strWellName, strTrackName);
}

//新建曲线，带属性
void MainWindowCurve::s_AddLine_Property(QString strSlfName, QString strWellName, QString strTrackName, QString strLineName,
                          double newLeftScale, double newRightScale, QString strScaleType, QColor lineColor, double width, Qt::PenStyle lineStyle)
{
    emit CallManage::getInstance()->sig_AddLine_Property(m_strUuid, strSlfName, strWellName, strTrackName, strLineName,
                                                                 newLeftScale, newRightScale, strScaleType, lineColor, width, lineStyle);
}

//新建井+道+曲线(首条)
void MainWindowCurve::NewWellAndTrack(QString strWellName, QString strSlfName, QString strLineName, QString strType)
{
    int nW = 0;
    if(strType=="SantuyibiaoObject")
    {
        //斜井三图一表
        nW = g_iOneWidth*4;
    }

    //
    if(m_listWell.contains(strWellName))
    {
        //不在道里，新建道+曲线
        //新建道+曲线
        emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, strLineName, strType, nW);
        //改变井宽
        emit sig_NewTrackChangeWidth(strWellName, nW);
    }
    else
    {
        //井没创建，创建井+道+曲线
        //新建井
        s_NewWell(strWellName, strSlfName);
        m_listWell.push_back(strWellName);

        //新建道+曲线
        emit CallManage::getInstance()->sig_NewTrack(m_strUuid, strWellName, strSlfName, strLineName, strType, nW);
    }
}

void MainWindowCurve::dragEnterEvent(QDragEnterEvent* event)
{
    qDebug() << "MainWindowCurve dragEnterEvent";

    const QMimeData* mimeData = event->mimeData();
    // 检查拖拽的数据类型，确定是否接受拖拽
    if (event->mimeData()->hasFormat("text/plain")) {
        event->acceptProposedAction();
        //QApplication::setOverrideCursor(Qt::PointingHandCursor); // 设置鼠标为可添加状态
    }
    else
    {
        event->ignore();
        //QApplication::setOverrideCursor(Qt::ForbiddenCursor); // 设置鼠标为不可添加状态
    }
}

void MainWindowCurve::dragMoveEvent(QDragMoveEvent* event)
{
    //qDebug() << "MainWindowCurve dragMoveEvent";

    // 可以在这里更新鼠标的位置，根据位置判断是否可以放置
    // ...
    //dragEnterEvent(event); // 可以使用相同的逻辑
    //event->accept();
}


void MainWindowCurve::dropEvent(QDropEvent* event)
{
    qDebug() << "MainWindowCurve dropEvent";

    // 处理放置动作，更新UI或数据
    if (event->mimeData()->hasFormat("text/plain")) {
        // 获取拖拽的数据
        QString strExtern = event->mimeData()->text();
        qDebug() << strExtern;
        //
        QStringList list = strExtern.split("#@@#");//QString字符串分割函数
        if (list.size() > 3)
        {
            QString strSlfName = list[0];
            QString strWellName = list[1];
            QString strLineName = list[2];
            QString strType = list[3];

            qDebug() << "strSlfName:" << strSlfName<< " strWellName:" << strWellName << " strLineName:" << strLineName << " strType:" << strType;

            if(strType=="curveObject" || strType=="waveObject" || strType=="tableObject")
            {
                //新建井+道+曲线(首条)
                NewWellAndTrack(strWellName, strSlfName, strLineName, strType);
            }
        }

        //QMessageBox::information(this, "提示", strExtern);

        // 接受拖拽事件
        event->setDropAction(Qt::MoveAction);
        event->accept();
    }
    else
    {
         // 如果数据格式不正确，不接受拖拽事件
         event->ignore();
    }
    // 恢复鼠标光标
    //QApplication::restoreOverrideCursor();
}

void MainWindowCurve::slotContextMenu(QPoint pos)
{
//    QMenu menu(ui->tableWidget);
//    QAction *newAction = menu.addAction("新建图头");
//    // 弹出菜单
//    QAction *selectedAction = menu.exec(ui->tableWidget->mapToGlobal(pos));
//    if (selectedAction == newAction) {
//        NewHeadDialog *dlg = new NewHeadDialog(this);
//        //
//        dlg->setAttribute(Qt::WA_DeleteOnClose);//关闭时，自动删除窗口对象
//        int result = dlg->exec();//模态对话框
//        if (result == QDialog::Accepted) {
//            // 处理用户点击了确定按钮的逻辑
//            qDebug() << "Accepted=";

//            int rowcount = ui->tableWidget->rowCount();  //总行数
//            //增加1行
//            ui->tableWidget->setRowCount(rowcount+1);
//            //行标题
//            QTableWidgetItem *headerItem = new QTableWidgetItem("");
//            ui->tableWidget->setVerticalHeaderItem(rowcount, headerItem);

//            int iWidth=0;
//            //设置行高度
//            ui->tableWidget->setRowHeight(rowcount, g_iRows*(g_iRowsHight+2)+1);
//            if(rowcount==0)
//            {
//                iWidth=g_iCols*g_iColsWidth;
//                //设置列宽
//                ui->tableWidget->setColumnWidth(0, g_iCols*(g_iColsWidth+1)+1);
//            }
//            else
//            {
//                iWidth=ui->tableWidget->columnWidth(0);
//                if(iWidth<g_iCols*g_iColsWidth)//列宽变大
//                {
//                    iWidth=g_iCols*g_iColsWidth;
//                    //设置列宽
//                    ui->tableWidget->setColumnWidth(0, g_iCols*(g_iColsWidth+1)+1);
//                }
//            }
//            //
//            FormHead *widgetHead = new FormHead(this, 1);
//            widgetHead->Init(g_iRows, g_iCols, iWidth);
//            ui->tableWidget->setCellWidget(rowcount, 0, widgetHead);
//        }
//        else if (result == QDialog::Rejected) {
//            // 处理用户点击了取消按钮的逻辑
//            qDebug() << "Rejected=";
//        }
//        else {
//            // 处理其他情况的逻辑
//            qDebug() << "other=";
//        }
//    }


//    if(ui->tableWidget->rowCount()==0 && ui->tableWidget->rowCount()==0)
//    {
//        QMenu menu(ui->tableWidget);
//        QAction *newAction = menu.addAction("新建图头");
//        // 弹出菜单
//        QAction *selectedAction = menu.exec(ui->tableWidget->mapToGlobal(pos));
//        if (selectedAction == newAction) {
//            NewHeadDialog *dlg = new NewHeadDialog(this);
//            //
//            dlg->setAttribute(Qt::WA_DeleteOnClose);//关闭时，自动删除窗口对象
//            int result = dlg->exec();//模态对话框
//            if (result == QDialog::Accepted) {
//                // 处理用户点击了确定按钮的逻辑
//                qDebug() << "Accepted=";
//                //
//                ui->tableWidget->clear();
//                //
//                ui->tableWidget->setColumnCount(g_iCols);
//                ui->tableWidget->setRowCount(g_iRows); //动态设置行数
//                for(int i=0; i<g_iRows; i++)
//                {
//                    for(int j=0; j<g_iCols; j++)
//                    {
//                        QTableWidgetItem* item = new QTableWidgetItem("");
//                        ui->tableWidget->setItem(i, j, item);
//                    }
//                }

//            }
//            else if (result == QDialog::Rejected) {
//                // 处理用户点击了取消按钮的逻辑
//                qDebug() << "Rejected=";
//            }
//            else {
//                // 处理其他情况的逻辑
//                qDebug() << "other=";
//            }
//        }
//    }
//    else
//    {
//        QMenu menu(ui->tableWidget);
//        QAction *mergeAction = menu.addAction("合并表格");
//        QAction *refreshAction = menu.addAction("拆分表格");
//        QAction *deleteAction = menu.addAction("删除行");
//        QAction *addAction = menu.addAction("添加行");

//        // 弹出菜单
//        QAction *selectedAction = menu.exec(ui->tableWidget->mapToGlobal(pos));

//        if (selectedAction == mergeAction) {
//            qDebug() << "合并表格";
//            slotMerge();
//        } else if (selectedAction == deleteAction) {
//            //删除1行
//            int row = ui->tableWidget->currentRow();
//            ui->tableWidget->removeRow(row);
//        } else if (selectedAction == refreshAction) {
//            qDebug() << "拆分表格";
//            slotSplit();
//        }
//    }
}

//合并
void MainWindowCurve::slotMerge()
{
//    QModelIndexList list = ui->tableWidget->selectionModel()->selectedIndexes();
//    if (list.size() < 2)
//    {
//        QMessageBox::warning(this, "单元格合并", "所选中单元格中为单个单元格，无法合并", "确定");
//        return;
//    }

//    int topRow = 0;
//    int leftCol = 0;
//    int bottomRow = 0;
//    int rightCol = 0;

//    QList<QTableWidgetSelectionRange> selectRanges = ui->tableWidget->selectedRanges();

//       if (selectRanges.size() > 0)
//       {
//           topRow = selectRanges[0].topRow();
//           leftCol = selectRanges[0].leftColumn();
//           bottomRow = selectRanges[0].bottomRow();
//           rightCol = selectRanges[0].rightColumn();
//       }
//       for(auto range:selectRanges)
//       {
//          if(range.topRow()<topRow)
//              topRow=range.topRow();
//          if(range.leftColumn()<leftCol)
//              leftCol=range.leftColumn();
//          if(range.bottomRow()> bottomRow)
//              bottomRow=range.bottomRow();
//          if(range.rightColumn()>rightCol)
//              rightCol=range.rightColumn();
//       }

//     int rowSpan = (bottomRow - topRow) + 1;
//     int colSpan = (rightCol - leftCol) + 1;
//     ui->tableWidget->setSpan(topRow, leftCol, rowSpan, colSpan);
}


//拆分
void MainWindowCurve::slotSplit()
{
//    int row,col;
//    QList<QTableWidgetSelectionRange> selectRanges = ui->tableWidget->selectedRanges();
//    if (selectRanges.size() < 2)
//    {
//        QMessageBox::warning(this, "拆分表格失败", "单元格已是最小单位，不能再进行拆分", "确定");
//        return;
//    }
//    QList<QTableWidgetItem*> selectItems = ui->tableWidget->selectedItems();
//    if(selectItems.size()==0)
//    {
//        QMessageBox::warning(this, "拆分表格失败", "请先为表格设置元素item", "确定");
//        return;
//    }
//    if(selectItems.size()>1)
//    {
//         QMessageBox::warning(this, "拆分表格失败", "非法选择", "确定");
//         return;
//    }
//    for(auto item:selectItems)
//    {
//        row= item->row();
//        col=item->column();
//    }

//    ui->tableWidget->setSpan(row, col, 1, 1);  // 设置跨度为1
}

bool MainWindowCurve::eventFilter(QObject* obj, QEvent* event)
{
//    if (obj == ui->tableWidget && event->type() == QEvent::KeyPress) {
//        QKeyEvent* keyEvent = static_cast<QKeyEvent*>(event);
//        if (keyEvent->matches(QKeySequence::Paste)) {
//            onPasteExcelData();
//            return true;
//        }
//    }
    return QMainWindow::eventFilter(obj, event);
}

//复制粘贴事件
void MainWindowCurve::keyPressEvent(QKeyEvent * event)
{
//    //excel 行分是 "\n" ;  列分是 "\t"
//    if (event->matches(QKeySequence::Copy))
//    {
//        copy();
//    }
//    else if (event->matches(QKeySequence::Paste))
//    {
//        Paste();
//    }
//    else if (event->matches(QKeySequence::SelectAll))
//    {
//        ui->tableWidget->selectAll();
//    }
//    else
//    {
//        QWidget::keyPressEvent(event);
//    }
}

void MainWindowCurve::copy()
{
//    QMap<int, QList<int>> selMap;//行，列
//        QList<QTableWidgetItem*> list = ui->tableWidget->selectedItems();
//        if (list.count() <= 0)
//            return;
//        for (QTableWidgetItem* item : list)
//        {
//            int rowN = ui->tableWidget->row(item);
//            int colN = ui->tableWidget->column(item);
//            selMap[rowN].append(colN);
//        }
//        QString cpStr;
//        QMap<int, QList<int>>::iterator it = selMap.begin();
//        while (it != selMap.end())
//        {
//            for (int i = 0; i < (*it).count(); i++)
//            {
//                QTableWidgetItem* item = ui->tableWidget->item(it.key(), (*it).at(i));
//                if (item)
//                {
//                    cpStr.append(item->text().trimmed());
//                }
//                if (i != (*it).count() - 1)
//                    cpStr.append("\t");
//            }
//            it++;
//            if (it != selMap.end())
//            {
//                cpStr.append("\n");
//            }
//        }
//        QApplication::clipboard()->setText(cpStr);
}

void MainWindowCurve::Paste()
{
//    QString pastText = QApplication::clipboard()->text();
//    QStringList rowList = pastText.split("\n", QString::KeepEmptyParts);
//    if(rowList.size()==0)
//    {
//        return;
//    }
//    if(rowList.at(rowList.size()-1)=="")
//    {
//        rowList.removeAt(rowList.size()-1);
//    }
//    QTableWidgetItem* crtItem = ui->tableWidget->currentItem();
//    int rowN, colN;
//    if (!crtItem)
//    {
//        rowN = ui->tableWidget->currentRow();
//        colN = ui->tableWidget->currentColumn();
//    }
//    else
//    {
//        rowN = ui->tableWidget->row(crtItem);
//        colN = ui->tableWidget->column(crtItem);
//    }
//    for (int i = 0; i < (ui->tableWidget->rowCount() - rowN) && (i < rowList.length()); i++)
//    {
//        QStringList rowDataList = rowList.at(i).split("\t", QString::KeepEmptyParts);
//        for (int j = 0; j < (ui->tableWidget->columnCount() - colN) && (j < rowDataList.length()); j++)
//        {
//            int x = i + rowN;
//            int y = j + colN;

//            QTableWidgetItem* item = ui->tableWidget->item(x, y);
//            if (item)
//            {
//                item->setText(rowDataList.at(j));
//            }
//            else
//            {
//                ui->tableWidget->setItem(x, y, new QTableWidgetItem(rowDataList.at(j)));
//            }
//        }
//    }
}

void MainWindowCurve::onPasteExcelData()
{
//    QClipboard* clipboard = QApplication::clipboard();
//    const QString clipData = clipboard->text();

//    if (clipData.isEmpty()) return;

//    QList<QStringList> rowsData;
//    const QStringList rows = clipData.split('\n', QString::SkipEmptyParts);
//    for (const QString row:rows) {
//        rowsData << row.split('\t', QString::SkipEmptyParts);
//    }

//    QTableWidget* table = ui->tableWidget;
//    const QModelIndex currentIndex = table->currentIndex();
//    const int startRow = currentIndex.isValid() ? currentIndex.row() : 0;
//    const int startCol = currentIndex.isValid() ? currentIndex.column() : 0;

//    table->setUpdatesEnabled(false);
//    table->setRowCount(std::max(table->rowCount(), startRow + rowsData.size()));
//    table->setColumnCount(std::max(table->columnCount(), startCol + rowsData[0].size()));

//    for (int i = 0; i < rowsData.size(); ++i) {
//        for (int j = 0; j < rowsData[i].size(); ++j) {
//            if (startRow + i >= table->rowCount()) break;
//            if (startCol + j >= table->columnCount()) break;

//            QTableWidgetItem* item = table->item(startRow + i, startCol + j);
//            if (!item) {
//                item = new QTableWidgetItem();
//                table->setItem(startRow + i, startCol + j, item);
//            }
//            item->setText(rowsData[i][j]);
//        }
//    }
//    table->setUpdatesEnabled(true);
}


void MainWindowCurve::Open(QString fileFull)
{
    QString strPrjname = "";
    QJsonArray wellsArray;

    QJsonParseError jsonError;
    // 文件
    QFile file(fileFull);
    if(file.open(QIODevice::ReadOnly))
    {
        // 解析JSON
        QJsonDocument document = QJsonDocument::fromJson(file.readAll(), &jsonError);
        if (!document.isNull() && (jsonError.error == QJsonParseError::NoError))
        {
            if (document.isObject())
            {
                QJsonObject object = document.object();
                //
                if (object.contains("prjname"))
                {
                    QJsonValue value = object.value("prjname");
                    if (value.isString()) {
                        strPrjname = value.toString();
                        qDebug() << "prjname:" << strPrjname;

                        if(strPrjname != g_prjname)
                        {
                            file.close();
                            qDebug() << "JSON 模板文件项目名称与当前项目不一致！";
                            return;
                        }
                    }
                }
                //
                if (object.contains("iScale"))
                {
                    QJsonValue value = object.value("iScale");
                    if (value.isDouble()) {
                        int iScale = value.toInt();
                        qDebug() << "iScale:" << QString::number(iScale);
                        //
                        m_iScale  = iScale;
                    }
                }
                //
                if (object.contains("iY1"))
                {
                    QJsonValue value = object.value("iY1");
                    if (value.isDouble()) {
                        int iY1 = value.toInt();
                        qDebug() << "iY1:" << QString::number(iY1);
                        //
                        m_iY1  = iY1;
                    }
                }
                //
                if (object.contains("iY2"))
                {
                    QJsonValue value = object.value("iY2");
                    if (value.isDouble()) {
                        int iY2 = value.toInt();
                        qDebug() << "iY2:" << QString::number(iY2);
                        //
                        m_iY2  = iY2;
                    }
                }
                //
                if (object.contains("wells"))
                {
                    QJsonValue value = object.value("wells");
                    if (value.isArray()) {
                        wellsArray = value.toArray();
                        qDebug() << "wellsArray number:" << QString::number(wellsArray.size());
                        //展示所有井
                        DisplayWells(wellsArray);
                    }
                }
            }
        }

        //
        file.close();
        qDebug() << "JSON 模板文件读取成功！";

        //触发更新
        //QTimer::singleShot(2000, this, SLOT(slot_time()));
    } else {
        qWarning() << "JSON 模板文件打开失败：" << file.errorString();
    }
}

//改变道宽
void MainWindowCurve::s_changeWidth(QString strUuid, QString strSlfName, QString strWellName, QString strTrackName, int iCurrentCol, int iNewWidth)
{
    int columnCount = ui->tableWidget_2->columnCount();//总列数
    for(int i=0; i<columnCount; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }

        if( ui->tableWidget_2->cellWidget(1, i) != nullptr )
        {
             auto myWidget = ui->tableWidget_2->cellWidget(1, i);
             if(myWidget)
             {
                 //
                 FormWell *widgetWell = (FormWell*)myWidget;//获得widget
                 if(widgetWell)
                 {
                     if(widgetWell->m_strUuid==strUuid
                        && widgetWell->m_strSlfName==strSlfName
                        && widgetWell->m_strWellName==strWellName)
                     {
                        int iWellWidth = widgetWell->setColWidth(iCurrentCol, iNewWidth);

                        //调整井宽
                        ui->tableWidget_2->setColumnWidth(i, iWellWidth);
                        break;
                     }
                 }
             }
        }
    }
}

void MainWindowCurve::slot_time()
{
}

//改变缩放比例
void MainWindowCurve::s_changeScale(QString strUuid, int iNewScale)
{
    if(m_strUuid==strUuid)
    {
    }
    else
    {
        return;
    }

    QProgressBar *progressBar = new QProgressBar(this);
    progressBar->setGeometry(100, 100, 500, 30); // 设置进度条的位置和大小
    progressBar->setMaximum(100); // 设置最大值为100
    progressBar->setValue(0); // 初始值设为0
    progressBar->show();

    m_iScale = iNewScale;

    double dHight = 0;
    dHight = (m_iY2-m_iY1)*100.0/(double)m_iScale * g_dPixelPerCm;
    if(g_iShow==1)
    {
        //显示刻度
        dHight = dHight+30;
    }
    if(dHight>32767)
    {
        dHight = 32767;
    }

    double dHightOne = dHight+300+100+10;
    //设置高度
    ui->tableWidget_2->setRowHeight(1, (int)dHightOne);//8020

    //--------------------
    //
    int columnCount = ui->tableWidget_2->columnCount();//总列数
    int iSplit = 100 / (columnCount/2+1);

    for(int i=0; i<columnCount; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }

        //progressBar->setValue(i*iSplit); // 更新进度条的值
        //QCoreApplication::processEvents(); // 让界面更新显示进度条的当前值

        if( ui->tableWidget_2->cellWidget(1, i) != nullptr )
        {
             auto myWidget = ui->tableWidget_2->cellWidget(1, i);
             if(myWidget)
             {
                 //
                 FormWell *widgetWell = (FormWell*)myWidget;//获得widget
                 if(widgetWell)
                 {
                    widgetWell->m_iScale = iNewScale;
                    widgetWell->setRowHeight(dHight, progressBar, iSplit);
                 }
             }
        }
    }
    //
    progressBar->deleteLater();
    //update();
}


//改变深度
void MainWindowCurve::s_changeDepth(QString strUuid, QString strSlfName, QString strWellName, int iY1, int iY2)
{
    if(m_strUuid==strUuid)
    {
    }
    else
    {
        return;
    }

    QProgressBar *progressBar = new QProgressBar(this);
    progressBar->setGeometry(100, 100, 500, 30); // 设置进度条的位置和大小
    progressBar->setMaximum(100); // 设置最大值为100
    progressBar->setValue(0); // 初始值设为0
    progressBar->show();

    m_iY1 = iY1;
    m_iY2 = iY2;

    double dHight = 0;
    dHight = (m_iY2-m_iY1)*100.0/(double)m_iScale * g_dPixelPerCm;
    if(g_iShow==1)
    {
        //显示刻度
        dHight = dHight+30;
    }
    if(dHight>32767)
    {
        dHight = 32767;
    }


    double dHightMax=0;
    //--------------------
    //
    int columnCount = ui->tableWidget_2->columnCount();//总列数
    int iSplit = 100 / (columnCount/2+1);

    for(int i=0; i<columnCount; i++)
    {
        if(i%2==0)
        {
        }
        else
        {
            //空白列
            continue;
        }

        //progressBar->setValue(i*iSplit); // 更新进度条的值
        //QCoreApplication::processEvents(); // 让界面更新显示进度条的当前值

        if( ui->tableWidget_2->cellWidget(1, i) != nullptr )
        {
             auto myWidget = ui->tableWidget_2->cellWidget(1, i);
             if(myWidget)
             {
                 //
                 FormWell *widgetWell = (FormWell*)myWidget;//获得widget
                 if(widgetWell)
                 {
                     if(widgetWell->m_strUuid==strUuid
                             && widgetWell->m_strSlfName==strSlfName
                             && widgetWell->m_strWellName==strWellName)
                     {
                        widgetWell->m_iY1 = iY1;
                        widgetWell->m_iY2 = iY2;
                        widgetWell->setRowHeight(dHight, progressBar, iSplit);
                        //break;
                     }
                     //
                     double temp = widgetWell->m_iY2 - widgetWell->m_iY1;
                     if(dHightMax<temp)
                     {
                         dHightMax=temp;
                     }
                 }
             }
        }
    }

    dHightMax = dHightMax*100.0/(double)m_iScale * g_dPixelPerCm;
    double dHightOne = dHightMax+300+100+10;
    //设置高度
    ui->tableWidget_2->setRowHeight(1, (int)dHightOne);//8020

    //
    progressBar->deleteLater();
    //update();
}

void MainWindowCurve::DisplayWells(QJsonArray wellsArray)
{
    QMap<int, int> mapWells;

    int id = 0;
    int iCount = wellsArray.size();
    for(int i=0; i<iCount; i++)
    {
        QJsonValue wellValue = wellsArray[i];

        QJsonObject wellObj = wellValue.toObject();
        //
        if (wellObj.contains("id"))
        {
            QJsonValue value = wellObj.value("id");
            if (value.isDouble()) {
                id = value.toInt();
                qDebug() << "id:" << QString::number(id);
                //
                mapWells.insert(id, i);
            }
        }
    }

    for(int id=0; id<iCount; id++)
    {
        if(mapWells.contains(id*2))
        {
            int iNum = mapWells.value(id*2);
            //按照id顺序，展示井
            QJsonValue wellValue = wellsArray[iNum];
            QJsonObject wellObj = wellValue.toObject();
            //
            if (wellObj.contains("info"))
            {
                QJsonValue value = wellObj.value("info");
                if (value.isObject()) {
                    QJsonObject wellObjInfo = value.toObject();
                    //展示其中一口井
                    DisplayWell_One(wellObjInfo);
                }
            }
        }
    }
}

//展示其中一口井
void MainWindowCurve::DisplayWell_One(QJsonObject wellObjInfo)
{
    QString strWellName = "";
    QString strSlfName = "";
    QJsonArray tracksArray;

    if (wellObjInfo.contains("WellName"))
    {
        QJsonValue value = wellObjInfo.value("WellName");
        if (value.isString()) {
            strWellName = value.toString();
            qDebug() << "WellName:" << strWellName;

            //新建井
            //mainWindowCurve->s_NewWell(strWellName);
            //s_NewWell(strWellName);
        }
    }

    if (wellObjInfo.contains("SlfName"))
    {
        QJsonValue value = wellObjInfo.value("SlfName");
        if (value.isString()) {
            strSlfName = value.toString();
            qDebug() << "strSlfName:" << strSlfName;

            //新建井
            //mainWindowCurve->s_NewWell(strWellName);
            //s_NewWell(strWellName);
        }
    }

    //新建井
    QString folderPath = GetLogdataPath();
    folderPath = folderPath + g_prjname;
    strSlfName = folderPath + "/" + "#" + strWellName + "/" + strSlfName;
    s_NewWell(strWellName, strSlfName);

    //
    if (wellObjInfo.contains("formTracks"))
    {
        QJsonValue value = wellObjInfo.value("formTracks");
        if (value.isArray()) {
            tracksArray = value.toArray();
            qDebug() << "tracksArray number:" << QString::number(tracksArray.size());
            //展示所有道
            DisplayTracks(tracksArray);
        }
    }
}

//展示所有道
void MainWindowCurve::DisplayTracks(QJsonArray tracksArray)
{
    QMap<int, int> mapTracks;

    int id = 0;
    int iCount = tracksArray.size();
    for(int i=0; i<iCount; i++)
    {
        QJsonValue trackValue = tracksArray[i];

        QJsonObject trackObj = trackValue.toObject();
        //
        if (trackObj.contains("id"))
        {
            QJsonValue value = trackObj.value("id");
            if (value.isDouble()) {
                id = value.toInt();
                qDebug() << "id:" << QString::number(id);
                //
                mapTracks.insert(id, i);
            }
        }
    }

    for(int id=0; id<iCount; id++)
    {
        if(mapTracks.contains(id))
        {
            int iNum = mapTracks.value(id);
            //按照id顺序，展示道
            QJsonValue trackValue = tracksArray[iNum];
            QJsonObject trackObj = trackValue.toObject();
            //
            if (trackObj.contains("info"))
            {
                QJsonValue value = trackObj.value("info");
                if (value.isObject()) {
                    QJsonObject trackObjInfo = value.toObject();
                    //展示其中一道
                    DisplayTrack_One(trackObjInfo, id);
                }
            }
        }
    }
}

//展示其中一道
void MainWindowCurve::DisplayTrack_One(QJsonObject trackObjInfo, int id)
{
    QString strWellName = "";
    QString strTrackName = "";
    QJsonArray linesArray;

    if (trackObjInfo.contains("WellName"))
    {
        QJsonValue value = trackObjInfo.value("WellName");
        if (value.isString()) {
            strWellName = value.toString();
            qDebug() << "WellName:" << strWellName;
        }
    }
    if (trackObjInfo.contains("TrackName"))
    {
        QJsonValue value = trackObjInfo.value("TrackName");
        if (value.isString()) {
            strTrackName = value.toString();
            qDebug() << "TrackName:" << strTrackName;
        }
    }

    //新建道+曲线
    s_NewTrack_No_Line(strWellName, strTrackName);//新建空白道，没有曲线
    if(id>0)
    {
        //改变井宽
        s_NewTrackChangeWidth(strWellName);
        //mainWindowCurve->s_NewTrackChangeWidth(strWellName);
    }

    //
    if (trackObjInfo.contains("formInfos"))
    {
        QJsonValue value = trackObjInfo.value("formInfos");
        if (value.isArray()) {
            linesArray = value.toArray();
            qDebug() << "linesArray number:" << QString::number(linesArray.size());
            //展示所有曲线
            DisplayLines(linesArray);
        }
    }
}

//展示所有曲线
void MainWindowCurve::DisplayLines(QJsonArray linesArray)
{
    QMap<int, int> mapLines;

    int id = 0;
    int iCount = linesArray.size();
    for(int i=0; i<iCount; i++)
    {
        QJsonValue lineValue = linesArray[i];

        QJsonObject lineObj = lineValue.toObject();
        //
        if (lineObj.contains("id"))
        {
            QJsonValue value = lineObj.value("id");
            if (value.isDouble()) {
                id = value.toInt();
                qDebug() << "id:" << QString::number(id);
                //
                mapLines.insert(id, i);
            }
        }
    }

    for(int id=0; id<iCount; id++)
    {
        if(mapLines.contains(id))
        {
            int iNum = mapLines.value(id);
            //按照id顺序，展示曲线
            QJsonValue lineValue = linesArray[iNum];
            QJsonObject lineObj = lineValue.toObject();
            //
            if (lineObj.contains("info"))
            {
                QJsonValue value = lineObj.value("info");
                if (value.isObject()) {
                    QJsonObject lineObjInfo = value.toObject();
                    //展示其中一条曲线
                    DisplayLine_One(lineObjInfo);
                }
            }
        }
    }
}


//展示其中一条曲线
void MainWindowCurve::DisplayLine_One(QJsonObject lineObjInfo)
{
    QString strSlfName = "";
    QString strWellName = "";
    QString strTrackName = "";
    QString strLineName = "";
    //
    double newLeftScale = 0;//左刻度
    double newRightScale = 500;//右刻度
    QString strScaleType;//刻度类型（线性，对数）
    //
    double width = 3;//线宽
    QColor lineColor = QColor(0,0,0);//颜色
    Qt::PenStyle lineStyle = Qt::SolidLine;//线形
    //岩性填充
    QString newHeadFill;//头部图例
    QString newTargetLine;//目标曲线
    QString newFillType;//填充类型
    QString newFillMode;//填充模式
    QColor newColor;//填充颜色
    QString newLithosImage = "";//岩性图片
    float new_vMin;//其他目标曲线
    float new_vMax;//其他目标曲线
    QString strOtherScaleType;//其他目标曲线,刻度类型（线性，对数）
    QColor frontColor(0, 0, 0);//岩性前景色
    QColor backColor(255, 255, 255);//岩性背景色

    if (lineObjInfo.contains("SlfName"))
    {
        QJsonValue value = lineObjInfo.value("SlfName");
        if (value.isString()) {
            strSlfName = value.toString();
            //qDebug() << "SlfName:" << strSlfName;

            //
            QString slffilename=QString("");
            int ind=strSlfName.lastIndexOf('\\');
            int ind2=strSlfName.lastIndexOf('/');
            if(ind2>ind) ind=ind2;
            if(ind>-1) {
                slffilename = strSlfName.mid(ind+1);
                strSlfName = slffilename;
            }
        }
    }
    if (lineObjInfo.contains("WellName"))
    {
        QJsonValue value = lineObjInfo.value("WellName");
        if (value.isString()) {
            strWellName = value.toString();
            //qDebug() << "WellName:" << strWellName;
        }
    }
    if (lineObjInfo.contains("TrackName"))
    {
        QJsonValue value = lineObjInfo.value("TrackName");
        if (value.isString()) {
            strTrackName = value.toString();
            //qDebug() << "TrackName:" << strTrackName;
        }
    }
    if (lineObjInfo.contains("LineName"))
    {
        QJsonValue value = lineObjInfo.value("LineName");
        if (value.isString()) {
            strLineName = value.toString();
            //qDebug() << "LineName:" << strLineName;
        }
    }

    if (lineObjInfo.contains("vmin"))
    {
        QJsonValue value = lineObjInfo.value("vmin");
        if (value.isDouble()) {
            newLeftScale = value.toDouble();
            //qDebug() << "vmin:" << QString::number(newLeftScale);
        }
    }
    if (lineObjInfo.contains("vmax"))
    {
        QJsonValue value = lineObjInfo.value("vmax");
        if (value.isDouble()) {
            newRightScale = value.toDouble();
            //qDebug() << "vmax:" << QString::number(newRightScale);
        }
    }
    if (lineObjInfo.contains("ScaleType"))
    {
        QJsonValue value = lineObjInfo.value("ScaleType");
        if (value.isString()) {
            strScaleType = value.toString();
            //qDebug() << "ScaleType:" << strScaleType;
        }
    }
    if (lineObjInfo.contains("Width"))
    {
        QJsonValue value = lineObjInfo.value("Width");
        if (value.isDouble()) {
            width = value.toDouble();
            //qDebug() << "Width:" << QString::number(width);
        }
    }

    if (lineObjInfo.contains("lineStyle"))
    {
        QJsonValue value = lineObjInfo.value("lineStyle");
        if (value.isDouble()) {
            lineStyle = (Qt::PenStyle)value.toInt();
            //qDebug() << "lineStyle:" << QString::number(lineStyle);
        }
    }
    //
    if (lineObjInfo.contains("lineColorRed"))
    {
        QJsonValue value = lineObjInfo.value("lineColorRed");
        if (value.isDouble()) {
            lineColor.setRed(value.toInt());
            //qDebug() << "lineColorRed:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("lineColorGreen"))
    {
        QJsonValue value = lineObjInfo.value("lineColorGreen");
        if (value.isDouble()) {
            lineColor.setGreen(value.toInt());
            //qDebug() << "lineColorGreen:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("lineColorBlue"))
    {
        QJsonValue value = lineObjInfo.value("lineColorBlue");
        if (value.isDouble()) {
            lineColor.setBlue(value.toInt());
            //qDebug() << "lineColorBlue:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("lineColorAlpha"))
    {
        QJsonValue value = lineObjInfo.value("lineColorAlpha");
        if (value.isDouble()) {
            lineColor.setAlpha(value.toInt());
            //qDebug() << "lineColorAlpha:" << QString::number(value.toInt());
        }
    }


    QString folderPath = GetLogdataPath();
    folderPath = folderPath + g_prjname;
    strSlfName = folderPath + "/" + "#" + strWellName + "/" + strSlfName;

    if(strLineName!="")
    {
        //新建曲线
        s_AddLine_Property(strSlfName, strWellName, strTrackName, strLineName,
                                  newLeftScale, newRightScale, strScaleType, lineColor, width, lineStyle);
    }

    //---------------
    if (lineObjInfo.contains("newHeadFill"))
    {
        QJsonValue value = lineObjInfo.value("newHeadFill");
        if (value.isString()) {
            newHeadFill = value.toString();
            //qDebug() << "newHeadFill:" << newHeadFill;
        }
    }
    if (lineObjInfo.contains("newTargetLine"))
    {
        QJsonValue value = lineObjInfo.value("newTargetLine");
        if (value.isString()) {
            newTargetLine = value.toString();
            //qDebug() << "newTargetLine:" << newTargetLine;
        }
    }
    if (lineObjInfo.contains("newFillType"))
    {
        QJsonValue value = lineObjInfo.value("newFillType");
        if (value.isString()) {
            newFillType = value.toString();
            //qDebug() << "newFillType:" << newFillType;
        }
    }
    if (lineObjInfo.contains("newFillMode"))
    {
        QJsonValue value = lineObjInfo.value("newFillMode");
        if (value.isString()) {
            newFillMode = value.toString();
            //qDebug() << "newFillMode:" << newFillMode;
        }
    }
    //
    if (lineObjInfo.contains("newColorRed"))
    {
        QJsonValue value = lineObjInfo.value("newColorRed");
        if (value.isDouble()) {
            newColor.setRed(value.toInt());
            //qDebug() << "newColorRed:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("newColorGreen"))
    {
        QJsonValue value = lineObjInfo.value("newColorGreen");
        if (value.isDouble()) {
            newColor.setGreen(value.toInt());
            //qDebug() << "newColorGreen:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("newColorBlue"))
    {
        QJsonValue value = lineObjInfo.value("newColorBlue");
        if (value.isDouble()) {
            newColor.setBlue(value.toInt());
            //qDebug() << "newColorBlue:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("newColorAlpha"))
    {
        QJsonValue value = lineObjInfo.value("newColorAlpha");
        if (value.isDouble()) {
            newColor.setAlpha(value.toInt());
            //qDebug() << "newColorAlpha:" << QString::number(value.toInt());
        }
    }

    if (lineObjInfo.contains("newLithosImage"))
    {
        QJsonValue value = lineObjInfo.value("newLithosImage");
        if (value.isString()) {
            newLithosImage = value.toString();
            //qDebug() << "newLithosImage:" << newLithosImage;
        }
    }
    if (lineObjInfo.contains("new_vMin"))
    {
        QJsonValue value = lineObjInfo.value("new_vMin");
        if (value.isDouble()) {
            new_vMin = value.toDouble();
            //qDebug() << "new_vMin:" << QString::number(new_vMin);
        }
    }
    if (lineObjInfo.contains("new_vMax"))
    {
        QJsonValue value = lineObjInfo.value("new_vMax");
        if (value.isDouble()) {
            new_vMax = value.toDouble();
            //qDebug() << "new_vMax:" << QString::number(new_vMax);
        }
    }
    //
    if (lineObjInfo.contains("frontColorRed"))
    {
        QJsonValue value = lineObjInfo.value("frontColorRed");
        if (value.isDouble()) {
            frontColor.setRed(value.toInt());
            //qDebug() << "frontColorRed:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("frontColorGreen"))
    {
        QJsonValue value = lineObjInfo.value("frontColorGreen");
        if (value.isDouble()) {
            frontColor.setGreen(value.toInt());
            //qDebug() << "frontColorGreen:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("frontColorBlue"))
    {
        QJsonValue value = lineObjInfo.value("frontColorBlue");
        if (value.isDouble()) {
            frontColor.setBlue(value.toInt());
            //qDebug() << "frontColorBlue:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("frontColorAlpha"))
    {
        QJsonValue value = lineObjInfo.value("frontColorAlpha");
        if (value.isDouble()) {
            frontColor.setAlpha(value.toInt());
            //qDebug() << "frontColorAlpha:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("backColorRed"))
    {
        QJsonValue value = lineObjInfo.value("backColorRed");
        if (value.isDouble()) {
            backColor.setRed(value.toInt());
            //qDebug() << "backColorRed:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("backColorGreen"))
    {
        QJsonValue value = lineObjInfo.value("backColorGreen");
        if (value.isDouble()) {
            backColor.setGreen(value.toInt());
            //qDebug() << "backColorGreen:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("backColorBlue"))
    {
        QJsonValue value = lineObjInfo.value("backColorBlue");
        if (value.isDouble()) {
            backColor.setBlue(value.toInt());
            //qDebug() << "backColorBlue:" << QString::number(value.toInt());
        }
    }
    //
    if (lineObjInfo.contains("backColorAlpha"))
    {
        QJsonValue value = lineObjInfo.value("backColorAlpha");
        if (value.isDouble()) {
            backColor.setAlpha(value.toInt());
            //qDebug() << "backColorAlpha:" << QString::number(value.toInt());
        }
    }

    //
    if(newFillMode=="无填充")
    {
        //emit CallManage::getInstance()->sig_ClearFillMode(m_strUuid, strSlfName, strWellName, strTrackName, strLineName);
    }
    else //if(newFillMode=="填充")
    {
        //模板不立刻填充，bFillNow=false
        emit CallManage::getInstance()->sig_ChangeFillMode(m_strUuid, strSlfName, strWellName, strTrackName, strLineName,
                                                           newFillType, newTargetLine, newColor, newLithosImage, newHeadFill,
                                                           new_vMin, new_vMax, strOtherScaleType, frontColor, backColor, newFillMode, false);
    }
}