bool isVisibleFace(int faceIndex, const SbVec2f& pos, Gui::View3DInventorViewer* viewer)
{
SoSeparator* root = new SoSeparator;
root->ref();
root->addChild(viewer->getSoRenderManager()->getCamera());
root->addChild(vp->getRoot());
SoSearchAction searchAction;
searchAction.setType(PartGui::SoBrepFaceSet::getClassTypeId());
searchAction.setInterest(SoSearchAction::FIRST);
searchAction.apply(root);
SoPath* selectionPath = searchAction.getPath();
SoRayPickAction rp(viewer->getSoRenderManager()->getViewportRegion());
rp.setNormalizedPoint(pos);
rp.apply(selectionPath);
root->unref();
SoPickedPoint* pick = rp.getPickedPoint();
if (pick) {
const SoDetail* detail = pick->getDetail();
if (detail && detail->isOfType(SoFaceDetail::getClassTypeId())) {
int index = static_cast<const SoFaceDetail*>(detail)->getPartIndex();
if (faceIndex != index)
return false;
SbVec3f dir = viewer->getViewDirection();
const SbVec3f& nor = pick->getNormal();
if (dir.dot(nor) > 0)
return false; // bottom side points to user
return true;
}
}
return false;
}
SoNode* ViewProviderDocumentObject::findFrontRootOfType(const SoType& type) const
{
// first get the document this object is part of and get its GUI counterpart
App::Document* pAppDoc = pcObject->getDocument();
Gui::Document* pGuiDoc = Gui::Application::Instance->getDocument(pAppDoc);
SoSearchAction searchAction;
searchAction.setType(type);
searchAction.setInterest(SoSearchAction::FIRST);
// search in all view providers for the node type
std::vector<App::DocumentObject*> obj = pAppDoc->getObjects();
for (std::vector<App::DocumentObject*>::iterator it = obj.begin(); it != obj.end(); ++it) {
const ViewProvider* vp = pGuiDoc->getViewProvider(*it);
// Ignore 'this' view provider. It could also happen that vp is 0, e.g. when
// several objects have been added to the App::Document before notifying the
// Gui::Document
if (!vp || vp == this)
continue;
SoSeparator* front = vp->getFrontRoot();
//if (front && front->getTypeId() == type)
// return front;
if (front) {
searchAction.apply(front);
SoPath* path = searchAction.getPath();
if (path)
return path->getTail();
}
}
return 0;
}
bool Item::ContainsIvNode(SoNode *pNode)
{
SoSearchAction search;
search.setNode(pNode);
search.apply(_ivGeom);
if (search.getPath())
return true;
return false;
}
SoNodeList Renderer::getChildByName(SoSeparator * ivRoot, SbName & childName,
SoType targetType, int maxResultsExpected)
{
assert(ivRoot);
SoNodeList resultList;
SoSearchAction sa;
sa.setSearchingAll(true);
sa.setType(targetType, true);
sa.setInterest( SoSearchAction::ALL);
sa.setName(childName);
sa.setFind(SoSearchAction::NAME);
sa.apply(ivRoot);
SoPathList &pathList = sa.getPaths();
int numPaths = pathList.getLength();
if (numPaths > maxResultsExpected)
{
//DBGA(this->className() << "::getChildByName::Found too many children of node: "
// << ivRoot->getName().getString() << " with name: "
// <<childName.getString() << " " );
//DBGA(this->className() << "::getChildByName:: Expected:" << maxResultsExpected
// << " Found:" << numPaths);
//resultList.append(static_cast<SoNode *>(NULL));
return resultList;
}
for(int i = 0; i < numPaths; ++i)
{
resultList.append(pathList[i]->getTail());
}
return resultList;
}
SoPath* TSceneKit::GetSoPath(SoNode * theNode )
{
TSeparatorKit* sunNode = static_cast< TSeparatorKit* > (getPart( "childList[0]", false ) );
if( !sunNode ) return NULL;
TSeparatorKit* rootNode = static_cast< TSeparatorKit* > ( sunNode->getPart( "childList[0]", false ) );
if( !rootNode ) return NULL;
SoSearchAction* coinSearch = new SoSearchAction();
coinSearch->setNode( theNode );
coinSearch->setInterest( SoSearchAction::FIRST );
coinSearch->apply( rootNode );
SoPath* nodePath = coinSearch->getPath( );
return nodePath;
}
void IvDragger::_GetMatrix(SbMatrix &matrix, SoNode *root, SoNode *node)
{
SoGetMatrixAction getXform(_viewer.lock()->GetViewer()->getViewportRegion());
// get a path from the root to the node
SoSearchAction mySearchAction;
mySearchAction.setNode(node);
mySearchAction.setInterest(SoSearchAction::FIRST);
mySearchAction.apply(root);
// get the transformation matrix
getXform.apply(mySearchAction.getPath());
matrix = getXform.getMatrix();
}
SoCamera *
SoSceneTextureCubeMapP::findCamera(void)
{
SoSearchAction sa;
sa.setType(SoCamera::getClassTypeId());
sa.setInterest(SoSearchAction::FIRST);
sa.apply(PUBLIC(this)->scene.getValue());
SoPath * path = sa.getPath();
if (path == NULL)
return NULL;
else
return (SoCamera *)path->getTail();
}
SbMatrix ManipWidget::localToParentMatrix(SoNode *local)
{
SoNode *localRoot = local ? local : this->root;
SoSearchAction sa;
sa.setNode(localRoot);
sa.setInterest(SoSearchAction::FIRST);
sa.apply(inst->getPostCumulativeRoot());
SoPath *p = sa.getPath();
if (p) {
SoGetMatrixAction gma(viewer->getViewportRegion());
gma.apply(p);
return gma.getMatrix();
} else {
throw "ManipWidget::localToParentMatrix -- no path found?";
}
}
void
removeNodes(SoGroup *root, SoType type)
//
//////////////////////////////////////////////////////////////
{
SoSearchAction act;
act.setInterest(SoSearchAction::ALL);
act.setType(type);
act.apply(root);
SoPathList &paths = act.getPaths();
for (int i = 0; i < paths.getLength(); i++) {
SoNode *kid = paths[i]->getTail();
paths[i]->pop();
SoGroup *parent = (SoGroup *)paths[i]->getTail();
parent->removeChild(kid);
}
}
void
Shape::getTransform(::rl::math::Transform& transform)
{
SoSearchAction searchAction;
searchAction.setNode(this->shape);
searchAction.apply(this->root);
SbViewportRegion viewportRegion;
SoGetMatrixAction getMatrixAction(viewportRegion);
getMatrixAction.apply(searchAction.getPath());
SbMatrix matrix = getMatrixAction.getMatrix();
for (int i = 0; i < 4; ++i)
{
for (int j = 0; j < 4; ++j)
{
transform(i, j) = matrix[j][i];
}
}
}
void AlignmentGroup::setRandomColor()
{
std::vector<Gui::ViewProviderDocumentObject*>::iterator it;
for (it = this->_views.begin(); it != this->_views.end(); ++it) {
float r = /*(float)rand()/(float)RAND_MAX*/0.0f;
float g = (float)rand()/(float)RAND_MAX;
float b = (float)rand()/(float)RAND_MAX;
if ((*it)->isDerivedFrom(Gui::ViewProviderGeometryObject::getClassTypeId())) {
SoSearchAction searchAction;
searchAction.setType(SoMaterial::getClassTypeId());
searchAction.setInterest(SoSearchAction::FIRST);
searchAction.apply((*it)->getRoot());
SoPath* selectionPath = searchAction.getPath();
if (selectionPath) {
SoMaterial* material = static_cast<SoMaterial*>(selectionPath->getTail());
material->diffuseColor.setValue(r, g, b);
}
}
}
}
void LightManip(SoSeparator * root)
{
SoInput in;
in.setBuffer((void *)scenegraph, std::strlen(scenegraph));
SoSeparator * _root = SoDB::readAll( &in );
if ( _root == NULL ) return; // Shouldn't happen.
root->addChild(_root);
root->ref();
const char * pointlightnames[3] = { "RedLight", "GreenLight", "BlueLight" };
SoSearchAction sa;
for (int i = 0; i < 3; i++) {
sa.setName( pointlightnames[i] );
sa.setInterest( SoSearchAction::FIRST );
sa.setSearchingAll( false );
sa.apply( root );
SoPath * path = sa.getPath();
if ( path == NULL) return; // Shouldn't happen.
SoPointLightManip * manip = new SoPointLightManip;
manip->replaceNode( path );
}
}
void
IfWeeder::weedMaterial(SoNode *root, IfWeederMaterialEntry *entry)
{
// If the material affects no shapes at all, get rid of it. This
// can happen when vertex property nodes are used.
if (entry->shapes.getLength() == 0) {
SoSearchAction sa;
sa.setNode(entry->material);
sa.setInterest(SoSearchAction::ALL);
sa.apply(root);
for (int i = 0; i < sa.getPaths().getLength(); i++) {
SoPath *path = sa.getPaths()[i];
SoSeparator *parent = (SoSeparator *) path->getNodeFromTail(1);
int index = path->getIndexFromTail(0);
ASSERT(parent->isOfType(SoSeparator::getClassTypeId()));
ASSERT(parent->getChild(index) == entry->material);
parent->removeChild(index);
}
}
// Remove all material values from the material node that are
// not used by any dependent shapes. Adjust the indices in the
// dependent shapes accordingly.
removeDuplicateMaterials(entry);
// Now remove all material values that are not used by any
// dependent shapes. Again, adjust the indices in the dependent
// shapes.
removeUnusedMaterials(entry);
}
OSUInventorScene::OSUInventorScene(char *filename) {
SoSeparator *root = ReadScene(filename);
int numNodes = 0;
SoCallbackAction ca;
SoSearchAction SA;
SA.setType(SoLight::getClassTypeId(), TRUE);
SA.setInterest(SoSearchAction::ALL);
SA.apply(root);
SoPathList &paths = SA.getPaths();
#ifdef DEBUG
cerr << "There are " << paths.getLength() << " lights " << endl;
#endif
int i;
for (i = 0; i < paths.getLength(); i++) {
Lights.append(paths[i]->getTail()->copy());
}
SA.setType(SoCamera::getClassTypeId(), TRUE);
SA.setInterest(SoSearchAction::FIRST);
SA.apply(root);
if (SA.getPath()) {
Camera = (SoCamera *)SA.getPath()->getTail()->copy();
#ifdef DEBUG
cerr << "Found a camera!\n";
#endif
} else
Camera = NULL;
ca.addPreCallback(SoNode::getClassTypeId(), processNodesCB, (void *)
&Objects);
ca.apply(root);
// Now lets find the lights and camera!
//
#ifdef DEBUG
cerr << "There are " << Objects.getLength() << " shape objects left!\n";
#endif
}
void
SoXipImageOverlayManager::updateSliceMap()
{
// Removes all the previous entries
mSliceMap.clear();
SoSearchAction sa;
sa.setInterest( SoSearchAction::ALL );
sa.setType( SoXipShapeList::getClassTypeId() );
sa.setSearchingAll( TRUE );
sa.apply( mShapeSwitch );
SoPathList paths = sa.getPaths();
for( int i = 0; i < paths.getLength(); ++ i )
{
SbString label = ((SoXipShapeList *) paths[i]->getTail())->label.getValue().getString();
int sliceIndex;
if( sscanf( label.getString(), "%d", &sliceIndex ) != 1 )
{
SoDebugError::post( __FILE__, "Invalid label found '%s'", label.getString() );
continue ;
}
mSliceMap[ sliceIndex ] = (SoXipShapeList *) paths[i]->getTail();
}
}
void
IfReplacer::replaceMaterials(SoNode *sceneRoot, const SoType &typeToReplace)
{
// Find all nodes of the given type
SoSearchAction sa;
sa.setType(typeToReplace);
sa.setInterest(SoSearchAction::ALL);
sa.apply(sceneRoot);
// Replace the tail of each path with a material. To do this, we
// need to apply an SoCallbackAction to the path to gather the
// material components.
for (int i = 0; i < sa.getPaths().getLength(); i++) {
// Cast the path to a full path, just in case
SoFullPath *path = (SoFullPath *) sa.getPaths()[i];
ASSERT(path->getTail()->isOfType(typeToReplace));
// The path better have at least one group above the material
if (path->getLength() < 2 ||
! path->getNodeFromTail(1)->isOfType(SoGroup::getClassTypeId()))
continue;
// Create a material node that represents the material in
// effect at the tail of the path
SoMaterial *newMaterial = createMaterialForPath(path);
newMaterial->ref();
// Replace the tail node with that material
SoGroup *parent = (SoGroup *) path->getNodeFromTail(1);
parent->replaceChild(path->getTail(), newMaterial);
newMaterial->unref();
}
}
SoPickedPoint* ViewProvider::getPointOnRay(const SbVec2s& pos, const View3DInventorViewer* viewer) const
{
//first get the path to this node and calculate the current transformation
SoSearchAction sa;
sa.setNode(pcRoot);
sa.setSearchingAll(true);
sa.apply(viewer->getSoRenderManager()->getSceneGraph());
if (!sa.getPath())
return nullptr;
SoGetMatrixAction gm(viewer->getSoRenderManager()->getViewportRegion());
gm.apply(sa.getPath());
SoTransform* trans = new SoTransform;
trans->setMatrix(gm.getMatrix());
trans->ref();
// build a temporary scenegraph only keeping this viewproviders nodes and the accumulated
// transformation
SoSeparator* root = new SoSeparator;
root->ref();
root->addChild(viewer->getSoRenderManager()->getCamera());
root->addChild(trans);
root->addChild(pcRoot);
//get the picked point
SoRayPickAction rp(viewer->getSoRenderManager()->getViewportRegion());
rp.setPoint(pos);
rp.setRadius(viewer->getPickRadius());
rp.apply(root);
root->unref();
trans->unref();
SoPickedPoint* pick = rp.getPickedPoint();
return (pick ? new SoPickedPoint(*pick) : 0);
}
void ViewProviderVRMLObject::getLocalResources(SoNode* node, std::list<std::string>& resources)
{
// search for SoVRMLInline files
SoSearchAction sa;
sa.setType(SoVRMLInline::getClassTypeId());
sa.setInterest(SoSearchAction::ALL);
sa.setSearchingAll(true);
sa.apply(node);
const SoPathList & pathlist = sa.getPaths();
for (int i = 0; i < pathlist.getLength(); i++ ) {
SoPath * path = pathlist[i];
SoVRMLInline * vrml = static_cast<SoVRMLInline*>(path->getTail());
const SbString& url = vrml->getFullURLName();
if (url.getLength() > 0) {
// add the resource file if not yet listed
if (std::find(resources.begin(), resources.end(), url.getString()) == resources.end()) {
resources.push_back(url.getString());
}
// if the resource file could be loaded check if it references further resources
if (vrml->getChildData()) {
getLocalResources(vrml->getChildData(), resources);
}
}
}
// search for SoVRMLImageTexture, ... files
getResourceFile<SoVRMLImageTexture >(node, resources);
getResourceFile<SoVRMLMovieTexture >(node, resources);
getResourceFile<SoVRMLScript >(node, resources);
getResourceFile<SoVRMLBackground >(node, resources);
getResourceFile<SoVRMLAudioClip >(node, resources);
getResourceFile<SoVRMLAnchor >(node, resources);
}
IvDragger::IvDragger(QtCoinViewerPtr viewer, ItemPtr pItem, float draggerScale)
{
_selectedItem = pItem;
_viewer = viewer;
_scale = draggerScale;
_penv = viewer->GetEnv();
//_ptext = NULL;
// set some default behavioral options
_checkCollision = false;
_prevtransparency = pItem->GetIvTransparency()->value;
pItem->GetIvTransparency()->value = SoGLRenderAction::SCREEN_DOOR;
if( !!pItem &&(pItem->GetIvRoot() != NULL)) {
_GetBounds(pItem->GetIvRoot(), _ab);
// make the item transparent
SoSearchAction search;
search.setType(SoMaterial::getClassTypeId());
search.setInterest(SoSearchAction::ALL);
search.apply(pItem->GetIvRoot());
for(int i = 0; i < search.getPaths().getLength(); ++i) {
SoPath* path = search.getPaths()[i];
SoMaterial* pmtrl = (SoMaterial*)path->getTail();
vtransparency.push_back(pmtrl->transparency[0]);
pmtrl->transparency = 0.25f;
}
_vlinkaxes.resize(pItem->GetNumIvLinks());
for(size_t i = 0; i < _vlinkaxes.size(); ++i) {
_vlinkaxes[i] = _CreateAxes(i == 0 ? 1.0f : 0.25f,0.5f);
pItem->GetIvLink(i)->addChild(_vlinkaxes[i]);
}
}
}
SoPickedPoint* ViewProvider::getPointOnRay(const SbVec3f& pos,const SbVec3f& dir, const View3DInventorViewer* viewer) const
{
// Note: There seems to be a bug with setRay() which causes SoRayPickAction
// to fail to get intersections between the ray and a line
//first get the path to this node and calculate the current setTransformation
SoSearchAction sa;
sa.setNode(pcRoot);
sa.setSearchingAll(true);
sa.apply(viewer->getSoRenderManager()->getSceneGraph());
SoGetMatrixAction gm(viewer->getSoRenderManager()->getViewportRegion());
gm.apply(sa.getPath());
// build a temporary scenegraph only keeping this viewproviders nodes and the accumulated
// transformation
SoTransform* trans = new SoTransform;
trans->ref();
trans->setMatrix(gm.getMatrix());
SoSeparator* root = new SoSeparator;
root->ref();
root->addChild(viewer->getSoRenderManager()->getCamera());
root->addChild(trans);
root->addChild(pcRoot);
//get the picked point
SoRayPickAction rp(viewer->getSoRenderManager()->getViewportRegion());
rp.setRay(pos,dir);
rp.setRadius(viewer->getPickRadius());
rp.apply(root);
root->unref();
trans->unref();
// returns a copy of the point
SoPickedPoint* pick = rp.getPickedPoint();
//return (pick ? pick->copy() : 0); // needs the same instance of CRT under MS Windows
return (pick ? new SoPickedPoint(*pick) : 0);
}
void SIM::Coin3D::Quarter::SoQTQuarterAdaptor::setCameraType(SoType type)
{
if(!getSoRenderManager()->getCamera()->isOfType(SoPerspectiveCamera::getClassTypeId()) &&
!getSoRenderManager()->getCamera()->isOfType(SoOrthographicCamera::getClassTypeId())) {
Base::Console().Warning("Quarter::setCameraType",
"Only SoPerspectiveCamera and SoOrthographicCamera is supported.");
return;
}
SoType perspectivetype = SoPerspectiveCamera::getClassTypeId();
SbBool oldisperspective = getSoRenderManager()->getCamera()->getTypeId().isDerivedFrom(perspectivetype);
SbBool newisperspective = type.isDerivedFrom(perspectivetype);
if((oldisperspective && newisperspective) ||
(!oldisperspective && !newisperspective)) // Same old, same old..
return;
SoCamera* currentcam = getSoRenderManager()->getCamera();
SoCamera* newcamera = (SoCamera*)type.createInstance();
// Transfer and convert values from one camera type to the other.
if(newisperspective) {
convertOrtho2Perspective((SoOrthographicCamera*)currentcam,
(SoPerspectiveCamera*)newcamera);
}
else {
convertPerspective2Ortho((SoPerspectiveCamera*)currentcam,
(SoOrthographicCamera*)newcamera);
}
getSoRenderManager()->setCamera(newcamera);
getSoEventManager()->setCamera(newcamera);
//if the superscene has a camera we need to replace it too
SoSeparator* superscene = (SoSeparator*) getSoRenderManager()->getSceneGraph();
SoSearchAction sa;
sa.setInterest(SoSearchAction::FIRST);
sa.setType(SoCamera::getClassTypeId());
sa.apply(superscene);
if(sa.getPath()) {
SoNode* node = sa.getPath()->getTail();
SoGroup* parent = (SoGroup*) sa.getPath()->getNodeFromTail(1);
if(node && node->isOfType(SoCamera::getClassTypeId())) {
parent->replaceChild(node, newcamera);
}
}
};
SoCamera *
QuarterWidgetP::searchForCamera(SoNode * root)
{
SoSearchAction sa;
sa.setInterest(SoSearchAction::FIRST);
sa.setType(SoCamera::getClassTypeId());
sa.apply(root);
if (sa.getPath()) {
SoNode * node = sa.getPath()->getTail();
if (node && node->isOfType(SoCamera::getClassTypeId())) {
return (SoCamera *) node;
}
}
return NULL;
}
void ViewProviderVRMLObject::getResourceFile(SoNode* node, std::list<std::string>& resources)
{
SoSearchAction sa;
sa.setType(T::getClassTypeId());
sa.setInterest(SoSearchAction::ALL);
sa.setSearchingAll(true);
sa.apply(node);
const SoPathList & pathlist = sa.getPaths();
for (int i = 0; i < pathlist.getLength(); i++ ) {
SoFullPath * path = static_cast<SoFullPath *>(pathlist[i]);
if (path->getTail()->isOfType(T::getClassTypeId())) {
T * tex = static_cast<T*>(path->getTail());
for (int j = 0; j < tex->url.getNum(); j++) {
this->addResource(tex->url[j], resources);
}
}
}
}
void ViewProviderVRMLObject::getResourceFile<SoVRMLBackground>(SoNode* node, std::list<std::string>& resources)
{
SoSearchAction sa;
sa.setType(SoVRMLBackground::getClassTypeId());
sa.setInterest(SoSearchAction::ALL);
sa.setSearchingAll(true);
sa.apply(node);
const SoPathList & pathlist = sa.getPaths();
for (int i = 0; i < pathlist.getLength(); i++ ) {
SoFullPath * path = static_cast<SoFullPath *>(pathlist[i]);
if (path->getTail()->isOfType(SoVRMLBackground::getClassTypeId())) {
SoVRMLBackground * vrml = static_cast<SoVRMLBackground*>(path->getTail());
// backUrl
for (int j = 0; j < vrml->backUrl.getNum(); j++) {
addResource(vrml->backUrl[j], resources);
}
// bottomUrl
for (int j = 0; j < vrml->bottomUrl.getNum(); j++) {
addResource(vrml->bottomUrl[j], resources);
}
// frontUrl
for (int j = 0; j < vrml->frontUrl.getNum(); j++) {
addResource(vrml->frontUrl[j], resources);
}
// leftUrl
for (int j = 0; j < vrml->leftUrl.getNum(); j++) {
addResource(vrml->leftUrl[j], resources);
}
// rightUrl
for (int j = 0; j < vrml->rightUrl.getNum(); j++) {
addResource(vrml->rightUrl[j], resources);
}
// topUrl
for (int j = 0; j < vrml->topUrl.getNum(); j++) {
addResource(vrml->topUrl[j], resources);
}
}
}
}
IvDragger::~IvDragger()
{
ItemPtr selectedItem = GetSelectedItem();
if( !!selectedItem &&(selectedItem->GetIvRoot() != NULL)) {
for(size_t i = 0; i < _vlinkaxes.size(); ++i) {
selectedItem->GetIvLink(i)->removeChild(_vlinkaxes[i]);
}
_vlinkaxes.clear();
// revert transparency
SoSearchAction search;
search.setType(SoMaterial::getClassTypeId());
search.setInterest(SoSearchAction::ALL);
search.apply(selectedItem->GetIvRoot());
for(int i = 0; i < search.getPaths().getLength(); ++i) {
SoPath* path = search.getPaths()[i];
SoMaterial* pmtrl = (SoMaterial*)path->getTail();
if( i < (int)vtransparency.size() )
pmtrl->transparency = vtransparency[i];
}
selectedItem->GetIvTransparency()->value = _prevtransparency;
}
}
bool ViewProviderMirror::setEdit(int ModNum)
{
if (ModNum == ViewProvider::Default) {
// get the properties from the mirror feature
Part::Mirroring* mf = static_cast<Part::Mirroring*>(getObject());
Base::BoundBox3d bbox = mf->Shape.getBoundingBox();
float len = (float)bbox.CalcDiagonalLength();
Base::Vector3d base = mf->Base.getValue();
Base::Vector3d norm = mf->Normal.getValue();
Base::Vector3d cent = bbox.GetCenter();
base = cent.ProjToPlane(base, norm);
// setup the graph for editing the mirror plane
SoTransform* trans = new SoTransform;
SbRotation rot(SbVec3f(0,0,1), SbVec3f(norm.x,norm.y,norm.z));
trans->rotation.setValue(rot);
trans->translation.setValue(base.x,base.y,base.z);
trans->center.setValue(0.0f,0.0f,0.0f);
SoMaterial* color = new SoMaterial();
color->diffuseColor.setValue(0,0,1);
color->transparency.setValue(0.5);
SoCoordinate3* points = new SoCoordinate3();
points->point.setNum(4);
points->point.set1Value(0, -len/2,-len/2,0);
points->point.set1Value(1, len/2,-len/2,0);
points->point.set1Value(2, len/2, len/2,0);
points->point.set1Value(3, -len/2, len/2,0);
SoFaceSet* face = new SoFaceSet();
pcEditNode->addChild(trans);
pcEditNode->addChild(color);
pcEditNode->addChild(points);
pcEditNode->addChild(face);
// Now we replace the SoTransform node by a manipulator
// Note: Even SoCenterballManip inherits from SoTransform
// we cannot use it directly (in above code) because the
// translation and center fields are overridden.
SoSearchAction sa;
sa.setInterest(SoSearchAction::FIRST);
sa.setSearchingAll(FALSE);
sa.setNode(trans);
sa.apply(pcEditNode);
SoPath * path = sa.getPath();
if (path) {
SoCenterballManip * manip = new SoCenterballManip;
manip->replaceNode(path);
SoDragger* dragger = manip->getDragger();
dragger->addStartCallback(dragStartCallback, this);
dragger->addFinishCallback(dragFinishCallback, this);
dragger->addMotionCallback(dragMotionCallback, this);
}
pcRoot->addChild(pcEditNode);
}
else {
ViewProviderPart::setEdit(ModNum);
}
return true;
}
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;
}
}
// doc from parent
void
SoFCUnifiedSelection::handleEvent(SoHandleEventAction * action)
{
// If off then don't handle this event
if (!selectionRole.getValue()) {
inherited::handleEvent(action);
return;
}
static char buf[513];
HighlightModes mymode = (HighlightModes) this->highlightMode.getValue();
const SoEvent * event = action->getEvent();
// If we don't need to pick for locate highlighting,
// then just behave as separator and return.
// NOTE: we still have to pick for ON even though we don't have
// to re-render, because the app needs to be notified as the mouse
// goes over locate highlight nodes.
//if (highlightMode.getValue() == OFF) {
// inherited::handleEvent( action );
// return;
//}
//
// If this is a mouseMotion event, then check for locate highlighting
//
if (event->isOfType(SoLocation2Event::getClassTypeId())) {
// NOTE: If preselection is off then we do not check for a picked point because otherwise this search may slow
// down extremely the system on really big data sets. In this case we just check for a picked point if the data
// set has been selected.
if (mymode == AUTO || mymode == ON) {
// check to see if the mouse is over our geometry...
const SoPickedPoint * pp = this->getPickedPoint(action);
SoFullPath *pPath = (pp != NULL) ? (SoFullPath *) pp->getPath() : NULL;
ViewProvider *vp = 0;
ViewProviderDocumentObject* vpd = 0;
if (pPath && pPath->containsPath(action->getCurPath()))
vp = viewer->getViewProviderByPathFromTail(pPath);
if (vp && vp->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId()))
vpd = static_cast<ViewProviderDocumentObject*>(vp);
SbBool old_state = highlighted;
highlighted = FALSE;
if (vpd && vpd->useNewSelectionModel() && vpd->isSelectable()) {
std::string documentName = vpd->getObject()->getDocument()->getName();
std::string objectName = vpd->getObject()->getNameInDocument();
std::string subElementName = vpd->getElement(pp ? pp->getDetail() : 0);
static char buf[513];
snprintf(buf,512,"Preselected: %s.%s.%s (%f,%f,%f)",documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
getMainWindow()->showMessage(QString::fromAscii(buf),3000);
if (Gui::Selection().setPreselect(documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2])){
SoSearchAction sa;
sa.setNode(vp->getRoot());
sa.apply(vp->getRoot());
if (sa.getPath()) {
highlighted = TRUE;
if (currenthighlight && currenthighlight->getTail() != sa.getPath()->getTail()) {
SoHighlightElementAction action;
action.setHighlighted(FALSE);
action.apply(currenthighlight);
currenthighlight->unref();
currenthighlight = 0;
old_state = !highlighted;
}
currenthighlight = static_cast<SoFullPath*>(sa.getPath()->copy());
currenthighlight->ref();
}
}
}
if (currenthighlight/* && old_state != highlighted*/) {
SoHighlightElementAction action;
action.setHighlighted(highlighted);
action.setColor(this->colorHighlight.getValue());
action.setElement(pp ? pp->getDetail() : 0);
action.apply(currenthighlight);
if (!highlighted) {
currenthighlight->unref();
currenthighlight = 0;
}
this->touch();
}
}
}
// key press events
else if (event->isOfType(SoKeyboardEvent ::getClassTypeId())) {
SoKeyboardEvent * const e = (SoKeyboardEvent *) event;
if (SoKeyboardEvent::isKeyPressEvent(e,SoKeyboardEvent::LEFT_SHIFT) ||
SoKeyboardEvent::isKeyPressEvent(e,SoKeyboardEvent::RIGHT_SHIFT) )
bShift = true;
if (SoKeyboardEvent::isKeyReleaseEvent(e,SoKeyboardEvent::LEFT_SHIFT) ||
SoKeyboardEvent::isKeyReleaseEvent(e,SoKeyboardEvent::RIGHT_SHIFT) )
bShift = false;
if (SoKeyboardEvent::isKeyPressEvent(e,SoKeyboardEvent::LEFT_CONTROL) ||
SoKeyboardEvent::isKeyPressEvent(e,SoKeyboardEvent::RIGHT_CONTROL) )
bCtrl = true;
if (SoKeyboardEvent::isKeyReleaseEvent(e,SoKeyboardEvent::LEFT_CONTROL) ||
SoKeyboardEvent::isKeyReleaseEvent(e,SoKeyboardEvent::RIGHT_CONTROL) )
bCtrl = false;
}
// mouse press events for (de)selection
else if (event->isOfType(SoMouseButtonEvent::getClassTypeId()) &&
selectionMode.getValue() == SoFCUnifiedSelection::ON) {
const SoMouseButtonEvent* e = static_cast<const SoMouseButtonEvent *>(event);
if (SoMouseButtonEvent::isButtonReleaseEvent(e,SoMouseButtonEvent::BUTTON1)) {
// check to see if the mouse is over a geometry...
const SoPickedPoint * pp = this->getPickedPoint(action);
SoFullPath *pPath = (pp != NULL) ? (SoFullPath *) pp->getPath() : NULL;
ViewProvider *vp = 0;
ViewProviderDocumentObject* vpd = 0;
if (pPath && pPath->containsPath(action->getCurPath()))
vp = viewer->getViewProviderByPathFromTail(pPath);
if (vp && vp->isDerivedFrom(ViewProviderDocumentObject::getClassTypeId()))
vpd = static_cast<ViewProviderDocumentObject*>(vp);
if (vpd && vpd->useNewSelectionModel() && vpd->isSelectable()) {
SoSelectionElementAction::Type type = SoSelectionElementAction::None;
std::string documentName = vpd->getObject()->getDocument()->getName();
std::string objectName = vpd->getObject()->getNameInDocument();
std::string subElementName = vpd->getElement(pp ? pp->getDetail() : 0);
if (bCtrl) {
if (Gui::Selection().isSelected(documentName.c_str()
,objectName.c_str()
,subElementName.c_str())) {
Gui::Selection().rmvSelection(documentName.c_str()
,objectName.c_str()
,subElementName.c_str());
type = SoSelectionElementAction::Remove;
}
else {
bool ok = Gui::Selection().addSelection(documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
if (ok)
type = SoSelectionElementAction::Append;
if (mymode == OFF) {
snprintf(buf,512,"Selected: %s.%s.%s (%f,%f,%f)",documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
getMainWindow()->showMessage(QString::fromAscii(buf),3000);
}
}
}
else { // Ctrl
if (!Gui::Selection().isSelected(documentName.c_str()
,objectName.c_str()
,subElementName.c_str())) {
Gui::Selection().clearSelection(documentName.c_str());
bool ok = Gui::Selection().addSelection(documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
if (ok)
type = SoSelectionElementAction::Append;
}
else {
Gui::Selection().clearSelection(documentName.c_str());
bool ok = Gui::Selection().addSelection(documentName.c_str()
,objectName.c_str()
,0
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
if (ok)
type = SoSelectionElementAction::All;
}
if (mymode == OFF) {
snprintf(buf,512,"Selected: %s.%s.%s (%f,%f,%f)",documentName.c_str()
,objectName.c_str()
,subElementName.c_str()
,pp->getPoint()[0]
,pp->getPoint()[1]
,pp->getPoint()[2]);
getMainWindow()->showMessage(QString::fromAscii(buf),3000);
}
}
action->setHandled();
if (currenthighlight) {
SoSelectionElementAction action(type);
action.setColor(this->colorSelection.getValue());
action.setElement(pp ? pp->getDetail() : 0);
action.apply(currenthighlight);
this->touch();
}
} // picked point
} // mouse release
}
inherited::handleEvent(action);
}
static SoSeparator *
setUpGraph(const SbViewportRegion &vpReg,
SoInput *sceneInput,
Options &options)
//
//////////////////////////////////////////////////////////////
{
// Create a root separator to hold everything. Turn
// caching off, since the transformation will blow
// it anyway.
SoSeparator *root = new SoSeparator;
root->ref();
root->renderCaching = SoSeparator::OFF;
// Add a camera to view the scene
SoPerspectiveCamera *camera = new SoPerspectiveCamera;
root->addChild(camera);
// Add a transform node to spin the scene
SoTransform *sceneTransform = new SoTransform;
sceneTransform->setName(SCENE_XFORM_NAME);
root->addChild(sceneTransform);
// Read and add input scene graph
SoSeparator *inputRoot = SoDB::readAll(sceneInput);
if (inputRoot == NULL) {
fprintf(stderr, "Cannot read scene graph\n");
root->unref();
exit(1);
}
root->addChild(inputRoot);
SoPath *path;
SoGroup *parent, *group;
SoSearchAction act;
// expand out all File nodes and replace them with groups
// containing the children
SoFile *fileNode;
act.setType(SoFile::getClassTypeId());
act.setInterest(SoSearchAction::FIRST);
act.apply(inputRoot);
while ((path = act.getPath()) != NULL) {
fileNode = (SoFile *) path->getTail();
path->pop();
parent = (SoGroup *) path->getTail();
group = fileNode->copyChildren();
if (group) {
parent->replaceChild(fileNode, group);
// apply action again and continue
act.apply(inputRoot);
}
}
// expand out all node kits and replace them with groups
// containing the children
SoBaseKit *kitNode;
SoChildList *childList;
act.setType(SoBaseKit::getClassTypeId());
act.setInterest(SoSearchAction::FIRST);
act.apply(inputRoot);
while ((path = act.getPath()) != NULL) {
kitNode = (SoBaseKit *) path->getTail();
path->pop();
parent = (SoGroup *) path->getTail();
group = new SoGroup;
childList = kitNode->getChildren();
for (int i=0; i<childList->getLength(); i++)
group->addChild((*childList)[i]);
parent->replaceChild(kitNode, group);
act.apply(inputRoot);
}
// check to see if there are any lights
// if no lights, add a directional light to the scene
act.setType(SoLight::getClassTypeId());
act.setInterest(SoSearchAction::FIRST);
act.apply(inputRoot);
if (act.getPath() == NULL) { // no lights
SoDirectionalLight *light = new SoDirectionalLight;
root->insertChild(light, 1);
}
else
options.hasLights = TRUE;
// check to see if there are any texures in the scene
act.setType(SoTexture2::getClassTypeId());
act.setInterest(SoSearchAction::FIRST);
act.apply(inputRoot);
if (act.getPath() != NULL)
options.hasTextures = TRUE;
camera->viewAll(root, vpReg);
// print out information about the scene graph
int32_t numTris, numLines, numPoints, numNodes;
countPrimitives( inputRoot, numTris, numLines, numPoints, numNodes );
printf("Number of nodes in scene graph: %d\n", numNodes );
printf("Number of triangles in scene graph: %d\n", numTris );
printf("Number of lines in scene graph: %d\n", numLines );
printf("Number of points in scene graph: %d\n\n", numPoints );
// Make the center of rotation the center of
// the scene
SoGetBoundingBoxAction bba(vpReg);
bba.apply(root);
sceneTransform->center = bba.getBoundingBox().getCenter();
return root;
}
int QilexDoc::doc_insert_kinematic_chain(Rchain *kineengine, SoSeparator *kinechain)
{
int error = 0;
int i;
SbVec3f joinax;
float joinangle;
SbName joints[] = {"joint1", "joint2", "joint3", "joint4","joint5", "joint6",
"joint7", "joint8", "joint9", "joint10","joint11", "joint12",
"joint13", "joint14", "joint15", "joint16","joint17", "joint18",
"joint19", "joint20", "joint21", "joint22","joint23", "joint24", };
SoEngineList compR(kineengine->dof);
SoNodeList Rots(kineengine->dof);
SoSearchAction lookingforjoints;
SoTransform *pjoint = new SoTransform;
// Identifie the rotations and assing the job
i = 0;
while (i < kineengine->dof && error == 0)
{
lookingforjoints.setName(joints[i]);
lookingforjoints.setType(SoTransform::getClassTypeId());
lookingforjoints.setInterest(SoSearchAction::FIRST);
lookingforjoints.apply(kinechain);
// assert(lookingforjoints.getPath() != NULL);
SoNode * pnode = lookingforjoints.getPath()->getTail();;
pjoint = (SoTransform *) pnode;
if(NULL != pjoint)
{
Rots.append((SoTransform *) pjoint);
compR.append(new SoQtComposeRotation);
// cal comprobar si l'articulació es de rotació o translació: arreglar...
((SoTransform *) Rots[i])->rotation.getValue(joinax, joinangle);
((SoQtComposeRotation *) compR[i])->axis.setValue(joinax);
((SoTransform *) Rots[i])->rotation.connectFrom(&((SoQtComposeRotation *) compR[i])->rotation);
}
else
{
error = 5; // not a valid Model3d file
}
i++ ;
}
if (error == 0)
{
SoSeparator *axisworld = new SoSeparator;
axisworld->unrefNoDelete();
SoCoordinateAxis *AxisW = new SoCoordinateAxis();
AxisW->fNDivision = 1;
AxisW->fDivisionLength = 200;
axisworld->addChild(AxisW);
//kinechain->insertChild(AxisW,1);
view->addNoColObject(axisworld);
/* lookingforjoints.setName("tool");
lookingforjoints.setType(SoSeparator::getClassTypeId());
lookingforjoints.setInterest(SoSearchAction::FIRST);
lookingforjoints.apply(kinechain);
if(lookingforjoints.getPath() != NULL)
{
SoNode * pnode = lookingforjoints.getPath()->getTail();;
SoCoordinateAxis *AxisT = new SoCoordinateAxis();
AxisT->fNDivision = 1;
AxisT->fDivisionLength = 200;
SoSeparator *axistool = new SoSeparator;
axistool->ref();
axistool = (SoSeparator *) pnode;
axistool->addChild(AxisT);
view->addNoColObject(axistool);
}
*/
panel_control *panel = new panel_control(0, "Panel", kineengine);
for (int i = 0; i < kineengine->dof; i++)
{
// connect(panel->ldial[i], SIGNAL(valueChange(double)),((SoQtComposeRotation *) compR[i]), SLOT(setValue_angle(double)));
connect(panel->ldial[i], SIGNAL(valueChange(double)),&panel->kinechain->list_plug[i], SLOT(setValue(double)));
connect(&panel->kinechain->list_plug[i], SIGNAL(valueChanged(double)),((SoQtComposeRotation *) compR[i]), SLOT(setValue_angle(double)));
connect(&panel->kinechain->list_plug[i], SIGNAL(valueChanged(double)),panel->ldial[i], SLOT(setValue(double)));
}
view->addRobotCell(kinechain);
panel->show();
panel->update_limits();
//panel->kinechain->setconsole_mode(true); Ja estava comentada
panel->kinechain->setconsole_mode(false);
panel->kinechain->do_ready();
connect(view, SIGNAL(pick_point(Rhmatrix)),panel, SLOT(move_pickpoint(Rhmatrix )));
//panel->kinechain->setconsole_mode(false); Ja estava comentada
}
