maTranslator.cpp

//-
// ==========================================================================
// Copyright 1995,2006,2008 Autodesk, Inc. All rights reserved.
//
// Use of this software is subject to the terms of the Autodesk
// license agreement provided at the time of installation or download,
// or which otherwise accompanies this software in either electronic
// or hard copy form.
// ==========================================================================
//+


// Example Plugin: maTranslator.cpp
//
// This plugin is an example of a file translator.  Although this is not
// the actual code used by Maya when it creates files in MayaAscii format,
// it nonetheless produces a very close approximation of the of that same
// format.  Close enough that Maya can load the resulting files as if they
// were MayaAscii.
//
// Currently, the plugin does not support the following:
//
//   o  Export Selection.  The plugin will only export entire scenes.
//
//   o  Referencing files into the default namespace, or using a renaming
//      prefix.  It only supports referencing files into a separate
//      namespace.
//
//   o  MEL reference files.
//
//   o  Size hints for multi plugs.
//

#include <maya/MDagPath.h>
#include <maya/MDagPathArray.h>
#include <maya/MFileIO.h>
#include <maya/MFileObject.h>
#include <maya/MFnAttribute.h>
#include <maya/MFnCompoundAttribute.h>
#include <maya/MFnDagNode.h>
#include <maya/MFnDependencyNode.h>
#include <maya/MFnPlugin.h>
#include <maya/MGlobal.h>
#include <maya/MItDag.h>
#include <maya/MItDependencyNodes.h>
#include <maya/MObjectArray.h>
#include <maya/MPlug.h>
#include <maya/MPlugArray.h>
#include <maya/MPxFileTranslator.h>
#include <maya/MString.h>
#include <maya/MStringArray.h>

#include <ctype.h>
#include <maya/MFStream.h>
#include <time.h>

class maTranslator : public MPxFileTranslator
{
public:
        bool            haveReadMethod() const;
        bool            haveWriteMethod() const;
        MString         defaultExtension() const;

        MFileKind       identifyFile(
                                        const MFileObject& file,
                                        const char* buffer,
                                        short size
                                ) const;

        MStatus         reader(
                                        const MFileObject& file,
                                        const MString& options,
                                        FileAccessMode mode
                                );

        MStatus         writer(
                                        const MFileObject& file,
                                        const MString& options,
                                        FileAccessMode mode
                                );

        static void*    creator();
        static void             setPluginName(const MString& name);
        static MString  translatorName();

protected:
        void    getAddAttrCmds(const MObject& node, MStringArray& cmds);
        void    getSetAttrCmds(const MObject& node, MStringArray& cmds);
        void    writeBrokenRefConnections(fstream& f);
        void    writeConnections(fstream& f);
        void    writeCreateNode(fstream& f, const MObject& node);

        void    writeCreateNode(
                                fstream& f, const MDagPath& nodePath, const MDagPath& parentPath
                        );

        void    writeDagNodes(fstream& f);
        void    writeDefaultNodes(fstream& f);
        void    writeFileInfo(fstream& f);
        void    writeFooter(fstream& f, const MString& fileName);
        void    writeHeader(fstream& f, const MString& fileName);
        void    writeInstances(fstream& f);
        void    writeLockNode(fstream& f, const MObject& node);
        void    writeNodeAttrs(fstream& f, const MObject& node, bool isSelected);
        void    writeNodeConnections(fstream& f, const MObject& node);
        void    writeNonDagNodes(fstream& f);

        void    writeParent(
                                fstream& f,
                                const MDagPath& parent,
                                const MDagPath& child,
                                bool addIt
                        );

        void    writePlugSizeHint(fstream& f, const MPlug& plug);
        void    writeReferences(fstream& f);
        void    writeReferenceNodes(fstream& f);
        void    writeRefNodeParenting(fstream& f);
        void    writeRequirements(fstream& f);
        void    writeSelectNode(fstream& f, const MObject& node);
        void    writeUnits(fstream& f);

        static MString  comment(const MString& text);
        static MString  quote(const MString& text);

        static MString  fExtension;
        static MString  fFileVersion;
        static MString  fPluginName;
        static MString  fTranslatorName;

private:
        //
        // These are used to keep track of connections which were made within
        // a referenced file but then broken by main scene file.
        //
        MPlugArray              fBrokenConnSrcs;
        MPlugArray              fBrokenConnDests;

        //
        // This is used to keep track of default nodes.
        //
        MObjectArray    fDefaultNodes;

        //
        // These are used to keep track of those DAG nodes which have multiple
        // instances.  'fInstanceParents' holds the first parent, which is
        // usually set up when the child is created.
        //
        MDagPathArray   fInstanceChildren;
        MDagPathArray   fInstanceParents;

        //
        // This is used to keep track of non-reference nodes with referenced
        // parents and referenced nodes with non-referenced parents, as their
        // parenting requires special handling.
        //
        MDagPathArray   fParentingRequired;

        //
        // These are used to store the IDs of the temporary node flags used by 
        // the translator.
        //
        unsigned int    fAttrFlag;
        unsigned int    fCreateFlag;
        unsigned int    fConnectionFlag;
};

//
// Note that this translator writes out 4.5ff01 version Maya ASCII
// files, regardless of the current Maya version.
//
MString maTranslator::fFileVersion = "4.5ff01";
MString maTranslator::fExtension = "pma";
MString maTranslator::fPluginName = "";
MString maTranslator::fTranslatorName = "Maya ASCII (via plugin)";


inline MString maTranslator::defaultExtension() const
{       return fExtension;              }


inline bool maTranslator::haveReadMethod() const
{       return true;                    }


inline bool maTranslator::haveWriteMethod() const
{       return true;                    }


inline void maTranslator::setPluginName(const MString& name)
{       fPluginName = name;             }


inline MString maTranslator::translatorName()
{       return fTranslatorName; }


void* maTranslator::creator()
{
        return new maTranslator();
}


//
// Maya calls this method to find out if this translator is capable of
// handling the given file.
//
MPxFileTranslator::MFileKind maTranslator::identifyFile(
                const MFileObject& file, const char* buffer, short bufferLen
) const
{
        MString tagStr = comment(fTranslatorName);
        int             tagLen = tagStr.length();

        //
        // If the buffer contains enough info to positively identify the file,
        // then use it.  Otherwise we'll base the identification on the file
        // extension.
        //
        if (bufferLen >= tagLen)
        {
                MString initialContents(buffer, bufferLen);
                MStringArray    initialLines;

                initialContents.split('\n', initialLines);

                if (initialLines.length() > 0)
                {
                        if (((int)initialLines[0].length() >= tagLen)
                        &&      (initialLines[0].substring(0, tagLen-1) == tagStr))
                        {
                                return kIsMyFileType;
                        }
                }
        }
        else
        {
                MString fileName(file.name());
                int             fileNameLen = fileName.length();
                int             startOfExtension = fileName.rindex('.') + 1;

                if ((startOfExtension > 0)
                &&      (startOfExtension < fileNameLen)
                &&      (fileName.substring(startOfExtension, fileNameLen) == fExtension))
                {
                        return kIsMyFileType;
                }
        }

        return kNotMyFileType;
}


//
// Maya calls this method to have the translator write out a file.
//
MStatus maTranslator::writer(
                const MFileObject& file,
                const MString& /* options */,
                MPxFileTranslator::FileAccessMode mode
)
{
        //
        // For simplicity, we only do full saves/exports.
        //
        if ((mode != kSaveAccessMode) && (mode != kExportAccessMode))
                return MS::kNotImplemented;

        //
        // Let's see if we can open the output file.
        //
        fstream output(file.fullName().asChar(), ios::out | ios::trunc);

        if (!output.good()) return MS::kNotFound;

        //
        // Get some node flags to keep track of those nodes for which we
        // have already done various stages of processing.
        //
        MStatus status;

        fCreateFlag = MFnDependencyNode::allocateFlag(fPluginName, &status);

        if (status)
                fAttrFlag = MFnDependencyNode::allocateFlag(fPluginName, &status);

        if (status)
                fConnectionFlag = MFnDependencyNode::allocateFlag(fPluginName, &status);

        if (!status)
        {
                MGlobal::displayError(
                        "Could not allocate three free node flags."
                        "  Try unloading some other plugins."
                );

                return MS::kFailure;
        }

        //
        // Run through all of the nodes in the scene and clear their flags.
        //
        MItDependencyNodes      nodesIter;

        for (; !nodesIter.isDone(); nodesIter.next())
        {
                MObject                         node = nodesIter.item();
                MFnDependencyNode       nodeFn(node);

                nodeFn.setFlag(fCreateFlag, false);
                nodeFn.setFlag(fAttrFlag, false);
                nodeFn.setFlag(fConnectionFlag, false);
        }

        //
        // Write out the various sections of the file.
        //
        writeHeader(output, file.name());
        writeFileInfo(output);
        writeReferences(output);
        writeRequirements(output);
        writeUnits(output);
        writeDagNodes(output);
        writeNonDagNodes(output);
        writeDefaultNodes(output);
        writeReferenceNodes(output);
        writeConnections(output);
        writeFooter(output, file.name());

        output.close();

        MFnDependencyNode::deallocateFlag(fPluginName, fCreateFlag);

        return MS::kSuccess;
}


void maTranslator::writeHeader(fstream& f, const MString& fileName)
{
        //
        // Get the current time into the same format as used by Maya ASCII
        // files.
        //
        time_t          tempTime = time(NULL);
        struct tm*      curTime = localtime(&tempTime);
        char            formattedTime[100];

        strftime(
                formattedTime, sizeof(formattedTime), "%a, %b %e, %Y %r", curTime
        );

        //
        // Write out the header information.
        //
        f << comment(fTranslatorName).asChar() << " "
                << fFileVersion.asChar() << " scene" << endl;
        f << comment("Name: ").asChar() << fileName.asChar() << endl;
        f << comment("Last modified: ").asChar() << formattedTime << endl;
}


//
// Write out the "fileInfo" command for the freeform information associated
// with the scene.
//
void maTranslator::writeFileInfo(fstream& f)
{
        //
        // There's no direct access to the scene's fileInfo from within the API,
        // so we have to call MEL's 'fileInfo' command.
        //
        MStringArray    fileInfo;

        if (MGlobal::executeCommand("fileInfo -q", fileInfo))
        {
                unsigned        numEntries = fileInfo.length();
                unsigned        i;

                for (i = 0; i < numEntries; i += 2)
                {
                        f << "fileInfo " << quote(fileInfo[i]).asChar() << " "
                                        << quote(fileInfo[i+1]).asChar() << ";" << endl;
                }
        }
        else
                MGlobal::displayWarning("Could not get scene's fileInfo.");
}


//
// Write out the "file" commands which specify the reference files used by
// the scene.
//
void maTranslator::writeReferences(fstream& f)
{
        MStringArray    files;

        MFileIO::getReferences(files);

        unsigned        numRefs = files.length();
        unsigned        i;

        for (i = 0; i < numRefs; i++)
        {
                MString refCmd = "file -r";
                MString fileName = files[i];
                MString nsName = "";

                //
                // For simplicity, we assume that namespaces are always used when
                // referencing.
                //
                MString tempCmd = "file -q -ns \"";
                tempCmd += fileName + "\"";

                if (MGlobal::executeCommand(tempCmd, nsName))
                {
                        refCmd += " -ns \"";
                        refCmd += nsName + "\"";
                }
                else
                        MGlobal::displayWarning("Could not get namespace name.");

                //
                // Is this a deferred reference?
                //
                tempCmd = "file -q -dr \"";
                tempCmd += fileName + "\"";

                int     isDeferred;

                if (MGlobal::executeCommand(tempCmd, isDeferred))
                {
                        if (isDeferred) refCmd += " -dr 1";
                }
                else
                        MGlobal::displayWarning("Could not get deferred reference info.");

                //
                // Get the file's reference node, if it has one.
                //
                tempCmd = "file -q -rfn \"";
                tempCmd += fileName + "\"";

                MString refNode;

                if (MGlobal::executeCommand(tempCmd, refNode))
                {
                        if (refNode.length() > 0)
                        {
                                refCmd += " -rfn \"";
                                refCmd += refNode + "\"";
                        }
                }
                else
                        MGlobal::displayInfo("Could not query reference node name.");

                //
                // Write out the reference command.
                //
                f << refCmd.asChar() << " \"" << fileName.asChar() << "\";" << endl;
        }
}


//
// Write out the "requires" lines which specify the plugins needed by the
// scene.
//
void maTranslator::writeRequirements(fstream& f)
{
        //
        // Every scene requires Maya itself.
        //
        f << "requires maya \"" << fFileVersion.asChar() << "\";" << endl;

        //
        // Write out requirements for each plugin.
        //
        MStringArray    pluginsUsed;

        if (MGlobal::executeCommand("pluginInfo -q -pluginsInUse", pluginsUsed))
        {
                unsigned        numPlugins = pluginsUsed.length();
                unsigned        i;

                for (i = 0; i < numPlugins; i += 2)
                {
                        f << "requires " << quote(pluginsUsed[i]).asChar() << " "
                                        << quote(pluginsUsed[i+1]).asChar() << ";" << endl;
                }
        }
        else
        {
                MGlobal::displayWarning(
                        "Could not get list of plugins currently in use."
                );
        }
}


//
// Write out the units of measurement currently being used by the scene.
//
void maTranslator::writeUnits(fstream& f)
{
        MString args = "";
        MString result;

        //
        // Linear units.
        //
        if (MGlobal::executeCommand("currentUnit -q -fullName -linear", result))
                args += " -l " + result;
        else
                MGlobal::displayWarning("Could not get current linear units.");

        //
        // Angular units.
        //
        if (MGlobal::executeCommand("currentUnit -q -fullName -angle", result))
                args += " -a " + result;
        else
                MGlobal::displayWarning("Could not get current linear units.");

        //
        // Time units.
        //
        if (MGlobal::executeCommand("currentUnit -q -fullName -time", result))
                args += " -t " + result;
        else
                MGlobal::displayWarning("Could not get current linear units.");

        if (args != "")
        {
                f << "currentUnit" << args.asChar() << ";" << endl;
        }
}


void maTranslator::writeDagNodes(fstream& f)
{
        fParentingRequired.clear();

        MItDag          dagIter;

        dagIter.traverseUnderWorld(true);

        MDagPath        worldPath;

        dagIter.getPath(worldPath);

        //
        // We step over the world node before starting the loop, because it
        // doesn't get written out.
        //
        for (dagIter.next(); !dagIter.isDone(); dagIter.next())
        {
                MDagPath        path;
                dagIter.getPath(path);

                //
                // If the node has already been written, then all of its descendants
                // must have been written, or at least checked, as well, so prune
                // this branch of the tree from the iteration.
                //
                MFnDagNode      dagNodeFn(path);

                if (dagNodeFn.isFlagSet(fCreateFlag))
                {
                        dagIter.prune();
                        continue;
                }

                //
                // If this is a default node, it will be written out later, so skip
                // it.
                //
                if (dagNodeFn.isDefaultNode()) continue;

                //
                // If this node is not writable, and is not a shared node, then mark
                // it as having been written, and skip it.
                //
                if (!dagNodeFn.canBeWritten() && !dagNodeFn.isShared())
                {
                        dagNodeFn.setFlag(fCreateFlag, true);
                        continue;
                }

                unsigned int    numParents = dagNodeFn.parentCount();

                if (dagNodeFn.isFromReferencedFile())
                {
                        //
                        // We don't issue 'creatNode' commands for nodes from referenced
                        // files, but if the node has any parents which are not from
                        // referenced files, other than the world, then make a note that
                        // we'll need to issue extra 'parent' commands for it later on.
                        //
                        unsigned int i;

                        for (i = 0; i < numParents; i++)
                        {
                                MObject         altParent = dagNodeFn.parent(i);
                                MFnDagNode      altParentFn(altParent);

                                if (!altParentFn.isFromReferencedFile()
                                &&      (altParentFn.object() != worldPath.node()))
                                {
                                        fParentingRequired.append(path);
                                        break;
                                }
                        }
                }
                else
                {
                        //
                        // Find the node's parent.
                        //
                        MDagPath        parentPath = worldPath;

                        if (path.length() > 1)
                        {
                                //
                                // Get the parent's path.
                                //
                                parentPath = path;
                                parentPath.pop();

                                //
                                // If the parent is in the underworld, then find the closest
                                // ancestor which is not.
                                //
                                if (parentPath.pathCount() > 1)
                                {
                                        //
                                        // The first segment of the path contains whatever
                                        // portion of the path exists in the world.  So the closest
                                        // worldly ancestor is simply the one at the end of that
                                        // first path segment.
                                        //
                                        path.getPath(parentPath, 0);
                                }
                        }

                        MFnDagNode      parentNodeFn(parentPath);

                        if (parentNodeFn.isFromReferencedFile())
                        {
                                //
                                // We prefer to parent to a non-referenced node.  So if this
                                // node has any other parents, which are not from referenced
                                // files and have not already been processed, then we'll
                                // skip this instance and wait for an instance through one
                                // of those parents.
                                //
                                unsigned i;

                                for (i = 0; i < numParents; i++)
                                {
                                        if (dagNodeFn.parent(i) != parentNodeFn.object())
                                        {
                                                MObject         altParent = dagNodeFn.parent(i);
                                                MFnDagNode      altParentFn(altParent);

                                                if (!altParentFn.isFromReferencedFile()
                                                &&      !altParentFn.isFlagSet(fCreateFlag))
                                                {
                                                        break;
                                                }
                                        }
                                }

                                if (i < numParents) continue;

                                //
                                // This node only has parents within referenced files, so
                                // create it without a parent and note that we need to issue
                                // 'parent' commands for it later on.
                                //
                                writeCreateNode(f, path, worldPath);

                                fParentingRequired.append(path);
                        }
                        else
                        {
                                writeCreateNode(f, path, parentPath);

                                //
                                // Let's see if this node has any parents from referenced
                                // files, or any parents other than this one which are not
                                // from referenced files.
                                //
                                unsigned        int i;
                                bool            hasRefParents = false;
                                bool            hasOtherNonRefParents = false;

                                for (i = 0; i < numParents; i++)
                                {
                                        if (dagNodeFn.parent(i) != parentNodeFn.object())
                                        {
                                                MObject         altParent = dagNodeFn.parent(i);
                                                MFnDagNode      altParentFn(altParent);

                                                if (altParentFn.isFromReferencedFile())
                                                        hasRefParents = true;
                                                else
                                                        hasOtherNonRefParents = true;

                                                //
                                                // If we've already got positives for both tests,
                                                // then there's no need in continuing.
                                                //
                                                if (hasRefParents && hasOtherNonRefParents) break;
                                        }
                                }

                                //
                                // If this node has parents from referenced files, then
                                // make note that we will have to issue 'parent' commands
                                // later on.
                                //
                                if (hasRefParents) fParentingRequired.append(path);

                                //
                                // If this node has parents other than this one which are
                                // not from referenced files, then make note that the
                                // parenting for the other instances still has to be done.
                                //
                                if (hasOtherNonRefParents)
                                {
                                        fInstanceChildren.append(path);
                                        fInstanceParents.append(parentPath);
                                }
                        }

                        //
                        // Write out the node's 'addAttr', 'setAttr' and 'lockNode'
                        // commands.
                        //
                        writeNodeAttrs(f, path.node(), true);
                        writeLockNode(f, path.node());
                }

                //
                // Mark the node as having been written.
                //
                dagNodeFn.setFlag(fCreateFlag, true);
        }

        //
        // Write out the parenting for instances.
        //
        writeInstances(f);
}


//
// If a DAG node is instanced (i.e. has multiple parents), this method
// will put it under its remaining parents.  It will already have been put
// under its first parent when it was created.
//
void maTranslator::writeInstances(fstream& f)
{
        unsigned int numInstancedNodes = fInstanceChildren.length();
        unsigned int i;

        for (i = 0; i < numInstancedNodes; i++)
        {
                MFnDagNode      nodeFn(fInstanceChildren[i]);

                unsigned int numParents = nodeFn.parentCount();
                unsigned int p;

                for (p = 0; p < numParents; p++)
                {
                        //
                        // We don't want to issue a 'parent' command for the node's
                        // existing parent.
                        //
                        if (nodeFn.parent(i) != fInstanceParents[i].node())
                        {
                                MObject         parent = nodeFn.parent(i);
                                MFnDagNode      parentFn(parent);

                                if (!parentFn.isFromReferencedFile())
                                {
                                        //
                                        // Get the first path to the parent node.
                                        //
                                        MDagPath        parentPath;

                                        MDagPath::getAPathTo(parentFn.object(), parentPath);

                                        writeParent(f, parentPath, fInstanceChildren[i], true);
                                }
                        }
                }
        }

        //
        // We don't need this any more, so free up the space.
        //
        fInstanceChildren.clear();
        fInstanceParents.clear();
}


//
// Write out a 'parent' command to parent one DAG node under another.
//
void maTranslator::writeParent(
                fstream& f, const MDagPath& parent, const MDagPath& child, bool addIt
)
{
        f << "parent -s -nc -r ";
 
        //
        // If this is not the first parent then we have to include the "-a/add"
        // flag.
        //
        if (addIt) f << "-a ";

        //
        // If the parent is the world, then we must include the "-w/world" flag.
        //
        if (parent.length() == 0) f << "-w ";

        f << "\"" << child.partialPathName().asChar() << "\"";

        //
        // If the parent is NOT the world, then give the parent's name.
        //
        if (parent.length() != 0)
                f << " \"" << parent.partialPathName().asChar() << "\"";

        f << ";" << endl;
}


void maTranslator::writeNonDagNodes(fstream& f)
{
        MItDependencyNodes      nodeIter;

        for (; !nodeIter.isDone(); nodeIter.next())
        {
                MObject                         node = nodeIter.item();
                MFnDependencyNode       nodeFn(node);

                //
                // Save default nodes for later processing.
                //
                if (nodeFn.isDefaultNode())
                {
                        fDefaultNodes.append(node);
                }
                else if (!nodeFn.isFromReferencedFile()
                &&      !nodeFn.isFlagSet(fCreateFlag))
                {
                        //
                        // If this node is either writable or shared, then write it out.
                        // Otherwise don't, but still mark it as having been written so
                        // that we don't end up processing it again at some later time.
                        //
                        if (nodeFn.canBeWritten() || nodeFn.isShared())
                        {
                                writeCreateNode(f, node);
                                writeNodeAttrs(f, node, true);
                                writeLockNode(f, node);
                        }

                        nodeFn.setFlag(fCreateFlag, true);
                        nodeFn.setFlag(fAttrFlag, true);
                }
        }
}


void maTranslator::writeDefaultNodes(fstream& f)
{
        //
        // For default nodes we don't write out a createNode statement, but we
        // still write added attributes and changed attribute values.
        //
        unsigned int    numNodes = fDefaultNodes.length();
        unsigned int    i;

        for (i = 0; i < numNodes; i++)
        {
                writeNodeAttrs(f, fDefaultNodes[i], false);

                MFnDependencyNode       nodeFn(fDefaultNodes[i]);

                nodeFn.setFlag(fAttrFlag, true);
        }
}


//
// Write out the 'addAttr' and 'setAttr' commands for a node.
//
void maTranslator::writeNodeAttrs(
                fstream& f, const MObject& node, bool isSelected
)
{
        MFnDependencyNode       nodeFn(node);

        if (nodeFn.canBeWritten())
        {
                MStringArray    addAttrCmds;
                MStringArray    setAttrCmds;

                getAddAttrCmds(node, addAttrCmds);
                getSetAttrCmds(node, setAttrCmds);

                unsigned int    numAddAttrCmds = addAttrCmds.length();
                unsigned int    numSetAttrCmds = setAttrCmds.length();

                if (numAddAttrCmds + numSetAttrCmds > 0)
                {
                        //
                        // If the node is not already selected, then issue a command to
                        // select it.
                        //
                        if (!isSelected) writeSelectNode(f, node);

                        unsigned int i;

                        for (i = 0; i < numAddAttrCmds; i++)
                                f << addAttrCmds[i].asChar() << endl;

                        for (i = 0; i < numSetAttrCmds; i++)
                                f << setAttrCmds[i].asChar() << endl;
                }
        }
}


void maTranslator::writeReferenceNodes(fstream& f)
{
        //
        // We don't write out createNode commands for reference nodes, but
        // we do write out parenting between them and non-reference nodes,
        // as well as attributes added and attribute values changed after the
        // referenced file was loaded
        //
        writeRefNodeParenting(f);

        //
        // Output the commands for DAG nodes first.
        //
        MItDag  dagIter;

        for (dagIter.next(); !dagIter.isDone(); dagIter.next())
        {
                MObject                         node = dagIter.item();
                MFnDependencyNode       nodeFn(node);

                if (nodeFn.isFromReferencedFile()
                &&      !nodeFn.isFlagSet(fAttrFlag))
                {
                        writeNodeAttrs(f, node, false);

                        //
                        // Make note of any connections to this node which have been
                        // broken by the main scene.
                        //
                        MFileIO::getReferenceConnectionsBroken(
                                node, fBrokenConnSrcs, fBrokenConnDests, true, true
                        );

                        nodeFn.setFlag(fAttrFlag, true);
                }
        }

        //
        // Now do the remaining, non-DAG nodes.
        //
        MItDependencyNodes      nodeIter;

        for (; !nodeIter.isDone(); nodeIter.next())
        {
                MObject                         node = nodeIter.item();
                MFnDependencyNode       nodeFn(node);

                if (nodeFn.isFromReferencedFile()
                &&      !nodeFn.isFlagSet(fAttrFlag))
                {
                        writeNodeAttrs(f, node, false);

                        //
                        // Make note of any connections to this node which have been
                        // broken by the main scene.
                        //
                        MFileIO::getReferenceConnectionsBroken(
                                node, fBrokenConnSrcs, fBrokenConnDests, true, true
                        );

                        nodeFn.setFlag(fAttrFlag, true);
                }
        }
}


//
// Write out all of the connections in the scene.
//
void maTranslator::writeConnections(fstream& f)
{
        //
        // If the scene has broken any connections which were made in referenced
        // files, handle those first so that the attributes are free for any new
        // connections which may come along.
        //
        writeBrokenRefConnections(f);

        //
        // We're about to write out the scene's connections in three parts: DAG
        // nodes, non-DAG non-default nodes, then default nodes.
        //
        // It's really not necessary that we group them like this and would in
        // fact be more efficient to do them all in one MItDependencyNodes
        // traversal.  However, this is the order in which the normal MayaAscii
        // translator does them, so this makes it easier to compare the output
        // of this translator to Maya's output.
        //

        //
        // Write out connections for the DAG nodes first.
        //
        MItDag  dagIter;
        dagIter.traverseUnderWorld(true);

        for (dagIter.next(); !dagIter.isDone(); dagIter.next())
        {
                MObject         node = dagIter.item();
                MFnDagNode      dagNodeFn(node);

                if (!dagNodeFn.isFlagSet(fConnectionFlag)
                &&      dagNodeFn.canBeWritten()
                &&      !dagNodeFn.isDefaultNode())
                {
                        writeNodeConnections(f, dagIter.item());
                        dagNodeFn.setFlag(fConnectionFlag, true);
                }
        }

        //
        // Now do the non-DAG, non-default nodes.
        //
        MItDependencyNodes      nodeIter;

        for (; !nodeIter.isDone(); nodeIter.next())
        {
                MFnDependencyNode       nodeFn(nodeIter.item());

                if (!nodeFn.isFlagSet(fConnectionFlag)
                &&      nodeFn.canBeWritten()
                &&      !nodeFn.isDefaultNode())
                {
                        writeNodeConnections(f, nodeIter.item());
                        nodeFn.setFlag(fConnectionFlag, true);
                }
        }

        //
        // And finish up with the default nodes.
        //
        unsigned int    numNodes = fDefaultNodes.length();
        unsigned int    i;

        for (i = 0; i < numNodes; i++)
        {
                MFnDependencyNode       nodeFn(fDefaultNodes[i]);

                if (!nodeFn.isFlagSet(fConnectionFlag)
                &&      nodeFn.canBeWritten()
                &&      nodeFn.isDefaultNode())
                {
                        writeNodeConnections(f, fDefaultNodes[i]);
                        nodeFn.setFlag(fConnectionFlag, true);
                }
        }
}


//
// Write the 'disconnectAttr' statements for those connections which were
// made in referenced files, but broken in the main scene.
//
void maTranslator::writeBrokenRefConnections(fstream& f)
{
        unsigned int    numBrokenConnections = fBrokenConnSrcs.length();
        unsigned int    i;

        for (i = 0; i < numBrokenConnections; i++)
        {
                f << "disconnectAttr \""
                  << fBrokenConnSrcs[i].partialName(true).asChar()
                  << "\" \""
                  << fBrokenConnDests[i].partialName(true).asChar()
                  << "\"";

                //
                // If the destination plug is a multi for which index does not
                // matter, then we must add a "-na/nextAvailable" flag to the
                // command.
                //
                MObject                 attr = fBrokenConnDests[i].attribute();
                MFnAttribute    attrFn(attr);

                if (!attrFn.indexMatters()) f << " -na";

                f << ";" << endl;
        }
}


//
// Write the 'connectAttr' commands for all of a node's incoming
// connections.
//
void maTranslator::writeNodeConnections(fstream& f, const MObject& node)
{
        MFnDependencyNode       nodeFn(node);
        MPlugArray                      plugs;

        nodeFn.getConnections(plugs);

        unsigned int            numBrokenConns = fBrokenConnSrcs.length();
        unsigned int            numPlugs = plugs.length();
        unsigned int            i;

        for (i = 0; i < numPlugs; i++)
        {
                //
                // We only care about connections where we are the destination.
                //
                MPlug           destPlug = plugs[i];
                MPlugArray      srcPlug;

                destPlug.connectedTo(srcPlug, true, false);

                if (srcPlug.length() > 0)
                {
                        MObject                         srcNode = srcPlug[0].node();
                        MFnDependencyNode       srcNodeFn(srcNode);

                        //
                        // Don't write the connection if the source is not writable...
                        //
                        if (!srcNodeFn.canBeWritten()) continue;

                        //
                        // or the connection was made in a referenced file...
                        //
                        if (destPlug.isFromReferencedFile()) continue;

                        //
                        // or the plug is procedural...
                        //
                        if (destPlug.isProcedural()) continue;

                        //
                        // or it is a connection between a default node and a shared
                        // node (because those will get set up automatically).
                        //
                        if (srcNodeFn.isDefaultNode() && nodeFn.isShared()) continue;

                        f << "connectAttr \"";

                        //
                        // Default nodes get a colon at the start of their names.
                        //
                        if (srcNodeFn.isDefaultNode()) f << ":";

                        f << srcPlug[0].partialName(true).asChar()
                          << "\" \"";

                        if (nodeFn.isDefaultNode()) f << ":";

                        f << destPlug.partialName(true).asChar()
                          << "\"";

                        //
                        // If the src plug is also one from which a broken
                        // connection originated, then add the "-rd/referenceDest" flag
                        // to the command.  That will help Maya to better adjust if the
                        // referenced file has changed the next time it is loaded.
                        //
                        if (srcNodeFn.isFromReferencedFile())
                        {
                                unsigned int j;

                                for (j = 0; j < numBrokenConns; j++)
                                {
                                        if (fBrokenConnSrcs[j] == srcPlug[0])
                                        {
                                                f << " -rd \""
                                                  << fBrokenConnDests[j].partialName(true).asChar()
                                                  << "\"";

                                                break;
                                        }
                                }
                        }

                        //
                        // If the plug is locked, then add a "-l/lock" flag to the
                        // command.
                        //
                        if (destPlug.isLocked()) f << " -l on";

                        //
                        // If the destination attribute is a multi for which index
                        // does not matter, then we must add the "-na/nextAvailable"
                        // flag to the command.
                        //
                        MObject                 attr = destPlug.attribute();
                        MFnAttribute    attrFn(attr);

                        if (!attrFn.indexMatters()) f << " -na";

                        f << ";" << endl;
                }
        }
}


//
// Write out a 'createNode' command for a DAG node.
//
void maTranslator::writeCreateNode(
                fstream& f, const MDagPath& nodePath, const MDagPath& parentPath
)
{
        MObject         node(nodePath.node());
        MFnDagNode      nodeFn(node);

        //
        // Write out the 'createNode' command for this node.
        //
        f << "createNode " << nodeFn.typeName().asChar();

        //
        // If the node is shared, then add a "-s/shared" flag to the command.
        //
        if (nodeFn.isShared()) f << " -s";

        f << " -n \"" << nodeFn.name().asChar() << "\"";

        //
        // If this is not a top-level node, then include its first parent in the
        // command.
        //
        if (parentPath.length() > 0)
                f << " -p \"" << parentPath.partialPathName().asChar() << "\"";
   
        f << ";" << endl;
}


//
// Write out a 'createNode' command for a non-DAG node.
//
void maTranslator::writeCreateNode(fstream& f, const MObject& node)
{
        MFnDependencyNode       nodeFn(node);

        //
        // Write out the 'createNode' command for this node.
        //
        f << "createNode " << nodeFn.typeName().asChar();

        //
        // If the node is shared, then add a "-s/shared" flag to the command.
        //
        if (nodeFn.isShared()) f << " -s";

        f << " -n \"" << nodeFn.name().asChar() << "\";" << endl;
}


//
// Write out a "lockNode" command.
//
void maTranslator::writeLockNode(fstream& f, const MObject& node)
{
        MFnDependencyNode       nodeFn(node);

        //
        // By default, nodes are not locked, so we only have to issue a
        // "lockNode" command if the node is locked.
        //
        if (nodeFn.isLocked()) f << "lockNode;" << endl;
}


//
// Write out a "select" command.
//
void maTranslator::writeSelectNode(fstream& f, const MObject& node)
{
        MStatus                         status;
        MFnDependencyNode       nodeFn(node);
        MString                         nodeName;

        //
        // If the node has a unique name, then we can just go ahead and use
        // that.  Otherwise we will have to use part of its DAG path to to
        // distinguish it from the others with the same name.
        //
        if (nodeFn.hasUniqueName())
                nodeName = nodeFn.name();
        else
        {
                //
                // Only DAG nodes are allowed to have duplicate names.
                //
                MFnDagNode      dagNodeFn(node, &status);

                if (!status)
                {
                        MGlobal::displayWarning(
                                MString("Node '") + nodeFn.name()
                                + "' has a non-unique name but claimes to not be a DAG node.\n"
                                + "Using non-unique name."
                        );

                        nodeName = nodeFn.name();
                }
                else
                        nodeName = dagNodeFn.partialPathName();
        }

        //
        // We use the "-ne/noExpand" flag so that if the node is a set, we
        // actually select the set itself, rather than its members.
        //
        f << "select -ne ";

        //
        // Default nodes get a colon slapped onto the start of their names.
        //
        if (nodeFn.isDefaultNode()) f << ":";

        f << nodeName.asChar() << ";\n";
}


//
// Deal with nodes whose parenting is between referenced and non-referenced
// nodes.
//
void maTranslator::writeRefNodeParenting(fstream& f)
{
        unsigned int numNodes = fParentingRequired.length();
        unsigned int i;

        for (i = 0; i < numNodes; i++)
        {
                MFnDagNode      nodeFn(fParentingRequired[i]);

                //
                // Find out if this node has any parents from referenced or
                // non-referenced files.
                //
                bool                    hasRefParents = false;
                bool                    hasNonRefParents = false;
                unsigned int    numParents = nodeFn.parentCount();
                unsigned int    p;

                for (p = 0; p < numParents; p++)
                {
                        MObject         parent = nodeFn.parent(p);
                        MFnDagNode      parentFn(parent);

                        if (parentFn.isFromReferencedFile())
                                hasRefParents = true;
                        else
                                hasNonRefParents = true;

                        if (hasRefParents && hasNonRefParents) break;
                }

                //
                // If this node is from a referenced file and it has parents which
                // are also from a referenced file, then it already has its first
                // parent and all others are added instances.
                //
                // Similarly if the node is not from a referenced file and has
                // parents which are also not from referenced files.
                //
                bool    alreadyHasFirstParent =
                        (nodeFn.isFromReferencedFile() ? hasRefParents : hasNonRefParents);

                //
                // Now run through the parents again and output any parenting
                // which involves a non-referenced node, either as parent or child.
                //
                for (p = 0; p < numParents; p++)
                {
                        MObject         parent = nodeFn.parent(p);
                        MFnDagNode      parentFn(parent);

                        if (parentFn.isFromReferencedFile() != nodeFn.isFromReferencedFile())
                        {
                                //
                                // Get the first path to the parent.
                                //
                                MDagPath        parentPath;
                                MDagPath::getAPathTo(parentFn.object(), parentPath);

                                writeParent(
                                        f, parentPath, fParentingRequired[i], alreadyHasFirstParent
                                );

                                //
                                // If it didn't have its first parent before, it does now.
                                //
                                alreadyHasFirstParent = true;
                        }
                }
        }
}


void maTranslator::writeFooter(fstream& f, const MString& fileName)
{
        f << comment(" End of ").asChar() << fileName.asChar() << endl;
}


void maTranslator::getAddAttrCmds(const MObject& node, MStringArray& cmds)
{
        //
        // Run through the node's attributes.
        //
        MFnDependencyNode       nodeFn(node);
        unsigned int            numAttrs = nodeFn.attributeCount();
        unsigned int            i;

        for (i = 0; i < numAttrs; i++)
        {
                //
                // Use the attribute ordering which Maya uses when doing I/O.
                //
                MObject attr = nodeFn.reorderedAttribute(i);

                //
                // If this attribute has been added since the node was created,
                // then we may want to write out an addAttr statement for it.
                //
                if (nodeFn.isNewAttribute(attr))
                {
                        MFnAttribute    attrFn(attr);

                        //
                        // If the attribute has a parent then ignore it because it will
                        // be processed when we process the parent.
                        //
                        MStatus status;

                        attrFn.parent(&status);

                        if (status == MS::kNotFound)
                        {
                                //
                                // If the attribute is a compound, then we can do its entire
                                // tree at once.
                                //
                                MFnCompoundAttribute    cAttrFn(attr, &status);

                                if (status)
                                {
                                        MStringArray    newCmds;

                                        cAttrFn.getAddAttrCmds(newCmds);

                                        unsigned int    numCommands = newCmds.length();
                                        unsigned int    c;

                                        for (c = 0; c < numCommands; c++)
                                        {
                                                if (newCmds[c] != "")
                                                        cmds.append(newCmds[c]);
                                        }
                                }
                                else
                                {
                                        MString newCmd = attrFn.getAddAttrCmd();

                                        if (newCmd != "") cmds.append(newCmd);
                                }
                        }
                }
        }
}


void maTranslator::getSetAttrCmds(const MObject& node, MStringArray& cmds)
{
        //
        // Get rid of any garbage already in the array.
        //
        cmds.clear();

        //
        // Run through the node's attributes.
        //
        MFnDependencyNode       nodeFn(node);
        unsigned int            numAttrs = nodeFn.attributeCount();
        unsigned int            i;

        for (i = 0; i < numAttrs; i++)
        {
                //
                // Use the attribute ordering which Maya uses when doing I/O.
                //
                MObject                 attr = nodeFn.reorderedAttribute(i);
                MFnAttribute    attrFn(attr);
                MStatus                 status;

                attrFn.parent(&status);

                bool                    isChild = (status != MS::kNotFound);

                //
                // We don't want attributes which are children of other attributes
                // because they will be processed when we process the parent.
                //
                // And we only want storable attributes which accept inputs.
                //
                if (!isChild && attrFn.isStorable() && attrFn.isWritable())
                {
                        //
                        // Get a plug for the attribute.
                        //
                        MPlug   plug(node, attr);

                        //
                        // Get setAttr commands for this attribute, and any of its
                        // children, which have had their values changed by the scene.
                        //
                        MStringArray    newCmds;

                        plug.getSetAttrCmds(newCmds, MPlug::kChanged, false);

                        unsigned int    numCommands = newCmds.length();
                        unsigned int    c;

                        for (c = 0; c < numCommands; c++)
                        {
                                if (newCmds[c] != "")
                                        cmds.append(newCmds[c]);
                        }
                }
        }
}


MStatus maTranslator::reader(
                const MFileObject& /* file */,
                const MString& /* options */,
                MPxFileTranslator::FileAccessMode /* mode */
)
{
        return MS::kNotImplemented;
}


MString maTranslator::comment(const MString& text)
{
        MString result("//");
        result += text;

        return result;
}


//
// Convert a string into a quoted, printable string.
//
MString maTranslator::quote(const MString& str)
{
        const char* cstr = str.asChar();
        int     strLen = str.length();
        int i;

        MString result("\"");

        for (i = 0; i < strLen; i++)
        {
                int c = cstr[i];

                if (isprint(c))
                {
                        //
                        // Because backslash and double-quote have special meaning
                        // within a printable string, we have to turn those into escape
                        // sequences.
                        //
                        switch (c)
                        {
                                case '"':
                                        result += "\\\"";
                                break;

                                case '\\':
                                        result += "\\\\";
                                break;

                                default:
                                        result += MString((const char*)&c, 1);
                                break;
                        }
                }
                else
                {
                        //
                        // Convert non-printable characters into escape sequences.
                        //
                        switch (c)
                        {
                                case '\n':
                                        result += "\\n";
                                break;

                                case '\t':
                                        result += "\\t";
                                break;

                                case '\b':
                                        result += "\\b";
                                break;

                                case '\r':
                                        result += "\\r";
                                break;

                                case '\f':
                                        result += "\\f";
                                break;

                                case '\v':
                                        result += "\\v";
                                break;

                                case '\007':
                                        result += "\\a";
                                break;

                                default:
                                {
                                        //
                                        // Encode it as an octal escape sequence.
                                        //
                                        char buff[5];
                                        sprintf(buff, "\\%.3o", c);
                                        result += MString(buff, 4);
                                }
                        }
                }
        }

        //
        // Add closing quote.
        //
        result += "\"";

        return result;
}


// ****************************************

MStatus initializePlugin(MObject obj)
{
        MFnPlugin plugin(obj, PLUGIN_COMPANY, "1.0", "Any");

        maTranslator::setPluginName(plugin.name());

        plugin.registerFileTranslator(
                maTranslator::translatorName(),
                NULL,
                maTranslator::creator,
                NULL,
                NULL,
                false
        );

        return MS::kSuccess;
}


MStatus uninitializePlugin(MObject obj)
{
        MFnPlugin plugin( obj );

        plugin.deregisterFileTranslator(maTranslator::translatorName());

        return MS::kSuccess;
}