kindred/create
1
1
Fork 0
Code Issues 53 Pull Requests Actions Packages Projects 9 Releases 2 Wiki Activity
Files
85d3abeb8bb35a2369fbaf4471f00e6fa182ca10
create/src/Gui/propertyeditor/PropertyItem.cpp
Zheng, Lei 85d3abeb8b Gui: put private class to anonymous namespace
2022-04-04 04:53:52 +02:00

4501 lines
141 KiB
C++
Raw Blame History

/***************************************************************************
* Copyright (c) 2004 Werner Mayer <wmayer[at]users.sourceforge.net> *
* *
* 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"
#ifndef _PreComp_
# include <algorithm>
# include <QApplication>
# include <QComboBox>
# include <QFontDatabase>
# include <QLocale>
# include <QPalette>
# include <QPixmap>
# include <QTextStream>
# include <QTimer>
# include <QtGlobal>
# include <QMenu>
#endif
#include "PropertyItem.h"
#include "PropertyView.h"
#include <App/Document.h>
#include <App/DocumentObject.h>
#include <App/Expression.h>
#include <App/PropertyGeo.h>
#include <App/PropertyFile.h>
#include <App/PropertyUnits.h>
#include <Base/Console.h>
#include <Base/Interpreter.h>
#include <Base/Tools.h>
#include <Gui/Command.h>
#include <Gui/Control.h>
#include <Gui/DlgPropertyLink.h>
#include <Gui/FileDialog.h>
#include <Gui/MainWindow.h>
#include <Gui/Placement.h>
#include <Gui/QuantitySpinBox.h>
#include <Gui/Selection.h>
#include <Gui/SpinBox.h>
#include <Gui/VectorListEditor.h>
#include <Gui/ViewProviderDocumentObject.h>
using namespace Gui::PropertyEditor;
using namespace Gui::Dialog;
Gui::PropertyEditor::PropertyItemFactory* Gui::PropertyEditor::PropertyItemFactory::_singleton = nullptr;
PropertyItemFactory& PropertyItemFactory::instance()
{
if (_singleton == nullptr)
_singleton = new PropertyItemFactory;
return *_singleton;
}
void PropertyItemFactory::destruct ()
{
delete _singleton;
_singleton = nullptr;
}
PropertyItem* PropertyItemFactory::createPropertyItem (const char* sName) const
{
PropertyItem* w = static_cast<PropertyItem*>(Produce(sName));
return w;
}
// ----------------------------------------------------
QVariant PropertyItemAttorney::toString(PropertyItem* item, const QVariant& v)
{
return item->toString(v);
}
// ----------------------------------------------------
Q_DECLARE_METATYPE(Py::Object)
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyItem)
PropertyItem::PropertyItem() : parentItem(nullptr), readonly(false), linked(false), expanded(false)
{
precision = Base::UnitsApi::getDecimals();
setAutoApply(true);
}
PropertyItem::~PropertyItem()
{
qDeleteAll(childItems);
}
void PropertyItem::initialize()
{
}
void PropertyItem::reset()
{
qDeleteAll(childItems);
childItems.clear();
}
void PropertyItem::onChange()
{
if(hasExpression()) {
for(auto child : childItems) {
if(child && child->hasExpression())
child->setExpression(std::shared_ptr<App::Expression>());
}
for(auto item=parentItem;item;item=item->parentItem) {
if(item->hasExpression())
item->setExpression(std::shared_ptr<App::Expression>());
}
}
}
bool PropertyItem::hasAnyExpression() const
{
if(ExpressionBinding::hasExpression())
return true;
if(parentItem)
return parentItem->hasExpression();
return false;
}
void PropertyItem::setPropertyData(const std::vector<App::Property*>& items)
{
//if we have a single property we can bind it for expression handling
if (items.size() == 1) {
const App::Property& p = *items.front();
try {
// Check for 'DocumentObject' as parent because otherwise 'ObjectIdentifier' raises an exception
App::DocumentObject * docObj = Base::freecad_dynamic_cast<App::DocumentObject>(p.getContainer());
if (docObj && !docObj->isReadOnly(&p)) {
App::ObjectIdentifier id(p);
std::vector<App::ObjectIdentifier> paths;
p.getPaths(paths);
//there may be no paths available in this property (for example an empty constraint list)
if (id.getProperty() && !paths.empty())
bind(id);
}
}
//it may happen that setting properties is not possible
catch (...) {
}
}
propertyItems = items;
updateData();
this->initialize();
}
void PropertyItem::updateData()
{
bool ro = true;
for (std::vector<App::Property*>::const_iterator it = propertyItems.begin();
it != propertyItems.end(); ++it) {
App::PropertyContainer* parent = (*it)->getContainer();
if (parent)
ro &= (parent->isReadOnly(*it) || (*it)->testStatus(App::Property::ReadOnly));
}
this->setReadOnly(ro);
}
const std::vector<App::Property*>& PropertyItem::getPropertyData() const
{
return propertyItems;
}
bool PropertyItem::hasProperty(const App::Property* prop) const
{
std::vector<App::Property*>::const_iterator it = std::find(propertyItems.begin(), propertyItems.end(), prop);
if (it != propertyItems.end())
return true;
else
return false;
}
void PropertyItem::assignProperty(const App::Property*)
{
}
bool PropertyItem::removeProperty(const App::Property* prop)
{
std::vector<App::Property*>::iterator it = std::find(propertyItems.begin(), propertyItems.end(), prop);
if (it != propertyItems.end()) {
propertyItems.erase(it);
}
return propertyItems.empty();
}
App::Property* PropertyItem::getFirstProperty()
{
if (propertyItems.empty())
return nullptr;
return propertyItems.front();
}
const App::Property* PropertyItem::getFirstProperty() const
{
if (propertyItems.empty())
return nullptr;
return propertyItems.front();
}
void PropertyItem::setParent(PropertyItem* parent)
{
parentItem = parent;
}
PropertyItem *PropertyItem::parent() const
{
return parentItem;
}
void PropertyItem::appendChild(PropertyItem *item)
{
childItems.append(item);
}
void PropertyItem::insertChild(int index, PropertyItem *child)
{
childItems.insert(index, child);
}
/*!
* \brief PropertyItem::removeChildren
* Deletes the children in the range of [from, to]
*/
void PropertyItem::removeChildren(int from, int to)
{
int count = to-from+1;
for (int i=0; i<count; i++) {
PropertyItem* child = childItems.takeAt(from);
delete child;
}
}
void PropertyItem::moveChild(int from, int to)
{
childItems.move(from, to);
}
/*!
* \brief PropertyItem::takeChild
* Removes the child at index row but doesn't delete it
*/
PropertyItem *PropertyItem::takeChild(int row)
{
PropertyItem* child = childItems.takeAt(row);
child->setParent(nullptr);
return child;
}
PropertyItem *PropertyItem::child(int row)
{
return childItems.value(row);
}
int PropertyItem::childCount() const
{
return childItems.count();
}
int PropertyItem::columnCount() const
{
return 2;
}
void PropertyItem::setReadOnly(bool ro)
{
readonly = ro;
for (QList<PropertyItem*>::iterator it = childItems.begin(); it != childItems.end(); ++it)
(*it)->setReadOnly(ro);
}
bool PropertyItem::isReadOnly() const
{
return readonly;
}
void PropertyItem::setLinked(bool l)
{
linked = l;
for (QList<PropertyItem*>::iterator it = childItems.begin(); it != childItems.end(); ++it)
(*it)->setLinked(l);
}
bool PropertyItem::isLinked() const
{
return linked;
}
void PropertyItem::setExpanded(bool enable)
{
expanded = enable;
}
bool PropertyItem::isExpanded() const
{
return expanded;
}
bool PropertyItem::testStatus(App::Property::Status pos) const
{
std::vector<App::Property*>::const_iterator it;
for (it = propertyItems.begin(); it != propertyItems.end(); ++it) {
if ((*it)->testStatus(pos))
return true;
}
return false;
}
void PropertyItem::setDecimals(int prec)
{
precision = prec;
}
int PropertyItem::decimals() const
{
return precision;
}
QVariant PropertyItem::displayName() const
{
return QVariant(displayText);
}
QVariant PropertyItem::toolTip(const App::Property* prop) const
{
QString str = QApplication::translate("App::Property",
prop->getDocumentation());
return QVariant(str);
}
QVariant PropertyItem::decoration(const QVariant&) const
{
return QVariant();
}
QVariant PropertyItem::toString(const QVariant& prop) const
{
if (prop != QVariant() || propertyItems.size()!=1)
return prop;
std::ostringstream ss;
Base::PyGILStateLocker lock;
try {
Py::Object pyobj(propertyItems[0]->getPyObject(),true);
if(pyobj.isNone()) {
ss << "<None>";
}
else if(pyobj.isSequence()) {
ss << '[';
Py::Sequence seq(pyobj);
bool first = true;
Py_ssize_t i=0;
for (i=0; i<2 && i < seq.size(); ++i) {
if (first)
first = false;
else
ss << ", ";
ss << Py::Object(seq[i]).as_string();
}
if (i < seq.size())
ss << "...";
ss << ']';
}
else if (pyobj.isMapping()) {
ss << '{';
Py::Mapping map(pyobj);
bool first = true;
auto it = map.begin();
for(int i=0; i<2 && it != map.end(); ++it, ++i) {
if (first)
first = false;
else
ss << ", ";
const auto &v = *it;
ss << Py::Object(v.first).as_string() << ':' << Py::Object(v.second).as_string();
}
if (it != map.end())
ss << "...";
ss << '}';
}
else
ss << pyobj.as_string();
} catch (Py::Exception &) {
Base::PyException e;
ss.str("");
ss << "ERR: " << e.what();
} catch (Base::Exception &e) {
ss.str("");
ss << "ERR: " << e.what();
} catch (std::exception &e) {
ss.str("");
ss << "ERR: " << e.what();
} catch (...) {
ss.str("");
ss << "ERR!";
}
return QVariant(QString::fromUtf8(ss.str().c_str()));
}
QVariant PropertyItem::value(const App::Property* /*prop*/) const
{
return QVariant();
}
void PropertyItem::setValue(const QVariant& /*value*/)
{
}
QWidget* PropertyItem::createEditor(QWidget* /*parent*/, const QObject* /*receiver*/, const char* /*method*/) const
{
return nullptr;
}
void PropertyItem::setEditorData(QWidget * /*editor*/, const QVariant& /*data*/) const
{
}
QVariant PropertyItem::editorData(QWidget * /*editor*/) const
{
return QVariant();
}
QWidget* PropertyItem::createExpressionEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
if(!isBound())
return nullptr;
ExpLineEdit *le = new ExpLineEdit(parent,true);
le->setFrame(false);
le->setReadOnly(true);
QObject::connect(le, SIGNAL(textChanged(const QString&)), receiver, method);
le->bind(getPath());
le->setAutoApply(autoApply());
return le;
}
void PropertyItem::setExpressionEditorData(QWidget *editor, const QVariant& data) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
if(le)
le->setText(data.toString());
}
QVariant PropertyItem::expressionEditorData(QWidget *editor) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
if(le)
return QVariant(le->text());
return QVariant();
}
PropertyEditorWidget* PropertyItem::createPropertyEditorWidget(QWidget* parent) const
{
PropertyEditorWidget* editor = new PropertyEditorWidget(parent);
connect(editor, &PropertyEditorWidget::buttonClick, this, [this]() {
const auto &props = this->getPropertyData();
if (!props.empty()
&& props[0]->getName()
&& props[0]->testStatus(App::Property::UserEdit)
&& props[0]->getContainer())
{
props[0]->getContainer()->editProperty(props[0]->getName());
}
});
return editor;
}
QString PropertyItem::propertyName() const
{
if (propName.isEmpty())
return QLatin1String(QT_TRANSLATE_NOOP("App::Property", "<empty>"));
return propName;
}
void PropertyItem::setPropertyName(QString name, QString realName)
{
if(realName.size())
propName = realName;
else
propName = name;
setObjectName(propName);
QString display;
bool upper = false;
for (int i=0; i<name.length(); i++) {
if (name[i].isUpper() && !display.isEmpty()) {
// if there is a sequence of capital letters do not insert spaces
if (!upper) {
QChar last = display.at(display.length()-1);
if (!last.isSpace())
display += QLatin1String(" ");
}
}
upper = name[i].isUpper();
display += name[i];
}
propName = display;
QString str = QApplication::translate("App::Property", propName.toUtf8());
displayText = str;
}
void PropertyItem::setPropertyValue(const QString& value)
{
// Construct command for property assignment in one go, in case of any
// intermediate changes caused by property change that may potentially
// invalidate the current property array.
std::ostringstream ss;
for (std::vector<App::Property*>::const_iterator it = propertyItems.begin();
it != propertyItems.end(); ++it) {
auto prop = *it;
App::PropertyContainer* parent = prop->getContainer();
if (!parent || parent->isReadOnly(prop) || prop->testStatus(App::Property::ReadOnly))
continue;
if (parent->isDerivedFrom(App::Document::getClassTypeId())) {
App::Document* doc = static_cast<App::Document*>(parent);
ss << "FreeCAD.getDocument('" << doc->getName() << "').";
}
else if (parent->isDerivedFrom(App::DocumentObject::getClassTypeId())) {
App::DocumentObject* obj = static_cast<App::DocumentObject*>(parent);
App::Document* doc = obj->getDocument();
ss << "FreeCAD.getDocument('" << doc->getName() << "').getObject('"
<< obj->getNameInDocument() << "').";
}
else if (parent->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId())) {
App::DocumentObject* obj = static_cast<ViewProviderDocumentObject*>(parent)->getObject();
App::Document* doc = obj->getDocument();
ss << "FreeCADGui.getDocument('" << doc->getName() << "').getObject('"
<< obj->getNameInDocument() << "').";
}
else {
continue;
}
ss << parent->getPropertyPrefix() << prop->getName()
<< " = " << value.toUtf8().constData() << '\n';
}
std::string cmd = ss.str();
if (cmd.empty())
return;
try {
Gui::Command::runCommand(Gui::Command::App, cmd.c_str());
}
catch (Base::PyException &e) {
e.ReportException();
Base::Console().Error("Stack Trace: %s\n",e.getStackTrace().c_str());
}
catch (Base::Exception &e) {
e.ReportException();
}
catch (...) {
Base::Console().Error("Unknown C++ exception in PropertyItem::setPropertyValue thrown\n");
}
}
QVariant PropertyItem::data(int column, int role) const
{
// property name
if (column == 0) {
if (role == Qt::ForegroundRole && linked)
return QVariant::fromValue(QColor(0x20,0xaa,0x20));
if (role == Qt::BackgroundRole || role == Qt::ForegroundRole) {
if(PropertyView::showAll()
&& propertyItems.size() == 1
&& propertyItems.front()->testStatus(App::Property::PropDynamic)
&& !propertyItems.front()->testStatus(App::Property::LockDynamic))
{
return role==Qt::BackgroundRole
? QVariant::fromValue(QColor(0xFF,0xFF,0x99))
: QVariant::fromValue(QColor(0,0,0));
}
return QVariant();
}
if (role == Qt::DisplayRole) {
return displayName();
}
// no properties set
if (propertyItems.empty()) {
return QVariant();
}
else if (role == Qt::ToolTipRole) {
QString type = QString::fromLatin1("Type: %1\nName: %2").arg(
QString::fromLatin1(propertyItems[0]->getTypeId().getName()), objectName());
QString doc = PropertyItem::toolTip(propertyItems[0]).toString();
if(doc.isEmpty())
doc = toolTip(propertyItems[0]).toString();
if(doc.size())
return type + QLatin1String("\n\n") + doc;
return type;
}
return QVariant();
}
else {
// no properties set
if (propertyItems.empty()) {
PropertyItem* parent = this->parent();
if (!parent || !parent->parent()) {
return QVariant();
}
if (role == Qt::EditRole) {
return parent->property(qPrintable(objectName()));
}
else if (role == Qt::DecorationRole) {
QVariant val = parent->property(qPrintable(objectName()));
return decoration(val);
}
else if (role == Qt::DisplayRole) {
QVariant val = parent->property(qPrintable(objectName()));
return toString(val);
}
else if (role == Qt::ForegroundRole) {
if (hasExpression())
return QVariant::fromValue(QApplication::palette().color(QPalette::Link));
return QVariant();
}
return QVariant();
}
if (role == Qt::EditRole) {
return value(propertyItems[0]);
}
else if (role == Qt::DecorationRole) {
return decoration(value(propertyItems[0]));
}
else if (role == Qt::DisplayRole) {
return toString(value(propertyItems[0]));
}
else if (role == Qt::ToolTipRole) {
return toolTip(propertyItems[0]);
}
else if( role == Qt::ForegroundRole) {
if (hasExpression())
return QVariant::fromValue(QApplication::palette().color(QPalette::Link));
return QVariant();
}
return QVariant();
}
}
bool PropertyItem::setData (const QVariant& value)
{
// This is the basic mechanism to set the value to
// a property and if no property is set for this item
// it delegates it to its parent which sets then the
// property or delegates again to its parent...
if (propertyItems.empty()) {
PropertyItem* parent = this->parent();
if (!parent || !parent->parent() || hasAnyExpression())
return false;
parent->setProperty(qPrintable(objectName()),value);
return true;
}
else {
setValue(value);
return true;
}
}
Qt::ItemFlags PropertyItem::flags(int column) const
{
Qt::ItemFlags basicFlags = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
if (column == 1 && !isReadOnly())
return basicFlags | Qt::ItemIsEditable;
else
return basicFlags;
}
int PropertyItem::row() const
{
if (parentItem)
return parentItem->childItems.indexOf(const_cast<PropertyItem*>(this));
return 0;
}
void PropertyItem::bind(const App::ObjectIdentifier& _path)
{
Gui::ExpressionBinding::bind(_path);
propertyBound();
}
void PropertyItem::bind(const App::Property& prop)
{
Gui::ExpressionBinding::bind(prop);
propertyBound();
}
QString PropertyItem::expressionAsString() const
{
if (hasExpression()) {
try {
std::unique_ptr<App::Expression> result(getExpression()->eval());
return QString::fromStdString(result->toString());
}
catch (const Base::Exception& e) {
e.ReportException();
}
}
return QString();
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyStringItem)
PropertyStringItem::PropertyStringItem()
{
}
QVariant PropertyStringItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyString::getClassTypeId()));
std::string value = static_cast<const App::PropertyString*>(prop)->getValue();
return QVariant(QString::fromUtf8(value.c_str()));
}
void PropertyStringItem::setValue(const QVariant& value)
{
if(!hasExpression()) {
if (!value.canConvert(QVariant::String))
return;
QString val = value.toString();
val = QString::fromUtf8(Base::Interpreter().strToPython(val.toUtf8()).c_str());
QString data = QString::fromLatin1("\"%1\"").arg(val);
setPropertyValue(data);
}
}
QWidget* PropertyStringItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
ExpLineEdit *le = new ExpLineEdit(parent);
le->setFrame(false);
le->setReadOnly(isReadOnly());
QObject::connect(le, SIGNAL(textChanged(const QString&)), receiver, method);
if(isBound()) {
le->bind(getPath());
le->setAutoApply(autoApply());
}
return le;
}
void PropertyStringItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
le->setText(data.toString());
}
QVariant PropertyStringItem::editorData(QWidget *editor) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
return QVariant(le->text());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyFontItem)
PropertyFontItem::PropertyFontItem()
{
}
QVariant PropertyFontItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFont::getClassTypeId()));
std::string value = static_cast<const App::PropertyFont*>(prop)->getValue();
return QVariant(QString::fromUtf8(value.c_str()));
}
void PropertyFontItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::String))
return;
QString val = value.toString();
QString data = QString::fromLatin1("\"%1\"").arg(val);
setPropertyValue(data);
}
QWidget* PropertyFontItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
QComboBox *cb = new QComboBox(parent);
cb->setFrame(false);
cb->setDisabled(isReadOnly());
QObject::connect(cb, SIGNAL(activated(const QString&)), receiver, method);
return cb;
}
void PropertyFontItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QComboBox *cb = qobject_cast<QComboBox*>(editor);
QFontDatabase fdb;
QStringList familyNames = fdb.families(QFontDatabase::Any);
cb->addItems(familyNames);
int index = familyNames.indexOf(data.toString());
cb->setCurrentIndex(index);
}
QVariant PropertyFontItem::editorData(QWidget *editor) const
{
QComboBox *cb = qobject_cast<QComboBox*>(editor);
return QVariant(cb->currentText());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertySeparatorItem)
QWidget* PropertySeparatorItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Q_UNUSED(parent);
Q_UNUSED(receiver);
Q_UNUSED(method);
return nullptr;
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyIntegerItem)
PropertyIntegerItem::PropertyIntegerItem()
{
}
QVariant PropertyIntegerItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyInteger::getClassTypeId()));
int value = (int)static_cast<const App::PropertyInteger*>(prop)->getValue();
return QVariant(value);
}
void PropertyIntegerItem::setValue(const QVariant& value)
{
//if the item has an expression it issues the python code
if (!hasExpression()) {
if (!value.canConvert(QVariant::Int))
return;
int val = value.toInt();
QString data = QString::fromLatin1("%1").arg(val);
setPropertyValue(data);
}
}
QWidget* PropertyIntegerItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::IntSpinBox *sb = new Gui::IntSpinBox(parent);
sb->setFrame(false);
sb->setReadOnly(isReadOnly());
QObject::connect(sb, SIGNAL(valueChanged(int)), receiver, method);
if (isBound()) {
sb->bind(getPath());
sb->setAutoApply(autoApply());
}
return sb;
}
void PropertyIntegerItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QSpinBox *sb = qobject_cast<QSpinBox*>(editor);
sb->setRange(INT_MIN, INT_MAX);
sb->setValue(data.toInt());
}
QVariant PropertyIntegerItem::editorData(QWidget *editor) const
{
QSpinBox *sb = qobject_cast<QSpinBox*>(editor);
return QVariant(sb->value());
}
QVariant PropertyIntegerItem::toString(const QVariant& v) const
{
QString string(PropertyItem::toString(v).toString());
if (hasExpression())
string += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(string);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyIntegerConstraintItem)
PropertyIntegerConstraintItem::PropertyIntegerConstraintItem()
{
}
QVariant PropertyIntegerConstraintItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyIntegerConstraint::getClassTypeId()));
int value = (int)static_cast<const App::PropertyIntegerConstraint*>(prop)->getValue();
return QVariant(value);
}
void PropertyIntegerConstraintItem::setValue(const QVariant& value)
{
//if the item has an expression it issues the python code
if (!hasExpression()) {
if (!value.canConvert(QVariant::Int))
return;
int val = value.toInt();
QString data = QString::fromLatin1("%1").arg(val);
setPropertyValue(data);
}
}
QWidget* PropertyIntegerConstraintItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::IntSpinBox *sb = new Gui::IntSpinBox(parent);
sb->setFrame(false);
sb->setReadOnly(isReadOnly());
QObject::connect(sb, SIGNAL(valueChanged(int)), receiver, method);
if (isBound()) {
sb->bind(getPath());
sb->setAutoApply(autoApply());
}
return sb;
}
void PropertyIntegerConstraintItem::setEditorData(QWidget *editor, const QVariant& data) const
{
const App::PropertyIntegerConstraint* prop = static_cast
<const App::PropertyIntegerConstraint*>(getFirstProperty());
const App::PropertyIntegerConstraint::Constraints* c = nullptr;
if (prop) {
c = prop->getConstraints();
}
QSpinBox *sb = qobject_cast<QSpinBox*>(editor);
if (c) {
sb->setMinimum(c->LowerBound);
sb->setMaximum(c->UpperBound);
sb->setSingleStep(c->StepSize);
}
else {
sb->setMinimum(INT_MIN);
sb->setMaximum(INT_MAX);
}
sb->setValue(data.toInt());
}
QVariant PropertyIntegerConstraintItem::editorData(QWidget *editor) const
{
QSpinBox *sb = qobject_cast<QSpinBox*>(editor);
return QVariant(sb->value());
}
QVariant PropertyIntegerConstraintItem::toString(const QVariant& v) const
{
QString string(PropertyItem::toString(v).toString());
if (hasExpression())
string += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(string);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyFloatItem)
PropertyFloatItem::PropertyFloatItem()
{
}
QVariant PropertyFloatItem::toString(const QVariant& prop) const
{
double value = prop.toDouble();
QString data = QLocale().toString(value, 'f', decimals());
if (hasExpression())
data += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(data);
}
QVariant PropertyFloatItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFloat::getClassTypeId()));
double value = static_cast<const App::PropertyFloat*>(prop)->getValue();
return QVariant(value);
}
void PropertyFloatItem::setValue(const QVariant& value)
{
//if the item has an expression it issues the python code
if (!hasExpression()) {
if (!value.canConvert(QVariant::Double))
return;
double val = value.toDouble();
QString data = QString::fromLatin1("%1").arg(val,0,'f',decimals());
setPropertyValue(data);
}
}
QWidget* PropertyFloatItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::DoubleSpinBox *sb = new Gui::DoubleSpinBox(parent);
sb->setFrame(false);
sb->setDecimals(decimals());
sb->setReadOnly(isReadOnly());
QObject::connect(sb, SIGNAL(valueChanged(double)), receiver, method);
if (isBound()) {
sb->bind(getPath());
sb->setAutoApply(autoApply());
}
return sb;
}
void PropertyFloatItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QDoubleSpinBox *sb = qobject_cast<QDoubleSpinBox*>(editor);
sb->setRange((double)INT_MIN, (double)INT_MAX);
sb->setValue(data.toDouble());
}
QVariant PropertyFloatItem::editorData(QWidget *editor) const
{
QDoubleSpinBox *sb = qobject_cast<QDoubleSpinBox*>(editor);
return QVariant(sb->value());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyUnitItem)
PropertyUnitItem::PropertyUnitItem()
{
}
QVariant PropertyUnitItem::toString(const QVariant& prop) const
{
const Base::Quantity& unit = prop.value<Base::Quantity>();
QString string = unit.getUserString();
if (hasExpression())
string += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(string);
}
QVariant PropertyUnitItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyQuantity::getClassTypeId()));
Base::Quantity value = static_cast<const App::PropertyQuantity*>(prop)->getQuantityValue();
return QVariant::fromValue<Base::Quantity>(value);
}
void PropertyUnitItem::setValue(const QVariant& value)
{
//if the item has an expression it handles the python code
if (!hasExpression()) {
if (!value.canConvert<Base::Quantity>())
return;
const Base::Quantity& val = value.value<Base::Quantity>();
Base::QuantityFormat format(Base::QuantityFormat::Fixed, decimals());
QString unit = Base::UnitsApi::toString(val, format);
setPropertyValue(unit);
}
}
QWidget* PropertyUnitItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::QuantitySpinBox *infield = new Gui::QuantitySpinBox(parent);
infield->setFrame(false);
infield->setMinimumHeight(0);
infield->setReadOnly(isReadOnly());
//if we are bound to an expression we need to bind it to the input field
if (isBound()) {
infield->bind(getPath());
infield->setAutoApply(autoApply());
}
QObject::connect(infield, SIGNAL(valueChanged(double)), receiver, method);
return infield;
}
void PropertyUnitItem::setEditorData(QWidget *editor, const QVariant& data) const
{
const Base::Quantity& value = data.value<Base::Quantity>();
Gui::QuantitySpinBox *infield = qobject_cast<Gui::QuantitySpinBox*>(editor);
infield->setValue(value);
infield->selectAll();
}
QVariant PropertyUnitItem::editorData(QWidget *editor) const
{
Gui::QuantitySpinBox *infield = qobject_cast<Gui::QuantitySpinBox*>(editor);
Base::Quantity value = infield->value();
return QVariant::fromValue<Base::Quantity>(value);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyUnitConstraintItem)
PropertyUnitConstraintItem::PropertyUnitConstraintItem()
{
}
void PropertyUnitConstraintItem::setEditorData(QWidget *editor, const QVariant& data) const
{
const Base::Quantity& value = data.value<Base::Quantity>();
Gui::QuantitySpinBox *infield = qobject_cast<Gui::QuantitySpinBox*>(editor);
infield->setValue(value);
infield->selectAll();
const App::PropertyQuantityConstraint* prop = static_cast
<const App::PropertyQuantityConstraint*>(getFirstProperty());
const App::PropertyQuantityConstraint::Constraints* c = nullptr;
if (prop) {
c = prop->getConstraints();
}
if (c) {
infield->setMinimum(c->LowerBound);
infield->setMaximum(c->UpperBound);
infield->setSingleStep(c->StepSize);
}
else {
infield->setMinimum((double)INT_MIN);
infield->setMaximum((double)INT_MAX);
}
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyFloatConstraintItem)
PropertyFloatConstraintItem::PropertyFloatConstraintItem()
{
}
QVariant PropertyFloatConstraintItem::toString(const QVariant& prop) const
{
double value = prop.toDouble();
QString data = QLocale().toString(value, 'f', decimals());
return QVariant(data);
}
QVariant PropertyFloatConstraintItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFloatConstraint::getClassTypeId()));
double value = static_cast<const App::PropertyFloatConstraint*>(prop)->getValue();
return QVariant(value);
}
void PropertyFloatConstraintItem::setValue(const QVariant& value)
{
//if the item has an expression it issues the python code
if (!hasExpression()) {
if (!value.canConvert(QVariant::Double))
return;
double val = value.toDouble();
QString data = QString::fromLatin1("%1").arg(val,0,'f',decimals());
setPropertyValue(data);
}
}
QWidget* PropertyFloatConstraintItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::DoubleSpinBox *sb = new Gui::DoubleSpinBox(parent);
sb->setDecimals(decimals());
sb->setFrame(false);
sb->setReadOnly(isReadOnly());
QObject::connect(sb, SIGNAL(valueChanged(double)), receiver, method);
if (isBound()) {
sb->bind(getPath());
sb->setAutoApply(autoApply());
}
return sb;
}
void PropertyFloatConstraintItem::setEditorData(QWidget *editor, const QVariant& data) const
{
const App::PropertyFloatConstraint* prop = static_cast
<const App::PropertyFloatConstraint*>(getFirstProperty());
const App::PropertyFloatConstraint::Constraints* c = nullptr;
if (prop) {
c = prop->getConstraints();
}
QDoubleSpinBox *sb = qobject_cast<QDoubleSpinBox*>(editor);
if (c) {
sb->setMinimum(c->LowerBound);
sb->setMaximum(c->UpperBound);
sb->setSingleStep(c->StepSize);
}
else {
sb->setMinimum((double)INT_MIN);
sb->setMaximum((double)INT_MAX);
sb->setSingleStep(0.1);
}
sb->setValue(data.toDouble());
}
QVariant PropertyFloatConstraintItem::editorData(QWidget *editor) const
{
QDoubleSpinBox *sb = qobject_cast<QDoubleSpinBox*>(editor);
return QVariant(sb->value());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyPrecisionItem)
PropertyPrecisionItem::PropertyPrecisionItem()
{
setDecimals(16);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyAngleItem)
PropertyAngleItem::PropertyAngleItem()
{
}
void PropertyAngleItem::setEditorData(QWidget *editor, const QVariant& data) const
{
PropertyUnitConstraintItem::setEditorData(editor, data);
}
QVariant PropertyAngleItem::toString(const QVariant& prop) const
{
return PropertyUnitConstraintItem::toString(prop);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyBoolItem)
PropertyBoolItem::PropertyBoolItem()
{
}
QVariant PropertyBoolItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyBool::getClassTypeId()));
bool value = ((App::PropertyBool*)prop)->getValue();
return QVariant(value);
}
void PropertyBoolItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::Bool))
return;
bool val = value.toBool();
QString data = (val ? QLatin1String("True") : QLatin1String("False"));
setPropertyValue(data);
}
QWidget* PropertyBoolItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
QComboBox *cb = new QComboBox(parent);
cb->setFrame(false);
cb->addItem(QLatin1String("false"));
cb->addItem(QLatin1String("true"));
cb->setDisabled(isReadOnly());
QObject::connect(cb, SIGNAL(activated(int)), receiver, method);
return cb;
}
void PropertyBoolItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QComboBox *cb = qobject_cast<QComboBox*>(editor);
cb->setCurrentIndex(cb->findText(data.toString()));
}
QVariant PropertyBoolItem::editorData(QWidget *editor) const
{
QComboBox *cb = qobject_cast<QComboBox*>(editor);
return QVariant(cb->currentText());
}
// ---------------------------------------------------------------
namespace Gui { namespace PropertyEditor {
class VectorLineEdit : public Gui::ExpLineEdit
{
int decimals;
public:
VectorLineEdit (int decimals, QWidget * parent=nullptr, bool expressionOnly=false)
: Gui::ExpLineEdit(parent, expressionOnly)
, decimals(decimals)
{
}
bool apply(const std::string &propName) {
if (!ExpressionBinding::apply(propName)) {
QVariant data = property("coords");
if (data.canConvert<Base::Vector3d>()) {
const Base::Vector3d& value = data.value<Base::Vector3d>();
QString str = QString::fromLatin1("(%1, %2, %3)")
.arg(value.x,0,'f',decimals)
.arg(value.y,0,'f',decimals)
.arg(value.z,0,'f',decimals);
Gui::Command::doCommand(Gui::Command::Doc, "%s = %s", propName.c_str(), str.toLatin1().constData());
return true;
}
}
return false;
}
};
}}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyVectorItem)
PropertyVectorItem::PropertyVectorItem()
{
m_x = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_x->setParent(this);
m_x->setPropertyName(QLatin1String("x"));
this->appendChild(m_x);
m_y = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_y->setParent(this);
m_y->setPropertyName(QLatin1String("y"));
this->appendChild(m_y);
m_z = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_z->setParent(this);
m_z->setPropertyName(QLatin1String("z"));
this->appendChild(m_z);
}
QVariant PropertyVectorItem::toString(const QVariant& prop) const
{
QLocale loc;
const Base::Vector3d& value = prop.value<Base::Vector3d>();
QString data = QString::fromLatin1("[%1 %2 %3]")
.arg(loc.toString(value.x, 'f', 2),
loc.toString(value.y, 'f', 2),
loc.toString(value.z, 'f', 2));
if (hasExpression())
data += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(data);
}
QVariant PropertyVectorItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyVector::getClassTypeId()));
const Base::Vector3d& value = static_cast<const App::PropertyVector*>(prop)->getValue();
return QVariant::fromValue<Base::Vector3d>(value);
}
void PropertyVectorItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<Base::Vector3d>())
return;
const Base::Vector3d& val = value.value<Base::Vector3d>();
QString data = QString::fromLatin1("(%1, %2, %3)")
.arg(val.x,0,'f',decimals())
.arg(val.y,0,'f',decimals())
.arg(val.z,0,'f',decimals());
setPropertyValue(data);
}
QWidget* PropertyVectorItem::createEditor(QWidget* parent, const QObject* /*receiver*/, const char* /*method*/) const
{
VectorLineEdit *le = new VectorLineEdit(decimals(), parent);
le->setFrame(false);
le->setReadOnly(true);
if (isBound()) {
le->bind(getPath());
le->setAutoApply(autoApply());
}
return le;
}
void PropertyVectorItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QLocale loc;
QLineEdit* le = qobject_cast<QLineEdit*>(editor);
const Base::Vector3d& value = data.value<Base::Vector3d>();
QString text = QString::fromLatin1("[%1 %2 %3]")
.arg(loc.toString(value.x, 'f', 2),
loc.toString(value.y, 'f', 2),
loc.toString(value.z, 'f', 2));
le->setProperty("coords", data);
le->setText(text);
}
QVariant PropertyVectorItem::editorData(QWidget *editor) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
return QVariant(le->text());
}
double PropertyVectorItem::x() const
{
return data(1,Qt::EditRole).value<Base::Vector3d>().x;
}
void PropertyVectorItem::setX(double x)
{
setData(QVariant::fromValue(Base::Vector3d(x, y(), z())));
}
double PropertyVectorItem::y() const
{
return data(1,Qt::EditRole).value<Base::Vector3d>().y;
}
void PropertyVectorItem::setY(double y)
{
setData(QVariant::fromValue(Base::Vector3d(x(), y, z())));
}
double PropertyVectorItem::z() const
{
return data(1,Qt::EditRole).value<Base::Vector3d>().z;
}
void PropertyVectorItem::setZ(double z)
{
setData(QVariant::fromValue(Base::Vector3d(x(), y(), z)));
}
void PropertyVectorItem::propertyBound()
{
m_x->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("x"));
m_y->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("y"));
m_z->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("z"));
}
// ---------------------------------------------------------------
PropertyEditorWidget::PropertyEditorWidget (QWidget * parent)
: QWidget(parent)
{
QHBoxLayout *layout = new QHBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(2);
lineEdit = new QLineEdit(this);
lineEdit->setReadOnly(true);
layout->addWidget(lineEdit);
button = new QPushButton(QLatin1String("..."), this);
#if defined (Q_OS_MAC)
button->setAttribute(Qt::WA_LayoutUsesWidgetRect); // layout size from QMacStyle was not correct
#endif
layout->addWidget(button);
connect(button, SIGNAL(clicked()), this, SIGNAL(buttonClick()));
// QAbstractItemView will call selectAll() if a QLineEdit is the focus
// proxy. Since the QLineEdit here is read-only and not meant for editing,
// do not set it as focus proxy. Otherwise, the text won't even shown for
// most stylesheets (which contain a trick to hide the content of a selected
// read-only/disabled editor widgets).
//
// setFocusProxy(lineEdit);
}
PropertyEditorWidget::~PropertyEditorWidget()
{
}
void PropertyEditorWidget::resizeEvent(QResizeEvent* e)
{
button->setFixedWidth(e->size().height());
button->setFixedHeight(e->size().height());
}
void PropertyEditorWidget::showValue(const QVariant &d)
{
lineEdit->setText(d.toString());
}
QVariant PropertyEditorWidget::value() const
{
return variant;
}
void PropertyEditorWidget::setValue(const QVariant& val)
{
variant = val;
showValue(variant);
valueChanged(variant);
}
// ---------------------------------------------------------------
VectorListWidget::VectorListWidget(int decimals, QWidget *parent)
: PropertyEditorWidget(parent)
, decimals(decimals)
{
connect(button, SIGNAL(clicked()), this, SLOT(buttonClicked()));
}
void VectorListWidget::buttonClicked()
{
VectorListEditor dlg(decimals, this);
dlg.setValues(value().value<QList<Base::Vector3d>>());
QPoint p(0, 0);
p = this->mapToGlobal(p);
dlg.move(p);
if (dlg.exec() == QDialog::Accepted) {
QVariant data = QVariant::fromValue<QList<Base::Vector3d>>(dlg.getValues());
setValue(data);
}
}
void VectorListWidget::showValue(const QVariant& d)
{
QLocale loc;
QString data;
const QList<Base::Vector3d>& value = d.value<QList<Base::Vector3d>>();
if (value.isEmpty()) {
data = QString::fromLatin1("[]");
}
else {
data = QString::fromLatin1("[%1 %2 %3], ...")
.arg(loc.toString(value[0].x, 'f', 2),
loc.toString(value[0].y, 'f', 2),
loc.toString(value[0].z, 'f', 2));
}
lineEdit->setText(data);
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyVectorListItem)
PropertyVectorListItem::PropertyVectorListItem()
{
}
QVariant PropertyVectorListItem::toString(const QVariant& prop) const
{
QLocale loc;
QString data;
const QList<Base::Vector3d>& value = prop.value<QList<Base::Vector3d>>();
if (value.isEmpty()) {
data = QString::fromLatin1("[]");
}
else {
data = QString::fromLatin1("[%1 %2 %3], ...")
.arg(loc.toString(value[0].x, 'f', 2),
loc.toString(value[0].y, 'f', 2),
loc.toString(value[0].z, 'f', 2));
}
if (hasExpression())
data += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(data);
}
QVariant PropertyVectorListItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyVectorList::getClassTypeId()));
const std::vector<Base::Vector3d>& value = static_cast<const App::PropertyVectorList*>(prop)->getValue();
QList<Base::Vector3d> list;
std::copy(value.begin(), value.end(), std::back_inserter(list));
return QVariant::fromValue<QList<Base::Vector3d>>(list);
}
void PropertyVectorListItem::setValue(const QVariant& value)
{
if (!value.canConvert<QList<Base::Vector3d>>())
return;
const QList<Base::Vector3d>& val = value.value<QList<Base::Vector3d>>();
QString data;
QTextStream str(&data);
str << "[";
for (const auto& it : val) {
str << QString::fromLatin1("(%1, %2, %3), ")
.arg(it.x,0,'f',decimals())
.arg(it.y,0,'f',decimals())
.arg(it.z,0,'f',decimals());
}
str << "]";
setPropertyValue(data);
}
QWidget* PropertyVectorListItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
VectorListWidget *pe = new VectorListWidget(decimals(), parent);
QObject::connect(pe, SIGNAL(valueChanged(const QVariant &)), receiver, method);
pe->setDisabled(isReadOnly());
return pe;
}
void PropertyVectorListItem::setEditorData(QWidget *editor, const QVariant& data) const
{
VectorListWidget *pe = qobject_cast<VectorListWidget*>(editor);
pe->setValue(data);
}
QVariant PropertyVectorListItem::editorData(QWidget *editor) const
{
VectorListWidget *pe = qobject_cast<VectorListWidget*>(editor);
return pe->value();
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyVectorDistanceItem)
PropertyVectorDistanceItem::PropertyVectorDistanceItem()
{
m_x = static_cast<PropertyUnitItem*>(PropertyUnitItem::create());
m_x->setParent(this);
m_x->setPropertyName(QLatin1String("x"));
this->appendChild(m_x);
m_y = static_cast<PropertyUnitItem*>(PropertyUnitItem::create());
m_y->setParent(this);
m_y->setPropertyName(QLatin1String("y"));
this->appendChild(m_y);
m_z = static_cast<PropertyUnitItem*>(PropertyUnitItem::create());
m_z->setParent(this);
m_z->setPropertyName(QLatin1String("z"));
this->appendChild(m_z);
}
QVariant PropertyVectorDistanceItem::toString(const QVariant& prop) const
{
const Base::Vector3d& value = prop.value<Base::Vector3d>();
QString data = QString::fromLatin1("[") +
Base::Quantity(value.x, Base::Unit::Length).getUserString() + QString::fromLatin1(" ") +
Base::Quantity(value.y, Base::Unit::Length).getUserString() + QString::fromLatin1(" ") +
Base::Quantity(value.z, Base::Unit::Length).getUserString() + QString::fromLatin1("]");
if (hasExpression())
data += QString::fromLatin1(" ( %1 )").arg(QString::fromStdString(getExpressionString()));
return QVariant(data);
}
QVariant PropertyVectorDistanceItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyVector::getClassTypeId()));
const Base::Vector3d& value = static_cast<const App::PropertyVector*>(prop)->getValue();
return QVariant::fromValue<Base::Vector3d>(value);
}
void PropertyVectorDistanceItem::setValue(const QVariant& variant)
{
if (hasExpression() || !variant.canConvert<Base::Vector3d>())
return;
const Base::Vector3d& value = variant.value<Base::Vector3d>();
Base::Quantity x = Base::Quantity(value.x, Base::Unit::Length);
Base::Quantity y = Base::Quantity(value.y, Base::Unit::Length);
Base::Quantity z = Base::Quantity(value.z, Base::Unit::Length);
Base::QuantityFormat format(Base::QuantityFormat::Fixed, decimals());
QString data = QString::fromLatin1("(%1, %2, %3)")
.arg(Base::UnitsApi::toNumber(x, format))
.arg(Base::UnitsApi::toNumber(y, format))
.arg(Base::UnitsApi::toNumber(z, format));
setPropertyValue(data);
}
void PropertyVectorDistanceItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QLineEdit* le = qobject_cast<QLineEdit*>(editor);
le->setProperty("coords", data);
le->setText(toString(data).toString());
}
QWidget* PropertyVectorDistanceItem::createEditor(QWidget* parent, const QObject* /*receiver*/, const char* /*method*/) const
{
VectorLineEdit *le = new VectorLineEdit(decimals(), parent);
le->setFrame(false);
le->setReadOnly(true);
if (isBound()) {
le->bind(getPath());
le->setAutoApply(autoApply());
}
return le;
}
QVariant PropertyVectorDistanceItem::editorData(QWidget *editor) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
return QVariant(le->text());
}
Base::Quantity PropertyVectorDistanceItem::x() const
{
return Base::Quantity(data(1,Qt::EditRole).value<Base::Vector3d>().x, Base::Unit::Length);
}
void PropertyVectorDistanceItem::setX(Base::Quantity x)
{
setData(QVariant::fromValue(Base::Vector3d(x.getValue(), y().getValue(), z().getValue())));
}
Base::Quantity PropertyVectorDistanceItem::y() const
{
return Base::Quantity(data(1,Qt::EditRole).value<Base::Vector3d>().y, Base::Unit::Length);
}
void PropertyVectorDistanceItem::setY(Base::Quantity y)
{
setData(QVariant::fromValue(Base::Vector3d(x().getValue(), y.getValue(), z().getValue())));
}
Base::Quantity PropertyVectorDistanceItem::z() const
{
return Base::Quantity(data(1,Qt::EditRole).value<Base::Vector3d>().z, Base::Unit::Length);
}
void PropertyVectorDistanceItem::setZ(Base::Quantity z)
{
setData(QVariant::fromValue(Base::Vector3d(x().getValue(), y().getValue(), z.getValue())));
}
void PropertyVectorDistanceItem::propertyBound()
{
if (isBound()) {
m_x->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("x"));
m_y->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("y"));
m_z->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("z"));
};
}
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyPositionItem)
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyDirectionItem)
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyMatrixItem)
PropertyMatrixItem::PropertyMatrixItem()
{
const int decimals=16;
m_a11 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a11->setParent(this);
m_a11->setPropertyName(QLatin1String("A11"));
m_a11->setDecimals(decimals);
this->appendChild(m_a11);
m_a12 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a12->setParent(this);
m_a12->setPropertyName(QLatin1String("A12"));
m_a12->setDecimals(decimals);
this->appendChild(m_a12);
m_a13 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a13->setParent(this);
m_a13->setPropertyName(QLatin1String("A13"));
m_a13->setDecimals(decimals);
this->appendChild(m_a13);
m_a14 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a14->setParent(this);
m_a14->setPropertyName(QLatin1String("A14"));
m_a14->setDecimals(decimals);
this->appendChild(m_a14);
m_a21 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a21->setParent(this);
m_a21->setPropertyName(QLatin1String("A21"));
m_a21->setDecimals(decimals);
this->appendChild(m_a21);
m_a22 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a22->setParent(this);
m_a22->setPropertyName(QLatin1String("A22"));
m_a22->setDecimals(decimals);
this->appendChild(m_a22);
m_a23 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a23->setParent(this);
m_a23->setPropertyName(QLatin1String("A23"));
m_a23->setDecimals(decimals);
this->appendChild(m_a23);
m_a24 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a24->setParent(this);
m_a24->setPropertyName(QLatin1String("A24"));
m_a24->setDecimals(decimals);
this->appendChild(m_a24);
m_a31 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a31->setParent(this);
m_a31->setPropertyName(QLatin1String("A31"));
m_a31->setDecimals(decimals);
this->appendChild(m_a31);
m_a32 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a32->setParent(this);
m_a32->setPropertyName(QLatin1String("A32"));
m_a32->setDecimals(decimals);
this->appendChild(m_a32);
m_a33 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a33->setParent(this);
m_a33->setPropertyName(QLatin1String("A33"));
m_a33->setDecimals(decimals);
this->appendChild(m_a33);
m_a34 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a34->setParent(this);
m_a34->setPropertyName(QLatin1String("A34"));
m_a34->setDecimals(decimals);
this->appendChild(m_a34);
m_a41 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a41->setParent(this);
m_a41->setPropertyName(QLatin1String("A41"));
m_a41->setDecimals(decimals);
this->appendChild(m_a41);
m_a42 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a42->setParent(this);
m_a42->setPropertyName(QLatin1String("A42"));
m_a42->setDecimals(decimals);
this->appendChild(m_a42);
m_a43 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a43->setParent(this);
m_a43->setPropertyName(QLatin1String("A43"));
m_a43->setDecimals(decimals);
this->appendChild(m_a43);
m_a44 = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
m_a44->setParent(this);
m_a44->setPropertyName(QLatin1String("A44"));
m_a44->setDecimals(decimals);
this->appendChild(m_a44);
}
QVariant PropertyMatrixItem::toString(const QVariant& prop) const
{
QLocale loc;
const Base::Matrix4D& value = prop.value<Base::Matrix4D>();
QString text = QString::fromLatin1("[%1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16]")
.arg(loc.toString(value[0][0], 'f', 2), //(unsigned short usNdx)
loc.toString(value[0][1], 'f', 2),
loc.toString(value[0][2], 'f', 2),
loc.toString(value[0][3], 'f', 2),
loc.toString(value[1][0], 'f', 2),
loc.toString(value[1][1], 'f', 2),
loc.toString(value[1][2], 'f', 2),
loc.toString(value[1][3], 'f', 2),
loc.toString(value[2][0], 'f', 2))
.arg(loc.toString(value[2][1], 'f', 2),
loc.toString(value[2][2], 'f', 2),
loc.toString(value[2][3], 'f', 2),
loc.toString(value[3][0], 'f', 2),
loc.toString(value[3][1], 'f', 2),
loc.toString(value[3][2], 'f', 2),
loc.toString(value[3][3], 'f', 2));
return QVariant(text);
}
QVariant PropertyMatrixItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMatrix::getClassTypeId()));
const Base::Matrix4D& value = static_cast<const App::PropertyMatrix*>(prop)->getValue();
return QVariant::fromValue<Base::Matrix4D>(value);
}
QVariant PropertyMatrixItem::toolTip(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMatrix::getClassTypeId()));
const Base::Matrix4D& value = static_cast<const App::PropertyMatrix*>(prop)->getValue();
return QVariant(QString::fromStdString(value.analyse()));
}
void PropertyMatrixItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<Base::Matrix4D>())
return;
const Base::Matrix4D& val = value.value<Base::Matrix4D>();
const int decimals=16;
QString data = QString::fromLatin1("FreeCAD.Matrix(%1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11, %12, %13, %14, %15, %16)")
.arg(val[0][0],0, 'f', decimals)
.arg(val[0][1],0, 'f', decimals)
.arg(val[0][2],0, 'f', decimals)
.arg(val[0][3],0, 'f', decimals)
.arg(val[1][0],0, 'f', decimals)
.arg(val[1][1],0, 'f', decimals)
.arg(val[1][2],0, 'f', decimals)
.arg(val[1][3],0, 'f', decimals)
.arg(val[2][0],0, 'f', decimals)
.arg(val[2][1],0, 'f', decimals)
.arg(val[2][2],0, 'f', decimals)
.arg(val[2][3],0, 'f', decimals)
.arg(val[3][0],0, 'f', decimals)
.arg(val[3][1],0, 'f', decimals)
.arg(val[3][2],0, 'f', decimals)
.arg(val[3][3],0, 'f', decimals);
setPropertyValue(data);
}
QWidget* PropertyMatrixItem::createEditor(QWidget* parent, const QObject* /*receiver*/, const char* /*method*/) const
{
QLineEdit *le = new QLineEdit(parent);
le->setFrame(false);
le->setReadOnly(true);
return le;
}
void PropertyMatrixItem::setEditorData(QWidget *editor, const QVariant& data) const
{
QLocale loc;
QLineEdit* le = qobject_cast<QLineEdit*>(editor);
const Base::Matrix4D& value = data.value<Base::Matrix4D>();
QString text = QString::fromLatin1("[%1 %2 %3 %4 %5 %6 %7 %8 %9 %10 %11 %12 %13 %14 %15 %16]")
.arg(loc.toString(value[0][0], 'f', 2), //(unsigned short usNdx)
loc.toString(value[0][1], 'f', 2),
loc.toString(value[0][2], 'f', 2),
loc.toString(value[0][3], 'f', 2),
loc.toString(value[1][0], 'f', 2),
loc.toString(value[1][1], 'f', 2),
loc.toString(value[1][2], 'f', 2),
loc.toString(value[1][3], 'f', 2),
loc.toString(value[2][0], 'f', 2))
.arg(loc.toString(value[2][1], 'f', 2),
loc.toString(value[2][2], 'f', 2),
loc.toString(value[2][3], 'f', 2),
loc.toString(value[3][0], 'f', 2),
loc.toString(value[3][1], 'f', 2),
loc.toString(value[3][2], 'f', 2),
loc.toString(value[3][3], 'f', 2));
le->setText(text);
}
QVariant PropertyMatrixItem::editorData(QWidget *editor) const
{
QLineEdit *le = qobject_cast<QLineEdit*>(editor);
return QVariant(le->text());
}
double PropertyMatrixItem::getA11() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[0][0];
}
void PropertyMatrixItem::setA11(double A11)
{
setData(QVariant::fromValue(Base::Matrix4D(A11,getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA12() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[0][1];
}
void PropertyMatrixItem::setA12(double A12)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),A12,getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA13() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[0][2];
}
void PropertyMatrixItem::setA13(double A13)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),A13,getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA14() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[0][3];
}
void PropertyMatrixItem::setA14(double A14)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),A14,getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA21() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[1][0];
}
void PropertyMatrixItem::setA21(double A21)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),A21,getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA22() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[1][1];
}
void PropertyMatrixItem::setA22(double A22)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),A22,getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA23() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[1][2];
}
void PropertyMatrixItem::setA23(double A23)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),A23,getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA24() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[1][3];
}
void PropertyMatrixItem::setA24(double A24)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),A24,getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA31() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[2][0];
}
void PropertyMatrixItem::setA31(double A31)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),A31,getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA32() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[2][1];
}
void PropertyMatrixItem::setA32(double A32)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),A32,getA33(),getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA33() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[2][2];
}
void PropertyMatrixItem::setA33(double A33)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),A33,getA34(),getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA34() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[2][3];
}
void PropertyMatrixItem::setA34(double A34)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),A34,getA41(),getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA41() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[3][0];
}
void PropertyMatrixItem::setA41(double A41)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),A41,getA42(),getA43(),getA44() )));
}
double PropertyMatrixItem::getA42() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[3][1];
}
void PropertyMatrixItem::setA42(double A42)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),A42,getA43(),getA44() )));
}
double PropertyMatrixItem::getA43() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[3][2];
}
void PropertyMatrixItem::setA43(double A43)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),A43,getA44() )));
}
double PropertyMatrixItem::getA44() const
{
return data(1,Qt::EditRole).value<Base::Matrix4D>()[3][3];
}
void PropertyMatrixItem::setA44(double A44)
{
setData(QVariant::fromValue(Base::Matrix4D(getA11(),getA12(),getA13(),getA14(),getA21(),getA22(),getA23(),getA24(),getA31(),getA32(),getA33(),getA34(),getA41(),getA42(),getA43(),A44 )));
}
// ---------------------------------------------------------------
RotationHelper::RotationHelper()
: init_axis(false)
, changed_value(false)
, rot_angle(0)
, rot_axis(0,0,1)
{
}
void RotationHelper::setChanged(bool value)
{
changed_value = value;
}
bool RotationHelper::hasChangedAndReset()
{
if (!changed_value)
return false;
changed_value = false;
return true;
}
bool RotationHelper::isAxisInitialized() const
{
return init_axis;
}
void RotationHelper::setValue(const Base::Vector3d& axis, double angle)
{
rot_axis = axis;
rot_angle = angle;
init_axis = true;
}
void RotationHelper::getValue(Base::Vector3d& axis, double& angle) const
{
axis = rot_axis;
angle = rot_angle;
}
double RotationHelper::getAngle(const Base::Rotation& val) const
{
double angle;
Base::Vector3d dir;
val.getRawValue(dir, angle);
if (dir * this->rot_axis < 0.0)
angle = -angle;
return angle;
}
Base::Rotation RotationHelper::setAngle(double angle)
{
Base::Rotation rot;
rot.setValue(this->rot_axis, Base::toRadians<double>(angle));
changed_value = true;
rot_angle = angle;
return rot;
}
Base::Vector3d RotationHelper::getAxis() const
{
// We must store the rotation axis in a member because
// if we read the value from the property we would always
// get a normalized vector which makes it quite unhandy
// to work with
return this->rot_axis;
}
Base::Rotation RotationHelper::setAxis(const Base::Rotation& value, const Base::Vector3d& axis)
{
this->rot_axis = axis;
Base::Rotation rot = value;
Base::Vector3d dummy; double angle;
rot.getValue(dummy, angle);
if (dummy * axis < 0.0)
angle = -angle;
rot.setValue(axis, angle);
changed_value = true;
return rot;
}
void RotationHelper::assignProperty(const Base::Rotation& value, double eps)
{
double angle;
Base::Vector3d dir;
value.getRawValue(dir, angle);
Base::Vector3d cross = this->rot_axis.Cross(dir);
double len2 = cross.Sqr();
if (angle != 0) {
// vectors are not parallel
if (len2 > eps)
this->rot_axis = dir;
// vectors point into opposite directions
else if (this->rot_axis.Dot(dir) < 0)
this->rot_axis = -this->rot_axis;
}
this->rot_angle = Base::toDegrees(angle);
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyRotationItem)
PropertyRotationItem::PropertyRotationItem()
{
m_a = static_cast<PropertyUnitItem*>(PropertyUnitItem::create());
m_a->setParent(this);
m_a->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Angle")));
this->appendChild(m_a);
m_d = static_cast<PropertyVectorItem*>(PropertyVectorItem::create());
m_d->setParent(this);
m_d->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Axis")));
m_d->setReadOnly(true);
this->appendChild(m_d);
}
PropertyRotationItem::~PropertyRotationItem()
{
}
Base::Quantity PropertyRotationItem::getAngle() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Rotation>())
return Base::Quantity(0.0);
const Base::Rotation& val = value.value<Base::Rotation>();
double angle = h.getAngle(val);
return Base::Quantity(Base::toDegrees<double>(angle), Base::Unit::Angle);
}
void PropertyRotationItem::setAngle(Base::Quantity angle)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Rotation>())
return;
Base::Rotation rot = h.setAngle(angle.getValue());
setValue(QVariant::fromValue(rot));
}
Base::Vector3d PropertyRotationItem::getAxis() const
{
return h.getAxis();
}
void PropertyRotationItem::setAxis(const Base::Vector3d& axis)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Rotation>())
return;
Base::Rotation rot = value.value<Base::Rotation>();
rot = h.setAxis(rot, axis);
setValue(QVariant::fromValue(rot));
}
void PropertyRotationItem::assignProperty(const App::Property* prop)
{
// Choose an adaptive epsilon to avoid changing the axis when they are considered to
// be equal. See https://forum.freecadweb.org/viewtopic.php?f=10&t=24662&start=10
double eps = std::pow(10.0, -2*(decimals()+1));
if (prop->getTypeId().isDerivedFrom(App::PropertyRotation::getClassTypeId())) {
const Base::Rotation& value = static_cast<const App::PropertyRotation*>(prop)->getValue();
h.assignProperty(value, eps);
}
}
QVariant PropertyRotationItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyRotation::getClassTypeId()));
const Base::Rotation& value = static_cast<const App::PropertyRotation*>(prop)->getValue();
double angle;
Base::Vector3d dir;
value.getRawValue(dir, angle);
if (!h.isAxisInitialized()) {
if (m_a->hasExpression()) {
QString str = m_a->expressionAsString();
angle = str.toDouble();
}
else {
angle = Base::toDegrees(angle);
}
PropertyItem* x = m_d->child(0);
PropertyItem* y = m_d->child(1);
PropertyItem* z = m_d->child(2);
if (x->hasExpression()) {
QString str = x->expressionAsString();
dir.x = str.toDouble();
}
if (y->hasExpression()) {
QString str = y->expressionAsString();
dir.y = str.toDouble();
}
if (z->hasExpression()) {
QString str = z->expressionAsString();
dir.z = str.toDouble();
}
h.setValue(dir, angle);
}
return QVariant::fromValue<Base::Rotation>(value);
}
QVariant PropertyRotationItem::toolTip(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyRotation::getClassTypeId()));
const Base::Rotation& p = static_cast<const App::PropertyRotation*>(prop)->getValue();
double angle;
Base::Vector3d dir;
p.getRawValue(dir, angle);
angle = Base::toDegrees<double>(angle);
QLocale loc;
QString data = QString::fromUtf8("Axis: (%1 %2 %3)\n"
"Angle: %4")
.arg(loc.toString(dir.x,'f',decimals()),
loc.toString(dir.y,'f',decimals()),
loc.toString(dir.z,'f',decimals()),
Base::Quantity(angle, Base::Unit::Angle).getUserString());
return QVariant(data);
}
QVariant PropertyRotationItem::toString(const QVariant& prop) const
{
const Base::Rotation& p = prop.value<Base::Rotation>();
double angle;
Base::Vector3d dir;
p.getRawValue(dir, angle);
angle = Base::toDegrees<double>(angle);
QLocale loc;
QString data = QString::fromUtf8("[(%1 %2 %3); %4]")
.arg(loc.toString(dir.x,'f',2),
loc.toString(dir.y,'f',2),
loc.toString(dir.z,'f',2),
Base::Quantity(angle, Base::Unit::Angle).getUserString());
return QVariant(data);
}
void PropertyRotationItem::setValue(const QVariant& value)
{
if (!value.canConvert<Base::Rotation>())
return;
// Accept this only if the user changed the axis, angle or position but
// not if >this< item loses focus
if (!h.hasChangedAndReset())
return;
Base::Vector3d axis;
double angle;
h.getValue(axis, angle);
Base::QuantityFormat format(Base::QuantityFormat::Fixed, decimals());
QString data = QString::fromLatin1("App.Rotation(App.Vector(%1,%2,%3),%4)")
.arg(Base::UnitsApi::toNumber(axis.x, format))
.arg(Base::UnitsApi::toNumber(axis.y, format))
.arg(Base::UnitsApi::toNumber(axis.z, format))
.arg(Base::UnitsApi::toNumber(angle, format));
setPropertyValue(data);
}
QWidget* PropertyRotationItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Q_UNUSED(parent)
Q_UNUSED(receiver)
Q_UNUSED(method)
return nullptr;
}
void PropertyRotationItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Q_UNUSED(editor)
Q_UNUSED(data)
}
QVariant PropertyRotationItem::editorData(QWidget *editor) const
{
Q_UNUSED(editor)
return QVariant();
}
void PropertyRotationItem::propertyBound()
{
if (isBound()) {
m_a->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Rotation")
<<App::ObjectIdentifier::String("Angle"));
m_d->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Rotation")
<<App::ObjectIdentifier::String("Axis"));
}
}
// --------------------------------------------------------------------
PlacementEditor::PlacementEditor(const QString& name, QWidget * parent)
: LabelButton(parent), _task(nullptr)
{
propertyname = name;
propertyname.replace(QLatin1String(" "), QLatin1String(""));
}
PlacementEditor::~PlacementEditor()
{
}
void PlacementEditor::browse()
{
Gui::TaskView::TaskDialog* dlg = Gui::Control().activeDialog();
Gui::Dialog::TaskPlacement* task;
task = qobject_cast<Gui::Dialog::TaskPlacement*>(dlg);
if (dlg && !task) {
// there is already another task dialog which must be closed first
Gui::Control().showDialog(dlg);
return;
}
if (!task) {
task = new Gui::Dialog::TaskPlacement();
}
if (!_task) {
_task = task;
connect(task, SIGNAL(placementChanged(const QVariant &, bool, bool)),
this, SLOT(updateValue(const QVariant&, bool, bool)));
}
task->setPlacement(value().value<Base::Placement>());
task->setPropertyName(propertyname);
task->bindObject();
Gui::Control().showDialog(task);
}
void PlacementEditor::showValue(const QVariant& d)
{
const Base::Placement& p = d.value<Base::Placement>();
double angle;
Base::Vector3d dir, pos;
p.getRotation().getRawValue(dir, angle);
angle = Base::toDegrees<double>(angle);
pos = p.getPosition();
QLocale loc;
QString data = QString::fromUtf8("[(%1 %2 %3);%4 \xc2\xb0;(%5 %6 %7)]")
.arg(loc.toString(dir.x,'f',2),
loc.toString(dir.y,'f',2),
loc.toString(dir.z,'f',2),
loc.toString(angle,'f',2),
loc.toString(pos.x,'f',2),
loc.toString(pos.y,'f',2),
loc.toString(pos.z,'f',2));
getLabel()->setText(data);
}
void PlacementEditor::updateValue(const QVariant& v, bool incr, bool data)
{
if (data) {
if (incr) {
QVariant u = value();
const Base::Placement& plm = u.value<Base::Placement>();
const Base::Placement& rel = v.value<Base::Placement>();
Base::Placement newp = rel * plm;
setValue(QVariant::fromValue<Base::Placement>(newp));
}
else {
setValue(v);
}
}
}
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyPlacementItem)
PropertyPlacementItem::PropertyPlacementItem()
{
m_a = static_cast<PropertyUnitItem*>(PropertyUnitItem::create());
m_a->setParent(this);
m_a->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Angle")));
this->appendChild(m_a);
m_d = static_cast<PropertyVectorItem*>(PropertyVectorItem::create());
m_d->setParent(this);
m_d->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Axis")));
m_d->setReadOnly(true);
this->appendChild(m_d);
m_p = static_cast<PropertyVectorDistanceItem*>(PropertyVectorDistanceItem::create());
m_p->setParent(this);
m_p->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Position")));
m_p->setReadOnly(true);
this->appendChild(m_p);
}
PropertyPlacementItem::~PropertyPlacementItem()
{
}
Base::Quantity PropertyPlacementItem::getAngle() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Placement>())
return Base::Quantity(0.0);
const Base::Placement& val = value.value<Base::Placement>();
double angle = h.getAngle(val.getRotation());
return Base::Quantity(Base::toDegrees<double>(angle), Base::Unit::Angle);
}
void PropertyPlacementItem::setAngle(Base::Quantity angle)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Placement>())
return;
Base::Placement val = value.value<Base::Placement>();
Base::Rotation rot = h.setAngle(angle.getValue());
val.setRotation(rot);
setValue(QVariant::fromValue(val));
}
Base::Vector3d PropertyPlacementItem::getAxis() const
{
return h.getAxis();
}
void PropertyPlacementItem::setAxis(const Base::Vector3d& axis)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Placement>())
return;
Base::Placement val = value.value<Base::Placement>();
Base::Rotation rot = val.getRotation();
rot = h.setAxis(rot, axis);
val.setRotation(rot);
setValue(QVariant::fromValue(val));
}
Base::Vector3d PropertyPlacementItem::getPosition() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Placement>())
return Base::Vector3d(0,0,0);
const Base::Placement& val = value.value<Base::Placement>();
return val.getPosition();
}
void PropertyPlacementItem::setPosition(const Base::Vector3d& pos)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Base::Placement>())
return;
Base::Placement val = value.value<Base::Placement>();
val.setPosition(pos);
h.setChanged(true);
setValue(QVariant::fromValue(val));
}
void PropertyPlacementItem::assignProperty(const App::Property* prop)
{
// Choose an adaptive epsilon to avoid changing the axis when they are considered to
// be equal. See https://forum.freecadweb.org/viewtopic.php?f=10&t=24662&start=10
double eps = std::pow(10.0, -2*(decimals()+1));
if (prop->getTypeId().isDerivedFrom(App::PropertyPlacement::getClassTypeId())) {
const Base::Placement& value = static_cast<const App::PropertyPlacement*>(prop)->getValue();
h.assignProperty(value.getRotation(), eps);
}
}
QVariant PropertyPlacementItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyPlacement::getClassTypeId()));
const Base::Placement& value = static_cast<const App::PropertyPlacement*>(prop)->getValue();
double angle;
Base::Vector3d dir;
value.getRotation().getRawValue(dir, angle);
if (!h.isAxisInitialized()) {
if (m_a->hasExpression()) {
QString str = m_a->expressionAsString();
angle = str.toDouble();
}
else {
angle = Base::toDegrees(angle);
}
PropertyItem* x = m_d->child(0);
PropertyItem* y = m_d->child(1);
PropertyItem* z = m_d->child(2);
if (x->hasExpression()) {
QString str = x->expressionAsString();
dir.x = str.toDouble();
}
if (y->hasExpression()) {
QString str = y->expressionAsString();
dir.y = str.toDouble();
}
if (z->hasExpression()) {
QString str = z->expressionAsString();
dir.z = str.toDouble();
}
h.setValue(dir, angle);
}
return QVariant::fromValue<Base::Placement>(value);
}
QVariant PropertyPlacementItem::toolTip(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyPlacement::getClassTypeId()));
const Base::Placement& p = static_cast<const App::PropertyPlacement*>(prop)->getValue();
double angle;
Base::Vector3d dir, pos;
p.getRotation().getRawValue(dir, angle);
angle = Base::toDegrees<double>(angle);
pos = p.getPosition();
QLocale loc;
QString data = QString::fromUtf8("Axis: (%1 %2 %3)\n"
"Angle: %4\n"
"Position: (%5 %6 %7)")
.arg(loc.toString(dir.x,'f',decimals()),
loc.toString(dir.y,'f',decimals()),
loc.toString(dir.z,'f',decimals()),
Base::Quantity(angle, Base::Unit::Angle).getUserString(),
Base::Quantity(pos.x, Base::Unit::Length).getUserString(),
Base::Quantity(pos.y, Base::Unit::Length).getUserString(),
Base::Quantity(pos.z, Base::Unit::Length).getUserString());
return QVariant(data);
}
QVariant PropertyPlacementItem::toString(const QVariant& prop) const
{
const Base::Placement& p = prop.value<Base::Placement>();
double angle;
Base::Vector3d dir, pos;
p.getRotation().getRawValue(dir, angle);
angle = Base::toDegrees<double>(angle);
pos = p.getPosition();
QLocale loc;
QString data = QString::fromUtf8("[(%1 %2 %3); %4; (%5 %6 %7)]")
.arg(loc.toString(dir.x,'f',2),
loc.toString(dir.y,'f',2),
loc.toString(dir.z,'f',2),
Base::Quantity(angle, Base::Unit::Angle).getUserString(),
Base::Quantity(pos.x, Base::Unit::Length).getUserString(),
Base::Quantity(pos.y, Base::Unit::Length).getUserString(),
Base::Quantity(pos.z, Base::Unit::Length).getUserString());
return QVariant(data);
}
void PropertyPlacementItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<Base::Placement>())
return;
// Accept this only if the user changed the axis, angle or position but
// not if >this< item loses focus
if (!h.hasChangedAndReset())
return;
const Base::Placement& val = value.value<Base::Placement>();
Base::Vector3d pos = val.getPosition();
Base::Vector3d axis;
double angle;
h.getValue(axis, angle);
Base::QuantityFormat format(Base::QuantityFormat::Fixed, decimals());
QString data = QString::fromLatin1("App.Placement("
"App.Vector(%1,%2,%3),"
"App.Rotation(App.Vector(%4,%5,%6),%7))")
.arg(Base::UnitsApi::toNumber(pos.x, format))
.arg(Base::UnitsApi::toNumber(pos.y, format))
.arg(Base::UnitsApi::toNumber(pos.z, format))
.arg(Base::UnitsApi::toNumber(axis.x, format))
.arg(Base::UnitsApi::toNumber(axis.y, format))
.arg(Base::UnitsApi::toNumber(axis.z, format))
.arg(Base::UnitsApi::toNumber(angle, format));
setPropertyValue(data);
}
QWidget* PropertyPlacementItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
PlacementEditor *pe = new PlacementEditor(this->propertyName(), parent);
QObject::connect(pe, SIGNAL(valueChanged(const QVariant &)), receiver, method);
pe->setDisabled(isReadOnly());
return pe;
}
void PropertyPlacementItem::setEditorData(QWidget *editor, const QVariant& data) const
{
PlacementEditor *pe = qobject_cast<PlacementEditor*>(editor);
pe->setValue(data);
}
QVariant PropertyPlacementItem::editorData(QWidget *editor) const
{
PlacementEditor *pe = qobject_cast<PlacementEditor*>(editor);
return pe->value();
}
void PropertyPlacementItem::propertyBound()
{
if (isBound()) {
m_a->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Rotation")
<<App::ObjectIdentifier::String("Angle"));
m_d->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Rotation")
<<App::ObjectIdentifier::String("Axis"));
m_p->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Base"));
}
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyEnumItem)
PropertyEnumItem::PropertyEnumItem()
:m_enum(nullptr)
{
if(PropertyView::showAll()) {
m_enum = static_cast<PropertyStringListItem*>(PropertyStringListItem::create());
m_enum->setParent(this);
m_enum->setPropertyName(QLatin1String(QT_TRANSLATE_NOOP("App::Property", "Enum")));
this->appendChild(m_enum);
}
}
void PropertyEnumItem::propertyBound()
{
if (m_enum && isBound())
m_enum->bind(App::ObjectIdentifier(getPath())<<App::ObjectIdentifier::String("Enum"));
}
void PropertyEnumItem::setEnum(QStringList values)
{
setData(values);
}
QStringList PropertyEnumItem::getEnum() const
{
QStringList res;
auto prop = getFirstProperty();
if (prop && prop->getTypeId().isDerivedFrom(App::PropertyEnumeration::getClassTypeId())) {
const App::PropertyEnumeration* prop_enum = static_cast<const App::PropertyEnumeration*>(prop);
for(int i=0; i<prop_enum->getEnum().maxValue(); ++i)
res.push_back(QString::fromUtf8(prop_enum->getEnums()[i]));
}
return res;
}
QVariant PropertyEnumItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyEnumeration::getClassTypeId()));
const App::PropertyEnumeration* prop_enum = static_cast<const App::PropertyEnumeration*>(prop);
if(!prop_enum->isValid())
return QVariant(QString());
return QVariant(QString::fromUtf8(prop_enum->getValueAsString()));
}
void PropertyEnumItem::setValue(const QVariant& value)
{
if (hasExpression())
return;
QString data;
if (value.type() == QVariant::StringList) {
QStringList values = value.toStringList();
QTextStream str(&data);
str << "[";
for (QStringList::Iterator it = values.begin(); it != values.end(); ++it) {
QString text(*it);
text.replace(QString::fromUtf8("'"),QString::fromUtf8("\\'"));
std::string pystr = Base::Tools::escapedUnicodeFromUtf8(text.toUtf8());
pystr = Base::Interpreter().strToPython(pystr.c_str());
str << "u\"" << pystr.c_str() << "\", ";
}
str << "]";
}
else if (value.canConvert(QVariant::String)) {
QByteArray val = value.toString().toUtf8();
std::string str = Base::Tools::escapedUnicodeFromUtf8(val);
data = QString::fromLatin1("u\"%1\"").arg(QString::fromStdString(str));
}
else
return;
setPropertyValue(data);
}
namespace {
class EnumItems;
struct EnumItem {
QString text;
QString fullText;
std::shared_ptr<EnumItems> children;
EnumItem(const QString &t = QString(), const QString &f = QString())
:text(t), fullText(f)
{}
void populate(QMenu *menu);
};
class EnumItems : public std::vector<EnumItem>
{
};
void EnumItem::populate(QMenu *menu)
{
if (!children || children->empty()) {
auto action = menu->addAction(text);
action->setData(fullText);
return;
}
auto subMenu = menu->addMenu(text);
for (auto &item : *children)
item.populate(subMenu);
}
} // anonymous namespace
QWidget* PropertyEnumItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
const std::vector<App::Property*>& items = getPropertyData();
QStringList commonModes, modes;
for (std::vector<App::Property*>::const_iterator it = items.begin(); it != items.end(); ++it) {
if ((*it)->getTypeId() == App::PropertyEnumeration::getClassTypeId()) {
App::PropertyEnumeration* prop = static_cast<App::PropertyEnumeration*>(*it);
if (prop->getEnums() == nullptr) {
commonModes.clear();
return nullptr;
}
const std::vector<std::string>& value = prop->getEnumVector();
if (it == items.begin()) {
for (std::vector<std::string>::const_iterator jt = value.begin(); jt != value.end(); ++jt)
commonModes << QString::fromUtf8(jt->c_str());
}
else {
for (std::vector<std::string>::const_iterator jt = value.begin(); jt != value.end(); ++jt) {
if (commonModes.contains(QString::fromUtf8(jt->c_str())))
modes << QString::fromUtf8(jt->c_str());
}
commonModes = modes;
modes.clear();
}
}
}
if (commonModes.isEmpty())
return nullptr;
int index = -1;
std::shared_ptr<EnumItems> enumItems;
for (auto &mode : commonModes) {
++index;
auto fields = mode.split(QStringLiteral("|"));
if (!enumItems && fields.size() <= 1)
continue;
if (!enumItems) {
enumItems = std::make_shared<EnumItems>();
for (int i=0; i<index; ++i)
enumItems->emplace_back(commonModes[i], mode);
}
auto children = enumItems;
int j = -1;
for (auto &field : fields) {
++j;
field = field.trimmed();
auto it = children->end();
if (field.isEmpty()) {
if (!children->empty())
--it;
else
continue;
} else {
it = std::find_if(children->begin(), children->end(),
[&field](const EnumItem &item) {
return item.text == field;
});
if (it == children->end())
it = children->emplace(children->end(), field, mode);
}
if (j + 1 == (int)fields.size())
break;
if (!it->children)
it->children = std::make_shared<EnumItems>();
children = it->children;
}
}
if (!enumItems) {
QComboBox *cb = new QComboBox(parent);
cb->setFrame(false);
cb->setDisabled(isReadOnly());
cb->addItems(commonModes);
QObject::connect(cb, SIGNAL(activated(int)), receiver, method);
return cb;
}
auto button = new PropertyEnumButton(parent);
button->setDisabled(isReadOnly());
QMenu *menu = new QMenu(button);
for (auto &item : *enumItems)
item.populate(menu);
button->setMenu(menu);
QObject::connect(menu, &QMenu::aboutToShow, this, [=]() {
menu->setMinimumWidth(button->width());
});
QObject::connect(menu, &QMenu::triggered, this, [=](QAction *action) {
button->setText(action->data().toString());
button->picked();
});
QObject::connect(button, SIGNAL(picked()), receiver, method);
return button;
}
void PropertyEnumItem::setEditorData(QWidget *editor, const QVariant& data) const
{
if (auto cb = qobject_cast<QComboBox*>(editor)) {
cb->setEditable(false);
cb->setCurrentIndex(cb->findText(data.toString()));
}
else if (auto btn = qobject_cast<QPushButton*>(editor))
btn->setText(data.toString());
}
QVariant PropertyEnumItem::editorData(QWidget *editor) const
{
if (auto cb = qobject_cast<QComboBox*>(editor))
return QVariant(cb->currentText());
else if (auto btn = qobject_cast<QPushButton*>(editor))
return btn->text();
return QVariant();
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyStringListItem)
PropertyStringListItem::PropertyStringListItem()
{
}
QWidget* PropertyStringListItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::LabelEditor* le = new Gui::LabelEditor(parent);
le->setAutoFillBackground(true);
le->setDisabled(isReadOnly());
QObject::connect(le, SIGNAL(textChanged(const QString&)), receiver, method);
return le;
}
void PropertyStringListItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QStringList list = data.toStringList();
le->setText(list.join(QChar::fromLatin1('\n')));
}
QVariant PropertyStringListItem::editorData(QWidget *editor) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QString complete = le->text();
QStringList list = complete.split(QChar::fromLatin1('\n'));
return QVariant(list);
}
QVariant PropertyStringListItem::toString(const QVariant& prop) const
{
QStringList list = prop.toStringList();
if (list.size() > 10) {
list = list.mid(0, 10);
list.append(QLatin1String("..."));
}
QString text = QString::fromUtf8("[%1]").arg(list.join(QLatin1String(",")));
return QVariant(text);
}
QVariant PropertyStringListItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyStringList::getClassTypeId()));
QStringList list;
const std::vector<std::string>& value = (static_cast<const App::PropertyStringList*>(prop))->getValues();
for ( std::vector<std::string>::const_iterator jt = value.begin(); jt != value.end(); ++jt ) {
list << QString::fromUtf8((*jt).c_str());
}
return QVariant(list);
}
void PropertyStringListItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::StringList))
return;
QStringList values = value.toStringList();
QString data;
QTextStream str(&data);
str.setCodec("UTF-8");
str << "[";
for (QStringList::Iterator it = values.begin(); it != values.end(); ++it) {
QString text(*it);
std::string pystr = Base::Interpreter().strToPython(text.toUtf8().constData());
str << "\"" << QString::fromUtf8(pystr.c_str()) << "\", ";
}
str << "]";
setPropertyValue(data);
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyFloatListItem)
PropertyFloatListItem::PropertyFloatListItem()
{
}
QWidget* PropertyFloatListItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::LabelEditor* le = new Gui::LabelEditor(parent);
le->setAutoFillBackground(true);
le->setInputType(Gui::LabelEditor::Float);
le->setDisabled(isReadOnly());
QObject::connect(le, SIGNAL(textChanged(const QString&)), receiver, method);
return le;
}
void PropertyFloatListItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QStringList list = data.toStringList();
le->setText(list.join(QChar::fromLatin1('\n')));
}
QVariant PropertyFloatListItem::editorData(QWidget *editor) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QString complete = le->text();
QStringList list = complete.split(QChar::fromLatin1('\n'));
return QVariant(list);
}
QVariant PropertyFloatListItem::toString(const QVariant& prop) const
{
QStringList list = prop.toStringList();
if (list.size() > 10) {
list = list.mid(0, 10);
list.append(QLatin1String("..."));
}
QString text = QString::fromUtf8("[%1]").arg(list.join(QLatin1String(",")));
return QVariant(text);
}
QVariant PropertyFloatListItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFloatList::getClassTypeId()));
QStringList list;
const std::vector<double>& value = static_cast<const App::PropertyFloatList*>(prop)->getValues();
for (std::vector<double>::const_iterator jt = value.begin(); jt != value.end(); ++jt) {
list << QString::number(*jt, 'f', decimals());
}
return QVariant(list);
}
void PropertyFloatListItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::StringList))
return;
QStringList values = value.toStringList();
QString data;
QTextStream str(&data);
str << "[";
for (QStringList::Iterator it = values.begin(); it != values.end(); ++it) {
str << *it << ",";
}
str << "]";
if (data == QString::fromUtf8("[,]"))
data = QString::fromUtf8("[]");
setPropertyValue(data);
}
// ---------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyIntegerListItem)
PropertyIntegerListItem::PropertyIntegerListItem()
{
}
QWidget* PropertyIntegerListItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::LabelEditor* le = new Gui::LabelEditor(parent);
le->setAutoFillBackground(true);
le->setInputType(Gui::LabelEditor::Integer);
le->setDisabled(isReadOnly());
QObject::connect(le, SIGNAL(textChanged(const QString&)), receiver, method);
return le;
}
void PropertyIntegerListItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QStringList list = data.toStringList();
le->setText(list.join(QChar::fromLatin1('\n')));
}
QVariant PropertyIntegerListItem::editorData(QWidget *editor) const
{
Gui::LabelEditor *le = qobject_cast<Gui::LabelEditor*>(editor);
QString complete = le->text();
QStringList list = complete.split(QChar::fromLatin1('\n'));
return QVariant(list);
}
QVariant PropertyIntegerListItem::toString(const QVariant& prop) const
{
QStringList list = prop.toStringList();
if (list.size() > 10) {
list = list.mid(0, 10);
list.append(QLatin1String("..."));
}
QString text = QString::fromUtf8("[%1]").arg(list.join(QLatin1String(",")));
return QVariant(text);
}
QVariant PropertyIntegerListItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyIntegerList::getClassTypeId()));
QStringList list;
const std::vector<long>& value = static_cast<const App::PropertyIntegerList*>(prop)->getValues();
for (std::vector<long>::const_iterator jt = value.begin(); jt != value.end(); ++jt) {
list << QString::number(*jt);
}
return QVariant(list);
}
void PropertyIntegerListItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::StringList))
return;
QStringList values = value.toStringList();
QString data;
QTextStream str(&data);
str << "[";
for (QStringList::Iterator it = values.begin(); it != values.end(); ++it) {
str << *it << ",";
}
str << "]";
if (data == QString::fromUtf8("[,]"))
data = QString::fromUtf8("[]");
setPropertyValue(data);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyColorItem)
PropertyColorItem::PropertyColorItem()
{
}
QVariant PropertyColorItem::decoration(const QVariant& value) const
{
QColor color = value.value<QColor>();
int size = QApplication::style()->pixelMetric(QStyle::PM_ListViewIconSize);
QPixmap p(size, size);
p.fill(color);
return QVariant(p);
}
QVariant PropertyColorItem::toString(const QVariant& prop) const
{
QColor value = prop.value<QColor>();
QString color = QString::fromLatin1("[%1, %2, %3]")
.arg(value.red()).arg(value.green()).arg(value.blue());
return QVariant(color);
}
QVariant PropertyColorItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyColor::getClassTypeId()));
App::Color value = ((App::PropertyColor*)prop)->getValue();
return QVariant(value.asValue<QColor>());
}
void PropertyColorItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<QColor>())
return;
QColor col = value.value<QColor>();
App::Color val; val.setValue<QColor>(col);
QString data = QString::fromLatin1("(%1,%2,%3)")
.arg(val.r,0,'f',decimals())
.arg(val.g,0,'f',decimals())
.arg(val.b,0,'f',decimals());
setPropertyValue(data);
}
QWidget* PropertyColorItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::ColorButton* cb = new Gui::ColorButton( parent );
cb->setDisabled(isReadOnly());
QObject::connect(cb, SIGNAL(changed()), receiver, method);
return cb;
}
void PropertyColorItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
QColor color = data.value<QColor>();
cb->setColor(color);
}
QVariant PropertyColorItem::editorData(QWidget *editor) const
{
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
QVariant var;
var.setValue(cb->color());
return var;
}
// --------------------------------------------------------------------
namespace Gui { namespace PropertyEditor {
class Material
{
public:
QColor diffuseColor;
QColor ambientColor;
QColor specularColor;
QColor emissiveColor;
float shininess;
float transparency;
};
}
}
Q_DECLARE_METATYPE(Gui::PropertyEditor::Material)
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyMaterialItem)
PropertyMaterialItem::PropertyMaterialItem()
{
diffuse = static_cast<PropertyColorItem*>(PropertyColorItem::create());
diffuse->setParent(this);
diffuse->setPropertyName(QLatin1String("DiffuseColor"));
this->appendChild(diffuse);
ambient = static_cast<PropertyColorItem*>(PropertyColorItem::create());
ambient->setParent(this);
ambient->setPropertyName(QLatin1String("AmbientColor"));
this->appendChild(ambient);
specular = static_cast<PropertyColorItem*>(PropertyColorItem::create());
specular->setParent(this);
specular->setPropertyName(QLatin1String("SpecularColor"));
this->appendChild(specular);
emissive = static_cast<PropertyColorItem*>(PropertyColorItem::create());
emissive->setParent(this);
emissive->setPropertyName(QLatin1String("EmissiveColor"));
this->appendChild(emissive);
shininess = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
shininess->setParent(this);
shininess->setPropertyName(QLatin1String("Shininess"));
this->appendChild(shininess);
transparency = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
transparency->setParent(this);
transparency->setPropertyName(QLatin1String("Transparency"));
this->appendChild(transparency);
}
PropertyMaterialItem::~PropertyMaterialItem()
{
}
void PropertyMaterialItem::propertyBound()
{
}
QColor PropertyMaterialItem::getDiffuseColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return QColor();
Material val = value.value<Material>();
return val.diffuseColor;
}
void PropertyMaterialItem::setDiffuseColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.diffuseColor = color;
setValue(QVariant::fromValue<Material>(mat));
}
QColor PropertyMaterialItem::getAmbientColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return QColor();
Material val = value.value<Material>();
return val.ambientColor;
}
void PropertyMaterialItem::setAmbientColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.ambientColor = color;
setValue(QVariant::fromValue<Material>(mat));
}
QColor PropertyMaterialItem::getSpecularColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return QColor();
Material val = value.value<Material>();
return val.specularColor;
}
void PropertyMaterialItem::setSpecularColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.specularColor = color;
setValue(QVariant::fromValue<Material>(mat));
}
QColor PropertyMaterialItem::getEmissiveColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return QColor();
Material val = value.value<Material>();
return val.emissiveColor;
}
void PropertyMaterialItem::setEmissiveColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.emissiveColor = color;
setValue(QVariant::fromValue<Material>(mat));
}
float PropertyMaterialItem::getShininess() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return 0;
Material val = value.value<Material>();
return val.shininess;
}
void PropertyMaterialItem::setShininess(float s)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.shininess = s;
setValue(QVariant::fromValue<Material>(mat));
}
float PropertyMaterialItem::getTransparency() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return 0;
Material val = value.value<Material>();
return val.transparency;
}
void PropertyMaterialItem::setTransparency(float t)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return;
Material mat = value.value<Material>();
mat.transparency = t;
setValue(QVariant::fromValue<Material>(mat));
}
QVariant PropertyMaterialItem::decoration(const QVariant& value) const
{
// use the diffuse color
Material val = value.value<Material>();
QColor color = val.diffuseColor;
int size = QApplication::style()->pixelMetric(QStyle::PM_ListViewIconSize);
QPixmap p(size, size);
p.fill(color);
return QVariant(p);
}
QVariant PropertyMaterialItem::toString(const QVariant& prop) const
{
// use the diffuse color
Material val = prop.value<Material>();
QColor value = val.diffuseColor;
QString color = QString::fromLatin1("[%1, %2, %3]")
.arg(value.red()).arg(value.green()).arg(value.blue());
return QVariant(color);
}
QVariant PropertyMaterialItem::toolTip(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId()));
const App::Material& value = static_cast<const App::PropertyMaterial*>(prop)->getValue();
QColor dc = value.diffuseColor.asValue<QColor>();
QColor ac = value.ambientColor.asValue<QColor>();
QColor sc = value.specularColor.asValue<QColor>();
QColor ec = value.emissiveColor.asValue<QColor>();
QString data = QString::fromUtf8(
"Diffuse color: [%1, %2, %3]\n"
"Ambient color: [%4, %5, %6]\n"
"Specular color: [%7, %8, %9]\n"
"Emissive color: [%10, %11, %12]\n"
"Shininess: %13\n"
"Transparency: %14"
)
.arg(dc.red()).arg(dc.green()).arg(dc.blue())
.arg(ac.red()).arg(ac.green()).arg(ac.blue())
.arg(sc.red()).arg(sc.green()).arg(sc.blue())
.arg(ec.red()).arg(ec.green()).arg(ec.blue())
.arg(value.shininess)
.arg(value.transparency)
;
return QVariant(data);
}
QVariant PropertyMaterialItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterial::getClassTypeId()));
const App::Material& value = static_cast<const App::PropertyMaterial*>(prop)->getValue();
Material mat;
mat.diffuseColor = value.diffuseColor.asValue<QColor>();
mat.ambientColor = value.ambientColor.asValue<QColor>();
mat.specularColor = value.specularColor.asValue<QColor>();
mat.emissiveColor = value.emissiveColor.asValue<QColor>();
mat.shininess = value.shininess;
mat.transparency = value.transparency;
return QVariant::fromValue<Material>(mat);
}
void PropertyMaterialItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<Material>())
return;
Material mat = value.value<Material>();
App::Color dc; dc.setValue<QColor>(mat.diffuseColor);
App::Color ac; ac.setValue<QColor>(mat.ambientColor);
App::Color sc; sc.setValue<QColor>(mat.specularColor);
App::Color ec; ec.setValue<QColor>(mat.emissiveColor);
float s = mat.shininess;
float t = mat.transparency;
QString data = QString::fromLatin1(
"App.Material("
"DiffuseColor=(%1,%2,%3),"
"AmbientColor=(%4,%5,%6),"
"SpecularColor=(%7,%8,%9),"
"EmissiveColor=(%10,%11,%12),"
"Shininess=(%13),"
"Transparency=(%14),"
")"
)
.arg(dc.r, 0, 'f', decimals())
.arg(dc.g, 0, 'f', decimals())
.arg(dc.b, 0, 'f', decimals())
.arg(ac.r, 0, 'f', decimals())
.arg(ac.g, 0, 'f', decimals())
.arg(ac.b, 0, 'f', decimals())
.arg(sc.r, 0, 'f', decimals())
.arg(sc.g, 0, 'f', decimals())
.arg(sc.b, 0, 'f', decimals())
.arg(ec.r, 0, 'f', decimals())
.arg(ec.g, 0, 'f', decimals())
.arg(ec.b, 0, 'f', decimals())
.arg(s, 0, 'f', decimals())
.arg(t, 0, 'f', decimals())
;
setPropertyValue(data);
}
QWidget* PropertyMaterialItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::ColorButton* cb = new Gui::ColorButton(parent);
cb->setDisabled(isReadOnly());
QObject::connect(cb, SIGNAL(changed()), receiver, method);
return cb;
}
void PropertyMaterialItem::setEditorData(QWidget *editor, const QVariant& data) const
{
if (!data.canConvert<Material>())
return;
Material val = data.value<Material>();
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
cb->setColor(val.diffuseColor);
}
QVariant PropertyMaterialItem::editorData(QWidget *editor) const
{
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<Material>())
return QVariant();
Material val = value.value<Material>();
val.diffuseColor = cb->color();
return QVariant::fromValue<Material>(val);
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyMaterialListItem)
PropertyMaterialListItem::PropertyMaterialListItem()
{
// This editor gets a list of materials but it only edits the first item.
diffuse = static_cast<PropertyColorItem*>(PropertyColorItem::create());
diffuse->setParent(this);
diffuse->setPropertyName(QLatin1String("DiffuseColor"));
this->appendChild(diffuse);
ambient = static_cast<PropertyColorItem*>(PropertyColorItem::create());
ambient->setParent(this);
ambient->setPropertyName(QLatin1String("AmbientColor"));
this->appendChild(ambient);
specular = static_cast<PropertyColorItem*>(PropertyColorItem::create());
specular->setParent(this);
specular->setPropertyName(QLatin1String("SpecularColor"));
this->appendChild(specular);
emissive = static_cast<PropertyColorItem*>(PropertyColorItem::create());
emissive->setParent(this);
emissive->setPropertyName(QLatin1String("EmissiveColor"));
this->appendChild(emissive);
shininess = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
shininess->setParent(this);
shininess->setPropertyName(QLatin1String("Shininess"));
this->appendChild(shininess);
transparency = static_cast<PropertyFloatItem*>(PropertyFloatItem::create());
transparency->setParent(this);
transparency->setPropertyName(QLatin1String("Transparency"));
this->appendChild(transparency);
}
PropertyMaterialListItem::~PropertyMaterialListItem()
{
}
void PropertyMaterialListItem::propertyBound()
{
}
QColor PropertyMaterialListItem::getDiffuseColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return QColor();
QVariantList list = value.toList();
if (list.isEmpty())
return QColor();
if (!list[0].canConvert<Material>())
return QColor();
Material mat = list[0].value<Material>();
return mat.diffuseColor;
}
void PropertyMaterialListItem::setDiffuseColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.diffuseColor = color;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
QColor PropertyMaterialListItem::getAmbientColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return QColor();
QVariantList list = value.toList();
if (list.isEmpty())
return QColor();
if (!list[0].canConvert<Material>())
return QColor();
Material mat = list[0].value<Material>();
return mat.ambientColor;
}
void PropertyMaterialListItem::setAmbientColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.ambientColor = color;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
QColor PropertyMaterialListItem::getSpecularColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return QColor();
QVariantList list = value.toList();
if (list.isEmpty())
return QColor();
if (!list[0].canConvert<Material>())
return QColor();
Material mat = list[0].value<Material>();
return mat.specularColor;
}
void PropertyMaterialListItem::setSpecularColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.specularColor = color;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
QColor PropertyMaterialListItem::getEmissiveColor() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return QColor();
QVariantList list = value.toList();
if (list.isEmpty())
return QColor();
if (!list[0].canConvert<Material>())
return QColor();
Material mat = list[0].value<Material>();
return mat.emissiveColor;
}
void PropertyMaterialListItem::setEmissiveColor(const QColor& color)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.emissiveColor = color;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
float PropertyMaterialListItem::getShininess() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return 0;
QVariantList list = value.toList();
if (list.isEmpty())
return 0;
if (!list[0].canConvert<Material>())
return 0;
Material mat = list[0].value<Material>();
return mat.shininess;
}
void PropertyMaterialListItem::setShininess(float s)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.shininess = s;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
float PropertyMaterialListItem::getTransparency() const
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return 0;
QVariantList list = value.toList();
if (list.isEmpty())
return 0;
if (!list[0].canConvert<Material>())
return 0;
Material mat = list[0].value<Material>();
return mat.transparency;
}
void PropertyMaterialListItem::setTransparency(float t)
{
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
Material mat = list[0].value<Material>();
mat.transparency = t;
list[0] = QVariant::fromValue<Material>(mat);
setValue(list);
}
QVariant PropertyMaterialListItem::decoration(const QVariant& value) const
{
if (!value.canConvert<QVariantList>())
return QVariant();
QVariantList list = value.toList();
if (list.isEmpty())
return QVariant();
if (!list[0].canConvert<Material>())
return QVariant();
// use the diffuse color
Material mat = list[0].value<Material>();
QColor color = mat.diffuseColor;
int size = QApplication::style()->pixelMetric(QStyle::PM_ListViewIconSize);
QPixmap p(size, size);
p.fill(color);
return QVariant(p);
}
QVariant PropertyMaterialListItem::toString(const QVariant& prop) const
{
if (!prop.canConvert<QVariantList>())
return QVariant();
QVariantList list = prop.toList();
if (list.isEmpty())
return QVariant();
if (!list[0].canConvert<Material>())
return QVariant();
// use the diffuse color
Material mat = list[0].value<Material>();
QColor value = mat.diffuseColor;
QString color = QString::fromLatin1("[%1, %2, %3]")
.arg(value.red()).arg(value.green()).arg(value.blue());
return QVariant(color);
}
QVariant PropertyMaterialListItem::toolTip(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterialList::getClassTypeId()));
const std::vector<App::Material>& values = static_cast<const App::PropertyMaterialList*>(prop)->getValues();
if (values.empty())
return QVariant();
App::Material value = values.front();
QColor dc = value.diffuseColor.asValue<QColor>();
QColor ac = value.ambientColor.asValue<QColor>();
QColor sc = value.specularColor.asValue<QColor>();
QColor ec = value.emissiveColor.asValue<QColor>();
QString data = QString::fromUtf8(
"Diffuse color: [%1, %2, %3]\n"
"Ambient color: [%4, %5, %6]\n"
"Specular color: [%7, %8, %9]\n"
"Emissive color: [%10, %11, %12]\n"
"Shininess: %13\n"
"Transparency: %14"
)
.arg(dc.red()).arg(dc.green()).arg(dc.blue())
.arg(ac.red()).arg(ac.green()).arg(ac.blue())
.arg(sc.red()).arg(sc.green()).arg(sc.blue())
.arg(ec.red()).arg(ec.green()).arg(ec.blue())
.arg(value.shininess)
.arg(value.transparency)
;
return QVariant(data);
}
QVariant PropertyMaterialListItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyMaterialList::getClassTypeId()));
const std::vector<App::Material>& value = static_cast<const App::PropertyMaterialList*>(prop)->getValues();
QVariantList variantList;
for (std::vector<App::Material>::const_iterator it = value.begin(); it != value.end(); ++it) {
Material mat;
mat.diffuseColor = it->diffuseColor.asValue<QColor>();
mat.ambientColor = it->ambientColor.asValue<QColor>();
mat.specularColor = it->specularColor.asValue<QColor>();
mat.emissiveColor = it->emissiveColor.asValue<QColor>();
mat.shininess = it->shininess;
mat.transparency = it->transparency;
variantList << QVariant::fromValue<Material>(mat);
}
return variantList;
}
void PropertyMaterialListItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert<QVariantList>())
return;
QVariantList list = value.toList();
if (list.isEmpty())
return;
QString data;
QTextStream str(&data);
str << "(";
for (QVariantList::iterator it = list.begin(); it != list.end(); ++it) {
Material mat = it->value<Material>();
App::Color dc; dc.setValue<QColor>(mat.diffuseColor);
App::Color ac; ac.setValue<QColor>(mat.ambientColor);
App::Color sc; sc.setValue<QColor>(mat.specularColor);
App::Color ec; ec.setValue<QColor>(mat.emissiveColor);
float s = mat.shininess;
float t = mat.transparency;
QString item = QString::fromLatin1(
"App.Material("
"DiffuseColor=(%1,%2,%3),"
"AmbientColor=(%4,%5,%6),"
"SpecularColor=(%7,%8,%9),"
"EmissiveColor=(%10,%11,%12),"
"Shininess=(%13),"
"Transparency=(%14),"
")"
)
.arg(dc.r, 0, 'f', decimals())
.arg(dc.g, 0, 'f', decimals())
.arg(dc.b, 0, 'f', decimals())
.arg(ac.r, 0, 'f', decimals())
.arg(ac.g, 0, 'f', decimals())
.arg(ac.b, 0, 'f', decimals())
.arg(sc.r, 0, 'f', decimals())
.arg(sc.g, 0, 'f', decimals())
.arg(sc.b, 0, 'f', decimals())
.arg(ec.r, 0, 'f', decimals())
.arg(ec.g, 0, 'f', decimals())
.arg(ec.b, 0, 'f', decimals())
.arg(s, 0, 'f', decimals())
.arg(t, 0, 'f', decimals())
;
str << item << ", ";
}
str << ")";
setPropertyValue(data);
}
QWidget* PropertyMaterialListItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::ColorButton* cb = new Gui::ColorButton(parent);
cb->setDisabled(isReadOnly());
QObject::connect(cb, SIGNAL(changed()), receiver, method);
return cb;
}
void PropertyMaterialListItem::setEditorData(QWidget *editor, const QVariant& data) const
{
if (!data.canConvert<QVariantList>())
return;
QVariantList list = data.toList();
if (list.isEmpty())
return;
if (!list[0].canConvert<Material>())
return;
// use the diffuse color
Material mat = list[0].value<Material>();
QColor color = mat.diffuseColor;
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
cb->setColor(color);
}
QVariant PropertyMaterialListItem::editorData(QWidget *editor) const
{
Gui::ColorButton *cb = qobject_cast<Gui::ColorButton*>(editor);
QVariant value = data(1, Qt::EditRole);
if (!value.canConvert<QVariantList>())
return QVariant();
QVariantList list = value.toList();
if (list.isEmpty())
return QVariant();
if (!list[0].canConvert<Material>())
return QVariant();
// use the diffuse color
Material mat = list[0].value<Material>();
mat.diffuseColor = cb->color();
list[0] = QVariant::fromValue<Material>(mat);
return list;
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyFileItem)
PropertyFileItem::PropertyFileItem()
{
}
QVariant PropertyFileItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFile::getClassTypeId()));
std::string value = static_cast<const App::PropertyFile*>(prop)->getValue();
return QVariant(QString::fromUtf8(value.c_str()));
}
void PropertyFileItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::String))
return;
QString val = value.toString();
QString data = QString::fromLatin1("\"%1\"").arg(val);
setPropertyValue(data);
}
QVariant PropertyFileItem::toolTip(const App::Property* prop) const
{
return value(prop);
}
QWidget* PropertyFileItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::FileChooser *fc = new Gui::FileChooser(parent);
fc->setAutoFillBackground(true);
fc->setDisabled(isReadOnly());
QObject::connect(fc, SIGNAL(fileNameSelected(const QString&)), receiver, method);
return fc;
}
void PropertyFileItem::setEditorData(QWidget *editor, const QVariant& data) const
{
const App::Property* prop = getFirstProperty();
if (prop) {
const App::PropertyFile* propFile = static_cast<const App::PropertyFile*>(prop);
std::string filter = propFile->getFilter();
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
if (!filter.empty()) {
fc->setFilter(Base::Tools::fromStdString(filter));
}
fc->setFileName(data.toString());
}
}
QVariant PropertyFileItem::editorData(QWidget *editor) const
{
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
return QVariant(fc->fileName());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyPathItem)
PropertyPathItem::PropertyPathItem()
{
}
QVariant PropertyPathItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyPath::getClassTypeId()));
std::string value = static_cast<const App::PropertyPath*>(prop)->getValue().string();
return QVariant(QString::fromUtf8(value.c_str()));
}
void PropertyPathItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::String))
return;
QString val = value.toString();
QString data = QString::fromLatin1("\"%1\"").arg(val);
setPropertyValue(data);
}
QVariant PropertyPathItem::toolTip(const App::Property* prop) const
{
return value(prop);
}
QWidget* PropertyPathItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::FileChooser *fc = new Gui::FileChooser(parent);
fc->setMode(FileChooser::Directory);
fc->setAutoFillBackground(true);
fc->setDisabled(isReadOnly());
QObject::connect(fc, SIGNAL(fileNameSelected(const QString&)), receiver, method);
return fc;
}
void PropertyPathItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
fc->setFileName(data.toString());
}
QVariant PropertyPathItem::editorData(QWidget *editor) const
{
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
return QVariant(fc->fileName());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyTransientFileItem)
PropertyTransientFileItem::PropertyTransientFileItem()
{
}
QVariant PropertyTransientFileItem::value(const App::Property* prop) const
{
assert(prop && prop->getTypeId().isDerivedFrom(App::PropertyFileIncluded::getClassTypeId()));
std::string value = static_cast<const App::PropertyFileIncluded*>(prop)->getValue();
return QVariant(QString::fromUtf8(value.c_str()));
}
void PropertyTransientFileItem::setValue(const QVariant& value)
{
if (hasExpression() || !value.canConvert(QVariant::String))
return;
QString val = value.toString();
QString data = QString::fromLatin1("\"%1\"").arg(val);
setPropertyValue(data);
}
QVariant PropertyTransientFileItem::toolTip(const App::Property* prop) const
{
return value(prop);
}
QWidget* PropertyTransientFileItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
Gui::FileChooser *fc = new Gui::FileChooser(parent);
fc->setAutoFillBackground(true);
fc->setDisabled(isReadOnly());
QObject::connect(fc, SIGNAL(fileNameSelected(const QString&)), receiver, method);
return fc;
}
void PropertyTransientFileItem::setEditorData(QWidget *editor, const QVariant& data) const
{
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
fc->setFileName(data.toString());
}
QVariant PropertyTransientFileItem::editorData(QWidget *editor) const
{
Gui::FileChooser *fc = qobject_cast<Gui::FileChooser*>(editor);
return QVariant(fc->fileName());
}
// ---------------------------------------------------------------
LinkSelection::LinkSelection(const App::SubObjectT &link) : link(link)
{
}
LinkSelection::~LinkSelection()
{
}
void LinkSelection::select()
{
auto sobj = link.getSubObject();
if(!sobj) {
QMessageBox::critical(getMainWindow(), tr("Error"), tr("Object not found"));
return;
}
Gui::Selection().selStackPush();
Gui::Selection().clearSelection();
Gui::Selection().addSelection(link.getDocumentName().c_str(),
link.getObjectName().c_str(),
link.getSubName().c_str());
this->deleteLater();
}
// ---------------------------------------------------------------
LinkLabel::LinkLabel (QWidget * parent, const App::Property *prop)
: QWidget(parent), objProp(prop), dlg(nullptr)
{
QHBoxLayout *layout = new QHBoxLayout(this);
layout->setMargin(0);
layout->setSpacing(1);
label = new QLabel(this);
label->setAutoFillBackground(true);
label->setTextFormat(Qt::RichText);
// Below is necessary for the hytperlink to be clickable without losing focus
label->setTextInteractionFlags(Qt::TextBrowserInteraction);
layout->addWidget(label);
editButton = new QPushButton(QLatin1String("..."), this);
#if defined (Q_OS_MAC)
editButton->setAttribute(Qt::WA_LayoutUsesWidgetRect); // layout size from QMacStyle was not correct
#endif
editButton->setToolTip(tr("Change the linked object"));
layout->addWidget(editButton);
this->setFocusPolicy(Qt::StrongFocus);
this->setFocusProxy(label);
// setLayout(layout);
connect(label, SIGNAL(linkActivated(const QString&)),
this, SLOT(onLinkActivated(const QString&)));
connect(editButton, SIGNAL(clicked()),
this, SLOT(onEditClicked()));
}
LinkLabel::~LinkLabel()
{
}
void LinkLabel::updatePropertyLink()
{
QString text;
auto owner = objProp.getObject();
auto prop = Base::freecad_dynamic_cast<App::PropertyLinkBase>(objProp.getProperty());
link = QVariant();
if(owner && prop) {
auto links = DlgPropertyLink::getLinksFromProperty(prop);
if(links.size() == 1) {
auto &sobj = links.front();
link = QVariant::fromValue(sobj);
QString linkcolor = QApplication::palette().color(QPalette::Link).name();
text = QString::fromLatin1(
"<html><head><style type=\"text/css\">"
"p, li { white-space: pre-wrap; }"
"</style></head><body>"
"<p>"
"<a href=\"%1#%2.%3\"><span style=\" text-decoration: underline; color:%4;\">%5</span></a>"
"</p></body></html>"
)
.arg(QLatin1String(sobj.getDocumentName().c_str()),
QLatin1String(sobj.getObjectName().c_str()),
QString::fromUtf8(sobj.getSubName().c_str()),
linkcolor,
DlgPropertyLink::formatObject(
owner->getDocument(), sobj.getObject(), sobj.getSubName().c_str()));
} else if (links.size()) {
text = DlgPropertyLink::formatLinks(owner->getDocument(), links);
}
}
label->setText(text);
}
QVariant LinkLabel::propertyLink() const
{
return link;
}
void LinkLabel::onLinkActivated (const QString& s)
{
Q_UNUSED(s);
LinkSelection* select = new LinkSelection(qvariant_cast<App::SubObjectT>(link));
QTimer::singleShot(50, select, SLOT(select()));
}
void LinkLabel::onEditClicked ()
{
if(!dlg) {
dlg = new DlgPropertyLink(this);
dlg->init(objProp,true);
connect(dlg, SIGNAL(finished(int)), this, SLOT(onLinkChanged()));
} else
dlg->init(objProp,false);
dlg->show();
}
void LinkLabel::onLinkChanged() {
if(dlg) {
auto links = dlg->currentLinks();
if(links != dlg->originalLinks()) {
link = QVariant::fromValue(links);
/*emit*/ linkChanged(link);
updatePropertyLink();
}
}
}
void LinkLabel::resizeEvent(QResizeEvent* e)
{
editButton->setFixedWidth(e->size().height());
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyLinkItem)
PropertyLinkItem::PropertyLinkItem()
{
}
QVariant PropertyLinkItem::toString(const QVariant& prop) const
{
QString res;
if(propertyItems.size()) {
App::DocumentObjectT owner(propertyItems[0]);
res = DlgPropertyLink::formatLinks(owner.getDocument(),
qvariant_cast<QList<App::SubObjectT> >(prop));
}
return res;
}
QVariant PropertyLinkItem::data(int column, int role) const {
if(propertyItems.size() && column == 1
&& (role == Qt::ForegroundRole || role == Qt::ToolTipRole))
{
auto propLink = Base::freecad_dynamic_cast<const App::PropertyLinkBase>(propertyItems[0]);
if(propLink) {
if(role==Qt::ForegroundRole && propLink->checkRestore()>1)
return QVariant::fromValue(QColor(0xff,0,0));
else if(role == Qt::ToolTipRole) {
auto xlink = Base::freecad_dynamic_cast<const App::PropertyXLink>(propertyItems[0]);
if(xlink) {
const char *filePath = xlink->getFilePath();
if(filePath && filePath[0])
return QVariant::fromValue(QString::fromUtf8(filePath));
}
}
}
}
return PropertyItem::data(column,role);
}
QVariant PropertyLinkItem::value(const App::Property* prop) const
{
auto propLink = Base::freecad_dynamic_cast<App::PropertyLinkBase>(prop);
if(!propLink)
return QVariant();
auto links = DlgPropertyLink::getLinksFromProperty(propLink);
if(links.empty())
return QVariant();
return QVariant::fromValue(links);
}
void PropertyLinkItem::setValue(const QVariant& value)
{
auto links = qvariant_cast<QList<App::SubObjectT> >(value);
setPropertyValue(DlgPropertyLink::linksToPython(links));
}
QWidget* PropertyLinkItem::createEditor(QWidget* parent, const QObject* receiver, const char* method) const
{
if(propertyItems.empty())
return nullptr;
LinkLabel *ll = new LinkLabel(parent, propertyItems.front());
ll->setAutoFillBackground(true);
ll->setDisabled(isReadOnly());
QObject::connect(ll, SIGNAL(linkChanged(const QVariant&)), receiver, method);
return ll;
}
void PropertyLinkItem::setEditorData(QWidget *editor, const QVariant& data) const
{
(void)data;
LinkLabel *ll = static_cast<LinkLabel*>(editor);
return ll->updatePropertyLink();
}
QVariant PropertyLinkItem::editorData(QWidget *editor) const
{
LinkLabel *ll = static_cast<LinkLabel*>(editor);
return ll->propertyLink();
}
// --------------------------------------------------------------------
PROPERTYITEM_SOURCE(Gui::PropertyEditor::PropertyLinkListItem)
PropertyLinkListItem::PropertyLinkListItem()
{
}
PropertyItemEditorFactory::PropertyItemEditorFactory()
{
}
PropertyItemEditorFactory::~PropertyItemEditorFactory()
{
}
QWidget * PropertyItemEditorFactory::createEditor (int /*type*/, QWidget * /*parent*/) const
{
// do not allow to create any editor widgets because we do that in subclasses of PropertyItem
return nullptr;
}
QByteArray PropertyItemEditorFactory::valuePropertyName (int /*type*/) const
{
// do not allow to set properties because we do that in subclasses of PropertyItem
return "";
}
#include "moc_PropertyItem.cpp"
Reference in New Issue View Git Blame Copy Permalink