235 lines
8.4 KiB
C++
235 lines
8.4 KiB
C++
/***************************************************************************
|
|
* Copyright (c) 2015 Stefan Tröger <stefantroeger@gmx.net> *
|
|
* Copyright (c) 2015 Alexander Golubev (Fat-Zer) <fatzer2@gmail.com> *
|
|
* *
|
|
* This file is part of the FreeCAD CAx development system. *
|
|
* *
|
|
* This library is free software; you can redistribute it and/or *
|
|
* modify it under the terms of the GNU Library General Public *
|
|
* License as published by the Free Software Foundation; either *
|
|
* version 2 of the License, or (at your option) any later version. *
|
|
* *
|
|
* This library is distributed in the hope that it will be useful, *
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
|
|
* GNU Library General Public License for more details. *
|
|
* *
|
|
* You should have received a copy of the GNU Library General Public *
|
|
* License along with this library; see the file COPYING.LIB. If not, *
|
|
* write to the Free Software Foundation, Inc., 59 Temple Place, *
|
|
* Suite 330, Boston, MA 02111-1307, USA *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
|
|
#include "PreCompiled.h"
|
|
|
|
#ifndef _PreComp_
|
|
#include <string>
|
|
#endif
|
|
|
|
#include <App/Document.h>
|
|
#include <Base/Exception.h>
|
|
#include <Base/Placement.h>
|
|
|
|
#include "Origin.h"
|
|
#include "OriginFeature.h"
|
|
|
|
|
|
#ifndef M_PI
|
|
#define M_PI 3.14159265358979323846
|
|
#endif
|
|
|
|
using namespace App;
|
|
|
|
|
|
PROPERTY_SOURCE(App::Origin, App::DocumentObject)
|
|
|
|
const char* Origin::AxisRoles[3] = {"X_Axis", "Y_Axis", "Z_Axis"};
|
|
const char* Origin::PlaneRoles[3] = {"XY_Plane", "XZ_Plane", "YZ_Plane"};
|
|
|
|
Origin::Origin(void) : extension(this) {
|
|
ADD_PROPERTY_TYPE ( OriginFeatures, (nullptr), 0, App::Prop_Hidden,
|
|
"Axis and baseplanes controlled by the origin" );
|
|
|
|
setStatus(App::NoAutoExpand,true);
|
|
extension.initExtension(this);
|
|
}
|
|
|
|
|
|
Origin::~Origin(void)
|
|
{ }
|
|
|
|
App::OriginFeature *Origin::getOriginFeature( const char *role) const {
|
|
const auto & features = OriginFeatures.getValues ();
|
|
auto featIt = std::find_if (features.begin(), features.end(),
|
|
[role] (App::DocumentObject *obj) {
|
|
return obj->isDerivedFrom ( App::OriginFeature::getClassTypeId () ) &&
|
|
strcmp (static_cast<App::OriginFeature *>(obj)->Role.getValue(), role) == 0;
|
|
} );
|
|
if (featIt != features.end()) {
|
|
return static_cast<App::OriginFeature *>(*featIt);
|
|
} else {
|
|
|
|
std::stringstream err;
|
|
err << "Origin \"" << getFullName () << "\" doesn't contain feature with role \""
|
|
<< role << '"';
|
|
throw Base::RuntimeError ( err.str().c_str () );
|
|
}
|
|
}
|
|
|
|
App::Line *Origin::getAxis( const char *role ) const {
|
|
App::OriginFeature *feat = getOriginFeature (role);
|
|
if ( feat->isDerivedFrom(App::Line::getClassTypeId () ) ) {
|
|
return static_cast<App::Line *> (feat);
|
|
} else {
|
|
std::stringstream err;
|
|
err << "Origin \"" << getFullName () << "\" contains bad Axis object for role \""
|
|
<< role << '"';
|
|
throw Base::RuntimeError ( err.str().c_str () );
|
|
}
|
|
}
|
|
|
|
App::Plane *Origin::getPlane( const char *role ) const {
|
|
App::OriginFeature *feat = getOriginFeature (role);
|
|
if ( feat->isDerivedFrom(App::Plane::getClassTypeId () ) ) {
|
|
return static_cast<App::Plane *> (feat);
|
|
} else {
|
|
std::stringstream err;
|
|
err << "Origin \"" << getFullName () << "\" contains bad Plane object for role \""
|
|
<< role << '"';
|
|
throw Base::RuntimeError ( err.str().c_str () );
|
|
}
|
|
}
|
|
|
|
bool Origin::hasObject (const DocumentObject *obj) const {
|
|
const auto & features = OriginFeatures.getValues ();
|
|
return std::find (features.begin(), features.end(), obj) != features.end ();
|
|
}
|
|
|
|
short Origin::mustExecute(void) const {
|
|
if (OriginFeatures.isTouched ()) {
|
|
return 1;
|
|
} else {
|
|
return DocumentObject::mustExecute();
|
|
}
|
|
}
|
|
|
|
App::DocumentObjectExecReturn *Origin::execute(void) {
|
|
try { // try to find all base axis and planes in the origin
|
|
for (const char* role: AxisRoles) {
|
|
App::Line *axis = getAxis (role);
|
|
assert(axis);
|
|
(void)axis;
|
|
}
|
|
for (const char* role: PlaneRoles) {
|
|
App::Plane *plane = getPlane (role);
|
|
assert(plane);
|
|
(void)plane;
|
|
}
|
|
} catch (const Base::Exception &ex) {
|
|
setError ();
|
|
return new App::DocumentObjectExecReturn ( ex.what () );
|
|
}
|
|
|
|
return DocumentObject::execute ();
|
|
}
|
|
|
|
void Origin::setupObject () {
|
|
const static struct {
|
|
const Base::Type type;
|
|
const char *role;
|
|
Base::Rotation rot;
|
|
} setupData [] = {
|
|
{App::Line::getClassTypeId(), "X_Axis", Base::Rotation () },
|
|
{App::Line::getClassTypeId(), "Y_Axis", Base::Rotation ( Base::Vector3d (1,1,1), M_PI*2/3 ) },
|
|
{App::Line::getClassTypeId(), "Z_Axis", Base::Rotation ( Base::Vector3d (1,1,1), M_PI*4/3 ) },
|
|
{App::Plane::getClassTypeId (), "XY_Plane", Base::Rotation () },
|
|
{App::Plane::getClassTypeId (), "XZ_Plane", Base::Rotation ( 1.0, 0.0, 0.0, 1.0 ), },
|
|
{App::Plane::getClassTypeId (), "YZ_Plane", Base::Rotation ( Base::Vector3d (1,1,1), M_PI*2/3 ) },
|
|
};
|
|
|
|
App::Document *doc = getDocument ();
|
|
|
|
std::vector<App::DocumentObject *> links;
|
|
for (auto data: setupData) {
|
|
std::string objName = doc->getUniqueObjectName ( data.role );
|
|
App::DocumentObject *featureObj = doc->addObject ( data.type.getName(), objName.c_str () );
|
|
|
|
assert ( featureObj && featureObj->isDerivedFrom ( App::OriginFeature::getClassTypeId () ) );
|
|
|
|
App::OriginFeature *feature = static_cast <App::OriginFeature *> ( featureObj );
|
|
feature->Placement.setValue ( Base::Placement ( Base::Vector3d (), data.rot ) );
|
|
feature->Role.setValue ( data.role );
|
|
|
|
links.push_back (feature);
|
|
}
|
|
|
|
OriginFeatures.setValues (links);
|
|
}
|
|
|
|
void Origin::unsetupObject () {
|
|
const auto &objsLnk = OriginFeatures.getValues ();
|
|
// Copy to set to assert we won't call methode more then one time for each object
|
|
std::set<App::DocumentObject *> objs (objsLnk.begin(), objsLnk.end());
|
|
// Remove all controlled objects
|
|
for (auto obj: objs ) {
|
|
// Check that previous deletes wasn't inderectly removed one of our objects
|
|
const auto &objsLnk = OriginFeatures.getValues ();
|
|
if ( std::find(objsLnk.begin(), objsLnk.end(), obj) != objsLnk.end()) {
|
|
if ( ! obj->isRemoving() ) {
|
|
obj->getDocument()->removeObject (obj->getNameInDocument());
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
|
|
Origin::OriginExtension::OriginExtension(Origin* obj)
|
|
: obj(obj)
|
|
{
|
|
Group.setStatus(Property::Transient, true);
|
|
}
|
|
|
|
void Origin::OriginExtension::initExtension(ExtensionContainer* obj) {
|
|
App::GroupExtension::initExtension(obj);
|
|
}
|
|
|
|
bool Origin::OriginExtension::extensionGetSubObject(DocumentObject *&ret, const char *subname,
|
|
PyObject **pyobj, Base::Matrix4D *mat, bool, int depth) const {
|
|
if (!subname || subname[0] == '\0') {
|
|
return false;
|
|
}
|
|
|
|
// mapping of object name to role name
|
|
std::string name(subname);
|
|
for (int i=0; i<3; i++) {
|
|
if (name.rfind(Origin::AxisRoles[i], 0) == 0) {
|
|
name = Origin::AxisRoles[i];
|
|
break;
|
|
}
|
|
if (name.rfind(Origin::PlaneRoles[i], 0) == 0) {
|
|
name = Origin::PlaneRoles[i];
|
|
break;
|
|
}
|
|
}
|
|
|
|
try {
|
|
ret = obj->getOriginFeature(name.c_str());
|
|
if (!ret)
|
|
return false;
|
|
const char *dot = strchr(subname, '.');
|
|
if (dot)
|
|
subname = dot+1;
|
|
else
|
|
subname = "";
|
|
ret = ret->getSubObject(subname, pyobj, mat, true, depth+1);
|
|
return true;
|
|
}
|
|
catch (const Base::Exception& e) {
|
|
e.ReportException();
|
|
return false;
|
|
}
|
|
}
|