/*!
Set the Coin event manager for the widget.
*/
void
QuarterWidget::setSoEventManager(SoEventManager * manager)
{
bool carrydata = false;
SoNode * scene = NULL;
SoCamera * camera = NULL;
SbViewportRegion vp;
if (PRIVATE(this)->soeventmanager && (manager != NULL)) {
scene = PRIVATE(this)->soeventmanager->getSceneGraph();
camera = PRIVATE(this)->soeventmanager->getCamera();
vp = PRIVATE(this)->soeventmanager->getViewportRegion();
carrydata = true;
}
// ref before deleting the old scene manager to avoid that the nodes are deleted
if (scene) scene->ref();
if (camera) camera->ref();
if (PRIVATE(this)->initialsoeventmanager) {
delete PRIVATE(this)->soeventmanager;
PRIVATE(this)->initialsoeventmanager = false;
}
PRIVATE(this)->soeventmanager = manager;
if (carrydata) {
PRIVATE(this)->soeventmanager->setSceneGraph(scene);
PRIVATE(this)->soeventmanager->setCamera(camera);
PRIVATE(this)->soeventmanager->setViewportRegion(vp);
}
if (scene) scene->unref();
if (camera) camera->unref();
}
void
SoXtMaterialList::selectionCallback(// private
int materialid)
{
materialid--; // get index
SoXtMaterialDirectory * data = common->getMaterialDirectory();
assert(materialid >= 0 &&
materialid < data->groups[data->current]->numMaterials);
const char * materialdata =
data->groups[data->current]->materials[materialid]->data;
SoInput reader;
if (data->flags & SOXT_BUILTIN_MATERIALS) {
reader.setBuffer((void *) materialdata, strlen(materialdata));
} else {
if (! reader.openFile(materialdata, FALSE)) {
SoDebugError::postWarning("SoXtMaterialList::selectionCallback",
"could not open file: \"%s\"", materialdata);
return;
}
}
SoNode * material = NULL;
if (! SoDB::read(&reader, material)) {
SoDebugError::postWarning("SoXtMaterialList::selectionCallback",
"failed to read material");
return;
}
if (! material) {
SoDebugError::postWarning("SoXtMaterialList::selectionCallback",
"read returned no data");
return;
}
material->ref();
if (! material->isOfType(SoMaterial::getClassTypeId())) {
SoDebugError::postWarning("SoXtMaterialList::selectionCallback",
"not a material node!");
material->unref();
return;
}
common->invokeCallbacks((SoMaterial *) material);
material->unref();
} // selectionCallback()
// Store the \a newval node pointer in this field. If \a newval is not
// \c NULL, will add 1 to the reference count of the node.
void
SoSFNode::setValue(SoNode * newval)
{
// Don't use getValue() to find oldptr, since this might trigger a
// recursive evaluation call if the field is connected.
SoNode * oldptr = this->value;
if (oldptr == newval) return;
if (oldptr) {
#ifdef COIN_INTERNAL_SOSFPATH
SoNode * h = oldptr->getHead();
// The path should be audited by us at all times. So don't use
// SoSFPath to wrap SoTempPath or SoLightPath, for instance.
assert(h==this->head && "Path head changed without notification!");
if (h) {
h->removeAuditor(this, SoNotRec::FIELD);
h->unref();
}
#endif // COIN_INTERNAL_SOSFPATH
oldptr->removeAuditor(this, SoNotRec::FIELD);
oldptr->unref();
}
if (newval) {
newval->addAuditor(this, SoNotRec::FIELD);
newval->ref();
#ifdef COIN_INTERNAL_SOSFPATH
this->head = newval->getHead();
if (this->head) {
this->head->addAuditor(this, SoNotRec::FIELD);
this->head->ref();
}
#endif // COIN_INTERNAL_SOSFPATH
}
this->value = newval;
this->valueChanged();
}
void
SoXipImageOverlayManager::addOverlays()
{
const SoNode** nodes = overlays.getValues(0);
for( int i = 0; i < overlays.getNum(); ++ i )
{
const SoXipShapeList* shapeList = (const SoXipShapeList *) nodes[i];
if( !shapeList->isOfType( SoXipShapeList::getClassTypeId() ) )
{
SoDebugError::post( __FILE__, "Child not supported" );
return ;
}
int sliceIndex;
if( sscanf( shapeList->label.getValue().getString(), "%d", &sliceIndex ) != 1 )
{
SoDebugError::post( __FILE__, "Invalid label found '%s'", shapeList->label.getValue().getString() );
return ;
}
SoXipShapeList* sliceShapeList = mSliceMap[ sliceIndex ];
if( !sliceShapeList )
{
sliceShapeList = new SoXipShapeList;
sliceShapeList->label.setValue( SbString( sliceIndex ) );
mShapeSwitch->addChild( sliceShapeList );
mSliceMap[ sliceIndex ] = sliceShapeList;
}
int numShapes = shapeList->getNumChildren();
for( int i = 0; i < numShapes; ++ i )
{
// Copy to string to force removing of the connections
SoNode* copyNode = shapeList->getChild (i)->copy();
copyNode->ref();
SbString str = XipOverlayUtils::saveNodeToString( copyNode );
copyNode->unref();
// Reload copy node from this string
SoNode* readNode = XipOverlayUtils::loadNodeFromString( str.getString(), str.getLength() );
((SoXipShape *) readNode)->updateGeometries();
sliceShapeList->addChild( readNode );
}
}
}
/*!
Set the node which is top of the scene graph we're managing. The \a
sceneroot node reference count will be increased by 1, and any
previously set scene graph top node will have it's reference count
decreased by 1.
\sa getSceneGraph()
*/
void
SoSceneManager::setSceneGraph(SoNode * const sceneroot)
{
// Don't unref() until after we've set up the new root, in case the
// old root == the new sceneroot. (Just to be that bit more robust.)
SoNode * oldroot = PRIVATE(this)->scene;
PRIVATE(this)->scene = sceneroot;
PRIVATE(this)->rendermanager->setSceneGraph(sceneroot);
PRIVATE(this)->eventmanager->setSceneGraph(sceneroot);
if (PRIVATE(this)->scene) {
PRIVATE(this)->scene->ref();
this->setCamera(PRIVATE(this)->searchForCamera(PRIVATE(this)->scene));
} else {
this->setCamera(NULL);
}
if (oldroot) oldroot->unref();
}
osgDB::ReaderWriter::WriteResult
ReaderWriterIV::writeNode(const osg::Node& node, const std::string& fileName,
const osgDB::ReaderWriter::Options* /*options*/) const
{
// accept extension
std::string ext = osgDB::getLowerCaseFileExtension(fileName);
if (!acceptsExtension(ext)) return WriteResult::FILE_NOT_HANDLED;
bool useVRML1 = !isInventorExtension(osgDB::getFileExtension(fileName));
OSG_NOTICE << "osgDB::ReaderWriterIV::writeNode() Writing file "
<< fileName.data() << std::endl;
// Convert OSG graph to Inventor graph
ConvertToInventor osg2iv;
osg2iv.setVRML1Conversion(useVRML1);
(const_cast<osg::Node*>(&node))->accept(osg2iv);
SoNode *ivRoot = osg2iv.getIvSceneGraph();
if (ivRoot == NULL)
return WriteResult::ERROR_IN_WRITING_FILE;
ivRoot->ref();
// Change prefix according to VRML spec:
// Node names must not begin with a digit, and must not contain spaces or
// control characters, single or double quote characters, backslashes, curly braces,
// the sharp (#) character, the plus (+) character or the period character.
if (useVRML1)
SoBase::setInstancePrefix("_");
// Write Inventor graph to file
SoOutput out;
out.setHeaderString((useVRML1) ? "#VRML V1.0 ascii" : "#Inventor V2.1 ascii");
if (!out.openFile(fileName.c_str()))
return WriteResult::ERROR_IN_WRITING_FILE;
SoWriteAction wa(&out);
wa.apply(ivRoot);
ivRoot->unref();
return WriteResult::FILE_SAVED;
}
void
SoUnknownNode::write(SoWriteAction *action)
//
////////////////////////////////////////////////////////////////////////
{
int i;
SbBool saveNotify = enableNotify(FALSE);
// Remember alternateRep, if set:
SoNode *alternateRep = NULL;
if (hasChildren) {
if (getNumChildren() != 0) {
alternateRep = getChild(0);
alternateRep->ref();
}
// Add hiddenChildren to regular child list temporarily:
removeAllChildren();
for (i = 0; i < hiddenChildren.getLength(); i++) {
addChild(hiddenChildren[i]);
}
// Now write:
SoGroup::write(action);
removeAllChildren();
}
else {
SoNode::write(action);
}
if (alternateRep != NULL) {
addChild(alternateRep);
alternateRep->unref();
}
enableNotify(saveNotify);
}
int
main(int argc, char ** argv)
{
fprintf(stderr, "ivcp v0.1\n");
SoDB::init();
SoNodeKit::init();
SoInteraction::init();
if (argc != 3 ) {
fprintf(stdout, "Usage: %s infile outfile\n", argv[0]);
return 0;
}
SoInput * in = new SoInput;
if (!in->openFile(argv[1])) {
fprintf(stderr, "error: could not open file '%s'\n", argv[1]);
delete in;
SoDB::cleanup();
return -1;
}
SoNode * scene = SoDB::readAll(in);
if (!scene) {
fprintf(stderr, "error: could not read file '%s'\n", argv[1]);
delete in;
SoDB::cleanup();
return -1;
}
FileType inputFileType;
if (in->isFileVRML1())
inputFileType = VRML1;
else if (in->isFileVRML2())
inputFileType = VRML2;
else
inputFileType = INVENTOR;
delete in;
scene->ref();
SoNode * firstChild = static_cast<SoSeparator*>(scene)->getNumChildren()?
static_cast<SoSeparator*>(scene)->getChild(0)
:NULL;
if (firstChild && firstChild->isOfType(SoForeignFileKit::getClassTypeId())) {
SoForeignFileKit * kit = (SoForeignFileKit *) firstChild;
if (kit->canWriteScene() ) {
SoNode * subscene = NULL;
kit->writeScene(subscene);
if (!subscene ) {
return -1;
}
subscene->ref();
scene->unref();
scene = subscene;
}
}
SoOutput * out = new SoOutput;
if (!out->openFile(argv[2])) {
fprintf(stderr, "error: could not open file '%s' for writing\n");
scene->unref();
delete out;
SoDB::cleanup();
return -1;
}
switch (inputFileType) {
case VRML1:
out->setHeaderString("#VRML V1.0 ascii");
break;
case VRML2:
out->setHeaderString("#VRML V2.0 utf8");
}
SoWriteAction wa(out);
wa.apply(scene);
out->closeFile();
delete out;
scene->unref();
// with actions on the stack, cleanup can't be called...
// SoDB::cleanup();
return 0;
}
