299 lines
13 KiB
C++
299 lines
13 KiB
C++
/****************************************************************************
|
|
* Copyright (c) 2019 Zheng, Lei (realthunder) <realthunder.dev@gmail.com>*
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
****************************************************************************/
|
|
|
|
#include "PreCompiled.h"
|
|
#include <boost/algorithm/string/predicate.hpp>
|
|
#include <QMessageBox>
|
|
#include "DlgSheetConf.h"
|
|
#include <Base/Tools.h>
|
|
#include <App/Range.h>
|
|
#include <App/Document.h>
|
|
#include <App/Application.h>
|
|
#include <App/ExpressionParser.h>
|
|
#include <App/AutoTransaction.h>
|
|
#include <Gui/CommandT.h>
|
|
#include "ui_DlgSheetConf.h"
|
|
|
|
using namespace App;
|
|
using namespace Spreadsheet;
|
|
using namespace SpreadsheetGui;
|
|
|
|
DlgSheetConf::DlgSheetConf(Sheet *sheet, Range range, QWidget *parent)
|
|
: QDialog(parent), sheet(sheet), ui(new Ui::DlgSheetConf)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
if(range.colCount()==1) {
|
|
auto to = range.to();
|
|
to.setCol(CellAddress::MAX_COLUMNS-1);
|
|
range = Range(range.from(),to);
|
|
}
|
|
|
|
ui->lineEditStart->setText(QString::fromLatin1(range.from().toString().c_str()));
|
|
ui->lineEditEnd->setText(QString::fromLatin1(range.to().toString().c_str()));
|
|
|
|
ui->lineEditProp->setDocumentObject(sheet,false);
|
|
|
|
connect(ui->btnDiscard, SIGNAL(clicked()), this, SLOT(onDiscard()));
|
|
|
|
CellAddress from,to;
|
|
std::string rangeConf;
|
|
ObjectIdentifier path;
|
|
auto prop = prepare(from,to,rangeConf,path,true);
|
|
if(prop) {
|
|
ui->lineEditProp->setText(QString::fromUtf8(path.toString().c_str()));
|
|
if (auto group = prop->getGroup())
|
|
ui->lineEditGroup->setText(QString::fromUtf8(group));
|
|
}
|
|
|
|
ui->lineEditStart->setText(QString::fromLatin1(from.toString().c_str()));
|
|
ui->lineEditEnd->setText(QString::fromLatin1(to.toString().c_str()));
|
|
}
|
|
|
|
DlgSheetConf::~DlgSheetConf()
|
|
{
|
|
delete ui;
|
|
}
|
|
|
|
App::Property *DlgSheetConf::prepare(CellAddress &from, CellAddress &to,
|
|
std::string &rangeConf, ObjectIdentifier &path, bool init)
|
|
{
|
|
from = sheet->getCellAddress(
|
|
ui->lineEditStart->text().trimmed().toLatin1().constData());
|
|
to = sheet->getCellAddress(
|
|
ui->lineEditEnd->text().trimmed().toLatin1().constData());
|
|
|
|
if(from.col()>=to.col())
|
|
FC_THROWM(Base::RuntimeError, "Invalid cell range");
|
|
|
|
// Setup row as parameters, and column as configurations
|
|
to.setRow(from.row());
|
|
|
|
CellAddress confFrom(from.row()+1,from.col());
|
|
rangeConf = confFrom.toString();
|
|
// rangeConf is supposed to hold the range of string cells, each
|
|
// holding the name of a configuration. The '|' below indicates a
|
|
// growing but continuous column, so that we can auto include new
|
|
// configurations. We'll bind the string list to a
|
|
// PropertyEnumeration for dynamical switching of the
|
|
// configuration.
|
|
rangeConf += ":|";
|
|
|
|
if(!init) {
|
|
std::string exprTxt(ui->lineEditProp->text().trimmed().toUtf8().constData());
|
|
ExpressionPtr expr;
|
|
try {
|
|
expr.reset(App::Expression::parse(sheet,exprTxt));
|
|
} catch (Base::Exception &e) {
|
|
e.ReportException();
|
|
FC_THROWM(Base::RuntimeError, "Failed to parse expression for property");
|
|
}
|
|
if(expr->hasComponent() || !expr->isDerivedFrom(App::VariableExpression::getClassTypeId()))
|
|
FC_THROWM(Base::RuntimeError, "Invalid property expression: " << expr->toString());
|
|
|
|
path = static_cast<App::VariableExpression*>(expr.get())->getPath();
|
|
auto obj = path.getDocumentObject();
|
|
if(!obj)
|
|
FC_THROWM(Base::RuntimeError, "Invalid object referenced in: " << expr->toString());
|
|
|
|
int pseudoType;
|
|
auto prop = path.getProperty(&pseudoType);
|
|
if(pseudoType || (prop && (!prop->isDerivedFrom(App::PropertyEnumeration::getClassTypeId())
|
|
|| !prop->testStatus(App::Property::PropDynamic))))
|
|
{
|
|
FC_THROWM(Base::RuntimeError, "Invalid property referenced in: " << expr->toString());
|
|
}
|
|
return prop;
|
|
}
|
|
|
|
Cell *cell = sheet->getCell(from);
|
|
if(cell && cell->getExpression()) {
|
|
auto expr = cell->getExpression();
|
|
if(expr->isDerivedFrom(FunctionExpression::getClassTypeId())) {
|
|
auto fexpr = Base::freecad_dynamic_cast<FunctionExpression>(cell->getExpression());
|
|
if(fexpr && (fexpr->getFunction()==FunctionExpression::HREF
|
|
|| fexpr->getFunction()==FunctionExpression::HIDDENREF)
|
|
&& fexpr->getArgs().size()==1)
|
|
expr = fexpr->getArgs().front();
|
|
}
|
|
auto vexpr = Base::freecad_dynamic_cast<VariableExpression>(expr);
|
|
if(vexpr) {
|
|
auto prop = Base::freecad_dynamic_cast<PropertyEnumeration>(
|
|
vexpr->getPath().getProperty());
|
|
if(prop) {
|
|
auto obj = Base::freecad_dynamic_cast<DocumentObject>(prop->getContainer());
|
|
if (obj && prop->hasName()) {
|
|
path = ObjectIdentifier(sheet);
|
|
path.setDocumentObjectName(obj,true);
|
|
path << ObjectIdentifier::SimpleComponent(prop->getName());
|
|
return prop;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
void DlgSheetConf::accept()
|
|
{
|
|
bool commandActive = false;
|
|
try {
|
|
std::string rangeConf;
|
|
CellAddress from,to;
|
|
ObjectIdentifier path;
|
|
App::Property *prop = prepare(from,to,rangeConf,path,false);
|
|
|
|
Range range(from,to);
|
|
|
|
// check rangeConf, make sure it is a sequence of string only
|
|
Range r(sheet->getRange(rangeConf.c_str()));
|
|
do {
|
|
auto cell = sheet->getCell(*r);
|
|
if(cell && cell->getExpression()) {
|
|
ExpressionPtr expr(cell->getExpression()->eval());
|
|
if(expr->isDerivedFrom(StringExpression::getClassTypeId()))
|
|
continue;
|
|
}
|
|
FC_THROWM(Base::RuntimeError, "Expects cell "
|
|
<< r.address() << " evaluates to string.\n"
|
|
<< rangeConf << " is supposed to contain a list of configuration names");
|
|
} while(r.next());
|
|
|
|
std::string exprTxt(ui->lineEditProp->text().trimmed().toUtf8().constData());
|
|
App::ExpressionPtr expr(App::Expression::parse(sheet,exprTxt));
|
|
if(expr->hasComponent() || !expr->isDerivedFrom(App::VariableExpression::getClassTypeId()))
|
|
FC_THROWM(Base::RuntimeError, "Invalid property expression: " << expr->toString());
|
|
|
|
AutoTransaction guard("Setup conf table");
|
|
commandActive = true;
|
|
|
|
// unbind any previous binding
|
|
int count = range.rowCount() * range.colCount();
|
|
for (int i=0; i<count; ++i) {
|
|
auto r = range;
|
|
auto binding = sheet->getCellBinding(r);
|
|
if(!binding)
|
|
break;
|
|
Gui::cmdAppObjectArgs(sheet, "setExpression('.cells.%s.%s.%s', None)",
|
|
binding==PropertySheet::BindingNormal?"Bind":"BindHiddenRef",
|
|
r.from().toString(), r.to().toString());
|
|
}
|
|
|
|
auto obj = path.getDocumentObject();
|
|
if(!obj)
|
|
FC_THROWM(Base::RuntimeError, "Object not found");
|
|
|
|
// Add a dynamic PropertyEnumeration for user to switch the configuration
|
|
std::string propName = path.getPropertyName();
|
|
QString groupName = ui->lineEditGroup->text().trimmed();
|
|
if(!prop) {
|
|
prop = obj->addDynamicProperty("App::PropertyEnumeration", propName.c_str(),
|
|
groupName.toUtf8().constData());
|
|
} else if (groupName.size())
|
|
obj->changeDynamicProperty(prop, groupName.toUtf8().constData(), nullptr);
|
|
prop->setStatus(App::Property::CopyOnChange,true);
|
|
|
|
// Bind the enumeration items to the column of configuration names
|
|
Gui::cmdAppObjectArgs(obj, "setExpression('%s.Enum', '%s.cells[<<%s>>]')",
|
|
propName, sheet->getFullName(), rangeConf);
|
|
|
|
Gui::cmdAppObjectArgs(obj, "recompute()");
|
|
|
|
// Bind the first cell to string value of the PropertyEnumeration. We
|
|
// could have just bind the entire row as below, but binding the first
|
|
// cell separately using a simpler expression can make it easy for us
|
|
// to extract the name of the PropertyEnumeration for editing or unsetup.
|
|
Gui::cmdAppObjectArgs(sheet, "set('%s', '=hiddenref(%s.String)')",
|
|
from.toString(CellAddress::Cell::ShowRowColumn), prop->getFullName());
|
|
|
|
// Adjust the range to skip the first cell
|
|
range = Range(from.row(),from.col()+1,to.row(),to.col());
|
|
|
|
// Formulate expression to calculate the row binding using
|
|
// PropertyEnumeration
|
|
Gui::cmdAppObjectArgs(sheet, "setExpression('.cells.Bind.%s.%s', "
|
|
"'tuple(.cells, <<%s>> + str(hiddenref(%s)+%d), <<%s>> + str(hiddenref(%s)+%d))')",
|
|
range.from().toString(CellAddress::Cell::ShowRowColumn),
|
|
range.to().toString(CellAddress::Cell::ShowRowColumn),
|
|
range.from().toString(CellAddress::Cell::ShowColumn), prop->getFullName(), from.row()+2,
|
|
range.to().toString(CellAddress::Cell::ShowColumn), prop->getFullName(), from.row()+2);
|
|
|
|
Gui::Command::doCommand(Gui::Command::Doc, "App.ActiveDocument.recompute()");
|
|
Gui::Command::commitCommand();
|
|
QDialog::accept();
|
|
} catch(Base::Exception &e) {
|
|
e.ReportException();
|
|
QMessageBox::critical(this, tr("Setup configuration table"), QString::fromUtf8(e.what()));
|
|
if(commandActive)
|
|
Gui::Command::abortCommand();
|
|
}
|
|
}
|
|
|
|
void DlgSheetConf::onDiscard() {
|
|
bool commandActive = false;
|
|
try {
|
|
std::string rangeConf;
|
|
CellAddress from,to;
|
|
ObjectIdentifier path;
|
|
auto prop = prepare(from,to,rangeConf,path,true);
|
|
|
|
Range range(from,to);
|
|
|
|
AutoTransaction guard("Unsetup conf table");
|
|
commandActive = true;
|
|
|
|
// unbind any previous binding
|
|
int count = range.rowCount() * range.colCount();
|
|
for (int i=0; i<count; ++i) {
|
|
auto r = range;
|
|
auto binding = sheet->getCellBinding(r);
|
|
if(!binding)
|
|
break;
|
|
Gui::cmdAppObjectArgs(sheet, "setExpression('.cells.%s.%s.%s', None)",
|
|
binding==PropertySheet::BindingNormal?"Bind":"BindHiddenRef",
|
|
r.from().toString(), r.to().toString());
|
|
}
|
|
|
|
Gui::cmdAppObjectArgs(sheet, "clear('%s')", from.toString(CellAddress::Cell::ShowRowColumn));
|
|
|
|
if(prop && prop->getName()) {
|
|
auto obj = path.getDocumentObject();
|
|
if(!obj)
|
|
FC_THROWM(Base::RuntimeError, "Object not found");
|
|
Gui::cmdAppObjectArgs(obj, "setExpression('%s.Enum', None)", prop->getName());
|
|
if(prop->testStatus(Property::PropDynamic))
|
|
Gui::cmdAppObjectArgs(obj, "removeProperty('%s')", prop->getName());
|
|
}
|
|
|
|
Gui::Command::doCommand(Gui::Command::Doc, "App.ActiveDocument.recompute()");
|
|
Gui::Command::commitCommand();
|
|
QDialog::accept();
|
|
} catch(Base::Exception &e) {
|
|
e.ReportException();
|
|
QMessageBox::critical(this, tr("Unsetup configuration table"), QString::fromUtf8(e.what()));
|
|
if(commandActive)
|
|
Gui::Command::abortCommand();
|
|
}
|
|
}
|
|
|
|
#include "moc_DlgSheetConf.cpp"
|