Part::Feature* Transformed::getBaseObject(bool silent) const { Part::Feature *rv = Feature::getBaseObject(/* silent = */ true); if (rv) { return rv; } const char* err = nullptr; const std::vector<App::DocumentObject*> & originals = Originals.getValues(); // NOTE: may be here supposed to be last origin but in order to keep the old behaviour keep here first App::DocumentObject* firstOriginal = originals.empty() ? NULL : originals.front(); if (firstOriginal) { if(firstOriginal->isDerivedFrom(Part::Feature::getClassTypeId())) { rv = static_cast<Part::Feature*>(firstOriginal); } else { err = "Transformation feature Linked object is not a Part object"; } } else { err = "No originals linked to the transformed feature."; } if (!silent && err) { throw Base::Exception(err); } return rv; }
const bool TaskTransformedParameters::originalSelected(const Gui::SelectionChanges& msg) { if (msg.Type == Gui::SelectionChanges::AddSelection && ( (selectionMode == addFeature) || (selectionMode == removeFeature))) { if (strcmp(msg.pDocName, getObject()->getDocument()->getName()) != 0) return false; PartDesign::Transformed* pcTransformed = getObject(); App::DocumentObject* selectedObject = pcTransformed->getDocument()->getObject(msg.pObjectName); if (selectedObject->isDerivedFrom(PartDesign::FeatureAddSub::getClassTypeId())) { // Do the same like in TaskDlgTransformedParameters::accept() but without doCommand std::vector<App::DocumentObject*> originals = pcTransformed->Originals.getValues(); std::vector<App::DocumentObject*>::iterator o = std::find(originals.begin(), originals.end(), selectedObject); if (selectionMode == addFeature) { if (o == originals.end()) originals.push_back(selectedObject); else return false; // duplicate selection } else { if (o != originals.end()) originals.erase(o); else return false; } pcTransformed->Originals.setValues(originals); recomputeFeature(); return true; } } return false; }
void MDIViewPage::updateTemplate(bool forceUpdate) { App::DocumentObject *templObj = m_vpPage->getDrawPage()->Template.getValue(); // TODO: what if template has been deleted? templObj will be NULL. segfault? if (!templObj) { Base::Console().Log("INFO - MDIViewPage::updateTemplate - Page: %s has NO template!!\n",m_vpPage->getDrawPage()->getNameInDocument()); return; } if(m_vpPage->getDrawPage()->Template.isTouched() || templObj->isTouched()) { // Template is touched so update if(forceUpdate || (templObj && templObj->isTouched() && templObj->isDerivedFrom(TechDraw::DrawTemplate::getClassTypeId())) ) { QGITemplate *qItemTemplate = m_view->getTemplate(); if(qItemTemplate) { TechDraw::DrawTemplate *pageTemplate = dynamic_cast<TechDraw::DrawTemplate *>(templObj); qItemTemplate->setTemplate(pageTemplate); qItemTemplate->updateView(); } } } }
void Body::removeFeature(App::DocumentObject* feature) { App::DocumentObject* nextSolidFeature = getNextSolidFeature(feature); App::DocumentObject* prevSolidFeature = getPrevSolidFeature(feature); // This method must be called BEFORE the feature is removed from the Document! if (isSolidFeature(feature)) { // This is a solid feature // If the next feature is solid, reroute its BaseFeature property to the previous solid feature if (nextSolidFeature) { assert ( nextSolidFeature->isDerivedFrom ( PartDesign::Feature::getClassTypeId () ) ); // Note: It's ok to remove the first solid feature, that just mean the next feature become the base one static_cast<PartDesign::Feature*>(nextSolidFeature)->BaseFeature.setValue(prevSolidFeature); } } std::vector<App::DocumentObject*> model = Model.getValues(); std::vector<App::DocumentObject*>::iterator it = std::find(model.begin(), model.end(), feature); // Adjust Tip feature if it is pointing to the deleted object if (Tip.getValue()== feature) { if (prevSolidFeature) { Tip.setValue(prevSolidFeature); } else { Tip.setValue(nextSolidFeature); } } // Erase feature from Model model.erase(it); Model.setValues(model); }
bool ViewProviderDragger::setEdit(int ModNum) { Q_UNUSED(ModNum); App::DocumentObject *genericObject = this->getObject(); if (genericObject->isDerivedFrom(App::GeoFeature::getClassTypeId())) { App::GeoFeature *geoFeature = static_cast<App::GeoFeature *>(genericObject); const Base::Placement &placement = geoFeature->Placement.getValue(); SoTransform *tempTransform = new SoTransform(); tempTransform->ref(); updateTransform(placement, tempTransform); assert(!csysDragger); csysDragger = new SoFCCSysDragger(); csysDragger->draggerSize.setValue(0.05f); csysDragger->translation.setValue(tempTransform->translation.getValue()); csysDragger->rotation.setValue(tempTransform->rotation.getValue()); tempTransform->unref(); pcTransform->translation.connectFrom(&csysDragger->translation); pcTransform->rotation.connectFrom(&csysDragger->rotation); csysDragger->addStartCallback(dragStartCallback, this); csysDragger->addFinishCallback(dragFinishCallback, this); pcRoot->insertChild(csysDragger, 0); TaskCSysDragger *task = new TaskCSysDragger(this, csysDragger); Gui::Control().showDialog(task); } return true; }
void MDIViewPage::onDeleteObject(const App::DocumentObject& obj) { //if this page has a QView for this obj, delete it. if (obj.isDerivedFrom(TechDraw::DrawView::getClassTypeId())) { (void) m_view->removeQViewByName(obj.getNameInDocument()); } }
void ViewProviderBody::slotChangedObjectApp ( const App::DocumentObject& obj, const App::Property& prop ) { if (!obj.isDerivedFrom ( Part::Feature::getClassTypeId () ) || obj.isDerivedFrom ( Part::BodyBase::getClassTypeId () ) ) { // we are intrested only in Part::Features and not in bodies return; } const Part::Feature *feat = static_cast <const Part::Feature *>(&obj); if ( &feat->Shape != &prop && &feat->Placement != &prop) { // react only on changes in shapes and placement return; } PartDesign::Body *body = static_cast<PartDesign::Body*> ( getObject() ); if ( body && body->hasFeature (&obj ) ) { updateOriginDatumSize (); } }
void Body::insertFeature(App::DocumentObject* feature, App::DocumentObject* target, bool after) { if (target) { if (target == BaseFeature.getValue()) { // Handle the insertion relative to the base feature in a special way if (after) { target = nullptr; } else { throw Base::Exception("Body: impossible to insert before the base object"); } } else if (!hasFeature (target)) { // Check if the target feature belongs to the body throw Base::Exception("Body: the feature we should insert relative to is not part of that body"); } } std::vector<App::DocumentObject*> model = Model.getValues(); std::vector<App::DocumentObject*>::iterator insertInto; // Find out the position there to insert the feature if (!target) { if (after) { insertInto = model.begin(); } else { insertInto = model.end(); } } else { std::vector<App::DocumentObject*>::iterator targetIt = std::find (model.begin(), model.end(), target); assert (targetIt != model.end()); if (after) { insertInto = targetIt + 1; } else { insertInto = targetIt; } } // Insert the new feature after the given model.insert (insertInto, feature); Model.setValues (model); // Set the BaseFeature property if (Body::isSolidFeature(feature)) { // Set BaseFeature property to previous feature (this might be the Tip feature) App::DocumentObject* prevSolidFeature = getPrevSolidFeature(feature); // NULL is ok here, it just means we made the current one fiature the base solid static_cast<PartDesign::Feature*>(feature)->BaseFeature.setValue(prevSolidFeature); // Reroute the next solid feature's BaseFeature property to this feature App::DocumentObject* nextSolidFeature = getNextSolidFeature(feature); if (nextSolidFeature) { assert ( nextSolidFeature->isDerivedFrom ( PartDesign::Feature::getClassTypeId () ) ); static_cast<PartDesign::Feature*>(nextSolidFeature)->BaseFeature.setValue(feature); } } }
void CmdPartDesignMoveTip::activated(int iMsg) { Q_UNUSED(iMsg); std::vector<App::DocumentObject*> features = getSelection().getObjectsOfType( Part::Feature::getClassTypeId() ); App::DocumentObject* selFeature; PartDesign::Body* body= nullptr; if ( features.size() == 1 ) { selFeature = features.front(); if ( selFeature->getTypeId().isDerivedFrom ( PartDesign::Body::getClassTypeId() ) ) { body = static_cast<PartDesign::Body *> ( selFeature ); } else { body = PartDesignGui::getBodyFor ( selFeature, /* messageIfNot =*/ false ); } } else { selFeature = nullptr; } if (!selFeature) { QMessageBox::warning (0, QObject::tr( "Selection error" ), QObject::tr( "Select exactly one PartDesign feature or a body." ) ); return; } else if (!body) { QMessageBox::warning (0, QObject::tr( "Selection error" ), QObject::tr( "Couldn't determine a body for the selected feature '%s'.", selFeature->Label.getValue() ) ); return; } else if ( !selFeature->isDerivedFrom(PartDesign::Feature::getClassTypeId () ) && selFeature != body && body->BaseFeature.getValue() != selFeature ) { QMessageBox::warning (0, QObject::tr( "Selection error" ), QObject::tr( "Only a solid feature can be the tip of a body." ) ); return; } App::DocumentObject* oldTip = body->Tip.getValue(); if (oldTip == selFeature) { // it's not generally an error, so print only a console message Base::Console().Message ("%s is already the tip of the body", selFeature->getNameInDocument () ); return; } openCommand("Move tip to selected feature"); if (selFeature == body) { doCommand(Doc,"App.activeDocument().%s.Tip = None", body->getNameInDocument()); } else { doCommand(Doc,"App.activeDocument().%s.Tip = App.activeDocument().%s",body->getNameInDocument(), selFeature->getNameInDocument()); // Adjust visibility to show only the Tip feature doCommand(Gui,"Gui.activeDocument().show(\"%s\")", selFeature->getNameInDocument()); } // TOOD: Hide all datum features after the Tip feature? But the user might have already hidden some and wants to see // others, so we would have to remember their state somehow updateActive(); }
void MDIViewPage::onDeleteObject(const App::DocumentObject& obj) { //if this page has a QView for this obj, delete it. if (obj.isDerivedFrom(TechDraw::DrawView::getClassTypeId())) { (void) m_view->removeQViewByName(obj.getNameInDocument()); } else if (m_objectName == obj.getNameInDocument()) { // if obj is me, hide myself and my tab m_vpPage->hide(); } }
double DrawPage::getPageWidth() const { App::DocumentObject *obj = 0; obj = Template.getValue(); if( obj && obj->isDerivedFrom(TechDraw::DrawTemplate::getClassTypeId()) ) { TechDraw::DrawTemplate *templ = static_cast<TechDraw::DrawTemplate *>(obj); return templ->getWidth(); } throw Base::Exception("Template not set for Page"); }
void OriginGroup::setupObject () { App::Document *doc = getDocument (); std::string objName = std::string ( getNameInDocument()).append ( "Origin" ); App::DocumentObject *originObj = doc->addObject ( "App::Origin", objName.c_str () ); assert ( originObj && originObj->isDerivedFrom ( App::Origin::getClassTypeId () ) ); Origin.setValue (originObj); GeoFeatureGroup::setupObject (); }
void Body::onChanged (const App::Property* prop) { if ( prop == &BaseFeature ) { App::DocumentObject *baseFeature = BaseFeature.getValue(); App::DocumentObject *nextSolid = getNextSolidFeature ( baseFeature ); if ( nextSolid ) { assert ( nextSolid->isDerivedFrom ( PartDesign::Feature::getClassTypeId () ) ); static_cast<PartDesign::Feature*>(nextSolid)->BaseFeature.setValue( baseFeature ); } } Part::BodyBase::onChanged ( prop ); }
void Body::setupObject () { // NOTE: the code shared with App::OriginGroup App::Document *doc = getDocument (); std::string objName = std::string ( getNameInDocument() ).append ( "Origin" ); App::DocumentObject *originObj = doc->addObject ( "App::Origin", objName.c_str () ); assert ( originObj && originObj->isDerivedFrom ( App::Origin::getClassTypeId () ) ); Origin.setValue ( originObj ); Part::BodyBase::setupObject (); }
std::vector<App::DocumentObject*> ViewProviderPage::claimChildren(void) const { std::vector<App::DocumentObject*> temp; // Attach the template if it exists App::DocumentObject *templateFeat = 0; templateFeat = getPageObject()->Template.getValue(); if(templateFeat) { temp.push_back(templateFeat); } // Collect any child views // for Page, valid children are any View except: DrawProjGroupItem // DrawViewDimension // any FeatuerView in a DrawViewClip // DrawHatch const std::vector<App::DocumentObject *> &views = getPageObject()->Views.getValues(); try { for(std::vector<App::DocumentObject *>::const_iterator it = views.begin(); it != views.end(); ++it) { TechDraw::DrawView* featView = dynamic_cast<TechDraw::DrawView*> (*it); App::DocumentObject *docObj = *it; // Don't collect if dimension, projection group item, hatch or member of ClipGroup as these should be grouped elsewhere if(docObj->isDerivedFrom(TechDraw::DrawProjGroupItem::getClassTypeId()) || docObj->isDerivedFrom(TechDraw::DrawViewDimension::getClassTypeId()) || docObj->isDerivedFrom(TechDraw::DrawHatch::getClassTypeId()) || (featView && featView->isInClip()) ) continue; else temp.push_back(*it); } return temp; } catch (...) { std::vector<App::DocumentObject*> tmp; return tmp; } }
const char * DrawPage::getPageOrientation() const { App::DocumentObject *obj; obj = Template.getValue(); if(obj) { if(obj->isDerivedFrom(TechDraw::DrawTemplate::getClassTypeId())) { TechDraw::DrawTemplate *templ = static_cast<TechDraw::DrawTemplate *>(obj); return templ->Orientation.getValueAsString(); } } throw Base::Exception("Template not set for Page"); }
const bool TaskTransformedParameters::originalSelected(const Gui::SelectionChanges& msg) { if (msg.Type == Gui::SelectionChanges::AddSelection && originalSelectionMode) { if (strcmp(msg.pDocName, getObject()->getDocument()->getName()) != 0) return false; PartDesign::Transformed* pcTransformed = getObject(); App::DocumentObject* selectedObject = pcTransformed->getDocument()->getObject(msg.pObjectName); if (selectedObject->isDerivedFrom(PartDesign::Additive::getClassTypeId()) || selectedObject->isDerivedFrom(PartDesign::Subtractive::getClassTypeId())) { // Do the same like in TaskDlgTransformedParameters::accept() but without doCommand std::vector<App::DocumentObject*> originals(1,selectedObject); pcTransformed->Originals.setValues(originals); recomputeFeature(); originalSelectionMode = false; return true; } } return false; }
bool DrawPage::hasValidTemplate() const { App::DocumentObject *obj = 0; obj = Template.getValue(); if(obj && obj->isDerivedFrom(TechDraw::DrawTemplate::getClassTypeId())) { TechDraw::DrawTemplate *templ = static_cast<TechDraw::DrawTemplate *>(obj); if (templ->getWidth() > 0. && templ->getHeight() > 0.) { return true; } } return false; }
void ProfileBased::positionByPrevious(void) { Part::Feature* feat = getBaseObject(/* silent = */ true); if (feat) { this->Placement.setValue(feat->Placement.getValue()); } else { //no base. Use either Sketch support's placement, or sketch's placement itself. Part::Part2DObject *sketch = getVerifiedSketch(); App::DocumentObject* support = sketch->Support.getValue(); if(support && support->isDerivedFrom(App::GeoFeature::getClassTypeId())) { this->Placement.setValue(static_cast<App::GeoFeature*>(support)->Placement.getValue()); } else { this->Placement.setValue( sketch->Placement.getValue() ); } } }
App::Origin *Body::getOrigin () const { App::DocumentObject *originObj = Origin.getValue (); if ( !originObj ) { std::stringstream err; err << "Can't find Origin for \"" << getNameInDocument () << "\""; throw Base::Exception ( err.str().c_str () ); } else if (! originObj->isDerivedFrom ( App::Origin::getClassTypeId() ) ) { std::stringstream err; err << "Bad object \"" << originObj->getNameInDocument () << "\"(" << originObj->getTypeId().getName() << ") linked to the Origin of \"" << getNameInDocument () << "\""; throw Base::Exception ( err.str().c_str () ); } else { return static_cast<App::Origin *> ( originObj ); } }
Part::Feature *ProfileBased::getBaseObject(bool silent) const { // Test the base's class feature. Part::Feature *rv = Feature::getBaseObject(/* silent = */ true); if (rv) { return rv; } // getVerifiedObject() may throw it's own exception if fail Part::Feature* obj = getVerifiedObject(silent); if(!obj) return nullptr; if (!obj->isDerivedFrom(Part::Part2DObject::getClassTypeId())) return obj; //due to former test we know we have a 2d object Part::Part2DObject* sketch = getVerifiedSketch(silent); const char* err = nullptr; App::DocumentObject* spt = sketch->Support.getValue(); if (spt) { if (spt->isDerivedFrom(Part::Feature::getClassTypeId())) { rv = static_cast<Part::Feature*>(spt); } else { err = "No base set, sketch support is not Part::Feature"; } } else { err = "No base set, no sketch support either"; } if (!silent && err) { throw Base::RuntimeError (err); } return rv; }
PyObject* AttachEnginePy::writeParametersToFeature(PyObject* args) { PyObject* obj; if (!PyArg_ParseTuple(args, "O!",&(App::DocumentObjectPy::Type),&obj)) return NULL; // NULL triggers exception try{ App::DocumentObjectPy* dobjpy = static_cast<App::DocumentObjectPy*>(obj); App::DocumentObject* dobj = dobjpy->getDocumentObjectPtr(); if (! dobj->isDerivedFrom(Part::AttachableObject::getClassTypeId())){ throw Py::TypeError("Supplied object isn't Part::AttachableObject"); } Part::AttachableObject* feat = static_cast<Part::AttachableObject*>(dobj); const AttachEngine &attacher = *(this->getAttachEnginePtr()); AttachEngine::verifyReferencesAreSafe(attacher.references); feat->Support.Paste(attacher.references); feat->MapMode.setValue(attacher.mapMode); feat->MapReversed.setValue(attacher.mapReverse); feat->MapPathParameter.setValue(attacher.attachParameter); feat->superPlacement.setValue(attacher.superPlacement); return Py::new_reference_to(Py::None()); } ATTACHERPY_STDCATCH_METH; }
void ViewProviderRobotObject::updateData(const App::Property* prop) { Robot::RobotObject* robObj = static_cast<Robot::RobotObject*>(pcObject); if (prop == &robObj->RobotVrmlFile) { // read also from file const char* filename = robObj->RobotVrmlFile.getValue(); QString fn = QString::fromUtf8(filename); QFile file(fn); SoInput in; pcRobotRoot->removeAllChildren(); if (!fn.isEmpty() && file.open(QFile::ReadOnly)) { QByteArray buffer = file.readAll(); in.setBuffer((void *)buffer.constData(), buffer.length()); SoSeparator * node = SoDB::readAll(&in); if (node) pcRobotRoot->addChild(node); pcRobotRoot->addChild(pcTcpRoot); } // search for the conection points +++++++++++++++++++++++++++++++++++++++++++++++++ Axis1Node = Axis2Node = Axis3Node = Axis4Node = Axis5Node = Axis6Node = 0; SoSearchAction searchAction; SoPath * path; // Axis 1 searchAction.setName("FREECAD_AXIS1"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis1Node = static_cast<SoVRMLTransform *>(node); } // Axis 2 searchAction.setName("FREECAD_AXIS2"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis2Node = static_cast<SoVRMLTransform *>(node); } // Axis 3 searchAction.setName("FREECAD_AXIS3"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis3Node = static_cast<SoVRMLTransform *>(node); } // Axis 4 searchAction.setName("FREECAD_AXIS4"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis4Node = static_cast<SoVRMLTransform *>(node); } // Axis 5 searchAction.setName("FREECAD_AXIS5"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis5Node = static_cast<SoVRMLTransform *>(node); } // Axis 6 searchAction.setName("FREECAD_AXIS6"); searchAction.setInterest(SoSearchAction::FIRST); searchAction.setSearchingAll(FALSE); searchAction.apply(pcRobotRoot); path = searchAction.getPath(); if(path){ SoNode* node = path->getTail(); std::string typeName = (const char*)node->getTypeId().getName(); if (!node || node->getTypeId() != SoVRMLTransform::getClassTypeId()) throw; // should not happen Axis6Node = static_cast<SoVRMLTransform *>(node); } if(Axis1Node) Axis1Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis1.getValue()*(M_PI/180)); if(Axis2Node) Axis2Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis2.getValue()*(M_PI/180)); if(Axis3Node) Axis3Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis3.getValue()*(M_PI/180)); if(Axis4Node) Axis4Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis4.getValue()*(M_PI/180)); if(Axis5Node) Axis5Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis5.getValue()*(M_PI/180)); if(Axis6Node) Axis6Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis6.getValue()*(M_PI/180)); }else if (prop == &robObj->Axis1) { if(Axis1Node){ Axis1Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis1.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Axis2) { if(Axis2Node){ Axis2Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis2.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Axis3) { if(Axis3Node){ Axis3Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis3.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Axis4) { if(Axis4Node){ Axis4Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis4.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Axis5) { if(Axis5Node){ Axis5Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis5.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Axis6) { if(Axis6Node){ Axis6Node->rotation.setValue(SbVec3f(0.0,1.0,0.0),robObj->Axis6.getValue()*(M_PI/180)); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); } }else if (prop == &robObj->Tcp) { Base::Placement loc = robObj->Tcp.getValue(); SbMatrix M; M.setTransform(SbVec3f(loc.getPosition().x,loc.getPosition().y,loc.getPosition().z), SbRotation(loc.getRotation()[0],loc.getRotation()[1],loc.getRotation()[2],loc.getRotation()[3]), SbVec3f(150,150,150) ); if(pcDragger) pcDragger->setMotionMatrix(M); if(toolShape) toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); //pcTcpTransform->translation = SbVec3f(loc.getPosition().x,loc.getPosition().y,loc.getPosition().z); //pcTcpTransform->rotation = SbRotation(loc.getRotation()[0],loc.getRotation()[1],loc.getRotation()[2],loc.getRotation()[3]); }else if (prop == &robObj->ToolShape) { App::DocumentObject* o = robObj->ToolShape.getValue<App::DocumentObject*>(); if(o && (o->isDerivedFrom(Part::Feature::getClassTypeId()) || o->isDerivedFrom(App::VRMLObject::getClassTypeId())) ){ //Part::Feature *p = dynamic_cast<Part::Feature *>(o); toolShape = Gui::Application::Instance->getViewProvider(o); toolShape->setTransformation((robObj->Tcp.getValue() * (robObj->ToolBase.getValue().inverse())).toMatrix()); }else toolShape = 0; } }
PartDesign::Transformed *TaskTransformedParameters::getTopTransformedObject() const { App::DocumentObject *transform = getTopTransformedView()->getObject(); assert (transform->isDerivedFrom(PartDesign::Transformed::getClassTypeId())); return static_cast<PartDesign::Transformed*>(transform); }
void Workbench::setupContextMenu(const char* recipient, Gui::MenuItem* item) const { auto selection = Gui::Selection().getSelection(); // Add move Tip Command if ( selection.size () >= 1 ) { App::DocumentObject *feature = selection.front().pObject; PartDesign::Body *body = PartDesignGui::getBodyFor ( feature, false ); // lote of assertion so feature sould be marked as a tip if ( selection.size () == 1 && feature && ( feature->isDerivedFrom ( PartDesign::Body::getClassTypeId () ) || ( feature->isDerivedFrom ( PartDesign::Feature::getClassTypeId () ) && body ) || ( feature->isDerivedFrom ( Part::Feature::getClassTypeId () ) && body && body->BaseFeature.getValue() == feature ) ) ) { *item << "PartDesign_MoveTip"; } if (strcmp(recipient, "Tree") == 0) { Gui::MDIView *activeView = Gui::Application::Instance->activeView(); if ( selection.size () > 0 && activeView ) { bool docHaveBodies = activeView->getAppDocument()->countObjectsOfType ( PartDesign::Body::getClassTypeId () ) > 0; if ( docHaveBodies ) { bool addMoveFeature = true; bool addMoveFeatureInTree = (body != nullptr); for (auto sel: selection) { // if at least one selected feature cannot be moved to a body // disable the entry if ( addMoveFeature && !PartDesign::Body::isAllowed ( sel.pObject ) ) { addMoveFeature = false; } // if all at lest one selected feature doesn't belongs to the same body // disable the menu entry if ( addMoveFeatureInTree && !body->hasFeature ( sel.pObject ) ) { addMoveFeatureInTree = false; } if ( !addMoveFeatureInTree && !addMoveFeature ) { break; } } if (addMoveFeature) { *item << "PartDesign_MoveFeature"; } if (addMoveFeatureInTree) { *item << "PartDesign_MoveFeatureInTree"; } } } if (Gui::Selection().countObjectsOfType(PartDesign::Transformed::getClassTypeId()) - Gui::Selection().countObjectsOfType(PartDesign::MultiTransform::getClassTypeId()) == 1 ) *item << "PartDesign_MultiTransform"; } } }
void CmdPartDesignBody::activated(int iMsg) { Q_UNUSED(iMsg); if ( !PartDesignGui::assureModernWorkflow( getDocument() ) ) return; App::Part *actPart = PartDesignGui::getActivePart (); App::Part* partOfBaseFeature = nullptr; std::vector<App::DocumentObject*> features = getSelection().getObjectsOfType(Part::Feature::getClassTypeId()); App::DocumentObject* baseFeature = nullptr; bool viewAll = features.empty(); if (!features.empty()) { if (features.size() == 1) { baseFeature = features[0]; if ( baseFeature->isDerivedFrom ( PartDesign::Feature::getClassTypeId() ) && PartDesign::Body::findBodyOf ( baseFeature ) ) { // Prevent creating bodies based on features already belonging to other bodies QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Bad base feature"), QObject::tr("Body can't be based on a PartDesign feature.")); baseFeature = nullptr; } else if (PartDesign::Body::findBodyOf ( baseFeature )){ QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Bad base feature"), QObject::tr("%1 already belongs to a body, can't use it as base feature for another body.") .arg(QString::fromUtf8(baseFeature->Label.getValue()))); baseFeature = nullptr; } else if ( baseFeature->isDerivedFrom ( Part::BodyBase::getClassTypeId() ) ) { // Prevent creating bodies based on bodies QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Bad base feature"), QObject::tr("Body can't be based on another body.")); baseFeature = nullptr; } else { partOfBaseFeature = App::Part::getPartOfObject(baseFeature); if (partOfBaseFeature != 0 && partOfBaseFeature != actPart){ //prevent cross-part mess QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Bad base feature"), QObject::tr("Base feature (%1) belongs to other part.") .arg(QString::fromUtf8(baseFeature->Label.getValue()))); baseFeature = nullptr; }; } } else { QMessageBox::warning(Gui::getMainWindow(), QObject::tr("Bad base feature"), QObject::tr("Body may be based no more than on one feature.")); return; } } openCommand("Add a Body"); std::string bodyName = getUniqueObjectName("Body"); // add the Body feature itself, and make it active doCommand(Doc,"App.activeDocument().addObject('PartDesign::Body','%s')", bodyName.c_str()); if (baseFeature) { if (partOfBaseFeature){ //withdraw base feature from Part, otherwise visibility mandess results doCommand(Doc,"App.activeDocument().%s.removeObject(App.activeDocument().%s)", partOfBaseFeature->getNameInDocument(), baseFeature->getNameInDocument()); } doCommand(Doc,"App.activeDocument().%s.BaseFeature = App.activeDocument().%s", bodyName.c_str(), baseFeature->getNameInDocument()); } addModule(Gui,"PartDesignGui"); // import the Gui module only once a session doCommand(Gui::Command::Gui, "Gui.activeView().setActiveObject('%s', App.activeDocument().%s)", PDBODYKEY, bodyName.c_str()); // Make the "Create sketch" prompt appear in the task panel doCommand(Gui,"Gui.Selection.clearSelection()"); doCommand(Gui,"Gui.Selection.addSelection(App.ActiveDocument.%s)", bodyName.c_str()); if (actPart) { doCommand(Doc,"App.activeDocument().%s.addObject(App.ActiveDocument.%s)", actPart->getNameInDocument(), bodyName.c_str()); } // The method 'SoCamera::viewBoundingBox' is still declared as protected in Coin3d versions // older than 4.0. #if COIN_MAJOR_VERSION >= 4 // if no part feature was there then auto-adjust the camera if (viewAll) { Gui::Document* doc = Gui::Application::Instance->getDocument(getDocument()); Gui::View3DInventor* view = doc ? qobject_cast<Gui::View3DInventor*>(doc->getActiveView()) : nullptr; if (view) { SoCamera* camera = view->getViewer()->getCamera(); SbViewportRegion vpregion = view->getViewer()->getViewportRegion(); float aspectratio = vpregion.getViewportAspectRatio(); float size = Gui::ViewProviderOrigin::defaultSize(); SbBox3f bbox; bbox.setBounds(-size,-size,-size,size,size,size); camera->viewBoundingBox(bbox, aspectratio, 1.0f); } } #endif updateActive(); }
void DlgExtrusion::apply() { if (ui->treeWidget->selectedItems().isEmpty()) { QMessageBox::critical(this, windowTitle(), tr("Select a shape for extrusion, first.")); return; } Gui::WaitCursor wc; App::Document* activeDoc = App::GetApplication().getDocument(this->document.c_str()); if (!activeDoc) { QMessageBox::critical(this, windowTitle(), tr("The document '%1' doesn't exist.").arg(QString::fromUtf8(this->label.c_str()))); return; } activeDoc->openTransaction("Extrude"); Base::Reference<ParameterGrp> hGrp = App::GetApplication().GetUserParameter() .GetGroup("BaseApp")->GetGroup("Preferences")->GetGroup("Mod/Part"); bool addBaseName = hGrp->GetBool("AddBaseObjectName", false); QString shape, type, name, label; QList<QTreeWidgetItem *> items = ui->treeWidget->selectedItems(); for (QList<QTreeWidgetItem *>::iterator it = items.begin(); it != items.end(); ++it) { shape = (*it)->data(0, Qt::UserRole).toString(); type = QString::fromLatin1("Part::Extrusion"); if (addBaseName) { QString baseName = QString::fromLatin1("Extrude_%1").arg(shape); label = QString::fromLatin1("%1_Extrude").arg((*it)->text(0)); name = QString::fromLatin1(activeDoc->getUniqueObjectName((const char*)baseName.toLatin1()).c_str()); } else { name = QString::fromLatin1(activeDoc->getUniqueObjectName("Extrude").c_str()); label = name; } double len = ui->dirLen->value(); double dirX = ui->dirX->value(); double dirY = ui->dirY->value(); double dirZ = ui->dirZ->value(); double angle = ui->taperAngle->value().getValue(); bool makeSolid = ui->makeSolid->isChecked(); // inspect geometry App::DocumentObject* obj = activeDoc->getObject((const char*)shape.toLatin1()); if (!obj || !obj->isDerivedFrom(Part::Feature::getClassTypeId())) continue; Part::Feature* fea = static_cast<Part::Feature*>(obj); const TopoDS_Shape& data = fea->Shape.getValue(); if (data.IsNull()) continue; // check for planes if (ui->checkNormal->isChecked() && data.ShapeType() == TopAbs_FACE) { BRepAdaptor_Surface adapt(TopoDS::Face(data)); if (adapt.GetType() == GeomAbs_Plane) { double u = 0.5*(adapt.FirstUParameter() + adapt.LastUParameter()); double v = 0.5*(adapt.FirstVParameter() + adapt.LastVParameter()); BRepLProp_SLProps prop(adapt,u,v,1,Precision::Confusion()); if (prop.IsNormalDefined()) { gp_Pnt pnt; gp_Vec vec; // handles the orientation state of the shape BRepGProp_Face(TopoDS::Face(data)).Normal(u,v,pnt,vec); dirX = vec.X(); dirY = vec.Y(); dirZ = vec.Z(); } } } QString code = QString::fromLatin1( "FreeCAD.getDocument(\"%1\").addObject(\"%2\",\"%3\")\n" "FreeCAD.getDocument(\"%1\").%3.Base = FreeCAD.getDocument(\"%1\").%4\n" "FreeCAD.getDocument(\"%1\").%3.Dir = (%5,%6,%7)\n" "FreeCAD.getDocument(\"%1\").%3.Solid = (%8)\n" "FreeCAD.getDocument(\"%1\").%3.TaperAngle = (%9)\n" "FreeCADGui.getDocument(\"%1\").%4.Visibility = False\n" "FreeCAD.getDocument(\"%1\").%3.Label = '%10'\n") .arg(QString::fromLatin1(this->document.c_str())) .arg(type).arg(name).arg(shape) .arg(dirX*len) .arg(dirY*len) .arg(dirZ*len) .arg(makeSolid ? QLatin1String("True") : QLatin1String("False")) .arg(angle) .arg(label); Gui::Application::Instance->runPythonCode((const char*)code.toLatin1()); QByteArray to = name.toLatin1(); QByteArray from = shape.toLatin1(); Gui::Command::copyVisual(to, "ShapeColor", from); Gui::Command::copyVisual(to, "LineColor", from); Gui::Command::copyVisual(to, "PointColor", from); } activeDoc->commitTransaction(); try { ui->statusLabel->clear(); activeDoc->recompute(); ui->statusLabel->setText(QString::fromLatin1 ("<span style=\" color:#55aa00;\">%1</span>").arg(tr("Succeeded"))); } catch (const std::exception& e) { ui->statusLabel->setText(QString::fromLatin1 ("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed"))); Base::Console().Error("%s\n", e.what()); } catch (const Base::Exception& e) { ui->statusLabel->setText(QString::fromLatin1 ("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed"))); Base::Console().Error("%s\n", e.what()); } catch (...) { ui->statusLabel->setText(QString::fromLatin1 ("<span style=\" color:#ff0000;\">%1</span>").arg(tr("Failed"))); Base::Console().Error("General error in extrusion\n"); } }
MDIViewPage::MDIViewPage(ViewProviderPage *pageVp, Gui::Document* doc, QWidget* parent) : Gui::MDIView(doc, parent), //m_view(new QGVPage(pageVp)), pageGui(pageVp), m_frameState(true) { m_view = new QGVPage(pageVp,m_scene,this); m_backgroundAction = new QAction(tr("&Background"), this); m_backgroundAction->setEnabled(false); m_backgroundAction->setCheckable(true); m_backgroundAction->setChecked(true); connect(m_backgroundAction, SIGNAL(toggled(bool)), m_view, SLOT(setViewBackground(bool))); m_exportSVGAction = new QAction(tr("&Export SVG"), this); connect(m_exportSVGAction, SIGNAL(triggered()), this, SLOT(saveSVG())); //m_outlineAction is obs? never set to Enabled? m_outlineAction = new QAction(tr("&Outline"), this); m_outlineAction->setEnabled(false); m_outlineAction->setCheckable(true); m_outlineAction->setChecked(false); connect(m_outlineAction, SIGNAL(toggled(bool)), m_view, SLOT(setViewOutline(bool))); //in QGVPage m_nativeAction = new QAction(tr("&Native"), this); m_nativeAction->setCheckable(true); m_nativeAction->setChecked(false); #ifndef QT_NO_OPENGL m_glAction = new QAction(tr("&OpenGL"), this); m_glAction->setCheckable(true); #endif m_imageAction = new QAction(tr("&Image"), this); m_imageAction->setCheckable(true); #ifndef QT_NO_OPENGL m_highQualityAntialiasingAction = new QAction(tr("&High Quality Antialiasing"), this); m_highQualityAntialiasingAction->setEnabled(false); m_highQualityAntialiasingAction->setCheckable(true); m_highQualityAntialiasingAction->setChecked(false); connect(m_highQualityAntialiasingAction, SIGNAL(toggled(bool)), m_view, SLOT(setHighQualityAntialiasing(bool))); #endif isSelectionBlocked = false; QActionGroup *rendererGroup = new QActionGroup(this); rendererGroup->addAction(m_nativeAction); #ifndef QT_NO_OPENGL rendererGroup->addAction(m_glAction); #endif rendererGroup->addAction(m_imageAction); connect(rendererGroup, SIGNAL(triggered(QAction *)), this, SLOT(setRenderer(QAction *))); setWindowTitle(tr("dummy[*]")); //Yuck. prevents "QWidget::setWindowModified: The window title does not contain a '[*]' placeholder" setCentralWidget(m_view); //this makes m_view a Qt child of MDIViewPage m_orientation = QPrinter::Landscape; m_pageSize = QPrinter::A4; // Connect Signals and Slots QObject::connect( m_view->scene(), SIGNAL(selectionChanged()), this , SLOT (selectionChanged()) ); // A fresh page is added and we iterate through its collected children and add these to Canvas View // if docobj is a featureviewcollection (ex orthogroup), add its child views. if there are ever children that have children, // we'll have to make this recursive. -WF const std::vector<App::DocumentObject*> &grp = pageGui->getPageObject()->Views.getValues(); std::vector<App::DocumentObject*> childViews; for (std::vector<App::DocumentObject*>::const_iterator it = grp.begin();it != grp.end(); ++it) { attachView(*it); TechDraw::DrawViewCollection* collect = dynamic_cast<TechDraw::DrawViewCollection *>(*it); if (collect) { childViews = collect->Views.getValues(); for (std::vector<App::DocumentObject*>::iterator itChild = childViews.begin();itChild != childViews.end(); ++itChild) { attachView(*itChild); } } } //when restoring, it is possible for a Dimension to be loaded before the ViewPart it applies to //therefore we need to make sure parentage of the graphics representation is set properly. bit of a kludge. setDimensionGroups(); App::DocumentObject *obj = pageGui->getPageObject()->Template.getValue(); if(obj && obj->isDerivedFrom(TechDraw::DrawTemplate::getClassTypeId())) { TechDraw::DrawTemplate *pageTemplate = dynamic_cast<TechDraw::DrawTemplate *>(obj); attachTemplate(pageTemplate); } }
void ViewProviderDragger::updatePlacementFromDragger(ViewProviderDragger* sudoThis, SoFCCSysDragger* draggerIn) { App::DocumentObject *genericObject = sudoThis->getObject(); if (!genericObject->isDerivedFrom(App::GeoFeature::getClassTypeId())) return; App::GeoFeature *geoFeature = static_cast<App::GeoFeature *>(genericObject); Base::Placement originalPlacement = geoFeature->Placement.getValue(); double pMatrix[16]; originalPlacement.toMatrix().getMatrix(pMatrix); Base::Placement freshPlacement = originalPlacement; //local cache for brevity. double translationIncrement = draggerIn->translationIncrement.getValue(); double rotationIncrement = draggerIn->rotationIncrement.getValue(); int tCountX = draggerIn->translationIncrementCountX.getValue(); int tCountY = draggerIn->translationIncrementCountY.getValue(); int tCountZ = draggerIn->translationIncrementCountZ.getValue(); int rCountX = draggerIn->rotationIncrementCountX.getValue(); int rCountY = draggerIn->rotationIncrementCountY.getValue(); int rCountZ = draggerIn->rotationIncrementCountZ.getValue(); //just as a little sanity check make sure only 1 field has changed. int numberOfFieldChanged = 0; if (tCountX) numberOfFieldChanged++; if (tCountY) numberOfFieldChanged++; if (tCountZ) numberOfFieldChanged++; if (rCountX) numberOfFieldChanged++; if (rCountY) numberOfFieldChanged++; if (rCountZ) numberOfFieldChanged++; if (numberOfFieldChanged == 0) return; assert(numberOfFieldChanged == 1); //helper lamdas. auto getVectorX = [&pMatrix]() {return Base::Vector3d(pMatrix[0], pMatrix[4], pMatrix[8]);}; auto getVectorY = [&pMatrix]() {return Base::Vector3d(pMatrix[1], pMatrix[5], pMatrix[9]);}; auto getVectorZ = [&pMatrix]() {return Base::Vector3d(pMatrix[2], pMatrix[6], pMatrix[10]);}; if (tCountX) { Base::Vector3d movementVector(getVectorX()); movementVector *= (tCountX * translationIncrement); freshPlacement.move(movementVector); geoFeature->Placement.setValue(freshPlacement); } else if (tCountY) { Base::Vector3d movementVector(getVectorY()); movementVector *= (tCountY * translationIncrement); freshPlacement.move(movementVector); geoFeature->Placement.setValue(freshPlacement); } else if (tCountZ) { Base::Vector3d movementVector(getVectorZ()); movementVector *= (tCountZ * translationIncrement); freshPlacement.move(movementVector); geoFeature->Placement.setValue(freshPlacement); } else if (rCountX) { Base::Vector3d rotationVector(getVectorX()); Base::Rotation rotation(rotationVector, rCountX * rotationIncrement); freshPlacement.setRotation(rotation * freshPlacement.getRotation()); geoFeature->Placement.setValue(freshPlacement); } else if (rCountY) { Base::Vector3d rotationVector(getVectorY()); Base::Rotation rotation(rotationVector, rCountY * rotationIncrement); freshPlacement.setRotation(rotation * freshPlacement.getRotation()); geoFeature->Placement.setValue(freshPlacement); } else if (rCountZ) { Base::Vector3d rotationVector(getVectorZ()); Base::Rotation rotation(rotationVector, rCountZ * rotationIncrement); freshPlacement.setRotation(rotation * freshPlacement.getRotation()); geoFeature->Placement.setValue(freshPlacement); } draggerIn->clearIncrementCounts(); }