871 lines
25 KiB
C++
871 lines
25 KiB
C++
#include "QtFormulaDialogfactory.h"
|
|
|
|
#include <QHBoxLayout>
|
|
#include <QVBoxLayout>
|
|
#include <QApplication>
|
|
#include <QMap>
|
|
#include <QFileDialog>
|
|
#include <QAbstractItemModel>
|
|
#include <QHeaderView>
|
|
#include <QKeyEvent>
|
|
#include <QLineEdit>
|
|
//#include "BaseObject.h"
|
|
//#include "ObjectID.h"
|
|
//#include "DialogFactory.h"
|
|
///*#include "geo"*/
|
|
//using namespace pai::datamodel;
|
|
|
|
static inline void setupTreeViewEditorMargin(QLayout *lt)
|
|
{
|
|
enum { DecorationMargin = 4 };
|
|
if (QApplication::layoutDirection() == Qt::LeftToRight)
|
|
lt->setContentsMargins(DecorationMargin, 0, 0, 0);
|
|
else
|
|
lt->setContentsMargins(0, 0, DecorationMargin, 0);
|
|
}
|
|
|
|
template <class Value, class PrivateData>
|
|
static Value getData(const QMap<const QtProperty *, PrivateData> &propertyMap,
|
|
Value PrivateData::*data,
|
|
const QtProperty *property, const Value &defaultValue = Value())
|
|
{
|
|
typedef QMap<const QtProperty *, PrivateData> PropertyToData;
|
|
typedef typename PropertyToData::const_iterator PropertyToDataConstIterator;
|
|
const PropertyToDataConstIterator it = propertyMap.constFind(property);
|
|
if (it == propertyMap.constEnd())
|
|
return defaultValue;
|
|
return it.value().*data;
|
|
}
|
|
|
|
template <class Value, class PrivateData>
|
|
static Value getValue(const QMap<const QtProperty *, PrivateData> &propertyMap,
|
|
const QtProperty *property, const Value &defaultValue = Value())
|
|
{
|
|
return getData<Value>(propertyMap, &PrivateData::val, property, defaultValue);
|
|
}
|
|
|
|
CQtFormulaDialogFactory::CQtFormulaDialogFactory(QObject *parent)
|
|
: QtAbstractEditorFactory<CQtFormulaDialogPropertyManager>(parent), d_ptr(new CQtFormulaDialogFactoryPrivate())
|
|
{
|
|
d_ptr->q_ptr = this;
|
|
|
|
}
|
|
|
|
/*!
|
|
Destroys this factory, and all the widgets it has created.
|
|
*/
|
|
CQtFormulaDialogFactory::~CQtFormulaDialogFactory()
|
|
{
|
|
qDeleteAll(d_ptr->m_editorToProperty.keys());
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Reimplemented from the QtAbstractEditorFactory class.
|
|
*/
|
|
void CQtFormulaDialogFactory::connectPropertyManager(CQtFormulaDialogPropertyManager *manager)
|
|
{
|
|
connect(manager, SIGNAL(valueChanged(QtProperty*, QVariant)),
|
|
this, SLOT(slotPropertyChanged(QtProperty*, QVariant)));
|
|
}
|
|
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Reimplemented from the QtAbstractEditorFactory class.
|
|
*/
|
|
QWidget *CQtFormulaDialogFactory::createEditor(CQtFormulaDialogPropertyManager *manager, QtProperty *property,
|
|
QWidget *parent)
|
|
{
|
|
|
|
CQtFormulaDialogEditWidget *editor = d_ptr->createEditor(property, parent);
|
|
connect(editor,SIGNAL(tableChanged(const QString&)),manager,SIGNAL(tableChanged(const QString&)),Qt::UniqueConnection);
|
|
editor->tableDataList=manager->tableDataList;
|
|
editor->fieldList=manager->fieldDataList;
|
|
editor->tableModelData=manager->tableModelData;
|
|
connect(manager,SIGNAL(fieldListChanged(const QStringList&)),editor,SLOT(setComboxFieldDataList(const QStringList&)),Qt::UniqueConnection);
|
|
connect(manager,SIGNAL(tableListChanged(const QStringList&)),editor,SLOT(setComboxTableDataList(const QStringList&)),Qt::UniqueConnection);
|
|
|
|
connect(manager,SIGNAL(tableModelDataChanged(const ViewData&)),editor,SLOT(setTableModeData(const ViewData&)),Qt::UniqueConnection);
|
|
|
|
//connect(manager,SIGNAL(signalCallFormulaDialogAction()),editor,SLOT(buttonClicked()));
|
|
|
|
//editor->defaultDir=manager->defaultDir;
|
|
//editor->filter=manager->filter;
|
|
editor->setValue(manager->value(property));
|
|
|
|
|
|
connect(editor, SIGNAL(valueChanged(QString)), this, SLOT(slotSetValue(QString)),Qt::UniqueConnection);
|
|
connect(editor, SIGNAL(destroyed(QObject*)), this, SLOT(slotEditorDestroyed(QObject*)),Qt::UniqueConnection);
|
|
return editor;
|
|
|
|
}
|
|
|
|
/*!
|
|
\internal
|
|
|
|
Reimplemented from the QtAbstractEditorFactory class.
|
|
*/
|
|
void CQtFormulaDialogFactory::disconnectPropertyManager(CQtFormulaDialogPropertyManager *manager)
|
|
{
|
|
disconnect(manager, SIGNAL(valueChanged(QtProperty*,QString)),
|
|
this, SLOT(slotPropertyChanged(QtProperty*,QString)));
|
|
}
|
|
|
|
|
|
void CQtFormulaDialogFactoryPrivate::slotPropertyChanged(QtProperty *property, QVariant value)
|
|
{
|
|
|
|
const PropertyToEditorListMap::iterator it = m_createdEditors.find(property);
|
|
if (it == m_createdEditors.end())
|
|
return;
|
|
QListIterator<CQtFormulaDialogEditWidget *> itEditor(it.value());
|
|
|
|
while (itEditor.hasNext())
|
|
itEditor.next()->setValue(value.toString());
|
|
}
|
|
|
|
void CQtFormulaDialogFactoryPrivate::slotSetValue(QString value)
|
|
{
|
|
QObject *object = q_ptr->sender();
|
|
const QMap<CQtFormulaDialogEditWidget *, QtProperty *>::ConstIterator ecend = m_editorToProperty.constEnd();
|
|
for (QMap<CQtFormulaDialogEditWidget *, QtProperty *>::ConstIterator itEditor = m_editorToProperty.constBegin(); itEditor != ecend; ++itEditor)
|
|
if (itEditor.key() == object) {
|
|
QtProperty *property = itEditor.value();
|
|
CQtFormulaDialogPropertyManager *manager = q_ptr->propertyManager(property);
|
|
if (!manager)
|
|
return;
|
|
manager->setValue(property, value);
|
|
return;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
CQtFormulaDialogPropertyManager::CQtFormulaDialogPropertyManager(QObject *parent)
|
|
: QtAbstractPropertyManager(parent), d_ptr(new CQtFormulaDialogPropertyManagerPrivate)
|
|
{
|
|
d_ptr->q_ptr = this;
|
|
}
|
|
|
|
/*!
|
|
Destroys this manager, and all the properties it has created.
|
|
*/
|
|
CQtFormulaDialogPropertyManager::~CQtFormulaDialogPropertyManager()
|
|
{
|
|
clear();
|
|
}
|
|
|
|
/*!
|
|
Returns the given \a property's value which is an index in the
|
|
list returned by enumNames()
|
|
|
|
If the given property is not managed by this manager, this
|
|
function returns -1.
|
|
|
|
\sa enumNames(), setValue()
|
|
*/
|
|
QString CQtFormulaDialogPropertyManager::value(const QtProperty *property) const
|
|
{
|
|
return d_ptr->m_values.value(property, QString());
|
|
}
|
|
|
|
/*!
|
|
Returns the given \a property's list of enum names.
|
|
|
|
\sa value(), setEnumNames()
|
|
*/
|
|
/*!
|
|
\reimp
|
|
*/
|
|
QString CQtFormulaDialogPropertyManager::valueText(const QtProperty *property) const
|
|
{
|
|
const CQtFormulaDialogPropertyManagerPrivate::PropertyValueMap::const_iterator it = d_ptr->m_values.constFind(property);
|
|
if (it == d_ptr->m_values.constEnd())
|
|
return QString();
|
|
QString avalue=*it;
|
|
QString strFilePath = avalue;//得到用户输入的文件名
|
|
strFilePath.replace("\\","/");
|
|
QString file = strFilePath.split("/").takeLast();
|
|
//QString filename = file.split(".").takeFirst();
|
|
return file;
|
|
}
|
|
|
|
void CQtFormulaDialogPropertyManager::setFieldDataList(const QStringList &fieldList)
|
|
{
|
|
fieldDataList=fieldList;
|
|
emit fieldListChanged(fieldList);
|
|
}
|
|
void CQtFormulaDialogPropertyManager::setTableDataList(const QStringList &tableList)
|
|
{
|
|
tableDataList=tableList;
|
|
emit tableListChanged(tableList);
|
|
}
|
|
void CQtFormulaDialogPropertyManager::setTableModelData(const ViewData &modelData)
|
|
{
|
|
tableModelData=modelData;
|
|
emit tableModelDataChanged(modelData);
|
|
}
|
|
/*!
|
|
\fn void QtLineStyleEnumPropertyManager::setValue(QtProperty *property, int value)
|
|
|
|
Sets the value of the given \a property to \a value.
|
|
|
|
The specified \a value must be less than the size of the given \a
|
|
property's enumNames() list, and larger than (or equal to) 0.
|
|
|
|
\sa value(), valueChanged()
|
|
*/
|
|
void CQtFormulaDialogPropertyManager::setValue(QtProperty *property, QString val)
|
|
{
|
|
QString strFilePath = val;//得到用户输入的文件名
|
|
strFilePath.replace("\\","/");
|
|
QString file = strFilePath.split("/").takeLast();
|
|
//QString filename = file.split(".").takeFirst();
|
|
const CQtFormulaDialogPropertyManagerPrivate::PropertyValueMap::iterator it = d_ptr->m_values.find(property);
|
|
if (it == d_ptr->m_values.end())
|
|
return;
|
|
|
|
*it = file;
|
|
//m_label->setText(filename);
|
|
emit propertyChanged(property);
|
|
emit valueChanged(property, val);
|
|
|
|
|
|
}
|
|
|
|
/*!
|
|
Sets the given \a property's list of enum names to \a
|
|
enumNames. The \a property's current value is reset to 0
|
|
indicating the first item of the list.
|
|
|
|
If the specified \a enumNames list is empty, the \a property's
|
|
current value is set to -1.
|
|
|
|
\sa enumNames(), enumNamesChanged()
|
|
*/
|
|
|
|
/*!
|
|
Sets the given \a property's map of enum values to their icons to \a
|
|
enumIcons.
|
|
|
|
Each enum value can have associated icon. This association is represented with passed \a enumIcons map.
|
|
|
|
\sa enumNames(), enumNamesChanged()
|
|
*/
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void CQtFormulaDialogPropertyManager::initializeProperty(QtProperty *property)
|
|
{
|
|
d_ptr->m_values[property] = "可疑气油层";
|
|
}
|
|
|
|
/*!
|
|
\reimp
|
|
*/
|
|
void CQtFormulaDialogPropertyManager::uninitializeProperty(QtProperty *property)
|
|
{
|
|
d_ptr->m_values.remove(property);
|
|
}
|
|
|
|
//void CQtFormulaDialogPropertyManager::onGraphicsHeadCellFormula(const QString &formla)
|
|
//{
|
|
// cellFormula=formla;
|
|
//}
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//CQTtGeoStraEditWidget
|
|
CQtFormulaDialogEditWidget::CQtFormulaDialogEditWidget(QWidget *parent) :
|
|
QWidget(parent),
|
|
m_label(new QLabel),
|
|
m_button(new QToolButton),
|
|
m_formula(""),
|
|
m_tableCombox(new QComboBox),
|
|
m_fieldCombox(new QComboBox),
|
|
m_tableView(new QTableWidget),
|
|
btnAccpted(new QPushButton),
|
|
btnCancel(new QPushButton),
|
|
formulaDialog(new QDialog),
|
|
lblTable(new QLabel),
|
|
lblField(new QLabel),
|
|
lblSmall(new QLabel),
|
|
m_smallBox(new QSpinBox),
|
|
m_listWidget(new QListWidget),
|
|
btnAddCompute(new QPushButton),
|
|
btnSubtractCompute(new QPushButton),
|
|
btnMultiplyCompute(new QPushButton),
|
|
btnDivideCompute(new QPushButton),
|
|
btnAppend(new QPushButton),
|
|
btnUndo(new QPushButton),
|
|
editline(new QLineEdit()),
|
|
Noline(new QLineEdit()),
|
|
NoLabel(new QLabel),
|
|
m_lable1(new QLabel)
|
|
{
|
|
|
|
m_computeSymbol<<"+"<<"-"<<"*"<<"/";
|
|
QHBoxLayout *lt = new QHBoxLayout(this);
|
|
setupTreeViewEditorMargin(lt);
|
|
lt->setSpacing(0);
|
|
lt->addWidget(m_label);
|
|
lt->addItem(new QSpacerItem(0, 0, QSizePolicy::Expanding, QSizePolicy::Ignored));
|
|
|
|
m_button->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Ignored);
|
|
m_button->setFixedWidth(20);
|
|
setFocusProxy(m_button);
|
|
setFocusPolicy(m_button->focusPolicy());
|
|
m_button->setText(tr("..."));
|
|
m_button->installEventFilter(this);
|
|
|
|
lt->addWidget(m_button);
|
|
m_label->setText(m_formula);
|
|
m_tableView->setMouseTracking(true);
|
|
formulaDialog->setLayout(nullptr);
|
|
initConnect();
|
|
}
|
|
void CQtFormulaDialogEditWidget::initConnect()
|
|
{
|
|
connect(m_tableCombox,SIGNAL(currentIndexChanged(const QString &)),this,SIGNAL(tableChanged(const QString &)),Qt::UniqueConnection);
|
|
connect(m_button, SIGNAL(clicked()), this, SLOT(buttonClicked()));
|
|
connect(btnAccpted,SIGNAL(clicked()),this,SLOT(onAcceptOk()),Qt::UniqueConnection);
|
|
connect(btnCancel,SIGNAL(clicked()),this,SLOT(onCancel()),Qt::UniqueConnection);
|
|
|
|
|
|
connect(btnAddCompute,SIGNAL(clicked()),this,SLOT(onAddCompute()),Qt::UniqueConnection);
|
|
connect(btnSubtractCompute,SIGNAL(clicked()),this,SLOT(onSubtractCompute()),Qt::UniqueConnection);
|
|
connect(btnMultiplyCompute,SIGNAL(clicked()),this,SLOT(onMultipyCompute()),Qt::UniqueConnection);
|
|
connect(btnDivideCompute,SIGNAL(clicked()),this,SLOT(onDivideCompute()),Qt::UniqueConnection);
|
|
|
|
connect(btnAppend,SIGNAL(clicked()),this,SLOT(onAppend()),Qt::UniqueConnection);
|
|
connect(btnUndo,SIGNAL(clicked()),this,SLOT(onUndo()),Qt::UniqueConnection);
|
|
connect(m_tableView,SIGNAL(cellPressed(int, int)),this,SLOT(onCellPressed(int,int)));
|
|
|
|
}
|
|
void CQtFormulaDialogEditWidget::onCellPressed(int row,int column)
|
|
{
|
|
int rows=m_tableView->rowCount();
|
|
int cols=m_tableView->columnCount();
|
|
if (row >=0 && column < cols)
|
|
{
|
|
m_fieldCombox->setCurrentIndex(column);
|
|
}
|
|
QTableWidgetItem *item=m_tableView->item(row,column);
|
|
QString cellText,cellSam;
|
|
if (item)
|
|
{
|
|
cellText=item->text();
|
|
}
|
|
if (cellText.isEmpty())
|
|
{
|
|
return;
|
|
}
|
|
bool isOk=false;
|
|
float value=cellText.toFloat(&isOk);
|
|
int leftMid=0,canSize=0,orgSize=0;
|
|
if (isOk)
|
|
{
|
|
|
|
leftMid= cellText.lastIndexOf(".");
|
|
|
|
if (leftMid >=0)
|
|
{
|
|
leftMid=cellText.size()-(leftMid+1);
|
|
cellSam=cellText.right(leftMid);
|
|
}
|
|
|
|
}
|
|
|
|
m_smallBox->setValue(cellSam.size());
|
|
|
|
}
|
|
CQtFormulaDialogEditWidget::~CQtFormulaDialogEditWidget()
|
|
{
|
|
if(formulaDialog)
|
|
{
|
|
delete formulaDialog;
|
|
formulaDialog=NULL;
|
|
}
|
|
|
|
}
|
|
void CQtFormulaDialogEditWidget::setComboxFieldDataList()
|
|
{
|
|
|
|
m_fieldCombox->clear();
|
|
foreach(const QString &itemText,fieldList)
|
|
{
|
|
m_fieldCombox->addItem(itemText);
|
|
}
|
|
}
|
|
void CQtFormulaDialogEditWidget::setComboxTableDataList()
|
|
{
|
|
|
|
m_tableCombox->clear();
|
|
foreach(const QString &itemText,tableDataList)
|
|
{
|
|
m_tableCombox->addItem(itemText);
|
|
}
|
|
|
|
}
|
|
|
|
void CQtFormulaDialogEditWidget::setComboxFieldDataList(const QStringList& list)
|
|
{
|
|
fieldList=list;
|
|
setComboxFieldDataList();
|
|
}
|
|
void CQtFormulaDialogEditWidget::setComboxTableDataList(const QStringList& list)
|
|
{
|
|
tableDataList=list;
|
|
setComboxTableDataList();
|
|
|
|
}
|
|
|
|
void CQtFormulaDialogEditWidget::setTableModeData(const ViewData & tableData)
|
|
{
|
|
tableModelData=tableData;
|
|
bindTableData();
|
|
}
|
|
|
|
void CQtFormulaDialogEditWidget::setValue(const QString &c)
|
|
{
|
|
if (m_formula != c)
|
|
{
|
|
m_formula = c;
|
|
m_label->setText(c);
|
|
}
|
|
}
|
|
void CQtFormulaDialogEditWidget::showFormulaDlg()
|
|
{
|
|
|
|
setComboxFieldDataList();
|
|
initUI();
|
|
//bindTableData();
|
|
QString formulaStr("=TABLE(%1:%2:%3.%4)");
|
|
|
|
QString tableName,fieldName,mapFieldKey,mapFieldValue;
|
|
int tbCount=0,fieldCount=0;
|
|
bindCellFormula();
|
|
if(formulaDialog->exec() == QDialog::Accepted)
|
|
{
|
|
tbCount=m_tableCombox->count();
|
|
fieldCount=m_fieldCombox->count();
|
|
if(tbCount == 0 || fieldCount ==0)
|
|
{
|
|
return;
|
|
}
|
|
formulaStr=combinationFormual();
|
|
setValue(formulaStr);
|
|
emit valueChanged(formulaStr);
|
|
}
|
|
}
|
|
void CQtFormulaDialogEditWidget::initUI()
|
|
{
|
|
bool applayLayout=NULL == formulaDialog->layout();
|
|
if(applayLayout)
|
|
{
|
|
|
|
setComboxTableDataList();
|
|
//formulaDialog->setWindowFlags(Qt::FramelessWindowHint);
|
|
|
|
m_tableView->setParent(formulaDialog);
|
|
m_tableCombox->setParent(formulaDialog);
|
|
m_fieldCombox->setParent(formulaDialog);
|
|
btnAccpted->setParent(formulaDialog);
|
|
btnCancel->setParent(formulaDialog);
|
|
lblTable->setParent(formulaDialog);
|
|
editline->setParent(formulaDialog);
|
|
Noline->setParent(formulaDialog);
|
|
m_lable1->setParent(formulaDialog);
|
|
lblField->setParent(formulaDialog);
|
|
|
|
lblSmall->setParent(formulaDialog);
|
|
m_smallBox->setParent(formulaDialog);
|
|
m_listWidget->setParent(formulaDialog);
|
|
btnAddCompute->setParent(formulaDialog);
|
|
btnSubtractCompute->setParent(formulaDialog);
|
|
btnMultiplyCompute->setParent(formulaDialog);
|
|
btnDivideCompute->setParent(formulaDialog);
|
|
btnAppend->setParent(formulaDialog);
|
|
btnUndo->setParent(formulaDialog);
|
|
m_smallBox->setMinimum(0);
|
|
m_smallBox->setMaximum(6);
|
|
m_smallBox->setValue(0);
|
|
|
|
formulaDialog->resize(800,500);
|
|
|
|
m_lable1->setText("输入附加信息");
|
|
btnAccpted->setText("确定");
|
|
btnCancel->setText("取消");
|
|
lblTable->setText("选择数据表");
|
|
lblField->setText("选择字段");
|
|
lblSmall->setText("小数位数");
|
|
btnAddCompute->setText("+");
|
|
btnSubtractCompute->setText("-");
|
|
btnMultiplyCompute->setText("*");
|
|
btnDivideCompute->setText("/");
|
|
btnAppend->setText("添加");
|
|
btnUndo->setText("回退");
|
|
|
|
|
|
QHBoxLayout *hMainboxLayout=new QHBoxLayout(formulaDialog);
|
|
QVBoxLayout *vRightBoxLayout=new QVBoxLayout(formulaDialog);
|
|
QVBoxLayout *vboxLayout=new QVBoxLayout(formulaDialog);
|
|
QHBoxLayout *hboxLayout=new QHBoxLayout(formulaDialog);
|
|
QHBoxLayout *bottomhboxLayout=new QHBoxLayout(formulaDialog);
|
|
|
|
hboxLayout->addWidget(lblTable);
|
|
hboxLayout->addWidget(m_tableCombox);
|
|
|
|
hboxLayout->addWidget(lblField);
|
|
hboxLayout->addWidget(m_fieldCombox);
|
|
|
|
hboxLayout->addWidget(lblSmall);
|
|
hboxLayout->addWidget(m_smallBox);
|
|
|
|
hboxLayout->addStretch();
|
|
vboxLayout->addItem(hboxLayout);
|
|
vboxLayout->addWidget(m_listWidget,1);
|
|
//
|
|
vboxLayout->addWidget(m_tableView,2);
|
|
|
|
bottomhboxLayout->addStretch();
|
|
bottomhboxLayout->addWidget(m_lable1);
|
|
bottomhboxLayout->addWidget(editline);
|
|
bottomhboxLayout->addWidget(btnAccpted);
|
|
bottomhboxLayout->addWidget(btnCancel);
|
|
vboxLayout->addStretch();
|
|
vboxLayout->addItem(bottomhboxLayout);
|
|
|
|
vRightBoxLayout->addWidget(btnAddCompute);
|
|
vRightBoxLayout->addWidget(btnSubtractCompute);
|
|
vRightBoxLayout->addWidget(btnMultiplyCompute);
|
|
vRightBoxLayout->addWidget(btnDivideCompute);
|
|
vRightBoxLayout->addStretch();
|
|
vRightBoxLayout->addWidget(btnAppend);
|
|
vRightBoxLayout->addWidget(btnUndo);
|
|
vRightBoxLayout->addStretch();
|
|
NoLabel->setText("特定行");
|
|
vRightBoxLayout->addWidget(NoLabel);
|
|
vRightBoxLayout->addWidget(Noline);
|
|
|
|
vRightBoxLayout->addStretch();
|
|
|
|
hMainboxLayout->addItem(vboxLayout);
|
|
hMainboxLayout->addItem(vRightBoxLayout);
|
|
|
|
formulaDialog->setWindowTitle("选择表及字段");
|
|
|
|
}
|
|
}
|
|
QString CQtFormulaDialogEditWidget::combinationFormual()
|
|
{
|
|
QString formual;
|
|
int rows=m_listWidget->count();
|
|
if(rows == 0)
|
|
{
|
|
return formual;
|
|
}
|
|
QListWidgetItem *item=NULL;
|
|
QStringList symbolList;
|
|
for(int i=0;i<rows;i++)
|
|
{
|
|
item=m_listWidget->item(i);
|
|
if(item)
|
|
{
|
|
symbolList << item->text();
|
|
}
|
|
}
|
|
formual=symbolList.join("");
|
|
return formual;
|
|
}
|
|
void CQtFormulaDialogEditWidget::onAcceptOk()
|
|
{
|
|
formulaDialog->accept();
|
|
}
|
|
void CQtFormulaDialogEditWidget::onCancel()
|
|
{
|
|
formulaDialog->close();
|
|
}
|
|
|
|
void CQtFormulaDialogEditWidget::bindTableData()
|
|
{
|
|
|
|
int cols=0;
|
|
int rows=m_tableView->rowCount();
|
|
QAbstractItemModel *itemModel=m_tableView->model();
|
|
if (itemModel)
|
|
{
|
|
itemModel->removeRows(0,rows);
|
|
}
|
|
// 表字段
|
|
cols= fieldList.size();
|
|
// 表数据
|
|
rows=tableModelData.size();
|
|
if(rows == 0)
|
|
{
|
|
return;
|
|
}
|
|
m_tableView->setRowCount(rows);
|
|
m_tableView->setColumnCount(cols);
|
|
m_tableView->setHorizontalHeaderLabels(fieldList);
|
|
m_tableView->setSelectionMode(QAbstractItemView::SingleSelection);
|
|
m_tableView->setSelectionBehavior(QAbstractItemView::SelectItems);
|
|
|
|
QHeaderView *headView= m_tableView->horizontalHeader();
|
|
headView->setStretchLastSection(true);
|
|
itemModel=m_tableView->model();
|
|
|
|
QString text;
|
|
for(int r=0;r<rows;r++)
|
|
{
|
|
for (int c=0;c<cols;c++)
|
|
{
|
|
text=tableModelData.at(r).value(c);
|
|
if (itemModel)
|
|
{
|
|
itemModel->setData(itemModel->index(r,c),text,Qt::DisplayRole);
|
|
}
|
|
}
|
|
}
|
|
|
|
bindCellFormula();
|
|
}
|
|
void CQtFormulaDialogEditWidget::buttonClicked()
|
|
{
|
|
//QFileDialog fileDialog;
|
|
showFormulaDlg();
|
|
}
|
|
|
|
//compute slots
|
|
void CQtFormulaDialogEditWidget::onAddCompute()
|
|
{
|
|
appendComputeSymbol(btnAddCompute);
|
|
|
|
}
|
|
void CQtFormulaDialogEditWidget::onSubtractCompute()
|
|
{
|
|
appendComputeSymbol(btnSubtractCompute);
|
|
}
|
|
void CQtFormulaDialogEditWidget::onMultipyCompute()
|
|
{
|
|
appendComputeSymbol(btnMultiplyCompute);
|
|
}
|
|
void CQtFormulaDialogEditWidget::onDivideCompute()
|
|
{
|
|
appendComputeSymbol(btnDivideCompute);
|
|
}
|
|
void CQtFormulaDialogEditWidget::appendComputeSymbol(QPushButton *button)
|
|
{
|
|
|
|
QString symbolStr;
|
|
bool isAppend=false;
|
|
if (button)
|
|
{
|
|
symbolStr=button->text().trimmed();
|
|
isAppend=isAppendValidate(symbolStr);
|
|
if (isAppend)
|
|
{
|
|
m_listWidget->addItem(symbolStr);
|
|
}
|
|
}
|
|
}
|
|
bool CQtFormulaDialogEditWidget::isAppendValidate(const QString &rowItem)
|
|
{
|
|
int rows=m_listWidget->count();
|
|
bool isValidate=false;
|
|
QString symbolStr;
|
|
if(rows == 0 && !m_computeSymbol.contains(rowItem))
|
|
{
|
|
isValidate=true;
|
|
|
|
}else if(rows > 0)
|
|
{
|
|
QListWidgetItem *item= m_listWidget->item(rows-1);
|
|
symbolStr=item->text().trimmed();
|
|
if(m_computeSymbol.contains(rowItem) && !m_computeSymbol.contains(symbolStr))
|
|
{
|
|
isValidate=true;
|
|
|
|
}else if (m_computeSymbol.contains(symbolStr) && !m_computeSymbol.contains(rowItem))
|
|
{
|
|
isValidate=true;
|
|
}
|
|
}
|
|
return isValidate;
|
|
}
|
|
// fun
|
|
void CQtFormulaDialogEditWidget::onAppend()
|
|
{
|
|
int tbCount=m_tableCombox->count();
|
|
int fieldCount=m_fieldCombox->count();
|
|
if(tbCount == 0 || fieldCount ==0)
|
|
{
|
|
return;
|
|
}
|
|
QString formualTable=buildTableFormulaRow();
|
|
bool isAppend=isAppendValidate(formualTable);
|
|
if(isAppend)
|
|
{
|
|
m_listWidget->addItem(formualTable);
|
|
}
|
|
|
|
}
|
|
void CQtFormulaDialogEditWidget::onUndo()
|
|
{
|
|
int rows=m_listWidget->count();
|
|
if(rows == 0)
|
|
{
|
|
return;
|
|
}
|
|
int index=rows -1;
|
|
QListWidgetItem* item=m_listWidget->takeItem(index);
|
|
if (item)
|
|
{
|
|
delete item;
|
|
item=NULL;
|
|
}
|
|
|
|
//QListWidgetItem *item= m_listWidget->item(rows-1);
|
|
//m_listWidget->removeItemWidget(item);
|
|
}
|
|
|
|
QString CQtFormulaDialogEditWidget::buildTableFormulaRow(const QString &computeFlag)
|
|
{
|
|
QString formulaStr("=TABLE(%1:%2:%3.%4)");
|
|
QString tableName,fieldName;
|
|
int recordNo=0,reatinNum=m_smallBox->value();
|
|
if(computeFlag.isEmpty())
|
|
{
|
|
tableName=m_tableCombox->currentText();
|
|
fieldName=m_fieldCombox->currentText();
|
|
recordNo=m_tableView->currentRow()+1;
|
|
if(editline->text()!="")
|
|
{
|
|
tableName="QString";
|
|
fieldName=editline->text();
|
|
recordNo=-1;
|
|
}
|
|
if(Noline->text()!="") {
|
|
formulaStr=formulaStr.arg(tableName).arg(fieldName).arg(Noline->text()).arg(reatinNum);
|
|
}
|
|
else formulaStr=formulaStr.arg(tableName).arg(fieldName).arg(recordNo).arg(reatinNum);
|
|
}else
|
|
{
|
|
formulaStr=computeFlag;
|
|
|
|
}
|
|
return formulaStr;
|
|
}
|
|
//QString GetImagePath()
|
|
//{
|
|
// static QString imgpath;
|
|
// if(imgpath!="") return imgpath;
|
|
// QString strImagePath;
|
|
// {
|
|
// QString strPathTmp = QCoreApplication::applicationDirPath() + QDir::separator();
|
|
// strImagePath = QDir::toNativeSeparators( strPathTmp );
|
|
// QDir dir;
|
|
// if( dir.exists( strPathTmp + "image" ) )
|
|
// {
|
|
// return strPathTmp + "image" + QDir::separator();
|
|
// }else
|
|
// {
|
|
// strImagePath = strImagePath+".."+ "/LogPlus/image/";
|
|
// }
|
|
// }
|
|
// imgpath=strImagePath;
|
|
// return imgpath;
|
|
//}
|
|
bool CQtFormulaDialogEditWidget::eventFilter(QObject *obj, QEvent *ev)
|
|
{
|
|
if (obj == m_button) {
|
|
switch (ev->type()) {
|
|
case QEvent::KeyPress:
|
|
case QEvent::KeyRelease: { // Prevent the QToolButton from handling Enter/Escape meant control the delegate
|
|
switch (static_cast<const QKeyEvent*>(ev)->key()) {
|
|
case Qt::Key_Escape:
|
|
case Qt::Key_Enter:
|
|
case Qt::Key_Return:
|
|
ev->ignore();
|
|
return true;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
return QWidget::eventFilter(obj, ev);
|
|
}
|
|
|
|
void CQtFormulaDialogEditWidget::bindCellFormula()
|
|
{
|
|
//QString formulaStr("=TABLE(%1:%2:%3.%4)");
|
|
QStringList formulaLst;
|
|
QString formula;
|
|
QString computeChar;
|
|
int sIndex=0,eIndex=0;
|
|
|
|
if (m_formula.isEmpty())
|
|
{
|
|
return;
|
|
}
|
|
|
|
while(true)
|
|
{
|
|
eIndex = m_formula.indexOf(")",sIndex);
|
|
if (eIndex == -1)
|
|
{
|
|
break;
|
|
}
|
|
int tSize=m_formula.size();
|
|
eIndex++;
|
|
|
|
if (eIndex != m_formula.size())
|
|
{
|
|
computeChar= m_formula.mid(eIndex,1);
|
|
}
|
|
|
|
formula = m_formula.mid(sIndex,eIndex-sIndex);
|
|
formulaLst << formula;
|
|
if (!computeChar.isEmpty())
|
|
{
|
|
formulaLst << computeChar;
|
|
eIndex++;
|
|
computeChar=QString("");
|
|
}
|
|
|
|
sIndex=eIndex;
|
|
}
|
|
|
|
// 清空公式列表
|
|
int rows=m_listWidget->count();
|
|
while(rows > 0)
|
|
{
|
|
QListWidgetItem* item=m_listWidget->takeItem(0);
|
|
if (item)
|
|
{
|
|
delete item;
|
|
item=NULL;
|
|
}
|
|
rows=m_listWidget->count();
|
|
}
|
|
|
|
// 绑定到listview
|
|
for (int i=0;i < formulaLst.size(); i++)
|
|
{
|
|
formula=formulaLst.value(i);
|
|
bool isAppend=isAppendValidate(formula);
|
|
if(isAppend)
|
|
{
|
|
m_listWidget->addItem(formula);
|
|
}
|
|
}
|
|
|
|
}
|